Random Code

It’s been quiet on here for a while – that’s because I’ve been warped back to WebForms land where everything is craziness and it takes you half a day just to figure out wth is going on because you have to work with logic spread across a half dozen code behind files that all run to a couple thousand lines (no exaggeration!).

The app I am currently working on uses session variables a lot, and doesn’t clean them up very often, leading to odd behaviors due to stale state (among other things).

The first thing I do when I come across a page using session variables is extract them all into properties at the top of the page – this ensures those ugly string indexers are only in 2 places (the get and set) and you only have to write the cast once.  The problem I find with this is that to figure out if the session variable has a value or clean up the session variable I still have to address it using the string indexer, sure I can wrap that in a simple method call so I only have the indexer in 3 or 4 places, but when you have a page with 6 session variables, this starts to add a lot of cruft to the code behind.  What I really wanted was a simple way of adding a few methods to the property so I could do something like this…

int newValue = 0;
if( MySessionVar.HasValue )
{
  newValue += MySessionVar;
}
MySessionVar.Clear();

With a little bit of poking around, some generics and a simple implicit cast, I ended up with this:

using System;
using System.Web;

namespace Blog.Code
{
    ///<summary>
    /// Wraps a number of convenience methods around session variables allowing for a more fluent
    /// expression of the intent.
    ///</summary>
    ///<typeparam name="T">The type of the value to store in the session.</typeparam>
    public class SessionVariable<T> : IEquatable<SessionVariable<T>>
    {
        private readonly T _tempValueStore;
        private readonly string _sessionKey;

        ///<summary>
        /// The stored value or the default value for the type
        /// if there is no value associated with the sessionkey
        ///</summary>
        public T Value
        {
            get
            {
                object value = HttpContext.Current.Session[_sessionKey];
                if(value == null)
                {
                    return default( T );
                }

                return (T)value;
            }
        }

        ///<summary>
        /// Indicates if there is a value stored.
        ///</summary>
        public bool HasValue
        {
            get
            {
                return HttpContext.Current.Session[ _sessionKey ] != null;
            }
        }

        ///<summary>
        /// Creates a new SessionVariable to access the value stored in <paramref name="sessionKey"/>
        ///</summary>
        ///<param name="sessionKey">The key used to access the value in the session</param>
        public SessionVariable( string sessionKey )
        {
            _sessionKey = sessionKey;
        }

        ///<summary>
        /// Creates a new SessionVariable to store the value provided.
        ///</summary>
        ///<param name="value">The value to store.</param>
        /// <remarks>
        /// Value is not stored until <see cref="Store"/> is called.
        /// </remarks>
        public SessionVariable( T value )
        {
            _tempValueStore = value;
        }

        ///<summary>
        /// Stores the value in the session using the key specified.
        ///</summary>
        ///<param name="sessionKey">The key used to store the value.</param>
        public void Store(string sessionKey)
        {
            HttpContext.Current.Session[ sessionKey ] = _tempValueStore;
        }

        ///<summary>
        /// Removes the entry from the session.
        ///</summary>
        public void Clear()
        {
            HttpContext.Current.Session.Remove( _sessionKey );
        }

        ///<summary>
        /// Implicitly converts the specified value into a SessionVariable instance.
        ///</summary>
        ///<param name="value">The value to convert.</param>
        ///<returns>A SessionVariable instance holding the specified value.</returns>
        public static implicit operator SessionVariable<T>(T value)
        {
            return new SessionVariable<T>( value );
        }

        ///<summary>
        /// Implicitly converts the SessionVariable back to the type of the wrapped value.
        ///</summary>
        ///<param name="sessionVariable">The SessionVariable to convert</param>
        ///<returns>The wrapped value.</returns>
        public static implicit operator T(SessionVariable<T> sessionVariable)
        {
            return sessionVariable.Value;
        }

        public override string ToString()
        {
            return Value.ToString();
        }

        public bool Equals( SessionVariable<T> sessionVariable )
        {
            if ( sessionVariable == null )
            {
                return false;
            }
            return Equals( Value, sessionVariable.Value );
        }

        public override bool Equals( object obj )
        {
            if ( ReferenceEquals( this, obj ) )
            {
                return true;
            }
            return Equals( obj as SessionVariable<T> );
        }

        public override int GetHashCode()
        {
            return Value.GetHashCode();
        }
    }
}

Which can be used like this:

protected SessionVariable<string> SuccessMessage
{
    get
    {
        return new SessionVariable<string>("SuccessMessage");
    }
    set
    {
        value.Store("SuccessMessage");
    }
}

The only caveat is when accessing methods on the object you are wrapping, you have to use 1 of 2 approaches to get at the underlying value…

// Directly access the underlying value
SuccessMessage.Value.Split(...);

// Assign the wrapped value to a temporary variable to force the implicit cast
string successMessage = SuccessMessage;
successMessage.Split(...);

As the session is really just a Dictionary<string, object> you could probably make this work for any dictionary with a few simple changes, however I didn’t need that flexibility so I leave it as an exercise for the future.