Cache en mémoire dans ASP.NET Core

Par Rick Anderson, John Luo et Steve Smith

La mise en cache peut améliorer considérablement les performances et l’évolutivité d’une application en réduisant le travail nécessaire à la génération de contenu. La mise en cache fonctionne mieux avec des données qui changent rarement et qui sont coûteuses à générer. La mise en cache effectue une copie des données qui peut être renvoyée beaucoup plus rapidement qu’à partir de la source. Les applications doivent être écrites et testées pour ne jamais dépendre des données mises en cache.

ASP.NET Core prend en charge plusieurs caches différents. Le cache le plus simple est basé sur l’interface IMemoryCache . IMemoryCache Représente un cache stocké dans la mémoire du serveur web. Les applications exécutées sur une batterie de serveurs (plusieurs serveurs) doivent garantir que les sessions sont persistantes lors de l’utilisation du cache en mémoire. Les sessions persistantes garantissent que les requêtes d’un client sont toutes transmises au même serveur. Par exemple, une application web Azure utilise Microsoft ARR (Application Request Routing) pour acheminer toutes les requêtes vers le même serveur.

Les sessions non persistantes dans une ferme de serveurs web nécessitent un cache distribué pour éviter les problèmes de cohérence du cache. Pour certaines applications, un cache distribué peut prendre en charge un scale-out plus élevé qu’un cache en mémoire. L’utilisation d’un cache distribué décharge la mémoire cache vers un processus externe.

Le cache en mémoire peut stocker n’importe quel objet. L’interface de cache distribué est limitée à byte[]. Le cache en mémoire et le cache distribué stockent les éléments de cache sous forme de paires clé-valeur.

Utiliser System.Runtime.Caching/MemoryCache

System.Runtime.Caching / MemoryCache (Package NuGet) peut être utilisé avec :

• .NET Standard 2.0 ou version ultérieure
• Toute implémentation .NET qui cible .NET Standard 2.0 ou version ultérieure (par exemple, ASP.NET Core 3.1 ou version ultérieure)
• .NET Framework 4.5 ou ultérieur

Microsoft. Extensions.Caching.Memory/IMemoryCache (décrit dans cet article) est recommandé sur System.Runtime.Caching/MemoryCache, car il offre une meilleure intégration avec ASP.NET Core. Par exemple, IMemoryCache fonctionne nativement avec l'injection de dépendances d'ASP.NET Core.

À utiliser System.Runtime.Caching/MemoryCache comme pont de compatibilité lors du portage de code de ASP.NET 4.x vers ASP.NET Core.

Passer en revue les instructions pour la mise en cache en mémoire

Les instructions suivantes s’appliquent à la mise en cache en mémoire :

• Le code doit toujours avoir une option de secours pour extraire des données et ne pas dépendre de la disponibilité d’une valeur mise en cache.

• Le cache utilise la mémoire, qui est une ressource rare. Limiter la croissance du cache :

  • N’insérez pas d’entrée externe dans le cache. Par exemple, l’utilisation d’une entrée fournie par l’utilisateur arbitraire comme clé de cache n’est pas recommandée, car l’entrée peut consommer une quantité imprévisible de mémoire.

  • Utilisez des expirations pour limiter la croissance du cache.

  • Utilisez SetSize, Size et SizeLimit pour limiter la taille du cache. Le runtime ASP.NET Core doesn't limite la taille du cache en fonction de la sollicitation de la mémoire. Le développeur est chargé de limiter la taille du cache.

Créer une instance d’IMemoryCache

La mise en cache en mémoire est un service auquel une application fait référence à l’aide de l’injection de dépendances.

Warning

Si le même cache est utilisé par plusieurs frameworks ou bibliothèques, il s’agit d’un cache partagé . Si vous utilisez un cache de mémoire partagée à partir de l’injection de dépendances et que vous utilisez SetSizeégalement , Sizeet SizeLimit pour limiter la taille du cache, l’application peut échouer.

Lorsqu’une limite de taille est définie sur un cache, toutes les entrées doivent spécifier une taille lorsqu’elles sont ajoutées. Cette approche peut entraîner des problèmes, car les développeurs n’ont peut-être pas un contrôle total sur ce qui utilise le cache partagé.

Pour limiter la taille du cache avec la SetSize méthode, la Size propriété ou la SizeLimit propriété, créez un singleton de cache pour la mise en cache. Pour plus d’informations et un exemple, consultez Utiliser SetSize, Size et SizeLimit pour limiter la taille du cache.

Demandez l’instance IMemoryCache dans le constructeur :

public class IndexModel : PageModel
{
    private readonly IMemoryCache _memoryCache;

    public IndexModel(IMemoryCache memoryCache) =>
        _memoryCache = memoryCache;

