• Gereksiz Verileri Yüklemekten Kaçının (Select Kullanımı): Veritabanından sadece ihtiyacınız olan kolonları çekmek, hem ağ trafiğini azaltır hem de bellek kullanımını optimize eder. EF Core'da
  Kod:

  .Select()

  metodunu kullanarak belirli özelliklere sahip anonim tipler veya DTO'lar (Data Transfer Objects) oluşturabilirsiniz. Bu, özellikle büyük tablolarda önemli performans kazanımları sağlayabilir.
  
  Kod:

  var products = _context.Products
      .Where(p => p.IsActive)
      .Select(p => new { p.Id, p.Name, p.Price })
      .ToList();

  Bu yaklaşım, tüm Product nesnesini yüklemek yerine yalnızca belirtilen alanları veritabanından çeker.
  
• Değişiklik İzlemeyi Kapatın (AsNoTracking()): Eğer sorguladığınız varlıklar üzerinde herhangi bir değişiklik yapmayacaksanız ve sadece okuma amaçlı kullanacaksanız,
  Kod:

  AsNoTracking()

  metodunu kullanmak, EF'in değişiklik izleme mekanizmasının (Change Tracker) oluşturduğu ek yükü ortadan kaldırır. Bu, özellikle büyük veri setlerini okurken bellek kullanımını ve CPU döngülerini önemli ölçüde azaltır.
  
  Kod:

  var categories = _context.Categories
      .AsNoTracking()
      .ToList();

  Unutmayın, AsNoTracking() sadece okuma amaçlı sorgularda kullanılmalıdır. Eğer varlıkları güncelleyecekseniz, bu metodu kullanmamalısınız.

  Genişletmek için tıkla ...

• Sorgu Planı Önbelleğini Kullanma (Compiled Queries): EF Core, sorguları SQL'e çevirirken belirli bir maliyetle karşılaşır. Aynı sorgu şablonlarının tekrar tekrar yürütülmesi durumunda, bu maliyeti azaltmak için sorgu planlarını önbelleğe alabiliriz. EF Core'da bu özellik otomatik olarak çalışsa da, karmaşık sorgularda veya EF6'da Compiled Queries kavramı manuel önbellekleme için kullanılabilirdi. EF Core, iç mekanizmalarında bu optimizasyonu zaten yaptığı için, çoğu durumda özel bir işlem yapmanıza gerek kalmaz. Ancak, çok performans kritik senaryolarda `DbContext`'i farklı şekilde yapılandırmak gerekebilir.
  
• Ham SQL Sorguları (FromSqlRaw / FromSqlInterpolated): Bazı durumlarda, EF'in LINQ sorguları ile istenen performansı veya karmaşıklığı elde etmek zor olabilir. Bu gibi durumlarda, doğrudan ham SQL sorguları kullanmak daha verimli olabilir. EF Core,
  Kod:

  FromSqlRaw

  veya
  Kod:

  FromSqlInterpolated

  metodlarını kullanarak varlık tipleriyle eşleşen ham SQL sorgularını yürütmenize olanak tanır.
  
  Kod:

  var users = _context.Users
      .FromSqlRaw("SELECT * FROM Users WHERE Age > {0}", 30)
      .ToList();

  Bu yöntem, özellikle raporlama, karmaşık birleşimler veya stored procedure çağrıları için faydalıdır. Ancak SQL enjeksiyon riskine karşı parametreli sorgular kullandığınızdan emin olun.

• Eager Loading (Include): En yaygın ve genellikle en performanslı yöntemdir. Ana sorguyla birlikte ilişkili verileri de tek bir veritabanı sorgusunda yükler. Bu, "N+1 sorgu problemi"ni önler.
  
  Kod:

  var ordersWithItems = _context.Orders
      .Include(o => o.OrderItems)
      .ThenInclude(oi => oi.Product)
      .ToList();

  Birden fazla
  Kod:

  Include()

  veya
  Kod:

  ThenInclude()

  kullanarak derinlemesine ilişkili verileri yükleyebilirsiniz. Ancak çok fazla
  Kod:

  Include()

  kullanmak, SQL sorgusunun çok karmaşık hale gelmesine ve performans sorunlarına yol açabilir (cartesian product etkisi).
  
