Caching

builder.Services.AddMemoryCache();

public class ProductService(IMemoryCache cache) {
    public async Task<Product> GetProductAsync(int id) {
        return await cache.GetOrCreateAsync($"product-{id}", async entry => {
            entry.SlidingExpiration = TimeSpan.FromMinutes(10);
            return await _repository.GetByIdAsync(id);
        });
    }
}

Common follow-ups: What's the memory pressure risk of unbounded IMemoryCache growth?;How does IMemoryCache behave differently across multiple load-balanced instances?

builder.Services.AddStackExchangeRedisCache(options => {
    options.Configuration = builder.Configuration.GetConnectionString("Redis");
});

public async Task<Product?> GetProductAsync(int id) {
    var cached = await _distributedCache.GetStringAsync($"product-{id}");
    return cached is not null ? JsonSerializer.Deserialize<Product>(cached) : null;
}

Common follow-ups: Why does IDistributedCache only support byte[]/string, requiring manual serialization?;What's the latency trade-off of a network-based cache versus in-process memory access?

builder.Services.AddResponseCaching();
app.UseResponseCaching();

[ResponseCache(Duration = 60, VaryByQueryKeys = new[] { "category" })]
[HttpGet]
public IActionResult GetProducts(string category) => Ok(_products.Where(p => p.Category == category));

Common follow-ups: How does VaryByQueryKeys affect what counts as a 'unique' cached response?;How does response caching interact with a CDN sitting in front of the API?

builder.Services.AddOutputCache(options => {
    options.AddPolicy("ProductsPolicy", policy => policy.Expire(TimeSpan.FromMinutes(5)).Tag("products"));
});
app.UseOutputCache();

app.MapGet("/products", () => GetProducts()).CacheOutput("ProductsPolicy");

// Invalidate all cached responses tagged 'products' when data changes:
await outputCacheStore.EvictByTagAsync("products", default);

Common follow-ups: Why is tag-based invalidation not available with Response Caching middleware?;Can Output Caching be configured to use a distributed store like Redis instead of in-memory?

private static readonly SemaphoreSlim _lock = new(1, 1);

public async Task<Product> GetProductAsync(int id) {
    if (_cache.TryGetValue($"product-{id}", out Product cached)) return cached;
    await _lock.WaitAsync();
    try {
        if (_cache.TryGetValue($"product-{id}", out cached)) return cached;
        var product = await _repository.GetByIdAsync(id);
        _cache.Set($"product-{id}", product, TimeSpan.FromMinutes(10));
        return product;
    } finally { _lock.Release(); }
}

Common follow-ups: How does HybridCache handle this automatically without manual locking code?;What is 'stale-while-revalidate' as an alternative mitigation approach?

builder.Services.AddHybridCache();

public class ProductService(HybridCache cache) {
    public async Task<Product> GetProductAsync(int id) {
        return await cache.GetOrCreateAsync($"product-{id}", async ct => {
            return await _repository.GetByIdAsync(id, ct);
        }, new HybridCacheEntryOptions { Expiration = TimeSpan.FromMinutes(10) });
    }
}

Common follow-ups: How does HybridCache handle stampede protection across multiple server instances, not just within one process?;What serialization options does HybridCache support?

public async Task UpdateProductAsync(Product product) {
    await _repository.UpdateAsync(product);
    await _cache.RemoveAsync($"product-{product.Id}");  // must remember this on EVERY write path!
    await _outputCacheStore.EvictByTagAsync("products", default);
}

Common follow-ups: Why is 'there are only two hard things in computer science: cache invalidation and naming things' such a common joke?;How do cache tags simplify bulk invalidation compared to tracking individual keys?

builder.Services.AddStackExchangeRedisCache(options => {
    options.Configuration = builder.Configuration.GetConnectionString("Redis");
});

builder.Services.AddOutputCache(options => {
    options.AddBasePolicy(policy => policy.Expire(TimeSpan.FromMinutes(5)));
});
// Redis-backed output cache store configured via a corresponding provider package

Common follow-ups: What are the trade-offs of a shared Redis instance for both purposes versus separate instances?;How does connection pooling work for StackExchange.Redis under high concurrency?

[HttpGet("{id}")]
public IActionResult GetProduct(int id) {
    var product = _service.GetProduct(id);
    var etag = ComputeETag(product);
    if (Request.Headers.IfNoneMatch == etag) return StatusCode(304);
    Response.Headers.ETag = etag;
    Response.Headers.CacheControl = "public, max-age=300";
    return Ok(product);
}

Common follow-ups: How does a CDN's cache differ from browser caching in terms of who benefits?;What's the risk of overly aggressive Cache-Control settings for frequently-changing data?

// DANGEROUS: same cache key regardless of which user is requesting
var cacheKey = "user-dashboard";  // BUG!

// CORRECT: key includes user identity
var cacheKey = $"user-dashboard-{userId}";

// Output Caching: vary by an auth-derived value
app.MapGet("/dashboard", GetDashboard).CacheOutput(policy => policy.SetVaryByHeader("Authorization"));

Common follow-ups: How does VaryByHeader specifically help prevent this class of bug?;What data should never be cached server-side regardless of key scoping?