    // ...

Le code suivant utilise la TryGetValue méthode pour vérifier si une heure se trouve dans le cache. Si une heure n'est pas mise en cache, une nouvelle entrée est créée et ajoutée au cache avec la Set méthode suivante :

public void OnGet()
{
    CurrentDateTime = DateTime.Now;

    if (!_memoryCache.TryGetValue(CacheKeys.Entry, out DateTime cacheValue))
    {
        cacheValue = CurrentDateTime;

        var cacheEntryOptions = new MemoryCacheEntryOptions()
            .SetSlidingExpiration(TimeSpan.FromSeconds(3));

        _memoryCache.Set(CacheKeys.Entry, cacheValue, cacheEntryOptions);
    }

    CacheCurrentDateTime = cacheValue;
}

Dans le code précédent, l’entrée de cache est configurée avec une expiration glissante de 3 secondes. Si l’entrée du cache n’est pas accessible pendant plus de 3 secondes, l’entrée est supprimée du cache. Chaque fois que l’entrée du cache est accédée, elle reste dans le cache pendant 3 secondes supplémentaires. La CacheKeys classe fait partie de l’exemple de téléchargement.

L’heure actuelle et l’heure mise en cache sont affichées :

<ul>
    <li>Current Time: @Model.CurrentDateTime</li>
    <li>Cached Time: @Model.CacheCurrentDateTime</li>
</ul>

Le code suivant utilise la méthode d’extension Set pour mettre en cache les données pendant une durée relative sans MemoryCacheEntryOptions.

_memoryCache.Set(CacheKeys.Entry, DateTime.Now, TimeSpan.FromDays(1));

Dans le code précédent, l’entrée de cache est configurée avec une expiration relative d’un jour. L’entrée de cache est supprimée du cache après un jour, même si l’entrée est accessible pendant la période d’expiration.

Le code suivant utilise les méthodes GetOrCreate et GetOrCreateAsync pour mettre en cache les données.

public void OnGetCacheGetOrCreate()
{
    var cachedValue = _memoryCache.GetOrCreate(
        CacheKeys.Entry,
        cacheEntry =>
        {
            cacheEntry.SlidingExpiration = TimeSpan.FromSeconds(3);
            return DateTime.Now;
        });

    // ...
}

public async Task OnGetCacheGetOrCreateAsync()
{
    var cachedValue = await _memoryCache.GetOrCreateAsync(
        CacheKeys.Entry,
        cacheEntry =>
        {
            cacheEntry.SlidingExpiration = TimeSpan.FromSeconds(3);
            return Task.FromResult(DateTime.Now);
        });

    // ...
}

Le code suivant appelle la Get méthode pour récupérer l’heure mise en cache :

var cacheEntry = _memoryCache.Get<DateTime?>(CacheKeys.Entry);

Le code suivant obtient ou crée un élément mis en cache avec une expiration absolue :

var cachedValue = _memoryCache.GetOrCreate(
    CacheKeys.Entry,
    cacheEntry =>
    {
        cacheEntry.AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(20);
        return DateTime.Now;
    });

Un ensemble d’éléments mis en cache avec une expiration glissante uniquement risque de ne jamais expirer. Si l’élément mis en cache est consulté à plusieurs reprises dans l’intervalle d’expiration glissant, l’élément n’expire jamais. La combinaison d’une expiration glissante avec une expiration absolue garantit l’expiration de l’élément. L’expiration absolue définit une limite supérieure sur la durée pendant laquelle l’élément peut être mis en cache. Il permet toujours à l’élément d’expirer précédemment, si l’élément n’est pas demandé dans l’intervalle d’expiration glissant. Si l’intervalle d’expiration glissant ou le délai d’expiration absolu passe, l’élément est supprimé du cache.

Le code suivant obtient ou crée un élément mis en cache avec une expiration glissante et absolue :

var cachedValue = _memoryCache.GetOrCreate(
    CacheKeys.CallbackEntry,
    cacheEntry =>
    {
        cacheEntry.SlidingExpiration = TimeSpan.FromSeconds(3);
        cacheEntry.AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(20);
        return DateTime.Now;
    });

Le code précédent garantit que les données ne sont pas mises en cache plus longtemps que le temps absolu.

GetOrCreate, GetOrCreateAsync, et Get sont des méthodes d’extension dans la classe CacheExtensions. Ces méthodes étendent la capacité de IMemoryCache.

Créer MemoryCacheEntryOptions pour une entrée

L’exemple suivant montre comment créer MemoryCacheEntryOptions pour une entrée. Le code effectue les tâches suivantes :

• Définit la priorité du cache sur CacheItemPriority.NeverRemove.

• Définit un PostEvictionDelegate à appeler après que l’entrée a été supprimée du cache. Le rappel s’exécute sur un thread différent du code qui supprime l’élément du cache.

public void OnGetCacheRegisterPostEvictionCallback()
{
    var memoryCacheEntryOptions = new MemoryCacheEntryOptions()
        .SetPriority(CacheItemPriority.NeverRemove)
        .RegisterPostEvictionCallback(PostEvictionCallback, _memoryCache);

    _memoryCache.Set(CacheKeys.CallbackEntry, DateTime.Now, memoryCacheEntryOptions);
}

private static void PostEvictionCallback(
    object cacheKey, object cacheValue, EvictionReason evictionReason, object state)
{
    var memoryCache = (IMemoryCache)state;

