Este artigo do CodeProject realmente me inspirou,
http://www.codeproject.com/useritems/SessionWrapper.asp#xx1208856xx .
Como o autor disse, geralmente usamos muitos códigos semelhantes ao seguinte no ASP.NET para detectar os objetos armazenados na Sessão e evitar a perda de variáveis armazenadas após a expiração da Sessão:
Int32 nUserID = -1;
if ( null != Sessão["userID"] ) {
if (Sessão["userID"] é Int32) {
if ( 0 < Sessão["userID"] ) {
nUserID = (Int32) Sessão["userID"]
}
}
}
if (-1 == nUserID)
{
throw new ApplicationException("Situação inesperada: userID inválido." );
}
this.doSomething(nUserID);
Código como este estará em todo lugar.
Portanto, usar sua solução de encapsulamento para refatoração realmente torna o código muito mais simples e limpo!
Após seu encapsulamento, o código acima precisa apenas de uma frase:
this.doSomething( CCurrentSession.UserID )
Sua classe é na verdade muito simples, conforme mostrado abaixo:
usando o sistema;
usando System.Web
; -- ----------------------------------
/// Desenvolvido por M. van Eijkel - agosto de 2005
/// [e]: [email protected]
/// [w] :
namespace www.vaneijkel.com VanEijkel.Web
{
/**//// <resumo>
/// Classe wrapper para o objeto de sessão.
/// Centraliza a lógica de recuperação e validação das informações da sessão.
/// Ao usar uma abordagem como essa você melhora a proteção e o encapsulamento do código existente.
/// Ele oferece uma maneira simples, de baixo risco e fácil de gerenciar para melhorar o WebApplication existente.
/// Portanto, eu chamo isso de webRefactoring.
/// </sumário>
classe pública CurrentSession
{
Constantes#região Constantes
private const String sMANDATORY_SESSION_KEY_NOT_FOUND_MSG = "Variável de sessão excluída, mas não existe. Key={0}";
private
const String sMANDATORY_SESSION_VALUE_INVALID_NULL = "Nenhum valor de sessão nulo é excluído. Key={0}";
privado const Int32 nUSERID_MINIMUM = 1;
private const String sUSERID_INVALID = "UserID inválido:{0}. O UserID deve ser maior que:{1}";
#endregion
UserID#region UserID
/**//// <resumo>
/// Retorna o userID como um Int32 em vez de um objeto.
/// Desta forma você obterá a proteção do compilador e o suporte de inteligência que precisa.
/// </sumário>
ID de usuário Int32 estático público
{
pegar
{
retornar (Int32) GetValueOrDefault(eKeys.UserID, nUSERID_UNKOWN);
}
definir
{
if (nUSERID_MINIMUM >= valor)
{
lançar novo ApplicationException (String.Format(sUSERID_INVALID, valor, nUSERID_MINIMUM));
}
SetValue(eKeys.UserID, valor);
}
}
#endregion
privado: GetValueOrDefault( eKeys eKey, Object oDefaultValue ) #region privado: GetValueOrDefault( eKeys eKey, Object oDefaultValue )
/**//// <resumo>
/// Obtém o valor do objeto de sessão.
/// </sumário>
/// <param name="eKey"> A chave da sessão para a qual obter o valor.</param>
/// <param name="oDefaultValue">O valor padrão a ser usado se nenhum valor válido for armazenado.</param>
/// <returns>Quando o valor é nulo ou a chave não existe,
/// o valor padrão especificado é retornado.
/// Caso contrário, o valor será retornado</returns>
objeto estático privado GetValueOrDefault (eKeys eKey, Object oDefaultValue)
{
//obtém o valor
object oValue = GetValue( eKey );
//valor não encontrado ou nulo?
if (nulo == oValor)
{
//retorna o valor padrão
return oDefaultValue;
}
//tudo OK: retorna o valor da sessão
retornar oValor;
}
#endregion
privado: GetMandatoryValue( eKeys eKey )#região privada: GetMandatoryValue( eKeys eKey )
/**//// <resumo>
/// Retorna o valor da sessão para uma chave de sessão que deve existir.
/// Se a chave não existir, uma applicationException será lançada.
/// </sumário>
/// <param name="eKey"> A chave da sessão para a qual retornar o valor da sessão </param>.
/// <returns> Um valor não nulo.</returns>
objeto estático privado GetMandatoryValue (eKeys eKey)
{
//obtém o valor
object oValue = GetValue( eKey );
//chave não encontrada ou valor nulo?
if(nulo==oValor)
{
//lança applicationException porque é um erro de lógica de aplicação (nenhum CLR)
lançar nova ApplicationException (String.Format(sMANDATORY_SESSION_KEY_NOT_FOUND_MSG, eKey.ToString()));
}
//tudo OK: valor de retorno
retornar oValor;
}
#endregion
privado: GetValue( eKeys eKey )#região privada: GetValue( eKeys eKey )
/**//// <resumo>
/// Obtém o valor da sessão da chave especificada.
/// </sumário>
/// <param name="eKey">A chave da qual obter o valor</param>
/// <returns>O valor da sessão para a chave de sessão especificada.
/// Se a chave não existir, null será retornado.
/// </retorna>
objeto estático privado GetValue (eKeys eKey)
{
retornar HttpContext.Current.Items[eKey.ToString()];
}
#endregion
private SetMandatoryValue( eKeys eKey, Object oValue )#region private SetMandatoryValue( eKeys eKey, Object oValue )
private static void SetMandatoryValue (eKeys eKey, Object oValue)
{
if(nulo==oValor)
{
lançar novo ApplicationException(String.Format(sMANDATORY_SESSION_VALUE_INVALID_NULL, eKey.ToString()));
}
}
#endregion
private SetValue( eKeys eKey, Object oValue)#region private SetValue( eKeys eKey, Object oValue)
/**//// <resumo>
/// Armazena o valor de sessão especificado na chave de sessão especificada.
/// </sumário>
/// <param name="eKey">A chave do valor a ser armazenado na sessão.</param>
/// <param name="oValue">O valor a ser armazenado na sessão</param>
setValue vazio estático privado (eKeys eKey, Object oValue)
{
HttpContext.Current.Items[eKey.ToString()] = oValue;
}
#endregion
/**//// <resumo>
/// Um enum para o
/// </sumário>
eKeys de enumeração privada
{
ID do usuário
}
}
}