如何确定两个泛型类型值是否相等？

Question

更新* 很抱歉......我的示例代码包含一个错误，导致很多我不明白的答案。 而不是

Console.WriteLine("3. this.Equals   " + (go1.Equals(go2)));

我想写

Console.WriteLine("3. this.Equals   " + (go1.Equals(sb2)));

---

我试图弄清楚如何才能成功确定两个泛型类型值是否彼此相等。基于 Mark Byers 对 this question 的回答，我想我可以使用 value.Equals()，其中 value 是泛型类型。 我的实际问题是在 LinkedList 实现中，但可以通过这个更简单的示例来说明问题。

class GenericOjbect<T> {
    public T Value { get; private set; }
    public GenericOjbect(T value) {
        Value = value;
    }
    public bool Equals(T value) {
        return (Value.Equals(value));
    }
}

现在我定义一个包含new StringBuilder("StackOverflow") 的GenericObject<StringBuilder> 实例。如果我在这个 GenericObject 实例上调用Equals(new StringBuilder("StackOverflow")，我希望得到true，但我得到false。

显示此的示例程序：

using System;
using System.Text;

class Program
{
    static void Main()
    {
        var sb1 = new StringBuilder("StackOverflow");
        var sb2 = new StringBuilder("StackOverflow");

        Console.WriteLine("StringBuilder compare");
        Console.WriteLine("1. ==            " + (sb1 == sb2));
        Console.WriteLine("2. Object.Equals " + (Object.Equals(sb1, sb2)));
        Console.WriteLine("3. this.Equals   " + (sb1.Equals(sb2)));

        var go1 = new GenericOjbect<StringBuilder>(sb1);
        var go2 = new GenericOjbect<StringBuilder>(sb2);

        Console.WriteLine("\nGenericObject compare");
        Console.WriteLine("1. ==            " + (go1 == go2));
        Console.WriteLine("2. Object.Equals " + (Object.Equals(go1, sb2)));
        Console.WriteLine("3. this.Equals   " + (go1.Equals(sb2)));
        Console.WriteLine("4. Value.Equals  " + (go1.Value.Equals(sb2.Value)));
    }
}

对于比较两个StringBuilder对象的三种方法，只有StringBuilder.Equals实例方法（第三行）返回true。这是我所期望的。但是在比较 GenericObject 对象时，它的 Equals() 方法（第三行）返回 false。有趣的是，第四个比较方法确实返回true。我认为第三和第四个比较实际上是在做同样的事情。

我会期待true。因为在 GenericObject 类的 Equals() 方法中，value 和 Value 都是 T 类型，在这种情况下是 StringBuilder。根据 Mark Byers 在 this question 中的回答，我预计 Value.Equals() 方法将使用 StringBuilder 的 Equals() 方法。正如我所展示的，StringBuilder 的 Equal() 方法确实返回 true。

我试过了

public bool Equals(T value) {
    return EqualityComparer<T>.Default.Equals(Value, value);
}

但这也返回 false。

所以，这里有两个问题：

1. 为什么代码没有返回true？
2. 如何实现Equals 方法，使其确实返回true？

Answer 1

正如Marc Gravell's answer 中所建议的，问题在于StringBuilder Equals(object) 的实现与Equals(StringBuilder) 中的实现不同。

然后，您可以忽略该问题，因为您的代码将与任何其他一致实现的类一起使用，或者您可以使用动态来解决问题（再次按照 Mark Gravell 的建议）。

但是，鉴于你没有使用 C# 4（所以没有动态），你可以这样尝试：

public bool Equals(T value)
{
   // uses Reflection to check if a Type-specific `Equals` exists...
   var specificEquals = typeof(T).GetMethod("Equals", new Type[] { typeof(T) });
   if (specificEquals != null &&
       specificEquals.ReturnType == typeof(bool))
   {
       return (bool)specificEquals.Invoke(this.Value, new object[]{value});
   }
   return this.Value.Equals(value);
}

Answer 2

您的代码看起来不错。这里的问题是 StringBuilder 有一组令人困惑的相互矛盾的 Equals。特别是，Equals(StringBuilder) 不同意 Equals(object)，即使对象 是 StringBuilder。

所有EqualityComparer<T> 需要 是一个理智的 Equals(object) 实现。接口 (IEquatable<T>) 是可选的。不幸的是，StringBuilder 没有这个（至少与您的第三个测试使用的 Equals(StringBuilder) 相比）。

但总的来说，建议是：使用EqualityComparer<T>；这支持：

• 具有标准“解除”规则的 nullable-of-T
• IEquatable-of-T
• object.Equals

Answer 3

带有通用对象的第 3 行没有调用您的自定义编写方法。相反，它调用基础Object.Equals(object)。要调用您的自定义方法，您需要传入 T 而不是 GenericObject<T>。比如：go1.Equals(go2.Value)

Answer 4

正如 Eric Lippert 在回答 question 时所说的那样 - 在编译时执行重载解决方案。

如果您查看StringBuilder 的实现，您会注意到它重载了Equals，并且没有覆盖它。这基本上是问题的根源，为什么 StringBuilder.Equals 不能按您的示例中的预期工作。

以以下 2 个类为例。 Overloader 类似于示例中的 StringBuilder，因为它重载了 Equals。 Overrider 非常相似，只是它覆盖了Equals。

public class Overloader
{
  public string Str {get;private set;}
  public Overloader (string str) {Str = str;}

  public bool Equals( Overloader str )
  {
    return this.Str.Equals( str );
  }
}

public class Overrider
{
  public string Str {get;private set;}
  public Overrider (string str) {Str = str;}

  public override bool Equals( object obj )
  {
    if ( obj is Overrider )
    {
      return this.Str.Equals( (obj as Overrider).Str );
    }
    return base.Equals( obj );
  }
}

在我的示例中，我稍微修改了您的 GenericObject<T> 类：

class GenericOjbect<T>
{
  public T Value {get;private set;}
  public GenericOjbect( T val ) {Value = val;}

  public bool Equals( T val )
  {
    return Value.Equals( val );
  }

  public override bool Equals( object obj )
  {
    if ( obj is T )
    {
      return this.Equals( ( T )obj );
    }
    if (obj != null && obj is GenericOjbect<T> )
    {
      return this.Equals( ( obj as GenericOjbect<T> ).Value );
    }
    return base.Equals( obj );
  }
}

在这个示例程序中，您将看到Overloader（或Stringbuilder）将返回false。但是，Overrider 返回 true。

class Program
{
  static void Main( string[] args )
  {
    var goOverloader1 = new GenericOjbect<Overloader>( new Overloader( "StackOverflow" ) );
    var goOverloader2 = new GenericOjbect<Overloader>( new Overloader( "StackOverflow" ) );

    var goOverrider1 = new GenericOjbect<Overrider>( new Overrider( "StackOverflow" ) );
    var goOverrider2 = new GenericOjbect<Overrider>( new Overrider( "StackOverflow" ) );

    Console.WriteLine( "Overrider  : {0}", goOverloader1.Equals( goOverloader2 ) ); //False
    Console.WriteLine( "Overloader : {0}", goOverrider1.Equals( goOverrider2 ) ); //True
  }
}

再次引用 Eric Lippert - 在编译时执行重载解析。这意味着编译器基本上会像这样查看您的GenericObject<T>.Equals( T val )：

public bool Equals( T val )
{
  return Value.Equals( (Object) val );
}

回答您的问题如何确定两个泛型类型值是否相等？。你可以做两件事。

1. 如果您拥有所有将被包裹在GenericObject<T> 中的对象，请确保它们都至少覆盖Equals。
2. 您可以在 GenericObject<T>.Equals(T val) 中执行一些反射魔法来手动执行后期绑定。

Answer 5

首先比较 typeof() 的输出，因此您要确保比较相同类型的对象，然后在 X 类上编写一个 Equals 方法，该方法采用 X 类的另一个实例，并比较所有属性......一旦你找到不同的东西，返回 false，否则继续直到返回 true。

干杯:)

Answer 6

您可以实现IEquatable<T>，也可以实现一个实现IEqualityComparer<T> 的比较器类。

确保您检查相等性的value 是不可变的，并且仅在类初始化时设置。

另一个考虑是实现IComparer<T>，当您实现这个时，您不必担心哈希码，因此也可以为可变类型/字段实现。

一旦你在课堂上properly实现IEquatable<T>，你的问题就会得到解决。

更新： 调用return EqualityComparer<T>.Default.Equals(Value, value); 基本上会返回相同的结果，因为没有实现IEqualityComparer<T>...

Answer 7

详细说明Gideon's answer（请点赞他的，不是我的）：你定义的方法有签名

bool GenericOjbect<T>::Equals( T )

当您的代码正在调用时

bool GenericOjbect<T>::Equals( GenericOjbect<T> )

从Object继承（而不是覆盖）。