3

再次讨论平等我偶然发现EqualityComparer<T>.Default.Equals()。我更喜欢将此方法称为引用类型而不是object.Equals().
现在我觉得我大错特错了。

object.Equals()使用可覆盖的实例Equals()方法来提供正确的多态行为，而在实现时EqualityComparer<T>.Default.Equals()调用。IEquatable<T>.Equals()

现在考虑这个小程序：

public class Class1 : IEquatable<Class1>
{
    public int Prop1 { get; set; }

    public bool Equals(Class1 other)
    {
        if (other == null)
            return false;

        return Prop1 == other.Prop1;
    }

    public override bool Equals(object obj)
    {
        if (obj == null || GetType() != obj.GetType())
        {
            return false;
        }

        return Equals(obj as Class1);
    }
}

public class Class2 : Class1, IEquatable<Class2>
{
    public int Prop1 { get; set; }
    public int Prop2 { get; set; }

    public bool Equals(Class2 other)
    {
        if (other == null)
            return false;

        return Prop1 == other.Prop1 && Prop2 == other.Prop2;
    }

    public override bool Equals(object obj)
    {
        if (obj == null || GetType() != obj.GetType())
        {
            return false;
        }

        return Equals(obj as Class2);
    }
}


class Program
{
    static void Main(string[] args)
    {
        var c1 = new Class1 {Prop1 = 10};
        var c2 = new Class2 {Prop1 = 10, Prop2 = 5};
        var c3 = new Class2 {Prop1 = 10, Prop2 = 15};

        Console.WriteLine("Object.Equals()");
        Console.WriteLine("C1=C2 {0}",Equals(c1,c2));
        Console.WriteLine("C2=C1 {0}",Equals(c2, c1));
        Console.WriteLine("C2=C3 {0}",Equals(c2, c3));
        Console.WriteLine("C3=C2 {0}", Equals(c3, c2));

        var dec1 = EqualityComparer<Class1>.Default;

        Console.WriteLine();
        Console.WriteLine("EqualityComparer<Class1>.Default.Equals");
        Console.WriteLine("C1=C2 {0}", dec1.Equals(c1, c2));
        Console.WriteLine("C2=C1 {0}", dec1.Equals(c2, c1));
        Console.WriteLine("C2=C3 {0} BUG?", dec1.Equals(c2, c3));
        Console.WriteLine("C3=C2 {0} BUG?", dec1.Equals(c3, c2));

        Console.ReadKey();
    }
}

它显示了在相等语义中带来不一致是多么容易：

Object.Equals()
C1=C2 False
C2=C1 False
C2=C3 False
C3=C2 False

EqualityComparer<Class1>.Default.Equals
C1=C2 False
C2=C1 False
C2=C3 True BUG？
C3=C2 真正的BUG？

但是MSDN 文档建议：

给实现者的注意事项 如果您实现 Equals，您还应该重写 Object.Equals(Object) 和 GetHashCode 的基类实现，以便它们的行为与 IEquatable<T>.Equals 方法的行为一致。如果您确实重写了 Object.Equals(Object)，那么在调用类上的静态 Equals(System.Object, System.Object) 方法时也会调用您重写的实现。此外，您应该重载 op_Equality 和 op_Inequality 运算符。这可确保所有相等性测试返回一致的结果，如示例所示。

从这一刻开始，我认为没有理由IEquatable<T>为引用类型实现。谁能告诉我什么时候有任何意义？当我们以不同的方式看待类型（作为基本类型）时，我真的应该将不同的平等行为视为不一致吗？

4

2 回答 2

3

今天我问自己在添加IEquatable<T>课程时会产生哪些后果，我发现了你的问题。
然后我测试了你的代码。对于阅读本文的其他人，这里有一个答案，而不仅仅是“只是这样做才能使其工作”。

首先，这不是一个错误。
您的问题是，您指定了一个EqualityComparer<Class1>，它仅在class1by中实现public bool Equals(Class1 other)。
因此，dec1.Equals(c2, c3)将在仅比较的内容的情况下调用此函数class1。

从您的评论BUG?中，我可以看出您也希望对 的内容class2进行比较，就像其他人所期望的一样。为此，您需要在 中更改
public bool Equals(Class1 other)
并
public virtual bool Equals(Class1 other)
覆盖此功能class2，然后您还可以在其中比较class2.
但这可能会导致一个非常奇怪的结构。因此，为了完整起见，这是我的实现方式：

在基类中，仅类型检查：

//--------------------------------------------------------------------------
public static bool operator == (CClass1 i_value1, CClass1 i_value2)
{
  if (ReferenceEquals (i_value1, i_value2))
    return true;
  if (ReferenceEquals (null, i_value1))
    return false;

  return (i_value1.Equals (i_value2));
}

//--------------------------------------------------------------------------
public static bool operator != (CClass1 i_value1, CClass1 i_value2)
{
  return !(i_value1 == i_value2);
}

///-------------------------------------------------------------------------
public sealed override bool Equals (object i_value)
{
  if (ReferenceEquals (null, i_value))
    return false;
  if (ReferenceEquals (this, i_value))
    return true;

  if (i_value.GetType () != GetType ())
    return false;

  return Equals_EXEC ((CClass1)i_value);
}

///-------------------------------------------------------------------------
public bool Equals (CClass1 i_value)  // not virtual, don't allow overriding!
{
  if (ReferenceEquals (null, i_value))
    return false;
  if (ReferenceEquals (this, i_value))
    return true;

  if (i_value.GetType () != GetType ())
    return false;

  return Equals_EXEC (i_value);
}

仍在基类中，内容检查：

///-------------------------------------------------------------------------
protected override bool Equals_EXEC (CClass1 i_value)
{
  return Equals_exec (i_value);
}

//--------------------------------------------------------------------------
private bool Equals_exec (CClass1 i_value)
{
  return variable1 == i_value.variable1
      && variable2 == i_value.variable2
      && ... ;
}

在派生类中，内容检查：

///-------------------------------------------------------------------------
protected override bool Equals_EXEC (CClassN i_value)
{
  return base.Equals_EXEC (i_value)
      && Equals_exec (i_value as CClassN);
}

//--------------------------------------------------------------------------
private bool Equals_exec (CClassN i_value)
{
  return variable5 == i_value.variable5
      && variable6 == i_value.variable6
      && ... ;
}
于 2020-02-14T14:10:21.587 回答
2

对或错，这就是我倾向于在基类和派生类上实现Equals(Object)的IEquatable<T>.Equals(T)方式。

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

    public virtual bool Equals(Class1 obj)
    {
        if(ReferenceEquals(obj, null))
            return false;

        // Some property checking
    }
}

public class Class2 : Class1, IEquatable<Class2>
{
    public sealed override bool Equals(Class1 obj)
    {
        return Equals(obj as Class2);
    }

    public virtual bool Equals(Class2 obj)
    {
        if(!base.Equals(obj))
            return false;

        // Some more property checking
    }
}

public class Class3 : Class2, IEquatable<Class3>
{
    public sealed override bool Equals(Class2 obj)
    {
        return Equals(obj as Class3);
    }

    public virtual bool Equals(Class3 obj)
    {
        if(!base.Equals(obj))
            return false;

        // Some more property checking
    }
}

对于引用类型，实现的好处IEquatable<T>是微不足道的，如果你有两个类型的实例T，你可以直接调用T.Equals(T)。而不是T.Equals(Object)随后需要对参数执行类型检查。

的主要目的IEquatable<T>是用于值类型，其中装箱实例存在开销。

于 2013-11-26T14:48:29.053 回答