Multi-Region ASP.NET Core Session Provider for NCache

NCache provides session sharing support across multiple regions. This prevents users from losing their sessions in case you need to reroute your traffic to another location because of traffic or due to disaster recovery. Sessions are replicated across WAN seamlessly without replicating the entire session which may result in bandwidth expense. Figure 1 shows the process flow associated with session sharing across multiple regions.

Figure 1: Session Sharing across Data Centers

To share sessions across regions, you need to enable location affinity. This is enabled by setting the EnableLocationAffinity flag to true and providing the cache names and prefixes to identify the source (location) of the cache for the request. You can provide multiple cache names which form the web farm, however the cache specified against CacheName is considered the primary cache by default.

Prerequisites

• .NET/.NET Core

• Install the following NuGet packages in your application based on your NCache Version:
  • Enterprise: AspNetCore.Session.NCache
  • Professional: AspNetCore.Session.NCache.Professional
  • OpenSource: AspNetCore.Session.NCache.OpenSource
• To utilize the extension, include the following namespaces in your application in Startup.cs:
  • Alachisoft.NCache.Web.SessionState
• The cache must be running.
• For API details, refer to: AddNCacheSession, UseNCacheSession.
• Make sure that the data being added is serializable.
• To ensure the operation is fail safe, it is recommended to handle any potential exceptions within your application, as explained in Handling Failures.
• To handle any unseen exceptions, refer to the Troubleshooting section.

Step 1: Configure Services

The session management service needs to be initialized. In Startup.cs, use the AddNCacheSession() extension method on IServiceCollection in ConfigureServices() to initialize the service. The very basic overload of this extension method takes an IOptions<NCacheSessionConfiguration> as its base configuration.

There are two methods to specify configurations:

1. Through your application Startup.cs or
2. In JSON format in Appsettings.json .

Method 1: Specifying Configurations in Startup.cs

To enable session sharing, it is required to set the EnableLocationAffinity flag to true and provide the list of caches in AffinityMapping. Note that one of the caches should match the CacheName, which is considered the primary cache. It is also required to specify a directory which is shared by both the applications.

Note

The cache prefix should be maximum 4 characters long.

public void ConfigureServices(IServiceCollection services)
{
    // Add framework services.
    services.AddMvc();
    services.AddDataProtection()
    .PersistKeysToFileSystem(new DirectoryInfo(dir))
    .SetApplicationName("SharedCookieApp");

    services.AddNCacheSession(configuration =>
    {
        configuration.CacheName = "LondonCache"; //compulsory
        configuration.EnableLogs = true;
        configuration.SessionOptions.IdleTimeout = 5;
        configuration.EnableLocationAffinity = true;
        configuration.AffinityMapping = new CacheAffinity[]
        {
            new CacheAffinity { CacheName = "LondonCache", CachePrefix = "LDNC"},
            new CacheAffinity { CacheName = "NewYorkCache", CachePrefix = "NYKC"},
            new CacheAffinity { CacheName = "TokyoCache", CachePrefix = "TKYC"},
        };
    });
}

Method 2: Specifying Configurations in Appsettings.json

The session management service needs to be initialized. In Startup.cs, use the AddNCacheSession() extension method on IServiceCollection in ConfigureServices() to initialize the service. The very basic overload of this extension method takes an IOptions<NCacheSessionConfiguration> as its base configuration.

Note

The cache prefix should be maximum 4 characters long.

"NCacheSettings": {
    "EnableLocationAffinity": true,
    "EnableLogs": true,
    "RequestTimeout": 5,
    "CacheName": "LondonCache",
    "AffinityMapping": [
      {
        "CacheName": "LondonCache",
        "CachePrefix": "LDNC"
      },
      {
        "CacheName": "NewYorkCache",
        "CachePrefix": "NYKC"
      },
      {
        "CacheName": "TokyoCache",
        "CachePrefix": "TKYC"
      }
    ]
}

public void ConfigureServices(IServiceCollection services)
{
    //Add framework services
    services.AddMvc();

    //Add services to the container                    
    services.AddNCacheSession(Configuration.GetSection("NCacheSettings"));
}

Step 2: Add Middleware to Application

Once the services have been initialized, you can now configure the HTTP request pipeline by adding middleware in the Configure() method. The following is an excerpt showing the addition of a middleware layer through the use of UseNCacheSession() extension method in IApplicationBuilder. The NCache session middleware should always be stacked before the layer that utilizes the sessions.

public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
    loggerFactory.AddConsole(Configuration.GetSection("Logging"));
    loggerFactory.AddDebug();

    if (env.IsDevelopment()){
        app.UseDeveloperExceptionPage();
        app.UseBrowserLink();
    }
    else{
        app.UseExceptionHandler("/Home/Error");
    }

    app.UseStaticFiles();

    app.UseNCacheSession(); //store NCache session data

    app.UseMvc(routes =>
    {
        routes.MapRoute(
            name: "default",
            template: "{controller=myApp}/{action=Index}/{id?}");
    });
}

You can now proceed to use NCache as the underlying cache for your ASP.NET Core sessions.

Additional Resources

NCache provides sample application for Session Caching on GitHub.

• Shipped with NCache: %NCHOME%\samples\dotnetcore\SessionCaching

See Also

Using NCache with ASP.NET Core
Configure NCache ASP.​NET Core Session Provider
Session Storage in ASP.​NET Core
Object Caching in ASP.​NET Core
ASP.NET Core Response Caching