Caching in C#: Redis, Memcached und integrierte Lösungen von A bis Z

Caching in C#: Redis, Memcached und integrierte Lösungen — vollständiger Leitfaden

In der modernen Webentwicklung ist die Anwendungsleistung einer der entscheidenden Erfolgsfaktoren. Caching ermöglicht es, die Datenbanklast erheblich zu reduzieren und die Systemantwortzeit zu beschleunigen. Im C# (.NET)-Ökosystem stehen dem Entwickler drei Hauptansätze zur Verfügung: integriertes In-Memory-Caching (IMemoryCache), verteilte Lösungen (IDistributedCache) und externe Caching-Server wie Redis und Memcached. In diesem Artikel analysieren wir jeden dieser Ansätze von der Theorie bis zu praktischen Codebeispielen.

1. Integriertes Caching in .NET: IMemoryCache

Integriertes Caching ist die einfachste und schnellste Methode zur temporären Datenspeicherung. In ASP.NET Core wird es über das Interface IMemoryCache implementiert. Die Daten werden im Arbeitsspeicher eines einzelnen Prozesses gespeichert, was eine minimale Latenz gewährleistet.

Wann verwenden:

• Daten müssen nicht zwischen mehreren Servern synchronisiert werden.
• Das Volumen der zu cachenden Daten ist gering.
• Maximale Leistung ohne Konfiguration externer Dienste ist erforderlich.

Implementierungsbeispiel:

using Microsoft.Extensions.Caching.Memory;

public class WeatherService{    private readonly IMemoryCache _cache;

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

    public async Task<WeatherData> GetWeatherAsync(string city)    {        string cacheKey = $"weather_{city}";

        if (!_cache.TryGetValue(cacheKey, out WeatherData data))        {            // Daten sind nicht im Cache – aus externer Quelle laden            data = await FetchWeatherFromApi(city);

            // Cache-Konfiguration: Lebensdauer 5 Minuten            var cacheOptions = new MemoryCacheEntryOptions()                .SetAbsoluteExpiration(TimeSpan.FromMinutes(5));

            _cache.Set(cacheKey, data, cacheOptions);        }

        return data;    }

    private async Task<WeatherData> FetchWeatherFromApi(string city)    {        // Simulation eines externen API-Aufrufs        await Task.Delay(1000);        return new WeatherData { City = city, Temperature = 22.5 };    }}

public class WeatherData{    public string City { get; set; }    public double Temperature { get; set; }}

Wichtige Methoden: TryGetValue, Set, Remove. Es ist wichtig zu beachten, dass IMemoryCache nicht für eine Microservice-Architektur geeignet ist.

2. Verteiltes Caching: IDistributedCache und seine Provider

Für Anwendungen, die auf mehreren Servern laufen, ist verteiltes Caching erforderlich. In .NET wird dies über das Interface IDistributedCache abstrahiert. Dies ermöglicht einen einfachen Wechsel des Providers (Redis, SQL Server, NCache), ohne die Geschäftslogik zu ändern.

Wichtige Methoden:

• GetAsync / SetAsync — für die Arbeit mit Bytes.
• GetStringAsync / SetStringAsync — für Zeichenfolgendaten.
• RefreshAsync — Zurücksetzen des Timers für gleitende Lebensdauer.
• RemoveAsync — Löschen eines Eintrags.

Beispiel mit Redis:

// In Program.cs registrieren wir den Providerbuilder.Services.AddStackExchangeRedisCache(options =>{    options.Configuration = "localhost:6379";    options.InstanceName = "SampleApp";});

// Verwendung im Servicepublic class ProductService{    private readonly IDistributedCache _cache;

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

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

        if