Mise en cache distribuée avec .NET Core : Un exemple pratique
Le caching distribué est une technique essentielle pour améliorer les performances des applications .NET Core en stockant des données fréquemment accédées dans un emplacement accessible par plusieurs instances de l'application. Cela permet de réduire les appels coûteux à la base de données ou à d'autres services, ce qui conduit à une meilleure réactivité et une réduction de la charge du serveur.
Dans cet article, nous allons explorer un exemple concret de mise en cache distribuée avec .NET Core, en utilisant Redis comme système de cache. Redis est un magasin de données en mémoire très performant, idéal pour le caching distribué.
Configuration de Redis
Tout d'abord, nous devons installer et configurer Redis sur notre machine. Vous pouvez télécharger et installer Redis à partir du site officiel . Une fois installé, vous pouvez vérifier que Redis est en cours d'exécution en ouvrant un terminal et en exécutant la commande redis-cli.
Intégration de Redis dans .NET Core
Pour utiliser Redis dans .NET Core, nous avons besoin du package NuGet StackExchange.Redis. Ajoutez ce package à votre projet .NET Core via la console de gestion de package ou en utilisant Visual Studio.
using Microsoft.Extensions.Caching.Distributed;
using StackExchange.Redis;
Implémentation de la mise en cache distribuée
Maintenant, nous allons implémenter un exemple de caching distribué pour récupérer des données d'un service web.
public class DataService
{
private readonly IDistributedCache _cache;
private readonly IHttpClientFactory _httpClientFactory;
public DataService(IDistributedCache cache, IHttpClientFactory httpClientFactory)
{
_cache = cache;
_httpClientFactory = httpClientFactory;
}
public async Task GetCachedData(string key)
{
// Vérifier si les données sont déjà en cache
var cachedData = await _cache.GetStringAsync(key);
if (!string.IsNullOrEmpty(cachedData))
{
// Les données sont en cache, renvoyer les données
return cachedData;
}
else
{
// Les données ne sont pas en cache, récupérer les données du service web
var client = _httpClientFactory.CreateClient("myApi");
var response = await client.GetAsync("api/data");
if (response.IsSuccessStatusCode)
{
// Enregistrer les données dans le cache
cachedData = await response.Content.ReadAsStringAsync();
await _cache.SetStringAsync(key, cachedData, new DistributedCacheEntryOptions { AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(5) });
// Renvoyer les données
return cachedData;
}
else
{
// Erreur lors de la récupération des données du service web
return "Erreur";
}
}
}
}
Dans cet exemple, nous utilisons IDistributedCache pour interagir avec le cache distribué. GetStringAsync permet de récupérer les données du cache et SetStringAsync permet d'enregistrer les données dans le cache avec une durée de vie de 5 minutes.
Conclusion
Ce simple exemple montre comment utiliser le caching distribué avec .NET Core et Redis pour améliorer les performances de votre application. La mise en œuvre de cette technique peut vous aider à optimiser votre application, en particulier lorsqu'elle gère un volume élevé de requêtes. N'hésitez pas à expérimenter et à explorer d'autres options de caching distribué disponibles pour .NET Core.