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.
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:
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:
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:
ASP .NET Core - Implementando a segurança com ..
ASP.NET Core MVC - Criando um Dashboard ..
C# - Gerando QRCode - Macoratti
ASP .NET Core - CRUD usando Blazor e Entity ...
Vale a pena usar o Blazor
ASP .NET Core Blazor - Gerenciando Usuários e Perfis
ASP .NET - Gerando QRCode com a API do Google