Pregunta ¿Cuál es la mejor manera de determinar una variable de sesión nula o vacía en C #?


¿Cuál es la mejor manera de verificar la existencia de una variable de sesión en ASP.NET C #?

Me gusta usar String.IsNullOrEmpty funciona para cadenas y se preguntó si había un método similar para Session. Actualmente, la única forma que conozco es:

 var sSession;
 if (Session["variable"] != null)
 {
     sSession = Session["variable"].ToString();
 }
 else
 {
     sSession = "set this";
     Session["variable"] = sSession;
 }

73
2017-10-24 19:33


origen


Respuestas:


Seguir desde lo que otros han dicho. Tiendo a tener dos capas:

La capa central Esto está dentro de una DLL que se agrega a casi todos los proyectos de aplicaciones web. En esto tengo una clase SessionVars que hace el trabajo ronco para getters / setters de estado de sesión. Contiene código como el siguiente:

public class SessionVar
{
    static HttpSessionState Session
    {
        get
        {
            if (HttpContext.Current == null)
                throw new ApplicationException("No Http Context, No Session to Get!");

            return HttpContext.Current.Session;
        }
    }

    public static T Get<T>(string key)
    {
        if (Session[key] == null)
            return default(T);
        else
            return (T)Session[key];
    }

    public static void Set<T>(string key, T value)
    {
        Session[key] = value;
    }
}

Tenga en cuenta los genéricos para obtener cualquier tipo.

Luego también agrego Getters / Setters para tipos específicos, especialmente cadenas, ya que a menudo prefiero trabajar con string. Vacío en lugar de nulo para las variables presentadas a los usuarios.

p.ej:

public static string GetString(string key)
{
    string s = Get<string>(key);
    return s == null ? string.Empty : s;
}

public static void SetString(string key, string value)
{
    Set<string>(key, value);
}

Y así...

Luego creo envoltorios para abstraer eso y llevarlo al modelo de la aplicación. Por ejemplo, si tenemos detalles del cliente:

public class CustomerInfo
{
    public string Name
    {
        get
        {
            return SessionVar.GetString("CustomerInfo_Name");
        }
        set
        {
            SessionVar.SetString("CustomerInfo_Name", value);
        }
    }
}

¿Captas la idea cierto? :)

NOTA: Solo pensé cuando agregué un comentario a la respuesta aceptada. Siempre asegúrese de que los objetos sean serializables cuando los almacena en Sesión cuando usa un servidor de estado. Puede ser muy fácil intentar y guardar un objeto usando los genéricos cuando está en la granja de servidores web y se dispara. Implemento en una granja de servidores web en el trabajo, así que agregué cheques a mi código en la capa central para ver si el objeto es serializable, otro beneficio de encapsular los Getters de sesión y Setters :)


109
2017-10-24 20:25



Eso es más o menos cómo lo haces. Sin embargo, hay una sintaxis más corta que puede usar.

sSession = (string)Session["variable"] ?? "set this";

Esto significa que si las variables de sesión son nulas, configura sSession para "configurar esto"


17
2017-10-24 19:37



Puede hacer las cosas más elegantes para envolverlo en una propiedad.

string MySessionVar
{
   get{
      return Session["MySessionVar"] ?? String.Empty;
   }
   set{
      Session["MySessionVar"] = value;
   }
}

entonces puedes tratarlo como una cadena.

if( String.IsNullOrEmpty( MySessionVar ) )
{
   // do something
}

14
2017-10-24 19:59



La notación 'como' en c # 3.0 es muy clara. Como todas las variables de sesión son objetos que aceptan nulos, esto le permite tomar el valor y ponerlo en su propia variable tipeada sin preocuparse de lanzar una excepción. La mayoría de los objetos pueden manejarse de esta manera.

string mySessionVar = Session["mySessionVar"] as string;

Mi concepto es que debe extraer sus variables de Sesión en variables locales y luego manejarlas adecuadamente. Siempre suponga que sus variables de Sesión podrían ser nulas y nunca convertirlas en un tipo que no admite nulos.

