给你的类重写Equals--检测Class是否相等

在C#的容器中,常用的三个容器数组,ArrayList,Hashtable..数组比较简单,实现某种单一数据的存储,但是并不能*插入,移除和容纳不同的对象..,所以ArrayList是数组的替代品,并且由于ArrayList可以*的添加,删除,插入,读取,给我们提供了足够大的*性,颇得我的青睐..不过使用中,难免有些缺点,感觉最麻烦的就是检测某对象是否在Items中..因为每一个new出来的Class在内存中的表现不相同,即便是同一个类,你new出来两个,然后再判断,也是会一样的!!所以每次使用ArrayList.Contains()检测对象的时候,难免都得不到自己想要的结果..因为每个Class都是继承自Object类..而ArrayList.Contains()的实现是IList.Contains,而此方法是调用Class中的Equals方法判断是否相等,这个时候,可以在自己的对象中覆写Object.Equals方法,以达到自己的目的..注意,如果你覆写了Equals方法,则也要覆写GetHashCode(),因为Equals是用获取Object.GetHashCode()来做判断的.看看下面的代码就明白: posted on 2005-12-28 10:35 难得一蠢 阅读(2947) 评论(22)  编辑 收藏 引用 收藏至365Key 所属分类: C#.NET

 1using System;
 2
 3namespace HashCode_Test
 4{
 5/**//// <summary>
 6///        给你的类加入Equals,测试类
 7/// </summary>
 8public class Class2
 9{
10    int myHashCode = 0;
11    public Class2( int id )    //传递进一个int,作为GetHashCode的值
12    {
13        myHashCode = id;
14    }
15        
16    //覆写GetHashCode,关键的一步
17    public override int GetHashCode()    
18    {
19        return myHashCode;
20    }
21        
22    //这步,可有可无,主要是做测试结果用的
23    public override string ToString()    
24    {
25        return DateTime.Now.ToString();
26    }
27        
28    /**//// <summary>
29    ///        重载了Equals方法,这步和GetHashCode配合起来才会有效果
30    /// </summary>
31    /// <param name="o">要检测的对象</param>
32    /// <returns>返回是否相同</returns>
33    public override bool Equals( object o )    
34    {
35        return o.GetHashCode() == myHashCode;
36    }
37
38    //在这里使用运算符重载,主要是为了进一步演示Equals
39    public static bool operator ==(object c1, Class2 c2) 
40    {
41        return c1.GetHashCode().Equals( c2.GetHashCode() );
42    }
43    
44    //当你重载了==运算符后,必须要重载!=运算符
45    public static bool operator !=(object c1, Class2 c2) 
46    {
47        return c1.GetHashCode().Equals( c2.GetHashCode() );
48    }
49        
50}
51}
这里是测试代码:

 1System.Collections.ArrayList arr = new System.Collections.ArrayList();
 2
 3int i = 0;
 4for ( i = 0; i < 4 ; i ++ ) {
 5    Class2 class2 = new Class2(i);        //我们添加四个对象
 6    arr.Add( class2 );
 7}
 8
 9for ( i = 0; i < 4 ; i ++ ) 
10{
11    Class2 class2 = new Class2(i);        //重新创建四个对象,判断是否和容器中的对象相等
12    Console.WriteLine( i + ":" + arr.Contains(class2));//全部输出true
13}
14
15
16
17Class2 class2_1 = new Class2(1);    //再创建对象1,并添加到容器中,以判断是否有多个对象1存在
18arr.Add( class2_1  );                
19
20for ( i = 0;i<arr.Count;i++  ) {
21    Class2 class2_3 = new Class2(1);//这个时候我们要检测出容器中有多少个对象1
22    if ( arr[i].Equals( class2_3 ) ) {//我们用Equals来检测是否相等
23        Console.WriteLine( "我用Equals找到/t"  );
24    }
25    if ( arr[i] == class2_3  )            //我们用==来检测相等
26    {
27        Console.WriteLine( "我用==找到/t"  );
28    }
29    Console.WriteLine( arr[i].ToString() + "/t HashCode:" + arr[i] .GetHashCode());            //这里输出HashCode和ToString()查看
30    
31}
32

