比较一个类的两个实例

Question

我有这样的课

public class TestData
{
   public string Name {get;set;}
   public string type {get;set;}

   public List<string> Members = new List<string>();

   public void AddMembers(string[] members)
   {
      Members.AddRange(members);
   }   
}

我想知道是否可以直接将此类的实例与彼此进行比较，并找出它们完全相同吗？ 机制是什么？ 我正在寻找类似if(testData1 == testData2) //Do Something做点什么，如果没有，怎么做？

Answer 1

您应该在您的类上实现IEquatable<T>接口，这将允许您定义相等逻辑。 实际上，您也应该重写Equals方法。

public class TestData : IEquatable<TestData>
{
   public string Name {get;set;}
   public string type {get;set;}

   public List<string> Members = new List<string>();

   public void AddMembers(string[] members)
   {
      Members.AddRange(members);
   }   

  // Overriding Equals member method, which will call the IEquatable implementation
  // if appropriate.

   public override bool Equals( Object obj )
   {
       var other = obj as TestData;
       if( other == null ) return false;

       return Equals (other);             
   }

   public override int GetHashCode()
   {
      // Provide own implementation
   }


   // This is the method that must be implemented to conform to the 
   // IEquatable contract

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

       if( ReferenceEquals (this, other) )
       {
            return true;
       }

       // You can also use a specific StringComparer instead of EqualityComparer<string>
       // Check out the specific implementations (StringComparer.CurrentCulture, e.a.).
       if( EqualityComparer<string>.Default.Compare (Name, other.Name) == false )
       {
           return false;
       }
       ...

       // To compare the members array, you could perhaps use the 
       // [SequenceEquals][2] method.  But, be aware that [] {"a", "b"} will not
       // be considerd equal as [] {"b", "a"}

       return true;

   }

}

Answer 2

可以将三种引用类型为T对象彼此进行比较：

1. 使用object.Equals方法
2. 使用IEquatable<T>.Equals （仅适用于实现IEquatable<T>类型）
3. 使用比较运算符==

此外，每种情况都有两种可能性：

1. 被比较的静态类型的对象的是T （或某些其它基础T ）
2. 被比较object的静态类型是object

您绝对需要知道的规则是：

• Equals和operator==的默认值是测试引用是否相等
• 无论所比较的对象的静态类型是什么， Equals实现都能正常工作
• IEquatable<T>.Equals总是执行相同object.Equals ，但如果静态类型的对象是T ，它会提供表现略好

那么，所有这些在实践中意味着什么？

根据经验，应该使用Equals来检查是否相等（覆盖object.Equals 。必要时Equals ），并实现IEquatable<T>来提供更好的性能。 在这种情况下object.Equals应在以下方面来实现IEquatable<T>.Equals 。

对于某些特定类型（例如System.String ），也可以使用operator== ，尽管您必须注意不要进行“多态比较”。 另一方面，即使您进行了比较， Equals方法也将正常工作。

您可以在此处看到一个多态比较的示例以及它为什么会成为问题的原因。

最后，不要忘记，如果重写object.Equals你还必须重写object.GetHashCode相应。

Answer 3

一种实现方法是实现IEquatable<T>

public class TestData : IEquatable<TestData>
{
   public string Name {get;set;}
   public string type {get;set;}

   public List<string> Members = new List<string>();

   public void AddMembers(string[] members)
   {
      Members.AddRange(members);
   }

   public bool Equals(TestData other)
   {
        if (this.Name != other.Name) return false;
        if (this.type != other.type) return false;

        // TODO: Compare Members and return false if not the same

        return true;
   }
}


if (testData1.Equals(testData2))
    // classes are the same

您还可以重写Equals（object）方法（来自System.Object），如果执行此操作，则还应该重写GetHashCode， 请参见此处

Answer 4

我在这里看到了许多不错的答案，但以防万一您希望进行比较

if(testData1 == testData2) // DoSomething

可以使用==和！=运算符代替使用Equals函数：

public static bool operator == (TestData left, TestData right)
{
    bool comparison = true; //Make the desired comparison
    return comparison;
}

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

Answer 5

您可以覆盖equals方法，并在其中手动比较对象

另请参阅重载Equals（）和运算符==的准则

Answer 6

您将需要定义使对象A等于对象B的规则，然后重写此类型的Equals运算符。

http://msdn.microsoft.com/zh-CN/library/ms173147(v=vs.80).aspx

Answer 7

实现IEquatable<T> interface 。 这定义了一种通用方法，值类型或类实现该通用方法以创建用于确定实例相等性的特定于类型的方法。 此处有更多信息：

http://msdn.microsoft.com/en-us/library/ms131187.aspx

Answer 8

首先，很难定义平等，只有您才能确定平等对您的意义

1. 这是否意味着会员具有相同的价值
2. 或者他们指向相同的位置。

这是一个讨论和答案

比较引用类型的两个实例的“最佳实践”是什么？