C#范型概念和特点

范型的设计是为了解决上面提到过的Object的多态性设计中的两个问题： 
(1)，性能上面的，boxing和unboxing需要大量的复制开销； 
(2)，安全性上面的，在上面一个例子看到了如果unboxing类型不同会抛出一个InvalidCastException异常; 范型的设计格式是使用<和>封闭其中一个范型参数，例如： 
public class Stack<T>; 
范型的实例化格式是使用需要使用的类型替换<和>封闭其中一个范型参数,例如： 
Stack<char> char_Stack = new Stack<char>(); 
多范型类定义格式，在<和>封闭多个范型参数，例如： 
class Node<K,T> 
对于C++程序员，看上面关于范型的格式很快联系到了ISO C++当中的Template; 的确两者语法上面非常相似，但是两者的多态性编译和实现有很大不同． 在C++的Template编译后，没有编译带有Template的代码．而是通过一种宏的方式进行的替换过程． 每次使用Template类型，编译器都会生成一个对应的类型代码．而不管是否个类型代码已经使用过了，中国自学编程网，www.zxbc.cn． 
在C#2.0中范型是在中间语言(IL)和公共语言运行时(CLR)支持的．对于值类型：会在JIT编译时候替换参数类型，如果存在以及编译特定类型的机器代码，将直接返回这段代码．这样避免了在ISO C++中Template可能带来代码膨胀． 
对于引用类型：会直接在JIT编译时候替换参数类型． 
理解C# 2.0范型是在实现是基于CLR支持的很重要啊，因为.NET的本质是和语言无关的．任何语言最后都是编译为中间语言，这样基于IL和CLR支持的范型可以运用到所有基于CLR实现的语言，例如：Visual Basic 2005等等． 
３，范型和其他类型执行效率对比例子 
下面分别是使用Int,Object和范型构造的３个栈的类 
 /// <summary> 
 /// Int类型实现的栈 
 /// </summary> 
 class IntStack 
 { 
  private int[] data; 
  private int current; 
  private int length; 
  public IntStack(int Length) 
  { 
   length = Length; 
   current = 0; 
   data = new int[length]; 
  } 
  public int Top() 
  { 
   return data[current - 1]; 
  } 
  public void Push(int Data) 
  { 
   if (current < length) 
   { 
    data[current++] = Data; 
   } 
  } 
  public void Pop()   

{ 
   if (current > 0) 
   { 
    current--; 
   } 
  } 
 } 
 /// <summary> 
 /// 范型的栈 
 /// </summary> 
 /// <typeparam name="T">范型</typeparam> 
 class TemplateStack<T> 
 { 
  private int length; 
  private int current; 
  private T[] data; 
  public TemplateStack(int Length) 
  { 
   current = 0; 
   length = Length; 
   data = new T[length]; 
  } 
  public T Top() 
  { 
   return data[current - 1]; 
  } 
  public void Push(T Data) 
  { 
   if (current < length) 
   { 
    data[current++] = Data; 
   } 
  } 
  public void Pop() 
  { 
   if (current > 0) 
   { 
    current--; 
   } 
  } 
 } 
 /// <summary> 
 /// Object的栈 
 /// </summary> 
 class ObjectStack 
 { 
  private object[] data; 
  private int current; 
  private int length; 
  public ObjectStack(int Length) 
  { 
   length = Length; 
   current = 0; 
   data = new object[length]; 
  } 
  public object Top() 
  { 
   return data[current-1]; 
  } 
  public void Push(object Data) 
  { 
   if (current < length) 
   { 
    data[current++] = Data; 
   } 
  } 

public void Pop() 
  { 
   if (current > 0) 
   { 
    current--; 
   } 
  } 
 } 
通过测试直接使用Int的栈和范型构造Int栈的开销接近． 
而比较前面两个Object每增加一次unboxig开销是增加的2倍． 

执行这个操作时，程序将创建 TemplateStack类的新实例，其中的每个T都被提供的整数参数替换。实际上，当程序用整数参数创建 TemplateStack类的新实例时，在 TemplateStack类内部本地存储的项目数组将为整数，而不是对象。程序还消除了与将整数压入堆栈相关联的装箱问题。此外，当程序从堆栈弹出项目时，您无需将其显式转换为相应的类型，因为 Stack 类的当前特定实例会将整数本地存储在其数据结构中。
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
使用范型的优点：
        程序员只需要编写、测试、部署代码一次，即可以对不同的数据类型重复使用该代码。
        同时，编译器还会对范型进行检查。当程序使用提供的类型参数实例化范型类时，这个类型参数只能是程序在类定义中指定的类型。例如，如果程序创建了一个 Customer 对象类型的 Stack，就无法将整数压入堆栈。通过强制执行这种操作，可以生成更可靠的代码。
        此外，与其他严格的类型实现相比，泛型的 C# 实现降低了代码的膨胀速度。使用泛型创建具有类型的集合，可以在保持操作性能优势的同时避免创建每个类的特定变体。例如，程序可以创建一个参数化的 Stack 类，而无需创建用于存储整数的 IntegerStack、用于存储字符串的 StringStack 以及用于存储 Customer 类型的 CustomerStack。

４，附录.NET 2.0 Framework 范型容器列表： 
Comparer<T> 　　　　　Comparer  　比较 
Dictionary<K,T>  　　 HashTable 　hash表 
LinkedList<T>         LinkList  　链表 
List<T>               ArrayList 　数组链表 
Queue<T>              Queue 　　　队列 
SortedDictionary<K,T> SortedList　排序链表 
Stack<T>              Stack 　　　栈 
ICollection<T>  ICollection 　　　容器接口 
IComparable<T>  System.IComparable比较接口 
IDictionary<K,T>  IDictionary  　 字典接口 
IEnumerable<T>  IEnumerable 　　　枚举接口 
IEnumerator<T>  IEnumerator 　　　跌代接口 
IList<T>  IList 　　　　　　　　　链表接口