C# Kullanarak In-Memory Caching ve (Redis)Distributed Caching Uygulaması

🎯 Bu Rehberde Öğrenecekleriniz

🚀 Temel Kurulumlar

📦 Gerekli NuGet Paketleri

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

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

🔧 Program.cs Temel Yapılandırması

bash
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 = 0.25; // Temizlik oranı (%25)
  options.ExpirationScanFrequency = TimeSpan.FromMinutes(5); // Temizlik sıklığı
  // İSTATİSTİK VE İZLEME
  options.TrackStatistics = true; // Cache istatistiklerini topla (.NET 8.0+)
  options.TrackLinkedCacheEntries = true; // Linked entry'leri takip et (.NET 8.0+)
});
// Redis Distributed Cache Konfigürasyonu - TÜM OPTIONS
builder.Services.AddStackExchangeRedisCache(options =>
{
  // TEMEL BAĞLANTI YÖNETİMİ
  options.Configuration = builder.Configuration.GetConnectionString("Redis");
  options.InstanceName = "MyApp"; // Redis instance adı (key prefix)
  // GELİŞMİŞ KONFIGÜRASYON
  options.ConfigurationOptions = new ConfigurationOptions
  {
      EndPoints = { "localhost:6379", "localhost:6380" }, // Cluster endpoints
      Password = "mypassword", // Authentication
      Database = 0, // Redis database numarası
      ConnectTimeout = 5000, // Bağlantı timeout (ms)
      SyncTimeout = 5000, // Sync operation timeout (ms)
      AsyncTimeout = 5000, // Async operation timeout (ms)
      ConnectRetry = 3, // Bağlantı retry sayısı
      AbortOnConnectFail = false, // Bağlantı hatada abort etme
      AllowAdmin = false, // Admin komutlarına izin
      Ssl = false, // SSL kullanımı
      SslHost = null, // SSL host adı
      ClientName = "MyApp-Cache", // Client identifier
      CommandMap = CommandMap.Default, // Komut mapping
      DefaultDatabase = 0, // Varsayılan database
      KeepAlive = 60, // Keep-alive interval (saniye)
      ReconnectRetryPolicy = new ExponentialRetry(1000), // Reconnect stratejisi
      ResolveDns = true, // DNS çözümleme
      ServiceName = null, // Sentinel service name
      TieBreaker = "__Booksleeve_TieBreaker", // Tie-breaker key
      Version = RedisVersion.Default // Redis version
  };
  // FACTORY YÖNETİMİ
  options.ConnectionMultiplexerFactory = async () =>
  {
      var config = ConfigurationOptions.Parse("localhost:6379");
      config.ReconnectRetryPolicy = new ExponentialRetry(1000);
      return await ConnectionMultiplexer.ConnectAsync(config);
  };
  // PROFILING VE İZLEME
  options.ProfilingSession = () => new ProfilingSession();
});
var app = builder.Build();

🔧 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
  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
  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
  cache.Set("kavanoz1", data1, new MemoryCacheEntryOptions { Size = 3 }); 
  cache.Set("kavanoz2", data2, new MemoryCacheEntryOptions { Size = 4 }); 
  cache.Set("kavanoz3", data3, new MemoryCacheEntryOptions { Size = 3 }); 
  // Toplam: 3 + 4 + 3 = 10 birim ✅

  Her şey güzel gidiyor. Dolap tamamen doldu. Ama sonra bir eşya daha eklemeye çalışıyoruz:

  bash
  // Toplam: 3 + 4 + 3 = 10 birim Doldurmuştuk.
  cache.Set("kavanoz4", data4, new MemoryCacheEntryOptions { Size = 2 }); 
  // Toplam 12 olacak ❌

• ⛔️ 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
// 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
// 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
// 1. Küçük Veri (1KB - 1 birim)
cache.Set("user-settings", userSettings, new MemoryCacheEntryOptions
{
  Size = 1,
  AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(1)
});
// 2. Orta Boyut Veri (100KB - 100 birim)
cache.Set("product-list", productList, new MemoryCacheEntryOptions
{
  Size = 100,
  AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(30)
});
// 3. Büyük Veri (1MB - 1000 birim)
cache.Set("large-report", reportData, new MemoryCacheEntryOptions
{
  Size = 1000,
  AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(10)
});
// 4. Çok Büyük Veri (10MB - 10000 birim)
cache.Set("database-backup", backupData, new MemoryCacheEntryOptions
{
  Size = 10000,
  AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(5)
});

