Mise en cache en C# (.NET) : Redis et alternatives |…

Mise en cache en C# (.NET) : Redis et autres outils pour accélérer les applications

La mise en cache est l'un des moyens les plus efficaces d'améliorer les performances et l'évolutivité des applications en C# (.NET). Dans cet article, nous examinerons en détail les mécanismes de mise en cache intégrés, les bibliothèques populaires pour travailler avec Redis, ainsi que des solutions alternatives. Vous apprendrez à choisir l'outil adapté à votre tâche et à éviter les erreurs typiques.

Mécanismes de mise en cache intégrés dans .NET

La plateforme .NET fournit plusieurs solutions prêtes à l'emploi pour la mise en cache, adaptées à la plupart des scénarios sans installation de dépendances tierces.

1. MemoryCache (System.Runtime.Caching)

Cache intégré en mémoire du processus. Idéal pour les applications monothread ou les faibles charges. Les données sont stockées en RAM et sont automatiquement supprimées en cas de manque de ressources.

using System.Runtime.Caching;

public class MemoryCacheService{    private readonly MemoryCache _cache = MemoryCache.Default;

    public T GetOrSet<T>(string key, Func<T> factory, int expirationMinutes = 5)    {        var cached = _cache.Get(key);        if (cached != null) return (T)cached;

        var result = factory();        var policy = new CacheItemPolicy        {            AbsoluteExpiration = DateTimeOffset.UtcNow.AddMinutes(expirationMinutes)        };        _cache.Set(key, result, policy);        return result;    }}

2. IDistributedCache (Microsoft.Extensions.Caching)

Abstraction pour la mise en cache distribuée. Permet de basculer facilement entre Redis, SQL Server, NCache et d'autres fournisseurs. Recommandé pour les microservices et les applications cloud.

using Microsoft.Extensions.Caching.Distributed;using System.Text.Json;

public class DistributedCacheService{    private readonly IDistributedCache _cache;

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

    public async Task<T> GetOrSetAsync<T>(string key, Func<Task<T>> factory, int expirationMinutes = 10)    {        var cached = await _cache.GetStringAsync(key);        if (cached != null) return JsonSerializer.Deserialize<T>(cached);

        var result = await factory();        var options = new DistributedCacheEntryOptions        {            AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(expirationMinutes)        };        await _cache.SetStringAsync(key, JsonSerializer.Serialize(result), options);        return result;    }}

Redis : le roi de la mise en cache distribuée

Redis est un magasin de données en mémoire hautes performances, prenant en charge les chaînes, listes, hachages, ensembles et autres structures. Pour .NET, la bibliothèque principale est StackExchange.Redis.

Installation et configuration de StackExchange.Redis

Installez le package via NuGet :

dotnet add package StackExchange.Redis

Exemple de connexion et d'opérations de base :

using StackExchange.Redis;

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

    public RedisCacheService(string connectionString)    {        _redis = ConnectionMultiplexer.Connect(connectionString);        _db = _redis.GetDatabase();    }

    public async Task SetAsync(string key, string value, int expirationMinutes = 5)    {        await _db.StringSetAsync(key, value, TimeSpan.FromMinutes(expirationMinutes));    }

    public async Task<string> GetAsync(string key)    {        return await _db.StringGetAsync(key);    }}