我们先来看一个最为常见的泛型类型List<T>的定义

(真正的定义比这个要复杂的多，我这里删掉了很多东西)

[Serializable]  
public class List<T> : IList<T>, ICollection<T>, IEnumerable<T>  
{  
    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看作一个变量名，T代表着一个类型，在List<T>的源代码中任何地方都能使用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<T>和Dictionary<TKey,TValue>之类的泛型类型我们经常用到，下面我介绍几个不常用到的泛型类型。

ObservableCollection<T>

当这个集合发生改变后会有相应的事件得到通知。

请看如下代码：

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<int>是线程安全的集合

来看看下面这段代码

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<int>还可以设置CompleteAdding和IsCompleted属性来拒绝加入新元素。

.NET类库还提供了很多的泛型类型，在这里就不一一例举了。

五、泛型的继承：

在.net中一切都继承字Object，泛型也不例外，泛型类型可以继承自其他类型。

来看一下如下代码

public class MyType  
{  
    public virtual string getOneStr()  
    {  
        return "base object Str";  
    }  
}  
public class MyOtherType<T> : 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<T>成功的重写了非泛型类型MyType的方法。

如果我试图按如下方式从MyOtherType<T>类型派生子类型就会导致编译器错误。

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

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

public class MyThirdType : MyOtherType<int>  
 &nbs