Working With A Distributed Cache In ASP.NET Core

Introduction

In general terms, caching takes place where the frequently-used data is stored, so that the application can quickly access the data rather than accessing the data from the source. Caching can improve the performance and scalability of the application dramatically and can help us to remove the unnecessary requests from the external data sources for the data that changes infrequently.

ASP.NET Core has a rich support for caching and it supports different kinds of caching. In my past article, I explained about the In-memory caching. In this article, we will talk about distributed cache. It can help us to improve the performance and scalability of the application, when the application is hosted on the web farm or cloud environment.

In distributed caching, cache is not stored in to an individual web server’s memory. Cache data is centrally managed and the same data is available to all the app servers. The distributed caching has several advantages, as shown below.

• The cache is stored centrally, so all the users get the same data and data is not dependent on which web server handles its request.
• The cache data is not impacted if any problem happens with the web server; i.e.,  restart, new server is added, a server is removed.

The distributed cache can be configured with either Redis or SQL Server. The implementation of the caching is not dependent on the configuration; the application interacts with the cache, using IDistributedCache interface.

IDistributedCache Interface

This interface has methods, which allow us to add, remove, and retrieve the distributed cache. This interface contains synchronous and asynchronous methods.

• Get, GetAsync
  It retrieves the data from the cache, using key. It returns byte[], if the key is not found in to cache.
  
  
• Set, SetAsync
  It adds the item to cache as byte[].
  
  
• Refresh, RefreshAsync
  It refreshes the item in the cache and also resets its sliding expiration timeout, if any.
  
  
• Remove, RemoveAsync
  It removes the entry from the cache, using key.

We need to perform the three simple steps given below to configure distributed cache in ASP.NET Core.

1. Define cache dependencies into project.json file.
2. Configure cache Service ConfigureServices method of Startup class.
3. Dependency is automatically injected to the application's middleware or MVC controller constructor. Using this instance of cache dependency object, we can perform the operation related to distributed cache

Distributed Cache with SQL Server

SqlServerCache allows the distributed cache to use SQL Server as cache storing purpose. Prior to using SQL Server as a cache, we must create a table with the schema given below.

CREATE TABLE[dbo].[SQLCache](
       [Id][nvarchar](449) NOT NULL,
    [Value][varbinary](max) NOT NULL,
    [ExpiresAtTime][datetimeoffset](7) NOT NULL,
    [SlidingExpirationInSeconds][bigint] NULL,
    [AbsoluteExpiration][datetimeoffset](7) NULL,
    CONSTRAINT[pk_Id] PRIMARY KEY CLUSTERED([Id] ASC) WITH(PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON)
ON[PRIMARY]) ON[PRIMARY] TEXTIMAGE_ON[PRIMARY]

The next step is to add dependencies into the project.json file.To use SQL server as cache, we need to add "Microsoft.Extensions.Caching.SqlServer" dependency to the project. 

 

Project.json 

{
    "version": "1.0.0-*",
    "buildOptions": {
        "preserveCompilationContext": true,
        "debugType": "portable",
        "emitEntryPoint": true
    },
    "tool": {
        "Microsoft.Extensions.Caching.SqlConfig.Tools": "1.0.0-preview2-final"
    },
    "dependencies": {},
    "frameworks": {
        "netcoreapp1.0": {
            "dependencies": {
                "Microsoft.NETCore.App": {
                    "type": "platform",
                    "version": "1.0.1"
                },
                "Microsoft.AspNetCore.Server.Kestrel": "1.0.0",
                "Microsoft.AspNetCore.Mvc": "1.0.0",
                "Microsoft.Extensions.Caching.Memory": "1.0.0",
                "Microsoft.Extensions.Caching.SqlServer": "1.0.0"
            },
            "imports": "dnxcore50"
        }
    }
}

Now, we need to have some configuration in configureServices method of the startup class. Using method "AddDistributedSqlServerCache", we can configure SQL Server as cache. In this method, we need to pass the connection string, schema name and cache table name.

Startup.cs

public void ConfigureServices(IServiceCollection services) {
    services.AddMvc();
    services.AddDistributedSqlServerCache(opt => {
        opt.ConnectionString = @ "server=DESKTOP-HP\SQL;Database=CachingTest;Trusted_Connection=True;";
        opt.SchemaName = "dbo";
        opt.TableName = "SQLCache";
    });
}