Si necesita una variable tipeada que no admite nulos, puede usar TryParse para obtenerla.

int mySessionInt;
if (!int.TryParse(mySessionVar, out mySessionInt)){
   // handle the case where your session variable did not parse into the expected type 
   // e.g. mySessionInt = 0;
}

7
2017-10-24 21:00



En mi opinión, la manera más fácil de hacer esto que es clara y fácil de leer es:

 String sVar = (string)(Session["SessionVariable"] ?? "Default Value");

Puede que no sea el método más eficiente, ya que arroja el valor de cadena predeterminado incluso en el caso del valor predeterminado (conversión de una cadena como cadena), pero si lo convierte en una práctica de codificación estándar, encontrará que funciona para todos los tipos de datos, y es fácil de leer.

Por ejemplo (un ejemplo totalmente falso, pero muestra el punto):

 DateTime sDateVar = (datetime)(Session["DateValue"] ?? "2010-01-01");
 Int NextYear = sDateVar.Year + 1;
 String Message = "The Procrastinators Club will open it's doors Jan. 1st, " +
                  (string)(Session["OpeningDate"] ?? NextYear);

Me gusta la opción Genéricos, pero parece exagerado a menos que espere necesitar esto por todos lados. El método de extensiones podría modificarse para extender específicamente el objeto Session de manera que tenga una opción de obtención "segura" como Session.StringIfNull ("SessionVar") y Session ["SessionVar"] = "myval"; Rompe la simplicidad de acceder a la variable a través de Session ["SessionVar"], pero es un código limpio, y aún permite validar si es nulo o si es una cadena si la necesita.


2
2017-08-23 01:30



Verificar por nada / nulo es la forma de hacerlo.

Tratar con tipos de objetos no es el camino a seguir. Declare un tipo estricto y trate de convertir el objeto al tipo correcto. (Y usa la sugerencia de conversión o Convertir)

 private const string SESSION_VAR = "myString";
 string sSession;
 if (Session[SESSION_VAR] != null)
 {
     sSession = (string)Session[SESSION_VAR];
 }
 else
 {
     sSession = "set this";
     Session[SESSION_VAR] = sSession;
 }

Perdón por cualquier violación de sintaxis, soy un VB'er diario


1
2017-10-24 19:39



Normalmente, creo SessionProxy con propiedades fuertemente tipadas para los elementos en la sesión. El código que accede a estas propiedades comprueba la nulidad y realiza la conversión al tipo adecuado. Lo bueno de esto es que todos mis artículos relacionados con la sesión se mantienen en un solo lugar. No tengo que preocuparme por usar claves diferentes en diferentes partes del código (y me pregunto por qué no funciona). Y con inyección de dependencia y burla puedo probarlo completamente con pruebas unitarias. Si sigue los principios DRY y también me permite definir valores predeterminados razonables.

public class SessionProxy
{
    private HttpSessionState session; // use dependency injection for testability
    public SessionProxy( HttpSessionState session )
    {
       this.session = session;  //might need to throw an exception here if session is null
    }

    public DateTime LastUpdate
    {
       get { return this.session["LastUpdate"] != null
                         ? (DateTime)this.session["LastUpdate"] 
                         : DateTime.MinValue; }
       set { this.session["LastUpdate"] = value; }
    }

    public string UserLastName
    {
       get { return (string)this.session["UserLastName"]; }
       set { this.session["UserLastName"] = value; }
    }
}

1
2017-10-24 20:23



También me gusta ajustar las variables de sesión en las propiedades. Los setters aquí son triviales, pero me gusta escribir los métodos get para que tengan solo un punto de salida. Para hacer eso, generalmente comprobo nulo y lo configuro en un valor predeterminado antes de devolver el valor de la variable de sesión. Algo como esto:

string Name
{
   get 
   {
       if(Session["Name"] == Null)
           Session["Name"] = "Default value";
       return (string)Session["Name"];
   }
   set { Session["Name"] = value; }
}

}


1
2017-10-25 07:26