IMemoryCache — In-Process Caching in ASP.NET Core

IMemoryCache:
  Storage:   process memory (RAM on the current server)
  Speed:     nanoseconds (dictionary lookup)
  Lifetime:  process lifetime — cache lost on restart/redeploy
  Sharing:   NOT shared across multiple instances

When to use:
  ✓ Single-instance apps or Azure App Service with 1 instance
  ✓ Values that do not need consistency across instances
  ✓ Small-to-medium datasets (do not fill your process memory)
  ✓ Reference data: drug formulary, hospital code lookups
  ✗ Do not use when 2+ instances must share state

// Program.cs
builder.Services.AddMemoryCache(options =>
{
    options.SizeLimit = 1000;  // optional: cap the number of entries
    // Without SizeLimit, no eviction based on count — only expiration
});

public sealed class DrugFormularyCache
{
    private readonly IMemoryCache _cache;
    private readonly DrugRepository _repo;

    public DrugFormularyCache(IMemoryCache cache, DrugRepository repo)
        => (_cache, _repo) = (cache, repo);

    public async Task<List<Drug>> GetFormularyAsync(CancellationToken ct)
    {
        // GetOrCreateAsync: get if exists, create if not — atomically
        return await _cache.GetOrCreateAsync("formulary", async entry =>
        {
            entry.AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(1);
            entry.SlidingExpiration               = TimeSpan.FromMinutes(15);
            entry.Priority                        = CacheItemPriority.High;

            return await _repo.GetAllActiveAsync(ct);
        }) ?? new List<Drug>();
    }
}

Absolute expiration:
  entry.AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(1)
  Entry expires 1 hour after it was created
  Good for: data that changes on a schedule (nightly refresh)

Sliding expiration:
  entry.SlidingExpiration = TimeSpan.FromMinutes(15)
  Entry expires if not accessed for 15 minutes
  Resets on each access
  Good for: user-session data, per-user preferences

Combined (recommended):
  AbsoluteExpirationRelativeToNow = 1 hour
  SlidingExpiration               = 15 minutes
  Entry expires after 1 hour regardless, or 15 min of inactivity
  Prevents cache entries from living forever via constant access

builder.Services.AddMemoryCache(options =>
{
    options.SizeLimit = 500;  // max 500 size units
});

// Each entry must declare its size when SizeLimit is set
_cache.GetOrCreateAsync("formulary", entry =>
{
    entry.Size = 1;  // counts as 1 unit toward the 500 limit
    entry.AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(1);
    // ...
});

// Priority affects which entries are evicted first when memory pressure hits
entry.Priority = CacheItemPriority.High;    // evict last
entry.Priority = CacheItemPriority.Normal;  // default
entry.Priority = CacheItemPriority.Low;     // evict first
entry.Priority = CacheItemPriority.NeverRemove;  // never evicted by pressure

// Called when an entry is evicted — useful for logging or refresh
entry.RegisterPostEvictionCallback((key, value, reason, state) =>
{
    var logger = (ILogger)state!;
    logger.LogInformation(
        "Cache entry {Key} evicted due to {Reason}",
        key, reason);
    // reason: Expired, Replaced, Capacity, Removed
});

// Check if exists
if (_cache.TryGetValue("formulary", out List<Drug>? cached))
    return cached!;

// Set manually
_cache.Set("formulary", drugs, new MemoryCacheEntryOptions
{
    AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(1)
});

// Remove manually (invalidation)
_cache.Remove("formulary");

// Problem: 100 concurrent requests all miss the cache simultaneously
// All 100 hit the database at the same time

// Solution: lock or use SemaphoreSlim to allow only one to build
private static readonly SemaphoreSlim _lock = new(1, 1);

public async Task<List<Drug>> GetFormularyAsync(CancellationToken ct)
{
    if (_cache.TryGetValue("formulary", out List<Drug>? cached))
        return cached!;

    await _lock.WaitAsync(ct);
    try
    {
        // Double-check after acquiring lock
        if (_cache.TryGetValue("formulary", out cached))
            return cached!;

        var drugs = await _repo.GetAllActiveAsync(ct);
        _cache.Set("formulary", drugs, TimeSpan.FromHours(1));
        return drugs;
    }
    finally
    {
        _lock.Release();
    }
}

Drug formulary:
  AbsoluteExpiration: 4 hours (formulary updated by pharmacy team, not real-time)
  Key: "formulary:{hospitalId}"
  Invalidate: when pharmacy team saves a formulary change

Ward lookup:
  AbsoluteExpiration: 24 hours (wards rarely change)
  Key: "wards"

Patient in current session:
  SlidingExpiration: 10 minutes (evict if nurse walks away)
  Key: "patient:{patientId}:session:{sessionId}"
  Never cache diagnosis or drug orders — too critical to serve stale