bash
// ❌ SetSize olmadan (adil değil)
cache.Set("tiny-data", tinyData); // 1 birim (gerçekte 1KB)
cache.Set("huge-data", hugeData); // 1 birim (gerçekte 10MB)
// Her ikisi de aynı değer, ama memory kullanımları çok farklı!
// ✅ SetSize ile (adil)
cache.Set("tiny-data", tinyData, new MemoryCacheEntryOptions { Size = 1 });
cache.Set("huge-data", hugeData, new MemoryCacheEntryOptions { Size = 10000 });
// Gerçek memory kullanımına göre sayım

bash
// Senaryo 1: SizeLimit = 1000, SetSize kullanılmıyor
// 1000 entry eklenebilir (hepsi 1 birim)
// Ama memory kullanımı çok farklı olabilir
// Senaryo 2: SizeLimit = 1000, SetSize kullanılıyor
// Toplam 1000 birim eklenebilir
// 1 büyük entry (1000 birim) VEYA
// 1000 küçük entry (her biri 1 birim) VEYA
// Karışık boyutlarda entry'ler
// Senaryo 3: Gerçekçi örnek
cache.Set("user-123", userData, new MemoryCacheEntryOptions { Size = 50 });
cache.Set("products", productList, new MemoryCacheEntryOptions { Size = 200 });
cache.Set("categories", categoryList, new MemoryCacheEntryOptions { Size = 100 });
cache.Set("orders", orderList, new MemoryCacheEntryOptions { Size = 500 });
// Toplam: 850 birim (limit 1000'den altında)

🧹 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
// 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
// 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
// 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
// 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
// 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
// 4. Redis Cluster Bağlantı
options.Configuration = "redis1:6379,redis2:6379,redis3:6379";
// ✅ NE İÇİN: Yüksek availability gerektiren sistemler
// 📊 ÖZELLİKLER: Multiple endpoints, failover support
// ⚡ AVANTAJ: High availability
// ❌ DEZAVANTAJ: Karmaşık setup
// 5. Azure Redis Cache
options.Configuration = "myredis.redis.cache.windows.net:6380,ssl=true,password=mykey";
// ✅ NE İÇİN: Azure cloud uygulamaları
// 📊 ÖZELLİKLER: Managed Redis, SSL, authentication
// ⚡ AVANTAJ: Managed service, otomatik backup
// 💰 MALİYET: Azure pricing
// 6. AWS ElastiCache
options.Configuration = "mycluster.xxxxx.cache.amazonaws.com:6379,ssl=true";
// ✅ NE İÇİN: AWS cloud uygulamaları
// 📊 ÖZELLİKLER: AWS managed Redis, SSL
// ⚡ AVANTAJ: AWS integration, auto-scaling
// 💰 MALİYET: AWS pricing
// 7. Environment Variable ile Güvenli Bağlantı
options.Configuration = Environment.GetEnvironmentVariable("REDIS_CONNECTION_STRING");
// ✅ 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
// 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
// 🔄 DEPLOYMENT: Production'a geçmeden önce test
// 5. Machine Specific Prefix
options.InstanceName = $"MyApp-{Environment.MachineName}";
// ✅ NE İÇİN: Multi-server deployment
// 📊 ÖRNEK: user:123 → MyApp-SERVER01:user:123
// ⚡ AVANTAJ: Hangi server'ın hangi key'i kullandığı belli
// 🔍 DEBUGGING: Server-specific troubleshooting
// 6. Environment Variable ile Dynamic Prefix
options.InstanceName = Environment.GetEnvironmentVariable("REDIS_INSTANCE_NAME") ?? "MyApp";
// ✅ NE İÇİN: Flexible deployment
// 📊 ÖRNEK: Environment variable ile prefix değiştirilebilir
// ⚡ AVANTAJ: Deployment-time configuration
// 📈 ÖNERİ: CI/CD pipeline'ları için ideal
// 7. Multi-tenant Prefix
options.InstanceName = $"MyApp-{tenantId}";
// ✅ NE İÇİN: Multi-tenant uygulamalar
// 📊 ÖRNEK: user:123 → MyApp-TenantA:user:123
// ⚡ AVANTAJ: Tenant isolation
// 🔐 SECURITY: Tenant'lar birbirinin verilerini göremez
// PRATİK ÖRNEK - Aynı Redis'te Farklı Uygulamalar:
// Web API: MyApp-API:user:123
// Background Service: MyApp-BG:user:123
// Admin Panel: MyApp-Admin:user:123
// Hepsi aynı Redis'te ama birbirini etkilemez!

