Configure ASP.NET Session Sharing with ASP.NET Core

With the advent of .NET Core, many organizations have moved to this framework because of its increased performance and cross-platform, open-source support. However, in some cases, the cost of switching an entire complex application to a new framework can sometimes outweigh the benefits of the framework. Thus, it is feasible for companies to keep some modules in ASP.NET while keeping the others in ASP.NET Core.

In such a case, the need for seamless sharing sessions between the two frameworks arises. This means if a ASP.NET session has been created, ASP.NET Core apps can read and update that ASP.NET session and vice versa. Session sharing also allows a Single Sign-On (SSO) experience for websites that have multiple back-end applications running in ASP.NET and ASP.NET Core. Moreover, session sharing encourages low resource utilization and cuts down the cost of creating new sessions as the same session can be reused by multiple applications.

NCache offers exclusive support to share your ASP.NET Core and ASP.NET sessions with negligible programming effort on your part. It allows both ASP.NET and ASP.NET Core to collaborate using NCache as a data-sharing medium with few configuration changes.

Session Sharing NCache

Prerequisites to Configure ASP.NET Session Sharing with ASP.NET Core

Configure ASP.NET Core Sessions for Sharing

You can specify the configurations for session sharing within your ASP.NET Core application in Appsettings.json. The EnableSessionSharing must be set to true, it is false by default. The new configuration section is named NCacheSettings; you can also specify a name of your choice.

Important

The cookie name must be the same as provided in the ASP.NET configuration. If you want to use JSON serialization, set the useJsonSerialization flag as True for both ASP.NET and ASP.NET Core.

. . .
"NCacheSettings":
{    . . .
   "EnableSessionSharing":  true, // Set to true, false by default
   "CacheName": "demoCache", // Replace name with name of your cache
   "useJsonSerialization": false, // Set this flag as true if you want to use Json serialization
    "SessionOptions":
    {
      "CookieName": "ASP.NET_CORE_SessionId", // Must be same for both .NET Core and .NET
      "CookieDomain": null,
      "CookiePath": "/",
      "CookieHttpOnly": "True",
      "IdleTimeout": "20",
      "CookieSecure": "None"
    }
}

In Startup.cs of your application, refer to the configurations by specifying the name of the configuration section (NCacheSettings in this case):

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

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

NCache allows adding and fetching custom objects with ASP.NET Core sessions, eliminating the need to serialize and deserialize the objects at the client end. Hence, you must use NCache extension methods while using ASP.NET Core sessions.

Configure ASP.NET Sessions for Sharing

To enable session sharing in your ASP.NET application, add the following configuration in XML format in web.config of your application. The enableSessionSharing tag must be set to true, it is false by default.

Important

The cookie name must be the same as provided in the ASP.NET Core configuration. Also, if you want to use Json serialization, set the useJsonSerialization property as true.

<sessionState ...
            customProvider="NCacheSessionProvider"
            cookieName="ASP.NET_CORE_SessionId">
    <providers>
            <add name="NCacheSessionProvider"
            type="Alachisoft.NCache.Web.SessionState.NSessionStoreProvider"
            useJsonSerialization = "false"
            enableSessionSharing="true"
            sessionAppId="NCacheSharedSessionApp"
            cacheName="demoCache"
            ... />
    </providers>
</sessionState>

Use Custom Objects in ASP.NET Core Sessions

The default ASP.NET Core session interface supports adding/fetching session data as a byte with a string key. Some solutions exist to provide primitive type support to add/fetch primitive type data from sessions. However, there is still a need to serialize/deserialize data into a byte while dealing with custom objects. NCache provides extension methods on the ASP.NET Core session interface that support adding and fetching custom objects and automatically handles the serialization/deserialization of objects for you. This takes away the need to use binary/JSON converters or write code to serialize/deserialize data at the client end.

If you have enabled session sharing between your applications, you must use the extension methods provided by NCache for the ASP.NET Core interface. These methods are explained below:

Important

When using Session Sharing, you must use NCache extension methods with ASP.NET Core to add and fetch custom objects.

Add Custom Object to ASP.NET Core Session

You can add a custom object to the session using the NCache extension for the ASP.NET Core session interface Set method.

string key = "ProductID:1001";
Product customObejct = GetProduct(1001);

// Add custom object to session with against key
HttpContext.Session.Set(key, customObject);

Fetch Custom Object from ASP.NET Core Session

You can fetch a custom object from the session using NCache extension for the ASP.NET Core session interface TryGetValue method.

string key = "ProductID:1001";

// Fetch custom object against key it was added against ("ProductID:1001")
HttpContext.Session.TryGetValue(key, out customObject);

if(customObject != null)
{
   // Use custom object
}

See Also

.NET: Alachisoft.NCache.Web.SessionState namespace.