目录
- 创建泛型类
- 泛型类的特性
- 泛型接口
- 泛型方法
- 泛型委托
泛型并不是一个全新的结构，其他语言中也有类似的概念，比如C++中的模板，但C++中的模板和.NET中的泛型还是有很的的区别的，下面就对泛型做些研究。
- 创建泛型类
学习数据结构时，最为常见的就是链表，我们就以链表为例来描述泛型类创建的细节。首先，我们知道，链表是由不定数目的结点连接而成的，结点中有数据字段和指向下一个或上一个结点的对象应用，下面是双向链表结点类型代码：
public class LinkedListNode { public LinkedListNode(Object value) { this.value = value; } //结点数据值 private object value; public object Value { get { return this.value; } } //双向结点指向引用 private LinkedListNode next; private LinkedListNode pre; public LinkedListNode Next { get { return this.next; } internal set { this.next = value; } } public LinkedListNode Pre { get { return this.pre; } internal set { this.pre = value; } } }
其中，结点的数据存储在Object类型的Value字段中。下面我们来创建链表类，该链表类有一个头结点、尾结点和在链表的末尾添加/删除结点的方法：
//双向链表类 public class LinkedList { //头结点 private LinkedListNode head; public LinkedListNode Head { get { return this.head; } } //尾结点 private LinkedListNode last; public LinkedListNode Last { get { return this.last; } } //在链表尾插入结点 public LinkedListNode AddNode(Object value) { LinkedListNode node = new LinkedListNode(value); if (head == null) { head = node; last = head; } else { last.Next = node; node.Pre = last; last = node; } return last; } //在链表尾删除结点 public LinkedListNode SubNode() { if (last == null) { return null; } else { LinkedListNode node = last.Pre; node.Next = null; last = node; } return last; } }
因为是链表，所以我们希望能使用foreach遍历链表，那么，将链表类LinkedList继承IEnumerable接口并实现GetEnumerator()方法：
public class LinkedList : IEnumerable { ... public IEnumerator GetEnumerator() { LinkedListNode curr = head; while (curr != null) { yield return curr.Value; curr = curr.Next; } } }
全部代码：
这样我们就可以使用链表了，但该链表中的存储数据只能使Object类型的，这就并不能保证链表中的数据是类型统一的，因此在使用foreach遍历链表时可能出现致命的错误。比如该链表中有整形数据和字符串数据。而且，该链表并不能够为我们提供一个标准的模板。
下面，我们改进LinkedListNode结点类，使其使用泛型——存储数据的类型使我们任意指定的类型：
public class LinkedListNode<T> { public LinkedListNode(T value) { this.value = value; } //结点数据值 private T value; public T Value { get { return this.value; } } //双向结点指向引用 private LinkedListNode<T> next; private LinkedListNode<T> pre; public LinkedListNode<T> Next { get { return this.next; } internal set { this.next = value; } } public LinkedListNode<T> Pre { get { return this.pre; } internal set { this.pre = value; } } }
同样，也需要将链表类改为泛型类：
public class LinkedList<T> : IEnumerable<T> { //头结点 private LinkedListNode<T> head; public LinkedListNode<T> Head { get { return this.head; } } //尾结点 private LinkedListNode<T> last; public LinkedListNode<T> Last { get { return this.last; } } //在链表尾插入结点 public LinkedListNode<T> AddNode(T value) { LinkedListNode<T> node = new LinkedListNode<T>(value); if (head == null) { head = node; last = head; } else { last.Next = node; node.Pre = last; last = node; } return last; } //在链表尾删除结点 public LinkedListNode<T> SubNode() { if (last == null) { return null; } else { LinkedListNode<T> node = last.Pre; node.Next = null; last = node; } return last; } #region IEnumerable 成员 public IEnumerator<T> GetEnumerator() { LinkedListNode<T> curr = head; while (curr != null) { yield return curr.Value; curr = curr.Next; } } IEnumerator IEnumerable.GetEnumerator() { return GetEnumerator(); } #endregion }
这样我们就保证了链表中数据的统一性，因此可以安全的使用foreach遍历链表了。
其实，我个人认为，泛型也就是我们在编写代码时并不知道要使用的数据类型是什么，而是在使用代码时规定数据类型的，这样，我们就很容易的创建复用的模板代码，即减少了代码编写的工作，也节省了空间资源。
- 泛型类特性
到此为止，相信大家已经对泛型有了较为具体的概念了，接下来，继续我们的研究。
(1)默认值
我们知道，泛型类中，可以使用任意数据类型，比如引用类型和值类型。那么泛型有没有默认只呢？很显然，我们不能单纯的只将null赋值给泛型——非可空值类型的默认值并不是null。
这里我们可以用——default——关键字来获取泛型的默认值(null或0)来初始化泛型，格式如下：
public class LinkedListNode<T> { public LinkedListNode(T value) { this.value = default(T); ... } //结点数据值 private T value; ... }
(2)约束
我们的链表可以使用foreach进行遍历了，但作为集合类，可能还需要排序等功能，那么就需要结点与结点之间也能进行比较，这样我们就需要将节点类实现IComparable<T>泛型接口了，具体代码如下：
public class LinkedListNode<T> : IComparable<LinkedListNode<T>> { ... #region IComparable<LinkedListNode<T>> 成员 public int CompareTo(LinkedListNode<T> other) { return other.value.CompareTo(other.value); } #endregion }
这样我们就可以在值类型结点与结点之间直接比较大小了。但是，我们又会发现另一个问题——如果泛型T数据类型不是值类型的或是较为复杂的引用类型时(换句话说就是该数据类型对象之间不能直接比较)，那么结点之间的直接比较就会出错了，怎么办？当然，我们只需要给T类型的数据添加一个约束就行了：
public class LinkedListNode<T> : IComparable<LinkedListNode<T>> where T:IComparable<T> { ... }
同样，泛型链表类也需要添加约束：
public class LinkedList<T> : IEnumerable<T> where T:IComparable<T> { ... }
添加约束后，这样结点与结点之间直接比较就有了安全保障了。上述代码中，我们给泛型数据类型T添加约束后，就规定在使用链表时必须传入已经实现了IComparable<T>泛型接口的数据类型。
(3)继承
泛型类型可以实现泛型接口，也可以派生于一个类。
泛型类型可以派生与泛型基类，但必须要求重复泛型类型或必须指定基类的泛型类型：
public class Base<T> { ... } public class MyClass<T> : Base<T> { ... } 或者 public class MyClass<T> : Base<int> { ... }
另外，如果指定了泛型基类的数据类型，就可以被泛型类和非泛型类继承，其实道理很简单，当泛型类指定了泛型数据类型时就和普通的类没什么区别了，当然就可以被其他类继承了。
注意：泛型类也可以是抽象类，然后派生其他类。
(4)静态成员
我们知道，非泛型类中的静态数据成员是类所专有的，从这个类创建的所有对象都可以使用它。那么泛型类的静态数据成员就比非泛型类有趣多了。
首先，我们来定义一个泛型类：
public class Base<T> { public static int x; }
然后我们这样赋值：
Base<String> .x = 4;
Base<int> .x = 5;
那么，"x" 的值到底是4还是5呢？对于上面Base<T>的两句赋值语句，"x"的值分别是Base<String >的4和Base<int>的5.，而并不是Base<T>类独有的。也就是说，Base<String >和Base<int>各自都有自己独有的X静态成员，两者之间并不混淆。
- 泛型接口
上面的链表中，我们使用好几个泛型接口了，在使用泛型接口时个人认为和泛型类用户几乎形同，这里就不再罗嗦了。
- 泛型方法
将泛型应用与方法，可以得到一些很了不起的效果，下面还以以一个列子说明，就那最简单的两个数据交换函数吧，我们可以这样的定义该泛型方法：
public void Swap<T>(ref T x, ref T y) { T tmp = x; x = y; y = tmp; }
这样，所有的数据类型都可以使用这个函数来交换数据了，是不是很有趣。这就大大减少了C++中函数重载的代码重写过程。在调用泛型时，也很简单：
int i = 1, j = 0;
Swap<T>(ref i, ref j);
其实，我们也可以像非泛型方法那样调用泛型方法——因为，C#编译器会通过调用泛型方法来获取参数类型：
Swap(ref i, ref j);
- 泛型委托
我们知道，委托是类型安全的方法的引用，通过泛型委托，委托的参数可以以后定义，不如.NET库中定义的事件泛型委托:
public sealed delegate void EventHandler<TEventArgs>(object sender, TEventArgs e) where TEventArgs : EventArgs;
它的第二个参数是TEventArgs泛型类型，并且将该泛型类型添加了约束——就规定了TEventArgs泛型类型必须派生自EventArgs类。
接下来，我们看看一个例子，说明泛型委托的好处：
首先创建一个个人账户信息类（只包含姓名和工薪字段）：
public class Account { private String name; public String Name { get { return name; } } private decimal balance; public decimal Balance { get { return balance; } } public Account(String name, Decimal balance) { this.name = name; this.balance = balance; } }
然后再创建一个统计所有薪水的类：
public class Algorithm { public decimal AccumulateSimple(IEnumerable e) { decimal sum = 0; foreach(Account a in e) { sum += a.Balance; } return sum; } }
主函数中这样的调用：
class Program { static void Main() { List<Account> accounts = new List<Account>(); accounts.Add(new Account("Name1", 2500)); accounts.Add(new Account("Name2", 4500)); accounts.Add(new Account("Name3", 2000)); Algorithm alg = new Algorithm(); alg.AccumulateSimple(accounts); } }
但是，这样我们会发现，这只能统计Account类型的数据了，接下来使用泛型委托灵活的改变统计的范围了。
public delegate TSummary Action<TInput, TSummary>(TInput t, TSummary s);//定义一个泛型委托
然后再在Algorithm 类中定义一个泛型方法：
public TSummary Accumulate<TInput, TSummary>(IEnumerable<TInput> coll, Action<TInput, TSummary> action) { TSummary sum = default(TSummary); foreach (TInput input in coll) { sum = action(input, sum); } return sum; }
最后，我们就可以在Main函数中这样调用了：
alg.Accumulate<Account, decimal>(accounts, delegate(Account a, decimal d) { return a.Balance + d; });
上述代码中使用了匿名委托，大家没有忘记吧。
本例代码：
最后：
本文中，有大量了代码，本人个人认为，代码的表现力远远超出了语言所能表达的含义，因为我喜欢代码给我的直观感觉。
好了，下篇该整理集合了，主要是描述列表，队列，栈，链表，有序表，字典，LookUp，HashSet，位数组等数据类型，下回见。