⚙️ 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
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 = 2, // Farklı database kullan
  // ✅ NE İÇİN: Veri organizasyonu
  // 📊 ÖZELLİKLER: 0-15 arası database numarası
  // ⚡ AVANTAJ: Farklı veri türleri ayrı database'lerde
  // 📈 ÖNERİ: Cache için 0, session için 1, analytics için 2
  // ⏱️ TIMEOUT YÖNETİMİ
  ConnectTimeout = 10000,      // 10 saniye bağlantı timeout
  // ✅ NE İÇİN: Yavaş network bağlantıları
  // 📊 ETKİ: İlk bağlantı kurma süresi
  // ⚡ AVANTAJ: Network sorunlarında sabırlı
  // ❌ DEZAVANJ: Yavaş bağlantı tespiti
  SyncTimeout = 8000,          // 8 saniye sync timeout
  // ✅ NE İÇİN: Synchronous Redis operasyonları
  // 📊 ETKİ: GET, SET gibi sync komutların timeout'u
  // ⚡ AVANTAJ: Sync operasyonlar için optimize
  // 📈 ÖNERİ: Async operasyonlar tercih edin
  AsyncTimeout = 12000,        // 12 saniye async timeout
  // ✅ NE İÇİN: Asynchronous Redis operasyonları
  // 📊 ETKİ: Async GET, SET komutlarının timeout'u
  // ⚡ AVANTAJ: Async operasyonlar için optimize
  // 📈 ÖNERİ: Modern .NET uygulamaları için ideal
  // 🔄 RETRY VE RECONNECTION
  ConnectRetry = 5,            // 5 kez bağlantı dene
  // ✅ NE İÇİN: Network instability durumları
  // 📊 ETKİ: İlk bağlantı başarısız olursa 5 kez dener
  // ⚡ AVANTAJ: Geçici network sorunlarında dayanıklı
  // ❌ DEZAVANJ: Başarısız bağlantılar için daha uzun bekleme
  ReconnectRetryPolicy = new LinearRetry(1000), // Her 1 saniyede retry
  // ✅ NE İÇİN: Bağlantı koptuğunda yeniden bağlanma
  // 📊 ETKİ: Her 1 saniyede bir retry yapar
  // ⚡ AVANTAJ: Hızlı reconnection
  // 📈 ALTERNATİF: new ExponentialRetry(1000) - exponential backoff
  AbortOnConnectFail = false,  // İlk bağlantı hatada devam et
  // ✅ NE İÇİN: High availability gerektiren sistemler
  // 📊 ETKİ: İlk bağlantı başarısız olsa bile devam eder
  // ⚡ AVANTAJ: Cluster'da diğer node'ları dener
  // ❌ DEZAVANJ: Başarısız bağlantılar için daha uzun bekleme
  // 🔐 GÜVENLİK
  Ssl = true,                  // SSL/TLS kullan
  // ✅ NE İÇİN: Production sistemleri, cloud Redis
  // 📊 ÖZELLİKLER: Encrypted connection
  // ⚡ AVANTAJ: Veri güvenliği
  // 📈 ÖNERİ: Production'da mutlaka aktif edin
  SslHost = "*.redis.company.com", // SSL sertifika host
  // ✅ 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
  AllowAdmin = false,          // Admin komutlarını engelle
  // ✅ NE İÇİN: Production güvenliği
  // 📊 ETKİ: FLUSHDB, CONFIG gibi admin komutları engellenir
  // ⚡ AVANTAJ: Güvenlik riski azalır
  // 📈 ÖNERİ: Sadece gerekli durumlarda true yapın
  // ⚡ PERFORMANS
  KeepAlive = 180,            // 3 dakika keep-alive
  // ✅ NE İÇİN: Uzun süreli bağlantılar
  // 📊 ETKİ: Her 3 dakikada bir keep-alive paketi gönderir
  // ⚡ AVANTAJ: Firewall timeout'larını önler
  // 📈 ÖNERİ: Network timeout'larına göre ayarlayın
  DefaultDatabase = 0,         // Varsayılan database
  // ✅ 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
  // 📈 ÖNERİ: Cache için 0, session için 1 kullanın
  ClientName = "MyApp-WebAPI", // Client identifier
  // ✅ NE İÇİN: Monitoring ve debugging
  // 📊 ETKİ: Redis'te CLIENT LIST komutunda görünür
  // ⚡ AVANTAJ: Hangi uygulamanın bağlı olduğu belli
  // 📈 ÖNERİ: Anlamlı isimler verin
  // 🏰 SENTINEL SUPPORT
  ServiceName = "mymaster",    // Sentinel service adı
  // ✅ NE İÇİN: Redis Sentinel high availability
  // 📊 ETKİ: Sentinel cluster'da hangi master'ı takip edeceği
  // ⚡ AVANTAJ: Automatic failover
  // 📈 ÖNERİ: Sentinel setup'ları için gerekli
  TieBreaker = "tiebreaker",   // Split-brain önleme
  // ✅ NE İÇİN: Network partition durumları
  // 📊 ETKİ: Hangi master'ın aktif olacağını belirler
  // ⚡ AVANTAJ: Data consistency
  // 📈 ÖNERİ: Sentinel ile birlikte kullanın
  // 🌐 NETWORK
  ResolveDns = true,           // DNS çözümle
  // ✅ 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
  CheckCertificateRevocation = false // SSL sertifika iptal kontrolü
  // ✅ 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
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
options.ConfigurationOptions = new ConfigurationOptions
{
  EndPoints = {
      "redis1.prod.company.com:6379",
      "redis2.prod.company.com:6379"
  },
  Password = Environment.GetEnvironmentVariable("REDIS_PASSWORD"),
  ConnectTimeout = 10000,       // Sabırlı bağlantı
  SyncTimeout = 8000,           // Orta timeout
  AsyncTimeout = 12000,         // Uzun async timeout
  ConnectRetry = 5,             // Çok retry
  ReconnectRetryPolicy = new ExponentialRetry(1000),
  AbortOnConnectFail = false,   // Cluster support
  Ssl = true,                   // SSL gerekli
  SslHost = "*.prod.company.com",
  AllowAdmin = false,           // Güvenlik
  KeepAlive = 300,             // Uzun keep-alive
  ClientName = "MyApp-Prod"
};

