Implémentations C # dans C # .NET

Cache local, cache local persistant et cache distribué

• Le cache en mémoire est utilisé dans les cas où vous avez juste besoin d'implémenter le cache en un seul processus. Lorsqu'un processus meurt, le cache meurt avec lui. Si vous exécutez le même processus sur plusieurs serveurs, vous disposerez d'un cache distinct pour chaque serveur.
• Cache persistant en cours - c'est lorsque vous sauvegardez le cache en dehors de la mémoire du processus. Il peut être localisé dans un fichier ou dans une base de données. Il est plus complexe que le cache en mémoire, mais si votre processus redémarre, le cache n'est pas vidé. Idéal pour les cas où l'obtention d'un élément mis en cache coûte cher et que votre processus a tendance à redémarrer fréquemment.
• Le cache distribué est lorsque vous avez besoin d'un cache partagé pour plusieurs machines. Il s'agit généralement de plusieurs serveurs. Le cache distribué est stocké dans un service externe. Cela signifie que si un serveur a conservé un élément de cache, d'autres serveurs peuvent également l'utiliser. Des services comme Redis sont parfaits pour cela.

Implémentation primitive

public class NaiveCache<TItem>
{
    Dictionary<object, TItem> _cache = new Dictionary<object, TItem>();
 
    public TItem GetOrCreate(object key, Func<TItem> createItem)
    {
        if (!_cache.ContainsKey(key))
        {
            _cache[key] = createItem();
        }
        return _cache[key];
    }
}

var _avatarCache = new NaiveCache<byte[]>();
// ...
var myAvatar = _avatarCache.GetOrCreate(userId, () => _database.GetAvatar(userId));

1. Le cache peut commencer à occuper beaucoup de mémoire, ce qui conduit finalement à des exceptions en raison de sa pénurie et de ses plantages.
2. Une consommation élevée de mémoire peut entraîner une pression mémoire (également connue sous le nom de pression GC ). Dans cet état, le garbage collector fonctionne beaucoup plus qu'il ne devrait, ce qui réduit les performances.
3. Le cache peut devoir être mis à jour lorsque les données changent. Notre infrastructure de mise en cache doit prendre en charge cette fonctionnalité.

• Une politique d'expiration absolue qui supprime un élément du cache après un certain temps, quoi qu'il arrive.
• Une politique d'expiration glissante qui supprime un élément du cache s'il n'a pas été consulté pendant un certain temps. Autrement dit, si je règle le délai d'expiration sur 1 minute, l'élément restera dans le cache pendant que je l'utilise toutes les 30 secondes. Si je ne l'utilise pas pendant plus d'une minute, l'élément sera supprimé.
• Politique de limite de taille , qui limitera la taille du cache.

De meilleures solutions

System.Runtime.Caching / MemoryCache vs Microsoft.Extensions.Caching.Memory

public class SimpleMemoryCache<TItem>
{
    private MemoryCache _cache = new MemoryCache(new MemoryCacheOptions());
 
    public TItem GetOrCreate(object key, Func<TItem> createItem)
    {
        TItem cacheEntry;
        if (!_cache.TryGetValue(key, out cacheEntry)) //    .
        {
            //    ,   .
            cacheEntry = createItem();
            
            //    . 
            _cache.Set(key, cacheEntry);
        }
        return cacheEntry;
    }
}

var _avatarCache = new SimpleMemoryCache<byte[]>();
// ...
var myAvatar = _avatarCache.GetOrCreate(userId, () => _database.GetAvatar(userId));

public class MemoryCacheWithPolicy<TItem>
{
    private MemoryCache _cache = new MemoryCache(new MemoryCacheOptions()
    {
        SizeLimit = 1024
    });
 
    public TItem GetOrCreate(object key, Func<TItem> createItem)
    {
        TItem cacheEntry;
        if (!_cache.TryGetValue(key, out cacheEntry))//    .
        {
            //    ,   . 
            cacheEntry = createItem();
 
            var cacheEntryOptions = new MemoryCacheEntryOptions()
         	.SetSize(1)// 
         	//        (  )
                .SetPriority(CacheItemPriority.High)
                //       ,    .
                 .SetSlidingExpiration(TimeSpan.FromSeconds(2))
                //       ,    .
                .SetAbsoluteExpiration(TimeSpan.FromSeconds(10));
 
            //    .
            _cache.Set(key, cacheEntry, cacheEntryOptions);
        }
        return cacheEntry;
    }
}

1. Le MemoryCacheOptions a été ajouté SizeLimit. Cela ajoute une politique de limite de taille à notre conteneur de cache. Le cache n'a pas de mécanisme pour mesurer la taille des enregistrements. Par conséquent, nous devons définir la taille de chaque entrée de cache. Dans ce cas, chaque fois que nous définissons la taille sur 1 avec SetSize(1). Cela signifie que notre cache aura une limite de 1024 éléments.
2. , ? .SetPriority (CacheItemPriority.High). : Low (), Normal (), High () NeverRemove ( ).
3. SetSlidingExpiration(TimeSpan.FromSeconds(2)) 2 . , 2 , .
4. SetAbsoluteExpiration(TimeSpan.FromSeconds(10)) 10 . , 10 , .

Problèmes et fonctionnalités manquantes

1. Bien que vous puissiez définir une limite de taille, la mise en cache ne contrôle pas réellement la pression de la mémoire. Si nous surveillions, nous pourrions resserrer la politique à haute pression et affaiblir la politique à faible.
2. , . . , , , 10 . 2 , , ( ), .

public class WaitToFinishMemoryCache<TItem>
{
    private MemoryCache _cache = new MemoryCache(new MemoryCacheOptions());
    private ConcurrentDictionary<object, SemaphoreSlim> _locks = new ConcurrentDictionary<object, SemaphoreSlim>();
 
    public async Task<TItem> GetOrCreate(object key, Func<Task<TItem>> createItem)
    {
        TItem cacheEntry;
 
        if (!_cache.TryGetValue(key, out cacheEntry))//    .
        {
            SemaphoreSlim mylock = _locks.GetOrAdd(key, k => new SemaphoreSlim(1, 1));
 
            await mylock.WaitAsync();
            try
            {
                if (!_cache.TryGetValue(key, out cacheEntry))
                {
                    //    ,   .
                    cacheEntry = await createItem();
                    _cache.Set(key, cacheEntry);
                }
            }
            finally
            {
                mylock.Release();
            }
        }
        return cacheEntry;
    }
}

var _avatarCache = new WaitToFinishMemoryCache<byte[]>();
// ...
var myAvatar =
await _avatarCache.GetOrCreate(userId, async () => await _database.GetAvatar(userId));

Analyse de code

Quand utiliser WaitToFinishMemoryCache

• Lorsque l'heure de création d'un élément a une valeur et que vous souhaitez minimiser autant que possible le nombre de créations.
• Lorsque le temps de créer un élément est très long.
• Quand un élément doit être créé une fois pour chaque clé.

• Il n'y a aucun danger que plusieurs threads accèdent au même élément de cache.
• Vous n'êtes pas catégoriquement contre la création d'éléments plus d'une fois. Par exemple, si une requête supplémentaire dans la base de données n'affecte pas grand-chose.

Sommaire