相信上面的代码很容易看的懂..在我的Class2类中覆写了GetHashCode() ,ToString() ,Equals(object o),并重载了==运算符和!=运算符..将传递的id作为HashCode,然后判断当前传递的对象Object.GetHashCode是否等于当前对象的GetHashCode..这样就解决了ArrayList.Contains不能对Class做出正确判断的问题..

另外,还有一个容器Hashtable的使用和判断,并不能用上面的方法解决..因为Hashtable.Contains的实现方法是IDictionary.Contains来做判断..需要实现IDictionary接口的方法才可以.因为牵涉到的内容比较多.所以不能在这里全部写完..关于具体的方法和实现,我会找时间写出来的..

最后大家可以自己做一个没有实现Equals方法的类,再用ArrayList.Contains来做判断..可以看到结果都是flase..和上面的代码是个对比..
这个方法不仅可以用在ArrayList,而且也可以在多个地方使用,比如两个Class之间的关联?Class1和Class2是否关联??
评论: # re: 给你的类重写Equals--检测Class是否相等 2005-12-28 10:42 | 那一剑的风情
楼主，据我了解，Equals 方法 并不需要调用GetHashCode来进行判断传入对象是否和目标对象相等。

Hashtable要求任何两个相等的对象，都必须要有相同的散序码。

所以在重写Equals方法的时候，最好重写GetHashCode方法来保证这个要求。
  回复
   # re: 给你的类重写Equals--检测Class是否相等 2005-12-28 10:51 | 难得一蠢
To:那一剑的风情
是的啊..再重写的Equals的时候,是必须要重写GetHashCode方法的啊.
另外你说的Hashtable需要单独实现IDictionary接口..

对于ArrayList.Contains 的实现,你可以查下MSDN,它的确实是IList.Contains方法的..但是后面的备注是:此方法通过调用 Object.Equals 确定相等性。所以你需要在你的类中实现了Equals 和 GetHashCode就可以了..  回复
   # re: 给你的类重写Equals--检测Class是否相等 2005-12-28 10:58 | 那一剑的风情
可能我没有说明白自己的意思
我其实是对你的这句话比较迷惑

如果你覆写了Equals方法,则也要覆写GetHashCode(),因为Equals是用获取Object.GetHashCode()来做判断的

Equals没有必要一定要调用GetHashCode来实现，但是2个相等的object，最好返回相同的散序码

基于这样的考虑，当为一个类重写了Equals方法之后，最好重写GetHashCode方法，来保证2个相同的实例返回相同的散序码  回复
   # re: 给你的类重写Equals--检测Class是否相等 2005-12-28 11:49 | 难得一蠢
Equals没有必要一定要调用GetHashCode来实现
====================================
是的.这个是完全可以的..可以使用的单独的方法来实现是否相等的判断..不过这种方法我并不推荐..  回复
   # re: 给你的类重写Equals--检测Class是否相等 2005-12-28 12:00 | omnislash
实现的equals方法必须满足自反、对称和传递
而GetHashCode的行为依赖于equals的行为，所以需要一并重写。

这个话题可以参考Effective Java的第7、8款，这两个方法在Java/.Net里的语义是相同的  回复
   # re: 给你的类重写Equals--检测Class是否相等 2005-12-28 12:17 | 难得一蠢
To:omnislash

呵呵,说句玩笑话,我是前端时间看java编程思想的时候,看到java种的类似代码.所以用C#重新实现了.感觉C#没有公开源码.确实比起Java来有些保守的..  回复
   # re: 给你的类重写Equals--检测Class是否相等 2005-12-28 13:19 | Colin Han

首先需要明确一点概念：

Equals: 判断两个对象是否相等。
这个判断逻辑可以被Override，object的默认实现是判断两个Reference是否引用到同一个对象上。但是，经常我们希望控制这个检查，比如一个Font对象，当他们的所有属性都相同时，我们就认为这个对象是相同的。而不是必须引用到同一个对象上。