bash
options.ConfigurationOptions = new ConfigurationOptions
{
  EndPoints = { "redis-cluster.company.com:6379" },
  Password = Environment.GetEnvironmentVariable("REDIS_PASSWORD"),
  ConnectTimeout = 1000,        // Çok hızlı
  SyncTimeout = 500,            // Çok hızlı
  AsyncTimeout = 1000,          // Çok hızlı
  ConnectRetry = 3,             // Orta retry
  ReconnectRetryPolicy = new LinearRetry(500), // Hızlı retry
  AbortOnConnectFail = false,   // Cluster support
  Ssl = true,                   // SSL gerekli
  KeepAlive = 60,              // Kısa keep-alive
  ClientName = "MyApp-HighPerf"
};

🏭 Factory ve Profiling Options

bash
// Ö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
// Redis komut profiling'i
options.ProfilingSession = () =>
{
  return new ProfilingSession(); // Her request için yeni session
};
// Kullanım:
// var session = new ProfilingSession();
// ConnectionMultiplexer.SetProfiler(() => session);
// // Redis operations...
// var commands = session.FinishProfiling();

🎯 Environment-Specific Optimal Konfigürasyonlar

🔧 Development Environment

bash
// 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
// 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
// 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
// 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
// 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
SizeLimit = 256 (küçük memory footprint)
CompactionPercentage = 0.5 (agresif temizlik)
ExpirationScanFrequency = 1 dakika (hızlı cleanup)

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

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

