Caching Strategy

// Cache-Aside Pattern Implementation
public class CachedVendorService : IVendorService
{
    private readonly IDistributedCache _cache;
    private readonly IVendorRepository _repository;
    private readonly TimeSpan _cacheDuration = TimeSpan.FromMinutes(15);

    public async Task<Vendor> GetByIdAsync(Guid id)
    {
        var cacheKey = $"vendor:{id}";

        // 1. Check cache
        var cached = await _cache.GetStringAsync(cacheKey);
        if (cached != null)
        {
            return JsonSerializer.Deserialize<Vendor>(cached);
        }

        // 2. Cache miss - fetch from database
        var vendor = await _repository.GetByIdAsync(id);
        if (vendor == null) return null;

        // 3. Populate cache
        await _cache.SetStringAsync(
            cacheKey,
            JsonSerializer.Serialize(vendor),
            new DistributedCacheEntryOptions
            {
                AbsoluteExpirationRelativeToNow = _cacheDuration
            }
        );

        return vendor;
    }

    public async Task UpdateAsync(Vendor vendor)
    {
        await _repository.UpdateAsync(vendor);

        // Invalidate cache on update
        await _cache.RemoveAsync($"vendor:{vendor.Id}");
        await _cache.RemoveAsync($"vendors:tenant:{vendor.TenantId}");
    }
}

// Event-driven cache invalidation
public class CacheInvalidationHandler :
    INotificationHandler<VendorUpdatedEvent>,
    INotificationHandler<POApprovedEvent>
{
    private readonly IDistributedCache _cache;

    public async Task Handle(VendorUpdatedEvent notification, CancellationToken ct)
    {
        // Invalidate specific vendor cache
        await _cache.RemoveAsync($"vendor:{notification.VendorId}");

        // Invalidate tenant vendor list
        await _cache.RemoveAsync($"vendors:tenant:{notification.TenantId}");
    }

    public async Task Handle(POApprovedEvent notification, CancellationToken ct)
    {
        // Invalidate all KPI caches for this tenant
        var keys = await GetKeysByPatternAsync($"kpi:{notification.TenantId}:*");
        foreach (var key in keys)
        {
            await _cache.RemoveAsync(key);
        }
    }
}

// Angular build configuration (angular.json)
{
  "outputHashing": "all",  // Adds content hash to filenames
  "optimization": true,
  "buildOptimizer": true
}

// Generated files:
// main.abc123def.js
// styles.xyz789ghi.css

// ASP.NET Core CDN headers
app.UseStaticFiles(new StaticFileOptions
{
    OnPrepareResponse = ctx =>
    {
        if (ctx.File.Name.EndsWith(".js") || ctx.File.Name.EndsWith(".css"))
        {
            ctx.Context.Response.Headers.Append(
                "Cache-Control",
                "public, max-age=31536000, immutable"
            );
        }
    }
});

// ETag middleware for API responses
public class ETagMiddleware
{
    public async Task InvokeAsync(HttpContext context, RequestDelegate next)
    {
        if (context.Request.Method != HttpMethods.Get)
        {
            await next(context);
            return;
        }

        // Capture response
        var originalStream = context.Response.Body;
        using var memStream = new MemoryStream();
        context.Response.Body = memStream;

        await next(context);

        // Calculate ETag from response body
        memStream.Seek(0, SeekOrigin.Begin);
        var hash = MD5.HashData(memStream.ToArray());
        var etag = $"\"{Convert.ToHexString(hash)}\"";

        // Check If-None-Match header
        if (context.Request.Headers.IfNoneMatch == etag)
        {
            context.Response.StatusCode = 304; // Not Modified
            return;
        }

        context.Response.Headers.ETag = etag;
        memStream.Seek(0, SeekOrigin.Begin);
        await memStream.CopyToAsync(originalStream);
    }
}