c# - 在平等覆盖中检查空值

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

检查一对对象是否相等的方法有两种:引用相等和结构/值相等。引用相等性是所有引用类型(类)的默认值，结构相等性是所有值类型的默认值(但默认实现不是最优的)。使用以下指南为引用类型和值类型实现结构相等。

平等

相等性检查应遵循以下规则:

• 一个对象等于它自己(Identity)
• 比较 x至 y返回与比较 y 相同的事实至 x . (对称)
• 如果x等于y和 y等于z , 然后 x必须等于 z . (传递性)
• 对象永远不会等于null .
• null等于null .
• 不应抛出异常。

让您的类或结构实现 IEquatable<T> 用于自定义相等性检查的接口(interface)，然后执行 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);
}