Implementing Real-Time Cache Sync with NCache and SignalR

We can overcome all these bottlenecks by using scalable In-memory distributed Cache. In this article, I’m going to explain the NCache, which provides a distributed linear scalability that will help us to overcome all the bottlenecks which we discussed earlier.

What is NCache?

NCache is an in-memory distributed cache for .NET, Java, and Node.js, and it is also open-source. NCache is super-fast and scalable and caches application data to reduce database trips. NCache is used to overcome the performance issues related to data storage, databases, and scaling the .NET, Java, and Node.js applications.

Before going through the next topic, if you are new to NCache, please click here to check how to install the NCache and how to manage the Cache using the NCache web monitoring application.

What is ASP.NET Core SignalR?

ASP.NET Core SignalR is a library for developers to implement the process to integrate real-time functionality. The library can be used to integrate any kind of real-time web functionality into your ASP.NET application. It can have server-side code push content to the connected clients immediately once it is available. It is an open-source Microsoft API.

Implementing Real-Time Cache Sync NCache as a Backplane and ASP.Net Core SignalR Application

I’m going to use my existing ASP.NET Core SignalR application for the demo. You can download the source code from GitHub. Please read this article to understand how to create an ASP.NET Core SignalR application.

Add the below JSON object in the appsettings.json file:

"NCacheConfiguration": {
  "CacheName": "myLocalCache",
  "EventKey ": "signalRApplication"
},

• CacheName: Provide your newly created cluster cache name
• ApplicationID: Give some unique string relevant to your application. It acts as an event key, and each client of the application will use the same key while using the invoking NCache extension method.

Download and install the package AspNetCore.SignalR.NCache from NuGet Package Manager or use the below command from the package manager console in Visual Studio.

Install-Package AspNetCore.SignalR.NCache

Add the below code to Program.cs file.

ConfigurationManager configuration = builder.Configuration;
builder.Services.AddSignalR().AddNCache(ncacheOptions => {
    ncacheOptions.CacheName = configuration["NCacheConfiguration:CacheName"];
    ncacheOptions.EventKey = configuration["NCacheConfiguration: EventKey"];
});

Now our application is connected with NCache, assume we have two web servers connected with NCache as a backplane.

The application which I have used is to collect the real-time temperature from different agriculture farms; in real-time, the data will come from an IoT device, but for a demo, I used the client-side data entry for the temperature update. Once the temperature is updated from one client, it will reach the SignalR hub; since the web server is connected with NCache, an In-memory distributed cache acts as a Backplane. It will sync the data with other servers, and the real-time data will reach all the clients.

The default Hub protocol is using JSON. The sample looks like the below statement.

{
 “type”: 1 
  “target”: “Receiving a message”
   “argument”: [{”id”:1, “NewTemperature”:29}] 
}

Type 1 means that this is a function invocation.

Target is the name of the function, and argument is an array of parameters passed to the function.

Run the application and try it from two browsers as two clients and assume we have two web servers connected with NCache as a Backplane.

Update the temperature of farm B from 26 to 29. It will reflect across different clients.

Client Connection has been established, and now the NCache will act as a backplane for our SignalR application. Once the NCache initiates, you can see the client count in the NCache web monitor application, as shown in the below figure:

Summary

We have seen the basics of SignalR, the Backplane for SignalR to avoid the inconsistency in the real-time data across all the clients, and we found some bottlenecks with maintaining performance and avoiding the single point of failure with the conventional implementation of the SignalR with Backplane. To overcome these bottlenecks, we used NCache distributed Cache as a Backplane for our ASP.NET Core SignalR application to sync to real-time data and maintain user consistency across all the clients with high performance and no single point of failure.