⚙️ appsettings.json Konfigürasyonu

json
{
"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
MyApp/
├── Controllers/
├── Services/
│   ├── Interfaces/
│   │   └── ICacheService.cs
│   └── CacheService.cs
├── Models/
├── Configuration/
│   └── CacheConfiguration.cs
└── Extensions/
  └── ServiceCollectionExtensions.cs

🛠️ Cache Service Interface

bash
// 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
// 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> _logger;
  private readonly bool _useDistributedCache;
  private readonly TimeSpan _defaultExpiration;
  private readonly JsonSerializerOptions _jsonOptions;
  public CacheService(
      IMemoryCache memoryCache,
      IDistributedCache distributedCache,
      IConfiguration configuration,
      ILogger<CacheService> logger)
  {
      _memoryCache = memoryCache;
      _distributedCache = distributedCache;
      _configuration = configuration;
      _logger = logger;
      _useDistributedCache = _configuration.GetValue<bool>("CacheSettings:UseDistributedCache");
      _defaultExpiration = TimeSpan.FromMinutes(
          _configuration.GetValue<int>("CacheSettings:DefaultExpirationMinutes", 30));
      _jsonOptions = new JsonSerializerOptions
      {
          PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
          WriteIndented = false
      };
  }
  public async Task<T?> GetAsync<T>(string key) where T : class
  {
      ArgumentException.ThrowIfNullOrEmpty(key);
      try
      {
          // İlk olarak Memory Cache'den kontrol et (L1 Cache)
          if (_memoryCache.TryGetValue(key, out T? memoryValue))
          {
              _logger.LogDebug("Cache hit from memory for key: {Key}", key);
              return memoryValue;
          }
          // Distributed cache kullanılıyorsa Redis'ten kontrol et (L2 Cache)
          if (_useDistributedCache)
          {
              var distributedValue = await _distributedCache.GetStringAsync(key);
              if (!string.IsNullOrEmpty(distributedValue))
              {
                  var deserializedValue = JsonSerializer.Deserialize<T>(distributedValue, _jsonOptions);
                  // Bulunan değeri Memory Cache'e de ekle (cache warming)
                  var memoryCacheOptions = new MemoryCacheEntryOptions
                  {
                      AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(5),
                      Size = 1,
                      Priority = CacheItemPriority.Normal
                  };
                  _memoryCache.Set(key, deserializedValue, memoryCacheOptions);
                  _logger.LogDebug("Cache hit from distributed for key: {Key}", key);
                  return deserializedValue;
              }
          }
          _logger.LogDebug("Cache miss for key: {Key}", key);
          return null;
      }
      catch (Exception ex)
      {
          _logger.LogError(ex, "Error getting cache for key: {Key}", key);
          return null;
      }
  }
  public async Task SetAsync<T>(string key, T value, TimeSpan? expiration = null) where T : class
  {
      ArgumentException.ThrowIfNullOrEmpty(key);
      ArgumentNullException.ThrowIfNull(value);
      try
      {
          var cacheExpiration = expiration ?? _defaultExpiration;
          // Distributed Cache'e ekle
          if (_useDistributedCache)
          {
              var serializedValue = JsonSerializer.Serialize(value, _jsonOptions);
              var distributedCacheOptions = new DistributedCacheEntryOptions
              {
                  AbsoluteExpirationRelativeToNow = cacheExpiration
              };
              await _distributedCache.SetStringAsync(key, serializedValue, distributedCacheOptions);
          }
          // Memory Cache'e de ekle (L1 Cache)
          var memoryCacheOptions = new MemoryCacheEntryOptions
          {
              AbsoluteExpirationRelativeToNow = cacheExpiration,
              Size = 1,
              Priority = CacheItemPriority.Normal
          };
          _memoryCache.Set(key, value, memoryCacheOptions);
          _logger.LogDebug("Cache set for key: {Key}, expiration: {Expiration}", key, cacheExpiration);
      }
      catch (Exception ex)
      {
          _logger.LogError(ex, "Error setting cache for key: {Key}", key);
          throw; // Cache set operasyonu kritik olabilir, hata fırlatılır
      }
  }
  public async Task RemoveAsync(string key)
  {
      ArgumentException.ThrowIfNullOrEmpty(key);
      try
      {
          // Her iki cache'den de sil
          _memoryCache.Remove(key);
          if (_useDistributedCache)
          {
              await _distributedCache.RemoveAsync(key);
          }
          _logger.LogDebug("Cache removed for key: {Key}", key);
      }
      catch (Exception ex)
      {
          _logger.LogError(ex, "Error removing cache for key: {Key}", key);
      }
  }
  public async Task RemoveByPatternAsync(string pattern)
  {
      ArgumentException.ThrowIfNullOrEmpty(pattern);
      try
      {
          // Memory cache'de pattern bazlı silme mümkün değil
          // Redis için StackExchange.Redis ile özel implementation gerekli
          _logger.LogWarning("RemoveByPatternAsync partially implemented for pattern: {Pattern}", pattern);
          // Gelecek implementasyonlar için placeholder
          await Task.CompletedTask;
      }
      catch (Exception ex)
      {
          _logger.LogError(ex, "Error removing cache by pattern: {Pattern}", pattern);
      }
  }
  public async Task<bool> ExistsAsync(string key)
  {
      ArgumentException.ThrowIfNullOrEmpty(key);
      try
      {
          // Memory cache'de varlık kontrolü
          if (_memoryCache.TryGetValue(key, out _))
              return true;
          // Distributed cache'de varlık kontrolü
          if (_useDistributedCache)
          {
              var value = await _distributedCache.GetStringAsync(key);
              return !string.IsNullOrEmpty(value);
          }
          return false;
      }
      catch (Exception ex)
      {
          _logger.LogError(ex, "Error checking cache existence for key: {Key}", key);
          return false;
      }
  }
  public async Task<IEnumerable<string>> GetKeysAsync(string pattern)
  {
      // Bu metod Redis'e özel implementation gerektirir
      _logger.LogWarning("GetKeysAsync not implemented for current setup");
      await Task.CompletedTask;
      return Enumerable.Empty<string>();
  }
  public async Task ClearAllAsync()
  {
      try
      {
          // Memory cache tamamen temizlenir
          if (_memoryCache is MemoryCache mc)
          {
              mc.Compact(1.0); // %100 compaction
          }
          // Redis için tüm database'i temizleme (dikkatli kullanılmalı)
          _logger.LogWarning("ClearAllAsync called - this will clear all cache data");
          await Task.CompletedTask;
      }
      catch (Exception ex)
      {
          _logger.LogError(ex, "Error clearing all cache");
      }
  }
}

