Do you use Output Caching for better API performance?

When your API serves the same data repeatedly, every request hits your database and business logic unnecessarily. Output Caching stores the complete HTTP response and serves it directly for subsequent requests, dramatically improving performance and reducing server load.

ASP.NET Core 7+ includes built-in Output Caching middleware that's more powerful and flexible than the older Response Caching.

Output Caching vs Response Caching

Setting up Output Caching

// Program.cs
var builder = WebApplication.CreateBuilder(args);

builder.Services.AddOutputCache(options =>
{
    // Default policy - cache for 60 seconds
    options.AddBasePolicy(builder => builder.Expire(TimeSpan.FromSeconds(60)));

    // Named policy for specific endpoints
    options.AddPolicy("CacheProducts", builder =>
        builder.Expire(TimeSpan.FromMinutes(10))
               .Tag("products"));
});

var app = builder.Build();
app.UseOutputCache();

✅ Figure: Good example - Configure output caching with default and named policies

Applying cache policies to endpoints

// Without caching - hits database every time
app.MapGet("/api/products", async (ProductDbContext db) =>
{
    return await db.Products.ToListAsync();
});

❌ Figure: Bad example - No caching means unnecessary database hits for unchanged data

// With output caching - serves cached response
app.MapGet("/api/products", async (ProductDbContext db) =>
{
    return await db.Products.ToListAsync();
})
.CacheOutput("CacheProducts");

// Or inline policy
app.MapGet("/api/categories", async (ProductDbContext db) =>
{
    return await db.Categories.ToListAsync();
})
.CacheOutput(policy => policy.Expire(TimeSpan.FromMinutes(5)));

✅ Figure: Good example - Cache responses to reduce database load

Cache invalidation with tags

The real power of Output Caching is tag-based invalidation - when data changes, invalidate only the relevant cached responses.

app.MapPost("/api/products", async (
    Product product,
    ProductDbContext db,
    IOutputCacheStore cache) =>
{
    db.Products.Add(product);
    await db.SaveChangesAsync();

    // Invalidate all responses tagged with "products"
    await cache.EvictByTagAsync("products", default);

    return Results.Created($"/api/products/{product.Id}", product);
});

✅ Figure: Good example - Invalidate cache when data changes using tags

When to use Output Caching

Use Output Caching when:

• Data changes infrequently (product catalogs, reference data)
• Multiple users request the same data
• You need server-side control over caching
• You want tag-based invalidation

Don't use Output Caching when:

• Responses are user-specific (use Response Caching with Vary headers instead)
• Data is highly dynamic (real-time dashboards)
• Responses contain sensitive data
• You need distributed caching across multiple servers (use Redis-backed output cache)

Distributed Output Caching with Redis

For multi-server deployments, use Redis as the cache store:

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

✅ Figure: Good example - Use Redis for output caching in distributed environments