How to cal Session_End() method when you store the Session state not in Inprc but StageServer, etc.
Reference:http://www.codeproject.com/KB/aspnet/SessionEndStatePersister.aspx
The Session_End event is a useful event which an be handled in Global.asax to perform any actions when a session ends, such as logging an activity to the database, cleaning up temporary session files, etc.
However, when using any kind of state management other than InProc (such as StateServer or SqlStateServer), the ASP.NET web application does not fire the Session_End event, and any code in this method will not be executed.
Some browsing around returned a couple of good articles. The article Page tracking in ASP.NET offers a similar solution, though is geared around page tracking whereas my requirement was simply to find an alternative to the Session_End event that would work with the ASP.NET StateServer.
There's another excellent article called Preventing Multiple Logins in ASP.NET This is where I got the idea of using the application cache with a sliding expiry to trigger an event when the session ends.
The SessionEndModule class hooks into the PreRequestHandlerExecute event and inserts/replaces an item in the application cache, with a sliding expiry equal to the session expiry, and a callback method to be called when the item is removed from the application cache. The key of the cache item is the SessionId, and the value is the value of the item in the session with the key set as the SessionObjectKey.
When the item expires and the callback method is called. The key, value and reason of the expired item is passed to this callback method. The key is the SessionId, the value is the value copied from the session, and the reason is why the item was removed from the cache (was it removed, expired, underused, or it's dependency changed).
The callback method then checks that the item was removed as a result of it expiring, wraps the values into a SessionEndEventArgs class (which exposes SessionId and SessionObject properties), and fires the SessionEnd event.
//Code
using System.Diagnostics;
using System.IO;
using System.Web;
using System.Web.Caching;
using System.Web.SessionState;
namespace SessionTestWebApp
{
/// <summary>
/// When an ASP.NET State Server other than InProc, the Session_End event
/// does not get fired. This is an HttpModule which uses some workarounds
/// and fires a static event when a session ends, with the value of a single
/// configurable session variable in the event arguments.
/// </summary>
public class SessionEndModule : IHttpModule
{
#region Private Variables
private HttpApplication m_HttpApplication;
private static string m_SessionObjectKey;
#endregion
#region Accessors
/// <summary>
/// This is the key of the item in the session which should be returned
/// in the SessionEnd event (as the SessionObject).
/// </summary>
/// <example>
/// If you're storing the user ID in the session, under a key called 'UserId'
/// and need to do something with it in the SessionEnd event, you would set
/// this to 'UserId', which would cause the value of the session key called
/// 'UserId' to be returned.
/// </example>
public static string SessionObjectKey
{
get
{
return m_SessionObjectKey;
}
set
{
m_SessionObjectKey = value;
}
}
#endregion
#region IHttpModule Implementation
public void Init(HttpApplication context)
{
m_HttpApplication = context;
m_HttpApplication.PreRequestHandlerExecute += new EventHandler(OnPreRequestHandlerExecute);
}
public void Dispose()
{
// Do Nothing
}
#endregion
#region Events
/// <summary>
/// Event raised when the session ends
/// </summary>
public static event SessionEndEventHandler SessionEnd;
#endregion
private void OnPreRequestHandlerExecute(object sender, EventArgs e)
{
// We only want to update the session when an ASPX page is being viewed
// We're also doing this in the PreRequestHandler, as doing it elsewhere
// (like the PostRequestHandler) can cause some strange behaviour.
if (Path.GetExtension(m_HttpApplication.Context.Request.Path).ToLower() == ".aspx")
{
// Ensure we have a HttpContext
if (HttpContext.Current == null)
{
Debug.WriteLine("No current http context");
return;
}
// Get the current session
HttpSessionState currentSession = HttpContext.Current.Session;
// Ensure we have a current session
if (currentSession == null)
{
Debug.WriteLine("No current session");
return;
}
// Get the session timeout
TimeSpan sessionTimeout = new TimeSpan(0, 0, currentSession.Timeout, 0, 0);
// Get the object in the session we want to retrieve when the session times out
object sessionObject = currentSession[SessionObjectKey];
// Add the object to the cache with the current session id, and set a cache removal callback method
HttpContext.Current.Cache.Insert(currentSession.SessionID, sessionObject, null, DateTime.MaxValue, sessionTimeout, CacheItemPriority.NotRemovable, new CacheItemRemovedCallback(CacheItemRemovedCallbackMethod));
}
}
/// <summary>
/// This method is fired when an item is removed from the cache. It is used to detect when a cache item
/// expires, indicating that the session has expired, and fires the SessionEnd event.
/// </summary>
private void CacheItemRemovedCallbackMethod(string key, object value, CacheItemRemovedReason reason)
{
if (reason == CacheItemRemovedReason.Expired)
{
if (SessionEnd != null)
{
SessionEndedEventArgs e = new SessionEndedEventArgs(key, value);
SessionEnd(this, e);
}
}
}
}
/// <summary>
/// Event handler for handling the SessionEnd event
/// </summary>
public delegate void SessionEndEventHandler(object sender, SessionEndedEventArgs e);
/// <summary>
/// SessionEndedEventArgs for use in the SessionEnd event
/// </summary>
public class SessionEndedEventArgs : EventArgs
{
public readonly string SessionId;
public readonly object SessionObject;
public SessionEndedEventArgs(string sessionId, object sessionObject)
{
SessionId = sessionId;
SessionObject = sessionObject;
}
}
}
<add name="SessionEndModule" type="SessionTestWebApp.Components.SessionEndModule, SessionTestWebApp"/>
</httpModules>
<!-- Use the state server (rather than InProc), and set the timeout to 1 minute for easier testing-->
<sessionState mode="StateServer" stateConnectionString="tcpip=127.0.0.1:42424" timeout="1" cookieless="false"/>
{
// In our sample application, we want to use the value of Session["UserEmail"] when our session ends
SessionEndModule.SessionObjectKey = "UserEmail";
// Wire up the static 'SessionEnd' event handler
SessionEndModule.SessionEnd += new SessionEndEventHandler(SessionTimoutModule_SessionEnd);
}
private static void SessionTimoutModule_SessionEnd(object sender, SessionEndedEventArgs e)
{
Debug.WriteLine("SessionTimoutModule_SessionEnd : SessionId : " + e.SessionId);
// This will be the value in the session for the key specified in Application_Start
// In this demonstration, we've set this to 'UserEmail', so it will be the value of Session["UserEmail"]
object sessionObject = e.SessionObject;
string val = (sessionObject == null) ? "[null]" : sessionObject.ToString();
Debug.WriteLine("Returned value: " + val);
}
protected void Session_Start(object sender, EventArgs e)
{
Debug.WriteLine("Session started: " + Session.SessionID);
Session["UserId"] = new Random().Next(1, 100);
Session["UserEmail"] = new Random().Next(100, 1000).ToString() + "@domain.com";
Debug.WriteLine("UserId: " + Session["UserId"].ToString() + ", UserEmail: " +
Session["UserEmail"].ToString());
}