🔌 Service Registration Extension

bash
// 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));
      });
      // Distributed Cache conditionally eklenir
      if (useDistributedCache)
      {
          var redisSettings = cacheSettings.GetSection("RedisSettings");
          services.AddStackExchangeRedisCache(options =>
          {
              var connectionString = $"{redisSettings["Host"]}:{redisSettings["Port"]}";
              if (!string.IsNullOrEmpty(redisSettings["Password"]))
              {
                  connectionString += $",password={redisSettings["Password"]}";
              }
              options.Configuration = connectionString;
              options.InstanceName = configuration.GetValue<string>("ApplicationName", "MyApp");
              // Advanced Redis configuration
              options.ConfigurationOptions = new StackExchange.Redis.ConfigurationOptions
              {
                  EndPoints = { $"{redisSettings["Host"]}:{redisSettings["Port"]}" },
                  Password = redisSettings["Password"],
                  Database = redisSettings.GetValue<int>("Database", 0),
                  ConnectTimeout = redisSettings.GetValue<int>("ConnectTimeout", 5000),
                  SyncTimeout = redisSettings.GetValue<int>("SyncTimeout", 5000),
                  AbortOnConnectFail = false
              };
          });
      }
      // Cache Service'i register et
      services.AddScoped<ICacheService, CacheService>();
      // Cache metrikleri için (opsiyonel)
      services.AddSingleton<ICacheMetricsService, CacheMetricsService>();
      return services;
  }
}

