重写Object的虚方法——重写Equals和运算符

Object是所有类的顶级父类，而Object又提供了四个虚方法：

Equals , GetHashCode, ToString, Finalize。

那么在这个系列文章中，我们就看下，我们对这四个方法的利用。

首先是引用类型重写Equals，我分成三步：

1. 空值验证

2. 类型验证

3. 比较验证

代码如下：

class Person
{
public string Name { get; set; }
public int Age { get; set; }
public City MyCity { get; set; }
public override bool Equals(object obj)
{
if (obj == null)
{
return false;
}
if (obj.GetType() != this.GetType())
{
return false;
}
Person personTemp = obj as Person;
if (!Object.Equals(this.MyCity, personTemp.MyCity))
{
return false;
}
if (this.Age != personTemp.Age || this.Name != personTemp.Name)
{
return false;
}
return true;
}
}

在此需要注意的是，在比较引用类型属性的值是，需要使用Object的静态方法去比较，主要是为了防止属性值为null而抛出异常。我们来看下Object的静态Equals实现就明白了：

public static bool Equals(object objA, object objB)
{
return ((objA == objB) || (((objA != null) && (objB != null)) && objA.Equals(objB)));
}

呵呵，很漂亮的实现。解释一下，其实就是首先比较两者是否指向同一块引用，然后判断两者是否都不为空，最后来调用类型的Equals重写方法。

接下来，我们看下，如果这个时候我们实现了一个Person类的子类，我们该怎么写？

class Programmer:Person
{
public int CodeRowCount { get; set; }
public override bool Equals(object obj)
{
if (!base.Equals(obj)) { return false; }
Programmer pTemp = (Programmer)obj;
if (pTemp.CodeRowCount != this.CodeRowCount) { return false; }
return true;
}
}

来简单解释一下，由于Person已经判断了obj是否为空啊，类型是否相等，基类的字段是否相等，因此我们不需要再操心了，我们只需要比较子类独有的字段是否相等即可。

这里我们强调下，在Object默认的Equals实现中，比较的是两个对象是否指向了同一个引用，因此，如果我们的父类没有重写Equals方法，那么我们的这个版本将永远都是错误的，因此，我们也可以看出实现Equals方法的重要性吧，呵呵！

最后是值类型（主要是结构体）的重写Equals的方法，首先让我们看看所有值类型的父类System.ValueType对于Equals的实现：

public override bool Equals(object obj)
{
if (obj == null)
{
return false;
}
RuntimeType type = (RuntimeType)base.GetType();
RuntimeType type2 = (RuntimeType)obj.GetType();
if (type2 != type)
{
return false;
}
object a = this;
if (CanCompareBits(this))
{
return FastEqualsCheck(a, obj);
}
FieldInfo[] fields = type.GetFields(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
for (int i = 0; i < fields.Length; i++)
{
object obj3 = ((RtFieldInfo)fields[i]).InternalGetValue(a, false);
object obj4 = ((RtFieldInfo)fields[i]).InternalGetValue(obj, false);
if (obj3 == null)
{
if (obj4 != null)
{
return false;
}
}
else if (!obj3.Equals(obj4))
{
return false;
}
}
return true;
}

方法很长，我来解释一下：

首先，依然是来判断obj是否为空；

接下来，来得到两个对象的类型，在这里出现了一个类是RuntimeType，我们Reflector下这个类：





是一个Internal类型，程序集外无法访问，但是我们通过名称和其中的属性和方法名大概可以猜出，这是一个用于针对运行时反射而专门设计的类型。

接下来出现了CanCompareBits，FastEqualsCheck这两个方法，在Reflector中无法看到实现，但是根据方法名，我猜想应该是判断这个对象是否可以按位比较（我不是很理解，是指的序列化么？），如果可以的话，直接按位比较，这样的效率会比较高。（个人猜测，希望大家指点）

最后就是通过反射得到该对象中所有的属性，然后一一比较，不再赘述。

由此我们可以得知，System.ValueType以及为我们提供了很完善的实线，我们几乎不需要为之操心了，不过我们应该想到，在基类的实现中，这样的反射必定会浪费性能。那么我们的办法是为我们的结构体专门定制一个强类型的Equals方法：

struct ITWorker
{
public string name;
public int age;
public City city;
public override bool Equals(object obj)
{
if (! (obj is ITWorker)) { return false; }
return this.Equals((ITWorker)obj);
}
private bool Equals(ITWorker worker)
{
if (!Object.Equals(this.city, worker.city))
{
return false;
}
if (!this.name.Equals(worker.name) || ! (this.age != worker.age))
{
return false;
}
return true;
}
}

合理重写了Equals方法后，我们的事情还不算结束，我们知道，C#提供了重载运算符的功能，而==和!=也经常被人所使用，而且经常用于和Equals相同的场合。那么我们就有必要再重写Equals的同时，重载运算符。

public static bool operator ==(Person p1, Person p2)
{
return p1.Equals(p2);
}
public static bool operator !=(Person p1, Person p2)
{
return !(p1.Equals(p2));
}

就是这么简单。OK。原以为大功告成了，可是看看我的代码却发现了我的Person下出现了让我头疼的波浪线。





提示的意思是说，我重写了Equals方法，但是却没有重写GetHashCode方法。

哎，太长了，把这篇文章拆开写了。