平等

Question

好的，我有一个类我想要覆盖相等运算符，所以我有以下代码：

/// <summary>
/// Over-ride of the equality operator.
/// </summary>
/// <param name="credential1">The left hand object to test for equality.</param>
/// <param name="credential2">The right hand object to test for equality.</param>
/// <returns>True if the objects are equal.</returns>
public static bool operator ==(KnownServerCredential credential1, KnownServerCredential credential2)
{
    // ok check if either is null
    bool cell1Null = Equals(null, credential1);
    bool cell2Null = Equals(null, credential2);

    // if both are, then it's true
    if (cell1Null && cell2Null)
    {
        return true;
    }

    // if only one is, then how can they be the same?
    if (cell1Null || cell2Null)
    {
        return false;
    }

    // neither are - so we can now go to full on equality
    return credential1.IsEqualTo(credential2);
}

这很好用，我很满意。但是，静态分析工具（Resharper和VS2010代码分析）都会发誓最后一行可能抛出一个空引用异常，因为我在前两行检查null的方式。如果我将前两行从Equals(null, credentialX)更改为credentialX == null，那么静态分析工具很高兴，但它会创建一个堆栈溢出异常，因为我会递归调用相等覆盖。我可以使用(object)credentialX == null充分利用这两个世界，但这似乎并不是最干净的方式。

所以简单的问题是，我是否遗漏了某些东西，或者是否能够实现我想要的最佳方式？

Answer 1

有两种方法可以检查一对对象是否相等：引用相等和结构/值相等。引用相等性是所有引用类型（类）的缺省值，结构相等性是所有值类型的缺省值（但缺省实现不是最优的）。使用以下指南为引用类型和值类型实现结构相等。

平等

等同性检查应遵循以下规则：

对象等于自身（身份）
将x与y进行比较会返回与将y与x进行比较相同的事实。（对称）
如果x等于y且y等于z，则x必须等于z。（及物）
对象永远不会等于null。
null等于null。
不应抛出异常。

让您的类或结构实现IEquatable<T>接口以进行自定义相等性检查，然后实施IEquatable<T>.Equals(T)和Object.Equals()方法。

参考类型（类）的等同性

对于参考类型，请执行IEquatable<T>.Equals(T)方法，如下所示：

public bool Equals(MyType other)
{
    if (Object.ReferenceEquals(other, null) ||      // When 'other' is null
        other.GetType() != this.GetType())          // or of a different type
        return false;                               // they are not equal.
    return this.field1 == other.field1
        && this.field2 == other.field2;
}

然后像这样覆盖Object.Equals()：

public override bool Equals(object obj)
{
    return Equals(obj as MyType);
}

值类型（结构）的等同性

由于值类型不能为null，因此请执行IEquatable<T>.Equals(T)方法，如下所示：

public bool Equals(MyType other)
{
    return this.field == other.field
        && this.field2 == other.field2;
}

然后像这样覆盖Object.Equals()：

public override bool Equals(object obj)
{
    if (!(obj is MyType))
        return false;
    return Equals((MyType)obj);
}

平等运营商

对于引用和值类型，您可能希望覆盖默认的相等和不等运算符。基于this post by Jon Skeet，可以像这样实现运算符的相等和不等：

public static bool operator ==(MyType left, MyType right)
{
    return Object.Equals(left, right);
}

public static bool operator !=(MyType left, MyType right)
{
    return !(left == right);
}

请注意，当left和/或right为null时，Object.Equals(object, object)不会调用Object.Equals(object)覆盖（因此不会调用IEquatable<T>.Equals(T)方法）。

哈希码

有时，对象的哈希码很重要，例如，当对象可能放在字典或哈希表中时。通常，当您覆盖Equals()方法时，请覆盖GetHashCode()方法。哈希码应遵循these rules：

哈希码should never change，甚至在修改对象中的某些字段后也是如此。
对于被认为相等的对象，哈希码必须相等。
对于被认为不相等的对象，哈希码可以是任何（包括相等的）。
哈希码应该是随机分发的。
哈希代码函数绝不能抛出异常，必须始终返回。
应该非常快速地计算哈希码。

因此，要为使用结构相等的类或结构实现Object.GetHashCode()，请从对象中选择一些不可变的字段并将它们标记为readonly。仅使用这些字段来计算哈希码。覆盖Object.GetHashCode()方法和implement it like this：

public override int GetHashCode()
{
    unchecked
    {
        int hash = 17;
        // Don't forget to check for null values.
        hash = hash * 29 + field1.GetHashCode();
        hash = hash * 29 + field2.GetHashCode();
        // ...
        return hash;
    }
}

或者，如果您只有一个不可变字段，则可以考虑使用：

public override int GetHashCode()
{
    // Don't forget to check for null values.
    return field1.GetHashCode();
}

如果您没有不可变字段return a constant hash code。例如，hash code of the type itself。

public override int GetHashCode()
{
    return GetType().GetHashCode();
}

集合的结构相等

不应使用默认的Equals()方法比较集合。相反，集合的默认相等应该是引用相等。要实现结构相等性，请实现IStructuralEquatable接口。例如：

bool IStructuralEquatable.Equals(object obj, IEqualityComparer comparer)
{
    var other = obj as MyType;
    if (other == null)
        return false;
    return ((IStructuralEquatable)this.innerArray)
        .Equals(other.innerArray, comparer);
}

int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
{
    return ((IStructuralEquatable)this.innerArray).GetHashCode(comparer);
}

Answer 2

通常，当我必须检查等于null时，我使用：

if (object.ReferenceEquals(myref, null))
{

它的优势在于它可以绕过重载的Equals和operator==。

在相等覆盖范围内检查null

2 个答案:

平等

参考类型（类）的等同性

值类型（结构）的等同性

平等运营商

哈希码

集合的结构相等