Mise en cache en C# : Redis, Memcached et solutions intégrées de A à Z

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

Dans le développement web moderne, la performance de l'application est l'un des facteurs clés de succès. La mise en cache permet de réduire considérablement la charge sur la base de données et d'accélérer le temps de réponse du système. Dans l'écosystème C# (.NET), le développeur dispose de trois approches principales : la mise en cache intégrée en mémoire (IMemoryCache), les solutions distribuées (IDistributedCache) et les serveurs de cache externes comme Redis et Memcached. Dans cet article, nous analyserons chacune d'elles, de la théorie aux exemples pratiques de code.

1. Mise en cache intégrée dans .NET : IMemoryCache

La mise en cache intégrée est le moyen le plus simple et le plus rapide de stocker temporairement des données. Dans ASP.NET Core, elle est implémentée via l'interface IMemoryCache. Les données sont stockées dans la mémoire vive d'un seul processus, ce qui garantit une latence minimale.

Quand l'utiliser :

• Les données n'ont pas besoin d'être synchronisées entre plusieurs serveurs.
• Le volume des données à mettre en cache est faible.
• Une performance maximale est requise sans configuration de services externes.

Exemple d'implémentation :

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))        {            // Les données ne sont pas dans le cache — chargement depuis une source externe            data = await FetchWeatherFromApi(city);

            // Configuration du cache : durée de vie de 5 minutes            var cacheOptions = new MemoryCacheEntryOptions()                .SetAbsoluteExpiration(TimeSpan.FromMinutes(5));

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

        return data;    }

    private async Task<WeatherData> FetchWeatherFromApi(string city)    {        // Simulation d'un appel API externe        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; }}

Méthodes clés : TryGetValue, Set, Remove. Il est important de noter que IMemoryCache n'est pas adapté à une architecture de microservices.

2. Mise en cache distribuée : IDistributedCache et ses fournisseurs

Pour les applications fonctionnant sur plusieurs serveurs, une mise en cache distribuée est nécessaire. Dans .NET, elle est abstraite via l'interface IDistributedCache. Cela permet de changer facilement de fournisseur (Redis, SQL Server, NCache) sans modifier la logique métier.

Méthodes principales :

• GetAsync / SetAsync — pour travailler avec des octets.
• GetStringAsync / SetStringAsync — pour les données textuelles.
• RefreshAsync — réinitialisation du minuteur de durée de vie glissante.
• RemoveAsync — suppression d'une entrée.

Exemple avec Redis :

// Dans Program.cs, on enregistre le fournisseurbuilder.Services.AddStackExchangeRedisCache(options =>{    options.Configuration = "localhost:6379";    options.InstanceName = "SampleApp";});

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