ASP .NET Core - Apresentando e usando In-Memory Caching

Neste artigo vamos tratar do Cache na ASP .NET Core, os conceitos básicos, os tipos de cache e vamos focar no In-Memory Cache mostrando como funciona e como usar o recurso em uma aplicação ASP .NET Core.

O Cache é uma técnica de armazenamento de dados acessados/usados com freqüência para que as requisições futuras desses conjuntos de dados possam ser atendidas com muito mais rapidez para o cliente.

Ou seja, você pega os dados usados com mais freqüência e que também são menos modificados, e os copia para o armazenamento temporário para que possam ser acessados com muito mais rapidez nas chamadas futuras do cliente. Essa técnica pode aumentar o desempenho do seu aplicativo drasticamente, removendo requisições desnecessárias e freqüentes para a fonte de dados.

Teoricamente, é assim que o cache funcionaria.

O Cliente 1 solicita alguns dados que leva cerca de 20 segundos para ser obtido;
Durante a busca, também vamos copiar paralelamente esses dados buscados para o armazenamento temporário;
Agora, quando um Cliente 2 solicitar os mesmos dados, ele leva algo entre 1 a 2 segundos para obter uma resposta, visto que os dados estão em cache;

Mas você deve estar pensando...

O que acontecerá se os dados mudarem ?

Ainda estaremos fornecendo uma resposta desatualizada ?

Não, existem várias maneiras de atualizar o cache e também definir o tempo de expiração do cache como veremos mais adiante.

É importante observar que os aplicativos devem ser projetados de forma que nunca dependam diretamente da memória em cache. O aplicativo deve usar os dados de cache apenas se estiverem disponíveis. Se os dados do cache expiraram ou não estão disponíveis, o aplicativo deve solicitar os dados a partir da fonte de dados original.

O Cache na ASP .NET Core

A ASP.NET Core tem um ótimo suporte pronto para uso para vários tipos de cache, dentre eles temos:

In-Memory Caching ou Cache na memória - Onde os dados são armazenados em cache na memória do servidor;
Distributed Cache ou Cache distribuído - Os dados são armazenados externamente ao aplicativo em fontes como cache Redis, etc.;

Neste artigo, vamos focar no cache na memória.

Com o ASP.NET Core, agora é possível armazenar em cache os dados dentro do aplicativo. Isso é conhecido como cache na memória no ASP.NET Core e é o cache mais simples estando baseado no IMemoryCache que representa um cache armazenado na memória do servidor Web.

O aplicativo armazena os dados na instância do servidor (o cache na memória pode armazenar qualquer objeto) que, por sua vez, melhora drasticamente o desempenho do aplicativo. Esta é provavelmente a maneira mais fácil de implementar o cache em seu aplicativo.

Vejamos os Prós e Contras do cache na memória :

Prós

Muito mais rápido do que outras formas de cache distribuído, pois evita a comunicação em uma rede.
Altamente confiável.
Mais adequado para aplicações de pequena e média escala.

Contras

Se configurado incorretamente, ele pode consumir os recursos do seu servidor;
Com o dimensionamento do aplicativo e períodos de armazenamento em cache mais longos, pode ser caro manter o servidor;
Se implantado na nuvem, manter caches consistentes pode ser difícil;

Usando o Cache

Configurar o cache no ASP.NET Core é bem simples. São apenas algumas linhas de código que podem melhorar o tempo de feedback do seu aplicativo em mais de 50-75% facilmente!

O cache na memória no ASP.NET Core é um serviço que deve ser registrado no contêiner de serviço do aplicativo. Iremos usá-lo com a ajuda da injeção de dependência posteriormente.

Vamos criar uma nova solução Web API ASP.NET Core 3.1 no Visual Studio 2019 chamada Aspn_Cache1;

Crie um novo projeto via menu File-> New Project;

Selecionando o template API;

Clicando em Create teremos o projeto Web API criado.

Depois disso, basta navegar até a classe Startup.cs e adicionar a seguinte linha, destacada em azul, ao método ConfigureServices :

public void ConfigureServices(IServiceCollection services)
{
            services.AddMemoryCache();
            services.AddControllers();
 }

Isso adiciona uma implementação não distribuída na memória ao IServiceCollection.

É isso aí. Seu aplicativo agora suporta hospedagem na memória. Agora, para obter uma melhor compreensão de como o cache funciona, criaremos um endpoint simples que pode definir e obter o cache. Também exploraremos as configurações de expiração para armazenamento em cache no ASP.NET Core.

EndPoint para obter/definir o cache na memória

Na pasta Controllers, adicione um novo Empty API Controller chamado CacheController onde vamos definir apenas 2 endpoints usando os métodos GET e POST conforme código a seguir:

Get() - Retorna uma string com data de acesso da API;
GetCache(string key)
SetCache(CacheRquest data)

Route("api/[controller]")]
[ApiController]
public class CacheController : ControllerBase
{
    private readonly IMemoryCache memoryCache;
    public CacheController(IMemoryCache memoryCache)
    {
        this.memoryCache = memoryCache;
    }

    [HttpGet]
    public string Get()
    {
       return "API CacheController acessada em " + DateTime.Now;
    }

    [HttpGet("{key}")]
    public IActionResult GetCache(string key)
    {
        string value = string.Empty;
        memoryCache.TryGetValue(key, out value);
        return Ok(value);
    }


