Configure ASP.NET Session Sharing with ASP.NET Core

NCache provides a high-performance solution for cross-platform session sharing between ASP.NET and ASP.NET Core, enabling seamless data persistence across hybrid .NET environments. Organizations can maintain a consistent Single Sign-On (SSO) experience and ensure interoperability between legacy and modern frameworks with minimal configuration by utilizing NCache as a distributed session store. This optimizes resource utilization by letting multiple applications reuse the same session, while NCache’s specialized extension methods eliminate the manual serialization overhead, providing a low-latency medium for collaborative data sharing.

Prerequisites for NCache Session Sharing

• .NET

• Install the following NuGet packages in your application based on your NCache edition:
  • Enterprise: AspNet.SessionState.NCache
  • Enterprise (Core): AspNetCore.Session.NCache
  • OpenSource: AspNet.SessionState.NCache.OpenSource
• Include the following namespaces in your application:
  • Alachisoft.NCache.Web.SessionState
• The cache must be running.
• For API details, refer to: AddNCacheSession, TryGetValue, Set.
• 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 Appsettings.json in ASP.NET Core

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.

Step 2: Configure Web.config in ASP.NET

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>

Step 3: Use NCache Extension Methods for Custom Objects

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.