Dieser Artikel von CodeProject hat mich wirklich inspiriert,
http://www.codeproject.com/useritems/SessionWrapper.asp#xx1208856xx .
Wie der Autor sagte, verwenden wir in ASP.NET häufig eine Menge Code ähnlich dem folgenden, um die in der Sitzung gespeicherten Objekte zu erkennen und den Verlust gespeicherter Variablen nach Ablauf der Sitzung zu verhindern:
Int32 nUserID = -1;
if ( null != Session["userID"] ) {
if (Session["userID"] is Int32) {
if ( 0 < Session["userID"] ) {
nUserID = (Int32) Session["userID"]
}
}
}
if ( -1 == nUserID )
{
throw new ApplicationException („Unerwartete Situation: Benutzer-ID ungültig.“);
}
this.doSomething( nUserID );
Code wie dieser wird überall sein.
Die Verwendung seiner Kapselungslösung für das Refactoring macht den Code also wirklich viel einfacher und sauberer!
Nach seiner Kapselung benötigt der obige Code nur einen Satz:
this.doSomething( CCurrentSession.UserID )
Seine Klasse ist eigentlich sehr einfach, wie unten gezeigt:
Verwenden des Systems;
using System.Web;
/**////--------- -------------------------------------
/// Entwickelt von M. van Eijkel – August 2005
/// [e]: [email protected]
/// [w]: www.vaneijkel.com
-Namespace VanEijkel.Web
{
/**//// <Zusammenfassung>
/// Wrapper-Klasse für das Sitzungsobjekt.
/// Es zentralisiert die Logik zum Abrufen und Validieren von Sitzungsinformationen.
/// Mit einem solchen Ansatz verbessern Sie den Schutz und die Kapselung des vorhandenen Codes.
/// Es bietet eine einfache, risikoarme und leicht zu verwaltende Möglichkeit, bestehende Webanwendungen zu verbessern.
/// Deshalb nenne ich es webRefactoring.
/// </summary>
öffentliche Klasse CurrentSession
{
Konstanten#region Konstanten
private const String sMANDATORY_SESSION_KEY_NOT_FOUND_MSG = „Sitzungsvariable ausgenommen, aber nicht vorhanden. Key={0}“;
private const String sMANDATORY_SESSION_VALUE_INVALID_NULL = „Kein Null-Sitzungswert ausgenommen. Key={0}“
private const Int32 nUSERID_UNKOWN = -1;
private const Int32 nUSERID_MINIMUM = 1;
private const String sUSERID_INVALID = „Ungültige Benutzer-ID:{0}. Benutzer-ID sollte größer sein als:{1}“;
#endregion
UserID#region UserID
/**//// <Zusammenfassung>
/// Gibt die Benutzer-ID als Int32 statt als Objekt zurück.
/// Auf diese Weise erhalten Sie den Compiler-Schutz und die Intelligenzunterstützung, die Sie benötigen.
/// </summary>
öffentliche statische Int32-Benutzer-ID
{
erhalten
{
return (Int32) GetValueOrDefault( eKeys.UserID, nUSERID_UNKOWN );
}
Satz
{
if ( nUSERID_MINIMUM >= value )
{
throw new ApplicationException ( String.Format(sUSERID_INVALID, value, nUSERID_MINIMUM ));
}
SetValue(eKeys.UserID, Wert);
}
}
#endregion
private: GetValueOrDefault( eKeys eKey, Object oDefaultValue ) #region private: GetValueOrDefault( eKeys eKey, Object oDefaultValue )
/**//// <Zusammenfassung>
/// Ruft den Wert vom Sitzungsobjekt ab.
/// </summary>
/// <param name="eKey"> Der Sitzungsschlüssel, für den der Wert abgerufen werden soll.</param>
/// <param name="oDefaultValue">Der zu verwendende Standardwert, wenn kein gültiger Wert gespeichert ist.</param>
/// <returns>Wenn der Wert null ist oder der Schlüssel nicht existiert,
/// der angegebene Standardwert wird zurückgegeben.
/// Andernfalls wird der Wert zurückgegeben</returns>
privates statisches Objekt GetValueOrDefault( eKeys eKey, Objekt oDefaultValue )
{
//Erhalte den Wert
object oValue = GetValue( eKey );
//Wert nicht gefunden oder null?
if (null == oValue)
{
//Standardwert zurückgeben
return oDefaultValue;
}
//Alles OK: Sitzungswert zurückgeben
return oValue;
}
#endregion
privat: GetMandatoryValue( eKeys eKey )#region privat: GetMandatoryValue( eKeys eKey )
/**//// <Zusammenfassung>
/// Gibt den Sitzungswert für einen Sitzungsschlüssel zurück, der vorhanden sein muss.
/// Wenn der Schlüssel nicht existiert, wird eine applicationException ausgelöst.
/// </summary>
/// <param name="eKey"> Der Sitzungsschlüssel, für den der Sitzungswert zurückgegeben werden soll </param>
/// <returns> Ein Nicht-Null-Wert.</returns>
privates statisches Objekt GetMandatoryValue( eKeys eKey )
{
//Erhalte den Wert
object oValue = GetValue( eKey );
//Schlüssel nicht gefunden oder Wert null?
if(null==oValue)
{
//Anwendungsausnahme auslösen, weil Anwendungslogikfehler (keine CLR)
throw new ApplicationException ( String.Format( sMANDATORY_SESSION_KEY_NOT_FOUND_MSG, eKey.ToString() ));
}
//alles OK: Rückgabewert
return oValue;
}
#endregion
privat: GetValue( eKeys eKey )#region privat: GetValue( eKeys eKey )
/**//// <Zusammenfassung>
/// Ruft den Sitzungswert vom angegebenen Schlüssel ab.
/// </summary>
/// <param name="eKey">Der Schlüssel, von dem der Wert abgerufen werden soll</param>
/// <returns>Der Sitzungswert für den angegebenen Sitzungsschlüssel.
/// Wenn der Schlüssel nicht existiert, wird null zurückgegeben.
/// </returns>
privates statisches Objekt GetValue( eKeys eKey )
{
return 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(null==oValue)
{
throw new ApplicationException( String.Format(sMANDATORY_SESSION_VALUE_INVALID_NULL, eKey.ToString() ) );
}
}
#endregion
private SetValue( eKeys eKey, Object oValue)#region private SetValue( eKeys eKey, Object oValue)
/**//// <Zusammenfassung>
/// Speichert den angegebenen Sitzungswert im angegebenen Sitzungsschlüssel.
/// </summary>
/// <param name="eKey">Der Schlüssel für den Wert, der in der Sitzung gespeichert werden soll.</param>
/// <param name="oValue">Der in der Sitzung zu speichernde Wert</param>
private static void SetValue (eKeys eKey, Object oValue)
{
HttpContext.Current.Items[eKey.ToString()] = oValue;
}
#endregion
/**//// <Zusammenfassung>
/// Eine Aufzählung für die
/// </summary>
private Enumerations-eKeys
{
Benutzer-ID
}
}
}