• Lazy Loading (Tembel Yükleme): İlişkili verilerin, onlara ilk erişildiğinde otomatik olarak yüklenmesini sağlar. Bu, geliştirici için kolaylık sağlasa da, genellikle performans düşüşlerine yol açar. Özellikle bir döngü içinde her bir varlık için ilişkili verilere erişildiğinde, her seferinde ayrı bir veritabanı sorgusu tetiklenir ve bu da "N+1 sorgu problemi" olarak bilinen duruma neden olur. Bu genellikle Entity Framework Core'da varsayılan olarak kapalıdır ve açıkça etkinleştirilmesi gerekir (genellikle `Microsoft.EntityFrameworkCore.Proxies` paketiyle).
  
• Explicit Loading (Açık Yükleme): İlişkili verilerin belirli bir varlık için manuel olarak yüklenmesini sağlar. Bu, yalnızca belirli bir durumda ilişkili verilere gerçekten ihtiyacınız olduğunda kullanışlıdır. Örneğin:
  
  Kod:

  var order = _context.Orders.Find(1);
  _context.Entry(order).Collection(o => o.OrderItems).Load(); // Koleksiyonu yükle
  _context.Entry(order).Reference(o => o.Customer).Load();   // Referansı yükle

  Bu yöntem, gerektiğinde veri yükleme esnekliği sunsa da, N+1 problemine yol açma potansiyeli nedeniyle dikkatli kullanılmalıdır.

• Toplu Ekleme/Silme/Güncelleme İşlemleri: Çok sayıda varlığı aynı anda eklerken,
  Kod:

  AddRange()

  veya
  Kod:

  RemoveRange()

  gibi metodları kullanmak, tek tek
  Kod:

  Add()

  veya
  Kod:

  Remove()

  çağırmaktan çok daha performanslıdır. Benzer şekilde, EF Core 7 ve üzeri sürümlerde `ExecuteDelete()` ve `ExecuteUpdate()` gibi toplu işlemler, veritabanına sadece tek bir SQL komutu göndererek binlerce kaydı etkili bir şekilde güncelleyebilir veya silebilir.
  
  Kod:

  _context.Products.AddRange(newProductList);
  _context.SaveChanges();
  
  // EF Core 7+ ile toplu güncelleme
  _context.Products
      .Where(p => p.CategoryId == 1)
      .ExecuteUpdate(setters => setters
          .SetProperty(p => p.Price, p => p.Price * 1.1m)
          .SetProperty(p => p.LastUpdated, p => DateTime.Now));

• Önbellekleme Katmanları ve Veritabanı Dışı İşlemler: Eğer çok sayıda güncelleme yapacaksanız, ancak her birini veritabanına anında yansıtmanız gerekmiyorsa, bu işlemleri bir önbellek katmanında (örneğin Redis) toplayıp belirli aralıklarla veya arka plan görevleriyle toplu olarak veritabanına yazmak da bir performans stratejisi olabilir.

• Kısa Ömürlü DbContext (Short-Lived Instances): DbContext, genellikle her iş birimi (unit of work) için yeni bir örnek olarak oluşturulmalı ve iş bittiğinde atılmalıdır. Uzun ömürlü DbContext örnekleri, değişiklik izleme (change tracking) yükünü artırabilir, bellek sızıntılarına yol açabilir ve stale data (eskimiş veri) sorunlarına neden olabilir. ASP.NET Core uygulamalarında bağımlılık enjeksiyonu (dependency injection) ile scoped lifetime olarak yapılandırmak, bu prensibi otomatik olarak sağlar.
  
  Kod:

  // Doğru kullanım (using ile otomatik imha)
  using (var context = new MyDbContext())
  {
      // İşlemler...
  }
  
  // ASP.NET Core Dependency Injection
  services.AddDbContext<MyDbContext>(options => options.UseSqlServer(connectionString), ServiceLifetime.Scoped);

• Db Bağlantılarının Yönetimi: EF, veritabanı bağlantılarını kendisi yönetir ve genellikle bağlantı havuzlama (connection pooling) kullanır. Bu, bağlantı açma/kapatma maliyetini azaltır. Geliştiricilerin bu konuda özel bir işlem yapması nadiren gerekir, ancak `ConnectionString`'in doğru yapılandırıldığından emin olunmalıdır.

• Sorgulanan ve Filtrelenen Kolonlara İndeks Ekleme: `WHERE`, `ORDER BY`, `JOIN` gibi yan tümcelerde sıkça kullanılan kolonlara indeks eklemek, sorgu hızını önemli ölçüde artırır. Çok kolonlu indeksler (composite indexes) de belirli senaryolarda faydalı olabilir.
  
  Kod:

  modelBuilder.Entity<Product>()
      .HasIndex(p => p.CategoryId);
  
  modelBuilder.Entity<Customer>()
      .HasIndex(c => new { c.LastName, c.FirstName });