GetHashCode: 获得一个对象的Hash值。
Hash值得应用场景很多，比如：Hashtable中，比如加密，比如校验等。但是，Hash值应该比原对象简单（用来提高性能）。因此，Hash值不能表示源对象的所有特性（因为Hash值更简单）。同时，不同的对象可能具有相同的Hash值（这一点很重要），相同的对象必然有相同的Hash值（这一点同样很重要）。
因此，我们在Override Equals方法时，也必须Override GetHashCode方法，以保证符合上面的两条重要策略。

一般情况下，一个类型应该写成这个样子：

public class Class1
{
  public Class1(int p1, Font p2, Color p3)
  {
    this._p1 = p1;
    this._p2 = p2;
    this._p3 = p3;
  }

  private int _p1;
  private Font _p2;
  private Color _p3;

  public override Equals(object o)
  {
    if (!(o is Class1))
    { 
      return false;
    }

    return this._p1 == ((Class1)o)._p1 &&
           object.Equals(this._p2, ((Class1)o)._p2) &&
           object.Equals(this._p3, ((Class1)o)._p3);
  }

  public override GetHashCode()
  {
    return this._p1.GetHashCode() ^ this._p2.GetHashCode() ^ this._p3.GetHashCode();
  }
}

而Hashtable正是用了上面两条重要的策略来提高按Key索引的性能的。  回复
   # re: 给你的类重写Equals--检测Class是否相等 2005-12-28 13:25 | Anders06
Hashtable.ContainsKey(key1);
先去调用key1.GetHashCode()方法,如果返回一致是再去调用Equals()方法,
返回为True是,才认为在HashTable中存在. 估计ArrayList的也是.
重写Equals(), 并不一定要重写GetHashCode(), 编译器只是给出一个警告  回复
   # re: 给你的类重写Equals--检测Class是否相等 2005-12-28 13:28 | omnislash
据我所知，Equals方法并不是用HashCode来判断相等性的。

MSDN对GetHashCode的说明是：
Serves as a hash function for a particular type, suitable for use in hashing algorithms and data structures like a hash table.


GetHashCode方法是作为一个散列函数提供的。而.net（java也是）里的hashtable对象，是按桶(bucket)存储对象的，hashcode作为桶的索引，具有相同hashcode的对象将存放在一个桶中（这时其实就是发生了一个hash碰撞）。在查找的时候将首先通过hashcode查找桶，如果桶中元素不止一个，再调用equals方法进行比较。
由此我们可以发现，如果一个散列函数的碰撞率越低，那么每个桶存放的对象就越少，最优的情况是一个桶一个对象。另外一个极端，如果我们给所有的对象都实现了同样的GetHashCode，那么所有的对象就都存放在一个桶里，hashtable就退化为一个无序的线性表，查找效率就非常低了。当然，我们也可以通过在加入hashtable的时候提供一个实现了System.Collections.IHashCodeProvider的对象来做分桶。

GetHashCode是提取对象的一些区别于其他对象的特征后得到的一个特征码，而Equals方法就是检测一个对象是否区别于另外一个对象，因此GetHashCode方法实际上在行为上是依赖于Equals方法，而不是相反。

btw: 示例代码里面重写的Object.Equals方法没有考虑类型的比较，是一个bug。因为这将导致Equals方法不满足传递和对称的约束  回复
   # re: 给你的类重写Equals--检测Class是否相等 2005-12-28 13:56 | 那一剑的风情
omnislash说的更全面些
GetHashCode方法实际上在行为上是依赖于Equals方法
严重同意这个说法  回复
   # re: 给你的类重写Equals--检测Class是否相等 2005-12-28 15:01 | 难得一蠢
To: omnislash
你讲的很全面.我有几个疑问哦.
1.Equals是用上面来判断相等性的呢??给我的感觉是,只要我的Class中的GetHashCode和给定的Object.GetHashCode相等则会返回一个true...