Using methods explained above (get, set, and remove), we can access SQL cache. SQL cache is stored in binary format, so we need to cast to byte[] before storing it in to the cache and when retrieving the data from cache,  the system will return it in byte[]. To use data, we need to cast it to the required format.

In the following example, I have created methods for creating cache, retrieving cache and removing cache in controller. ASP.NET Core MVC Controller is able to request their dependencies explicitly via their constructors. We utilize the caching in our application by requesting an instance of IDistributedCache in our Controller (or middleware) constructor. In the code snippet given below, I have created controller class with three methods SetCacheData, GetCacheData and RemoveCacheData.

HomeController.cs

using System;
using System.Text;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Caching.Distributed;
public class HomeController: Controller {
    IDistributedCache _memoryCache;
    public HomeController(IDistributedCache memoryCache) {
            _memoryCache = memoryCache;
        }
        [Route("home/SetCacheData")]
    public IActionResult SetCacheData() {
            var Time = DateTime.Now.ToLocalTime().ToString();
            var cacheOptions = new DistributedCacheEntryOptions {
                AbsoluteExpiration = DateTime.Now.AddYears(1)
            };
            _memoryCache.Set("Time", Encoding.UTF8.GetBytes(Time), cacheOptions);
            return View();
        }
        [Route("home/GetCacheData")]
    public IActionResult GetCacheData() {
            string Time = string.Empty;
            Time = Encoding.UTF8.GetString(_memoryCache.Get("Time"));
            ViewBag.data = Time;
            return View();
        }
        [Route("home/RemoveCacheData")]
    public bool RemoveCacheData() {
        _memoryCache.Remove("Time");
        return true;
    }
}

Output of SQL table

When we call the setCacheData of the controller, it stores the data into SQL table, which is specified in the configuration. The snippet is given below, which shows how SQL Server stores the data.



Distributed Cache with Redis

Redis is an open source and in-memory data store, which is used as a distributed cache. We can install it locally and configure it. Also, we can configure an Azure Redis Cache. The easiest way to install Redis on a Windows machine is chocolatey. To install chocolatey in a local machine, run the command given below from PowerShell (with administrative mode).

PS C:\>iex ((new-object net.webclient).DownloadString('https://chocolatey.org/install.ps1'))



This command downloads the chocalatey installer for Windows and using the command given below, we can install Redis on the local machine.

PS C:\>choco install redis-64

Once Redis Server is installed, use the command given below, where we can start Redis Server.

PS C:\>redis-server



To check whether Redis Server starts working properly, we can ping this Server, using Redis client.
If the server is working correctly, it returns “PONG” as the response.



Now, Redis Server is ready to be used as a distributed cache. We need to add highlighted dependency given below in to project.json file. Here, Redis dependency only works with .NET framework 4.5.1 or 4.5.2, so I am using .NET framework 4.5.1.

Project.json

{
    "buildOptions": {
        "preserveCompilationContext": true,
        "debugType": "portable",
        "emitEntryPoint": true
    },
    "dependencies": {
        "Microsoft.AspNetCore.Server.Kestrel": "1.0.0",
        "Microsoft.AspNetCore.Mvc": "1.0.0",
        "Microsoft.Extensions.Caching.Redis": "1.0.0"
    },
    "frameworks": {
        "net451": {},
    }
}

Using the code given below, we can configure Redis Server as a cache in our project. Here, we need to pass the Server's address as configuration and the Server instance name as an instance name property. I am running the Server locally, so I have to pass “localhost:6379” as a configuration.

Statup.cs

public void ConfigureServices(IServiceCollection services) {
    services.AddMvc();
    services.AddDistributedRedisCache(options => {
        options.Configuration = "localhost:6379";
        options.InstanceName = "";
    });
}

Application code is same as described in SQL distributed cache. We can also verify how many keys are active on Redis Server by running the command given below on Redis client.

127.0.0.1:6379> keys *



Summary

If we compare in-memory cache and distributed cache then in-memory cache is much faster than the distributed cache but it has some disadvantages. If we compare the above two described options for distributed cache, Redis Server is faster than SQL server. To improve the performance for SQL server distributed cache, we can use memory-optimized tables for caching but varbinary(max) and datetimeoffset data types are not supported in memory-optimized tables. If we want to use SQL Server for caching, we can use "dbcc pintable" to ensure the table is kept in the memory.