30分钟泛型教程

一、泛型入门：

我们先来看一个最为常见的泛型类型List的定义
(真正的定义比这个要复杂的多，我这里删掉了很多东西)

[Serializable]
public class List : IList, ICollection, IEnumerable
{
    public T this[int index] { get; set; }
    public void Add(T item);
    public void Clear();
    public bool Contains(T item);
    public int IndexOf(T item);
    public bool Remove(T item);
    public void Sort();
    public T[] ToArray();
}

List后面紧跟着一个表示它操作的是一个未指定的数据类型
（T代表着一个未指定的数据类型）

可以把T看作一个变量名，T代表着一个类型，
在List的源代码中任何地方都能使用T

T被用作方法的参数和返回值
Add方法接收T类型的参数，ToArray方法返回一个T类型的数组

注意：

　　泛型参数应该以T开头，要么就叫T，要么就叫TKey、TValue之类的；
　　这跟接口要以I开头是一样的，这是约定。

下面来看一段使用泛型类型的代码

            var a = new List<int>();
            a.Add(1);
            a.Add(2);
            //这是错误的，因为你已经指定了泛型类型为int，就不能在这个容器中放入其他的值
            //这是编译器错误，更提升了排错效率，如果是运行期错误，不知道要多么烦人
            a.Add("3");
            var item = a[2];

请注意上面代码里的注释

二、泛型的作用(1)：

作为程序员，写代码时刻不忘代码重用。
代码重用可以分成很多类，其中算法重用就是非常重要的一类

假设你要为一组整型数据写一个排序算法，又要为一组浮点型数据写一个排序算法
如果没有泛型类型，你会怎么做呢？

你可能想到了方法的重载
写两个同名方法，一个方法接收整型数组，另一个方法接收浮点型的数组

但有了泛型，你就完全不必这么做，只要设计一个方法就够用了，你甚至可以用这个方法为一组字符串数据排序

三、泛型的作用(2)：

假设你是一个方法的设计者，
这个方法需要有一个输入参数，但你并能确定这个输入参数的类型
那么你会怎么做呢？

有一部分人可能会马上反驳：“不可能有这种时候！”
那么我会跟你说，编程是一门经验型的工作，你的经验还不够，还没有碰到过类似的地方。

另一部分人可能考虑把这个参数的类型设置成Object的
这确实是一种可行的方案
但会造成下面两个问题

如果我给这个方法传递整形的数据
（值类型的数据都一样）
就会产生额外的装箱、拆箱操作
造成性能损耗

如果你这个方法里的处理逻辑不适用于字符串的参数
而使用者又传了一个字符串进来
编译器是不会报错的，
只有在运行期才会报错
(如果质管部门没有测出这个运行期BUG，那么不知道要造成多大的损失呢)
这就是我们常说的：类型不安全

四、泛型的示例：

像List和Dictionary之类的泛型类型我们经常用到
下面我介绍几个不常用到的泛型类型

ObservableCollection
当这个集合发生改变后会有相应的事件得到通知
请看如下代码：

static void Main(string[] args)
{
    var a = new ObservableCollection<int>();
    a.CollectionChanged += a_CollectionChanged;
}

static void a_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
    //可以通过Action来判断是什么操作触发了事件
    //e.Action == NotifyCollectionChangedAction.Add

    //可以根据以下两个属性来得到更改前和更改后的内容
    //e.NewItems;
    //e.OldItems;
}

使用这个集合需要引用如下两个名称空间

using System.Collections.ObjectModel;
using System.Collections.Specialized;

 

BlockingCollection是线程安全的集合
来看看下面这段代码

var bcollec = new BlockingCollection<int>(2);
//试图添加1-50
Task.Run(() =>
{
    //并行循环
    Parallel.For(1, 51, i =>
    {
        bcollec.Add(i);
        Console.WriteLine("加入：" + i);
    });
});

Thread.Sleep(1000);
Console.WriteLine("调用一次Take");
bcollec.Take();

//等待无限长时间
Thread.Sleep(Timeout.Infinite);

输出结果为：

加入：1
加入：37
调用一次Take
加入：13

BlockingCollection还可以设置CompleteAdding和IsCompleted属性来拒绝加入新元素
.NET类库还提供了很多的泛型类型，在这里就不一一例举了

五、泛型的继承：

