Bagaimana cara memeriksa null di operator '==' yang kelebihan beban tanpa rekursi tak terbatas?

Berikut ini akan menyebabkan rekursi tak terbatas pada == metode kelebihan beban operator

    Foo foo1 = null;
    Foo foo2 = new Foo();
    Assert.IsFalse(foo1 == foo2);

    public static bool operator ==(Foo foo1, Foo foo2) {
        if (foo1 == null) return foo2 == null;
        return foo1.Equals(foo2);
    }

Bagaimana cara memeriksa nulls?

Penggunaan ReferenceEquals:

Foo foo1 = null;
Foo foo2 = new Foo();
Assert.IsFalse(foo1 == foo2);

public static bool operator ==(Foo foo1, Foo foo2) {
    if (object.ReferenceEquals(null, foo1))
        return object.ReferenceEquals(null, foo2);
    return foo1.Equals(foo2);
}

Transmisikan ke objek dalam metode kelebihan beban:

public static bool operator ==(Foo foo1, Foo foo2) {
    if ((object) foo1 == null) return (object) foo2 == null;
    return foo1.Equals(foo2);
}

Gunakan ReferenceEquals. Dari forum MSDN :

public static bool operator ==(Foo foo1, Foo foo2) {
    if (ReferenceEquals(foo1, null)) return ReferenceEquals(foo2, null);
    if (ReferenceEquals(foo2, null)) return false;
    return foo1.field1 == foo2.field2;
}

Mencoba Object.ReferenceEquals(foo1, null)

Bagaimanapun, saya tidak akan merekomendasikan membebani ==operator secara berlebihan ; itu harus digunakan untuk membandingkan referensi, dan digunakan Equalsuntuk perbandingan "semantik".

Jika saya telah mengganti bool Equals(object obj)dan saya ingin operator ==dan Foo.Equals(object obj)mengembalikan nilai yang sama, saya biasanya menerapkan !=operator seperti ini:

public static bool operator ==(Foo foo1, Foo foo2) {
  return object.Equals(foo1, foo2);
}
public static bool operator !=(Foo foo1, Foo foo2) {
  return !object.Equals(foo1, foo2);
}

Operator ==kemudian akan setelah melakukan semua pemeriksaan nol untuk saya akhirnya memanggil foo1.Equals(foo2)bahwa saya telah diganti untuk melakukan pemeriksaan sebenarnya jika keduanya sama.

Jika Anda menggunakan C # 7 atau yang lebih baru, Anda dapat menggunakan pencocokan pola konstan nol:

public static bool operator==(Foo foo1, Foo foo2)
{
    if (foo1 is null)
        return foo2 is null;
    return foo1.Equals(foo2);
}

Ini memberi Anda kode yang sedikit lebih rapi daripada yang memanggil objek .ReferenceEquals (foo1, null)

Sebenarnya ada cara yang lebih sederhana untuk memeriksa nulldalam kasus ini:

if (foo is null)

Itu dia!

Fitur ini diperkenalkan di C # 7

Pendekatan saya adalah melakukan

(object)item == null

di mana saya mengandalkan objectoperator kesetaraan sendiri yang tidak bisa salah. Atau metode ekstensi khusus (dan kelebihan beban):

public static bool IsNull<T>(this T obj) where T : class
{
    return (object)obj == null;
}

public static bool IsNull<T>(this T? obj) where T : struct
{
    return !obj.HasValue;
}

atau untuk menangani lebih banyak kasus, mungkin:

public static bool IsNull<T>(this T obj) where T : class
{
    return (object)obj == null || obj == DBNull.Value;
}

Batasan mencegah IsNull jenis nilai. Sekarang semanis menelepon

object obj = new object();
Guid? guid = null; 
bool b = obj.IsNull(); // false
b = guid.IsNull(); // true
2.IsNull(); // error

yang berarti saya memiliki satu gaya konsisten / tidak-rawan kesalahan dalam memeriksa nulls di seluruh. Saya juga telah menemukan(object)item == null sangat sangat sangat sedikit lebih cepat daripadaObject.ReferenceEquals(item, null) , tetapi hanya jika itu penting (saya saat ini sedang mengerjakan sesuatu di mana saya telah mengoptimalkan mikro semuanya!).