    memoryCache.Set(
        CacheKeys.CallbackMessage,
        $"Entry {cacheKey} was evicted: {evictionReason}.");
}

Limiter la taille du cache avec SetSize, Size et SizeLimit

Une MemoryCache instance peut éventuellement spécifier et appliquer une limite de taille. La limite de taille du cache n’a pas d’unité de mesure définie, car le cache ne dispose d’aucun mécanisme pour mesurer la taille des entrées. Si la limite de taille du cache est définie, toutes les entrées doivent spécifier la taille. Le runtime ASP.NET Core ne limite pas la taille du cache en fonction de la sollicitation de la mémoire. C’est au développeur de limiter la taille du cache. La taille spécifiée est exprimée en unités choisies par le développeur.

Par exemple:

• Si l’application web met principalement en cache les chaînes, chaque taille d’entrée de cache peut être la longueur de la chaîne.
• L’application peut spécifier la taille de toutes les entrées comme 1, et la limite de taille est le nombre d’entrées.

Si la SizeLimit propriété n’est pas définie, le cache augmente sans limite. Le runtime ASP.NET Core ne réduit pas le cache lorsque la mémoire système est faible. L’architecture des applications doit être conforme aux critères suivants :

• Limitez la croissance du cache.
• Appelez la méthode Compact ou Remove lorsque la mémoire disponible est limitée.

Le code suivant crée une instance de taille MemoryCache fixe sans unité accessible par injection de dépendances :

public class MyMemoryCache
{
    public MemoryCache Cache { get; } = new MemoryCache(
        new MemoryCacheOptions
        {
            SizeLimit = 1024
        });
}

La SizeLimit propriété n’a pas d’unités. Les entrées mises en cache doivent spécifier la taille dans les unités qu’elles considèrent le plus appropriée lorsque la limite de taille du cache est définie. Tous les utilisateurs d’une instance de cache doivent utiliser le même système d’unités. Une entrée n’est pas mise en cache si la somme des tailles d’entrée mises en cache dépasse la valeur spécifiée par SizeLimit. Si aucune limite de taille de cache n’est définie, la taille de cache définie sur l’entrée est ignorée.

Le code suivant inscrit l’instance MyMemoryCache auprès du conteneur d’injection de dépendances :

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddSingleton<MyMemoryCache>();

MyMemoryCache est créé en tant que cache de mémoire indépendant pour les composants qui connaissent ce cache de taille limitée et savent comment définir la taille d’entrée du cache de manière appropriée.

La taille de l’entrée de cache peut être définie à l’aide de la SetSize méthode d’extension ou de la Size propriété :

if (!_myMemoryCache.Cache.TryGetValue(CacheKeys.Entry, out DateTime cacheValue))
{
    var cacheEntryOptions = new MemoryCacheEntryOptions()
        .SetSize(1);

    // cacheEntryOptions.Size = 1;

    _myMemoryCache.Cache.Set(CacheKeys.Entry, cacheValue, cacheEntryOptions);
}

Dans le code précédent, les deux lignes en surbrillance obtiennent le même résultat en définissant la taille de l’entrée de cache. La SetSize méthode est fournie pour des raisons pratiques lors du chaînage des appels sur new MemoryCacheOptions().

Supprimer des éléments de cache avec MemoryCache.Compact

La MemoryCache.Compact méthode tente de supprimer le pourcentage spécifié du cache dans l’ordre suivant :

• Tous les éléments expirés
• Éléments par priorité, où les éléments de priorité les plus bas sont supprimés en premier
• Objets les moins récemment utilisés
• Éléments avec l’expiration absolue la plus ancienne
• Éléments avec l’expiration glissante la plus ancienne

Les éléments épinglés avec la priorité NeverRemovene sont jamais supprimés. Le code suivant supprime un élément de cache et appelle la Compact méthode pour supprimer 25% d’entrées mises en cache :

_myMemoryCache.Cache.Remove(CacheKeys.Entry);
_myMemoryCache.Cache.Compact(.25);

Pour plus d’informations, consultez la source Compact sur GitHub.

Supprimer une entrée de cache avec des dépendances expirées

L’exemple suivant montre comment faire expirer une entrée de cache si une entrée dépendante expire. Un CancellationChangeToken est ajouté à l’élément mis en cache. Lorsque la Cancel méthode est appelée sur l’objet, les deux entrées du CancellationTokenSource cache sont supprimées :

public void OnGetCacheCreateDependent()
{
    var cancellationTokenSource = new CancellationTokenSource();

    _memoryCache.Set(
        CacheKeys.DependentCancellationTokenSource,
        cancellationTokenSource);

    using var parentCacheEntry = _memoryCache.CreateEntry(CacheKeys.Parent);

    parentCacheEntry.Value = DateTime.Now;

    _memoryCache.Set(
        CacheKeys.Child,
        DateTime.Now,
        new CancellationChangeToken(cancellationTokenSource.Token));
}

public void OnGetCacheRemoveDependent()
{
    var cancellationTokenSource = _memoryCache.Get<CancellationTokenSource>(
        CacheKeys.DependentCancellationTokenSource);

    cancellationTokenSource.Cancel();
}

Lorsque vous utilisez un CancellationTokenSource objet, vous pouvez supprimer plusieurs entrées de cache en tant que groupe. Avec le using modèle dans le code précédent, les entrées de cache créées à l’intérieur de l’étendue using héritent des déclencheurs et des paramètres d’expiration.

Passer en revue les notes relatives à la mise en cache en mémoire

Les notes suivantes s’appliquent à la mise en cache en mémoire :

• L’expiration ne se produit pas en arrière-plan.