在.net中一切都继承自Object
泛型也不例外
泛型类型可以继承自其他类型
来看一下如下代码

public class MyType
{
    public virtual string getOneStr()
    {
        return "base object Str";
    }
}
public class MyOtherType : MyType
{
    public override string getOneStr()
    {
        return typeof(T).ToString();
    }
}
class Program
{
    static void Main(string[] args)
    {
        MyType target = new MyOtherType<int>();
        Console.WriteLine(target.getOneStr());
        Console.ReadKey();
    }
}

泛型类型MyOtherType成功的重写了非泛型类型MyType的方法
如果我试图按如下方式从MyOtherType类型派生子类型就会导致编译器错误

//编译期错误
public class MyThirdType : MyOtherType
{
}

但是如果写成这种方式，就不会出错

    public class MyThirdType : MyOtherType<int>
    {
        public override string getOneStr()
        {
            return "MyThirdType";
        }
    }

如果一个方法接收MyThirdType类型的参数，
那么不能将一个MyOtherType的实例传递给这个方法
然而一个方法如果接收MyOtherType类型的参数
却可以把MyThirdType类型的实例传递给这个方法
写成如下方式也不会出错

    public class MyThirdType : MyOtherType
    {
        public override string getOneStr()
        {
            return typeof(T).ToString() + " from MyThirdType";
        }
    }

此中诀窍，只可意会，不可言传

六、泛型接口

.NET类库里有很多泛型的接口
比如：IEnumerator、IList等
这里不对这些接口做详细描述了
值说说为什么要有泛型接口。

其实泛型接口出现的原因和泛型出现的原因类似
拿IComparable这个接口来说，
此接口只描述了一个方法：

int CompareTo(object obj);

大家看到，如果是值类型的参数，势必会导致装箱和拆箱操作
同时，也不是强类型的，不能在编译期确定参数的类型
有了IComparable就解决掉这个问题了

int CompareTo(T other);

七、泛型委托

委托描述方法，
泛型委托的由来和泛型接口类似

定义一个泛型委托也比较简单：

public delegate void MyAction(T obj);

这个委托描述一类方法
这类方法接收T类型的参数，没有返回值
来看看使用这个委托的方法

public delegate void MyAction(T obj);
static void Main(string[] args)
{
    var method = new MyAction<int>(printInt);
    method(3);
    Console.ReadKey();
}
static void printInt(int i)
{
    Console.WriteLine(i);
}

由于定义委托比较繁琐
.NET类库在System名称空间，下定义了三种比较常用的泛型委托

Predicate委托：

public delegate bool Predicate(T obj);

这个委托描述的方法为接收一个T类型的参数，返回一个BOOL类型的值，一般用于比较方法

Action委托

public delegate void Action(T obj);

public delegate void Action(T1 arg1, T2 arg2);

这个委托描述的方法，接收一个或多个T类型的参数（最多16个，我这里只写了两种类型的定义方式），没有返回值

Func委托

public delegate TResult Func();

public delegate TResult Func(T arg);

这个委托描述的方法，接收零个或多个T类型的参数（最多16个，我这里只写了两种类型的定义方式），
与Action委托不同的是，它有一个返回值，返回值的类型为TResult类型的

关于委托的描述，您还可以看我这篇文章
30分钟LINQ教程

八、泛型方法

泛型类型中的T可以用在这个类型的任何地方
然而有些时候，我们不希望在使用类型的时候就指定T的类型
我们希望在使用这个类型的方法时，再指定T的类型
来看看如下代码：

    public class MyClass
    {
        public TParam CompareTo(TParam other)
        {
            Console.WriteLine(other.ToString());
            return other;
        }
    }

上面的代码中MyClass并不是一个泛型类型
但这个类型中的CompareTo()却是一个泛型方法
TParam可以用在这个方法中的任何地方。

使用泛型方法一般用如下代码就可以了：

obj.CompareTo<int>(4);
obj.CompareTo<string>("ddd");

然而，你可以写的更简单一些，写成如下的方式

obj.CompareTo(2);
obj.CompareTo("123");

有人会问：“这不可能，没有指定CompareTo方法的TParam类型，肯定会编译出错的”
我告诉你：不会的，编译器可以帮你完成类型推断的工作。

