Variables de sesión, como usarlas correctamente.

Como bien sabemos, según en que entorno, no es recomendable usar muchas variables de sesión. Del mismo modo, no es recomendable usarlas de una forma desordenada, ya que en un futuro se transformará en algo imposible de mantener. Por ello, en ésta, mi primera entrada al blog, voy a proponer una forma de trabajar que muchos conocen pero que otros muchos, quizás, no se hayan planteado.

Una de las formas más habituales de trabajar con sesiones es:

if (Session["candy"] != null)
    Session["candy"] = ((int)Session["candy"])+1;

Siempre hacemos la comprobación de null para no arriesgarnos y en el caso de la variable exista, haremos un cast al tipo deseado para poder incrementar en una unidad.

Lo primero que nos puede venir a la cabeza para mejorar la operación anterior es eliminar el String que define la clave de sesión y usar una constante. De esa manera evitaremos los futuros errores de escritura en otras partes de código. Y, en el caso que en un futuro necesitemos cambiar la clave, solo será necesario modificar una vez el valor de la constante y no iremos buscando por todo el código.

Pero… sabiendo que aun podemos trabajar de una forma más ordenada y limpia… ¿Por qué no le damos otra vuelta al código? ¿No sería incluso mejor evitar hacer la comprobación de null cada vez que necesitemos trabajar con el valor que contiene Session[“candy”]? O incluso ¿Crear un manejador que gestiones todas las variables de sesión de una forma más genérica?

Pues bien, al turrón:

Me gustaría proponeros que uséis una Clase auxiliar que se encargue de manejar todos los accesos a sesión, tanto de lectura como de escritura.

El ejemplo quedaría algo así:

public class SessionManager
{
      private const string CANDY = "candy";

      #region Get and Set

      public static T GetValue<T>(string sessionKey)
      {
          object sessionValue = HttpContext.Current.Session[sessionKey];
          if (sessionValue == null)
           return default(T);
          else
           return ((T)sessionValue);
      }

      public static void SetValue(string sessionKey, object value)
      {
          HttpContext.Current.Session[sessionKey] = value;
      }

      #endregion


      #region Properties

      public static int Candy
      {
         get
         {
            return GetValue<int>(CANDY);
         }
        set
        {
            SetValue(CANDY, value);
        }
      }

      #endregion
}

Como podéis comprobar he creado dos funciones y una propiedad: GetValue, SetValue y Caramelo(candy). Si lo analizamos un poco, podemos ver que el método GetValue admite cualquier tipo y que cada vez que hagamos una petición nos va a hacer la comprobación de tipo null. Por lo tanto va a devolver el valor del tipo correspondiente.

Siguiendo el ejemplo, tenemos el método SetValue al que se le pasa la clave y el valor. Bien sencillo, simplemente es una asignación.

Y, por último, la propiedad Caramelo(candy) que hace uso de las dos funciones anteriores: nos simplifica el acceso de lectura y de escritura en la variable.

A demás, al trabajar de este modo, ganaremos comodidad para trabajar con sintaxis del tipo:

SessionManager.Candy++;

En resumidas cuentas:

  • Ganamos consistencia de código
  • Flexibilidad
  • Rapidez
  • Una mejora considerable en la escalabilidad del proyecto.

Código en CODEPAD: https://codepad.co/snippet/UA6qoLPl

Esto es todo. Espero que esta simple aportación os sea de ayuda!!

Raúl

Deja un comentario