Caché en C#: Redis, Memcached y soluciones integradas de .NET

Almacenamiento en caché en C#: Redis, Memcached y soluciones integradas para .NET

El almacenamiento en caché es una de las herramientas clave para mejorar el rendimiento de las aplicaciones en C#. Permite reducir el tiempo de respuesta, disminuir la carga en las bases de datos y las API externas. En el ecosistema .NET hay varios enfoques disponibles: desde el integrado MemoryCache hasta soluciones distribuidas basadas en Redis y Memcached. En este artículo analizaremos cada opción, mostraremos ejemplos de código y daremos recomendaciones para su elección.

1. Almacenamiento en caché integrado: MemoryCache e IDistributedCache

La plataforma .NET proporciona dos mecanismos abstractos principales para trabajar con la caché: IMemoryCache (en proceso) y IDistributedCache (distribuido).

1.1 IMemoryCache

Almacena datos en la memoria del proceso. Ideal para aplicaciones de un solo subproceso o monolíticas donde no se requiere sincronización entre varios servidores. Es simple de configurar y no requiere dependencias externas.

// Adición en DI (Program.cs)builder.Services.AddMemoryCache();

// Uso en un serviciopublic 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;        }

        // Emulación de una solicitud larga        await Task.Delay(2000);        string result = $"Clima en {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

Abstracción para caché distribuida. Permite cambiar fácilmente entre proveedores (Redis, SQL Server, NCache) sin modificar la lógica de negocio. Por defecto, almacena datos en formato byte[].

// Registro (Program.cs) - usamos 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 a la 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: caché distribuida con capacidades avanzadas

Redis es la solución más popular para almacenamiento en caché en .NET. Funciona como un almacenamiento en memoria de alto rendimiento con soporte para estructuras de datos complejas (listas, hashes, conjuntos).

2.1 Instalación y configuración

Para conectar Redis a .NET use el paquete Microsoft.Extensions.Caching.StackExchangeRedis.

dotnet add package Microsoft.Extensions.Caching.StackExchangeRedis

2.2 Ejemplo con Redis e IDistributedCache

Además del almacenamiento en caché básico, Redis permite implementar:

• sesiones de usuario — almacenamiento de datos de sesión entre solicitudes.
• bloqueos