Untuk melihat panduan lengkap tentang penerapan pemeriksaan kesetaraan, lihat Apa itu "Praktik Terbaik" Untuk Membandingkan Dua Contoh dari Jenis Referensi?

Equals(Object, Object)Metode statis menunjukkan apakah dua objek, objAdan objB, sama. Ini juga memungkinkan Anda untuk menguji objek yang nilainya nulluntuk persamaan. Ini membandingkan objAdan objBuntuk kesetaraan sebagai berikut:

• Ini menentukan apakah dua objek mewakili referensi objek yang sama. Jika ya, metode tersebut akan kembali true. Tes ini setara dengan memanggil ReferenceEqualsmetode. Selain itu, jika keduanya objAdan objBadalah null, metode akan kembali true.
• Ini menentukan apakah salah satu objAatau objBitu null. Jika demikian, itu kembali false. Jika dua objek tidak mewakili referensi objek yang sama dan tidak juga null, itu akan memanggil objA.Equals(objB)dan mengembalikan hasilnya. Artinya jika objAmenimpa Object.Equals(Object)metode, penggantian ini dipanggil.

.

public static bool operator ==(Foo objA, Foo objB) {
    return Object.Equals(objA, objB);
}

membalas lebih ke operator utama bagaimana membandingkan dengan null yang mengalihkan ke sini sebagai duplikat.

Dalam kasus di mana ini dilakukan untuk mendukung Objek Nilai, saya menemukan notasi baru berguna, dan ingin memastikan hanya ada satu tempat di mana perbandingan dibuat. Juga memanfaatkan Object.Equals (A, B) menyederhanakan pemeriksaan null.

Ini akan membebani ==,! =, Equals, dan GetHashCode

    public static bool operator !=(ValueObject self, ValueObject other) => !Equals(self, other);
    public static bool operator ==(ValueObject self, ValueObject other) => Equals(self, other);
    public override bool Equals(object other) => Equals(other as ValueObject );
    public bool Equals(ValueObject other) {
        return !(other is null) && 
               // Value comparisons
               _value == other._value;
    }
    public override int GetHashCode() => _value.GetHashCode();

Untuk objek yang lebih rumit, tambahkan perbandingan tambahan di Equals dan GetHashCode yang lebih kaya.

Untuk sintaksis modern dan ringkas:

public static bool operator ==(Foo x, Foo y)
{
    return x is null ? y is null : x.Equals(y);
}

public static bool operator !=(Foo x, Foo y)
{
    return x is null ? !(y is null) : !x.Equals(y);
}

Sebuah kesalahan umum dalam overloads operator == adalah dengan menggunakan (a == b), (a ==null)atau (b == null)untuk memeriksa kesetaraan referensi. Ini malah menghasilkan panggilan ke operator yang kelebihan beban ==, menyebabkan infinite loop. Gunakan ReferenceEqualsatau transmisikan tipe ke Object, untuk menghindari pengulangan.

Lihat ini

// If both are null, or both are same instance, return true.
if (System.Object.ReferenceEquals(a, b))// using ReferenceEquals
{
    return true;
}

// If one is null, but not both, return false.
if (((object)a == null) || ((object)b == null))// using casting the type to Object
{
    return false;
}

referensi Panduan untuk Overloading Sama () dan Operator ==

Anda dapat mencoba menggunakan properti objek dan menangkap NullReferenceException yang dihasilkan. Jika properti yang Anda coba diwarisi atau diganti dari Object, maka ini berfungsi untuk semua kelas.

public static bool operator ==(Foo foo1, Foo foo2)
{
    //  check if the left parameter is null
    bool LeftNull = false;
    try { Type temp = a_left.GetType(); }
    catch { LeftNull = true; }

    //  check if the right parameter is null
    bool RightNull = false;
    try { Type temp = a_right.GetType(); }
    catch { RightNull = true; }

    //  null checking results
    if (LeftNull && RightNull) return true;
    else if (LeftNull || RightNull) return false;
    else return foo1.field1 == foo2.field2;
}