昨天我在新手区发了一篇《重载还是覆写？》的随笔，后来我发现我犯了一个严重的错误，没有具体说明是.NET 1.1还是2.0，在.NET2.0中由于泛型的出现，对重载和覆写有时候就不能按照1.1下那几个特征去要求。

1．重载（Overload）

在.NET1.1下，我们定义重载：类中定义的方法可能有不同的版本，它具有如下的特征：

I.           方法名必须相同

II.         参数列表必须不相同，与参数列表的顺序无关

III.       返回值类型可以不相同

示意代码：

public class MyClass
{
    public void Write(string _str)
    { 
        //
    }
    public void Write(string _str, string _target)
    { 
        //
    }
    public bool Write(string _str, string _target, bool _flag)
    { 
        //
    }
}

在.NET2.0下，由于泛型的出现，我们就不能再用这三个特征来判断重载，如下面的两个方法，它们具有相同的方法名，相同的参数列表，相同的返回值，但是它们却可以构成重载：

public class MyClass
{
    public void Write<T>(string _str)
    { 
        //
    }
    public void Write(string _str)
    { 
        //
    }
}

再看下面这两个方法，它们不能构成重载，因为如果T，U如果实例化时传入相同的类型，则这两个方法就具有相同的签名：

public class MyClass8<T,U>
{
    public T MyMothed(T a, U b)
    {
        return a;
    }
    public U MyMothed(U a, T b)
    {
        return b;
    }
}

但是当我们再添加另外一个方法后，这个类却可以编译通过：

public class MyClass8<T,U>
{
    public T MyMothed(T a, U b)
    {
        return a;
    }
    public U MyMothed(U a, T b)
    {
        return b;
    }
    public int MyMothed(int a, int b)
    {
        return a + b;
    }
}

通过调用可以发现，优先匹配的方法是一般方法，而非泛型方法。总之，构成重载的第二个特征参数列表必须不同，其实是让方法具有不同的签名，调用程序可以区分，在有泛型时要特别注意，而第一点和第三点仍然适用。

2．覆写（Override）

在.NET1.1下，对覆写我们的定义是：子类中为满足自己的需要来重复定义某个方法的不同实现，它具有如下特征：

I.           通过使用关键字Override来覆写

II.         只有虚方法和抽象方法直接可以被覆写

III.       相同的方法名

IV.       相同的参数列表

V.         相同的返回值类型

示意代码：

public abstract class BaseClass
{
    public abstract void Write(string _str);
}
public class SubClass : BaseClass
{
    public override void Write(string _str)
    {
        //
    }
}

在.NET2.0中，泛型方法的覆写，除了要遵守以上几点外，还应该注意：

在重写定义了泛型参数的虚拟方法时，子类方法必须重新定义该方法特定的泛型参数：

public class MyBaseClass
{
    public virtual void MyMothed<T>(T t)
    {
        //  
    }
}
public class MySubClass : MyBaseClass
{
    public override void MyMothed<T>(T t)//重新定义泛型参数T
    {
        // 
    }
}

在重写定义了泛型参数的虚拟方法时，子类实现不能重复在基类方法级别出现的约束：

public class MyBaseClass
{
    public virtual void MyMothed<T>(T t) where T : new()
    { 
        //  
    }
}
public class MySubClass:MyBaseClass
{
    public override void MyMothed<T>(T t)//不能重复任何约束
    {
       // 
    }
}