Caché en C# (.NET): Redis y alternativas

Caché en C# (.NET): Redis y otras herramientas para acelerar aplicaciones

El almacenamiento en caché es una de las formas más efectivas de mejorar el rendimiento y la escalabilidad de las aplicaciones en C# (.NET). En este artículo, analizaremos en detalle los mecanismos de caché integrados, las bibliotecas populares para trabajar con Redis, así como soluciones alternativas. Aprenderá cómo elegir la herramienta adecuada para su tarea y evitar errores típicos.

Mecanismos de caché integrados en .NET

La plataforma .NET proporciona varias soluciones listas para usar para el almacenamiento en caché que se adaptan a la mayoría de los escenarios sin necesidad de instalar dependencias de terceros.

1. MemoryCache (System.Runtime.Caching)

Caché integrada en la memoria del proceso. Ideal para aplicaciones de un solo subproceso o cargas pequeñas. Los datos se almacenan en la memoria RAM y se eliminan automáticamente cuando faltan 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)

Abstracción para caché distribuida. Permite cambiar fácilmente entre Redis, SQL Server, NCache y otros proveedores. Recomendado para microservicios y aplicaciones en la nube.

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: el rey del caché distribuido

Redis es un almacén de datos en memoria de alto rendimiento que admite cadenas, listas, hashes, conjuntos y otras estructuras. Para .NET, la biblioteca principal es StackExchange.Redis.

Instalación y configuración de StackExchange.Redis

Instale el paquete a través de NuGet:

dotnet add package StackExchange.Redis

Ejemplo de conexión y operaciones 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);    }}