• Gereksiz İndekslerden Kaçınma: Her indeksin veritabanında yer kapladığını ve INSERT, UPDATE, DELETE işlemlerinin performansını olumsuz etkilediğini unutmayın. Bu nedenle, sadece gerçekten ihtiyaç duyulan indeksleri oluşturun ve periyodik olarak kullanılmayan indeksleri gözden geçirin ve kaldırın.

ToListAsync()

SaveChangesAsync()

FirstOrDefaultAsync()

var products = await _context.Products.ToListAsync();
await _context.SaveChangesAsync();

• EF Core Bulk Extensions: ZZZ Projects'in Entity Framework Extensions gibi kütüphaneler, BulkInsert, BulkUpdate, BulkDelete gibi operasyonlar sunar. Bu kütüphaneler, veritabanına tek bir büyük komut göndererek çok sayıda işlemi standart EF yöntemlerine göre kat kat hızlı bir şekilde gerçekleştirir.
  
  Kod:

  // Örnek: BulkInsert ile birden fazla ürün ekleme
  _context.BulkInsert(productsToInsert);

  Bu tür kütüphaneler, özellikle veri göçü (data migration) veya büyük miktarda veri senkronizasyonu gibi senaryolarda hayat kurtarıcı olabilir.

• EF Core ile Stored Procedure Çağırma: EF Core,
  Kod:

  FromSqlRaw

  veya
  Kod:

  FromSqlInterpolated

  metodlarını kullanarak Stored Procedure'leri doğrudan çağırabilir ve sonuçlarını varlıklarınıza veya anonim tiplere eşleştirebilirsiniz.
  
  Kod:

  var reportData = _context.Set<ReportItem>()
      .FromSqlRaw("EXEC GetSalesReport @StartDate = {0}, @EndDate = {1}", startDate, endDate)
      .ToList();

  Stored procedure'ler, özellikle veritabanı yöneticileri tarafından optimize edilmiş ve test edilmiş karmaşık iş mantıkları için tercih edilebilir.

  Genişletmek için tıkla ...

• Birinci Düzey Önbellek (First-Level Cache): DbContext, varsayılan olarak birinci düzey bir önbellek görevi görür. Aynı DbContext örneği içinde aynı varlığı birden fazla kez sorguladığınızda, EF varlığı veritabanından tekrar çekmez, bunun yerine belleğindeki örneği döndürür. Bu, bir DbContext yaşam döngüsü içindeki sorgular için otomatik bir optimizasyondur.
  
• İkinci Düzey Önbellek (Second-Level Cache): Birden fazla DbContext örneği veya farklı HTTP istekleri arasında veri önbelleklemesi yapmak için ikinci düzey önbellek çözümleri gereklidir. Bu genellikle harici bir önbellek hizmeti (örneğin Redis, Memcached) veya bir ORM önbellek sağlayıcısı (örneğin EFCore.Cacheable) kullanılarak uygulanır.
  
  Kod:

  // Örnek: EFCore.Cacheable kullanımı (pseudo-code)
  var cachedProducts = await _context.Products
      .Where(p => p.IsActive)
      .Cacheable()
      .ToListAsync();

  Bu tür önbellekleme, veritabanı yükünü önemli ölçüde azaltabilir, ancak önbellek geçersiz kılma (cache invalidation) stratejileri dikkatlice yönetilmelidir.

• SQL Server Profiler / Azure Data Studio / SSMS: Doğrudan veritabanı sunucusundaki sorguları izlemek için bu araçlar kullanılabilir. Yavaş çalışan sorguları, uzun süren okuma/yazma işlemlerini ve kilitlenmeleri tespit etmeye yardımcı olur.
  
• EF Core Power Tools: Visual Studio için bir eklenti olup, EF Core bağlamında oluşturulan SQL sorgularını analiz etmenize olanak tanır. Sorgu planlarını görselleştirebilir ve performans ipuçları alabilirsiniz.
  
• MiniProfiler: Web uygulamalarınızdaki isteklerin performansını izlemek için hafif bir profilleme aracıdır. Her isteğin ne kadar sürdüğünü ve hangi sorguların yavaş olduğunu görmenizi sağlar.
  
• APM (Application Performance Monitoring) Araçları: Azure Application Insights, New Relic, Dynatrace gibi araçlar, uygulamanızın tüm katmanlarındaki performans verilerini toplayıp analiz ederek darboğazları belirlemenize yardımcı olur.

Unutmayın: Performans optimizasyonu sürekli bir süreçtir ve uygulamanızın yaşam döngüsü boyunca periyodik olarak gözden geçirilmelidir.

Genişletmek için tıkla ...