Session State In ASP.NET Core

Introduction

Web applications work on HTTP protocol and HTTP is a stateless protocol. Every HTTP request is treated as an independent request. The Server does not have knowledge about the variable values, which are being used in the previous request.

 

Session is a feature in ASP.NET Core that enables us to save/store the user data. Session stores the data in the dictionary on the Server and SessionId is used as a key. The SessionId is stored on the client at cookie. The SessionId cookie is sent with every request. The SessionId cookie is per browser and it cannot be shared between the browsers. There is no timeout specified for SessionId cookie and they are deleted when the Browser session ends.

At the Server end, session is retained for a limited time. The default session timeout at the Server is 20 minutes but it is configurable.

Sessions are of two types, namely In-Proc or In-memory and Out-Proc or Distributed session. If our session is in-memory and our application is hosted on Web-Farm environment, we need to use sticky sessions to tie each session to a specific Server whereas an Out-Proc session does not require sticky sessions and they are the most preferred way to use sessions in our application.

 

Configuring session

Microsoft.AspNetCore.Session package provides middleware to manage the sessions in ASP.NET Core. To use session in our Application, we need to add this package as a dependency in project.json file.

 

Project.json

{
  "version": "1.0.0-*",
  "buildOptions": {
    "debugType": "portable",
    "emitEntryPoint": true
  },
  "dependencies": {},
  "frameworks": {
    "netcoreapp1.0": {
      "dependencies": {
        "Microsoft.NETCore.App": {
          "type": "platform",
          "version": "1.0.1"
        },
        "Microsoft.AspNetCore.Mvc": "1.0.1",
        "Microsoft.AspNetCore.Server.Kestrel": "1.0.1",
        "Microsoft.AspNetCore.Routing": "1.0.1",
        "Microsoft.AspNetCore.Session" : "1.0.1"
      },
      "imports": "dnxcore50"
    }
  }
}

The next step is to configure session in Startup class. We need to call "AddSession" method in ConfigureServices method of startup class. The "AddSession" method has one overload method, which accepts various session options such as Idle Timeout, Cookie Name and Cookie Domain etc. If we do not pass the session options, the system will take the default options. Now, we need to call "UseSession" method in Configure method of startup class. This method enables the session for the Application.

 

Startup.cs

using System;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;

namespace WebApplication {
    public class Startup {
        public void Configure(IApplicationBuilder app)
        {
            app.UseSession();
            app.UseMvc();
            app.Run(context => {
                return context.Response.WriteAsync("Hello Readers!");
            });
        }

        public void ConfigureServices(IServiceCollection services)
        {
            services.AddMvc();
            services.AddSession(options => {
                options.IdleTimeout = TimeSpan.FromMinutes(30);
            });
        }
    }
}

It is important to call "UseSession" method before the "UseMvc" method in Configure method of startup class. If we call “UseMvc” method before “UseSession” method, the system will throw an exception.

 

 

 

How to access the session

We can use session from HttpContext, once it is installed and configured. To use session in controller class, we need to reference "Microsoft.AspNet.Http" in controller. There are three methods that enables us to set the session value, which are Set, SetInt32 and SetString. The "Set" method accepts byte array as an argument. The SetInt32 and SetString method are the extension methods of Set and they internally cast byte array to int and string respectively. Same as there are three methods that  are used to retrieve the value from the session: Get, GetInt32 and GetString. The Get method returns byte of arrays.

 

The main reason behind storing bytes array is to make sure that session values are serializable for the storage on remote Servers. Apart from int and string, we need to serialize to byte array to store it in session.

 

Example

In the example given below, I have set my name into session in first request and retrieved the session value in another request.

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;

public class HomeController : Controller
{

    [Route("home/index")]
    public IActionResult Index()
    {
        HttpContext.Session.se.SetString("name","Jignesh Trivedi");
        return View();
    }
    [Route("home/GetSessionData")]
    public IActionResult GetSessionData()
    {
        ViewBag.data = HttpContext.Session.GetString("name");;
        return View();
    }
}

Output

 

 

Custom Session Extension methods

As discussed earlier, there are two extension methods to get the data from session and set the data to session are available, namely GetInt32 and GetString, SetInt32 and SetString. Similarly, we can add our custom extension methods to get and set the value in session.

In the example given below, I have created an extension method to set double value to session and get double value from session.

using System;
using Microsoft.AspNetCore.Http;
public static class SessionExtensions
{
    public static double? GetDouble(this ISession session, string key)
    {
        var data = session.Get(key);
        if (data == null)
        {
            return null;
        }
        return BitConverter.ToDouble(data, 0);
    }

    public static void SetDouble(this ISession session, string key, double value)
    {
        session.Set(key, BitConverter.GetBytes(value));
    }
}

Usage of the extension method

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
public class HomeController : Controller
{

    [Route("home/index")]
    public IActionResult Index()
    {
        HttpContext.Session.SetString("name","Jignesh Trivedi");
        HttpContext.Session.SetDouble("Percentage",75.56);
        return View();
    }
    [Route("home/GetSessionData")]
    public IActionResult GetSessionData()
    {
        ViewBag.data = HttpContext.Session.GetString("name");
        ViewBag.Percent = HttpContext.Session.GetDouble("Percentage");
        return View();
    }
}

Output

 

 

Store Complex Data in to Session

As we are aware, session is able to store only byte of an array. Compared to the previous version, ASP.NET Core does not perform any operation such as serialization/ de-serialization on the values stored in session. Here, I am converting the complex object into JSON and store it as a string. Later, I am retrieving it as a string and de-serialize to original object.

Thus, I have written the extension method for set and get complex object to session.

using System;
using Microsoft.AspNetCore.Http;
using Newtonsoft.Json;

public static class SessionExtensions
{
    public static T GetComplexData<T>(this ISession session, string key)
    {
        var data = session.GetString(key);
        if (data == null)
        {
            return default(T);
        }
        return JsonConvert.DeserializeObject<T>(data);
    }

    public static void SetComplexData(this ISession session, string key, object value)
    {
        session.SetString(key, JsonConvert.SerializeObject(value));
    }
}

Usage of the extension method

In the following example, I have created one public class and within controller action method, created the instance of the class, stored some data and sent it for storing in session. Similarly, I created one action method to retrieve the complex data from session.

public class User
{
    public string Name { get; set; }
    public double Percentage { get; set; }
}

Action method

[Route("home/SetComplexData")]
public IActionResult SetComplexData()
{
    User user = new User();
    user.Name = "Jignesh Trivedi";
    user.Percentage = 75.45;

    HttpContext.Session.SetComplexData("UserData", user);
    return View("index");
}
[Route("home/GetComplexData")]
public IActionResult GetComplexData()
{
    ViewBag.data = HttpContext.Session.GetComplexData<User>("UserData");
    return View();
}

Summary

The main advantages of ASP.NET Core is that it supports modularity. It means that we need to add the module, as we wish to use it in our application. The usage of session is slightly different than the classic ASP.NET Application. This article helps us to understand how to install, configure and use session with ASP.NET Core.