IMemoryCache

• The simplest cache is based on the IMemoryCache, which represents a cache stored in the memory of the web server.
  • Apps which run on a server farm of multiple servers should ensure that sessions are sticky when using the in-memory cache.
  • Sticky sessions ensure that subsequent requests from a client all go to the same server.
    • For example, Azure Web apps use Application Request Routing (ARR) to route all subsequent requests to the same server.
  • Non-sticky sessions in a web farm require a distributed cache to avoid cache consistency problems.
  • For some apps, a distributed cache can support higher scale out than an in-memory cache.
  • Using a distributed cache offloads the cache memory to an external process.
• The **IMemoryCache** cache will evict cache entries under memory pressure unless the cache priority is set to **CacheItemPriority.NeverRemove**.
• The in-memory cache can store any object; the distributed cache interface is limited to **byte[]**.
• **IMemoryCache** requires NuGet package "Microsoft.Extensions.Caching.Memory".
• In-memory caching is a service that's referenced from your app using Dependency Injection.

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddMemoryCache();
        services.AddMvc();
    }
}

• Request the **IMemoryCache** instance in the constructor:

public class HomeController : Controller
{
    private IMemoryCache _cache;

    public HomeController(IMemoryCache memoryCache)
    {
        _cache = memoryCache;
    }

	public IActionResult CacheTryGetValueSet()
	{
		DateTime cacheEntry;
    
        // Look for cache key.
        if (!_cache.TryGetValue(CacheKeys.Entry, out cacheEntry))
        {
            // Key not in cache, so get data.
            cacheEntry = DateTime.Now;
    
            var cacheEntryOptions = new MemoryCacheEntryOptions()
                // Keep in cache for this time, reset time if accessed.
                .SetSlidingExpiration(TimeSpan.FromSeconds(3));

            _cache.Set(CacheKeys.Entry, cacheEntry, cacheEntryOptions);
        }    
        return View("Cache", cacheEntry);
    }
	
	public IActionResult CacheGet()
	{
		var cacheEntry = _cache.Get<DateTime?>(CacheKeys.Entry);
		return View("Cache", cacheEntry);
	}

	public IActionResult CacheGetOrCreate()
	{
		var cacheEntry = _cache.GetOrCreate(CacheKeys.Entry, entry =>
		{
			entry.SlidingExpiration = TimeSpan.FromSeconds(3);
			return DateTime.Now;
		});

		return View("Cache", cacheEntry);
	}

	public async Task<IActionResult> CacheGetOrCreateAsync()
	{
		var cacheEntry = await _cache.GetOrCreateAsync(CacheKeys.Entry, entry =>
		{
			entry.SlidingExpiration = TimeSpan.FromSeconds(3);
			return Task.FromResult(DateTime.Now);
		});

		return View("Cache", cacheEntry);
	}
}

MemoryCacheEntryOptions

public IActionResult CreateCallbackEntry()
{
    var cacheEntryOptions = new MemoryCacheEntryOptions()        
        .SetPriority(CacheItemPriority.NeverRemove)        
        .RegisterPostEvictionCallback(callback: EvictionCallback, state: this);

    _cache.Set(CacheKeys.CallbackEntry, DateTime.Now, cacheEntryOptions);

    return RedirectToAction("GetCallbackEntry");
}

public IActionResult GetCallbackEntry()
{
    return View("Callback", new CallbackViewModel
    {
        CachedTime = _cache.Get<DateTime?>(CacheKeys.CallbackEntry),
        Message = _cache.Get<string>(CacheKeys.CallbackMessage)
    });
}

public IActionResult RemoveCallbackEntry()
{
    _cache.Remove(CacheKeys.CallbackEntry);
    return RedirectToAction("GetCallbackEntry");
}

private static void EvictionCallback(object key, object value,
    EvictionReason reason, object state)
{
    var message = $"Entry was evicted. Reason: {reason}.";
    ((HomeController)state)._cache.Set(CacheKeys.CallbackMessage, message);
}

Cache Dependencies

• Using a **CancellationTokenSource** allows multiple cache entries to be evicted as a group.
• With the using pattern, cache entries created inside the using block will inherit triggers and expiration settings.
• When using a callback to repopulate a cache item:
  • Multiple requests can find the cached key value empty because the callback hasn't completed.
  • This can result in several threads repopulating the cached item.
• When one cache entry is used to create another, the child copies the parent entry's expiration tokens and time-based expiration settings.
  • The child isn't expired by manual removal or updating of the parent entry.

public IActionResult CreateDependentEntries()
{
    var cts = new CancellationTokenSource();
    _cache.Set(CacheKeys.DependentCTS, cts);

    using (var entry = _cache.CreateEntry(CacheKeys.Parent))
    {
        // expire this entry if the dependant entry expires.
        entry.Value = DateTime.Now;
        entry.RegisterPostEvictionCallback(DependentEvictionCallback, this);
        _cache.Set(CacheKeys.Child, DateTime.Now, new CancellationChangeToken(cts.Token));
    }
    return RedirectToAction("GetDependentEntries");
}

public IActionResult GetDependentEntries()
{
    return View("Dependent", new DependentViewModel
    {
        ParentCachedTime = _cache.Get<DateTime?>(CacheKeys.Parent),
        ChildCachedTime = _cache.Get<DateTime?>(CacheKeys.Child),
        Message = _cache.Get<string>(CacheKeys.DependentMessage)
    });
}

public IActionResult RemoveChildEntry()
{
    _cache.Get<CancellationTokenSource>(CacheKeys.DependentCTS).Cancel();
    return RedirectToAction("GetDependentEntries");
}

private static void DependentEvictionCallback(object key, object value,
    EvictionReason reason, object state)
{
    var message = $"Parent entry was evicted. Reason: {reason}.";
    ((HomeController)state)._cache.Set(CacheKeys.DependentMessage, message);
}

ASP.NET Core MemoryCache - GetOrCreate calls factory method multiple times - .NET BLOG

Distributed Cache

• The information in the cache isn't stored in the memory of individual web servers, and the cached data is available to all of the app's servers.