ฉันจะตรวจสอบ null ในโอเวอร์โหลดตัวดำเนินการ '==' โดยไม่มีการเรียกซ้ำแบบไม่สิ้นสุดได้อย่างไร

สิ่งต่อไปนี้จะทำให้เกิดการเรียกซ้ำแบบไม่สิ้นสุดในวิธีการโอเวอร์โหลดตัวดำเนินการ ==

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

ฉันจะตรวจสอบค่าว่างได้อย่างไร

ใช้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);
}

ส่งไปยังวัตถุในวิธีโอเวอร์โหลด:

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

ใช้ReferenceEquals. จากฟอรัม 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;
}

ลอง Object.ReferenceEquals(foo1, null)

อย่างไรก็ตามฉันไม่แนะนำให้ใช้ตัว==ดำเนินการมากเกินไป ควรใช้เพื่อเปรียบเทียบการอ้างอิงและใช้Equalsสำหรับการเปรียบเทียบแบบ "ความหมาย"

หากฉันได้ลบล้างbool Equals(object obj)และฉันต้องการตัวดำเนินการ==และFoo.Equals(object obj)ส่งคืนค่าเดียวกันฉันมักจะใช้ตัว!=ดำเนินการดังนี้:

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

==หลังจากนั้นโอเปอเรเตอร์จะทำการตรวจสอบค่าว่างทั้งหมดให้ฉันจบลงด้วยการเรียกfoo1.Equals(foo2)ว่าฉันได้ลบล้างเพื่อทำการตรวจสอบจริงว่าทั้งสองเท่ากันหรือไม่

หากคุณใช้ C # 7 หรือใหม่กว่าคุณสามารถใช้การจับคู่รูปแบบคงที่ว่างได้:

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

สิ่งนี้ให้รหัสที่ใกล้เคียงกับวัตถุที่เรียกใช้เล็กน้อย ReferenceEquals (foo1, null)

มีวิธีตรวจสอบที่ง่ายกว่าnullในกรณีนี้:

if (foo is null)

แค่นั้นแหละ!

คุณลักษณะนี้ได้รับการแนะนำใน C # 7

แนวทางของฉันคือการทำ

(object)item == null

ซึ่งฉันอาศัยobjectตัวดำเนินการความเท่าเทียมกันของตัวเองซึ่งไม่สามารถผิดพลาดได้ หรือวิธีการขยายที่กำหนดเอง (และการโอเวอร์โหลด):

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

หรือเพื่อจัดการกรณีอื่น ๆ อาจเป็น:

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

ข้อ จำกัด ป้องกันIsNullประเภทค่า ตอนนี้มันหวานเหมือนการโทร

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

ซึ่งหมายความว่าฉันมีรูปแบบการตรวจสอบค่า null ที่สอดคล้อง / ไม่ผิดพลาดตลอด ฉันพบว่า(object)item == nullเร็วกว่าเล็กน้อยมากObject.ReferenceEquals(item, null)แต่เฉพาะในกรณีที่มีความสำคัญ (ฉันกำลังดำเนินการบางอย่างที่ฉันจะเพิ่มประสิทธิภาพทุกอย่างในระดับไมโคร!)

หากต้องการดูคำแนะนำฉบับสมบูรณ์เกี่ยวกับการใช้การตรวจสอบความเท่าเทียมกันโปรดดู"แนวทางปฏิบัติที่ดีที่สุด" สำหรับการเปรียบเทียบสองอินสแตนซ์ของประเภทการอ้างอิงคืออะไร

Equals(Object, Object)วิธีการคงที่ระบุว่าวัตถุสองชิ้นobjAและobjBมีค่าเท่ากันหรือไม่ นอกจากนี้ยังช่วยให้คุณทดสอบวัตถุที่มีค่าnullเพื่อความเท่าเทียมกัน เปรียบเทียบobjAและobjBเพื่อความเท่าเทียมกันดังนี้:

• กำหนดว่าวัตถุทั้งสองเป็นตัวแทนของการอ้างอิงวัตถุเดียวกันหรือไม่ หากเป็นเช่นนั้นวิธีการจะกลับtrueมา การทดสอบนี้เทียบเท่ากับการเรียกใช้ReferenceEqualsเมธอด นอกจากนี้ถ้าทั้งสองobjAและobjBเป็นnullวิธีการจะคืนค่าtrueวิธีการส่งกลับ
• จะเป็นตัวกำหนดว่าอย่างใดอย่างหนึ่งobjAหรือเป็นobjB nullถ้าเป็นเช่นนั้นมันจะกลับfalseมา หากวัตถุทั้งสองไม่ได้แสดงถึงการอ้างอิงอ็อบเจ็กต์เดียวกันและไม่เป็นnullเหมือนกันมันจะเรียกobjA.Equals(objB)และส่งคืนผลลัพธ์ ซึ่งหมายความว่าถ้าobjAแทนที่Object.Equals(Object)เมธอดการลบล้างนี้จะถูกเรียกว่า

.

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

การตอบกลับเพิ่มเติมเกี่ยวกับการแทนที่โอเปอเรเตอร์วิธีเปรียบเทียบกับ nullที่เปลี่ยนเส้นทางที่นี่ว่าซ้ำกัน

ในกรณีที่ทำสิ่งนี้เพื่อรองรับ Value Objects ฉันพบว่าสัญกรณ์ใหม่มีประโยชน์และต้องการให้แน่ใจว่ามีเพียงที่เดียวที่ทำการเปรียบเทียบ นอกจากนี้ยังใช้ประโยชน์จาก Object.Equals (A, B) ทำให้การตรวจสอบ null ง่ายขึ้น

สิ่งนี้จะเกิน ==,! =, เท่ากับและ 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();

สำหรับวัตถุที่ซับซ้อนมากขึ้นให้เพิ่มการเปรียบเทียบเพิ่มเติมใน Equals และ GetHashCode ที่สมบูรณ์ยิ่งขึ้น

สำหรับไวยากรณ์ที่ทันสมัยและย่อ:

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

ข้อผิดพลาดที่พบบ่อยในทับถมของผู้ประกอบการ == คือการใช้(a == b), (a ==null)หรือ(b == null)การตรวจสอบเพื่อความเท่าเทียมกันการอ้างอิง สิ่งนี้ ส่งผลให้เกิดการเรียกใช้ตัวดำเนินการมากเกินไป == ทำให้เกิดinfinite loopไฟล์. ใช้ReferenceEqualsหรือส่งประเภทเป็น Object เพื่อหลีกเลี่ยงการวนซ้ำ

ตรวจสอบสิ่งนี้

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

อ้างอิง แนวทางสำหรับการโอเวอร์โหลดเท่ากับ () และตัวดำเนินการ ==

คุณสามารถลองใช้คุณสมบัติอ็อบเจ็กต์และจับผลลัพธ์ NullReferenceException หากคุณสมบัติที่คุณพยายามสืบทอดหรือแทนที่จาก Object สิ่งนี้ใช้ได้กับคลาสใด ๆ

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