在相等覆盖范围内检查 null

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 代码分析）发誓最后一行可能会引发空引用异常，因为我在前两行中检查空值的方式。如果我将前两行从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==。