Post
Ask Question

Session Wrapper Design Pattern For ASP.NET Core

In previous post, we learned how to use Session in ASP.NET Core. In this article, we'll learn about Session Wrapper design pattern to ease the access of Session. In short, we'll make our access of session "Typed". Also, we may apply any validation or constraint in this wrapper class.
 
Step 1 - Create a Session Manager class
 
In this example, we are going to store two items in Session (i.e. ID & LoginName).
  1. We are injecting IHttpContextAccessor so that we can access the Session variable. 
  2. We are creating properties which are actually accessing Session variable and returning the data or writing the data to Session.
  3. We have added one helping property "IsLoggedIn" which is using other properties to make a decision. We may have more such helping/wrapper properties.
  1. using Microsoft.AspNetCore.Http;

  3. public class SessionManager  
  4.     {  
  5.         private readonly ISession _session;  
  6.         private const String ID_KEY = "_ID";  
  7.         private const String LOGIN_KEY = "_LoginName";  
  8.         public SessionManager(IHttpContextAccessor httpContextAccessor)  
  9.         {  
  10.             _session = httpContextAccessor.HttpContext.Session;  
  11.         }  
  12.   
  13.         public int ID  
  14.         {  
  15.             get  
  16.             {  
  17.                 var v = _session.GetInt32(ID_KEY);  
  18.                 if (v.HasValue)  
  19.                     return v.Value;  
  20.                 else  
  21.                     return 0;  
  22.             }  
  23.             set  
  24.             {  
  25.                 _session.SetInt32(ID_KEY, value);  
  26.             }  
  27.         }  
  28.         public String LoginName  
  29.         {  
  30.             get  
  31.             {  
  32.                 return _session.GetString(LOGIN_KEY);  
  33.             }  
  34.             set  
  35.             {  
  36.                 _session.SetString(LOGIN_KEY, value);  
  37.             }  
  38.         }  
  39.         public Boolean IsLoggedIn  
  40.         {  
  41.             get  
  42.             {  
  43.                 if (ID > 0)  
  44.                     return true;  
  45.                 else  
  46.                     return false;  
  47.             }  
  48.         }  
  49.     }  

Step 2

Registering IHttpContextAccessor and SessionManager in Startup file.
  1. services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();  
  2. services.AddScoped<SessionManager>();  
Step 3
 
Injecting SessionManager in your classes. Here is an example of Controller class but in the same way, it can be injected in non-controller classes too.
  1. private readonly SessionManager _sessionManager;  
  2. public HomeController(SessionManager sessionManager)  
  3. {  
  4.       _sessionManager = sessionManager;  
  5. }  
Step 4
 
Using SessionManager to access Session Data,
  1. _sessionManager.ID = 1;  
  2. _sessionManager.LoginName = dto.Login;  
  1. if(_sessionManager.IsLoggedIn == true)  
  2. {  
  3.    ViewBag.Login = _sessionManager.LoginName;  
  4.    return View();  
  5. }  

Conclusion

 
This wrapper pattern helps using Session without worrying about KeyNames & Makes access easier. It also helps you apply different conditioning and constraints in a wrapper class.


Similar Articles