Qual è il modo corretto per verificare la presenza di valori nulli?

Adoro l'operatore di coalescenza null perché semplifica l'assegnazione di un valore predefinito per i tipi nullable.

 int y = x ?? -1;

È fantastico, tranne se devo fare qualcosa di semplice con x. Ad esempio, se voglio controllare Session, di solito finisco per dover scrivere qualcosa di più dettagliato.

Vorrei poterlo fare:

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

Ma non puoi perché .ToString()viene chiamato prima del controllo null, quindi non riesce se Session["key"]è null. Finisco per fare questo:

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

Funziona ed è migliore, secondo me, dell'alternativa a tre righe:

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

Anche se funziona, sono ancora curioso di sapere se esiste un modo migliore. Non importa a cosa devo sempre fare riferimento Session["key"]due volte; una volta per il controllo e di nuovo per l'assegnazione. Qualche idea?

Che dire

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

Se lo fai spesso in modo specifico conToString() potresti scrivere un metodo di estensione:

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

...

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

O un metodo che assume un valore predefinito, ovviamente:

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

...

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

Puoi anche usare as, che restituisce nullse la conversione fallisce:

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

Questo sarebbe tornato "none"anche se qualcuno farcito una intin Session["key"].

Se sarà sempre a string, puoi trasmettere :

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

Questo ha il vantaggio di lamentarsi invece di nascondere l'errore se qualcuno inserisce un into qualcosa Session["key"]. ;)

Tutte le soluzioni suggerite sono valide e rispondono alla domanda; quindi questo è solo per estenderlo leggermente. Attualmente la maggior parte delle risposte riguarda solo la convalida nulla e i tipi di stringa. È possibile estendere l' StateBagoggetto per includere un genericoGetValueOrDefault metodo , simile alla risposta pubblicata da Jon Skeet.

Un semplice metodo di estensione generico che accetta una stringa come chiave e quindi controlla il tipo dell'oggetto sessione. Se l'oggetto è null o non è dello stesso tipo, viene restituito il valore predefinito, altrimenti il ​​valore della sessione viene restituito fortemente tipizzato.

Qualcosa come questo

/// <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;
}

Usiamo un metodo chiamato NullOr .

uso

// 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());

fonte

/// <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();
    }
}

La mia preferenza, per uno, sarebbe quella di utilizzare un cast sicuro per stringere nel caso in cui l'oggetto memorizzato con la chiave non sia uno. L'utilizzo ToString()potrebbe non avere i risultati desiderati.

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

Come dice @ Jon Skeet, se ti ritrovi a farlo spesso come un metodo di estensione o, meglio, forse un metodo di estensione in combinazione con una classe SessionWrapper fortemente tipizzata. Anche senza il metodo di estensione, il wrapper fortemente tipizzato potrebbe essere una buona idea.

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 }
    }
}

Usato come

 var session = new SessionWrapper(Session);

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

creare una funzione ausiliaria

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


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

La risposta di Skeet è la migliore, in particolare penso che la sua ToStringOrNull()sia piuttosto elegante e si adatti meglio alle tue esigenze. Volevo aggiungere un'altra opzione all'elenco dei metodi di estensione:

Restituisce l'oggetto originale o il valore di stringa predefinito per 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");

Utilizzare varper il valore restituito poiché tornerà come tipo di input originale, solo come stringa predefinita quandonull

Questo è il mio piccolo "operatore Elvis" sicuro per le versioni di .NET che non supportano?.

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);
    }
}

Il primo argomento è l'oggetto testato. La seconda è la funzione. E il terzo è il valore nullo. Quindi per il tuo caso:

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

È molto utile anche per i tipi nullable. Per esempio:

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