Redis Cache-Aside Pattern — Scale Beyond One Server

Client → API → SQL Server → 12ms per request
At 1,000 req/s = 12 seconds of SQL Server CPU per second

Client → API → Redis hit → 0.3ms per request
SQL Server only called when cache misses (1-2% of requests)

dotnet add OrderFlow.Infrastructure package Microsoft.Extensions.Caching.StackExchangeRedis
dotnet add OrderFlow.Infrastructure package StackExchange.Redis

// In DependencyInjection.cs
services.AddStackExchangeRedisCache(opt =>
{
    opt.Configuration = configuration.GetConnectionString("Redis");
    opt.InstanceName  = "orderflow:";   // key prefix to avoid collisions
});

// For direct Redis operations (pub/sub, transactions)
services.AddSingleton<IConnectionMultiplexer>(
    ConnectionMultiplexer.Connect(configuration.GetConnectionString("Redis")!));

// OrderFlow.Infrastructure/Caching/CacheService.cs
public class CacheService(IDistributedCache cache) : ICacheService
{
    private static readonly JsonSerializerOptions _jsonOptions = new()
    {
        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
    };

    public async Task<T?> GetAsync<T>(string key, CancellationToken ct = default)
    {
        var bytes = await cache.GetAsync(key, ct);
        if (bytes is null) return default;

        return JsonSerializer.Deserialize<T>(bytes, _jsonOptions);
    }

    public async Task SetAsync<T>(
        string key,
        T value,
        TimeSpan? absoluteExpiry = null,
        TimeSpan? slidingExpiry  = null,
        CancellationToken ct     = default)
    {
        var options = new DistributedCacheEntryOptions();
        if (absoluteExpiry is not null) options.AbsoluteExpirationRelativeToNow = absoluteExpiry;
        if (slidingExpiry  is not null) options.SlidingExpiration               = slidingExpiry;

        var bytes = JsonSerializer.SerializeToUtf8Bytes(value, _jsonOptions);
        await cache.SetAsync(key, bytes, options, ct);
    }

    public Task RemoveAsync(string key, CancellationToken ct = default) =>
        cache.RemoveAsync(key, ct);

    public async Task<T> GetOrSetAsync<T>(
        string key,
        Func<CancellationToken, Task<T>> factory,
        TimeSpan expiry,
        CancellationToken ct = default)
    {
        var cached = await GetAsync<T>(key, ct);
        if (cached is not null) return cached;

        var value = await factory(ct);
        await SetAsync(key, value, absoluteExpiry: expiry, ct: ct);
        return value;
    }
}

public interface ICacheService
{
    Task<T?> GetAsync<T>(string key, CancellationToken ct = default);
    Task SetAsync<T>(string key, T value, TimeSpan? absoluteExpiry = null, TimeSpan? slidingExpiry = null, CancellationToken ct = default);
    Task RemoveAsync(string key, CancellationToken ct = default);
    Task<T> GetOrSetAsync<T>(string key, Func<CancellationToken, Task<T>> factory, TimeSpan expiry, CancellationToken ct = default);
}

// OrderFlow.Infrastructure/Caching/CacheKeys.cs
public static class CacheKeys
{
    public static string Product(Guid id)          => $"products:{id}";
    public static string ProductBySku(string sku)  => $"products:sku:{sku.ToLower()}";
    public static string ProductsList()            => "products:list";
    public static string Customer(Guid id)         => $"customers:{id}";
    public static string OrderSummaries(Guid customerId) => $"orders:customer:{customerId}";
}

// OrderFlow.Application/Products/Queries/GetProductByIdQueryHandler.cs
public class GetProductByIdQueryHandler(
    IProductRepository repo,
    ICacheService      cache) : IRequestHandler<GetProductByIdQuery, ProductDto?>
{
    public async Task<ProductDto?> Handle(GetProductByIdQuery query, CancellationToken ct)
    {
        var cacheKey = CacheKeys.Product(query.ProductId);

        // 1. Try cache first
        var cached = await cache.GetAsync<ProductDto>(cacheKey, ct);
        if (cached is not null)
        {
            return cached;
        }

        // 2. Cache miss — hit the database
        var product = await repo.GetByIdAsync(query.ProductId, ct);
        if (product is null) return null;

        var dto = product.ToDto();

        // 3. Write to cache — 30 min TTL (products change infrequently)
        await cache.SetAsync(cacheKey, dto, absoluteExpiry: TimeSpan.FromMinutes(30), ct: ct);

        return dto;
    }
}

// GetOrSetAsync makes this even more concise
public async Task<ProductDto?> Handle(GetProductByIdQuery query, CancellationToken ct)
{
    var product = await repo.GetByIdAsync(query.ProductId, ct);
    if (product is null) return null;

    return await cache.GetOrSetAsync(
        CacheKeys.Product(query.ProductId),
        async _ => (await repo.GetByIdAsync(query.ProductId, ct))!.ToDto(),
        TimeSpan.FromMinutes(30),
        ct);
}

