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

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

Cache é uma das principais ferramentas de otimização de desempenho em aplicações web modernas. No ecossistema C# (.NET), o desenvolvedor tem acesso tanto a mecanismos integrados (IMemoryCache, IDistributedCache) quanto a soluções externas poderosas (Redis, Memcached). Neste artigo, analisaremos suas características, compararemos o desempenho e forneceremos exemplos práticos de código.

1. Soluções integradas .NET: IMemoryCache e IDistributedCache

ASP.NET Core fornece duas interfaces principais para trabalhar com cache: IMemoryCache (cache local na memória de um único processo) e IDistributedCache (abstração para cache distribuído).

IMemoryCache

Ideal para aplicações monolíticas ou microsserviços onde não é necessária sincronização entre instâncias. O cache é armazenado na memória RAM do servidor.

// Registro em Program.csbuilder.Services.AddMemoryCache();

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

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

    public async Task<string> GetExpensiveDataAsync(int id)    {        string cacheKey = $"data_{id}";        if (_cache.TryGetValue(cacheKey, out string cachedData))        {            return cachedData;        }

        // Emulação de operação pesada        await Task.Delay(500);        string data = $"Result for {id}";

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

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

IDistributedCache

Abstração que permite conectar diferentes backends (Redis, SQL Server, NCache) sem alterar o código da aplicação. É registrado através de AddDistributedRedisCache ou AddDistributedSqlServerCache.

// Exemplo com Redisbuilder.Services.AddStackExchangeRedisCache(options =>{    options.Configuration = "localhost:6379";    options.InstanceName = "SampleInstance";});

// Usopublic class DistributedService{    private readonly IDistributedCache _cache;

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

    public async Task<string> GetDataAsync(string key)    {        var cached = await _cache.GetStringAsync(key);        if (cached != null) return cached;

        var data = $"Computed at {DateTime.Now}";        await _cache.SetStringAsync(key, data, new DistributedCacheEntryOptions        {            AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(5)        });        return data;    }}

2. Redis: cache distribuído poderoso para C#

Redis é um armazenamento de dados in-memory com suporte a estruturas complexas (listas, conjuntos, hashes). Para .NET, são usados o cliente StackExchange.Redis ou o wrapper de alto nível Microsoft.Extensions.Caching.StackExchangeRedis.

Vantagens do Redis em C#:

• Velocidade: latências submilissegundo (em média 0,5-1 ms).
• Pub/Sub: possibilidade de notificar outros serviços sobre alterações no cache.
• Persistência: dados podem ser salvos em disco (RDB/AOF).
• Clusterização: escalabilidade horizontal nativa.

Exemplo de uso avançado com serialização JSON:

using StackExchange.Redis;using System.Text.Json;

public class RedisCacheService{    private readonly IDatabase _db;    private readonly ConnectionMultiplexer _redis;

    public RedisCacheService(string connectionString)    {        _redis = ConnectionMultiplexer.Connect(connectionStri