Quelle est la bonne façon de vérifier les valeurs nulles?

J'adore l'opérateur null-coalescing car il facilite l'attribution d'une valeur par défaut pour les types Nullable.

 int y = x ?? -1;

C'est génial, sauf si j'ai besoin de faire quelque chose de simple avec x. Par exemple, si je veux vérifier Session, je finis généralement par devoir écrire quelque chose de plus détaillé.

J'aimerais pouvoir faire ceci:

string y = Session["key"].ToString() ?? "none";

Mais vous ne pouvez pas car le .ToString()est appelé avant la vérification de null, donc il échoue s'il Session["key"]est nul. Je finis par faire ceci:

string y = Session["key"] == null ? "none" : Session["key"].ToString();

Cela fonctionne et c'est mieux, à mon avis, que l'alternative à trois lignes:

string y = "none";
if (Session["key"] != null)
    y = Session["key"].ToString();

Même si cela fonctionne, je suis toujours curieux de savoir s'il existe un meilleur moyen. Il semble que peu importe ce que je dois toujours mentionner Session["key"]deux fois; une fois pour le chèque, et encore une fois pour la mission. Des idées?

Qu'en est-il de

string y = (Session["key"] ?? "none").ToString();

Si vous faites souvent cela spécifiquement avec,ToString() vous pouvez écrire une méthode d'extension:

public static string NullPreservingToString(this object input)
{
    return input == null ? null : input.ToString();
}

...

string y = Session["key"].NullPreservingToString() ?? "none";

Ou une méthode prenant un défaut, bien sûr:

public static string ToStringOrDefault(this object input, string defaultValue)
{
    return input == null ? defaultValue : input.ToString();
}

...

string y = Session["key"].ToStringOrDefault("none");

Vous pouvez également utiliser as, qui donne nullsi la conversion échoue:

Session["key"] as string ?? "none"

Cela reviendrait "none"même si quelqu'un bourrait unint dans Session["key"].

Si ce sera toujours un string, vous pouvez lancer:

string y = (string)Session["key"] ?? "none";

Cela a l'avantage de se plaindre au lieu de cacher l'erreur si quelqu'un fourre un intou quelque chose Session["key"]. ;)

Toutes les solutions suggérées sont bonnes et répondent à la question; donc c'est juste pour étendre légèrement dessus. Actuellement, la majorité des réponses ne concernent que la validation nulle et les types de chaîne. Vous pouvez étendre l' StateBagobjet pour inclure une GetValueOrDefaultméthode générique , similaire à la réponse publiée par Jon Skeet.

Une méthode d'extension générique simple qui accepte une chaîne comme clé, puis vérifie le type de l'objet de session. Si l'objet est nul ou n'est pas du même type, la valeur par défaut est renvoyée, sinon la valeur de session est renvoyée fortement typée.

Quelque chose comme ça

/// <summary>
/// Gets a value from the current session, if the type is correct and present
/// </summary>
/// <param name="key">The session key</param>
/// <param name="defaultValue">The default value</param>
/// <returns>Returns a strongly typed session object, or default value</returns>
public static T GetValueOrDefault<T>(this HttpSessionState source, string key, T defaultValue)
{
    // check if the session object exists, and is of the correct type
    object value = source[key]
    if (value == null || !(value is T))
    {
        return defaultValue;
    }

    // return the session object
    return (T)value;
}

Nous utilisons une méthode appelée NullOr .

Usage

// Call ToString() if it’s not null, otherwise return null
var str = myObj.NullOr(obj => obj.ToString());

// Supply default value for when it’s null
var str = myObj.NullOr(obj => obj.ToString()) ?? "none";

// Works with nullable return values, too —
// this is properly typed as “int?” (nullable int)
// even if “Count” is just int
var count = myCollection.NullOr(coll => coll.Count);

// Works with nullable input types, too
int? unsure = 47;
var sure = unsure.NullOr(i => i.ToString());

La source

/// <summary>Provides a function delegate that accepts only value types as return types.</summary>
/// <remarks>This type was introduced to make <see cref="ObjectExtensions.NullOr{TInput,TResult}(TInput,FuncStruct{TInput,TResult})"/>
/// work without clashing with <see cref="ObjectExtensions.NullOr{TInput,TResult}(TInput,FuncClass{TInput,TResult})"/>.</remarks>
public delegate TResult FuncStruct<in TInput, TResult>(TInput input) where TResult : struct;

/// <summary>Provides a function delegate that accepts only reference types as return types.</summary>
/// <remarks>This type was introduced to make <see cref="ObjectExtensions.NullOr{TInput,TResult}(TInput,FuncClass{TInput,TResult})"/>
/// work without clashing with <see cref="ObjectExtensions.NullOr{TInput,TResult}(TInput,FuncStruct{TInput,TResult})"/>.</remarks>
public delegate TResult FuncClass<in TInput, TResult>(TInput input) where TResult : class;

