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

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

La mise en cache est l'un des outils clés pour améliorer les performances des applications en C#. Elle permet de réduire le temps de réponse, de diminuer la charge sur les bases de données et les API externes. Dans l'écosystème .NET, plusieurs approches sont disponibles : du MemoryCache intégré aux solutions distribuées basées sur Redis et Memcached. Dans cet article, nous analyserons chaque option, montrerons des exemples de code et donnerons des recommandations pour le choix.

1. Mise en cache intégrée : MemoryCache et IDistributedCache

La plateforme .NET fournit deux mécanismes abstraits principaux pour travailler avec le cache : IMemoryCache (in-process) et IDistributedCache (distribué).

1.1 IMemoryCache

Stocke les données dans la mémoire du processus. Idéal pour les applications monolithiques ou monothread où la synchronisation entre plusieurs serveurs n'est pas nécessaire. Simple à configurer et ne nécessite pas de dépendances externes.

// Ajout dans DI (Program.cs)builder.Services.AddMemoryCache();

// Utilisation dans un 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 d'une requête longue        await Task.Delay(2000);        string result = $"Météo à {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

Abstraction pour le cache distribué. Permet de basculer facilement entre les fournisseurs (Redis, SQL Server, NCache) sans modifier la logique métier. Par défaut, stocke les données sous forme de byte[].

// Enregistrement (Program.cs) - utilisation de Redisbuilder.Services.AddStackExchangeRedisCache(options =>{    options.Configuration = "localhost:6379";});

// Utilisationpublic 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);        }

        // Requête à la base de données        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 : cache distribué avec des fonctionnalités avancées

Redis est la solution la plus populaire pour la mise en cache en .NET. Il fonctionne comme un stockage in-memory haute performance avec le support de structures de données complexes (listes, hachages, ensembles).

2.1 Installation et configuration

Pour connecter Redis à .NET, utilisez le package Microsoft.Extensions.Caching.StackExchangeRedis.

dotnet add package Microsoft.Extensions.Caching.StackExchangeRedis

2.2 Exemple avec Redis et IDistributedCache

En plus de la mise en cache de base, Redis permet de réaliser :

• Sessions utilisateur — stockage des données de session entre les requêtes.
• Verrous