这是实现 Equals 和相等/不等运算符的良好/有效的习惯用法吗？

Question

我在正确执行此操作时遇到了一些问题，因此我想询问是否有人对这是否是为自定义不可变类实现 Equals 方法和相等/不等运算符的有效方法有任何反馈。我的程序非常频繁地调用这些运算符，因此我想确保它们正确无误。

class MyObj
{

    public static bool operator ==(MyObj a, MyObj b)
    {
        if (!object.ReferenceEquals(a, null))
            return a.Equals(b);
        else if (!object.ReferenceEquals(b, null))
            return b.Equals(a);
        else
            // both are null
            return true;
    }

    public static bool operator !=(MyObj a, MyObj b)
    {
        if (!object.ReferenceEquals(a, null))
            return !a.Equals(b);
        else if (!object.ReferenceEquals(b, null))
            return !b.Equals(a);
        else
            // both are null
            return false
    }

    public override bool Equals(object obj)
    {
        return this.Equals(obj as MyObj);
    }

    public bool Equals(MyObj obj)
    {
        if (object.ReferenceEquals(obj, null))
            return false;
        else
            return (obj.FieldOne == this.FieldOne &&
                    obj.FieldTwo == this.FieldTwo && ...);
    }

}

Answer 1

我注意到的一些事情：

• 因为您要重写 Equals，所以您还应该重写 GetHashCode。
• 由于您的 Equals(MyObj) 方法是整个 IEquatable 接口的有效实现，因此 MyObj 确实应该实现该接口。这也将允许 Dictionary<> 等直接利用您的 Equals(MyObj) 方法，而不是通过 Equals(object) >。

另外，我完全同意 Trillian 的替代实现，除了我会直接将 a != b 实现为 !(a == b) 而不是 !Equals( a，b）。 （当然差异很小。）

Answer 2

基本上是的，但是有一个错误需要纠正。

Equals(object) 方法调用自身，而不是调用 Equals(MyObj) 方法，从而导致永久循环。它应该是：

public override bool Equals(object obj) {
   MyObj other = obj as MyObj;
   return this.Equals(other);
}

或简单地：

public override bool Equals(object obj) {
   return this.Equals(obj as MyObj);
}

另外，您可以将不等式运算符简化为：

public static bool operator !=(MyObj a, MyObj b) {
   return !(a == b);
}

Answer 3

如果您正在寻求效率，我建议使用它而不是 object.ReferenceEquals(foo, null)：

(object)foo == null

这实际上是等效的，但避免了函数调用。

我还喜欢在所有覆盖 Equals 的类型中实现 IEquatable。对于引用类型，我然后将 Equals(object) 转发到 Equals(Foo)。

public override bool Equals(object other){return Equals(other as Foo);}

运算符重载可以这样简化：

public static bool operator==(Foo a, Foo b){
    if((object)a == null)
        return (object)b == null;
    return a.Equals(b);
}
public static bool operator!=(Foo a, Foo b){
    return !(a == b);
}

不过，如果需要绝对效率，则可能值得在这些函数中重复一些代码以避免额外的函数调用，但与使用 ( object)foo == null 而不是 object.ReferenceEquals(foo, null)，避免函数调用需要额外的代码来维护，因此小小的收益可能不值得。

Answer 4

我更喜欢将所有“如果这是 null 则执行其他操作...”逻辑留给框架：

class MyObj : IEquatable<MyObj> {

  public static bool operator ==( MyObj left, MyObj right ) {
    return EqualityComparer<MyObj>.Default.Equals( left, right );
  }

  public static bool operator !=( MyObj left, MyObj right ) {
    return !EqualityComparer<MyObj>.Default.Equals( left, right );
  }

  public override bool Equals( object obj ) {
    return this.Equals( obj as MyObj );
  }

  public bool Equals( MyObj other ) {
    return !object.ReferenceEquals( other, null )
        && obj.FieldOne == this.FieldOne
        && obj.FieldTwo == this.FieldTwo
        && ...
        ;
  }

  ...

}

另请参阅 重写 GetHashCode 的最佳算法是什么？ 用于实现 GetHashCode。

Answer 5

我将以下代码片段用于引用类型，在我看来，它的重复更少并且感觉更干净。拥有静态“Equals”方法允许 .NET 语言在没有运算符重载的情况下比较您的实例，而无需在调用实例方法之前测试 null。如果您正在实现相等运算符，那么如果可以的话，最好使您的类不可变。

class Foo : IEquatable<Foo>
{
    public override bool Equals(object obj)
    {
        return Equals(obj as Foo);
    }

    public bool Equals(Foo other)
    {
        if (object.ReferenceEquals(other, null)) return false;

        // Optional early out
        if (object.ReferenceEquals(this, other)) return true; 

        // Compare fields here
    }

    public static bool Equals(Foo a, Foo b)
    {
        if (ReferenceEquals(a, null)) return ReferenceEquals(b, null);
        return a.Equals(b);
    }

    public static bool operator ==(Foo a, Foo b)
    {
        return Equals(a, b);
    }

    public static bool operator !=(Foo a, Foo b)
    {
        return !Equals(a, b);
    }
}