📚 Shared Klasöründe Organize Yapı

📁 Shared Klasör Yapısı

text
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
// 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<T>(string? filter = null, int? page = null, int? pageSize = null) where T : class;
  string GenerateHashKey(string algorithm, string input);
  bool IsValidKey(string key);
}
// Shared/Caching/Services/CacheKeyGenerator.cs
public class CacheKeyGenerator : ICacheKeyGenerator
{
  private const string SEPARATOR = ":";
  private const int MAX_KEY_LENGTH = 250; // Redis key length limit
  private readonly string _applicationName;
  private readonly string _environment;
  public CacheKeyGenerator(IConfiguration configuration)
  {
      _applicationName = configuration.GetValue<string>("CacheSettings:ApplicationName", "MyApp");
      _environment = configuration.GetValue<string>("Environment", "Development");
  }
  public string GenerateKey(string prefix, params object[] parameters)
  {
      ArgumentException.ThrowIfNullOrEmpty(prefix);
      var keyParts = new List<string> { _applicationName, _environment, prefix };
      if (parameters?.Length > 0)
      {
          keyParts.AddRange(parameters.Where(p => p != null).Select(p => p.ToString()!));
      }
      var key = string.Join(SEPARATOR, keyParts);
      if (!IsValidKey(key))
      {
          throw new ArgumentException($"Generated key '{key}' is invalid");
      }
      return key;
  }
  public string GenerateUserSpecificKey(string userId, string prefix, params object[] parameters)
  {
      ArgumentException.ThrowIfNullOrEmpty(userId);
      ArgumentException.ThrowIfNullOrEmpty(prefix);
      var keyParts = new List<string> { _applicationName, _environment, "user", userId, prefix };
      if (parameters?.Length > 0)
      {
          keyParts.AddRange(parameters.Where(p => p != null).Select(p => p.ToString()!));
      }
      var key = string.Join(SEPARATOR, keyParts);
      if (!IsValidKey(key))
      {
          throw new ArgumentException($"Generated user key '{key}' is invalid");
      }
      return key;
  }
  public string GenerateEntityKey<T>(object id) where T : class
  {
      ArgumentNullException.ThrowIfNull(id);
      var entityName = typeof(T).Name.ToLowerInvariant();
      return GenerateKey("entity", entityName, id);
  }
  public string GenerateListKey<T>(string? filter = null, int? page = null, int? pageSize = null) where T : class
  {
      var entityName = typeof(T).Name.ToLowerInvariant();
      var parameters = new List<object> { "list", entityName };
      if (!string.IsNullOrEmpty(filter))
          parameters.Add($"filter:{filter}");
      if (page.HasValue)
          parameters.Add($"page:{page}");
      if (pageSize.HasValue)
          parameters.Add($"size:{pageSize}");
      return GenerateKey("query", parameters.ToArray());
  }
  public string GenerateHashKey(string algorithm, string input)
  {
      ArgumentException.ThrowIfNullOrEmpty(algorithm);
      ArgumentException.ThrowIfNullOrEmpty(input);
      using var hash = algorithm.ToUpperInvariant() switch
      {
          "MD5" => System.Security.Cryptography.MD5.Create(),
          "SHA1" => System.Security.Cryptography.SHA1.Create(),
          "SHA256" => System.Security.Cryptography.SHA256.Create(),
          _ => throw new NotSupportedException($"Hash algorithm '{algorithm}' is not supported")
      };
      var hashBytes = hash.ComputeHash(System.Text.Encoding.UTF8.GetBytes(input));
      var hashString = Convert.ToHexString(hashBytes).ToLowerInvariant();
      return GenerateKey("hash", algorithm.ToLowerInvariant(), hashString);
  }
  public bool IsValidKey(string key)
  {
      if (string.IsNullOrEmpty(key))
          return false;
      if (key.Length > MAX_KEY_LENGTH)
          return false;
      // Redis key naming restrictions
      return !key.Contains(' ') && !key.Contains('\t') && !key.Contains('\n') && !key.Contains('\r');
  }
}

🎯 Cacheable Attribute

bash
// 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
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/