Cet article de CodeProject m'a vraiment inspiré,
http://www.codeproject.com/useritems/SessionWrapper.asp#xx1208856xx .
Comme l'a dit l'auteur, nous utilisons souvent beaucoup de code similaire au suivant dans ASP.NET pour détecter les objets stockés dans la session afin d'éviter la perte des variables stockées après l'expiration de la session :
Int32 nIDUtilisateur = -1 ;
if ( null != Session["IDutilisateur"] ) {
si (Session["userID"] est Int32) {
si ( 0 < Session["IDutilisateur"] ) {
nUserID = (Int32) Session["userID"]
}
}
}
si ( -1 == nIDUtilisateur )
{
throw new ApplicationException ( "Situation inattendue : ID utilisateur invalide." );
}
this.doSomething( nUserID );
Un code comme celui-ci sera partout.
Ainsi, utiliser sa solution d’encapsulation pour le refactoring rend vraiment le code beaucoup plus simple et plus propre !
Après son encapsulation, le code ci-dessus n'a besoin que d'une seule phrase :
this.doSomething( CCurrentSession.UserID )
Sa classe est en fait très simple, comme indiqué ci-dessous :
utiliser le système ;
en utilisant System.Web ;
/**////-------------------------------------- -- ----------------------------------
/// Développé par M. van Eijkel - août 2005
/// [e] : [email protected]
/// [w] :
espace de noms www.vaneijkel.com VanEijkel.Web
{
/**//// <résumé>
/// Classe wrapper pour l'objet session.
/// Il centralise la logique de récupération et de validation des informations de session.
/// En utilisant une approche comme celle-ci, vous améliorez la protection et l'encapsulation du code existant.
/// Il offre un moyen simple, à faible risque et facile à gérer d'améliorer une application Web existante.
/// Par conséquent, je l'appelle webRefactoring.
/// </summary>
classe publique CurrentSession
{
Constantes#region Constantes
private const String sMANDATORY_SESSION_KEY_NOT_FOUND_MSG = "Variable de session exceptée mais n'existe pas. Key={0}";
private const String sMANDATORY_SESSION_VALUE_INVALID_NULL = "Aucune valeur de session nulle exceptée. Key={0}";
private const Int32 nUSERID_UNKOWN = -1;
privé const Int32 nUSERID_MINIMUM = 1;
private const String sUSERID_INVALID = "ID utilisateur invalide :{0}. L'ID utilisateur doit être supérieur à :{1}" ;
#endregion
ID utilisateur#region ID utilisateur
/**//// <résumé>
/// Renvoie l'ID utilisateur sous forme de Int32 au lieu d'un objet.
/// De cette façon, vous obtiendrez la protection du compilateur et le support de renseignement dont vous avez besoin.
/// </summary>
ID utilisateur Int32 public statique
{
obtenir
{
return (Int32) GetValueOrDefault( eKeys.UserID, nUSERID_UNKOWN );
}
ensemble
{
si ( nUSERID_MINIMUM >= valeur )
{
lancer une nouvelle ApplicationException ( String.Format(sUSERID_INVALID, value, nUSERID_MINIMUM ));
}
SetValue(eKeys.UserID, valeur);
}
}
#endregion
privé : GetValueOrDefault( eKeys eKey, Object oDefaultValue ) #region private : GetValueOrDefault( eKeys eKey, Object oDefaultValue )
/**//// <résumé>
/// Obtient la valeur de l'objet de session.
/// </summary>
/// <param name="eKey"> La clé de session pour laquelle obtenir la valeur.</param>
/// <param name="oDefaultValue">La valeur par défaut à utiliser si aucune valeur valide n'est stockée.</param>
/// <returns>Lorsque la valeur est nulle ou que la clé n'existe pas,
/// la valeur par défaut spécifiée est renvoyée.
/// Sinon, la valeur est renvoyée</returns>
objet statique privé GetValueOrDefault (eKeys eKey, Object oDefaultValue)
{
//récupère la valeur
objet oValue = GetValue( eKey );
//valeur introuvable ou nulle ?
si (null == oValue)
{
// renvoie la valeur par défaut
renvoyer oDefaultValue ;
}
//tout va bien : renvoie la valeur de la session
retourner oValeur ;
}
#endregion
privé : GetMandatoryValue( eKeys eKey )#region privé : GetMandatoryValue( eKeys eKey )
/**//// <résumé>
/// Renvoie la valeur de session pour une clé de session qui doit exister.
/// Si la clé n'existe pas, une applicationException est levée.
/// </summary>
/// <param name="eKey"> La clé de session pour laquelle renvoyer la valeur de session </param>.
/// <returns> Une valeur non nulle.</returns>
objet statique privé GetMandatoryValue( eKeys eKey )
{
//récupère la valeur
object oValue = GetValue( eKey );
//clé introuvable ou valeur nulle ?
si (null == oValeur)
{
//lance une exception applicationCar car son erreur de logique d'application (aucun CLR)
lancer une nouvelle ApplicationException ( String.Format( sMANDATORY_SESSION_KEY_NOT_FOUND_MSG, eKey.ToString() ));
}
//tout va bien : valeur de retour
retourner oValeur ;
}
#endregion
privé : GetValue( eKeys eKey )#region privé : GetValue( eKeys eKey )
/**//// <résumé>
/// Obtient la valeur de session à partir de la clé spécifiée.
/// </summary>
/// <param name="eKey">La clé à partir de laquelle obtenir la valeur</param>
/// <returns>La valeur de session pour la clé de session spécifiée.
/// Si la clé n'existe pas, null est renvoyé.
/// </retourne>
objet statique privé GetValue (eKeys eKey)
{
return HttpContext.Current.Items[ eKey.ToString() ];
}
#endregion
private SetMandatoryValue( eKeys eKey, Object oValue )#region private SetMandatoryValue( eKeys eKey, Object oValue )
vide statique privé SetMandatoryValue (eKeys eKey, Object oValue)
{
si (null == oValeur)
{
lancer une nouvelle ApplicationException( String.Format(sMANDATORY_SESSION_VALUE_INVALID_NULL, eKey.ToString() ) );
}
}
#endregion
Private SetValue (eKeys eKey, Objet oValue)#region private SetValue (eKeys eKey, Objet oValue)
/**//// <résumé>
/// Stocke la valeur de session spécifiée dans la clé de session spécifiée.
/// </summary>
/// <param name="eKey">La clé de la valeur à stocker dans la session.</param>
/// <param name="oValue">La valeur à stocker dans la session</param>
vide statique privé SetValue (eKeys eKey, Object oValue)
{
HttpContext.Current.Items[eKey.ToString()] = oValue ;
}
#endregion
/**//// <résumé>
/// Une énumération pour le
/// </summary>
Clés électroniques d'énumération privée
{
ID de l'utilisateur
}
}
}