Output Caching, HybridCache and Rate Limiting in ASP.NET Core

using Microsoft.Extensions.Caching.Hybrid;

// Any registered IDistributedCache becomes the L2 cache automatically.
builder.Services.AddStackExchangeRedisCache(options =>
    options.Configuration = builder.Configuration.GetConnectionString("redis"));

builder.Services.AddHybridCache(options =>
{
    options.MaximumPayloadBytes = 1024 * 1024; // default: larger values are logged, not cached
    options.MaximumKeyLength = 1024;           // default: longer keys bypass the cache
    options.DefaultEntryOptions = new HybridCacheEntryOptions
    {
        Expiration = TimeSpan.FromMinutes(30),         // overall lifetime, including Redis
        LocalCacheExpiration = TimeSpan.FromMinutes(2) // in-memory lifetime
    };
});

using System.ComponentModel;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Caching.Hybrid;

public sealed class ProductCatalog(HybridCache cache, CatalogDbContext db)
{
    private static readonly HybridCacheEntryOptions Details = new()
    {
        Expiration = TimeSpan.FromHours(1),
        LocalCacheExpiration = TimeSpan.FromMinutes(5)
    };

    public ValueTask<ProductDto?> GetAsync(int id, CancellationToken ct = default) =>
        cache.GetOrCreateAsync(
            $"product:{id}",
            async token => await db.Products
                .Where(p => p.Id == id)
                .Select(p => new ProductDto(p.Id, p.Name, p.Price))
                .FirstOrDefaultAsync(token),
            Details,
            tags: ["products"],
            cancellationToken: ct);

    public async Task UpdatePriceAsync(int id, decimal price, CancellationToken ct = default)
    {
        await db.Products.Where(p => p.Id == id)
            .ExecuteUpdateAsync(s => s.SetProperty(p => p.Price, price), ct);

        await cache.RemoveAsync($"product:{id}", ct); // this node's L1 plus the shared L2
    }

    public ValueTask InvalidateCatalogAsync(CancellationToken ct = default) =>
        cache.RemoveByTagAsync("products", ct);
}

// Sealed and immutable, so HybridCache may return the same L1 instance to every caller.
[ImmutableObject(true)]
public sealed record ProductDto(int Id, string Name, decimal Price);