IDistributedCache — Shared Caching with Redis in ASP.NET Core

IDistributedCache with Redis:
  Storage:   Redis server (external process)
  Speed:     ~0.5ms per operation (network + serialization overhead)
  Lifetime:  survives API restarts
  Sharing:   ALL instances share one cache
  Use when:  2+ instances, or you need cache to survive deploys

Common Redis providers for ASP.NET Core:
  Microsoft.Extensions.Caching.StackExchangeRedis (official)
  StackExchange.Redis (lower level)

// Program.cs
builder.Services.AddStackExchangeRedisCache(options =>
{
    options.Configuration         = builder.Configuration.GetConnectionString("Redis");
    options.InstanceName          = "SystemForge:";  // prefix all keys
    options.ConfigurationOptions = new ConfigurationOptions
    {
        AbortOnConnectFail = false,   // continue if Redis is unavailable
        ConnectRetry       = 3,
        ConnectTimeout     = 5000,
    };
});

// appsettings.json
{
  "ConnectionStrings": {
    "Redis": "localhost:6379,password=yourpassword,ssl=false"
  }
}

public sealed class PatientCacheService
{
    private readonly IDistributedCache    _cache;
    private readonly PatientRepository   _repo;

    public PatientCacheService(IDistributedCache cache, PatientRepository repo)
        => (_cache, _repo) = (cache, repo);

    private static string Key(Guid id) => $"patient:{id}";

    public async Task<PatientDto?> GetByIdAsync(Guid id, CancellationToken ct)
    {
        var bytes = await _cache.GetAsync(Key(id), ct);
        if (bytes is not null)
            return JsonSerializer.Deserialize<PatientDto>(bytes);

        var patient = await _repo.GetByIdAsync(id, ct);
        if (patient is null) return null;

        var dto = patient.ToDto();
        await SetAsync(id, dto, ct);
        return dto;
    }

    private async Task SetAsync(Guid id, PatientDto dto, CancellationToken ct)
    {
        var bytes   = JsonSerializer.SerializeToUtf8Bytes(dto);
        var options = new DistributedCacheEntryOptions
        {
            AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(30),
            SlidingExpiration               = TimeSpan.FromMinutes(5),
        };
        await _cache.SetAsync(Key(id), bytes, options, ct);
    }

    public async Task InvalidateAsync(Guid id, CancellationToken ct)
        => await _cache.RemoveAsync(Key(id), ct);
}

// IDistributedCache stores byte[]. Serialize your objects.

// Option 1: System.Text.Json (recommended — fast, no dependencies)
var bytes = JsonSerializer.SerializeToUtf8Bytes(dto,
    new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });
var dto   = JsonSerializer.Deserialize<PatientDto>(bytes)!;

// Option 2: MessagePack (faster, smaller payload, requires attribute annotation)
// Install: MessagePack
var bytes = MessagePackSerializer.Serialize(dto);
var dto   = MessagePackSerializer.Deserialize<PatientDto>(bytes);

// Create a typed cache wrapper to avoid serialization code in every service
public sealed class TypedCache<T>
{
    private readonly IDistributedCache _cache;

    public async Task<T?> GetAsync(string key, CancellationToken ct)
    {
        var bytes = await _cache.GetAsync(key, ct);
        return bytes is null ? default : JsonSerializer.Deserialize<T>(bytes);
    }

    public async Task SetAsync(string key, T value,
        DistributedCacheEntryOptions opts, CancellationToken ct)
    {
        var bytes = JsonSerializer.SerializeToUtf8Bytes(value);
        await _cache.SetAsync(key, bytes, opts, ct);
    }

    public Task RemoveAsync(string key, CancellationToken ct)
        => _cache.RemoveAsync(key, ct);
}

// Standard pattern: check cache → miss → load from DB → populate cache → return
public async Task<List<DrugDto>> GetFormularyAsync(Guid hospitalId, CancellationToken ct)
{
    var key   = $"formulary:{hospitalId}";
    var bytes = await _cache.GetAsync(key, ct);

    if (bytes is not null)
    {
        _logger.LogDebug("Cache hit: {Key}", key);
        return JsonSerializer.Deserialize<List<DrugDto>>(bytes)!;
    }

    _logger.LogDebug("Cache miss: {Key}", key);
    var drugs = await _repo.GetFormularyAsync(hospitalId, ct);
    var dtos  = drugs.Select(d => d.ToDto()).ToList();

    await _cache.SetAsync(key,
        JsonSerializer.SerializeToUtf8Bytes(dtos),
        new DistributedCacheEntryOptions
        {
            AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(4)
        }, ct);

    return dtos;
}

// Single-entity invalidation
await _cache.RemoveAsync($"patient:{id}", ct);

// Pattern-based invalidation requires StackExchange.Redis directly
// (IDistributedCache does not support key pattern deletion)
var redis   = ConnectionMultiplexer.Connect(connectionString);
var server  = redis.GetServer(redis.GetEndPoints().First());
var keys    = server.Keys(pattern: "patient:*").ToArray();
foreach (var key in keys)
    await redis.GetDatabase().KeyDeleteAsync(key);

// Tag-based invalidation (requires HybridCache or custom implementation)
// Store tags with entries, use a tag index to find related keys

// StackExchange.Redis reconnects automatically, but operations during
// disconnection fail. Handle gracefully:
public async Task<T?> GetWithFallbackAsync<T>(
    string key, Func<Task<T>> fallback, CancellationToken ct) where T : class
{
    try
    {
        var bytes = await _cache.GetAsync(key, ct);
        if (bytes is not null)
            return JsonSerializer.Deserialize<T>(bytes);
    }
    catch (RedisConnectionException ex)
    {
        _logger.LogWarning(ex, "Redis unavailable, bypassing cache for {Key}", key);
        return await fallback();  // fall through to DB
    }

    var value = await fallback();
    if (value is not null)
    {
        try
        {
            await _cache.SetAsync(key,
                JsonSerializer.SerializeToUtf8Bytes(value),
                new DistributedCacheEntryOptions
                    { AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(30) }, ct);
        }
        catch (RedisConnectionException) { /* best-effort populate */ }
    }
    return value;
}