Apa cara yang tepat untuk memeriksa nilai null?

Saya suka operator penggabungan nol karena membuatnya mudah untuk menetapkan nilai default untuk tipe nullable.

 int y = x ?? -1;

Itu bagus, kecuali jika saya perlu melakukan sesuatu yang sederhana x. Misalnya, jika saya ingin memeriksa Session, biasanya saya harus menulis sesuatu yang lebih bertele-tele.

Saya berharap saya bisa melakukan ini:

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

Tetapi Anda tidak bisa karena .ToString()dipanggil sebelum pemeriksaan null sehingga gagal jika Session["key"]null. Saya akhirnya melakukan ini:

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

Ini berfungsi dan lebih baik, menurut saya, daripada alternatif tiga baris:

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

Meskipun itu berhasil, saya masih penasaran apakah ada cara yang lebih baik. Sepertinya tidak peduli apa yang selalu saya rujuk Session["key"]dua kali; sekali untuk cek, dan sekali lagi untuk tugas. Ada ide?

Bagaimana dengan

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

Jika Anda sering melakukan ini secara khusus,ToString() Anda dapat menulis metode ekstensi:

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

...

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

Atau metode yang mengambil default, tentu saja:

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

...

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

Anda juga bisa menggunakan as, yang menghasilkan nulljika konversi gagal:

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

Ini akan kembali "none"bahkan jika seseorang boneka sebuah intdi Session["key"].

Jika akan selalu menjadi string, Anda dapat mentransmisikan:

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

Ini memiliki keuntungan dari mengeluh daripada menyembunyikan kesalahan jika seseorang memasukkan intatau sesuatu Session["key"]. ;)

Semua solusi yang disarankan bagus, dan jawab pertanyaannya; jadi ini hanya untuk memperpanjangnya sedikit. Saat ini mayoritas jawaban hanya berurusan dengan validasi null dan tipe string. Anda dapat memperluas StateBagobjek untuk menyertakan GetValueOrDefaultmetode umum , mirip dengan jawaban yang diposting oleh Jon Skeet.

Metode ekstensi generik sederhana yang menerima string sebagai kunci, lalu ketik memeriksa objek sesi. Jika objek null atau bukan jenis yang sama, default dikembalikan, jika nilai sesi dikembalikan sangat diketik.

Sesuatu seperti ini

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

Kami menggunakan metode yang disebut NullOr.

Pemakaian

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

Sumber

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

Preferensi saya, untuk yang satu ini, akan menggunakan cast yang aman ke string jika objek yang disimpan dengan kunci bukan satu. Menggunakan ToString()mungkin tidak memberikan hasil yang Anda inginkan.

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

Seperti yang dikatakan @Jon Skeet, jika Anda sering melakukan ini sebagai metode ekstensi atau, lebih baik, namun mungkin metode ekstensi dalam hubungannya dengan kelas SessionWrapper yang diketik dengan kuat. Bahkan tanpa metode ekstensi, pembungkus yang diketik dengan kuat mungkin merupakan ide yang bagus.

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

Digunakan sebagai

 var session = new SessionWrapper(Session);

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

membuat fungsi tambahan

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


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

Jawaban Skeet adalah yang terbaik - khususnya menurut saya jawabannya ToStringOrNull()cukup elegan dan paling sesuai dengan kebutuhan Anda. Saya ingin menambahkan satu opsi lagi ke daftar metode ekstensi:

Kembalikan objek asli atau nilai string default untuk 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");

Gunakan varuntuk nilai yang dikembalikan karena akan kembali sebagai tipe masukan asli, hanya sebagai string default ketikanull

Ini adalah "operator Elvis" tipe kecil saya yang aman untuk versi .NET yang tidak mendukung?.

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

Argumen pertama adalah objek yang diuji. Kedua adalah fungsinya. Dan ketiga adalah nilai nol. Jadi untuk kasus Anda:

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

Ini juga sangat berguna untuk tipe nullable. Sebagai contoh:

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