Jaki jest właściwy sposób sprawdzania wartości null?

Uwielbiam operator łączenia wartości null, ponieważ ułatwia przypisywanie wartości domyślnej dla typów dopuszczających wartość null.

 int y = x ?? -1;

To świetnie, z wyjątkiem sytuacji, gdy muszę zrobić coś prostego x. Na przykład, jeśli chcę to sprawdzić Session, zwykle muszę napisać coś bardziej szczegółowego.

Chciałbym móc to zrobić:

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

Ale nie możesz, ponieważ .ToString()zostaje wywołany przed sprawdzeniem zerowej wartości, więc kończy się niepowodzeniem, jeśli Session["key"]jest zerowy. W końcu robię to:

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

Działa i moim zdaniem jest lepsza niż trzywierszowa alternatywa:

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

Mimo że to działa, wciąż jestem ciekawy, czy istnieje lepszy sposób. Wydaje się, że nie ma znaczenia, do czego zawsze muszę się odwoływać Session["key"]dwukrotnie; raz do sprawdzenia i jeszcze raz do zadania. Jakieś pomysły?

Co powiesz na

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

Jeśli często robisz to specjalnie z,ToString() możesz napisać metodę rozszerzającą:

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

...

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

Lub oczywiście domyślna metoda:

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

...

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

Możesz także użyć as, co daje, nulljeśli konwersja się nie powiedzie:

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

To wróci "none"nawet jeśli ktoś nadziewane się intin Session["key"].

Jeśli zawsze będzie string, możesz przesyłać:

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

Ma to tę zaletę, że narzekają, zamiast ukrywać błąd, jeśli ktoś wbija intcoś lub coś w środku Session["key"]. ;)

Wszystkie sugerowane rozwiązania są dobre i odpowiedz na pytanie; więc to jest tylko nieznaczne wydłużenie. Obecnie większość odpowiedzi dotyczy tylko walidacji wartości null i typów ciągów. Możesz rozszerzyć StateBagobiekt, aby zawierał ogólny plikGetValueOrDefault metodę , podobną do odpowiedzi opublikowanej przez Jona Skeeta.

Prosta ogólna metoda rozszerzenia, która akceptuje ciąg jako klucz, a następnie typ sprawdza obiekt sesji. Jeśli obiekt ma wartość null lub nie jest tego samego typu, zwracana jest wartość domyślna, w przeciwnym razie zwracana jest wartość sesji o silnym typie.

Coś takiego

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

Używamy metody o nazwie NullOr.

Stosowanie

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

Źródło

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

Wolałbym jednorazowo użyć bezpiecznego rzutowania na łańcuch na wypadek, gdyby obiekt przechowywany z kluczem nie był jednym. Używanie ToString()może nie przynieść oczekiwanych rezultatów.

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

Jak mówi @Jon Skeet, jeśli często robisz to jako metoda rozszerzająca lub, jeszcze lepiej, może metoda rozszerzająca w połączeniu z silnie wpisaną klasą SessionWrapper. Nawet bez metody rozszerzającej opakowanie o jednoznacznie określonym typie może być dobrym pomysłem.

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

Użyty jako

 var session = new SessionWrapper(Session);

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

stworzyć funkcję pomocniczą

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


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

Odpowiedź Skeeta jest najlepsza - szczególnie uważam, że jego ToStringOrNull()jest dość elegancki i najlepiej pasuje do twoich potrzeb. Chciałem dodać jeszcze jedną opcję do listy metod rozszerzających:

Zwróć oryginalny obiekt lub domyślną wartość ciągu dla 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");

Użyj vardla zwróconej wartości, ponieważ wróci jako typ oryginalnego wejścia, tylko jako ciąg domyślny, kiedynull

To jest mój mały "operator Elvisa" bezpieczny dla typów dla wersji .NET, które nie obsługują?.

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

Pierwszym argumentem jest testowany obiekt. Druga to funkcja. A trzecia to wartość zerowa. Więc w twoim przypadku:

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

Jest to również bardzo przydatne w przypadku typów dopuszczających wartość null. Na przykład:

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