Làm cách nào để kiểm tra giá trị rỗng trong quá tải toán tử '==' mà không cần đệ quy vô hạn?

Điều sau sẽ gây ra đệ quy vô hạn trên phương thức nạp chồng toán tử ==

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

Làm cách nào để kiểm tra giá trị rỗng?

Sử dụng 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);
}

Truyền tới đối tượng trong phương thức quá tải:

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

Sử dụng ReferenceEquals. Từ các diễn đàn 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;
}

Thử Object.ReferenceEquals(foo1, null)

Dù sao, tôi không khuyên bạn nên quá tải ==toán tử; nó nên được sử dụng để so sánh các tham chiếu và sử dụng Equalsđể so sánh "ngữ nghĩa".

Nếu tôi đã ghi đè bool Equals(object obj)và tôi muốn toán tử ==và Foo.Equals(object obj)trả về cùng một giá trị, tôi thường triển !=khai toán tử như sau:

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

==Sau khi thực hiện tất cả các kiểm tra null cho tôi, nhà điều hành sẽ kết thúc cuộc gọi foo1.Equals(foo2)rằng tôi đã ghi đè để thực hiện kiểm tra thực tế nếu cả hai bằng nhau.

Nếu bạn đang sử dụng C # 7 trở lên, bạn có thể sử dụng đối sánh mẫu hằng số null:

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

Điều này cung cấp cho bạn mã gọn gàng hơn một chút so với một đối tượng đang gọi .ReferenceEquals (foo1, null)

Thực ra có một cách đơn giản hơn để kiểm tra nulltrong trường hợp này:

if (foo is null)

Đó là nó!

Tính năng này đã được giới thiệu trong C # 7

Cách tiếp cận của tôi là làm

(object)item == null

mà tôi đang dựa vào objecttoán tử bình đẳng của riêng mình mà không thể sai. Hoặc phương thức tiện ích mở rộng tùy chỉnh (và quá tải):

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

hoặc để xử lý nhiều trường hợp hơn, có thể là:

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

Ràng buộc ngăn cản IsNullcác kiểu giá trị. Bây giờ nó ngọt ngào như đang gọi

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

có nghĩa là tôi có một phong cách nhất quán / không dễ xảy ra lỗi trong việc kiểm tra các giá trị rỗng trong suốt. Tôi cũng nhận thấy rằng (object)item == nullnó nhanh hơn rất nhiều so với một chútObject.ReferenceEquals(item, null) , nhưng chỉ khi nó quan trọng (tôi hiện đang làm việc trên một cái gì đó mà tôi đã tối ưu hóa mọi thứ!).

Để xem hướng dẫn đầy đủ về cách thực hiện kiểm tra bằng nhau, hãy xem "Phương pháp hay nhất" để so sánh hai trường hợp của một loại tham chiếu là gì?

Equals(Object, Object)Phương thức static cho biết liệu hai đối tượng objAvà objB, có bằng nhau hay không. Nó cũng cho phép bạn kiểm tra các đối tượng có giá trị nullbằng nhau. Nó so sánh objAvà objBbình đẳng như sau:

• Nó xác định xem hai đối tượng có đại diện cho cùng một tham chiếu đối tượng hay không. Nếu đúng như vậy, phương thức sẽ trả về true. Kiểm tra này tương đương với việc gọi ReferenceEqualsphương thức. Ngoài ra, nếu cả hai objAvà objBđều null, phương thức trả về true.
• Nó xác định xem objAhoặc objBlà null. Nếu vậy, nó trả về false. Nếu hai đối tượng không đại diện cho cùng một tham chiếu đối tượng và cũng vậy null, nó sẽ gọi objA.Equals(objB)và trả về kết quả. Điều này có nghĩa là nếu objAghi đè Object.Equals(Object)phương thức, ghi đè này được gọi.

.

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

trả lời thêm cho toán tử ghi đè cách so sánh với null chuyển hướng đến đây như một bản sao.

Trong trường hợp điều này đang được thực hiện để hỗ trợ Đối tượng Giá trị, tôi thấy ký hiệu mới rất tiện dụng và muốn đảm bảo rằng chỉ có một nơi duy nhất để so sánh được thực hiện. Cũng tận dụng Object.Equals (A, B) đơn giản hóa việc kiểm tra null.

Điều này sẽ làm quá tải ==,! =, Equals và 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();

Đối với các đối tượng phức tạp hơn, hãy thêm các so sánh bổ sung trong Equals và GetHashCode phong phú hơn.

Để có một cú pháp hiện đại và cô đọng:

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

Một lỗi phổ biến trong quá tải toán tử == là sử dụng (a == b), (a ==null)hoặc (b == null)để kiểm tra bình đẳng tham khảo. Thay vào đó, điều này dẫn đến cuộc gọi đến toán tử quá tải ==, gây ra infinite loop. Sử dụng ReferenceEqualshoặc ép kiểu thành Đối tượng, để tránh vòng lặp.

kiểm tra cái này

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

tham khảo Hướng dẫn về Nạp chồng bằng () và toán tử ==

Bạn có thể thử sử dụng một thuộc tính đối tượng và bắt NullReferenceException kết quả. Nếu thuộc tính bạn cố gắng được kế thừa hoặc ghi đè từ Đối tượng, thì điều này sẽ hoạt động cho bất kỳ lớp nào.

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