Este artículo de CodeProject realmente me inspiró.
http://www.codeproject.com/useritems/SessionWrapper.asp#xx1208856xx .
Como dijo el autor, a menudo usamos una gran cantidad de código similar al siguiente en ASP.NET para detectar los objetos almacenados en la sesión y evitar la pérdida de variables almacenadas después de que expire la sesión:
Int32 nID de usuario = -1;
if (nulo! = Sesión["ID de usuario"]) {
if (Sesión["ID de usuario"] es Int32) {
if (0 < Sesión["ID de usuario"]) {
nUserID = (Int32) Sesión["userID"]
}
}
}
si (-1 == nID de usuario)
{
throw new ApplicationException ("Situación inesperada: ID de usuario no válido.");
}
this.doSomething( nUserID );
Códigos como este estarán en todas partes.
Entonces, usar su solución de encapsulación para refactorizar realmente hace que el código sea mucho más simple y limpio.
Después de su encapsulación, el código anterior solo necesita una oración:
this.doSomething( CCurrentSession.UserID )
Su clase es en realidad muy simple, como se muestra a continuación:
usando Sistema;
usando System.Web
/**////-------------------------------------- ------------------------------------
/// Desarrollado por M. van Eijkel - agosto de 2005
/// [e]: [email protected]
/// [w]: www.vaneijkel.com
espacio de nombres VanEijkel.Web
{
/**//// <resumen>
/// Clase contenedora para el objeto de sesión.
/// Centraliza la lógica de recuperación y validación de información de sesión.
/// Al utilizar un enfoque como este, se mejora la protección y la encapsulación del código existente.
/// Ofrece una forma sencilla, de bajo riesgo y fácil de gestionar de mejorar la aplicación web existente.
/// Por eso lo llamo webRefactoring.
/// </summary>
clase pública sesión actual
{
Constantes#región Constantes
private const String sMANDATORY_SESSION_KEY_NOT_FOUND_MSG = "La variable de sesión está exceptuada pero no existe. Clave={0}";
private const String sMANDATORY_SESSION_VALUE_INVALID_NULL = "No se exceptúa ningún valor de sesión nulo. Clave = {0}";
private const Int32 nUSERID_UNKOWN = -1;
constante privada Int32 nUSERID_MINIMUM = 1;
private const String sUSERID_INVALID = "ID de usuario no válido:{0}. El ID de usuario debe ser mayor que:{1}";
#endregion
ID de usuario#región ID de usuario
/**//// <resumen>
/// Devuelve el ID de usuario como Int32 en lugar de un objeto.
/// De esta manera obtendrá la protección del compilador y el soporte de inteligencia que necesita.
/// </summary>
ID de usuario público estático Int32
{
conseguir
{
retorno (Int32) GetValueOrDefault (eKeys.UserID, nUSERID_UNKOWN);
}
colocar
{
si (nUSERID_MINIMUM >= valor)
{
lanzar una nueva ApplicationException (String.Format(sUSERID_INVALID, valor, nUSERID_MINIMUM));
}
SetValue(eKeys.UserID, valor);
}
}
#endregion
privada: GetValueOrDefault (eKeys eKey, objeto oDefaultValue) #región privada: GetValueOrDefault (eKeys eKey, objeto oDefaultValue)
/**//// <resumen>
/// Obtiene el valor del objeto de sesión.
/// </summary>
/// <param name="eKey"> La clave de sesión para obtener el valor.</param>
/// <param name="oDefaultValue">El valor predeterminado que se utilizará si no se almacena ningún valor válido.</param>
/// <returns>Cuando el valor es nulo o la clave no existe,
/// se devuelve el valor predeterminado especificado.
/// En caso contrario, se devuelve el valor</returns>
objeto estático privado GetValueOrDefault (eKeys eKey, objeto oDefaultValue)
{
//obtener el valor
objeto oValue = GetValue(eKey);
//¿valor no encontrado o nulo?
si (nulo == oValor)
{
//devuelve el valor predeterminado
devolver oDefaultValue;
}
//todo bien: devolver el valor de la sesión
devolver oValor;
}
#regiónfinal
privado: GetMandatoryValue( eKeys eKey )#región privado: GetMandatoryValue( eKeys eKey )
/**//// <resumen>
/// Devuelve el valor de sesión para una clave de sesión que debe existir.
/// Si la clave no existe, se lanza una excepción de aplicación.
/// </summary>
/// <param name="eKey"> La clave de sesión para devolver el valor de sesión </param>.
/// <returns> Un valor no nulo.</returns>
objeto estático privado GetMandatoryValue (eKeys eKey)
{
//obtener el valor
objeto oValue = GetValue(eKey);
//¿clave no encontrada o valor nulo?
si(nulo==oValor)
{
//lanzamos applicationException debido a un error de lógica de aplicación (ninguno CLR)
lanzar una nueva ApplicationException (String.Format(sMANDATORY_SESSION_KEY_NOT_FOUND_MSG, eKey.ToString()));
}
//todo OK: valor de retorno
devolver oValor;
}
#regiónfinal
privado: GetValue (eKeys eKey) #región privado: GetValue (eKeys eKey)
/**//// <resumen>
/// Obtiene el valor de la sesión de la clave especificada.
/// </summary>
/// <param name="eKey">La clave para obtener el valor</param>
/// <returns>El valor de sesión para la clave de sesión especificada.
/// Si la clave no existe, se devuelve nulo.
/// </retornos>
objeto estático privado GetValue (eKeys eKey)
{
devolver HttpContext.Current.Items[eKey.ToString()];
}
#endregion
setMandatoryValue privado (eKeys eKey, objeto oValue) #región privado SetMandatoryValue (eKeys eKey, objeto oValue)
vacío estático privado SetMandatoryValue (eKeys eKey, objeto oValue)
{
si(nulo==oValor)
{
lanzar una nueva ApplicationException (String.Format (sMANDATORY_SESSION_VALUE_INVALID_NULL, eKey.ToString()));
}
}
#regiónfinal
SetValue privado (eKeys eKey, Objeto oValue)#región SetValue privado (eKeys eKey, Objeto oValue)
/**//// <resumen>
/// Almacena el valor de sesión especificado en la clave de sesión especificada.
/// </summary>
/// <param name="eKey">La clave del valor a almacenar en la sesión.</param>
/// <param name="oValue">El valor a almacenar en la sesión</param>
vacío estático privado SetValue (eKeys eKey, objeto oValue)
{
HttpContext.Current.Items[eKey.ToString()] = oValue;
}
#endregion
/**//// <resumen>
/// Una enumeración para el
/// </summary>
claves electrónicas de enumeración privada
{
ID de usuario
}
}
}