// GetAllProductsQueryHandler.cs
public async Task<PagedResponse<ProductDto>> Handle(
    GetAllProductsQuery query, CancellationToken ct)
{
    // Only cache the default (first) page — other pages are too dynamic
    if (query.Page == 1 && query.Search is null)
    {
        var cacheKey = CacheKeys.ProductsList();
        var cached   = await cache.GetAsync<PagedResponse<ProductDto>>(cacheKey, ct);
        if (cached is not null) return cached;

        var result = await repo.GetPagedAsync(1, query.PageSize, null, ct);
        await cache.SetAsync(cacheKey, result, absoluteExpiry: TimeSpan.FromMinutes(5), ct: ct);
        return result;
    }

    // For search results or other pages, always hit the DB
    return await repo.GetPagedAsync(query.Page, query.PageSize, query.Search, ct);
}

// OrderFlow.Domain/Events/ProductUpdatedEvent.cs
public record ProductUpdatedEvent(Guid ProductId, string Sku) : IDomainEvent;

// Domain entity raises the event
public void UpdatePrice(decimal newPrice)
{
    if (newPrice < 0) throw new ArgumentException("Price cannot be negative.");
    Price = newPrice;
    RaiseDomainEvent(new ProductUpdatedEvent(Id, Sku));
}

// OrderFlow.Application/Products/Events/InvalidateProductCacheHandler.cs
public class InvalidateProductCacheHandler(ICacheService cache)
    : INotificationHandler<ProductUpdatedEvent>
{
    public async Task Handle(ProductUpdatedEvent notification, CancellationToken ct)
    {
        // Remove all cache entries related to this product
        await Task.WhenAll(
            cache.RemoveAsync(CacheKeys.Product(notification.ProductId), ct),
            cache.RemoveAsync(CacheKeys.ProductBySku(notification.Sku), ct),
            cache.RemoveAsync(CacheKeys.ProductsList(), ct));
    }
}

// ❌ Wrong — stale stock data could allow overselling
await cache.SetAsync(CacheKeys.Product(id), dto, absoluteExpiry: TimeSpan.FromMinutes(30));

// ✅ Better — very short TTL for inventory data; still helps burst traffic
await cache.SetAsync(
    CacheKeys.Product(id),
    dto,
    absoluteExpiry: TimeSpan.FromSeconds(10));  // 10s: reduces DB load on burst, minimal staleness risk

// ✅ Best — serve product details from cache but fetch stock live
var cached = await cache.GetAsync<ProductDetailsDto>(CacheKeys.ProductDetails(id));
// ProductDetailsDto has everything EXCEPT StockLevel
var stock  = await repo.GetCurrentStockAsync(id, ct);  // always live
return cached with { StockLevel = stock };

// Use Redis distributed lock to ensure only one request regenerates the cache
public async Task<T> GetOrSetWithLockAsync<T>(
    string key,
    Func<CancellationToken, Task<T>> factory,
    TimeSpan expiry,
    CancellationToken ct = default)
{
    var cached = await GetAsync<T>(key, ct);
    if (cached is not null) return cached;

    var lockKey = $"{key}:lock";
    var db      = _redis.GetDatabase();

    // Try to acquire lock (expires after 30s to prevent deadlock)
    var acquired = await db.StringSetAsync(
        lockKey, "1",
        TimeSpan.FromSeconds(30),
        When.NotExists);

    if (!acquired)
    {
        // Another instance is regenerating — wait briefly and retry from cache
        await Task.Delay(100, ct);
        return await GetAsync<T>(key, ct) ?? await factory(ct);
    }

    try
    {
        var value = await factory(ct);
        await SetAsync(key, value, absoluteExpiry: expiry, ct: ct);
        return value;
    }
    finally
    {
        await db.KeyDeleteAsync(lockKey);
    }
}

// Add middleware
app.UseResponseCaching();
app.UseOutputCache();

// On the endpoint
group.MapGet("/public", GetPublicProducts)
    .AllowAnonymous()
    .CacheOutput(p => p.Expire(TimeSpan.FromMinutes(5)).Tag("products"));

// Invalidate by tag when products change
await outputCache.EvictByTagAsync("products", ct);

// Log cache hit/miss rate
public async Task<T?> GetAsync<T>(string key, CancellationToken ct = default)
{
    var stopwatch = Stopwatch.StartNew();
    var bytes     = await cache.GetAsync(key, ct);
    stopwatch.Stop();

    var hit = bytes is not null;
    _metrics.RecordCacheOperation(key.Split(':')[0], hit, stopwatch.Elapsed);

    if (bytes is null) return default;
    return JsonSerializer.Deserialize<T>(bytes, _jsonOptions);
}

redis-cli INFO stats | grep keyspace_hits
redis-cli INFO stats | grep keyspace_misses
# Target: >95% hit rate on hot paths