/// <summary>Provides extension methods that apply to all types.</summary>
public static class ObjectExtensions
{
    /// <summary>Returns null if the input is null, otherwise the result of the specified lambda when applied to the input.</summary>
    /// <typeparam name="TInput">Type of the input value.</typeparam>
    /// <typeparam name="TResult">Type of the result from the lambda.</typeparam>
    /// <param name="input">Input value to check for null.</param>
    /// <param name="lambda">Function to apply the input value to if it is not null.</param>
    public static TResult NullOr<TInput, TResult>(this TInput input, FuncClass<TInput, TResult> lambda) where TResult : class
    {
        return input == null ? null : lambda(input);
    }

    /// <summary>Returns null if the input is null, otherwise the result of the specified lambda when applied to the input.</summary>
    /// <typeparam name="TInput">Type of the input value.</typeparam>
    /// <typeparam name="TResult">Type of the result from the lambda.</typeparam>
    /// <param name="input">Input value to check for null.</param>
    /// <param name="lambda">Function to apply the input value to if it is not null.</param>
    public static TResult? NullOr<TInput, TResult>(this TInput input, Func<TInput, TResult?> lambda) where TResult : struct
    {
        return input == null ? null : lambda(input);
    }

    /// <summary>Returns null if the input is null, otherwise the result of the specified lambda when applied to the input.</summary>
    /// <typeparam name="TInput">Type of the input value.</typeparam>
    /// <typeparam name="TResult">Type of the result from the lambda.</typeparam>
    /// <param name="input">Input value to check for null.</param>
    /// <param name="lambda">Function to apply the input value to if it is not null.</param>
    public static TResult? NullOr<TInput, TResult>(this TInput input, FuncStruct<TInput, TResult> lambda) where TResult : struct
    {
        return input == null ? null : lambda(input).Nullable();
    }
}

Ma préférence, pour un one off, serait d'utiliser un cast sécurisé en chaîne au cas où l'objet stocké avec la clé n'en serait pas un. L'utilisation ToString()peut ne pas avoir les résultats souhaités.

var y = Session["key"] as string ?? "none";

Comme le dit @Jon Skeet, si vous vous trouvez souvent en train de faire cela, une méthode d'extension ou, mieux, peut-être une méthode d'extension en conjonction avec une classe SessionWrapper fortement typée. Même sans la méthode d'extension, le wrapper fortement typé peut être une bonne idée.

public class SessionWrapper
{
    private HttpSessionBase Session { get; set; }

    public SessionWrapper( HttpSessionBase session )
    {
        Session = session;
    }

    public SessionWrapper() : this( HttpContext.Current.Session ) { }

    public string Key
    {
         get { return Session["key"] as string ?? "none";
    }

    public int MaxAllowed
    {
         get { return Session["maxAllowed"] as int? ?? 10 }
    }
}

Utilisé comme

 var session = new SessionWrapper(Session);

 string key = session.Key;
 int maxAllowed = session.maxAllowed;

créer une fonction auxiliaire

public static String GetValue( string key, string default )
{
    if ( Session[ key ] == null ) { return default; }
    return Session[ key ].toString();
}


string y = GetValue( 'key', 'none' );

La réponse de Skeet est la meilleure - en particulier, je pense que la sienne ToStringOrNull()est assez élégante et répond le mieux à vos besoins. Je voulais ajouter une autre option à la liste des méthodes d'extension:

Renvoie l'objet d'origine ou la valeur de chaîne par défaut pour null :

// Method:
public static object OrNullAsString(this object input, string defaultValue)
{
    if (defaultValue == null)
        throw new ArgumentNullException("defaultValue");
    return input == null ? defaultValue : input;
}

// Example:
var y = Session["key"].OrNullAsString("defaultValue");

À utiliser varpour la valeur renvoyée car elle reviendra comme type d'entrée d'origine, uniquement comme chaîne par défaut lorsquenull

Ceci est mon petit "opérateur Elvis" de type sécurisé pour les versions de .NET qui ne prennent pas en charge?.

public class IsNull
{
    public static O Substitute<I,O>(I obj, Func<I,O> fn, O nullValue=default(O))
    {
        if (obj == null)
            return nullValue;
        else
            return fn(obj);
    }
}

Le premier argument est l'objet testé. La deuxième est la fonction. Et le troisième est la valeur nulle. Donc pour votre cas:

IsNull.Substitute(Session["key"],s=>s.ToString(),"none");

Il est également très utile pour les types Nullable. Par exemple:

decimal? v;
...
IsNull.Substitute(v,v.Value,0);
....