Quel est le meilleur moyen de déterminer si une variable de session est nulle ou vide en C #?
Quel est le meilleur moyen de vérifier l'existence d'une variable de session dans ASP.NET C #?
J'aime utiliser String.IsNullOrEmpty fonctionne pour les chaînes et je me suis demandé s'il existait une méthode similaire pour Session. Actuellement, le seul moyen que je connaisse est:
var sSession;
if (Session["variable"] != null)
{
sSession = Session["variable"].ToString();
}
else
{
sSession = "set this";
Session["variable"] = sSession;
}
Pour faire suite à ce que d’autres ont dit. J'ai tendance à avoir deux couches:
La couche de base. Cela se trouve dans une DLL ajoutée à presque tous les projets d'application Web . En cela, j'ai une classe SessionVars qui effectue le travail difficile pour les getters/setters d'état de session. Il contient le code suivant:
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;
}
}
Notez les génériques pour obtenir n'importe quel type.
Ensuite, j'ajoute également des paramètres Getters/Setters pour des types spécifiques, en particulier string, car je préfère souvent travailler avec string.Empty plutôt que null pour les variables présentées aux utilisateurs.
par exemple:
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);
}
Etc...
Je crée ensuite des wrappers pour faire abstraction de cela et l'amener au modèle d'application. Par exemple, si nous avons les détails du client:
public class CustomerInfo
{
public string Name
{
get
{
return SessionVar.GetString("CustomerInfo_Name");
}
set
{
SessionVar.SetString("CustomerInfo_Name", value);
}
}
}
Vous avez la bonne idée? :)
NOTE: Je viens d'avoir une pensée lors de l'ajout d'un commentaire à la réponse acceptée. Assurez-vous toujours que les objets sont sérialisables lors de leur stockage dans Session lors de l'utilisation d'un serveur d'état. Il peut être trop facile d'essayer de sauvegarder un objet en utilisant les génériques lorsque vous êtes sur une ferme Web. Je déploie sur une batterie de serveurs Web au travail. J'ai donc ajouté des vérifications à mon code dans la couche principale pour voir si l'objet est sérialisable. Un autre avantage de l'encapsulation des Getters et Setters de la session :)
C'est à peu près comment vous le faites. Cependant, vous pouvez utiliser une syntaxe plus courte.
sSession = (string)Session["variable"] ?? "set this";
Cela signifie que si les variables de session sont nulles, définissez sSession sur "set this"
Il peut être plus élégant de l’envelopper dans une propriété.
string MySessionVar
{
get{
return Session["MySessionVar"] ?? String.Empty;
}
set{
Session["MySessionVar"] = value;
}
}
alors vous pouvez le traiter comme une chaîne.
if( String.IsNullOrEmpty( MySessionVar ) )
{
// do something
}
La notation 'as' dans c # 3.0 est très propre. Comme toutes les variables de session sont des objets nullables, cela vous permet de saisir la valeur et de la placer dans votre propre variable typée sans vous soucier de générer une exception. La plupart des objets peuvent être manipulés de cette façon.
string mySessionVar = Session["mySessionVar"] as string;
Mon concept est que vous devriez extraire vos variables de session en variables locales, puis les gérer correctement. Supposez toujours que vos variables de session peuvent être nulles et ne les convertissez jamais en un type non nullable.
Si vous avez besoin d'une variable typée non nullable, vous pouvez utiliser TryParse pour l'obtenir.
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;
}
À mon avis, la façon la plus simple de le faire, claire et facile à lire, est la suivante:
String sVar = (string)(Session["SessionVariable"] ?? "Default Value");
Ce n'est peut-être pas la méthode la plus efficace, car elle convertit la valeur de chaîne par défaut même dans le cas de la valeur par défaut (transformer une chaîne en chaîne), mais si vous en faites une pratique de codage standard, vous constaterez que cela fonctionne pour tous les types de données et est facilement lisible.
Par exemple (un exemple totalement faux, mais il montre le point):
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);
J'aime l'option des génériques, mais cela semble excessif sauf si vous vous attendez à en avoir besoin partout. La méthode extensions pourrait être modifiée pour étendre spécifiquement l'objet Session afin qu'il dispose d'une option get "sûre" comme Session.StringIfNull ("SessionVar") et Session ["SessionVar"] = "myval"; Il rompt la simplicité d'accès à la variable via Session ["SessionVar"], mais il s'agit d'un code vierge qui permet néanmoins de valider si null ou si string si vous en avez besoin.
J'aime aussi envelopper les variables de session dans les propriétés. Les setters ici sont triviaux, mais j'aime bien écrire les méthodes get afin qu'ils n'aient qu'un seul point de sortie. Pour ce faire, je vérifie généralement la valeur null et la définit comme valeur par défaut avant de renvoyer la valeur de la variable de session. Quelque chose comme ça:
string Name
{
get
{
if(Session["Name"] == Null)
Session["Name"] = "Default value";
return (string)Session["Name"];
}
set { Session["Name"] = value; }
}
}
Cette méthode ne suppose pas non plus que l'objet de la variable Session est une chaîne.
if((Session["MySessionVariable"] ?? "").ToString() != "")
//More code for the Code God
Donc, fondamentalement, remplace la variable null par une chaîne vide avant de la convertir en chaîne car ToString fait partie de la classe Object
En règle générale, je crée SessionProxy avec des propriétés fortement typées pour les éléments de la session. Le code qui accède à ces propriétés vérifie la nullité et effectue le transtypage selon le type approprié. La bonne chose à ce sujet est que tous les éléments liés à ma session sont conservés au même endroit. Je n'ai pas à craindre d'utiliser différentes clés dans différentes parties du code (et à me demander pourquoi cela ne fonctionne pas). Et avec l'injection de dépendance et moqueur, je peux le tester complètement avec des tests unitaires. Si suit les principes DRY et me permet également de définir des valeurs par défaut raisonnables.
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; }
}
}
Vérifier pour rien/Null est le moyen de le faire.
Traiter avec des types d'objet n'est pas la solution. Déclarez un type strict et essayez de convertir l'objet en un type correct. (Et utilisez l'indice de conversion ou Convert)
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;
}
Désolé pour les violations de syntaxe, je suis un quotidien VB'er
Utilisez-vous .NET 3.5? Créez une méthode d'extension IsNull:
public static bool IsNull(this object input)
{
input == null ? return true : return false;
}
public void Main()
{
object x = new object();
if(x.IsNull)
{
//do your thing
}
}
Si vous savez que c'est une chaîne, vous pouvez utiliser la fonction String.IsEmptyOrNull ().
de cette manière, il est possible de vérifier si une telle clé est disponible
if (Session.Dictionary.ContainsKey("Sessionkey")) --> return Bool