Mise en cache en C# : Redis, Memcached et solutions intégrées pour .NET

Mise en cache en C# : Redis, Memcached et solutions intégrées

La mise en cache est l'un des outils clés d'optimisation des performances dans les applications web modernes. Dans l'écosystème C# (.NET), le développeur a accès à la fois à des mécanismes intégrés (IMemoryCache, IDistributedCache) et à des solutions externes puissantes (Redis, Memcached). Dans cet article, nous analyserons leurs caractéristiques, comparerons leurs performances et fournirons des exemples de code pratiques.

1. Solutions intégrées .NET : IMemoryCache et IDistributedCache

ASP.NET Core fournit deux interfaces principales pour travailler avec le cache : IMemoryCache (cache local en mémoire d'un seul processus) et IDistributedCache (abstraction pour le cache distribué).

IMemoryCache

Idéal pour les applications monolithiques ou les microservices où la synchronisation entre instances n'est pas nécessaire. Le cache est stocké dans la RAM du serveur.

// Enregistrement dans Program.csbuilder.Services.AddMemoryCache();

// Utilisation dans un 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;        }

        // Simulation d'une opération lourde        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

Abstraction permettant de connecter différents backends (Redis, SQL Server, NCache) sans modifier le code de l'application. S'enregistre via AddDistributedRedisCache ou AddDistributedSqlServerCache.

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

// Utilisationpublic 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 : un cache distribué puissant pour C#

Redis est un magasin de données in-memory prenant en charge des structures complexes (listes, ensembles, hachages). Pour .NET, on utilise le client StackExchange.Redis ou l'enveloppe de haut niveau Microsoft.Extensions.Caching.StackExchangeRedis.

Avantages de Redis en C# :

• Vitesse : latences inférieures à la milliseconde (en moyenne 0,5-1 ms).
• Pub/Sub : possibilité de notifier d'autres services des modifications du cache.
• Persistance : les données peuvent être sauvegardées sur disque (RDB/AOF).
• Clustering : mise à l'échelle horizontale prête à l'emploi.

Exemple d'utilisation avancée avec sérialisation JSON :

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