    [HttpPost]
    public IActionResult SetCache(CacheRequest data)
    {
        var cacheExpiryOptions = new MemoryCacheEntryOptions
        {
            AbsoluteExpiration = DateTime.Now.AddMinutes(5),
            Priority = CacheItemPriority.High,
            SlidingExpiration = TimeSpan.FromMinutes(2),
            Size = 1024,
        };
        memoryCache.Set(data.key, data.value, cacheExpiryOptions);
        
        return Ok($"Dados colocados no cache {data.key} - {data.value}");
    }

    public class CacheRequest
    {
        public string key { get; set; }
        public string value { get; set; }
    }
}

O código acima define a utilização do IMemoryCache para acessar a implementação In-memory na ASP .NET Core via injeção de dependência no construtor da classe.

O Método POST será responsável pela configuração do cache; ele funciona de forma bem semelhante a um dicionário C#. Isso significa que você precisará de 2 parâmetros, uma chave e um valor, e, usaremos a chave para identificar o valor (dados).

O Cache que definimos pode ser visualizado usando o Endpoint GET, mas isso depende se o cache está disponível/expirou/existe.

Definindo o Cache

A definição do Cache é feita usando um método POST que aceita um objeto com propriedade de chave e valor:

public IActionResult SetCache(CacheRequest data)
{
}

Usamos a classe MemoryCacheEntryOptions para definir as as propriedades do armazenamento em cache em questão. Estaremos criando uma instância desta classe e passando para o objeto memoryCache mais tarde. Mas antes disso, vamos entender as propriedades de MemoryCacheEntryOptions:

Priority - Define a prioridade de manter a entrada de cache no cache. A configuração padrão é Normal. Outras opções são: High, Low e Never Remove;
Size - Permite definir o tamanho desta entrada de cache específica, para que ela não comece a consumir os recursos do servidor;
Sliding Expiration - Um período de tempo definido dentro do qual uma entrada de cache irá expirar se não for usada por ninguém neste período de tempo específico. No nosso exemplo, vaus definir 2 minutos. Se, após configurar o cache, nenhum cliente solicitar essa entrada de cache por 2 minutos, o cache será excluído;
Absolute Expiration - O problema com a Sliding Expiration é que, teoricamente, ela pode durar para sempre. Digamos que alguém solicite os dados a cada 1,59 minutos pelos próximos dias, o aplicativo estaria tecnicamente servindo um cache desatualizado por vários dias.

Com a Absolute Expiration, podemos definir a expiração real da entrada do cache. No exemplo usamos 5 minutos. Assim, a cada 5 minutos, sem levar em consideração a Sliding Expiration, o cache irá expirar. É sempre uma boa prática usar essas duas verificações de expiração para melhorar o desempenho. Mas lembre-se, a Absolute Expiration NUNCA DEVE SER MENOR que a Sliding Expiration.

Para configurar o Cache efetivamente usamos o método Set passando parâmetros como Key, Value e a classe de opções criada cacheExpiryOptions:

memoryCache.Set(data.key, data.value, cacheExpiryOptions);

Assim, configuramos e criamos o cache In-Memory na ASP .NET Core.

Retornando a entrada do Cache

Vamos agora mostrar como retornar um valor da entrada do cache.

Para isso vamos usar o método POST para definir o cache.

E vamos usar os seguintes parâmetros para key e value: key = “Nome”, value = “Macoratti.net”.

Depois de definir essa entrada no request no formato JSON vamos precisar de um método para poder recuperar o valor.

O método GetCache é um método GET que aceita a chave como parâmetro. É um método simples onde você acessa o objeto memoryCache e tenta obter um valor que corresponde à chave inserida. Isso significa que, se você passar a chave como “Nome”, deverá obter “Macoratti” como sua resposta.

Vamos então usar o Postman e mostrar isso funcionando...

Antes temos que ajustar o valor da propriedade para iniciar a aplicação no arquivo launchSettings.json como:
"launchUrl": "api/cache",

Executando o projeto vamos obter no navegador o resultado do método Get:

Agora vamos definir um valor no cache no Postman usando o método POST:

Pronto ! já temos os dados no cache.

Uma vez que o Cache esta definido, vamos recuperar a entrada do cache.

Vamos fazer a seguinte chamada usando o método GET : https://localhost:4437/api/cache/{key}

onde a key é chave que acabamos de definir no POST e tem o valor de "Nome".

Assim no lugar de {key} vamos informar Nome no request e enviar a requisição.

Ai, podemos confirmar o valor 'Macoratti.net' que oi recuperado do cache.

Com isso, acho que você entendeu muito bem como o cache realmente funciona no ASP.NET Core.

Agora, esta é uma implementação muito simples de cache que não faz muito sentido em um nível prático, certo ?

Portanto, em outro artigo vamos fazer uma implementação mais prática em que você pode usar esse armazenamento em cache em cenários do mundo real.

O projeto completo aqui: Aspn_Cache1.zip (sem as referências)

"E em nada vos espanteis dos que resistem, o que para eles, na verdade, é indício de perdição, mas para vós de salvação, e isto de Deus. Porque a vós vos foi concedido, em relação a Cristo, não somente crer nele, como também padecer por ele"
Filipenses 1:28,29

Referências:

José Carlos Macoratti