Caching in ASP.NET Core: In-Memory, Distributed & Response Caching Explained

using Microsoft.Extensions.Caching.Memory;
using System;
using System.Threading.Tasks;

// Register IMemoryCache in Program.cs:
// builder.Services.AddMemoryCache();

public class ProductService
{
    private readonly IMemoryCache _cache;
    private readonly IProductRepository _repository;

    // Cache key constants prevent typos across the codebase
    private const string ProductCacheKeyPrefix = "product_";
    private static readonly TimeSpan ProductCacheDuration = TimeSpan.FromMinutes(10);

    public ProductService(IMemoryCache cache, IProductRepository repository)
    {
        _cache = cache;
        _repository = repository;
    }

    public async Task<Product?> GetProductByIdAsync(int productId)
    {
        // Build a unique key per product so we can invalidate one without flushing all
        string cacheKey = $"{ProductCacheKeyPrefix}{productId}";

        // TryGetValue returns true on a cache HIT — we skip the database entirely
        if (_cache.TryGetValue(cacheKey, out Product? cachedProduct))
        {
            Console.WriteLine($"[CACHE HIT] Returning product {productId} from memory cache.");
            return cachedProduct;
        }

        // Cache MISS — go to the real data source
        Console.WriteLine($"[CACHE MISS] Fetching product {productId} from database.");
        Product? product = await _repository.GetByIdAsync(productId);

        if (product is not null)
        {
            // Configure cache entry options before storing
            var cacheOptions = new MemoryCacheEntryOptions()
                // Evict this entry if it hasn't been accessed in 5 minutes (sliding)
                .SetSlidingExpiration(TimeSpan.FromMinutes(5))
                // But always evict after 10 minutes regardless of access (absolute)
                .SetAbsoluteExpiration(ProductCacheDuration)
                // Mark as normal priority — the runtime can evict under memory pressure
                .SetPriority(CacheItemPriority.Normal);

            _cache.Set(cacheKey, product, cacheOptions);
            Console.WriteLine($"[CACHE SET] Product {productId} stored in memory cache.");
        }

        return product;
    }

    // Call this when a product is updated so the next read fetches fresh data
    public void InvalidateProductCache(int productId)
    {
        string cacheKey = $"{ProductCacheKeyPrefix}{productId}";
        _cache.Remove(cacheKey);
        Console.WriteLine($"[CACHE INVALIDATED] Removed product {productId} from cache.");
    }
}

// --- Simulated output for two sequential calls to GetProductByIdAsync(42) ---
// First call:
// [CACHE MISS] Fetching product 42 from database.
// [CACHE SET]  Product 42 stored in memory cache.
//
// Second call (within 5 minutes):
// [CACHE HIT]  Returning product 42 from memory cache.

// Program.cs registration (Redis example):
// builder.Services.AddStackExchangeRedisCache(options =>
// {
//     options.Configuration = builder.Configuration.GetConnectionString("Redis");
//     options.InstanceName = "MyApp:"; // Prefix all keys to avoid collisions
// });
//
// For SQL Server instead, use:
// builder.Services.AddDistributedSqlServerCache(options => { ... });

using Microsoft.Extensions.Caching.Distributed;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;

// A generic wrapper that hides the byte-array pain of IDistributedCache
public class DistributedCacheService
{
    private readonly IDistributedCache _distributedCache;

    public DistributedCacheService(IDistributedCache distributedCache)
    {
        _distributedCache = distributedCache;
    }

    // Returns cached value or null on a miss — caller decides what to do
    public async Task<T?> GetAsync<T>(string cacheKey, CancellationToken cancellationToken = default)
        where T : class
    {
        byte[]? cachedBytes = await _distributedCache.GetAsync(cacheKey, cancellationToken);

        if (cachedBytes is null || cachedBytes.Length == 0)
        {
            return null; // Cache miss
        }

        // Deserialise from JSON bytes back to the strongly-typed object
        return JsonSerializer.Deserialize<T>(cachedBytes);
    }

