Caching: strategies, expiration & pitfalls

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddStackExchangeRedisCache(o =>
    o.Configuration = builder.Configuration.GetConnectionString("redis")); // L2 (shared)
builder.Services.AddHybridCache();   // L1 memory + the L2 registered above
builder.Services.AddOutputCache();   // full-response cache

var app = builder.Build();
app.UseOutputCache();
app.MapGet("/products", GetProducts)
   .CacheOutput(p => p.Expire(TimeSpan.FromMinutes(5)).Tag("products"));

public sealed class ProductService(HybridCache cache, AppDbContext db)
{
    // Cache-aside: on a miss, the factory runs once and the result is cached
    public ValueTask<Product?> GetAsync(int id, CancellationToken ct) =>
        cache.GetOrCreateAsync($"product:{id}",
            async token => await db.Products.FindAsync([id], token),
            cancellationToken: ct);

    public async Task UpdateAsync(Product product, CancellationToken ct)
    {
        db.Products.Update(product);
        await db.SaveChangesAsync(ct);                       // 1. write the DB
        await cache.RemoveAsync($"product:{product.Id}", ct); // 2. then delete the key
    }
}

// TTL with jitter + tags, so a whole group can be invalidated by one event
var options = new HybridCacheEntryOptions
{
    Expiration = TimeSpan.FromMinutes(5) + TimeSpan.FromSeconds(Random.Shared.Next(30)),
    LocalCacheExpiration = TimeSpan.FromMinutes(1)
};
var rate = await cache.GetOrCreateAsync($"fx:{pair}", LoadRateAsync, options, tags: ["fx"]);
await cache.RemoveByTagAsync("fx");      // e.g. when a "RatesPublished" event arrives

// Sliding expiration with an absolute cap (sessions)
memoryCache.Set(sessionId, session, new MemoryCacheEntryOptions
{
    SlidingExpiration = TimeSpan.FromMinutes(15),
    AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(8)
});

RemoveAsync / RemoveByTagAsync invalidate this server's L1 and the shared L2, but not the in-memory L1 on other servers. Keep LocalCacheExpiration short, so stale L1 copies age out quickly.

Interview version: an O(1) LRU in C# with Dictionary + LinkedList (not thread-safe; wrap it in a Lock if it's shared):

public sealed class LruCache<TKey, TValue>(int capacity) where TKey : notnull
{
    private readonly Dictionary<TKey, LinkedListNode<(TKey Key, TValue Value)>> _map = new();
    private readonly LinkedList<(TKey Key, TValue Value)> _list = new();

    public bool TryGet(TKey key, out TValue value)
    {
        if (_map.TryGetValue(key, out var node))
        {
            _list.Remove(node); _list.AddFirst(node);      // now most recently used
            value = node.Value.Value; return true;
        }
        value = default!; return false;
    }

    public void Put(TKey key, TValue value)
    {
        if (_map.TryGetValue(key, out var existing)) _list.Remove(existing);
        else if (_map.Count == capacity)
        {
            var lru = _list.Last!;                          // least recently used
            _list.RemoveLast(); _map.Remove(lru.Value.Key);
        }
        _map[key] = _list.AddFirst((key, value));
    }
}

// Penetration guard: reject IDs that can't exist before touching the cache or DB
var bloom = redis.GetDatabase().BF();
if (!await bloom.ExistsAsync("accounts:valid", accountId))
    return Results.NotFound();

// Redis: unique cards today (HLL) and card attempts per merchant (CMS)
await db.HyperLogLogAddAsync($"uniq:cards:{day}", cardToken);
long uniqueCards = await db.HyperLogLogLengthAsync($"uniq:cards:{day}");   // about ±0.81%

var cms = db.CMS();                                     // NRedisStack
await cms.IncrByAsync($"attempts:{hour}", merchantId, 1);
long[] attempts = await cms.QueryAsync($"attempts:{hour}", merchantId);

// In memory: a small Bloom filter with double hashing
public sealed class BloomFilter(int bits, int hashes)
{
    private readonly BitArray _bits = new(bits);

    public void Add(string item) { foreach (var i in Positions(item)) _bits[i] = true; }

    public bool MightContain(string item)          // false = definitely not added
    {
        foreach (var i in Positions(item)) if (!_bits[i]) return false;
        return true;
    }

    private IEnumerable<int> Positions(string item)
    {
        ulong h = XxHash3.HashToUInt64(Encoding.UTF8.GetBytes(item));
        ulong h1 = (uint)h, h2 = h >> 32;
        for (ulong k = 0; k < (ulong)hashes; k++) yield return (int)((h1 + k * h2) % (ulong)bits);
    }
}

Size a Bloom filter for the number of items you expect. Overfill it and the false-positive rate climbs fast. Rebuild it (or use Redis's scaling filters) when the data grows.