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

Zwischenspeicherung in C#: Redis, Memcached und integrierte Lösungen

Zwischenspeicherung ist eines der wichtigsten Werkzeuge zur Leistungsoptimierung in modernen Webanwendungen. Im C# (.NET) Ökosystem stehen dem Entwickler sowohl integrierte Mechanismen (IMemoryCache, IDistributedCache) als auch leistungsstarke externe Lösungen (Redis, Memcached) zur Verfügung. In diesem Artikel analysieren wir ihre Besonderheiten, vergleichen die Leistung und geben praktische Codebeispiele.

1. Integrierte .NET Lösungen: IMemoryCache und IDistributedCache

ASP.NET Core bietet zwei Hauptschnittstellen für die Arbeit mit dem Cache: IMemoryCache (lokaler Cache im Speicher eines einzelnen Prozesses) und IDistributedCache (Abstraktion für verteilten Cache).

IMemoryCache

Ideal für monolithische Anwendungen oder Microservices, bei denen keine Synchronisation zwischen Instanzen erforderlich ist. Der Cache wird im Arbeitsspeicher des Servers gespeichert.

// Registrierung in Program.csbuilder.Services.AddMemoryCache();

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

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

    public async Task<string> GetExpensiveDataAsync(int id)    {        string cacheKey = $"data_{id}";        if (_cache.TryGetValue(cacheKey, out string cachedData))        {            return cachedData;        }

        // Emulation einer schweren Operation        await Task.Delay(500);        string data = $"Result for {id}";

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

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

IDistributedCache

Eine Abstraktion, die es ermöglicht, verschiedene Backends (Redis, SQL Server, NCache) ohne Änderung des Anwendungscodes anzubinden. Registriert wird es über AddDistributedRedisCache oder AddDistributedSqlServerCache.

// Beispiel mit Redisbuilder.Services.AddStackExchangeRedisCache(options =>{    options.Configuration = "localhost:6379";    options.InstanceName = "SampleInstance";});

// Verwendungpublic class DistributedService{    private readonly IDistributedCache _cache;

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

    public async Task<string> GetDataAsync(string key)    {        var cached = await _cache.GetStringAsync(key);        if (cached != null) return cached;

        var data = $"Computed at {DateTime.Now}";        await _cache.SetStringAsync(key, data, new DistributedCacheEntryOptions        {            AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(5)        });        return data;    }}

2. Redis: Leistungsstarker verteilter Cache für C#

Redis ist ein In-Memory-Datenspeicher mit Unterstützung für komplexe Strukturen (Listen, Mengen, Hashes). Für .NET wird der Client StackExchange.Redis oder der High-Level-Wrapper Microsoft.Extensions.Caching.StackExchangeRedis verwendet.

Vorteile von Redis in C#:

• Geschwindigkeit: Submillisekunden-Latenzen (durchschnittlich 0,5-1 ms).
• Pub/Sub: Möglichkeit, andere Dienste über Cache-Änderungen zu benachrichtigen.
• Persistenz: Daten können auf der Festplatte gespeichert werden (RDB/AOF).
• Clustering: Horizontale Skalierung out-of-the-box.

Beispiel für fortgeschrittene Nutzung mit JSON-Serialisierung:

using StackExchange.Redis;using System.Text.Json;

public class RedisCacheService{    private readonly IDatabase _db;    private readonly ConnectionMultiplexer _redis;

    public RedisCacheService(string connectionString)    {        _redis = ConnectionMultiplexer.Connect(connectionStri