Caching in C#: Redis, Memcached und integrierte .NET-Lösungen

Caching in C#: Redis, Memcached und integrierte Lösungen für .NET

Caching ist eines der wichtigsten Werkzeuge zur Leistungssteigerung von Anwendungen in C#. Es ermöglicht, die Antwortzeit zu verkürzen und die Last auf Datenbanken und externe APIs zu reduzieren. Im .NET-Ökosystem stehen mehrere Ansätze zur Verfügung: vom integrierten MemoryCache bis zu verteilten Lösungen auf Basis von Redis und Memcached. In diesem Artikel analysieren wir jede Option, zeigen Codebeispiele und geben Empfehlungen zur Auswahl.

1. Integriertes Caching: MemoryCache und IDistributedCache

Die .NET-Plattform bietet zwei grundlegende abstrakte Mechanismen für die Arbeit mit dem Cache: IMemoryCache (In-Process) und IDistributedCache (verteilt).

1.1 IMemoryCache

Speichert Daten im Prozessspeicher. Ideal für Single-Thread- oder monolithische Anwendungen, bei denen keine Synchronisation zwischen mehreren Servern erforderlich ist. Einfach einzurichten und benötigt keine externen Abhängigkeiten.

// Hinzufügen zu DI (Program.cs)builder.Services.AddMemoryCache();

// Verwendung im Servicepublic class WeatherService{    private readonly IMemoryCache _cache;

    public WeatherService(IMemoryCache cache)    {        _cache = cache;    }

    public async Task<string> GetWeatherAsync(string city)    {        string cacheKey = $"weather_{city}";        if (_cache.TryGetValue(cacheKey, out string cachedData))        {            return cachedData;        }

        // Simulation einer langen Anfrage        await Task.Delay(2000);        string result = $"Wetter in {city}: +25°C";

        var options = new MemoryCacheEntryOptions()            .SetAbsoluteExpiration(TimeSpan.FromMinutes(5))            .SetSlidingExpiration(TimeSpan.FromMinutes(2));

        _cache.Set(cacheKey, result, options);        return result;    }}

1.2 IDistributedCache

Abstraktion für einen verteilten Cache. Ermöglicht das einfache Wechseln zwischen Anbietern (Redis, SQL Server, NCache), ohne die Geschäftslogik zu ändern. Standardmäßig werden Daten als byte[] gespeichert.

// Registrierung (Program.cs) - Verwendung von Redisbuilder.Services.AddStackExchangeRedisCache(options =>{    options.Configuration = "localhost:6379";});

// Verwendungpublic class ProductService{    private readonly IDistributedCache _cache;

    public ProductService(IDistributedCache cache)    {        _cache = cache;    }

    public async Task<Product> GetProductAsync(int id)    {        string cacheKey = $"product_{id}";        var cachedBytes = await _cache.GetAsync(cacheKey);

        if (cachedBytes != null)        {            return JsonSerializer.Deserialize<Product>(cachedBytes);        }

        // Datenbankabfrage        var product = await GetProductFromDb(id);

        var options = new DistributedCacheEntryOptions()            .SetAbsoluteExpiration(TimeSpan.FromHours(1));

        var serialized = JsonSerializer.SerializeToUtf8Bytes(product);        await _cache.SetAsync(cacheKey, serialized, options);

        return product;    }}

2. Redis: Verteilter Cache mit erweiterten Funktionen

Redis ist die beliebteste Lösung für Caching in .NET. Es fungiert als leistungsstarker In-Memory-Speicher mit Unterstützung für komplexe Datenstrukturen (Listen, Hashes, Sets).

2.1 Installation und Konfiguration

Verwenden Sie das Paket Microsoft.Extensions.Caching.StackExchangeRedis, um Redis mit .NET zu verbinden.

dotnet add package Microsoft.Extensions.Caching.StackExchangeRedis

2.2 Beispiel mit Redis und IDistributedCache

Neben dem grundlegenden Caching ermöglicht Redis die Implementierung von:

• Benutzersitzungen — Speicherung von Sitzungsdaten zwischen Anfragen.
• Sperren