Caché en C#: Redis, Memcached y soluciones integradas de la A a la Z

Caché en C#: Redis, Memcached y soluciones integradas — guía completa

En el desarrollo web moderno, el rendimiento de la aplicación es uno de los factores clave del éxito. El almacenamiento en caché permite reducir significativamente la carga en la base de datos y acelerar la respuesta del sistema. En el ecosistema de C# (.NET), el desarrollador tiene tres enfoques principales: caché integrada en memoria (IMemoryCache), soluciones distribuidas (IDistributedCache) y servidores de caché externos como Redis y Memcached. En este artículo, analizaremos cada uno de ellos desde la teoría hasta ejemplos prácticos de código.

1. Caché integrada en .NET: IMemoryCache

La caché integrada es la forma más simple y rápida de almacenar datos temporalmente. En ASP.NET Core se implementa a través de la interfaz IMemoryCache. Los datos se almacenan en la memoria RAM de un solo proceso, lo que garantiza una latencia mínima.

Cuándo usarla:

• Los datos no necesitan sincronizarse entre varios servidores.
• El volumen de datos a almacenar en caché es pequeño.
• Se requiere el máximo rendimiento sin configurar servicios externos.

Ejemplo de implementación:

using Microsoft.Extensions.Caching.Memory;

public class WeatherService{    private readonly IMemoryCache _cache;

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

    public async Task<WeatherData> GetWeatherAsync(string city)    {        string cacheKey = $"weather_{city}";

        if (!_cache.TryGetValue(cacheKey, out WeatherData data))        {            // Los datos no están en caché — los cargamos desde una fuente externa            data = await FetchWeatherFromApi(city);

            // Configuración de caché: tiempo de vida de 5 minutos            var cacheOptions = new MemoryCacheEntryOptions()                .SetAbsoluteExpiration(TimeSpan.FromMinutes(5));

            _cache.Set(cacheKey, data, cacheOptions);        }

        return data;    }

    private async Task<WeatherData> FetchWeatherFromApi(string city)    {        // Simulación de llamada a una API externa        await Task.Delay(1000);        return new WeatherData { City = city, Temperature = 22.5 };    }}

public class WeatherData{    public string City { get; set; }    public double Temperature { get; set; }}

Métodos clave: TryGetValue, Set, Remove. Es importante recordar que IMemoryCache no es adecuada para arquitecturas de microservicios.

2. Caché distribuido: IDistributedCache y sus proveedores

Para aplicaciones que se ejecutan en varios servidores, se necesita un caché distribuido. En .NET se abstrae a través de la interfaz IDistributedCache. Esto permite cambiar fácilmente de proveedor (Redis, SQL Server, NCache) sin modificar la lógica de negocio.

Métodos principales:

• GetAsync / SetAsync — para trabajar con bytes.
• GetStringAsync / SetStringAsync — para datos de tipo cadena.
• RefreshAsync — restablece el temporizador de expiración deslizante.
• RemoveAsync — elimina una entrada.

Ejemplo con Redis:

// En Program.cs registramos el proveedorbuilder.Services.AddStackExchangeRedisCache(options =>{    options.Configuration = "localhost:6379";    options.InstanceName = "SampleApp";});

// Uso en el serviciopublic class ProductService{    private readonly IDistributedCache _cache;

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

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

        if