Apa perbedaan antara “x is null” dan “x == null”?

Di C # 7 kita bisa menggunakan

if (x is null) return;

dari pada

if (x == null) return;

Apakah ada keuntungan menggunakan cara baru (contoh sebelumnya) dibandingkan cara lama?

Apakah semantiknya berbeda?

Apakah hanya masalah selera? Jika tidak, kapan saya harus menggunakan yang satu?

Referensi: Apa yang Baru di C # 7.0 .

Pembaruan: Kompilator Roslyn telah diperbarui untuk membuat perilaku kedua operator sama ketika tidak ada operator kesetaraan yang kelebihan beban . Silakan lihat kode dalam hasil kompiler saat ini ( M1dan M2dalam kode) yang menunjukkan apa yang terjadi ketika tidak ada pembanding kesetaraan kelebihan beban. Mereka berdua sekarang memiliki ==perilaku yang lebih baik . Jika ada pembanding kesetaraan kelebihan beban, kode masih berbeda .

Lihat untuk versi yang lebih lama dari kompiler Roslyn analisis di bawah ini.

Karena nulltidak ada perbedaan dengan apa yang biasa kita gunakan dengan C # 6. Namun, hal-hal menjadi menarik ketika Anda berubah nullke konstanta lain.

Ambil ini sebagai contoh:

Test(1);

public void Test(object o)
{
    if (o is 1) Console.WriteLine("a");
    else Console.WriteLine("b");
}

Tes menghasilkan a. Jika Anda membandingkannya dengan o == (object)1apa yang Anda tulis secara normal, itu membuat perbedaan besar. ismempertimbangkan jenis di sisi lain perbandingan. Itu keren!

Saya pikir pola == nullvs is nullkonstan adalah sesuatu yang sangat akrab dengan 'kebetulan', di mana sintaksis isoperator dan operator sederajat menghasilkan hasil yang sama.

Seperti svick berkomentar, is nullpanggilan System.Object::Equals(object, object)tempat ==panggilanceq .

IL untuk is:

IL_0000: ldarg.1              // Load argument 1 onto the stack
IL_0001: ldnull               // Push a null reference on the stack
IL_0002: call bool [mscorlib]System.Object::Equals(object, object) // Call method indicated on the stack with arguments
IL_0007: ret                  // Return from method, possibly with a value

IL untuk ==:

IL_0000: ldarg.1              // Load argument 1 onto the stack
IL_0001: ldnull               // Push a null reference on the stack
IL_0002: ceq                  // Push 1 (of type int32) if value1 equals value2, else push 0
IL_0004: ret                  // Return from method, possibly with a value

Karena kita berbicara tentang null, tidak ada perbedaan karena ini hanya membuat perbedaan pada instance . Ini bisa berubah ketika Anda telah kelebihan beban operator kesetaraan.

Kelebihan muatan sama dengan operator

Sebenarnya ada perbedaan dalam semantik antara dua perbandingan ketika Anda membandingkan nulldengan jenis yang telah membebani ==operator. foo is nullakan menggunakan perbandingan referensi langsung untuk menentukan hasilnya, sedangkan foo == nulltentu saja akan menjalankan ==operator yang kelebihan beban jika ada.

Dalam contoh ini saya telah memperkenalkan "bug" pada ==operator yang kelebihan beban , menyebabkannya selalu mengeluarkan pengecualian jika argumen kedua adalah null:

void Main()
{
    Foo foo = null;

    if (foo is null) Console.WriteLine("foo is null"); // This condition is met
    if (foo == null) Console.WriteLine("foo == null"); // This will throw an exception
}

public class Foo
{
    public static bool operator ==(Foo foo1, Foo foo2)
    {
        if (object.Equals(foo2, null)) throw new Exception("oops");
        return object.Equals(foo1, foo2);
    }

    // ...
}

Kode IL untuk foo is nullmenggunakan ceqinstruksi untuk melakukan perbandingan referensi langsung:

IL_0003:  ldloc.0     // foo
IL_0004:  ldnull      
IL_0005:  ceq

Kode IL untuk foo == nullmenggunakan panggilan ke operator yang kelebihan beban:

IL_0016:  ldloc.0     // foo
IL_0017:  ldnull      
IL_0018:  call        UserQuery+Foo.op_Equality

Jadi perbedaannya adalah, bahwa jika Anda menggunakan ==Anda berisiko menjalankan kode pengguna (yang berpotensi memiliki perilaku yang tidak terduga atau masalah kinerja).

Pembatasan obat generik

Menggunakan is nullkonstruk membatasi tipe ke tipe referensi. Kompiler memastikan hal ini, yang berarti Anda tidak dapat menggunakan is nulltipe nilai. Jika Anda memiliki metode generik, Anda tidak akan dapat menggunakan is nullkecuali tipe generik dibatasi menjadi tipe referensi.

bool IsNull<T>(T item) => item is null;                  // Compile error: CS0403
bool IsNull<T>(T item) => item == null;                  // Works
bool IsNull<T>(T item) where T : class => item is null;  // Works

Terima kasih kepada David Augusto Villa yang telah menunjukkan ini.