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 .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.
Prerequisites to Configure ASP.NET Session Sharing with ASP.NET Core
- Install the following NuGet packages in your application:
- Enterprise: AspNet.SessionState.NCache
- Enterprise: AspNetCore.Session.NCache
- Include the following namespaces in your application:
- 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.
Configure ASP.NET Core Sessions for Sharing
You can specify the configurations for session sharing within your ASP.NET Core application in Appsettings.json. 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
Ensure the following:
- 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 asTrue
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.