Click here to Skip to main content
65,938 articles
CodeProject is changing. Read more.
Articles
(untagged)

ASP.NET Core 2.0 Caching

0.00/5 (No votes)
5 Sep 2017 1  
How to use distributed caching and Redis in ASP.NET Core. Continue reading...

Problem

How to use distributed caching and Redis in ASP.NET Core.

Solution

Starting from an empty project, add Redis services in ConfigureServices() method of Startup:

public void ConfigureServices(
            IServiceCollection services)
        {
            services.AddDistributedRedisCache(options =>
            {
                options.Configuration = "..."; // Redis connection string
            });
        }

Create utility methods to set/get typed objects from the cache:

public static class CachingExtensions
    {
        public static async Task SetObjectAsync<T>(
            this IDistributedCache cache, string key, T value)
        {
            await cache.SetStringAsync(key, JsonConvert.SerializeObject(value));
        }

        public static async Task<T> GetObjectAsync<T>(
            this IDistributedCache cache, string key)
        {
            var value = await cache.GetStringAsync(key);
            return value == null ? default(T) :
                                  JsonConvert.DeserializeObject<T>(value);
        }
    }

Create a middleware to write to the cache:

public class WriteCachingMiddleware
    {
        private readonly RequestDelegate next;
        private readonly IDistributedCache cache;

        public WriteCachingMiddleware(
            RequestDelegate next,
            IDistributedCache cache)
        {
            this.next = next;
            this.cache = cache;
        }

        public async Task Invoke(HttpContext context)
        {
            await cache.SetObjectAsync("CurrentUser",
                new UserInfo { Username = "James", Email = "james@bond.com" });
            await this.next(context);
        }
    }

Create a middleware to read from the cache:

public class ReadCachingMiddleware
    {
        private readonly RequestDelegate next;
        private readonly IDistributedCache cache;

        public ReadCachingMiddleware(
            RequestDelegate next,
            IDistributedCache cache)
        {
            this.next = next;
            this.cache = cache;
        }

        public async Task Invoke(HttpContext context)
        {
            var user = await cache.GetObjectAsync<UserInfo>("CurrentUser");
            await context.Response.WriteAsync($"{user.Username}, {user.Email}");
        }
    }

Discussion

Caching frequently used data can improve the performance of a web application. For application hosted on multiple servers, using distributed caching means the application can access data regardless of the instance server. Caching should be considered an alternate to using Session State.

ASP.NET Core provides an abstraction over the distributed caching so that regardless of where the cache is physically stored (Redis, SQL), developers can interact using a uniform API. This interface is IDistributedCache and provides methods to set, get and remove cache data. Notice that it can be injected as dependency in your middleware, controllers, etc.

The set/get methods of IDistributedCache work with byte[] but framework also provides extension methods to work with string values. These extension methods use Encoding.UTF8.GetBytes() and Encoding.UTF8.GetString() behind the scenes.

You could write your own extension methods to work with other strongly typed objects, as the above solution demonstrates.

I recommend considering Azure Redis Cache, it is really simple to setup and provides a lot of useful analytics to monitor usage.

License

This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.

A list of licenses authors might use can be found here