    public async Task SetAsync<T>(
        string cacheKey,
        T value,
        TimeSpan absoluteExpiration,
        CancellationToken cancellationToken = default)
        where T : class
    {
        byte[] serialisedBytes = JsonSerializer.SerializeToUtf8Bytes(value);

        var cacheEntryOptions = new DistributedCacheEntryOptions
        {
            // Absolute expiration from now — always evict after this window
            AbsoluteExpirationRelativeToNow = absoluteExpiration
        };

        await _distributedCache.SetAsync(cacheKey, serialisedBytes, cacheEntryOptions, cancellationToken);
    }

    public async Task RemoveAsync(string cacheKey, CancellationToken cancellationToken = default)
    {
        await _distributedCache.RemoveAsync(cacheKey, cancellationToken);
    }
}

// --- Usage in a controller or service ---
public class OrderSummaryService
{
    private readonly DistributedCacheService _cache;
    private readonly IOrderRepository _orderRepository;
    private static readonly TimeSpan OrderSummaryCacheDuration = TimeSpan.FromMinutes(15);

    public OrderSummaryService(DistributedCacheService cache, IOrderRepository orderRepository)
    {
        _cache = cache;
        _orderRepository = orderRepository;
    }

    public async Task<OrderSummary?> GetOrderSummaryAsync(int customerId, CancellationToken cancellationToken)
    {
        string cacheKey = $"order_summary_{customerId}";

        // Step 1: Try the distributed cache first
        OrderSummary? cached = await _cache.GetAsync<OrderSummary>(cacheKey, cancellationToken);
        if (cached is not null)
        {
            Console.WriteLine($"[REDIS HIT] Order summary for customer {customerId} served from Redis.");
            return cached;
        }

        // Step 2: Cache miss — hit the database
        Console.WriteLine($"[REDIS MISS] Querying database for customer {customerId} order summary.");
        OrderSummary? summary = await _orderRepository.GetSummaryByCustomerIdAsync(customerId, cancellationToken);

        // Step 3: Store in Redis for the next caller — all server instances benefit
        if (summary is not null)
        {
            await _cache.SetAsync(cacheKey, summary, OrderSummaryCacheDuration, cancellationToken);
            Console.WriteLine($"[REDIS SET] Customer {customerId} summary cached for 15 minutes.");
        }

        return summary;
    }
}

// Program.cs — register and use the middleware (ORDER MATTERS):
// builder.Services.AddResponseCaching();
// ...
// app.UseResponseCaching(); // Must come before app.MapControllers()

using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
using System.Threading.Tasks;

[ApiController]
[Route("api/[controller]")]
public class CatalogueController : ControllerBase
{
    private readonly ICatalogueService _catalogueService;

    public CatalogueController(ICatalogueService catalogueService)
    {
        _catalogueService = catalogueService;
    }

    // This response is cached for 60 seconds server-side AND tells CDNs they can cache it too.
    // 'public' means any cache (server, CDN, proxy) can store this response.
    // 'VaryByQueryKeys' means separate cache entries are kept per 'category' query param
    // so /api/catalogue?category=shoes and ?category=hats each get their own cached version.
    [HttpGet]
    [ResponseCache(Duration = 60, Location = ResponseCacheLocation.Any, VaryByQueryKeys = new[] { "category" })]
    public async Task<IActionResult> GetProductsAsync([FromQuery] string category = "all")
    {
        Console.WriteLine($"[CONTROLLER HIT] Fetching products for category: {category}");
        // This line only runs on a cache MISS — during a 60-second window it runs once per category
        IEnumerable<ProductSummary> products = await _catalogueService.GetByCategoryAsync(category);
        return Ok(products);
    }

    // [ResponseCache(NoStore = true)] explicitly opts this endpoint OUT of caching.
    // Use this for any endpoint that returns user-specific or sensitive data.
    [HttpGet("my-orders")]
    [ResponseCache(NoStore = true, Location = ResponseCacheLocation.None)]
    public async Task<IActionResult> GetMyOrdersAsync()
    {
        // Each call always hits the controller — never cached
        var orders = await _catalogueService.GetOrdersForCurrentUserAsync();
        return Ok(orders);
    }
}

// HTTP Response headers produced by the first endpoint:
// Cache-Control: public,max-age=60
// Vary: Accept-Encoding
//
// Subsequent requests within 60 seconds return:
// [Served from response cache — controller action does NOT execute]
//
// HTTP Response headers produced by the second endpoint:
// Cache-Control: no-store,no-cache