  Il n’y a pas de minuterie qui analyse activement le cache à la recherche d’éléments expirés. Toute activité sur le cache (via Get, , TryGetValueou SetRemove) peut déclencher une analyse en arrière-plan pour les éléments expirés. Un minuteur défini sur l’objet CancellationTokenSource (à l’aide de la CancelAfter méthode) supprime également l’entrée et déclenche une analyse des éléments expirés.

  L’exemple suivant utilise le CancellationTokenSource(TimeSpan) constructeur surchargé pour le jeton enregistré. Lorsque ce jeton est déclenché, il supprime immédiatement l’entrée et lance les rappels d’expulsion :

  if (!_memoryCache.TryGetValue(CacheKeys.Entry, out DateTime cacheValue))
  {
      cacheValue = DateTime.Now;
  
      var cancellationTokenSource = new CancellationTokenSource(
          TimeSpan.FromSeconds(10));
  
      var cacheEntryOptions = new MemoryCacheEntryOptions()
          .AddExpirationToken(
              new CancellationChangeToken(cancellationTokenSource.Token))
          .RegisterPostEvictionCallback((key, value, reason, state) =>
          {
              ((CancellationTokenSource)state).Dispose();
          }, cancellationTokenSource);
  
      _memoryCache.Set(CacheKeys.Entry, cacheValue, cacheEntryOptions);
  }
  

• Lorsque vous utilisez un rappel pour remplir à nouveau un élément de cache :

  • Plusieurs requêtes peuvent découvrir que la valeur de clé mise en cache est vide, car le rappel n’est pas terminé.
  • Cette approche peut entraîner la mise à jour de l'élément mis en cache par plusieurs threads.

• Lorsqu’une entrée de cache (le parent) crée une autre entrée (l’enfant), l’enfant copie les jetons d’expiration de l’entrée parente et les paramètres d’expiration basés sur le temps. L'enfant ne expire pas par suppression manuelle ou mise à jour de l'entrée du parent (parent entry).

• Utilisez la PostEvictionCallbacks propriété pour spécifier les rappels à déclencher une fois qu’une entrée de cache est supprimée du cache.

• Pour la plupart des applications, IMemoryCache est activé. Par exemple, l'appel des méthodes AddMvc, AddControllersWithViews, AddRazorPages, AddMvcCore().AddRazorViewEngine, et de nombreuses autres Add{Service} dans le fichier Program.cs active IMemoryCache.

  Pour les applications qui n’appellent pas l’une des méthodes mentionnées Add{Service} , vous devrez peut-être appeler la AddMemoryCache méthode dans le fichier Program.cs .

Utiliser une mise à jour du cache en arrière-plan

Utilisez un service en arrière-plan tel que l’interface IHostedService pour mettre à jour le cache. Le service en arrière-plan peut recompiler les entrées et les affecter au cache uniquement une fois qu’elles sont prêtes.

Contenu connexe

• Afficher ou télécharger un exemple de code (comment télécharger)
• Détecter les modifications avec des jetons de modification dans ASP.NET Core
• Mise en cache des réponses dans ASP.NET Core