Cache em C#: Redis, Memcached e soluções integradas do A ao Z

Cache em C#: Redis, Memcached e soluções integradas — guia completo

No desenvolvimento web moderno, o desempenho da aplicação é um dos principais fatores de sucesso. O cache permite reduzir significativamente a carga no banco de dados e acelerar a resposta do sistema. No ecossistema C# (.NET), o desenvolvedor tem três abordagens principais: cache integrado em memória (IMemoryCache), soluções distribuídas (IDistributedCache) e servidores de cache externos, como Redis e Memcached. Neste artigo, abordaremos cada um deles, da teoria aos exemplos práticos de código.

1. Cache integrado no .NET: IMemoryCache

O cache integrado é a maneira mais simples e rápida de armazenar dados temporariamente. No ASP.NET Core, ele é implementado através da interface IMemoryCache. Os dados são armazenados na memória RAM de um único processo, garantindo latência mínima.

Quando usar:

• Os dados não precisam ser sincronizados entre vários servidores.
• O volume de dados em cache é pequeno.
• É necessário desempenho máximo sem configurar serviços externos.

Exemplo de implementação:

using Microsoft.Extensions.Caching.Memory;

public class WeatherService{    private readonly IMemoryCache _cache;

    public WeatherService(IMemoryCache cache)    {        _cache = cache;    }

    public async Task<WeatherData> GetWeatherAsync(string city)    {        string cacheKey = $"weather_{city}";

        if (!_cache.TryGetValue(cacheKey, out WeatherData data))        {            // Dados não estão em cache — carregar de fonte externa            data = await FetchWeatherFromApi(city);

            // Configuração do cache: tempo de vida de 5 minutos            var cacheOptions = new MemoryCacheEntryOptions()                .SetAbsoluteExpiration(TimeSpan.FromMinutes(5));

            _cache.Set(cacheKey, data, cacheOptions);        }

        return data;    }

    private async Task<WeatherData> FetchWeatherFromApi(string city)    {        // Simulação de chamada de API externa        await Task.Delay(1000);        return new WeatherData { City = city, Temperature = 22.5 };    }}

public class WeatherData{    public string City { get; set; }    public double Temperature { get; set; }}

Métodos principais: TryGetValue, Set, Remove. É importante lembrar que IMemoryCache não é adequado para arquitetura de microsserviços.

2. Cache distribuído: IDistributedCache e seus provedores

Para aplicações que rodam em vários servidores, é necessário o cache distribuído. No .NET, ele é abstraído através da interface IDistributedCache. Isso permite trocar facilmente o provedor (Redis, SQL Server, NCache) sem alterar a lógica de negócios.

Métodos principais:

• GetAsync / SetAsync — para trabalhar com bytes.
• GetStringAsync / SetStringAsync — para dados de string.
• RefreshAsync — reiniciar o timer de expiração deslizante.
• RemoveAsync — remover um registro.

Exemplo com Redis:

// Em Program.cs registramos o provedorbuilder.Services.AddStackExchangeRedisCache(options =>{    options.Configuration = "localhost:6379";    options.InstanceName = "SampleApp";});

// Uso no serviçopublic class ProductService{    private readonly IDistributedCache _cache;

    public ProductService(IDistributedCache cache)    {        _cache = cache;    }

    public async Task<Product> GetProductAsync(int id)    {        string cacheKey = $"product_{id}";        string cachedData = await _cache.GetStringAsync(cacheKey);

        if