Implementações de C # em C # .NET

Cache local, cache local persistente e cache distribuído

• O cache na memória é usado para casos em que você só precisa implementar o cache em um processo. Quando um processo morre, o cache morre com ele. Se você estiver executando o mesmo processo em vários servidores, terá um cache separado para cada servidor.
• Cache persistente no processo - é quando você faz o backup do cache fora da memória do processo. Pode ser localizado em um arquivo ou em um banco de dados. É mais complexo que o cache da memória, mas se o processo reiniciar, o cache não será liberado. Mais adequado para casos em que a obtenção de um item em cache é dispendiosa e seu processo tende a reiniciar com frequência.
• Cache distribuído é quando você precisa de um cache compartilhado para várias máquinas. Geralmente estes são vários servidores. O cache distribuído é armazenado em um serviço externo. Isso significa que, se um servidor reteve um elemento de cache, outros servidores também podem usá-lo. Serviços como Redis são ótimos para isso.

Implementação 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. Um cache pode começar a ocupar muita memória, o que acaba gerando exceções devido à sua falta e falhas.
2. Alto consumo de memória pode levar à pressão da memória (também conhecida como pressão do GC ). Nesse estado, o coletor de lixo trabalha muito mais do que deveria, o que reduz o desempenho.
3. O cache pode precisar ser atualizado quando os dados forem alterados. Nossa infraestrutura de armazenamento em cache deve suportar esse recurso.

• Uma política de Expiração absoluta que remove um item do cache após um período fixo de tempo, não importa o quê.
• Uma política de Expiração de Deslizamento que remove um item do cache se ele não for acessado por um determinado período de tempo. Ou seja, se eu definir o tempo de expiração para 1 minuto, o item permanecerá no cache enquanto eu o uso a cada 30 segundos. Se eu não usá-lo por mais de um minuto, o item será excluído.
• Política de limite de tamanho , que limitará o tamanho do cache.

Melhores Soluções

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. O MemoryCacheOptions foi adicionado SizeLimit. Isso adiciona uma política de limite de tamanho ao nosso contêiner de cache. O cache não possui um mecanismo para medir o tamanho dos registros. Portanto, precisamos definir o tamanho de cada entrada de cache. Nesse caso, sempre que definirmos o tamanho como 1 com SetSize(1). Isso significa que nosso cache terá um limite 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 e recursos ausentes

1. Embora você possa definir um limite de tamanho, o armazenamento em cache não controla a pressão da memória. Se monitorássemos, poderíamos restringir a política com alta pressão e enfraquecer a política com baixa.
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álise de código

Quando usar WaitToFinishMemoryCache

• Quando o tempo de criação de um item tiver algum valor e você desejar minimizar o número de criações o máximo possível.
• Quando o tempo para criar um item é muito longo.
• Quando um item deve ser criado uma vez para cada chave.

• Não há perigo de que vários threads obtenham acesso ao mesmo elemento de cache.
• Você não é categoricamente contra a criação de elementos mais de uma vez. Por exemplo, se uma consulta adicional ao banco de dados não afetar significativamente nada.

Sumário