2.关于Equals验证类型的比较,可以对Equals这么写:
public override bool Equals( Class2 o )
{
return o.GetHashCode() == myHashCode;
}
从而禁止提交非特定类型的Class...避免产生异常..并且我不推荐对每个Class都使用相同的验证方法..必要的时候可以用你上面的代码..做进一步的验证..从而达到精确..精准..

感谢指教..仔细看了大家的回复..真的是收获颇多..呵呵..  回复
   # re: 给你的类重写Equals--检测Class是否相等 2005-12-28 16:11 | omnislash
很高兴参与讨论，指教可不敢当。
简单回复：
1、相等性的判断完全来自需求。
多数情况下，一个对象实例代表一个独一无二的实体，因此按引用比较就足够了，而从Object继承来的Equals方法就是按引用比较，因此无需重写。
有时候需要提供某种相等逻辑来代替引用比较，这个时候需要重写Equals方法，例如System.String，相等的逻辑就是2个字符串的字面值相同。同样，如果你用class来实现值对象，就必须重写Equals方法，而用struct声明值对象就不必，因为struct的Equals方法默认是全字段比较的。
需要重写Equals方法的是常常出现的一种中间情况。就是按一个对象的某些字段比较。举例来说，我定义一个Person对象，具有3个字段
class Person
{
private string idNumber;
private string name;
private int weight;
}
显然姓名，体重是会变的，而身份证号是他的唯一标识，那么为了识别这个人，要重写Equals方法来作比较
public override Equals(object o)
{
if (object.ReferenceEquals(this, o)) return true;
if (!o.GetType().Equals(this.GetType())) return false;
Person other = o as Person;
return this.idNumber == other.idNumber;
}

这就实现了Equals方法，同时，它不违反自反、传递、对称的约束 -- 这3项是Equals方法的通用契约。

当然，如果你提供的GetHashCode方法也能够满足自反、传递、对称的约束，用它来作Equals的实现也是可以的，但是我的感觉这个在实际项目中基本上很难，而且代码的可读性和可维护性不够理想。

Equals方法和GetHashCode方法的关系：
如果有a.Equals(b) == true，一定应该有(a.GetHashCode == b.GetHashCode) == true
反过来，如果有(a.GetHashCode == b.GetHashCode) == false
必须保证a.Equals(b) == false

总之，对第一个问题
1. 重写Equals方法取决于需求，你究竟是想要引用相等，还是逻辑相等
2. 重写Equals方法必须满足自反，对称，传递的约束
3. a.Equals(b)是a.GetHashCode == b.GetHashCode的充分条件

第二个问题是这样的，你是重载(overload)了equals方法而不是重写(override)，这样会导致你的强类型的equals方法和从object继承来的equals方法语义不一致，而致命的是，hashtable调用的是object.Equals(object o)方法，而不是你的强类型版本……

最后，强烈推荐Effective Java这本书，90%以上的话题都适用于.net。其实我们今天讨论的东西拿本书里面都说到了，包括刚才那个强类型版本的Equals方法，呵呵。  回复
   # re: 给你的类重写Equals--检测Class是否相等 2005-12-28 16:47 | 难得一蠢
你是重载(overload)了equals方法而不是重写(override)
=======================
这个在我的类中我是用了override修饰过方法的..并不是重载版本..
值得注意的是:object.Equals(object o)这个方法,是应该修改一下,改为当前类型的Class..

另外,这个例子,我的使用环境是:在webApp中,我在Login的时候创建一个user(int userID)添加到ArrayList中,并将ArrayList保存在Application中,在用户Exit的时候,再次创建user(int userID),匹配ArrayList中的User, 反找回来用户..再进行一些退出操作.所以这个时候,必须使用覆写Equals,并且因为ID是不能重复的,所以这个办法是可行的...
  回复
   # re: 给你的类重写Equals--检测Class是否相等 2005-12-28 16:57 | 双鱼座
