<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Harun Dursun on Medium]]></title>
        <description><![CDATA[Stories by Harun Dursun on Medium]]></description>
        <link>https://medium.com/@harundursunf?source=rss-6a34d5a59ece------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*QlGBsNvlLLq8bdoWlg4Y0Q@2x.jpeg</url>
            <title>Stories by Harun Dursun on Medium</title>
            <link>https://medium.com/@harundursunf?source=rss-6a34d5a59ece------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 15:49:17 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@harundursunf/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[ASP.NET Core’da Dependency Injection (DI)]]></title>
            <link>https://medium.com/@harundursunf/asp-net-coreda-dependency-injection-di-c66a2249c0d4?source=rss-6a34d5a59ece------2</link>
            <guid isPermaLink="false">https://medium.com/p/c66a2249c0d4</guid>
            <dc:creator><![CDATA[Harun Dursun]]></dc:creator>
            <pubDate>Tue, 22 Apr 2025 14:58:19 GMT</pubDate>
            <atom:updated>2025-04-22T14:58:19.924Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wj5j1WS80Guty6tO-2VByA.png" /></figure><p>Merhabalar, Bu yazımda sizlere ASP.NET Core projelerinde çok sık duyduğumuz bir konu olan <strong>Dependency Injection (DI)</strong>’ı hem basit hem de mantığını kavrayacak şekilde anlatmaya çalışacağım.</p><p>Konuya sadece teorik olarak değil, sınıfların nasıl çalıştığı, RAM kullanımı nasıl etkileniyor, neden new yerine DI tercih ediyoruz gibi sorularla da yaklaşacağım. Ayrıca projenin temel noktası olan <strong>Program.cs</strong> dosyası üzerinden ilerleyeceğiz.</p><h3>🔧 Program.cs’in Mantığını Anlamak</h3><p>ASP.NET Core Web API projelerinde her şey <strong>Program.cs</strong> dosyasında başlıyor. Bu dosyayı ikiye ayırabilirz:</p><ol><li><strong>Servis Kayıt (Service Registration) Alanı</strong><br> Bu kısımda builder.Services.Add...() gibi kodlarla hangi sınıfı, hangi yapıyla kullanacağımızı belirtiyoruz.</li><li><strong>Middleware Katmanı</strong><br> app.Use...() şeklinde geçen middleware&#39;ler burada sırayla çalışıyor.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yppkuUYNZCrkpJC3tmeWcA.png" /></figure><h3>📦 Class Nedir? Neden new’leriz?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Q4BJU3LCpBvqFYHnmdXrVA.png" /></figure><p>Bir class (sınıf), bir nesnenin şablonudur. İçinde değişkenler (field/properties) ve fonksiyonlar (methodlar) barındırır. Örneğin yukarda gördüğümüz gibi Test sınıfı şöyle:</p><pre>class Test<br>{<br>    public Guid id { get; set; } = Guid.CreateVersion7();<br>    public int Calculate()<br>    {<br>        return 5;<br>    }<br>}</pre><h4>Bunu bu şekilde kullandık:</h4><pre>app.MapGet(&quot;test&quot;, () =&gt;<br>{<br>    List&lt;Test&gt; tests = new();<br>    for (int i = 0; i &lt; 10000000; i++)<br>    {<br>        Test test = new Test(); <br>        tests.Add(new Test());<br>    }<br>   <br>    return Results.Ok();<br>});</pre><p>Bu işlem RAM’de Test türünde yeni bir nesne oluşturur. Ama dikkat! 👇</p><h3>💥 Neden Her Seferinde new Yapmak Sıkıntılıdır?</h3><p>Koda baktığımızda</p><pre>for (int i = 0; i &lt; 10000000; i++)<br>{<br>    Test test = new Test();<br>    tests.Add(new Test());<br>}</pre><p>Bu kod her çalıştığında <strong>10 milyon tane </strong><strong>Test nesnesi</strong> RAM&#39;e yazılıyor. Her biri Guid.CreateVersion7() ile yeni bir ID oluşturuyor. Dolayısıyla RAM <strong>şişiyor</strong> ve uygulaman büyük miktarda bellek tüketiyor.</p><p>Bu, kısa vadede performans sorunlarına, uzun vadede sistem çökmesine yol açabilir.</p><h4>Uygulamayı çalıştırıp metotudu tetiklemeden önce:</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/917/1*E60MpBYyg-QwVinA9SpBHA.png" /></figure><h4>Uygulama çalıştıktan sonra:</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/933/1*5jO1ZHOTwbW56xhvlmrbgg.png" /></figure><blockquote>Bu demek oluyor ki biz her new işlemi yaptığımızda RAM’i şişiriyoruz. İşte bu noktada devreye <strong>Dependency Injection</strong> giriyor.</blockquote><h3>🧠 DI ile Yaşam Süresini Kontrol Etmek</h3><p>Dependency Injection aslında şu soruya cevap arıyor:</p><blockquote><em>“Bu nesne ne kadar yaşasın?”</em></blockquote><p>Yani nesne her çağrıldığında yeniden mi oluşsun, yoksa uygulama süresince tek bir tane mi kullanılsın?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*10TwnJJWZY4R3tur76-A9w.png" /></figure><p>Örneğin şöyle bir senaryo düşünelim:</p><ul><li>Test sınıfında bir Id üretiyoruz (örneğin bir GUID).</li><li>Test2 sınıfında da bu ID’yi kullanmak istiyoruz.</li></ul><p>Ama işler şöyle gidiyor:</p><p>Her new işleminde farklı bir Id üretiliyor. Yani nesne her çağrıda sıfırdan yaratılıyor. Ama ben her iki sınıfta da <strong>aynı ID</strong>&#39;yi kullanmak istiyorum. Bu durumda ilk nesnenin yaşam süresini <strong>uzatmam gerekiyor</strong>. Bunu da DI ile yapıyoruz.</p><h3>🔄 ASP.NET Core’da Yaşam Süreleri</h3><p>Şimdi DI sistemine bir class’ı eklerken 3 farklı yöntemimiz var. Bunlara <strong>lifetime</strong> (yaşam süresi) diyoruz:</p><h3>1. AddTransient</h3><pre>services.AddTransient&lt;ITest, Test&gt;();</pre><ul><li>Her çağrıda <strong>yeni bir nesne</strong> oluşturur.</li><li>RAM’de her biri ayrı yer kaplar.</li><li>new işlemiyle birebir aynı mantık.</li><li><strong>Not:</strong> new ile farkı, DI&#39;nin bağımlılıkları otomatik çözmesidir. Faydası, bağımlılıkların yönetilebilir olmasıdır.</li></ul><blockquote><strong>Kullanım Senaryoları:</strong></blockquote><blockquote>Hafif ve stateless servisler.</blockquote><blockquote>Her kullanımda yeni bir instance gerektiren durumlar (örneğin, bir matematik hesap servisi).</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/743/1*Se3XMs_8OFyi6GIBabj7Xg.png" /></figure><h3>2. AddScoped</h3><pre>services.AddScoped&lt;ITest, Test&gt;();</pre><ul><li>Her <strong>HTTP isteği</strong> için tek bir nesne oluşturur.</li><li>Yani aynı istek içinde ID hep aynı kalır.</li><li>Web API gibi request tabanlı projelerde en çok tercih edilendir.</li></ul><blockquote><strong>Kullanım Senaryoları:</strong></blockquote><blockquote>Entity Framework Core DbContext (default olarak scoped kullanır).</blockquote><blockquote>Request bazında state tutulması gereken durumlar (örneğin, kullanıcı kimliği).</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/711/1*KAZvINPwd5D4gavL20wyiw.png" /></figure><h3>3. AddSingleton</h3><pre>services.AddSingleton&lt;ITest, Test&gt;();</pre><ul><li>Uygulama başlarken bir kere nesne oluşturur.</li><li>Uygulama kapanana kadar <strong>hep aynı nesne</strong> kullanılır.</li><li>RAM’de kalıcıdır, adeta “ölümsüzdür” diyebiliriz 😄(uygulama kapanana kadar tabi)</li></ul><blockquote><strong>Kullanım Senaryoları:</strong></blockquote><blockquote>Paylaşımlı kaynaklar (örneğin, bir cache mekanizması veya konfigürasyon loader).</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/717/1*9uL83PmEgEhuGT4QCqeGTQ.png" /></figure><h3>🎯 Neden DI Kullanmalıyız?</h3><p>Şimdi bir toparlayalım: Dependency Injection bize ne kazandırıyor?</p><ul><li>Her sınıfı new’lemeye gerek kalmaz.</li><li>Belleği daha verimli kullanırız.</li><li>Sınıflarımız birbirine daha <strong>gevşek bağlı</strong> olur (loose coupling).</li><li>Test yazmak kolaylaşır, çünkü sahte nesneleri rahatça enjekte edebiliriz.</li><li>Kodun yönetimi, bakımı ve genişletilmesi daha kolay hale gelir.</li></ul><h3>✍️ Sonuç</h3><p>Eğer projende her sınıfı tek tek new’lemeye çalışıyorsan, performans kaybı yaşarsın, RAM şişer, sınıflar arası geçişler zorlaşır. Ama DI ile sınıflar arasında daha temiz, daha kontrollü bir yapı kurarsın.</p><p>Kısaca şöyle düşünebiliriz:</p><blockquote><em>DI = Kodları daha az </em><em>new’le, daha çok kontrol et! 💡</em></blockquote><blockquote>Okuduğunuz için teşekkürler! Bu yazıda ASP.NET Core’da Dependency Injection’ı (DI) anlamaya ve ne işe yaradığını basit bir şekilde anlatmaya çalıştım. Elimden geldiğince açıklayıcı olmaya gayret ettim. Umarım faydalı olmuştur. Geri bildirimlerinizi çok duymak isterim! 😊</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c66a2249c0d4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Database First ve Code First Yaklaşımları]]></title>
            <link>https://medium.com/@harundursunf/db-first-ve-code-first-yakla%C5%9F%C4%B1mlar%C4%B1-bfc93384d0a0?source=rss-6a34d5a59ece------2</link>
            <guid isPermaLink="false">https://medium.com/p/bfc93384d0a0</guid>
            <dc:creator><![CDATA[Harun Dursun]]></dc:creator>
            <pubDate>Wed, 12 Mar 2025 15:01:13 GMT</pubDate>
            <atom:updated>2025-03-12T16:03:34.291Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kBNcV_XsHdDxLZU92v0INQ.png" /></figure><p>Bir konuyu gerçekten anlamak istiyorsak, o konunun <strong>kilit noktalarını</strong> öğrenmemiz gerekir. Eğer bu <strong>kilit noktaları</strong> göz ardı edersek, konuyu hep eksik öğrenmiş oluruz. Yazılım dünyasında <strong>yaklaşımlar</strong> da bu temel kavramlardan biridir. Özellikle <strong>Entity Framework (EF)</strong> tarafını daha iyi kavrayabilmek için, kullanılan yaklaşımları doğru bir şekilde anlamamız gerekir.</p><blockquote>EF’de iki temel yaklaşım bulunur:<br> 🔹 <strong>Database First (DB First)</strong><br> 🔹 <strong>Code First</strong></blockquote><p>Ancak konuyu anlamaya başlamadan önce şu soruyu soralım:</p><h3>Yaklaşım Nedir?</h3><p>Yaklaşım, bir olay veya olguya <strong>bütünsel bir bakış açısı</strong> getirme yöntemidir. Her iki yaklaşımın da kendine özgü özellikleri olsa da, <strong>temel amaç aynıdır:</strong> <strong>veritabanı ile kod arasındaki ilişkiyi yönetmek</strong>.</p><h3>Hangi Yaklaşımı Seçmeliyim?</h3><blockquote>Bu sorunun cevabı <strong>mevcut bir veritabanımız olup olmadığına</strong> bağlıdır:<br> ✅ <strong>Eğer mevcut bir veritabanımız varsa</strong>, <strong>Database First</strong> tercih edilir.<br> ✅ <strong>Eğer veritabanımız yoksa</strong>, <strong>Code First</strong> yöntemi düşünülebilir.<br> ✅ <strong>Ancak, veritabanımız yok diye sadece Code First seçilecek diye bir kural da yoktur.</strong> Proje gereksinimlerine göre <strong>DB First de tercih edilebilir</strong>.</blockquote><h3>🗄️Database First Yaklaşımı:</h3><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*eyYOs8ovwYLTcSvgTNbTwg.png" /></figure><p>Database First, <strong>önceden oluşturulmuş bir veritabanının</strong> <strong>tersine mühendislik</strong>(Bu kavrama ilerde değineceğim) yöntemiyle analiz edilip, kod tarafına <strong>model olarak</strong> yansıtıldığı bir yaklaşımdır. Yani, <strong>var olan bir veritabanı temel alınarak</strong> <strong>otomatik olarak</strong> kod tarafında entity (varlık) modelleri oluşturulur.</p><h3>✅ Avantajları:</h3><blockquote>✔ <strong>Mevcut Veritabanı ile Uyumlu:</strong> Halihazırda bir veritabanı varsa, hızla projeye entegre edilebilir.<br> ✔ <strong>SQL ile Çalışanlar İçin Kolaylık:</strong> SQL bilen geliştiriciler için daha tanıdık bir yöntemdir.<br> ✔ <strong>Veritabanı Mimarisini Korur:</strong> Tablolar, ilişkiler, indeksler ve diğer veritabanı bileşenleri olduğu gibi korunur.<br> ✔ <strong>Otomatik Modelleme:</strong> Entity Framework, veritabanındaki tabloları baz alarak kod tarafında sınıfları otomatik olarak oluşturur.</blockquote><h3>❌ Dezavantajları:</h3><blockquote>❌ <strong>Esneklik Azalabilir:</strong> Kod tarafında manuel değişiklik yapmak zor olabilir, çünkü değişiklikler veritabanına bağımlıdır.<br> ❌ <strong>Kod ile Veritabanı Arasında Bağımlılık Oluşur:</strong> Her değişiklikte modelin güncellenmesi gerekir.<br> ❌ <strong>Migration (Göç) Yönetimi Daha Karmaşıktır:</strong> Schema değişiklikleri için genellikle manuel işlemler gerekir.</blockquote><h3>Ne Zaman DB First Kullanmalıyız?</h3><blockquote>✅ <strong>Eğer mevcut bir veritabanımız varsa ve bunu projeye entegre etmemiz gerekiyorsa.</strong><br> ✅ <strong>SQL odaklı bir geliştirme süreci yürütülüyorsa.</strong><br> ✅ <strong>Veritabanı mimarisinin kontrolü yazılım ekibinde değilse (örneğin, büyük kurumsal projelerde veritabanı ayrı bir ekip tarafından yönetiliyorsa).</strong></blockquote><h3>💻📦DB First ile Uygulama Geliştirme</h3><p>DB First yaklaşımı, <strong>mevcut bir veritabanı</strong> üzerinden tersine mühendislik yaparak <strong>Entity Framework (EF)</strong> ile <strong>model sınıflarını otomatik</strong> oluşturmamıza olanak tanır. Bu yaklaşım, özellikle var olan bir sistemle çalışıyorsak <strong>hızlı ve verimli</strong> bir çözüm sunar.</p><p>Şimdi <strong>adım adım bir proje oluşturalım.</strong></p><h3>1. SQL Server’da Veritabanı Oluşturma</h3><p>Öncelikle <strong>SQL Server</strong> üzerinde bir veritabanı oluşturmalıyız. <strong>SSMS (SQL Server Management Studio)</strong> veya herhangi bir SQL yönetim aracı kullanabiliriz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/350/1*HJ5oqyIjcgWtP-_DmgtofA.png" /></figure><pre>CREATE DATABASE SirketDB;</pre><p>Bu komut ile <strong>SirketDB</strong> adında bir veritabanı oluşturduk.</p><h3>Tabloları Ekleyelim</h3><p>Şimdi, bu veritabanına aşağıdaki tabloları ekleyelim:</p><h4>Birimler Tablosu</h4><pre>  CREATE TABLE Birimler (<br>    Id INT PRIMARY KEY IDENTITY(1,1),<br>    Ad NVARCHAR(100) NOT NULL<br>);</pre><h4>Personeller Tablosu</h4><pre>CREATE TABLE Personeller (<br>    Id INT PRIMARY KEY IDENTITY(1,1),<br>    Ad NVARCHAR(100) NOT NULL,<br>    Soyad NVARCHAR(100) NOT NULL,<br>    BirimId INT FOREIGN KEY REFERENCES Birimler(Id)<br>);</pre><h4>Müşteriler Tablosu</h4><pre>CREATE TABLE Musteriler (<br>    Id INT PRIMARY KEY IDENTITY(1,1),<br>    Ad NVARCHAR(100) NOT NULL,<br>    Soyad NVARCHAR(100) NOT NULL<br>);</pre><h4>Satışlar Tablosu</h4><pre>CREATE TABLE Satislar (<br>    Id INT PRIMARY KEY IDENTITY(1,1),<br>    MusteriId INT FOREIGN KEY REFERENCES Musteriler(Id),<br>    PersonelId INT FOREIGN KEY REFERENCES Personeller(Id),<br>    Tutar DECIMAL(10,2) NOT NULL,<br>    Tarih DATETIME NOT NULL DEFAULT GETDATE()<br>);</pre><p>Artık <strong>SirketDB</strong> adlı bir veritabanımız var ve içinde <strong>Birimler, Personeller, Musteriler ve Satislar</strong> tabloları bulunuyor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/305/1*l0OFxRUI_sk40K8_i-yXDw.png" /></figure><h3>2. Visual Studio’da Proje Oluşturma</h3><p>Şimdi <strong>Visual Studio’yu</strong> açalım ve aşağıdaki adımları takip edelim:</p><p>1️⃣ <strong>Yeni bir proje oluştur</strong></p><ul><li><strong>Console App (.NET Core) veya ASP.NET Core Web API</strong> seçebiliriz.</li><li>Proje adını <strong>SirketApp</strong> olarak belirleyelim.</li></ul><p>2️⃣ <strong>Gerekli NuGet Paketlerini Yükle</strong></p><p>Projemize <strong>Entity Framework Core</strong> ile <strong>SQL Server</strong> bağlantısını sağlayacak paketleri yüklemeliyiz. <strong>NuGet Package Manager</strong> üzerinden aşağıdaki komutları çalıştırabiliriz:</p><pre>  Install-Package Microsoft.EntityFrameworkCore.SqlServer<br>  Install-Package Microsoft.EntityFrameworkCore.Tools</pre><p>Bu paketler sayesinde <strong>EF Core</strong> ile <strong>SQL Server bağlantısını</strong> sağlayacağız.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/979/1*k-C-X7JSIQLYv72dwUousQ.png" /></figure><h3>3. Tersine Mühendislik ile Veritabanını Kodlara Dönüştürme</h3><p>Şimdi, <strong>Entity Framework Core’un </strong><strong>Scaffold-DbContext komutu</strong> ile veritabanını kod olarak oluşturacağız.</p><p>Visual Studio’da <strong>Tools → NuGet Package Manager → Package Manager Console</strong> yolunu izleyerek <strong>aşağıdaki komutu çalıştıralım:</strong></p><pre>Scaffold-DbContext &quot;Server=xxxxx;Database=SirketDB;Trusted_Connection=True;&quot; Microsoft.EntityFrameworkCore.SqlServer -OutputDir Models -Context AppDbContext</pre><blockquote>💡 <strong>Bu komut ne yapar?</strong></blockquote><blockquote><strong>Mevcut veritabanını alır</strong> ve <strong>Models</strong> klasörüne <strong>entity (model) sınıflarını</strong> oluşturur.</blockquote><blockquote>AppDbContext sınıfını oluşturarak <strong>veritabanı bağlantısını</strong> yönetir.</blockquote><h3>4. <strong>Models klasörü</strong> İncelenmesi</h3><p>Komutu çalıştırdıktan sonra <strong>Models klasörü</strong> içinde aşağıdaki yapılar otomatik olarak oluşturulacaktır:</p><p>📌 <strong>AppDbContext.cs</strong> (Veritabanı bağlantısını yöneten DbContext)<br> 📌 <strong>Birim.cs, Personel.cs, Musteri.cs, Satis.cs</strong> (Tabloların karşılık geldiği model sınıfları)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/670/1*KjP_8R4axBVS9R5ack9NIg.png" /></figure><h3>🖥️Code First Yaklaşımı:</h3><p>Gelelim ikinci yönteme: <strong>Code First</strong>. Bu yaklaşımda <strong>veritabanımız yoktur</strong> ve biz <strong>kod yazarak</strong> onu oluştururuz. Yani <strong>önce kodu yazarız, ardından veritabanı bu koddan türetilir</strong>. Entity Framework (EF) bizim yazdığımız kodları baz alarak veritabanı şemalarını oluşturur ve yönetir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*drar_eKzdfjpAf5lSr43Ng.png" /></figure><h3>Code First Yaklaşımının Avantajları ve Dezavantajları</h3><h3>✅ Avantajları:</h3><blockquote>✔ <strong>Daha Fazla Esneklik:</strong> Kod üzerinden doğrudan veritabanı şeması oluşturulabilir ve değişiklikler kolayca yönetilebilir.<br> ✔ <strong>Migration (Göç) Yönetimi Kolaydır:</strong> EF, kod değişikliklerini veritabanına aktarmak için otomatik olarak migration (göç) işlemlerini sağlar.<br> ✔ <strong>Sürüm Kontrolüne Uygundur:</strong> Tüm veritabanı şeması kod tabanında olduğu için Git gibi sürüm kontrol sistemleriyle kolayca yönetilebilir.<br> ✔ <strong>Bağımsız Geliştirme:</strong> Veritabanı henüz hazır olmasa bile proje geliştirmeye başlanabilir.</blockquote><h3>❌ Dezavantajları:</h3><blockquote>❌ <strong>Mevcut Veritabanı İçin Uygun Değil:</strong> Halihazırda bir veritabanı varsa, Code First yerine DB First tercih edilmelidir.<br> ❌ <strong>Veritabanı Yönetimi Daha Teknik Olabilir:</strong> SQL bilmeyen geliştiriciler için migration ve schema yönetimi zor olabilir.</blockquote><h3><strong>Ne Zaman Code-First Kullanmalıyız?:</strong></h3><blockquote>✅ Eğer projeye sıfırdan başlıyorsak ve veritabanı şemasını kod üzerinden tasarlamak istiyorsak.<br> ✅ Yazılım odaklı bir geliştirme süreci izleniyorsa ve veri modeli kod tarafında yönetilmek isteniyorsa.<br> ✅ Veritabanı yapısında esneklik ve kolayca değişiklik yapma ihtiyacı varsa.<br> ✅ Versiyon kontrolüyle veritabanı değişikliklerini takip etmek isteniyorsa.</blockquote><h3>🖥️⚙️Code First ile Uygulama Geliştirme:</h3><h3>📌 1. Projeyi Başlatma</h3><p>Öncelikle bir <strong>ASP.NET Core Web API</strong> projesi oluşturuyorum:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JW7cpHwNsVFTkHgwsPrn0Q.png" /></figure><h3>📌 2. Gerekli Paketleri Yükleme</h3><p>Entity Framework Core ve SQL Server için şu paketleri ekliyorum:</p><pre>dotnet add package Microsoft.EntityFrameworkCore.SqlServer<br>dotnet add package Microsoft.EntityFrameworkCore.Tools</pre><h3>📌 3. Model Sınıflarını (Tabloları) Tanımlama</h3><p>📂 <strong>CodeFirstApp</strong><br> ┣ 📂 <strong>Models</strong><br> ┃ ┣ 📄 <strong>Birim.cs</strong><br> ┃ ┣ 📄 <strong>Personel.cs</strong><br> ┃ ┣ 📄 <strong>Musteri.cs</strong><br> ┃ ┗ 📄 <strong>Satis.cs</strong><br> ┗ …</p><p>📄 <strong>Birim.cs</strong></p><pre>namespace CodeFirstApp.Models<br>{<br>    public class Birim<br>    {<br>        public int Id { get; set; }<br>        public string Ad { get; set; }<br>    }<br>}</pre><p>📄 <strong>Personel.cs</strong></p><pre>namespace CodeFirstApp.Models<br>{<br>    public class Personel<br>    {<br>        public int Id { get; set; }<br>        public string Ad { get; set; }<br>        public string Soyad { get; set; }<br>        public int BirimId { get; set; }<br>        public Birim Birim { get; set; }<br>    }<br>}</pre><p>📄 <strong>Musteri.cs</strong></p><pre>namespace CodeFirstApp.Models<br>{<br>    public class Musteri<br>    {<br>        public int Id { get; set; }<br>        public string Ad { get; set; }<br>        public string Email { get; set; }<br>    }<br>}</pre><p>📄 <strong>Satis.cs</strong></p><pre>namespace CodeFirstApp.Models<br>{<br>    public class Satis<br>    {<br>        public int Id { get; set; }<br>        public int MusteriId { get; set; }<br>        public Musteri Musteri { get; set; }<br>        public decimal Tutar { get; set; }<br>    }<br>}</pre><h3>📌 4. AppDbContext (Veritabanı Bağlantısı ve DbSet Tanımları)</h3><p>📄 <strong>AppDbContext.cs</strong><br> 📂 <strong>CodeFirstApp/Data/AppDbContext.cs</strong></p><pre>using Microsoft.EntityFrameworkCore;<br>using CodeFirstApp.Models;<br><br>namespace CodeFirstApp.Data<br>{<br>    public class AppDbContext : DbContext<br>    {<br>        public AppDbContext(DbContextOptions&lt;AppDbContext&gt; options) : base(options) { }<br><br>        public DbSet&lt;Birim&gt; Birimler { get; set; }<br>        public DbSet&lt;Personel&gt; Personeller { get; set; }<br>        public DbSet&lt;Musteri&gt; Musteriler { get; set; }<br>        public DbSet&lt;Satis&gt; Satislar { get; set; }<br>    }<br>}</pre><h3>📌 5. appsettings.json (Veritabanı Bağlantı Dizesi)</h3><p>📄 <strong>appsettings.json</strong></p><pre>{<br>  &quot;ConnectionStrings&quot;: {<br>    &quot;DefaultConnection&quot;: &quot;Server=xxxx;Database=CodeFirstDB;Trusted_Connection=True;MultipleActiveResultSets=True;&quot;<br>  }<br>}</pre><h3>📌 6. Program.cs İçerisinde DbContext Tanımlama</h3><p>📄 <strong>Program.cs</strong></p><pre>using CodeFirstApp.Data;<br>using Microsoft.EntityFrameworkCore;<br><br>var builder = WebApplication.CreateBuilder(args);<br><br>// Veritabanı bağlantısını ekleme<br>builder.Services.AddDbContext&lt;AppDbContext&gt;(options =&gt;<br>    options.UseSqlServer(builder.Configuration.GetConnectionString(&quot;DefaultConnection&quot;)));<br><br>builder.Services.AddControllers();<br>var app = builder.Build();<br><br>app.UseAuthorization();<br>app.MapControllers();<br>app.Run();</pre><h3>📌 7. Migration İşlemi (Veritabanını Oluşturma)</h3><p>📌 <strong>Migration (Geçiş) Ekliyorum:</strong></p><pre>dotnet ef migrations add InitialCreate</pre><p>📌 <strong>Veritabanını Güncelliyorum:</strong></p><pre>dotnet ef database update</pre><p><strong>Birim, Personel, Musteri ve Satis</strong> tabloları veritabanında oluştu.</p><h3>Entity (Varlık) Nedir?</h3><p>Entity, <strong>gerçek dünyadaki bir nesneyi temsil eden</strong> ve yazılımda <strong>bir sınıf olarak modellenen</strong> yapıdır. Örneğin, <strong>bir müşteri, bir sipariş veya bir ürün bir entity olabilir</strong>. Yani entity, yazılımın işleyişinde anlamlı bir veri kümesini temsil eden en temel birimdir.</p><p>📌 <strong>Basit bir tanımla:</strong> Eğer bir nesnenin <strong>adı, özellikleri (property’leri) ve ilişkileri</strong> varsa, bu bir entity’dir.<br> Örneğin, aşağıda bir <strong>Musteri (Customer) entity’si</strong> var:</p><pre>public class Musteri <br>{<br>    public int Id { get; set; }<br>    public string Ad { get; set; }<br>    public string Soyad { get; set; }<br>    public string Email { get; set; }<br>}</pre><h3>Veritabanı, DBContext ve Tablolar</h3><p><strong>Dikkat Edilmesi Gerken Bir Konu Var =&gt;</strong>Veritabanı <strong>tabloları</strong> her zaman çoğul isimlendirilir. Çünkü her tablo, tek tek entity’leri değil, <strong>birden fazla entity’yi</strong> tutar. Örneğin, <strong>“Musteriler” tablosu, birden çok “Musteri” entity’sini içerebilir.</strong></p><p><strong>DBContext ve DbSet Kullanımı</strong><br> DBContext, Entity Framework’ün <strong>veritabanı ile iletişimi yönettiği</strong> en temel sınıftır. Tabloları temsil eden entity’ler, <strong>DbSet&lt;&gt;</strong> ile belirtilir ve SQL ile eşleştirilir.</p><p>📌 <strong>Kod örneği:</strong></p><pre>public class UygulamaDbContext : DbContext<br>{<br>    public DbSet&lt;Musteri&gt; Musteriler { get; set; }<br>    public DbSet&lt;Urun&gt; Urunler { get; set; }<br>}</pre><blockquote>Burada <strong>Musteriler</strong> ve <strong>Urunler</strong> tablolarını veritabanında oluşturacak şekilde DbSet olarak tanımladık.</blockquote><h3>Kolon ve Veri Kavramları</h3><h3>1️⃣ Kolon (Property)</h3><p>Tablodaki <strong>sütunlar</strong>, entity içindeki <strong>property’ler</strong> olarak tanımlanır. Yani <strong>Musteri sınıfındaki “Ad”, “Soyad”, “Email” gibi property’ler, veritabanında kolon olarak karşılık bulur.</strong></p><p>📌 <strong>Örnek:</strong></p><pre>public class Musteri <br>{<br>    public int Id { get; set; }  // Id sütunu<br>    public string Ad { get; set; }  // Ad sütunu<br>    public string Soyad { get; set; }  // Soyad sütunu<br>    public string Email { get; set; }  // Email sütunu<br>}</pre><h3>2️⃣ Veri (Instance — Örnek)</h3><p>Tablodaki her bir satır, bir entity’nin <strong>instance (örneği)</strong> olarak düşünülebilir. <strong>New</strong> anahtar kelimesi ile yeni bir entity örneği oluşturulabilir.</p><p>📌 <strong>Örnek:</strong></p><pre>Musteri yeniMusteri = new Musteri()<br>{<br>    Id = 1,<br>    Ad = &quot;Harun&quot;,<br>    Soyad = &quot;Yılmaz&quot;,<br>    Email = &quot;harun@example.com&quot;<br>};</pre><blockquote>Burada <strong>yeniMusteri</strong>, <strong>Musteriler tablosuna kaydedilecek</strong> yeni bir satır (veri) anlamına gelir.</blockquote><h3>🎯DB First ve Code First Extra</h3><h3>1️⃣ Veritabanı Şemasını Elle Yönetmek (Schema Kullanımı)</h3><p>Varsayılan olarak <strong>Entity Framework her şeyi &quot;dbo&quot; şemasına atar</strong>. Ama büyük projelerde <strong>şemalar düzenli olmalıdır!</strong></p><p>Mesela <strong>Yetkilendirme</strong> ve <strong>Sipariş Yönetimi</strong> tablolarını ayırmak istiyorsun.</p><p><strong>Nasıl yaparsın?</strong></p><pre>[Table(&quot;Kullanicilar&quot;, Schema = &quot;Yetkilendirme&quot;)]<br>public class Kullanici<br>{<br>    public int Id { get; set; }<br>    public string Ad { get; set; }<br>}</pre><blockquote><strong>Bu ne sağlar?</strong></blockquote><blockquote>Veritabanı <strong>daha düzenli</strong> olur.</blockquote><blockquote>Büyük projelerde <strong>tabloları anlamak kolaylaşır</strong>.</blockquote><h3>2️⃣ Fluent API ile Daha Güçlü Yapılandırma</h3><p>Fluent API, annotation’ların alternatifi olarak <strong>daha fazla kontrol sağlar</strong>.</p><p>Örneğin, <strong>Foreign Key</strong> bağlantısı için klasik yöntemi kullanmak yerine Fluent API ile daha sağlam bir yapı kurabilirsin:</p><pre>protected override void OnModelCreating(ModelBuilder modelBuilder)<br>{<br>    modelBuilder.Entity&lt;Musteri&gt;()<br>        .HasOne(m =&gt; m.Adres)<br>        .WithMany(a =&gt; a.Musteriler)<br>        .HasForeignKey(m =&gt; m.AdresId);<br>}</pre><blockquote><strong>Neden önemli?</strong></blockquote><blockquote>Kodun <strong>daha okunabilir ve yönetilebilir</strong> olur.</blockquote><blockquote>Migration hatalarını <strong>minimuma indirir</strong>.</blockquote><h3>3️⃣ Performans Optimizasyonu: Lazy, Eager ve Explicit Loading</h3><p>Bir veriyi çekerken <strong>performans en büyük farkı yaratır</strong>! Yanlış sorgular ile sunucuyu yakmak istemeyiz değil mi :)</p><p>📌 <strong>Bunu bilmeyen biri ne yapar?</strong></p><pre>var musteriler = _context.Musteriler.ToList();</pre><blockquote>Bu, tüm müşteri verilerini çeker <strong>ama ilişkili Sipariş verilerini çekmez</strong></blockquote><p>📌 <strong>Doğru yöntemler:</strong></p><p>✔ <strong>Lazy Loading (Varsayılan)</strong></p><pre>public class Musteri<br>{<br>    public int Id { get; set; }<br>    public string Ad { get; set; }<br>    public virtual List&lt;Siparis&gt; Siparisler { get; set; }<br>}</pre><blockquote><em>🔹 </em><em>virtual keyword’ü sayesinde </em><strong><em>siparişler ancak ihtiyaç duyulduğunda çekilir</em></strong><em>.</em></blockquote><p>✔ <strong>Eager Loading (Performans için en iyisi)</strong></p><pre>var musteriler = _context.Musteriler.Include(m =&gt; m.Siparisler).ToList();</pre><blockquote><em>🔹 </em><em>Include() ile </em><strong><em>siparişler de müşteriyle beraber gelir</em></strong><em>.</em></blockquote><p>✔ <strong>Explicit Loading (Kontrollü yükleme)</strong></p><pre>var musteri = _context.Musteriler.First();<br>_context.Entry(musteri).Collection(m =&gt; m.Siparisler).Load();</pre><blockquote><em>🔹 Veri </em><strong><em>ancak ihtiyacın olduğunda</em></strong><em> çekilir.</em></blockquote><h3>4️⃣ Migration Sonrası Seed Data Eklemek</h3><p>Yeni bir migration yaptın. Ama her seferinde test verilerini elle girmek biraz sıkıcı gelebilir. <strong>Seed Data</strong> ile migration sonrası verileri otomatik ekleyebilirsin.</p><pre>protected override void OnModelCreating(ModelBuilder modelBuilder)<br>{<br>    modelBuilder.Entity&lt;Kategori&gt;().HasData(<br>        new Kategori { Id = 1, Ad = &quot;Elektronik&quot; },<br>        new Kategori { Id = 2, Ad = &quot;Giyim&quot; }<br>    );<br>}</pre><blockquote><strong>Bunu bize ne katar?</strong></blockquote><blockquote><strong>Development ortamında</strong> test verisi ekleyerek her şeyi elle yazmaktan kurtulur.</blockquote><h3>5️⃣ Veritabanı İşlemlerini Transaction ile Güvenceye Almak</h3><p>Diyelim ki <strong>bir müşteri kaydı ve sipariş ekleme</strong> işlemi yapıyorsun. Ama ortada bir hata var ve <strong>sipariş eklendi, ama müşteri eklenmedi.</strong></p><p>İşte <strong>Transaction kullanarak</strong> bunu önleyebilirsin:</p><pre>using (var transaction = _context.Database.BeginTransaction())<br>{<br>    try<br>    {<br>        var musteri = new Musteri { Ad = &quot;Ali&quot; };<br>        _context.Musteriler.Add(musteri);<br>        _context.SaveChanges();<br><br>        var siparis = new Siparis { MusteriId = musteri.Id, Tutar = 500 };<br>        _context.Siparisler.Add(siparis);<br>// Tüm değişiklikleri tek bir SaveChanges çağrısı ile kaydet<br>        _context.SaveChanges();<br> // İşlem başarılıysa transaction&#39;ı commit et<br>        transaction.Commit();<br>    }<br>    catch<br>    {<br>// Hata durumunda transaction&#39;ı geri al<br>        transaction.Rollback();<br>// Hatayı logla veya yeniden fırlat<br>// Log(ex);<br>    }<br>}</pre><blockquote>“Bu yazıyı yazarken Code-First ve DB-First yaklaşımlarını daha iyi anlama fırsatı buldum. Umarım siz de okurken yeni bilgiler edinmiş, farklı bakış açıları kazanmışsınızdır.</blockquote><blockquote>Bilgi, paylaşıldıkça çoğalan tek hazinedir. Yeni yazılarda görüşmek üzere, keyifli okumalar!”</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bfc93384d0a0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Entity Framework]]></title>
            <link>https://medium.com/@harundursunf/entity-framework-d4790b6fa05a?source=rss-6a34d5a59ece------2</link>
            <guid isPermaLink="false">https://medium.com/p/d4790b6fa05a</guid>
            <dc:creator><![CDATA[Harun Dursun]]></dc:creator>
            <pubDate>Thu, 06 Mar 2025 21:37:54 GMT</pubDate>
            <atom:updated>2025-03-06T21:37:54.122Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*3xF2oyIq4ObYRQqa.png" /></figure><p>Entity Framework (EF), .NET uygulamalarında veritabanı işlemlerini kolaylaştıran bir <strong>Object-Relational Mapper (ORM)</strong> aracıdır. ORM, ilişkisel veritabanları (SQL gibi) ile nesne yönelimli programlama dilleri (C# gibi) arasındaki <strong>uyumsuzluğu giderir</strong> ve daha az SQL kodu yazarak veritabanı işlemleri yapmamızı sağlar.</p><h4>Günlük Hayattan Bir Örnek Verelim</h4><p>Bir restoran düşünelim. Bu restoranda müşteri siparişlerini garsonlar alır ve mutfağa iletir. Mutfak, doğrudan müşterilerle muhatap olmaz, yalnızca gelen siparişleri hazırlar.</p><p>Burada:</p><ul><li><strong>Müşteri (Bizim C# kodumuz)</strong></li><li><strong>Garson (ORM — Entity Framework)</strong></li><li><strong>Mutfak (Veritabanı — SQL Server, MySQL vb.)</strong></li></ul><p>Müşteri, doğrudan mutfağa gitmek yerine garson aracılığıyla sipariş verir. Garson siparişi alır, mutfakta uygun formata çevirir ve mutfağa iletir. İşte ORM’nin yaptığı da budur! Bizim nesnelerimizi (C# class’larımızı), veritabanının anlayabileceği bir formata çevirir ve tersine çeviri yaparak sonuçları bize döndürür.</p><h3>ORM Olmadan ve ORM ile Kullanım Farkı</h3><p><strong>ORM Kullanılmadan (SQL ile Elle Sorgu Yazma)</strong></p><pre>SqlConnection connection = new SqlConnection(&quot;connection-string&quot;);<br>connection.Open();<br>SqlCommand command = new SqlCommand(&quot;SELECT * FROM Customers&quot;, connection);<br>SqlDataReader reader = command.ExecuteReader();<br>while (reader.Read())<br>{<br>    Console.WriteLine(reader[&quot;Name&quot;]);<br>}<br>connection.Close();</pre><p>Burada bağlantıyı açmamız, sorguyu yazmamız, çalıştırmamız ve sonrasında bağlantıyı kapatmamız gerekiyor.</p><p><strong>Entity Framework Kullanarak (ORM ile)</strong></p><pre>using (var context = new AppDbContext())<br>{<br>    var customers = context.Customers.ToList();<br>    foreach (var customer in customers)<br>    {<br>        Console.WriteLine(customer.Name);<br>    }<br>}</pre><p>ORM sayesinde SQL komutları yazmadan doğrudan nesnelerle çalışabiliyoruz. Kod <strong>daha temiz, okunabilir ve yönetilebilir</strong> hale geliyor.</p><blockquote>Entity Framework Kullanmanın Avantajları</blockquote><blockquote>✅ <strong>Daha Az Kod</strong>: SQL sorguları yazmak zorunda kalmayız.<br> ✅ <strong>Güvenlik</strong>: SQL Injection gibi saldırılara karşı daha korumalıdır.<br> ✅ <strong>Bakımı Kolay</strong>: Kodlar daha okunaklı ve düzenlidir.<br> ✅ <strong>Veritabanı Bağımsızlığı</strong>: Farklı veritabanlarına kolayca geçiş yapabiliriz.</blockquote><h3>ASP.NET Core Web API ile CRUD İşlemleri</h3><p>Şimdi de <strong>ASP.NET Core Web API</strong> kullanarak veritabanı işlemlerini nasıl yapabileceğimizi adım adım öğreneceğiz. Bu projede <strong>Entity Framework Core</strong> kullanarak SQL Server ile bağlantı kuracağız ve <strong>CRUD (Create, Read, Update, Delete)</strong> işlemlerini gerçekleştireceğiz.</p><h3>1️⃣ Web API Projesi Oluşturma</h3><p>İlk olarak bir <strong>ASP.NET Core Web API</strong> projesi oluşturalım. Bunu <strong>terminal (CLI)</strong> veya <strong>Visual Studio</strong> üzerinden yapabilirsiniz.</p><blockquote><strong>Visual Studio</strong> üzerinden:</blockquote><blockquote>1️⃣ <strong>File &gt; New &gt; Project</strong> menüsüne girin.<br> 2️⃣ <strong>ASP.NET Core Web API</strong> seçeneğini seçin.<br> 3️⃣ <strong>Proje ismini girin</strong> ve <strong>oluşturun</strong>.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8kEMA0WWulTMynKJCnki7A.png" /></figure><h3>2️⃣ Entity Framework Core Paketlerini Yükleme</h3><p>Veritabanı işlemleri yapabilmek için <strong>Entity Framework Core</strong> paketlerini yüklememiz gerekiyor. Terminalde şu komutları çalıştırıyoruz:</p><pre>dotnet add package Microsoft.EntityFrameworkCore.SqlServer<br>dotnet add package Microsoft.EntityFrameworkCore.Design<br>dotnet add package Microsoft.EntityFrameworkCore.Tools</pre><blockquote>📌 <strong>Bu paketler ne işe yarıyor?</strong><br>✅ <strong>Microsoft.EntityFrameworkCore.SqlServer</strong> → SQL Server ile bağlantı kurmamızı sağlar.<br>✅ <strong>Microsoft.EntityFrameworkCore.Design</strong> → Code First yaklaşımı ile veritabanı oluşturmamıza yardımcı olur.<br>✅ <strong>Microsoft.EntityFrameworkCore.Tools</strong> → EF Core komutlarını terminalden çalıştırmamızı sağlar.</blockquote><blockquote>💡 <strong>Alternatif Yöntem:</strong><br>Bu paketleri <strong>Visual Studio’da</strong> <strong>Manage NuGet Packages</strong> penceresinden de yükleyebilirsiniz.<br>1️⃣ <strong>Tools</strong> → <strong>NuGet Package Manager</strong> → <strong>Manage NuGet Packages for Solution</strong><br>2️⃣ <strong>Browse</strong> sekmesine geçin ve yukarıdaki paketleri aratarak <strong>Install</strong> butonuna tıklayın.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BTPBttaD5znfNz21oeW_Dg.png" /></figure><h3><strong>ASP.NET Core Web API ile CRUD İşlemleri</strong></h3><p>Bu projede, <strong>Entity Framework Core</strong> kullanarak <strong>SQL Server</strong> veritabanına bağlanan bir <strong>ASP.NET Core Web API</strong> geliştirmeyi hedefliyoruz. Amacımız, <strong>CRUD (Create, Read, Update, Delete)</strong> işlemlerini yaparak, <strong>Ürün (Product)</strong> verilerini nasıl yönetebileceğimizi görmek.</p><p>Proje gerçekten basit olacak, çünkü asıl amacımız işin mantığını kavramak ve temel işlemleri öğrenmek. Yapacağımız işlemler şunlar olacak:</p><ul><li><strong>Create</strong>: Yeni bir ürün ekleyebilmek için bir API endpoint’i oluşturacağız.</li><li><strong>Read</strong>: Ürünlerin listesini görüntüleyeceğiz ve tek bir ürünü sorgulamak için endpoint’ler yazacağız.</li><li><strong>Update</strong>: Var olan bir ürünü güncelleyebilmek için bir endpoint ekleyeceğiz.</li><li><strong>Delete</strong>: Ürünleri silebilmek için bir API endpoint’i oluşturacağız.</li></ul><h3>1️⃣ Veritabanı Bağlantı Dizesi (appsettings.json)</h3><p>Öncelikle <strong>veritabanı bağlantı dizesini</strong> appsettings.json içine ekleyelim:</p><pre>{<br>  &quot;ConnectionStrings&quot;: {<br>    &quot;DefaultConnection&quot;: &quot;Server=.;Database=MyDatabase;Trusted_Connection=True;&quot;<br>  }<br>}</pre><h3>2️⃣ Model Klasörü ve Sınıfı (Models/Product.cs)</h3><p>📂 Proje klasör yapımız şu şekilde olacak:</p><p>📂 <strong>MyWebAPI</strong><br> ├── 📂 <strong>Models</strong> → (Model Sınıfları)<br> │ ├── Product.cs<br> ├── 📂 <strong>Data</strong> → (Veritabanı Bağlantısı)<br> │ ├── AppDbContext.cs<br> ├── 📂 <strong>Controllers</strong> → (API Kontrolleri)<br> │ ├── ProductsController.cs<br> ├── Program.cs</p><p><strong>🔹 </strong><strong>Product.cs (Model Sınıfı)</strong></p><pre>using System.ComponentModel.DataAnnotations;<br><br>namespace MyWebAPI.Models<br>{<br>    public class Product<br>    {<br>        [Key] // Birincil anahtar<br>        public int Id { get; set; }<br><br>        [Required(ErrorMessage = &quot;Ürün adı zorunludur.&quot;)]<br>        public string Name { get; set; }<br><br>        [Range(0, double.MaxValue, ErrorMessage = &quot;Fiyat negatif olamaz!&quot;)]<br>        public decimal Price { get; set; }<br>    }<br>}</pre><blockquote>📌 <strong>Ne Yaptık?</strong><br> ✔️ Id → <strong>Primary Key</strong> olarak belirlendi.<br> ✔️ Name → <strong>Zorunlu</strong> alan eklendi.<br> ✔️ Price → <strong>Negatif olmaması</strong> için doğrulama eklendi.</blockquote><h3>3️⃣ DbContext (Veritabanı Bağlantısı - AppDbContext.cs)</h3><p>Şimdi <strong>Entity Framework</strong> kullanarak veritabanı bağlantısını oluşturalım.</p><p><strong>🔹 </strong><strong>AppDbContext.cs</strong></p><pre>using Microsoft.EntityFrameworkCore;<br>using MyWebAPI.Models;<br><br>namespace MyWebAPI.Data<br>{<br>    public class AppDbContext : DbContext<br>    {<br>        public AppDbContext(DbContextOptions&lt;AppDbContext&gt; options) : base(options) { }<br><br>        public DbSet&lt;Product&gt; Products { get; set; }<br>    }<br>}</pre><blockquote>📌 <strong>Bu sınıf ne yapıyor?</strong><br> ✅ Products → <strong>Veritabanında bir </strong><strong>Product tablosu oluşturur.</strong><br> ✅ DbContext üzerinden <strong>veritabanına erişimi yönetir.</strong></blockquote><h3>4️⃣ Program.cs (Uygulama Başlatma)</h3><p>Şimdi <strong>veritabanı bağlantısını</strong> Program.cs içinde yapılandırıyoruz.</p><p><strong>🔹 </strong><strong>Program.cs</strong></p><pre>using Microsoft.EntityFrameworkCore;<br>using MyWebAPI.Data;<br><br>var builder = WebApplication.CreateBuilder(args);<br>// appsettings.json&#39;dan bağlantı dizesini al<br>builder.Services.AddDbContext&lt;AppDbContext&gt;(options =&gt;<br>    options.UseSqlServer(builder.Configuration.GetConnectionString(&quot;DefaultConnection&quot;)));<br>// Controller&#39;ları servis koleksiyonuna ekleyerek API&#39;yi oluşturuyoruz<br>builder.Services.AddControllers();<br>// API&#39;nin daha iyi keşfi için EndpointsApiExplorer ekliyoruz<br>builder.Services.AddEndpointsApiExplorer();<br>// Swagger&#39;ı ekliyoruz, API dokümantasyonu ve test arayüzü sağlar<br>builder.Services.AddSwaggerGen();<br>var app = builder.Build();<br>// Eğer geliştirme ortamında isek Swagger&#39;ı etkinleştiriyoruz<br>if (app.Environment.IsDevelopment())<br>{<br>    app.UseSwagger();<br>    app.UseSwaggerUI();<br>}<br>// Yetkilendirmeyi (Authorization) uyguluyoruz<br>app.UseAuthorization();<br>// Controller&#39;ların API&#39;ye haritalanmasını sağlıyoruz<br>app.MapControllers();<br>// Uygulamayı çalıştırıyoruz<br>app.Run();</pre><blockquote>📌 <strong>Burada ne yaptık?</strong><br> ✅ DbContext&#39;i <strong>dependency injection (bağımlılık enjeksiyonu)</strong> ile ekledik.<br> ✅ <strong>Swagger</strong> ekleyerek <strong>API dokümantasyonu</strong> sağladık.<br> ✅ <strong>Veritabanı bağlantısını </strong><strong>appsettings.json üzerinden çektik.</strong></blockquote><h3>5️⃣ API Controller (ProductsController.cs)</h3><p>Şimdi <strong>ürün ekleme, güncelleme, silme ve listeleme</strong> işlemlerini yapabileceğimiz bir <strong>Controller</strong> oluşturalım.</p><h3><strong>🔹</strong> Tüm Ürünleri Getir</h3><pre>[HttpGet]<br>public async Task&lt;ActionResult&lt;IEnumerable&lt;Product&gt;&gt;&gt; GetProducts()<br>{<br>    return await _context.Products.ToListAsync();<br>}</pre><ul><li><strong>Yöntem:</strong> GET</li><li><strong>Açıklama:</strong> Bu endpoint, veritabanındaki tüm ürünleri liste olarak döndürür. ToListAsync() ile asenkron olarak ürünler alınır.</li></ul><h3><strong>🔹</strong> Belirli Bir Ürünü Getir</h3><pre>[HttpGet(&quot;{id}&quot;)]<br>public async Task&lt;ActionResult&lt;Product&gt;&gt; GetProduct(int id)<br>{<br>    var product = await _context.Products.FindAsync(id);<br>    if (product == null) return NotFound(new { message = &quot;Ürün bulunamadı!&quot; });<br>    return product;<br>}</pre><ul><li><strong>Yöntem:</strong> GET</li><li><strong>Açıklama:</strong> Bu endpoint, verilen id&#39;ye göre bir ürün arar. Eğer ürün bulunamazsa, NotFound döner.</li></ul><h3><strong>🔹</strong> Yeni Ürün Ekle</h3><pre>[HttpPost]<br>public async Task&lt;ActionResult&lt;Product&gt;&gt; AddProduct(Product product)<br>{<br>    if (!ModelState.IsValid) return BadRequest(ModelState);<br>    _context.Products.Add(product);<br>    await _context.SaveChangesAsync();<br>    return CreatedAtAction(nameof(GetProduct), new { id = product.Id }, product);<br>}</pre><ul><li><strong>Yöntem:</strong> POST</li><li><strong>Açıklama:</strong> Bu endpoint, gönderilen Product nesnesini veritabanına ekler. Model geçerliliğini kontrol eder ve geçerli ise kaydeder. Başarıyla eklenen ürün, CreatedAtAction ile döndürülür.</li></ul><h3><strong>🔹</strong> Ürünü Güncelle</h3><pre>[HttpPut(&quot;{id}&quot;)]<br>public async Task&lt;IActionResult&gt; UpdateProduct(int id, Product product)<br>{<br>    if (id != product.Id) return BadRequest(new { message = &quot;ID eşleşmiyor!&quot; });<br>    _context.Entry(product).State = EntityState.Modified;<br>    try<br>    {<br>        await _context.SaveChangesAsync();<br>    }<br>    catch (DbUpdateConcurrencyException)<br>    {<br>        if (!_context.Products.Any(e =&gt; e.Id == id))<br>            return NotFound(new { message = &quot;Güncellenmek istenen ürün bulunamadı!&quot; });<br>        throw;<br>    }<br>    return NoContent();<br>}</pre><ul><li><strong>Yöntem:</strong> PUT</li><li><strong>Açıklama:</strong> Bu endpoint, verilen id ile gelen ürünü günceller. Eğer ID&#39;ler eşleşmezse, BadRequest döner. Güncelleme sırasında bir hata oluşursa, ilgili hata mesajı döndürülür.</li></ul><h3><strong>🔹</strong> Ürünü Sil</h3><pre>[HttpDelete(&quot;{id}&quot;)]<br>public async Task&lt;IActionResult&gt; DeleteProduct(int id)<br>{<br>    var product = await _context.Products.FindAsync(id);<br>    if (product == null) return NotFound(new { message = &quot;Silinmek istenen ürün bulunamadı!&quot; });<br>    _context.Products.Remove(product);<br>    await _context.SaveChangesAsync();<br>    return NoContent();<br>}</pre><ul><li><strong>Yöntem:</strong> DELETE</li><li><strong>Açıklama:</strong> Bu endpoint, verilen id ile ürünü veritabanından siler. Eğer ürün bulunamazsa, NotFound döner. Başarıyla silindiğinde, NoContent döner.</li></ul><h4>Kodumuzun son hali :</h4><pre>namespace MyWebAPI.Controllers<br>{<br>    [Route(&quot;api/[controller]&quot;)]<br>    [ApiController]<br>    public class ProductsController : ControllerBase<br>    {<br>        private readonly AppDbContext _context;<br><br>        public ProductsController(AppDbContext context)<br>        {<br>            _context = context;<br>        }<br><br>        // 1️⃣ Tüm Ürünleri Getir<br>        [HttpGet]<br>        public async Task&lt;ActionResult&lt;IEnumerable&lt;Product&gt;&gt;&gt; GetProducts()<br>        {<br>            return await _context.Products.ToListAsync();<br>        }<br><br>        // 2️⃣ Belirli Bir Ürünü Getir<br>        [HttpGet(&quot;{id}&quot;)]<br>        public async Task&lt;ActionResult&lt;Product&gt;&gt; GetProduct(int id)<br>        {<br>            var product = await _context.Products.FindAsync(id);<br>            if (product == null) return NotFound(new { message = &quot;Ürün bulunamadı!&quot; });<br>            return product;<br>        }<br><br>        // 3️⃣ Yeni Ürün Ekle<br>        [HttpPost]<br>        public async Task&lt;ActionResult&lt;Product&gt;&gt; AddProduct(Product product)<br>        {<br>            if (!ModelState.IsValid) return BadRequest(ModelState);<br>            _context.Products.Add(product);<br>            await _context.SaveChangesAsync();<br>            return CreatedAtAction(nameof(GetProduct), new { id = product.Id }, product);<br>        }<br><br>        // 4️⃣ Ürünü Güncelle<br>        [HttpPut(&quot;{id}&quot;)]<br>        public async Task&lt;IActionResult&gt; UpdateProduct(int id, Product product)<br>        {<br>            if (id != product.Id) return BadRequest(new { message = &quot;ID eşleşmiyor!&quot; });<br>            _context.Entry(product).State = EntityState.Modified;<br>            try<br>            {<br>                await _context.SaveChangesAsync();<br>            }<br>            catch (DbUpdateConcurrencyException)<br>            {<br>                if (!_context.Products.Any(e =&gt; e.Id == id))<br>                    return NotFound(new { message = &quot;Güncellenmek istenen ürün bulunamadı!&quot; });<br>                throw;<br>            }<br>            return NoContent();<br>        }<br><br>        // 5️⃣ Ürünü Sil<br>        [HttpDelete(&quot;{id}&quot;)]<br>        public async Task&lt;IActionResult&gt; DeleteProduct(int id)<br>        {<br>            var product = await _context.Products.FindAsync(id);<br>            if (product == null) return NotFound(new { message = &quot;Silinmek istenen ürün bulunamadı!&quot; });<br>            _context.Products.Remove(product);<br>            await _context.SaveChangesAsync();<br>            return NoContent();<br>        }<br>    }<br>}</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vwajCF-WTprInbSaS7DbBg.png" /></figure><blockquote>📌 <strong>Ne Yaptık?</strong><br> ✅ <strong>GET (</strong><strong>/api/products)</strong> → Tüm ürünleri getir.<br> ✅ <strong>GET (</strong><strong>/api/products/{id})</strong> → Belirtilen ürünü getir.<br> ✅ <strong>POST (</strong><strong>/api/products)</strong> → Yeni bir ürün ekle.<br> ✅ <strong>PUT (</strong><strong>/api/products/{id})</strong> → Var olan ürünü güncelle.<br> ✅ <strong>DELETE (</strong><strong>/api/products/{id})</strong> → Ürünü sil.</blockquote><blockquote>📌 <strong>Sonuç:</strong><br> ✅ <strong>ASP.NET Core Web API ile CRUD işlemleri oluşturduk.</strong><br> ✅ <strong>Entity Framework Core ile SQL Server bağlantısı yaptık.</strong><br> ✅ <strong>Model doğrulamalarını ekledik.</strong><br> ✅ <strong>Swagger UI kullanarak API dokümantasyonu sağladık.</strong><br> ✅ <strong>Daha okunaklı, güvenli ve genişletilebilir bir yapı kurduk.</strong></blockquote><h3>Entity Framework İle Sorgu Yöntemleri ve Özellikler</h3><p>1️⃣ <strong>ToList()</strong><br> ToList() metodu, veritabanındaki tüm kayıtları liste olarak döner. Bu yöntem, verileri belleğe almanızı sağlar. Ancak çok büyük veri setleriyle çalışıyorsanız, belleği fazla tüketebilir.</p><pre>var products = _context.Products.ToList();</pre><p><strong>Not:</strong> Bu yöntem, tüm veriyi belleğe yükler ve tüm veriler getirildikten sonra sorgu tamamlanır. Bu nedenle, büyük veri setlerinde dikkatli olunması gerekir.</p><p>2️⃣ <strong>AsQueryable()</strong><br> AsQueryable() metodu, veritabanı sorgusunu IQueryable olarak döner ve böylece sorgu üzerinde daha fazla işlem yapmanızı sağlar. IQueryable sayesinde sorgularınızı zincirleme olarak oluşturabilirsiniz.</p><pre>var query = _context.Products.AsQueryable();</pre><p><strong>Not:</strong> AsQueryable(), sorgu üzerinde daha fazla esneklik sağlar, ancak sadece sorguyu oluşturur, veri getirmez. Yani, verileri sorgulamak için sonrasında ToList() veya başka bir metot kullanmak gerekir. Gereksiz yere kullanmak, performans sorunlarına yol açabilir.</p><p>3️⃣ <strong>FirstOrDefault()</strong><br> FirstOrDefault() metodu, belirtilen koşula uyan <strong>ilk öğeyi</strong> döndürür. Eğer koşula uyan herhangi bir öğe bulunmazsa, null döner. Bu yöntem, yalnızca koşula uyan ilk öğeyi alır ve işlem tamamlanır.</p><pre>var product = _context.Products.FirstOrDefault(p =&gt; p.Name == &quot;Product1&quot;);</pre><p><strong>Not:</strong> Bu yöntem yalnızca ilk eşleşen öğeyi döner. Eğer veritabanında birden fazla eşleşen öğe varsa, sadece ilkini getirir. Yani, çoklu eşleşme durumunda yalnızca ilk öğe dikkate alınır. Ayrıca, veritabanında eşleşen öğe yoksa null döneceği için, sonucu kontrol etmek önemlidir.</p><p>4️⃣ <strong>SingleOrDefault()</strong><br> SingleOrDefault() metodu, belirtilen koşula uyan <strong>yalnızca bir öğe olması</strong> gerektiğini varsayar. Eğer koşula uyan birden fazla öğe varsa, InvalidOperationException hatası alırsınız. Eğer koşula uyan öğe bulunmazsa, null döner.</p><pre>var product = _context.Products.SingleOrDefault(p =&gt; p.Id == 1);</pre><p><strong>Not:</strong> Bu yöntem yalnızca <strong>bir öğe</strong> olması gerektiğinden emin olmanız gerekir. Eğer birden fazla eşleşme varsa, InvalidOperationException hatası alınır. SingleOrDefault() kullanırken yalnızca <strong>bir öğe</strong> beklediğinizden emin olmalısınız; aksi takdirde, sistem hata verecektir. Ayrıca, eşleşme bulunmazsa null döner.</p><h4>5️⃣ Select()</h4><p>Select() metodu, belirli bir sütunu veya özelliği seçmek için kullanılır. Bu yöntem sayesinde yalnızca ihtiyacınız olan verileri alabilirsiniz.</p><pre>var productNames = _context.Products.Select(p =&gt; p.Name).ToList();</pre><p><strong>Not</strong>: Veritabanında yalnızca gerekli alanları seçmek, performansı artırabilir.</p><h4>6️⃣ Max() ve Min()</h4><p>Max() ve Min() metotları, veritabanındaki sayısal sütunlardan maksimum ve minimum değerleri döndürür. Bu metodlarla sayısal veriler üzerinde hızlıca analizler yapabilirsiniz.</p><pre>var maxPrice = _context.Products.Max(p =&gt; p.Price);<br>var minPrice = _context.Products.Min(p =&gt; p.Price);</pre><p><strong>Not</strong>: Bu metotlar, doğrudan veritabanında çalışır ve yalnızca sayısal sütunlarda kullanılabilir.</p><h4>7️⃣ ToArray()</h4><p>ToArray() metodu, veritabanındaki verileri bir diziye dönüştürür. ToArray() kullanmak, verileri hızlı bir şekilde dizi olarak almanıza olanak tanır.</p><pre>var productArray = _context.Products.ToArray();</pre><p><strong>Not</strong>: Bellekte dizi olarak veriyi saklar, büyük veri setlerinde dikkatli kullanılması gerekir.</p><h4>8️⃣ Join Kullanarak Sorgu Yapma</h4><p>Join kullanarak, birden fazla tabloyu birleştirip sorgu yapabilirsiniz. Bu, ilişkili verileri bir arada almak için kullanılır.</p><pre>var productsWithCategory = from p in _context.Products<br>                           join c in _context.Categories on p.CategoryId equals c.Id<br>                           select new { p.Name, c.Name };</pre><p>9️⃣ <strong>DTO (Data Transfer Object) Nesneleri Kullanma</strong><br> DTO (Data Transfer Object), yalnızca gerekli veriyi dışarıya göndermek amacıyla kullanılan bir tasarım desenidir. Veritabanı nesnelerindeki tüm veriyi dışarıya taşımak yerine, sadece ihtiyacınız olan alanları seçip dışarıya iletmek, veri güvenliğini artırır ve gereksiz verilerin istemciye veya başka bir sistem bileşenine sızmasını engeller.</p><p>Örneğin, aşağıdaki gibi bir ProductDTO sınıfı oluşturup yalnızca gerekli alanları dışarıya aktarabilirsiniz:</p><pre>public class ProductDTO<br>{<br>    public string Name { get; set; }<br>    public decimal Price { get; set; }<br>}</pre><p>Veritabanındaki tüm ürünleri alıp, yalnızca Name ve Price alanlarını içeren DTO nesnelerine dönüştürebiliriz:</p><pre>var productDTOs = _context.Products<br>    .Select(p =&gt; new ProductDTO { Name = p.Name, Price = p.Price })<br>    .ToList();</pre><p><strong>Not:</strong> DTO kullanımı, yalnızca gerekli alanları dışarıya çıkararak veri güvenliğini sağlar. Bu sayede, veritabanında bulunan ancak dışarıya gönderilmemesi gereken hassas veriler (örneğin, şifre, kullanıcı bilgileri, vb.) istemciye sızmaz. Ayrıca, sadece ihtiyacınız olan verilerin taşınması, sistem performansını da artırabilir. DTO kullanmak, istemci tarafında gereksiz veri işlemeyi de engeller.</p><h4>🔟 From Yapısında Where Sorgusu</h4><p>Where ile belirli bir koşula göre filtreleme yapılır. Bu, verilerinizi daha hedeflenmiş ve özelleştirilmiş şekilde almanızı sağlar.</p><pre>var filteredProducts = from p in _context.Products<br>                       where p.Price &gt; 50<br>                       select p;</pre><p><strong>Not</strong>: Where sorgusu veritabanında filtreleme işlemini yapar ve sadece ihtiyaç duyduğunuz verileri getirir.</p><h4>1️⃣1️⃣ Find() ile Veri Bulma</h4><p>Find() metodu, birincil anahtar (Primary Key) ile veritabanında veri araması yapar. Bu yöntem, anahtarı bilinen veriler için oldukça hızlıdır.</p><pre>var product = _context.Products.Find(1);</pre><p><strong>Not</strong>: Find(), yalnızca birincil anahtar ile çalışır ve hızlı sonuç verir. Ancak, diğer koşullara göre sorgulama yapmaz.</p><h3>Veritabanı Tasarımı: Code First ve İleri Yöntemler</h3><h3>1️⃣ Entity Framework ile Code First</h3><p><strong>Code First</strong>, Entity Framework’ün veritabanını yazdığınız C# sınıflarına göre oluşturmasını sağlar. Yani önce modelinizi yazıyorsunuz, sonra EF bu model üzerinden veritabanını yaratıyor.</p><p><strong>Örnek:</strong></p><pre>public class AppDbContext : DbContext<br>{<br>    public DbSet&lt;Product&gt; Products { get; set; }</pre><pre>    protected override void OnModelCreating(ModelBuilder modelBuilder)<br>    {<br>        modelBuilder.Entity&lt;Product&gt;().HasKey(p =&gt; p.Id); // Ürün ID&#39;sini birincil anahtar olarak ayarlıyoruz<br>    }<br>}</pre><p><strong>Neden kullanılır?</strong><br> Veritabanınızı tamamen kod üzerinden kontrol edebilirsiniz. Modelde yaptığınız her değişiklik veritabanına yansır, çok kolay bir yöntemdir.</p><h3>2️⃣ Data Annotations ile Özellik Eklemek</h3><p><strong>Data Annotations</strong>, modeldeki alanlara basit açıklamalar ekleyerek veritabanı özelliklerini ayarlamanızı sağlar. Küçük projeler için iyi bir yöntemdir.</p><p><strong>Örnek:</strong></p><pre>public class Product<br>{<br>    [Key] // Bu alanın birincil anahtar olduğunu belirtiyoruz<br>    public int Id { get; set; }</pre><pre>    [Required] // Bu alan zorunlu<br>    public string Name { get; set; }</pre><pre>    [Range(0, 10000)] // Fiyatın 0 ile 10.000 arasında olmasını istiyoruz<br>    public decimal Price { get; set; }<br>}</pre><p><strong>Neden kullanılır?</strong><br> Küçük projelerde hızlıca veritabanı yapısını kurmak için harika bir seçenek. Kolayca istediğiniz kısıtlamaları ekleyebilirsiniz.</p><p><strong>Ama dikkat!</strong><br> Eğer proje büyüdükçe, bu yöntem bazı karmaşık yapılandırmalar için yetersiz kalabilir. Ama başlangıç için gayet yeterli.</p><h3>3️⃣ OnModelCreating ile Özelleştirme</h3><p><strong>OnModelCreating</strong> metodu, veritabanı modelini daha detaylı özelleştirmenize olanak tanır. İlişkiler ya da özel ayarlamalar yapmak istiyorsanız bu metodu kullanırsınız.</p><p><strong>Örnek:</strong></p><pre>protected override void OnModelCreating(ModelBuilder modelBuilder)<br>{<br>    modelBuilder.Entity&lt;Product&gt;()<br>                .Property(p =&gt; p.Name)<br>                .IsRequired() // Name zorunlu olacak<br>                .HasMaxLength(100); // Name&#39;in en fazla 100 karakter olmasına izin veriyoruz<br>}</pre><p><strong>Neden kullanılır?</strong><br> Veritabanı modelini çok daha esnek bir şekilde kontrol edebilirsiniz. Örneğin, bir alanın uzunluğunu, veri tipini ya da kısıtlamalarını burada detaylıca belirleyebilirsiniz.</p><h3>4️⃣ EntityTypeConfiguration ile Yapılandırma</h3><p><strong>EntityTypeConfiguration</strong>, model sınıflarını ayrı ayrı yapılandırmanıza imkan verir. Bu yöntem, projeyi daha modüler ve düzenli hale getirir. Özellikle büyük projelerde oldukça kullanışlıdır.</p><p><strong>Örnek:</strong></p><pre>public class ProductConfiguration : IEntityTypeConfiguration&lt;Product&gt;<br>{<br>    public void Configure(EntityTypeBuilder&lt;Product&gt; builder)<br>    {<br>        builder.HasKey(p =&gt; p.Id); // Ürün ID&#39;si birincil anahtar<br>        builder.Property(p =&gt; p.Name).IsRequired().HasMaxLength(100); // Name zorunlu ve en fazla 100 karakter<br>    }<br>}</pre><p><strong>Neden kullanılır?</strong><br> Projeniz büyüdükçe, her modelin yapılandırmasını ayrı sınıflarda tutarak daha modüler ve anlaşılır hale getirebilirsiniz. Bu, çok daha temiz ve yönetilebilir bir kod sağlar.</p><h3>5️⃣ Tablolar Arası İlişki Kurma</h3><p>Entity Framework ile tablolar arasındaki ilişkileri kurabilirsiniz. Bu ilişkiler <strong>One-to-Many</strong>, <strong>Many-to-Many</strong> veya <strong>One-to-One</strong> olabilir. Yani bir kategoriye birden fazla ürün, ya da bir ürüne ait bir kategori olabilir.</p><p><strong>Örnek:</strong></p><pre>public class Category<br>{<br>    public int Id { get; set; }<br>    public string Name { get; set; }<br>    public ICollection&lt;Product&gt; Products { get; set; } // Kategoriye ait birden fazla ürün<br>}</pre><pre>public class Product<br>{<br>    public int Id { get; set; }<br>    public string Name { get; set; }<br>    public decimal Price { get; set; }<br>    public int CategoryId { get; set; }<br>    public Category Category { get; set; } // Her ürünün bir kategorisi var<br>}</pre><p>Bu yazım, benim için önemli bir başlangıç oldu. İlk kez böyle bir konu üzerine yazıyorum ve umarım, burada paylaştıklarım faydalı olmuştur. Entity Framework ve ASP.NET Core Web API hakkında öğrendiklerimi, sizlerle paylaşarak pekiştirmiş oldum. Bu süreçte birçok yeni şey öğrendim ve öğrendiklerimi başkalarına aktarmanın ne kadar değerli olduğunu fark ettim.</p><p>Teknolojiler hızla gelişiyor ve bu yazının, bu alanda ilerlemek isteyenler için bir rehber olabileceğini umuyorum. Yazımın faydalı olduğunu düşünüyorsanız, ben de bu tarz konuları daha fazla keşfetmeye devam edeceğim.</p><p>Teşekkürler!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d4790b6fa05a" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>