Caching (In-Memory, Distributed & Redis)

builder.Services.AddMemoryCache();

public class ProductService {
    private readonly IMemoryCache _cache;
    public ProductService(IMemoryCache cache) => _cache = 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 IMemoryCache with unbounded growth?;How does IMemoryCache differ across multiple load-balanced server instances?

_cache.Set("key", value, new MemoryCacheEntryOptions {
    SlidingExpiration = TimeSpan.FromMinutes(5),      // resets on each access
    AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(1)  // hard cap regardless
});

Common follow-ups: What happens if only sliding expiration is set with no absolute cap?;How does cache eviction interact with memory pressure signals?

builder.Services.AddStackExchangeRedisCache(options => {
    options.Configuration = "localhost:6379";
});

public class ProductService {
    private readonly IDistributedCache _cache;
    public async Task<Product?> GetProductAsync(int id) {
        var cached = await _cache.GetStringAsync($"product-{id}");
        if (cached != null) return JsonSerializer.Deserialize<Product>(cached);
        // ... fetch and cache
    }
}

Common follow-ups: Why does IDistributedCache only work with byte[]/string, unlike IMemoryCache's object storage?;What's the latency trade-off of every cache access requiring a network call?

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

// Usage
await cache.SetStringAsync("key", JsonSerializer.Serialize(data),
    new DistributedCacheEntryOptions { AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(30) });

Common follow-ups: What's the difference between using IDistributedCache versus IConnectionMultiplexer directly?;How does InstanceName help avoid key collisions when multiple apps share one Redis instance?

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;  // double-check
        var product = await _repository.GetByIdAsync(id);
        _cache.Set($"product-{id}", product, TimeSpan.FromMinutes(10));
        return product;
    } finally { _lock.Release(); }
}

Common follow-ups: How does IMemoryCache.GetOrCreateAsync handle this internally?;What is 'stale-while-revalidate' as an alternative mitigation strategy?

// Explicit invalidation on write
public async Task UpdateProductAsync(Product product) {
    await _repository.UpdateAsync(product);
    await _cache.RemoveAsync($"product-{product.Id}");  // must remember this every time!
}

// Versioned key strategy
var cacheKey = $"products-v{await GetCacheVersionAsync()}";

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/groups simplify bulk invalidation?

builder.Services.AddHybridCache();

public class ProductService {
    private readonly 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 for complex objects?

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?

// Using IConnectionMultiplexer directly for Redis-specific features
var db = _redis.GetDatabase();
await db.SortedSetIncrementAsync("product-views", productId.ToString(), 1);
var topProducts = await db.SortedSetRangeByScoreWithScoresAsync("product-views", order: Order.Descending, take: 10);

Common follow-ups: What is Redis pub/sub and how does it enable cross-instance cache invalidation?;When would you reach for raw IConnectionMultiplexer instead of the IDistributedCache abstraction?

// Cache-aside (most common)
public async Task<Product> GetProductAsync(int id) {
    var cached = await _cache.GetAsync(id);
    if (cached != null) return cached;
    var product = await _db.GetProductAsync(id);
    await _cache.SetAsync(id, product);
    return product;
}

// Write-through: cache updated on every write, not just read-miss
public async Task UpdateProductAsync(Product product) {
    await _db.UpdateAsync(product);
    await _cache.SetAsync(product.Id, product);  // cache updated immediately
}

Common follow-ups: What is write-behind (write-back) caching and when is it appropriate?;How does cache-aside handle the stampede problem differently than write-through?