Simple ASP.NET Session Management Framework

• Download source files - 8.02 Kb

Introduction

For a project of my former employer, I’ve run into a problem of losing Session information after communication with other applications on different domains. My ASP.NET application was communicating via hidden-fields through a POST on a Java-Servlet and PHP pages. These pages get my postback-aspx-URL but after the postback, I lose the Session information because these applications where running on a different domain.

That's why I've looked for the possibilities in ASP.NET for storing Session information, without using difficult State-Management-servers or databases.

Creating the framework

ASP.NET developers are familiar with the objects Session and Cache, these objects are central in my framework for managing Session information.

I’ve started creating an object for storing Session information, named SessionObject. See listing 1. In this object, you can place your variables needed for your sessions.

public class SessionObject
{
  private string _userName = string.Empty;

  public string UserName
  {
    get { return _userName; }
    set { _userName = value; }
  }
}

Listing 1. SessionObject.cs

Thereafter, I’ve been thinking how I can get SessionObject back. In ASP.NET there is an object called Cache. This object is created on each Application-Domain and is type-safe on multi-threaded applications. Don’t forget that when your ASP.NET application is unloaded by the WebServer, your Cache object is also flushed. See listing 2.

public class SessionManager
{
  private const string SESSION_MANAGER = "SessionManager";
  private HttpContext _context;
  private Guid _sessionID;
  private SessionObject _sessionObject;

  public SessionManager (HttpContext httpContext)
  {
    _context = httpContext;
  }
  public static void Initialize(HttpContext httpContext)
  {
    httpContext.Items.Add(SESSION_MANAGER, new SessionManager (httpContext));
  }
  public static SessionManager Current
  {
    get { return (SessionManager) HttpContext.Current.Items[SESSION_MANAGER]; }
  }

  public Guid SessionID
  {
    get { return _sessionID; }
    set
    { 
      if (!_sessionID.Equals(value))
      {
        _sessionID = value;
        GetSessionObject(value);
       }
    }
  }
  private void GetSessionObject(Guid sessionID)
  {
    _sessionObject = _context.Cache[sessionID.ToString()] as SessionObject;
    if (_sessionObject == null)
      SetSessionObject(sessionID, new SessionObject());
  }

  private void SetSessionObject(Guid sessionID, SessionObject sessionObject)
  {
    _context.Cache.Add(sessionID.ToString(), 
      sessionObject,
      null,
      DateTime.MaxValue,
      TimeSpan.FromHours(2),
      System.Web.Caching.CacheItemPriority.High,
      null);
    _sessionObject = sessionObject;
  }

  public SessionObject SessionObject
  {
    get { return _sessionObject; }
  }
}

Listing 2. SessionManager.cs

The SessionManager uses a SessionID, this is stored in the Session object (not our SessionObject) or it will be returned by a QueryString variable of ASPX-page. On every request on the ASP.NET application, the SessionManager is initialized and added on the HttpContext.Items.

protected void Application_BeginRequest(Object sender, EventArgs e)
{
  Chompff.SessionManager.Web.SessionManager.Initialize(Context);
}

Listing 3. Global.asax.cs

By creating a base ASPX-page where all other ASPX-pages derive from, with a property SessionManager, you have access to the SessionManager on all other ASPX-pages. But it’s possible that the SessionManager doesn’t have a SessionObject initialized. Therefore, we create a property SessionID, and by setting the SessionID of the base ASPX-page, the SessionManager gets the SessionObject from the Cache, or when it doesn’t exist, it creates one and places it in the Cache. See listing 4.

public class BaseWebForm : System.Web.UI.Page
{
  private void Page_Load(object sender, System.EventArgs e)
  {
    // Put user code to initialize the page here
  }
  public SessionManager SessionManager
  {
    get { return SessionManager.Current; }
  }

  public Guid SessionID
  {
    get { return (Guid) Session["SessionID"]; }
    set
    {
      Session["SessionID"] = value;
      SessionManager.SessionID = value;
    }
  }
  override protected void OnInit(EventArgs e)
  {
    InitializeComponent();
    base.OnInit(e);
  }
  private void InitializeComponent()
  {
    this.Load += new System.EventHandler(this.Page_Load);
  }
}

Listing 4. BaseWebForm.cs

In every ASP.NET application, there is a start page. This page has to create a new SessionID by executing in the Page_Load: this.SessionID = Guid.NewGuid;. Now, there is a SessionObject created in the Cache, and you can get the Session information on every other ASPX-page by setting SessionID on that page.

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)