Cache em C#: Redis, Memcached e soluções integradas .NET

Cache em C#: Redis, Memcached e soluções integradas para .NET

Cache é uma das ferramentas-chave para melhorar o desempenho de aplicações em C#. Ele permite reduzir o tempo de resposta, diminuir a carga em bancos de dados e APIs externas. No ecossistema .NET, existem várias abordagens disponíveis: desde o MemoryCache integrado até soluções distribuídas baseadas em Redis e Memcached. Neste artigo, vamos analisar cada opção, mostrar exemplos de código e dar recomendações de escolha.

1. Cache integrado: MemoryCache e IDistributedCache

A plataforma .NET fornece dois mecanismos abstratos principais para trabalhar com cache: IMemoryCache (in-process) e IDistributedCache (distribuído).

1.1 IMemoryCache

Armazena dados na memória do processo. Ideal para aplicações single-thread ou monolíticas, onde não é necessária sincronização entre vários servidores. Simples de configurar e não requer dependências externas.

// Adicionando ao DI (Program.cs)builder.Services.AddMemoryCache();

// Uso no serviçopublic class WeatherService{    private readonly IMemoryCache _cache;

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

    public async Task<string> GetWeatherAsync(string city)    {        string cacheKey = $"weather_{city}";        if (_cache.TryGetValue(cacheKey, out string cachedData))        {            return cachedData;        }

        // Emulação de uma requisição longa        await Task.Delay(2000);        string result = $"Clima em {city}: +25°C";

        var options = new MemoryCacheEntryOptions()            .SetAbsoluteExpiration(TimeSpan.FromMinutes(5))            .SetSlidingExpiration(TimeSpan.FromMinutes(2));

        _cache.Set(cacheKey, result, options);        return result;    }}

1.2 IDistributedCache

Abstração para cache distribuído. Permite alternar facilmente entre provedores (Redis, SQL Server, NCache) sem alterar a lógica de negócios. Por padrão, armazena dados como byte[].

// Registro (Program.cs) - usando Redisbuilder.Services.AddStackExchangeRedisCache(options =>{    options.Configuration = "localhost:6379";});

// Usopublic class ProductService{    private readonly IDistributedCache _cache;

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

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

        if (cachedBytes != null)        {            return JsonSerializer.Deserialize<Product>(cachedBytes);        }

        // Consulta ao BD        var product = await GetProductFromDb(id);

        var options = new DistributedCacheEntryOptions()            .SetAbsoluteExpiration(TimeSpan.FromHours(1));

        var serialized = JsonSerializer.SerializeToUtf8Bytes(product);        await _cache.SetAsync(cacheKey, serialized, options);

        return product;    }}

2. Redis: cache distribuído com recursos avançados

Redis é a solução mais popular para cache em .NET. Funciona como um armazenamento in-memory de alto desempenho com suporte a estruturas de dados complexas (listas, hashes, conjuntos).

2.1 Instalação e configuração

Para conectar Redis ao .NET, use o pacote Microsoft.Extensions.Caching.StackExchangeRedis.

dotnet add package Microsoft.Extensions.Caching.StackExchangeRedis

2.2 Exemplo com Redis e IDistributedCache

Além do cache básico, o Redis permite implementar:

• Sessões de usuário — armazenamento de dados de sessão entre requisições.
• Bloqueios