Caching

// Program.csbuilder.Services.AddHybridCache(options =>{    options.DefaultEntryOptions = new HybridCacheEntryOptions    {        Expiration = TimeSpan.FromMinutes(5),        LocalCacheExpiration = TimeSpan.FromMinutes(2)    };});
// Optional: Add Redis as the L2 distributed cachebuilder.Services.AddStackExchangeRedisCache(options =>{    options.Configuration = builder.Configuration.GetConnectionString("Redis");});

// Usage in a handlerpublic class GetProduct{    public record Query(Guid Id);    public record Response(Guid Id, string Name, decimal Price);
    internal class Handler(AppDbContext db, HybridCache cache)    {        public async Task<Response?> Handle(Query query, CancellationToken ct)        {            return await cache.GetOrCreateAsync(                $"products:{query.Id}",                async token => await db.Products                    .Where(p => p.Id == query.Id)                    .Select(p => new Response(p.Id, p.Name, p.Price))                    .FirstOrDefaultAsync(token),                new HybridCacheEntryOptions                {                    Expiration = TimeSpan.FromMinutes(10)                },                cancellationToken: ct);        }    }}

// Invalidate on mutationpublic class UpdateProduct{    internal class Handler(AppDbContext db, HybridCache cache)    {        public async Task<Result> Handle(Command command, CancellationToken ct)        {            var product = await db.Products.FindAsync([command.Id], ct);            if (product is null) return Result.Failure("Product not found");
            product.Update(command.Name, command.Price);            await db.SaveChangesAsync(ct);
            // Invalidate the cached entry            await cache.RemoveAsync($"products:{command.Id}", ct);
            return Result.Success();        }    }}

// Program.csbuilder.Services.AddOutputCache(options =>{    options.AddBasePolicy(b => b.NoCache()); // Don't cache by default
    options.AddPolicy("ProductList", b => b        .Expire(TimeSpan.FromMinutes(5))        .Tag("products"));
    options.AddPolicy("ProductById", b => b        .Expire(TimeSpan.FromMinutes(10))        .SetVaryByRouteValue("id")        .Tag("products"));});
app.UseOutputCache();
// Apply to endpointsgroup.MapGet("/", ListProducts).CacheOutput("ProductList");group.MapGet("/{id:guid}", GetProduct).CacheOutput("ProductById");
// Invalidate by tag on mutationsgroup.MapPut("/{id:guid}", async (Guid id, UpdateProductRequest request,    IOutputCacheStore store, CancellationToken ct) =>{    // ... update logic ...    await store.EvictByTagAsync("products", ct);    return TypedResults.NoContent();});

// BAD — cache lives forever, stale data guaranteedawait cache.SetStringAsync(key, value);
// GOOD — always set TTLawait cache.SetStringAsync(key, value, new DistributedCacheEntryOptions{    AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(10)});

// BAD — caching user's cart with a global keyawait cache.GetOrCreateAsync("shopping-cart", ...);
// GOOD — include user ID in keyawait cache.GetOrCreateAsync($"shopping-cart:{userId}", ...);

// BAD — manual lock to prevent cache stampedeprivate static readonly SemaphoreSlim Lock = new(1, 1);await Lock.WaitAsync();try { /* check cache, populate if missing */ }finally { Lock.Release(); }
// GOOD — HybridCache has built-in stampede protectionawait hybridCache.GetOrCreateAsync(key, factory);