实现Equals方式有3种不同的方式：
1）为基类没有重写Object.Equals方法的引用类型实现Equals
class MyRefType : BaseType
{
RefType refobj; // This field is a reference type.
ValType valobj; // This field is a value type.
public override Boolean Equals(Object obj)
{
// Because ’this’ isn’t null, if obj is null,
// then the objects can’t be equal.
if (obj == null) return false;
// If the objects are of different types, they can’t be equal.
if (this.GetType() != obj.GetType()) return false;
// Cast obj to this type to access fields. NOTE: This cast can’t
// fail because you know that objects are of the same type.
MyRefType other = (MyRefType) obj;
// To compare reference fields, do this:
if (!Object.Equals(refobj, other.refobj)) return false;
// To compare value fields, do this:
if (!valobj.Equals(other.valobj)) return false;
return true; // Objects are equal.
}
// Optional overloads of the == and != operators
public static Boolean operator==(MyRefType o1, MyRefType o2)
{
if (o1 == null) return false;
return o1.Equals(o2);
}
public static Boolean operator!=(MyRefType o1, MyRefType o2)
{
return !(o1 == o2);
}
}
2） 为基类没有重写Object.Equals方法的引用类型实现Equals方法
class MyRefType : BaseType
{
RefType refobj; // This field is a reference type.
ValType valobj; // This field is a value type.
public override Boolean Equals(Object obj)
{
// Let the base type compare its fields.
if (!base.Equals(obj)) return false;
// All the code from here down is identical to
// that shown in the previous version.
// Because ’this’ isn’t null, if obj is null,
// then the objects can’t be equal.
// NOTE: This line can be deleted if you trust that
// the base type implemented Equals correctly.
if (obj == null) return false;
// If the objects are of different types, they can’t be equal.
// NOTE: This line can be deleted if you trust that
// the base type implemented Equals correctly.
if (this.GetType() != obj.GetType()) return false;
// Cast obj to this type to access fields. NOTE: This cast
// can’t fail because you know that objects are of the same type.
MyRefType other = (MyRefType) obj;
// To compare reference fields, do this:
if (!Object.Equals(refobj, other.refobj)) return false;
// To compare value fields, do this:
if (!valobj.Equals(other.valobj)) return false;
return true; // Objects are equal.
}
// Optional overloads of the == and != operators
public static Boolean operator==(MyRefType o1, MyRefType o2)
{
if (o1 == null) return false;
return o1.Equals(o2);
}
public static Boolean operator!=(MyRefType o1, MyRefType o2)
{
return !(o1 == o2);
}
}
这里和上面唯一的差别是这里要求比较基类型中定义的字段，若基类型认为对象不相等，那么它们就不相等。
若base.Equals会导致调用Object.Equals方法，那么就不应该再调用它，因为只有在两个引用指向同一个对象，Object.Equals方法才会返回true.所以，若这样，我们实现的Equals方法就会总是返回false!!
3） 为值类型实现Equals方法
System.ValueType.Equals方法在内部首先使用反射机制来得到类型所有的实例字段，然后再比较它们是否相等，这就意味着值类型继承的Equals判断的是值相等。
下面是System.ValueType.Equals方法的实现：
class ValueType
{
public override Boolean Equals(Object obj)
{
// Because ’this’ isn’t null, if obj is null,
// then the objects can’t be equal.
if (obj == null) return false;
// Get the type of ’this’ object.
Type thisType = this.GetType();
// If ’this’ and ’obj’ are different types, they can’t be equal.
if (thisType != obj.GetType()) return false;
// Get the set of public and private instance
// fields associated with this type.
FieldInfo[] fields = thisType.GetFields(BindingFlags.Public |
BindingFlags.NonPublic | BindingFlags.Instance);
// Compare each instance field for equality.
for (Int32 i = 0; i < fields.Length; i++)
{
// Get the value of the field from both objects.
Object thisValue = fields[i].GetValue(this);
Object thatValue = fields[i].GetValue(obj);
// If the values aren’t equal, the objects aren’t equal.
if (!Object.Equals(thisValue, thatValue)) return false;
}
// All the field values are equal, and the objects are equal.
return true;
}
}
尽管ValueType提供了比较好的Equals实现，但我们还应该自己实现，因为这样效率比较高，并且可以避免额外的装箱操作。
struct MyValType
{
RefType refobj; // This field is a reference type.
ValType valobj; // This field is a value type.
public override Boolean Equals(Object obj)
{
// If obj is not your type, then the objects can’t be equal.
if (!(obj is MyValType)) return false;
// Call the type-safe overload of Equals to do the work.
return this.Equals((MyValType) obj);
}
// Implement a strongly typed version of Equals.
public Boolean Equals(MyValType obj)
{
// To compare reference fields, do this:
if (!Object.Equals(this.refobj, obj.refobj)) return false;
// To compare value fields, do this:
if (!this.valobj.Equals(obj.valobj)) return false;
return true; // Objects are equal.
}
// Optionally overload operator==
public static Boolean operator==(MyValType v1, MyValType v2)
{
return (v1.Equals(v2));
}
// Optionally overload operator!=
public static Boolean operator!=(MyValType v1, MyValType v2)
{
return !(v1 == v2);
}
}
一个类如果重写了Equals方法，就必须也重写GetHashCode方法，这是因为System.Collection.HashTable类的实现要求任何两个相等的对象都必须要有相同的hash码值。所以若重写了Equals方法，我们就应该重写GetHashCode方法以确保用来判等的算法和用来计算对象hash码的算法一致。
当我们向一个HashTable中添加一个“键/值对”时，其中“键对象”的散列码会首先被获取，这个散列码指出了“键/值对”应该被存储在哪个“散列桶”中，当HashTable对象需要查找某个“键”时，它会取得指定“键对象”的散列码，然后在该散列码所标志的那个“散列桶“中进一步查找和指定的”键对象“相等的键对象。这就意味着若改变了HashTable中的一个”键对象“，就不能够在HashTable中找到该对象，若我们要改变一个散列表中的”键对象“，应该首先删除原来的”键/值对“，然后改变”键对象“，最后再把新的”键/值对“加到散列表中。
如果一个类不想作为基类被继承，又不想被实例化出对象，那么可以把类设置成sealed,并且将其构造函数的访问符设为private，定义了私有构造器就可以阻止编译器调用默认构造器，而类外也不能访问私有构造器，因此就不会新建对象。
Object的GetHashCode方法返回的是一个在应用程序域范围内确保唯一的数值，该数值在对象的整个生存期中保证不会改变，但是在对象执行垃圾收集后，这个唯一的数值可以被重新利用作为一个新的对象的散列值。而ValueType的GetHashCode方法则使用反射来返回类型中第一个字段的散列值。
选择散列码算法，应该遵循下列原则：
1） 应该使所得的数值有一个良好的随机分布
2） 可以调用基类型的GetHashCode方法，将它的返回值包含在代码中，但一般情况下，不应该调用Object或ValueType的GetHashCode方法，
3） 应该至少使用一个实例字段。
4） 算法中使用的字段应该是恒定不变的，也就是说在构造对象时字段被初始化后，它们就不应该再在对象的生存期内有任何改变。
5） 算法应该执行的尽可能快。
6） 有相同值的对象应该返回相同的散列码。
本文转自Phinecos(洞庭散人)博客园博客，原文链接：http://www.cnblogs.com/phinecos/archive/2006/09/06/496882.html，如需转载请自行联系原作者
611
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
