Cache Invalidation Strategies

using Microsoft.Extensions.Caching.Memory;
using StackExchange.Redis;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddMemoryCache();
builder.Services.AddSingleton<IConnectionMultiplexer>(_ =>
{
    var options = ConfigurationOptions.Parse(builder.Configuration.GetConnectionString("Redis")!);
    options.AbortOnConnectFail = false; // a Redis outage at boot must not stop the API from starting
    return ConnectionMultiplexer.Connect(options);
});
builder.Services.AddHostedService<CacheInvalidationListener>();
builder.Services.AddSingleton<CacheInvalidationPublisher>();
builder.Services.AddSingleton<PriceRepository>();

var app = builder.Build();
app.MapPut("/products/{sku}/price", async (string sku, PriceChange change, PriceRepository prices,
    IMemoryCache cache, CacheInvalidationPublisher publisher, CancellationToken ct) =>
{
    await prices.SaveAsync(sku, change.Price, ct);    // 1. commit
    cache.Remove($"price:v1:{sku}");                  // 2. evict this pod now
    await publisher.PublishAsync($"price:v1:{sku}");  // 3. every other pod evicts on the message
    return TypedResults.NoContent();
});
app.Run();

public sealed record PriceChange(decimal Price);

// Stands in for the real database write; the cache code does not depend on how it is stored.
public sealed class PriceRepository
{
    private readonly Dictionary<string, decimal> _prices = [];

    public async Task SaveAsync(string sku, decimal price, CancellationToken ct)
    {
        await Task.Delay(10, ct);
        lock (_prices) _prices[sku] = price;
    }
}

public sealed class CacheInvalidationPublisher(IConnectionMultiplexer redis)
{
    public static readonly RedisChannel Channel = RedisChannel.Literal("catalog-api:cache-invalidation");

    public Task PublishAsync(string key) => redis.GetSubscriber().PublishAsync(Channel, key);
}

public sealed class CacheInvalidationListener(IConnectionMultiplexer redis, IMemoryCache cache, ILogger<CacheInvalidationListener> logger)
    : IHostedService
{
    public Task StartAsync(CancellationToken cancellationToken)
    {
        // Messages published while this pod was disconnected are lost, so drop the whole local cache on reconnect.
        redis.ConnectionRestored += (_, _) =>
        {
            if (cache is MemoryCache memory) memory.Clear();
            logger.LogInformation("Redis reconnected; cleared the local cache");
        };
        return redis.GetSubscriber().SubscribeAsync(CacheInvalidationPublisher.Channel, (_, key) =>
        {
            cache.Remove(key.ToString());
            logger.LogDebug("Evicted {CacheKey} on invalidation message", key.ToString());
        });
    }

    public Task StopAsync(CancellationToken cancellationToken) =>
        redis.GetSubscriber().UnsubscribeAsync(CacheInvalidationPublisher.Channel);
}

using Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.Primitives;

public sealed record CategoryPage(string Category, int Page, IReadOnlyList<string> Skus);

public sealed class CategoryPageCache(IMemoryCache cache)
{
    private readonly Lock _gate = new();
    private readonly Dictionary<string, CancellationTokenSource> _groups = [];

    public CategoryPage GetOrAdd(string category, int page, Func<CategoryPage> load) =>
        cache.GetOrCreate(("category-page", category, page), entry =>
        {
            entry.AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(10);
            entry.AddExpirationToken(new CancellationChangeToken(GroupToken(category)));
            return load();
        })!;

    // Expires every page of the category at once, however many were cached.
    public void InvalidateCategory(string category)
    {
        CancellationTokenSource? old;
        lock (_gate)
        {
            _groups.Remove(category, out old);
        }
        old?.Cancel();
        old?.Dispose();
    }

    private CancellationToken GroupToken(string category)
    {
        lock (_gate)
        {
            if (!_groups.TryGetValue(category, out var cts))
                _groups[category] = cts = new CancellationTokenSource();
            return cts.Token;
        }
    }
}

using Microsoft.Extensions.Caching.Distributed;

public sealed class PriceListCache(IDistributedCache cache)
{
    private static readonly DistributedCacheEntryOptions GenerationTtl = new() { AbsoluteExpirationRelativeToNow = TimeSpan.FromDays(7) };
    private static readonly DistributedCacheEntryOptions PriceTtl = new() { AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(30) };

    public async Task<string?> GetPriceJsonAsync(string priceList, string sku, CancellationToken ct)
    {
        var generation = await CurrentGenerationAsync(priceList, ct);
        return await cache.GetStringAsync($"price:{priceList}:g{generation}:{sku}", ct);
    }

    public async Task SetPriceJsonAsync(string priceList, string sku, string json, CancellationToken ct)
    {
        var generation = await CurrentGenerationAsync(priceList, ct);
        await cache.SetStringAsync($"price:{priceList}:g{generation}:{sku}", json, PriceTtl, ct);
    }

    // After a bulk import commits: every old key is unreachable at once and expires on its own.
    public Task InvalidateAsync(string priceList, CancellationToken ct) =>
        cache.SetStringAsync(GenerationKey(priceList), DateTimeOffset.UtcNow.ToUnixTimeMilliseconds().ToString(), GenerationTtl, ct);

    private async Task<string> CurrentGenerationAsync(string priceList, CancellationToken ct) =>
        await cache.GetStringAsync(GenerationKey(priceList), ct) ?? "0";

    private static string GenerationKey(string priceList) => $"price-generation:{priceList}";
}