Implementaciones de C # en C # .NET

Caché local, caché local persistente y caché distribuida

• La memoria caché en memoria se usa para casos en los que solo necesita implementar la memoria caché en un proceso. Cuando un proceso muere, el caché muere con él. Si está ejecutando el mismo proceso en varios servidores, tendrá un caché separado para cada servidor.
• Caché en proceso persistente : esto es cuando realiza una copia de seguridad del caché fuera de la memoria del proceso. Se puede ubicar en un archivo o en una base de datos. Es más complejo que el caché en la memoria, pero si el proceso se reinicia, el caché no se vacía. Se adapta mejor a los casos en los que obtener un elemento almacenado en caché es costoso y su proceso tiende a reiniciarse con frecuencia.
• La caché distribuida es cuando necesita una caché compartida para varias máquinas. Por lo general, estos son varios servidores. El caché distribuido se almacena en un servicio externo. Esto significa que si un servidor ha retenido un elemento de caché, otros servidores también pueden usarlo. Servicios como Redis son excelentes para esto.

Implementación primitiva

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. Un caché puede comenzar a ocupar mucha memoria, lo que en última instancia conduce a excepciones debido a su escasez y bloqueos.
2. El alto consumo de memoria puede conducir a la presión de la memoria (también conocida como Presión GC ). En este estado, el recolector de basura funciona mucho más de lo que debería, lo que reduce el rendimiento.
3. Es posible que sea necesario actualizar el caché cuando cambien los datos. Nuestra infraestructura de almacenamiento en caché debe ser compatible con esta característica.

• Una política de caducidad absoluta que elimina un elemento del caché después de un período de tiempo fijo, pase lo que pase.
• Una política de caducidad deslizante que elimina un elemento de la memoria caché si no se ha accedido a él durante un cierto período de tiempo. Es decir, si configuro el tiempo de caducidad en 1 minuto, el elemento permanecerá en el caché mientras lo uso cada 30 segundos. Si no lo uso durante más de un minuto, el elemento se eliminará.
• Política de límite de tamaño , que limitará el tamaño de la memoria caché.

Mejores soluciones

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. MemoryCacheOptions ha sido agregado SizeLimit. Esto agrega una política de límite de tamaño a nuestro contenedor de caché. El caché no tiene un mecanismo para medir el tamaño de los registros. Por lo tanto, necesitamos establecer el tamaño de cada entrada de caché. En este caso, cada vez que establecemos el tamaño en 1 con SetSize(1). Esto significa que nuestro caché tendrá un límite de 1024 elementos.
2. , ? .SetPriority (CacheItemPriority.High). : Low (), Normal (), High () NeverRemove ( ).
3. SetSlidingExpiration(TimeSpan.FromSeconds(2)) 2 . , 2 , .
4. SetAbsoluteExpiration(TimeSpan.FromSeconds(10)) 10 . , 10 , .

Problemas y características faltantes

1. Si bien puede establecer un límite de tamaño, el almacenamiento en caché en realidad no controla la presión de la memoria. Si monitoreamos, podríamos endurecer la política con alta presión y debilitar la política con baja.
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));

Análisis de código

Cuándo usar WaitToFinishMemoryCache

• Cuando el tiempo de creación de un elemento tiene algún valor, y desea minimizar el número de creaciones tanto como sea posible.
• Cuando el tiempo para crear un artículo es muy largo.
• Cuando un elemento debe crearse una vez para cada clave.

• No hay peligro de que varios subprocesos obtengan acceso al mismo elemento de caché.
• No está categóricamente en contra de crear elementos más de una vez. Por ejemplo, si una consulta adicional a la base de datos no afecta mucho a nada.

Resumen