🚀 Temel Kurulumlar

📦 Gerekli NuGet Paketleri

typescript
Kopyala
<PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="8.0.0" />
<PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="8.0.0" />

typescript
Kopyala
<PackageReference Include="Microsoft.Extensions.Caching.StackExchangeRedis" Version="8.0.0" />
<PackageReference Include="StackExchange.Redis" 

🔧 Program.cs Temel Yapılandırması

bash
Kopyala
using Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.Caching.Distributed;
using StackExchange.Redis;
var builder = WebApplication.CreateBuilder(args);
// In-Memory Cache Konfigürasyonu - TÜM OPTIONS
builder.Services.AddMemoryCache(options =>
{
  // TEMEL BOYUT YÖNETİMİ
  options.SizeLimit = 1024; // Cache boyut sınırı (entry sayısı)
  options.CompactionPercentage   // İSTATİSTİK VE İZLEME
// Redis Distributed Cache Konfigürasyonu - TÜM OPTIONS
  // TEMEL BAĞLANTI YÖNETİMİ
  // GELİŞMİŞ KONFIGÜRASYON
  // FACTORY YÖNETİMİ
  // PROFILING VE İZLEME

🔧 Tüm Memory Cache Options Detayları

📊 Temel Boyut Yönetimi Options

MemoryCache Kavramı – Dolap Analojisiyle Anlayalım

• Hayal et ki bir mutfağın var ve orada bir dolap var. Bu dolapta çeşitli yiyecekleri saklıyorsun: kavanozlar, tabaklar, kutular… Ama bu dolabın bir sınırı var değil mi? Yani dolabın bir kapasitesi sınırlı: Ne kadar büyük şey koyarsan, o kadar az şey sığar. Her şeyden azar azar koyarsan, daha fazla şey sığar.

• Yazılımda da bu dolap gibi çalışan bir yapı var: Buna MemoryCache diyoruz. Bu sistem, RAM üzerinde çalışır. Çok hızlıdır – çünkü bellekte durur. Ama geçicidir – uygulama kapanırsa silinir. Ve en önemlisi: sınırlı bir kapasitesi vardır.
• SizeLimit – Dolabın Kapasitesini Belirlemek
  • Dolaba “şu kadar şey koyabilirsin” demek bir sınır koymaktır. Aynı şekilde, biz MemoryCache için de bir limit tanımlarız:

• bash
  Kopyala
  var cache = new MemoryCache(new MemoryCacheOptions
  {
    SizeLimit = 100 // Dolabın kapasitesi: 100 birimlik yer
  });

• Yani bu örnekte: “Benim dolabım (cache), toplamda 100 birimlik veri alabilir” demiş oluyoruz. Eğer bu limit aşılırsa sistem çökmese bile eski veriler silinir veya hata alınabilir: OutOfMemoryException gibi hatalar oluşabilir.
• SetSize – Bu Eşya Kaç Yer Kaplıyor?
• Şimdi düşün: Dolaba konulan her eşyanın (mesela kavanoz) kapladığı alanı bilirsen, dolabı çok daha verimli kullanabilirsin değil mi? İşte yazılımda da cache'e veri eklerken, o verinin kaç birim yer kapladığını belirtmemiz gerekir. Buna SetSize denir. Her cache verisi yani her bir “entry” için boyut belirlemek şarttır:

• bash
  Kopyala
  memoryCache.Set("products", productList, new MemoryCacheEntryOptions
  {
    Size = 5  // Bu veri büyük, 5 birim yer kaplasın
  });

• Kavram	Açıklama
  MemoryCache	Dolap (RAM üzerinde çalışan hızlı geçici saklama alanı)
  SizeLimit	Dolabın toplam kapasitesi (Kaç birimlik eşya alabileceği)
  SetSize	Her bir eşyanın (verinin) kaç birim yer kapladığı

• 🍱 Örnek Senaryo – Dolabı Dolduralım Dolap kapasitesi: SizeLimit = 10 Şimdi dolaba veri (eşya) ekliyoruz:

• bash
  Kopyala
  cache.Set("kavanoz1", data1, new MemoryCacheEntryOptions { Size = 3 }); 
  cache.Set("kavanoz2", data2, new MemoryCacheEntryOptions { Size 

  Her şey güzel gidiyor. Dolap tamamen doldu. Ama sonra bir eşya daha eklemeye çalışıyoruz:
• ⛔️ Artık sığmaz! Dolap (cache) dolu olduğu için yeni veriyi ekleyemez. Bu durumda MemoryCache, en eski veya az kullanılan verileri otomatik olarak çıkarır ve yerine yenisini koyar. Bu sürece Eviction (taşma ve çıkarma) denir.
• Eviction Nedir?
• Eviction, dolapta yer kalmadığında eski eşyaların (verilerin) otomatik çıkarılması işlemidir. Örneğin: “En eski kavanozu at, yenisini koy.” mantığı.

🎯 SizeLimit - Cache Boyut Sınırı

• Ne İşe Yarar?
  • Cache'de aynı anda tutabileceğiniz maksimum veri sayısını belirler
  • Memory kullanımını kontrol altında tutar
  • İstem dışı bellek tükenmelerini (OutOfMemoryException) engeller
• Nasıl Çalışır?
  • SetSize() belirtilmemişse, her cache girişi 1 birim sayılır
  • SetSize() ile belirli boyut atarsan, entry (Cache’e eklediğin her bir veri parçasına “entry” denir.) bu değere göre sayılır
  • Limit aşılırsa, LRU (Least Recently Used) algoritması ile eski veriler silinir
  • Null atanırsa bu Sınırsız demektir ve tehlikelidir.
• Neden Null Tehlikeli?
  • Memory dolana kadar büyür, uygulama çöker
  • Sistem kaynaklarını tüketir, diğer uygulamaları etkiler
  • Production'da asla kullanmayın, sadece test ortamında düşünün
  • Örnek: 1GB memory'li sistemde cache 2GB'a çıkarsa sistem donar
    • 1GB RAM’li Bir Sistemde Cache 2GB Olabilir mi? Kısa cevap: Hayır, olamaz (ya da olmamalıdır). Çünkü bu sistemin fiziksel belleğinden (RAM) daha büyük bir alanı cache için ayırmak, OutOfMemoryException (bellek taşması) gibi hatalara ve hatta sistemin tamamen çökmesine yol açabilir.

bash
Kopyala
// 1. Sınırsız Cache (DİKKATLİ KULLAN!)
options.SizeLimit = null;
// ❌ NEDEN TEHLİKELİ: Memory dolana kadar büyür, uygulama çöker
// ✅ NE ZAMAN KULLAN: Sadece çok küçük veriler için, test ortamında
// 2. Küçük Uygulamalar (100 entry)
options.SizeLimit = 100;
// ✅ NE İÇİN: Blog siteleri, kişisel projeler
// 📊 MEMORY: ~1-2 MB kullanım
// ⚡ PERFORMANS: Çok hızlı, sürekli temizlik
// 3. Orta Ölçekli Uygulamalar (1024 entry)
options.SizeLimit = 1024;
// ✅ NE İÇİN: E-ticaret siteleri, kurumsal web uygulamaları
// 📊 MEMORY: ~10-20 MB kullanım
// ⚡ PERFORMANS: Dengeli, makul temizlik sıklığı
// 4. Büyük Uygulamalar (10000 entry)
options.SizeLimit = 10000;
// ✅ NE İÇİN: Sosyal medya, büyük e-ticaret platformları
// 📊 MEMORY: ~100-200 MB kullanım
// ⚡ PERFORMANS: Yavaş temizlik, yüksek hit rate
// 5. Enterprise Uygulamalar (50000 entry)
options.SizeLimit = 50000;
// ✅ NE İÇİN: Netflix, Amazon gibi mega platformlar
// 📊 MEMORY: ~500MB-1GB kullanım
// ⚡ PERFORMANS: Çok yavaş temizlik, maksimum cache hit

🎯 SetSize - Entry Boyutu Belirleme

• Ne İşe Yarar?
  • Her bir cache entry'nin hafızada kapladığı alanı simgeler
  • SizeLimit ile birlikte çalışır
  • Daha gerçekçi ve şeffaf boyut yönetimi sağlar
• Nasıl Çalışır?
  • Entry'e atanırken .SetSize(int) ile kullanılır
  • SizeLimit'e ulaşıldığında en eski SetSize'li veriler temizlenir
• Neden SetSize Kullanırız?
  • SetSize olmadan: Her entry 1 birim sayılır (büyük/küçük fark etmez)
  • SetSize ile: Gerçek memory kullanımına göre sayım yapılır
  • Örnek: 1MB'lık veri ile 1KB'lık veri aynı değer (1 birim)
  • SetSize ile: 1MB = 1000 birim, 1KB = 1 birim (daha adil)

bash
Kopyala
// Cache konfigürasyonu
builder.Services.AddMemoryCache(options =>
{
  options.SizeLimit = 10000; // Toplam 10.000 birim
});
// Farklı boyutlarda entry'ler ekleme
cache.Set("small-data", smallData, new MemoryCacheEntryOptions
{
  Size = 1 // 1 birim
});
cache.Set("medium-data", mediumData, new MemoryCacheEntryOptions
{
  Size = 100 // 100 birim
});
cache.Set("large-data", largeData, new MemoryCacheEntryOptions
{
  Size = 1000 // 1000 birim
});
// Toplam: 1 + 100 + 1000 = 1101 birim (limit 10.000)

bash
Kopyala
// 1. Küçük Veri (1KB - 1 birim)
cache.Set("user-settings", userSettings, new MemoryCacheEntryOptions

bash
Kopyala
// ❌ SetSize olmadan (adil değil)
cache.Set("tiny-data", tinyData); // 1 birim (gerçekte 1KB)
cache.Set(// Gerçek memory kullanımına göre sayım

bash
Kopyala
// Senaryo 1: SizeLimit = 1000, SetSize kullanılmıyor
// 1000 entry eklenebilir (hepsi 1 birim)// Ama memory kullanımı çok farklı olabilir

🧹 CompactionPercentage - Temizlik Yüzdesi

• Ne İşe Yarar?
  • Cache dolduğunda ne kadar veri silineceğini belirler
  • Memory temizliğinin ne kadar sert yapılacağını kontrol eder
  • Cache performansını ve memory kullanımını dengeler
• Nasıl Çalışır?
  • 0.0 ile 1.0 arası değer alır (0% ile 100%)
  • Cache dolduğunda bu yüzde kadar entry silinir
  • Daha yüksek değer = Daha sert temizlik (daha fazla veri silinir)
• Pratik Örnek:
  • %10 temizlik: 1000 entry varsa sadece 100 tanesi silinir (yumuşak temizlik)
  • %50 temizlik: 1000 entry varsa 500 tanesi silinir (sert temizlik)
  • %75 temizlik: 1000 entry varsa 750 tanesi silinir (çok sert temizlik)

bash
Kopyala
// 1. Conservative Temizlik (%10)
options.CompactionPercentage = 0.1;
// ✅ NE İÇİN: Cache hit rate'i yüksek olması gereken uygulamalar
// 📊 ETKİ: 1000 entry varsa, sadece 100 tanesi silinir
// ⚡ AVANTAJ: Cache'de daha fazla veri kalır
// ❌ DEZAVANTAJ: Sık temizlik yapılır
// 2. Balanced Temizlik (%25) - EN YAYGIN
options.CompactionPercentage = 0.25;
// ✅ NE İÇİN: Çoğu production uygulaması
// 📊 ETKİ: 1000 entry varsa, 250 tanesi silinir
// ⚡ AVANTAJ: Dengeli performans
// 📈 ÖNERİ: Başlangıç için bu değeri kullanın
// 3. Aggressive Temizlik (%50)
options.CompactionPercentage = 0.5;
// ✅ NE İÇİN: Memory sıkıntısı olan sistemler
// 📊 ETKİ: 1000 entry varsa, 500 tanesi silinir
// ⚡ AVANTAJ: Hızlı memory temizliği
// ❌ DEZAVANTAJ: Cache hit rate düşer
// 4. Very Aggressive Temizlik (%75)
options.CompactionPercentage = 0.75;
// ✅ NE İÇİN: Çok sınırlı memory'li sistemler
// 📊 ETKİ: 1000 entry varsa, 750 tanesi silinir
// ⚡ AVANTAJ: Çok hızlı memory temizliği
// ❌ DEZAVANTAJ: Cache neredeyse boş kalır

⏰ ExpirationScanFrequency - Tarama Sıklığı

• Ne İşe Yarar?
• Süresi dolmuş cache entry'lerin ne sıklıkla temizleneceğini belirler
• CPU kullanımını ve memory temizliğini dengeler
• Memory leak'leri önler
• Nasıl Çalışır?
• Background thread bu sıklıkta çalışır
• Expired entry'leri bulup siler
• Daha sık tarama = Daha fazla CPU kullanımı ama daha temiz memory
• Pratik Örnek:
• 30 saniye: Her 30 saniyede bir kontrol eder (çok sık, CPU yoğun)
• 5 dakika: Her 5 dakikada bir kontrol eder (dengeli, önerilen)
• 30 dakika: Her 30 dakikada bir kontrol eder (yavaş, CPU tasarrufu)
• 0 (sıfır): Hiç kontrol etmez (tehlikeli, memory leak riski)

bash
Kopyala
// 1. Çok Hızlı Tarama (30 saniye)
options.ExpirationScanFrequency = TimeSpan.FromSeconds(30);
// ✅ NE İÇİN: Test ortamları, development
// 📊 CPU KULLANIMI: Yüksek (her 30 saniyede bir tarama)
// ⚡ AVANTAJ: Expired entry'ler hemen silinir
// ❌ DEZAVANTAJ: CPU kaynağı tüketir
// 2. Hızlı Tarama (1 dakika)
options.ExpirationScanFrequency = TimeSpan.FromMinutes(1);
// ✅ NE İÇİN: Development, küçük production sistemleri
// 📊 CPU KULLANIMI: Orta-yüksek
// ⚡ AVANTAJ: Hızlı cleanup
// 📈 ÖNERİ: Development için ideal
// 3. Normal Tarama (5 dakika) - EN YAYGIN
options.ExpirationScanFrequency = TimeSpan.FromMinutes(5);
// ✅ NE İÇİN: Çoğu production uygulaması
// 📊 CPU KULLANIMI: Düşük
// ⚡ AVANTAJ: Dengeli CPU kullanımı
// 📈 ÖNERİ: Production için ideal
// 4. Yavaş Tarama (15 dakika)
options.ExpirationScanFrequency = TimeSpan.FromMinutes(15);
// ✅ NE İÇİN: Yüksek performans gerektiren sistemler
// 📊 CPU KULLANIMI: Çok düşük
// ⚡ AVANTAJ: Minimum CPU kullanımı
// ❌ DEZAVANTAJ: Expired entry'ler uzun süre memory'de kalır
// 5. Çok Yavaş Tarama (30 dakika)
options.ExpirationScanFrequency = TimeSpan.FromMinutes(30);
// ✅ NE İÇİN: CPU kritik sistemler
// 📊 CPU KULLANIMI: Minimal
// ⚡ AVANTAJ: Maksimum CPU tasarrufu
// ❌ DEZAVANTAJ: Memory leak riski
// 6. Taramayı Devre Dışı Bırak
options.ExpirationScanFrequency = TimeSpan.Zero;
// ❌ NEDEN TEHLİKELİ: Expired entry'ler hiç silinmez
// ✅ NE ZAMAN: Sadece özel durumlar için

📈 İstatistik ve İzleme Options (.NET 8.0+)

📊 TrackStatistics - İstatistik Toplama

• Ne İşe Yarar?
  • Cache hit/miss oranlarını takip eder
  • Performance monitoring için kritik veriler sağlar
  • Cache stratejinizi optimize etmenize yardım eder
  • Nasıl Çalışır?
  • Her cache operasyonunu sayar
  • Hit: Cache'den veri bulundu (başarılı)
  • Miss: Cache'de veri bulunamadı (başarısız)
  • Ratio = Hit / (Hit + Miss) (başarı oranı)
  • Pratik Örnek:
  • Hit Ratio %90: Cache çok iyi çalışıyor, veriler çoğunlukla cache'den geliyor
  • Hit Ratio %50: Cache orta düzeyde çalışıyor, yarı yarıya
  • Hit Ratio %10: Cache kötü çalışıyor, çoğunlukla database'den geliyor
  • Hit Ratio %0: Cache hiç çalışmıyor, tüm veriler database'den geliyor

bash
Kopyala
// 1. İstatistikleri Aktif Et
options.TrackStatistics = true;
// ✅ NE İÇİN: Production sistemleri, monitoring gerektiren uygulamalar
// 📊 VERİLER: Hit count, miss count, hit ratio
// ⚡ AVANTAJ: Performance analizi yapabilirsiniz
// 📈 ÖNERİ: Production'da mutlaka aktif edin
// 2. İstatistikleri Devre Dışı Bırak
options.TrackStatistics = false;
// ✅ NE İÇİN: Çok küçük uygulamalar, test ortamları
// 📊 VERİLER: Hiçbir istatistik toplanmaz
// ⚡ AVANTAJ: Hafif memory footprint
// ❌ DEZAVANTAJ: Performance analizi yapamazsınız
// KULLANIM ÖRNEĞİ:
var stats = memoryCache.GetCurrentStatistics();
if (stats != null)
{
  Console.WriteLine($"Cache Hit Count: {stats.TotalHits}");
  Console.WriteLine($"Cache Miss Count: {stats.TotalMisses}");
  double hitRatio = (double)stats.TotalHits / (stats.TotalHits + stats.TotalMisses);
  Console.WriteLine($"Cache Hit Ratio: {hitRatio:P2}");
  // Hit ratio %80'in altındaysa cache stratejinizi gözden geçirin
  if (hitRatio < 0.8)
  {
      Console.WriteLine("⚠️ Cache hit ratio düşük! Stratejinizi optimize edin.");
  }
}

🔗 TrackLinkedCacheEntries - Linked Entry Takibi

• Ne İşe Yarar?
  • Cache entry'leri arasındaki bağlantıları takip eder
  • Bir entry silindiğinde bağlı entry'leri de silmenizi sağlar
  • Cache invalidation stratejileri için kullanışlı
  • Nasıl Çalışır?
  • Entry'ler arasında parent-child ilişkisi kurar
  • Parent silindiğinde child'lar da silinir
  • Chain invalidation için idealdir
  • Pratik Örnek:
  • User silindiğinde → User'ın tüm cache'leri de silinir
  • Product silindiğinde → Product'ın tüm cache'leri de silinir
  • Category silindiğinde → Category'nin tüm cache'leri de silinir
  • Bu sayede tutarsız veri kalmaz, cache her zaman güncel kalır

bash
Kopyala
// 1. Linked Entry Tracking Aktif
options.TrackLinkedCacheEntries = true;
// ✅ NE İÇİN: Karmaşık cache stratejileri, dependency management
// 📊 ÖRNEK: User silindiğinde user'ın tüm cache'leri de silinir
// ⚡ AVANTAJ: Otomatik cleanup, tutarlılık
// ❌ DEZAVANTAJ: Hafif performance overhead
// 2. Linked Entry Tracking Devre Dışı
options.TrackLinkedCacheEntries = false;
// ✅ NE İÇİN: Basit cache stratejileri, performance kritik sistemler
// 📊 ÖRNEK: Her entry bağımsız olarak yönetilir
// ⚡ AVANTAJ: Maksimum performance
// ❌ DEZAVANTAJ: Manuel cleanup gerekir
// KULLANIM ÖRNEĞİ:
// User ve user'ın order'ları arasında link kurma
var userKey = "user:123";
var userOrdersKey = "user:123:orders";
// User'ı cache'le
memoryCache.Set(userKey, user, new MemoryCacheEntryOptions
{
  Size = 1,
  Priority = CacheItemPriority.Normal
});
// User'ın order'larını cache'le ve user'a link'le
memoryCache.Set(userOrdersKey, orders, new MemoryCacheEntryOptions
{
  Size = 1,
  Priority = CacheItemPriority.Normal,
  // User silindiğinde orders da silinir
  PostEvictionCallbacks = { new PostEvictionCallbackRegistration
  {
      EvictionCallback = (key, value, reason, state) =>
      {
          if (key.ToString() == userKey)
          {
              memoryCache.Remove(userOrdersKey);
          }
      }
  }}
});

⚡ Tüm Redis Cache Options Detayları

🔗 Temel Bağlantı Options

🌐 Configuration - Bağlantı String'i

• Ne İşe Yarar?
  • Redis sunucusuna nasıl bağlanacağınızı belirler
  • Tek satırda tüm bağlantı ayarlarını yapmanızı sağlar
  • En basit ve hızlı Redis konfigürasyon yöntemidir
  • Nasıl Çalışır?
  • Connection string formatı: host:port[,options]
  • Virgülle ayrılmış key-value çiftleri
  • Redis client bu string'i parse eder ve bağlantı kurar
  • Pratik Örnek:
  • localhost:6379 → Local Redis'e bağlanır
  • redis.company.com:6380,ssl=true,password=mykey → Güvenli remote bağlantı
  • redis1:6379,redis2:6379,redis3:6379 → Cluster'a bağlanır
  • Environment variable kullanarak güvenli hale getirin

bash
Kopyala
// 1. Basit Local Bağlantı
options.Configuration = "localhost:6379";
// ✅ NE İÇİN: Development, test ortamları
// 📊 ÖZELLİKLER: Şifresiz, SSL yok, default port
// ⚡ AVANTAJ: En basit kurulum
// ❌ DEZAVANTAJ: Güvenlik yok, sadece local
// 2. Şifreli Local Bağlantı
options.Configuration = "localhost:6379,password=mypassword";
// ✅ NE İÇİN: Development, küçük production sistemleri
// 📊 ÖZELLİKLER: Authentication var, SSL yok
// ⚡ AVANTAJ: Basit güvenlik
// 🔐 GÜVENLİK: Şifre connection string'de (environment variable kullanın!)
// 3. SSL Remote Bağlantı
options.Configuration = "redis.company.com:6380,ssl=true,password=mykey";
// ✅ NE İÇİN: Production sistemleri, cloud Redis
// 📊 ÖZELLİKLER: SSL/TLS encryption, authentication
// ⚡ AVANTAJ: Güvenli bağlantı
// 📈 ÖNERİ: Production için ideal
// ✅ NE İÇİN: Yüksek availability gerektiren sistemler
// 📊 ÖZELLİKLER: Multiple endpoints, failover support
// ⚡ AVANTAJ: High availability
// ❌ DEZAVANTAJ: Karmaşık setup
// ✅ NE İÇİN: Azure cloud uygulamaları
// 📊 ÖZELLİKLER: Managed Redis, SSL, authentication
// ⚡ AVANTAJ: Managed service, otomatik backup
// 💰 MALİYET: Azure pricing
// ✅ NE İÇİN: AWS cloud uygulamaları
// 📊 ÖZELLİKLER: AWS managed Redis, SSL
// ⚡ AVANTAJ: AWS integration, auto-scaling
// 💰 MALİYET: AWS pricing
// ✅ NE İÇİN: Production sistemleri
// 📊 ÖZELLİKLER: Güvenli credential management
// ⚡ AVANTAJ: Şifreler kodda yok
// 📈 ÖNERİ: En güvenli yöntem

🏷️ InstanceName - Key Prefix Sistemi

• Ne İşe Yarar?
• Redis'teki tüm key'lerin başına prefix ekler
• Farklı uygulamaların aynı Redis'i kullanmasını sağlar
• Key collision'larını önler
• Nasıl Çalışır?
• Uygulama: "user:123" key'i kullanır
• Redis'te gerçek key: "MyApp:user:123" olur
• InstanceName + ":" + OriginalKey formatı
• Pratik Örnek:
• MyApp:user:123 → Web uygulamasının user cache'i
• MyApp-API:user:123 → API uygulamasının user cache'i
• MyApp-BG:user:123 → Background service'in user cache'i
• Hepsi aynı Redis'te ama birbirini etkilemez

bash
Kopyala
// 1. Production Prefix
options.InstanceName = "MyApp";
// ✅ NE İÇİN: Production ortamları
// 📊 ÖRNEK: user:123 → MyApp:user:123
// ⚡ AVANTAJ: Temiz ve anlaşılır
// 📈 ÖNERİ: Production için ideal
// 2. Development Prefix
options.InstanceName = "MyApp-Dev";
// ✅ NE İÇİN: Development ortamları
// 📊 ÖRNEK: user:123 → MyApp-Dev:user:123
// ⚡ AVANTAJ: Dev/Prod ayrımı
// 🔍 DEBUGGING: Redis'te hangi key'in dev'e ait olduğu belli
// 3. Test Prefix
options.InstanceName = "MyApp-Test";
// ✅ NE İÇİN: Test ortamları
// 📊 ÖRNEK: user:123 → MyApp-Test:user:123
// ⚡ AVANTAJ: Test verileri ayrı
// 🧪 TESTING: Test verileri production'ı etkilemez
// 4. Staging Prefix
options.InstanceName = "MyApp-Staging";// ✅ NE İÇİN: Staging ortamları
// 📊 ÖRNEK: user:123 → MyApp-Staging:user:123
// ⚡ AVANTAJ: Pre-production testing
// ✅ NE İÇİN: Multi-tenant uygulamalar
// 📊 ÖRNEK: user:123 → MyApp-TenantA:user:123
// ⚡ AVANTAJ: Tenant isolation
// Web API: MyApp-API:user:123
// Background Service: MyApp-BG:user:123
// Admin Panel: MyApp-Admin:user:123

⚙️ Gelişmiş Konfigürasyon Options

🔧 ConfigurationOptions - Detaylı Redis Ayarları

• Ne İşe Yarar?
  • Connection string'den daha detaylı Redis konfigürasyonu sağlar
  • Programmatic olarak tüm Redis ayarlarını kontrol etmenizi sağlar
  • Karmaşık Redis setup'ları için gereklidir
  • Nasıl Çalışır?
  • Configuration property'si yerine kullanılır
  • Daha fazla kontrol ve esneklik sağlar
  • Type-safe configuration yöntemidir

bash
Kopyala
options.ConfigurationOptions = new ConfigurationOptions
{
  // 🌐 BAĞLANTI YÖNETİMİ
  EndPoints = {
      "redis1.company.com:6379",
      "redis2.company.com:6379",
      "redis3.company.com:6380"
  },
  // ✅ NE İÇİN: Redis cluster, high availability
  // 📊 ÖZELLİKLER: Multiple server support, failover
  // ⚡ AVANTAJ: Bir server down olsa diğerleri çalışır
  // ❌ DEZAVANJ: Karmaşık setup gerektirir
  Password = Environment.GetEnvironmentVariable("REDIS_PASSWORD"),
  // ✅ NE İÇİN: Production sistemleri
  // 📊 ÖZELLİKLER: Güvenli credential management
  // ⚡ AVANTAJ: Şifre kodda yok
  // 📈 ÖNERİ: Environment variable kullanın
  Database =  // ✅ NE İÇİN: Veri organizasyonu
  // ⚡ AVANTAJ: Sync operasyonlar için optimize
  // 📈 ÖNERİ: Async operasyonlar tercih edin
  // ✅ NE İÇİN: Asynchronous Redis operasyonları
  // ✅ NE İÇİN: Custom SSL sertifikaları
  // 📊 ÖZELLİKLER: Certificate validation
  // ⚡ AVANTAJ: Man-in-the-middle saldırılarına karşı koruma
  // 📈 ÖNERİ: Wildcard sertifikalar için kullanın
  // ✅ NE İÇİN: Production güvenliği
  // 📊 ETKİ: FLUSHDB, CONFIG gibi admin komutları engellenir
  // ⚡ AVANTAJ: Güvenlik riski azalır
  // ⚡ PERFORMANS
  // ✅ NE İÇİN: Uzun süreli bağlantılar
  // ✅ NE İÇİN: Database seçimi
  // 📊 ETKİ: Bağlantı kurulduğunda otomatik bu database seçilir
  // ⚡ AVANTAJ: Her seferinde SELECT komutu çalıştırmaya gerek yok
  // ✅ NE İÇİN: Monitoring ve debugging
  // ✅ NE İÇİN: Network partition durumları
  // 📊 ETKİ: Hangi master'ın aktif olacağını belirler
  // ⚡ AVANTAJ: Data consistency
  // 📈 ÖNERİ: Sentinel ile birlikte kullanın
  // 🌐 NETWORK
  // ✅ NE İÇİN: Dynamic DNS environments
  // 📊 ETKİ: DNS değişikliklerini otomatik takip eder
  // ⚡ AVANTAJ: IP değişikliklerinde otomatik adaptasyon
  // 📈 ÖNERİ: Cloud environments için ideal
  // ✅ NE İÇİN: Performance optimization
  // 📊 ETKİ: SSL sertifika iptal listesi kontrol edilmez
  // ⚡ AVANTAJ: Daha hızlı SSL handshake
  // ❌ DEZAVANJ: İptal edilmiş sertifikalar tespit edilmez

🎯 Farklı Senaryolar İçin ConfigurationOptions Örnekleri

bash
Kopyala
options.ConfigurationOptions = new ConfigurationOptions
{
  EndPoints = { "localhost:6379" },
  ConnectTimeout = 2000,        // Hızlı bağlantı
  SyncTimeout = 2000,           // Hızlı sync
  AsyncTimeout = 3000,          // Hızlı async
  ConnectRetry = 2,             // Az retry
  AbortOnConnectFail = true,    // Hızlı hata tespiti
  Ssl = false,                  // SSL yok (local)
  KeepAlive = 60,              // Kısa keep-alive
  ClientName = "MyApp-Dev"
};

bash
Kopyala
options.ConfigurationOptions = new ConfigurationOptions
{
  EndPoints = {
      "redis1.prod.company.com:6379",
      

bash
Kopyala
options.ConfigurationOptions = new ConfigurationOptions
{
  EndPoints = { "redis-cluster.company.com:6379" },
  Password =

🏭 Factory ve Profiling Options

bash
Kopyala
// Özel bağlantı mantığı
options.ConnectionMultiplexerFactory = async () =>
{
  var config = new ConfigurationOptions
  {
      EndPoints = { GetRedisEndpoint() }, // Dynamic endpoint
      Password = await GetRedisPasswordFromVault(), // Güvenli şifre alma
      ConnectTimeout = 5000,
      ConnectRetry = 3
  };
  // Custom retry logic
  var multiplexer = await ConnectionMultiplexer.ConnectAsync(config);
  // Connection event handlers
  multiplexer.ConnectionFailed += (sender, args) =>
  {
      Console.WriteLine($"Redis connection failed: {args.Exception}");
  };
  multiplexer.ConnectionRestored += (sender, args) =>
  {
      Console.WriteLine("Redis connection restored");
  };
  return multiplexer;
};

bash
Kopyala
// Redis komut profiling'i
options.ProfilingSession = () =>
{
  return new ProfilingSession(); // Her request için yeni session
// Kullanım:

🎯 Environment-Specific Optimal Konfigürasyonlar

🔧 Development Environment

bash
Kopyala
// Memory Cache - Development
options.SizeLimit = 100;
options.CompactionPercentage = 0.5;
options.ExpirationScanFrequency = TimeSpan.FromMinutes(1);
options.TrackStatistics = true;
// Redis Cache - Development
options.Configuration = "localhost:6379";
options.InstanceName = "MyApp-Dev";
options.ConfigurationOptions.ConnectTimeout = 2000;
options.ConfigurationOptions.SyncTimeout = 2000;

🚀 Production Environment

bash
Kopyala
// Memory Cache - Production
options.SizeLimit = 5000;
options.CompactionPercentage = 0.25;
options.ExpirationScanFrequency = TimeSpan.FromMinutes(10);
options.TrackStatistics = true;
// Redis Cache - Production
options.Configuration = "redis-cluster.company.com:6379,ssl=true";
options.InstanceName = "MyApp-Prod";
options.ConfigurationOptions.ConnectRetry = 5;
options.ConfigurationOptions.ReconnectRetryPolicy = new ExponentialRetry(1000);
options.ConfigurationOptions.KeepAlive = 300;

⚡ High Performance Environment

bash
Kopyala
// Memory Cache - High Performance
options.SizeLimit = 20000;
options.CompactionPercentage = 0.1;
options.ExpirationScanFrequency = TimeSpan.FromMinutes(30);
options.TrackLinkedCacheEntries = false; // Performance için devre dışı
// Redis Cache - High Performance
options.ConfigurationOptions.AsyncTimeout = 1000;
options.ConfigurationOptions.SyncTimeout = 1000;
options.ConfigurationOptions.ConnectTimeout = 1000;
options.ConfigurationOptions.KeepAlive = 60;

📋 Cache Konfigürasyon Parametreleri Detayları

🧠 In-Memory Cache Parametreleri

🔄 Redis Distributed Cache Parametreleri

text
Kopyala
// InstanceName = "MyApp" olduğunda:
Uygulama cache key'i: "user:123"
Redis'teki gerçek key: "MyApp:user:123"
// Başka bir uygulama InstanceName = "BlogApp" kullanırsa:
Uygulama cache key'i: "user:123"
Redis'teki gerçek key: "BlogApp:user:123"
// Bu sayede iki uygulama aynı Redis'i kullanabilir

csharp
Kopyala
// Basit bağlantı
"Redis": "localhost:6379"
// Authentication ile
"Redis": "localhost:6379,password=mypassword"
// Cluster setup
"Redis": "redis1:6379,redis2:6379,redis3:6379"
// SSL ile
"Redis": "myredis.cache.windows.net:6380,ssl=true,password=mykey"

⚙️ Optimal Değerler ve Best Practice'ler

text
Kopyala
SizeLimit = 256 (küçük memory footprint)
CompactionPercentage = 0.5 (agresif temizlik)
ExpirationScanFrequency = 1 dakika (hızlı cleanup)

text
Kopyala
SizeLimit = 2048 veya daha fazla (yeterli capacity)
CompactionPercentage = 0.25 (balanced cleanup)
ExpirationScanFrequency = 5 dakika (CPU friendly)

text
Kopyala
SizeLimit = null (Redis'e güven, memory cache minimal)
CompactionPercentage = 0.1 (minimal disruption)
ExpirationScanFrequency = 10 dakika (performance priority)

⚙️ appsettings.json Konfigürasyonu

json
Kopyala
{
"ConnectionStrings": {
  "Redis": "localhost:6379"
},
"CacheSettings": {
  "DefaultExpirationMinutes": 30,
  "UseDistributedCache": true,
  "RedisSettings": {
    "Host": "localhost",
    "Port": 6379,
    "Password": "",
    "Database": 0,
    "ConnectTimeout": 5000,
    "SyncTimeout": 5000
  },
  "MemoryCacheSettings": {
    "SizeLimit": 1024,
    "CompactionPercentage": 0.25,
    "ExpirationScanFrequencyMinutes": 5
  }
}
}

🏢 Monolit Mimaride Cache Implementasyonu

📁 Klasör Yapısı

text
Kopyala
MyApp/
├── Controllers/
├── Services/
│   ├── Interfaces/
│   │   └── ICacheService.cs
│   └── CacheService.cs
├── Models/
├── Configuration/
│   └── CacheConfiguration.cs
└── Extensions/
  └── ServiceCollectionExtensions.cs

🛠️ Cache Service Interface

bash
Kopyala
// Services/Interfaces/ICacheService.cs
public interface ICacheService
{
  Task<T?> GetAsync<T>(string key) where T : class;
  Task SetAsync<T>(string key, T value, TimeSpan? expiration = null) where T : class;
  Task RemoveAsync(string key);
  Task RemoveByPatternAsync(string pattern);
  Task<bool> ExistsAsync(string key);
  Task<IEnumerable<string>> GetKeysAsync(string pattern);
  Task ClearAllAsync();
}

🔨 Hybrid Cache Service Implementation

bash
Kopyala
// Services/CacheService.cs
using Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.Caching.Distributed;
using System.Text.Json;
public class CacheService : ICacheService
{
  private readonly IMemoryCache _memoryCache;
  private readonly IDistributedCache _distributedCache;
  private readonly IConfiguration _configuration;
  private readonly ILogger<CacheService>      IMemoryCache memoryCache,
      IDistributedCache distributedCache,
      IConfiguration configuration,
      try
      try
      try
          // Memory cache tamamen temizlenir

🔌 Service Registration Extension

bash
Kopyala
// Extensions/ServiceCollectionExtensions.cs
public static class ServiceCollectionExtensions
{
  public static IServiceCollection AddCachingServices(
      this IServiceCollection services,
      IConfiguration configuration)
  {
      // Cache ayarlarını configuration'dan al
      var cacheSettings = configuration.GetSection("CacheSettings");
      var useDistributedCache = cacheSettings.GetValue<bool>("UseDistributedCache");
      // Memory Cache her zaman eklenir (L1 Cache olarak)
      services.AddMemoryCache(options =>
      {
          var memoryCacheSettings = cacheSettings.GetSection("MemoryCacheSettings");
          options.SizeLimit = memoryCacheSettings.GetValue<int>("SizeLimit", 1024);
          options.CompactionPercentage = memoryCacheSettings.GetValue<double>("CompactionPercentage", 0.25);
          options.ExpirationScanFrequency = TimeSpan.FromMinutes(
              memoryCacheSettings.GetValue<int>("ExpirationScanFrequencyMinutes", 5));

📚 Shared Klasöründe Organize Yapı

📁 Shared Klasör Yapısı

text
Kopyala
Shared/
├── Caching/
│   ├── Interfaces/
│   │   ├── ICacheService.cs
│   │   ├── ICacheKeyGenerator.cs
│   │   ├── ICacheConfiguration.cs
│   │   └── ICacheMetricsService.cs
│   ├── Services/
│   │   ├── MemoryCacheService.cs
│   │   ├── RedisCacheService.cs
│   │   ├── HybridCacheService.cs
│   │   ├── CacheKeyGenerator.cs
│   │   └── CacheMetricsService.cs
│   ├── Configuration/
│   │   ├── CacheSettings.cs
│   │   ├── RedisCacheOptions.cs
│   │   └── MemoryCacheOptions.cs
│   ├── Extensions/
│   │   ├── CacheServiceCollectionExtensions.cs
│   │   └── CacheServiceProviderExtensions.cs
│   ├── Attributes/
│   │   ├── CacheableAttribute.cs
│   │   └── CacheEvictAttribute.cs
│   ├── Middleware/
│   │   └── CacheMiddleware.cs
│   └── Exceptions/
│       ├── CacheException.cs
│       └── CacheConnectionException.cs

🏗️ Cache Key Generator

bash
Kopyala
// Shared/Caching/Interfaces/ICacheKeyGenerator.cs
public interface ICacheKeyGenerator
{
  string GenerateKey(string prefix, params object[] parameters);
  string GenerateUserSpecificKey(string userId, string prefix, params object[] parameters);
  string GenerateEntityKey<T>(object id) where T : class;
  string GenerateListKey// Shared/Caching/Services/CacheKeyGenerator.cs
      // Redis key naming restrictions

🎯 Cacheable Attribute

bash
Kopyala
// Shared/Caching/Attributes/CacheableAttribute.cs
[AttributeUsage(AttributeTargets.Method)]
public class CacheableAttribute : Attribute
{
  public string? KeyPrefix { get; set; }
  public int ExpirationMinutes { get; set; } = 30;
  public bool UseDistributedCache { get; set; } = true;
  public string[]? Tags { get; set; }
  public CacheItemPriority Priority { get; set; } = CacheItemPriority.Normal;
  public bool IncludeParameters { get; set; } = true;
  /// <summary>
  /// Cache condition expression (SpEL benzeri)
  /// Örnek: "args[0] != null && args[0].IsActive"
  /// </summary>
  public string? Condition { get; set; }
}
// Shared/Caching/Attributes/CacheEvictAttribute.cs
[AttributeUsage(AttributeTargets.Method)]
public class CacheEvictAttribute : Attribute
{
  public string? KeyPrefix { get; set; }
  public string[]? Keys { get; set; }
  public string[]? Tags { get; set; }
  public bool AllEntries { get; set; } = false;
  public bool BeforeInvocation { get; set; } = false;
}

🧅 Onion Architecture'de Cache Implementasyonu

📁 Onion Architecture Klasör Yapısı

text
Kopyala
MyApp/
├── Core/
│   ├── Domain/
│   │   ├── Entities/
│   │   ├── ValueObjects/
│   │   └── Events/
│   └── Application/
│       ├── Interfaces/
│       │   ├── Repositories/
│       │   └── Services/
│       │       ├── ICacheService.cs
│       │       └── ICacheKeyService.cs
│       ├── Services/
│       ├── DTOs/
│       └── UseCases/
├── Infrastructure/
│   ├── Persistence/
│   └── Caching/
│       ├── Services/
│       │   ├── RedisCacheService.cs
│       │   ├── MemoryCacheService.cs
│       │   └── CacheKeyService.cs
│       └── Configuration/
│           └── CacheConfiguration.cs
└── Presentation/
  └── WebAPI/
      ├── Controllers/
      └── Middleware/

🎯 Application Layer Interface

bash
Kopyala
// Core/Application/Interfaces/Services/ICacheService.cs
namespace MyApp.Core.Application.Interfaces.Services;
public interface ICacheService
{
  Task<T?> GetAsync<T>(string key, CancellationToken cancellationToken = default) where T : class;
  Task<T> GetOrSetAsync<T>(string key, Func<Task<T>> getItem, TimeSpan? expiration = null, CancellationToken cancellationToken = default// Core/Application/Interfaces/Services/ICacheKeyService.cs
public interface ICacheKeyService

🏗️ Infrastructure Layer Implementation

bash
Kopyala
// Infrastructure/Caching/Services/RedisCacheService.cs
using MyApp.Core.Application.Interfaces.Services;
using Microsoft.Extensions.Caching.Distributed;
using System.Text.Json;
namespace MyApp.Infrastructure.Caching.Services;
public class RedisCacheService : ICacheService
{
  private readonly IDistributedCache _distributedCache;
  private readonly ILogger<RedisCacheService> _logger;
  private readonly JsonSerializerOptions _jsonOptions      IDistributedCache distributedCache,
      try
      try
      try
      try
      try
          // Redis tag-based invalidation için Redis Set kullanılabilir
          // Bu implementasyon StackExchange.Redis ile özel tag management gerektirir
      try
      try

🔑 Cache Key Service Implementation

bash
Kopyala
// Infrastructure/Caching/Services/CacheKeyService.cs
using MyApp.Core.Application.Interfaces.Services;
using MyApp.Core.Domain.Common;
namespace MyApp.Infrastructure.Caching.Services;
public class CacheKeyService : ICacheKeyService
{
  private const string SEPARATOR = ":";
  private readonly string _applicationPrefix;
  private readonly string _environmentPrefix;
  public CacheKeyService(IConfiguration configuration)

🗄️ Repository Design Pattern'da Cache Kullanımı

🎯 Generic Repository Interface

bash
Kopyala
// Core/Application/Interfaces/Repositories/IRepository.cs
using MyApp.Core.Domain.Common;
namespace MyApp.Core.Application.Interfaces.Repositories;
public interface IRepository<TEntity> where TEntity : BaseEntity
{
  // Read Operations
  Task<TEntity?> GetByIdAsync(int id, bool useCache = true, CancellationToken cancellationToken = default);
  Task<IEnumerable<TEntity>>  // Write Operations
  // Query Operations
// Core/Application/Interfaces/Repositories/IUserRepository.cs

🏗️ Repository Implementation with Caching

bash
Kopyala
// Infrastructure/Persistence/Repositories/UserRepository.cs
using MyApp.Core.Application.Interfaces.Repositories;
using MyApp.Core.Application.Interfaces.Services;
using MyApp.Core.Domain.Entities;
using Microsoft.EntityFrameworkCore;
using System.Linq.Expressions;
namespace MyApp.Infrastructure.Persistence.Repositories;
public class UserRepository : IUserRepository
{
  private readonly ApplicationDbContext _context;
  private readonly ICacheService _cacheService;
  private   // Cache expiration strategies
      ApplicationDbContext context,
      ICacheService cacheService,
      ICacheKeyService cacheKeyService,

🎯 Best Practices ve Öneriler

✅ Cache Best Practices

🚫 Cache Anti-Patterns

🔧 Configuration Best Practices

bash
Kopyala
// Optimal Configuration Örneği
public class CacheConfiguration
{
  public class MemoryCacheConfig
  {
      public int SizeLimit { get; set; } = 1024;
      public double CompactionPercentage { get; set; } = 0.25;
      public TimeSpan ExpirationScanFrequency   public class RedisCacheConfig
  public class CacheSettings
  public class CacheStrategies

📊 Performance Monitoring

bash
Kopyala
// Cache Metrics Service
public interface ICacheMetricsService
{
  void RecordCacheHit(string cacheType, string operation, TimeSpan duration);
  void RecordCacheMiss(string cacheType, string operation);
  void RecordCacheSetTime(string cacheType, string operation, TimeSpan duration);
  void RecordCacheError(string cacheType, string operation, Exception exception);
  Task<CacheStatistics> GetStatisticsAsync(TimeSpan timeWindow  private class CacheOperationStats
public class CacheStatistics

🎉 Sonuç

🔑 Önemli Takeaway'ler: