Session Wrapper

Question

I have two types of session wrappers:

Type 1

public class SessionHandler
{
    public static SessionHandler CurrentSession
    {
        get
        {
            SessionHandler session =
              (SessionHandler)HttpContext.Current.Session["SessionId"];
            if (session == null)
            {
                session = new SessionHandler();
                HttpContext.Current.Session["SessionId"] = session;
            }
            return session;
        }
    }

    public int? UserId { get; set; }
}

Type 2

public static class SessionHandler
{
    private static void SetSession<T>(string sessionId, T value)
    {
        HttpContext.Current.Session[sessionId] = value;
    }

    private static T GetSession<T>(string sessionId)
    {
        return (T)HttpContext.Current.Session[sessionId];
    }

    public static int? UserId
    {
        get
        {
            return GetSession<int>("UserId");
        }
        set
        {
            SetSession<int>("UserId", value);
        }
    }
}

The usage is as follows:

//Type 1
SessionHandler.CurrentSession.UserId = 10;
//Type 2
SessionHandler.UserId = 10;

Please suggest which one is better and why.

What I think about type 1:

Good for readability and maintainability. I can add more properties with less efforts, but the session will become heavy (single session for whole application). This approach may not be good, if we have more sessions to store. However, I'm not sure whether assignment/retrieving the session is just changing the reference or does some serialization/de-serialization.

What I think about type 2:

Usage is easy, but it needs little work while adding more sessions. This is the same as a normal session usage but, it just avoids the typos which might happen frequently while retrieving the sessions on various places.

Answer 1

private static T GetSession<T>(string sessionId)
{
    return (T)HttpContext.Current.Session[sessionId];
}

The above code will throw an exception if the value is not present.

Consider something like the following:

    private static T GetSession<T>(string sessionId)
    {
        T val = default(T);
        var session = HttpContext.Current.Session;

        if (session[sessionId] != null)
        {
            val = (T)session[sessionId];
        }

        return val;
    }

Answer 2

Alternatively you might want to consider using enums that have string values attached to them. There is an article detailing how you can make that work with attributes.

That way you can define an enum with all the keys that you want to store values in your session with like this:

public enum SessionKey {

    [StringValue("UserId")]
    UserId,

    [StringValue("UserName")]
    UserName,

    [StringValue("Hcskn")]
    HighlyComplexSessionKeyName

}

In your session wrapper you can have methods (such as a GetInt(SessionKey.UserId) or GetString(SessionKey.UserName)) that retrieve the values for you. This way you can be completely sure that you don't use the wrong string to retrieve values from the session and it is somewhat typesafe.

The only drawback is the amount of initial code you need to set it all up for you. The advantage is that it is easy to add new variable keys to store session values in as you only need to add that to the SessionKey enum.

---

EDIT:

As Chuck pointed out in comments: If the names on the enum values are enough then you can use ToString method on the enum to get the string representation. E.g.:

Console.Write(Session.Key.UserId.ToString()); 
// prints "UserId"