Microsofts ASP.NET Core has become a popular way to build high-performance modern web applications that can run on Windows Linux or MacOS. An important way to ensure high performance and reliability in applications that experience high volumes of requests is caching frequently used data.
LazyCache is a simple in-memory caching service that is both easy to use and thread safe. ’Lazy’ refers to the fact that LazyCache will never execute your cacheable delegates more than once for each ’cache miss’ i.e. whenever the data requested is not found in the cache. In other words laziness reduces computational overhead.
This article talks about how we can work with LazyCache in ASP.NET Core 5.0. To work with the code examples illustrated in this article you should have Visual Studio 2019 installed in your system. If you dont already have a copy you can download Visual Studio 2019 here.
First off lets create an ASP.NET Core 5 project in Visual Studio 2019. Following these steps should create a new ASP.NET Core MVC 5 project in Visual Studio 2019.
Following the above steps will create a new ASP.NET Core MVC 5 project. Well use this project in the subsequent sections in this article.
To work with LazyCache in ASP.NET Core MVC 5.0 you should install the following two packages into your project:
Both LazyCache and LazyCache.AspNetCore libraries are available as NuGet packages. You can install these packages either from the NuGet Package Manager or by using the following commands at the NuGet Package Manager Console window.
PMgt; Install-Package LazyCache
PMgt; Install-Package LazyCache.AspNetCore
Caching is a state management strategy that is often used in web applications to store relatively stale data in the memory for later reuse. Caching improves the applications performance by enabling the application to read the data from the memory instead of from disk — accessing memory is orders of magnitude faster than accessing the disk.
Although ASP.NET Core lacks a built-in Cache object it provides support for several different types of caching including in-memory caching distributed caching and response caching.
LazyCache is an open-source simple thread-safe extensible caching service with a developer-friendly API. Under the hood LazyCache takes advantage of MemoryCache pertaining to the Microsoft.Extensions.Caching namespace and uses lazy locking to ensure the delegate only gets executed once.
LazyCache is a good choice for caching database calls complex object graphs and web service calls. Although you can store items in the cache for a shorter or longer duration the default duration supported is 20 minutes.
Here is a list of the benefits of LazyCache at a quick glance:
You should call the AddLazyCache() method on the IServiceCollection instance in your ConfigureServices method as shown in the code snippet given below.
public void ConfigureServices(IServiceCollection services)
This will make sure that you access LazyCache throughout your application.
Access to LazyCache is provided by the IAppCache interface. IAppCache represents the LazyCache service and provides a GetOrAddAsync method that accepts the following:
You should take advantage of constructor injection to inject the IAppCache instance as shown in the code snippet given below.
public class HomeController : Controller
private readonly ILoggerlt;HomeControllergt; logger;
private readonly IAppCache lazyCache = new CachingService();
public HomeController(ILoggerlt;HomeControllergt; logger IAppCache cache)
logger = logger;
lazyCache = cache;
You can now use the LazyCache instance to add and retrieve data to and from the cache.
Consider the following method that returns a list of strings.
private async Tasklt;Listlt;stringgt;gt; GetData()
return new Listlt;stringgt;()
You can use the following code to retrieve data from the cache or add data to the cache if it isnt present.
var data = await lazyCache.GetOrAddAsync("Authors" GetData DateTimeOffset.Now.AddMinutes(30));
The GetOrAddAsync() extension method pertaining to the LazyCache library provides an easy and elegant way to implement caching in your applications. It takes advantage of a factory delegate and generics to add cached method calls to your code. Using this method you can get cached data when requested by the application or store data to the cache if the piece of data is not available in the cache.
If you would like to store more data in memory and you want a more advanced caching service you could take advantage of Redis for distributed caching. The best part is that because were using IAppCache in our application you can change the underlying caching provider easily.