@omnislash:
我补充两点:
".net实现的Hash Bucket当发生Hash碰撞的时候采用二级桶,不过Equals在二级桶中的意义并不大"
".net采用算法索引,换句话说,即使hash code不发生碰撞,最好hash code在int.MinValue ~ int.MaxValue间均匀分布"

我倒是推荐《最大化.net性能》一书,此书是我唯一一本逐行看完的.net书籍，我觉得值得细细精读
http://www.apress.com/book/bookDisplay.html?bID=217  回复
   # re: 给你的类重写Equals--检测Class是否相等 2005-12-28 17:32 | omnislash
to 难得一蠢：
1.没办法重写一个并不存在的虚函数吧？
2.用userID作key，放在Hashtable也不错。

to 双鱼座：
谢谢你的补充，很有收获。
你看的是原书还是中译本？如果是后者，翻译质量怎么样？
另外，你有电子版吗……？
  回复
   # re: 给你的类重写Equals--检测Class是否相等 2005-12-28 18:20 | 难得一蠢
我前期做的时候也是用的Hashtable做,但是用了Equals之后,就取消了Hashtable了..呵呵..感觉还可以..免去了Hashtable中使用IDictionaryEnumerator的遍历的麻烦..

国内好像还没有<<最大化.net性能>>中译版吧..  回复
   # re: 给你的类重写Equals--检测Class是否相等 2005-12-29 09:14 | omnislash
中译本：
http://www.china-pub.com/computers/common/info.asp?id=27689

好像没有引进原版的样子  回复
   # re: 给你的类重写Equals--检测Class是否相等 2005-12-29 10:15 | 难得一蠢
已经看中了三本书了..呵呵..准备下单子了.

Effective Java中文版

测试驱动开发——实用指南

.NET性能优化

都是要细读的书啊..还有看过的好书吗??再推荐下..过年就可以好好充电了..  回复
   # re: 给你的类重写Equals--检测Class是否相等 2005-12-30 08:19 | Ninputer

33 public override bool Equals( object o )
34 {
35 return o.GetHashCode() == myHashCode;
36 }

不管怎么说，这个是不对的。对象相等应该以对象本身的状态为准，如果你的对象没有确定的状态，就不能重写Equals和GetHashCode，这种情况需要依赖引用相等和每隔实例一个Hashcode的默认规则来维持规则的有效性。

Hashcode应该能反映对象的状态而不是作对象的状态。  回复
   # re: 给你的类重写Equals--检测Class是否相等 2005-12-30 08:27 | Ninputer
双鱼座所说的“二级桶”是指Hashtable结构开放定址法解决冲突的探测规则，我认为就是指平方探测法。这是Hashtable中常见的，常常与再散列共同使用。

虽然GetHashCode并不与平方探测的规则直接相关，但了解了Hashtable的工作原理后，就会发现散列函数是很难写的，特别是完全自定义状态的类型。如果你不是很有把握，最好不要轻易实现。多利用一下.NET现有基本类型的GetHashCode方法可以帮你尽可能分布地宽些。  回复
   # re: 给你的类重写Equals--检测Class是否相等 2005-12-30 08:41 | 难得一蠢
但了解了Hashtable的工作原理后，就会发现散列函数是很难写的
==============================

是的..很难写..呵呵..不过C#高级编程中提到的一个比较简单的方法:
你的方法.GetHashCode+素数 + 每个方法字段的值+素数 可以构建一个假的HashCode..但是此方法并不均匀..所以还是有问题的..
也有另一个方法,用微软自带的..ToString().GetHasdCode也是可以的.  回复
   # re: 给你的类重写Equals--检测Class是否相等 2006-05-10 16:03 | Sunny
38 //在这里使用运算符重载,主要是为了进一步演示Equals
39 public static bool operator ==(object c1, Class2 c2)
40 {
41 return c1.GetHashCode().Equals( c2.GetHashCode() );
42 }
43
44 //当你重载了==运算符后,必须要重载!=运算符
45 public static bool operator !=(object c1, Class2 c2)
46 {
47 return c1.GetHashCode().Equals( c2.GetHashCode() );
48 }

一模一样，肯定有错误啊！！  回复