Cache em C# (.NET): Redis e alternativas

Cache em C# (.NET): Redis e outras ferramentas para acelerar aplicações

Cache é uma das maneiras mais eficazes de melhorar o desempenho e a escalabilidade de aplicações em C# (.NET). Neste artigo, abordaremos detalhadamente os mecanismos de cache integrados, bibliotecas populares para trabalhar com Redis, bem como soluções alternativas. Você aprenderá como escolher a ferramenta certa para sua tarefa e evitar erros comuns.

Mecanismos de cache integrados no .NET

A plataforma .NET oferece várias soluções prontas para cache que atendem à maioria dos cenários sem a necessidade de instalar dependências de terceiros.

1. MemoryCache (System.Runtime.Caching)

Cache integrado na memória do processo. Ideal para aplicações single-thread ou cargas pequenas. Os dados são armazenados na RAM e removidos automaticamente quando há falta de recursos.

using System.Runtime.Caching;

public class MemoryCacheService{    private readonly MemoryCache _cache = MemoryCache.Default;

    public T GetOrSet<T>(string key, Func<T> factory, int expirationMinutes = 5)    {        var cached = _cache.Get(key);        if (cached != null) return (T)cached;

        var result = factory();        var policy = new CacheItemPolicy        {            AbsoluteExpiration = DateTimeOffset.UtcNow.AddMinutes(expirationMinutes)        };        _cache.Set(key, result, policy);        return result;    }}

2. IDistributedCache (Microsoft.Extensions.Caching)

Abstração para cache distribuído. Permite alternar facilmente entre Redis, SQL Server, NCache e outros provedores. Recomendado para microsserviços e aplicações em nuvem.

using Microsoft.Extensions.Caching.Distributed;using System.Text.Json;

public class DistributedCacheService{    private readonly IDistributedCache _cache;

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

    public async Task<T> GetOrSetAsync<T>(string key, Func<Task<T>> factory, int expirationMinutes = 10)    {        var cached = await _cache.GetStringAsync(key);        if (cached != null) return JsonSerializer.Deserialize<T>(cached);

        var result = await factory();        var options = new DistributedCacheEntryOptions        {            AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(expirationMinutes)        };        await _cache.SetStringAsync(key, JsonSerializer.Serialize(result), options);        return result;    }}

Redis: o rei do cache distribuído

Redis é um armazenamento de dados in-memory de alto desempenho que suporta strings, listas, hashes, conjuntos e outras estruturas. Para .NET, a principal biblioteca é StackExchange.Redis.

Instalação e configuração do StackExchange.Redis

Instale o pacote via NuGet:

dotnet add package StackExchange.Redis

Exemplo de conexão e operações básicas:

using StackExchange.Redis;

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

    public RedisCacheService(string connectionString)    {        _redis = ConnectionMultiplexer.Connect(connectionString);        _db = _redis.GetDatabase();    }

    public async Task SetAsync(string key, string value, int expirationMinutes = 5)    {        await _db.StringSetAsync(key, value, TimeSpan.FromMinutes(expirationMinutes));    }

    public async Task<string> GetAsync(string key)    {        return await _db.StringGetAsync(key);    }}