注意：
如果你为一个方法指定了两个泛型参数，而且这两个参数的类型都是T，
那么如果你想使用类型推断，你必须传递两个相同类型的参数给这个方法
不能一个参数用string类型，另一个用object类型，这会导致编译错误。

九、泛型约束

我们设计了一个泛型类型
很多时候，我们不希望使用者传入任意类型的参数
也就是说，我们希望“约束”一下T的类型
来看看如下代码：

    public class MyClass where T : IComparable
    {
        public int CompareTo(T other)
        {
            return 0;
        }
    }

上面的代码要求T类型必须实现了IComparable接口
如你所见：泛型的约束通过关键字where来实现。

泛型方法当然也可以通过类似的方式对泛型参数进行约束
请看如下代码：

public class MyClass
{
    public TParam CompareTo(TParam other) where TParam:class
    {
        Console.WriteLine(other.ToString());
        return other;
    }
}

上面代码中用了class关键字约束泛型参数TParam；具体稍后解释。

注意1：
如果我有一个类型也定义为MyClass但没有做约束，
那么这个时候，做过约束的MyClass将与没做约束的MyClass冲突，编译无法通过

注意2：
当你重写一个泛型方法时，如果这个方法指定了约束
在重写这个方法时，不能再指定约束了

注意3：
虽然我上面的例子写的是接口约束，但你完全可以写一个类型，比如说BaseClass
而且，只要是继承自BaseClass的类型都可以当作T类型使用，你不要试图约束T为Object类型，编译不会通过的。（傻子才这么干）

注意4：
有两个特殊的约束：class和struct。
where T : class   约束T类型必须为引用类型
where T : struct  约束T类型必须为值类型

注意5：
如果你没有对T进行class约束，
那么你不能写这样的代码：T obj = null;  这无法通过编译，因为T有可能是值类型的。
如果你没有对T进行struct约束，也没有对T进行new约束
那么你不能写这样的代码：T obj = new T();  这无法通过编译，因为值类型肯定有无参数构造器，而引用类型就不一定了。
如果你对T进行了new约束：where T : new();  那么new T()就是正确的，因为new约束要求T类型有一个公共无参构造器。

注意6：
就算没有对T进行任何约束，也有一个办法来处理值类型和引用类型的问题
T temp = default(T);
如果T为引用类型，那么temp就是null；如果T为值类型，那么temp就是0；

注意7：
试图对T类型的变量进行强制转化，一般情况下会报编译期错误。
但你可以先把T转化成object再把object转化成你要的类型（一般不推荐这么做，你应该考虑把T转化成一个约束兼容的类型）
你也可以考虑用as操作符进行类型转化，这一般不会报错，但只能转化成引用类型。

关于泛型约束的内容，我在这篇文章里也有提到
30分钟linq教程

十、逆变和协变

 一般情况下，我们使用泛型时，由T标记的泛型类型是不能更改的
也就是说,如下两种写法都是错误的

var a = new List<object>();
List<string> b = a;
var c = new List<string>();
List<object> d = c;

注意：这里没有写强制转换，即使写了强制转换也是错误的，编译就无法通过

然而泛型提供了逆变和协变的特性，
有了这两种特性，这种转换就成为了可能。

逆变：
泛型类型T可以从基类型更改为该类的派生类型，
用in关键字标记逆变形式的类型参数，
而且这个参数一般作输入参数。

协变：
泛型类型T可以从派生类型更改为它的基类型，
用out关键字来标记协变形式的类型参数，
而且这个参数一般作为返回值

如果我们定义了一个这样的委托：

public delegate TResult MyAction<in T,out TResult>(T obj);

那么，就可以让如下代码通过编译（不用强制转换）

var a = new MyAction<object, ArgumentException>(o => new ArgumentException(o.ToString()));
MyAction<string, Exception> b = a;

这就是逆变和协变的威力。

注意：
只有接口和委托的泛型类型才可以使用逆变和协变的特性

参考资料

Mgen的博客
CLR VIA C#(第三版)

修改记录：

2013.4.21完成了一半的内容

2013.4.28完成了全部内容，修改了一些错别字

2013.4.29增加了一大部分内容，修改了排版样式

2013.5.3修改了一个错别字，增加了逆变和协变的注意。

2013.5.5修改了泛型的集成小节中的“注意”环节

2013.5.6修改了泛型命名的约定那里的措辞