引言：

　　在上一个专题中介绍了C#2.0 中引入泛型的原因以及有了泛型后所带来的好处，然而上一专题相当于是介绍了泛型的一些基本知识的，对于泛型的性能为什么会比非泛型的性能高却没有给出理由，所以在这个专题就中将会介绍原因和一些关于泛型的其他知识。

一、泛型类型和类型参数

　　泛型类型和其他int,string一样都是一种类型，泛型类型有两种表现形式的：泛型类型（包括类、接口、委托和结构，但是没有泛型枚举的）和泛型方法。那什么样的类、接口、委托和方法才称作泛型类型的呢 ？我的理解是类、接口、委托、结构或方法中有类型参数就是泛型类型，这样就有类型参数的概念的。 类型参数 ——是一个真实类型的一个占位符（我想到一个很形象的比喻的，比如大家在学校的时候，一到中午下课的时候食堂人特别多的，所以很多应该都有用书本占位置的习惯的， 书本就相当于一个占位符，真真坐在位置上的当然是自己的，讲到占位置，以前听过我同学说，他们班有个很牛逼的MM，中午下完课的时候用手机占位子的，等它打完饭回来的时候手机已经不见， 当时听完我就和我同学说，你们班这位女生真牛逼的，后面我们就[C# 基础知识系列]专题七: 泛型深入理解(一) _泛型），泛型声明中，类型参数必须放在一对尖括号里面（即<>这个符号），并且用逗号分隔多个类型参数，如List<T>类中T就是类型参数，在使用泛型类型或方法的时候，我们要用真实类型来代替，就像用书本占位子一个，书本只是暂时的在那个位置上，等打好饭了就要换成你坐在位置上了，同样在C#中泛型也是同样道理，类型参数只是暂时的在那个位置，真真使用中要用真实的类型去代替它的位置，此时我们把真实类型又取名为类型实参，如上一专题的代码中List<int>，类型实参就是int(代替T的位置)。

　　如果没有为类型参数提供类型实参，此时我们就声明了一个未绑定的泛型类型，如果指定了类型实参，此时的类型就叫做已构造类型（这里同样可以以书占位置去理解），然而已构造类型又可以是开放类型或封闭类型的，这里先给出这个两个概念的定义的：开放类型——具有类型参数的类型就是开放类型（所有的未绑定的泛型类型都属于开放类型的），封闭类型——为每个类型参数都传递了实际的数据类型。对于开放类型，我们创建开放类型的实例。

　　注意:在C#代码中，我们唯一可以看到未绑定泛型类型的地方（除了作为声明之外）就是在typeof操作符里。

下面通过以下代码来更好的说明这点：

  1. using System;  
  2. using System.Collections.Generic;  
  3.  
  4. namespace CloseTypeAndOpenType  
  5. {  
  6.     // 声明开放泛型类型  
  7.     public sealed class DictionaryStringKey<T> : Dictionary<string, T>  
  8.     {  
  9.    
  10.     }  
  11.  
  12.    public class Program  
  13.     {  
  14.         static void Main(string[] args)  
  15.         {  
  16.             object o = null;  
  17.  
  18.             // Dictionary<,>是一个开放类型，它有2个类型参数  
  19.             Type t = typeof(Dictionary<,>);  
  20.  
  21.             // 创建开放类型的实例（创建失败，出现异常）  
  22.             o = CreateInstance(t);  
  23.             Console.WriteLine();  
  24.  
  25.             // DictionaryStringKey<>也是一个开放类型，但它有1个类型参数  
  26.             t = typeof(DictionaryStringKey<>);  
  27.  
  28.             // 创建该类型的实例（同样会失败，出现异常）  
  29.             o = CreateInstance(t);  
  30.             Console.WriteLine();  
  31.  
  32.             // DictionaryStringKey<int>是一个封闭类型  
  33.             t = typeof(DictionaryStringKey<int>);  
  34.  
  35.             // 创建封闭类型的一个实例（成功）  
  36.             o = CreateInstance(t);  
  37.  
  38.             Console.WriteLine("对象类型 = " + o.GetType());  
  39.             Console.Read();  
  40.         }  
  41.  
  42.  
  43.        // 创建类型  
  44.         private static object CreateInstance(Type t)  
  45.         {  
  46.             object o = null;  
  47.             try 
  48.             {  
  49.                 // 使用指定类型t的默认构造函数来创建该类型的实例  
  50.                 o = Activator.CreateInstance(t);  
  51.                 Console.WriteLine("已创建{0}的实例", t.ToString());  
  52.             }  
  53.             catch(Exception ex)  
  54.             {  
  55.                 Console.WriteLine(ex.Message);  
  56.             }  
  57.  
  58.             return o;  
  59.         }  
  60.     }  
  61. } 

运行结果为（从结果中也可以看出开放类型不能创建该类型的一个实例，异常信息中指出类型中包含泛型参数）：[C# 基础知识系列]专题七: 泛型深入理解(一) _泛型_02

二、泛型类型中的静态字段和静态构造函数

　　首先实例字段是属于一个实例的，静态字段是从属于它们声明的类型，即如果在某个Myclass类中声明了一个静态字段field,则不管创建Myclass的多少个实例，也不管从Myclass中派生出多少个实例，都只有一个Myclass.x字段。然而每个封闭类型都有它自己的静态字段（使用类型实参时，实际上CLR会定义一个新的类型对象， 所以每个静态字段都是不一样对象里面的静态字段，所以才会每个都有各自的值） 通过以下代码来更好说明下——每个封闭类型都有它自己的静态字段：

  1.  
  2. namespace GenericStaticFieldAndStaticFunction  
  3. {  
  4.     // 泛型类，具有一个类型参数  
  5.     public static class TypeWithStaticField<T>  
  6.     {  
  7.         public static string field;  
  8.         public static void OutField()  
  9.         {  
  10.             Console.WriteLine(field+":"+typeof(T).Name);  
  11.         }  
  12.     }  
  13.  
  14.     // 非泛型类  
  15.     public static class NoGenericTypeWithStaticField  
  16.     {  
  17.         public static string field;  
  18.         public static void OutField()  
  19.         {  
  20.             Console.WriteLine(field);  
  21.         }  
  22.     }  
  23.     class Program  
  24.     {  
  25.         static void Main(string[] args)  
  26.         {  
  27.             // 使用类型实参时，实际上CLR会定义一个新的类型对象  
  28.             // 所以每个静态字段都是不一样对象里面的静态字段，所以才会每个都有各自的值  
  29.             // 对泛型类型类的静态字段赋值  
  30.             TypeWithStaticField<int>.field = "一";  
  31.             TypeWithStaticField<string>.field = "二";  
  32.             TypeWithStaticField<Guid>.field = "三";  
  33.  
  34.             // 此时filed 值只会有一个值，每个赋值都是改变了原来的值  
  35.             NoGenericTypeWithStaticField.field = "非泛型类静态字段一";  
  36.             NoGenericTypeWithStaticField.field = "非泛型类静态字段二";  
  37.             NoGenericTypeWithStaticField.field = "非泛型类静态字段三";  
  38.  
  39.             NoGenericTypeWithStaticField.OutField();  
  40.  
  41.             // 证明每个封闭类型都有一个静态字段  
  42.             TypeWithStaticField<int>.OutField();  
  43.             TypeWithStaticField<string>.OutField();  
  44.             TypeWithStaticField<Guid>.OutField();  
  45.             Console.Read();  
  46.  
  47.         }  
  48.     }  
  49. } 

运行结果：[C# 基础知识系列]专题七: 泛型深入理解(一) _C# 基础知识_03

同样每个封闭类型都有一个静态构造函数的，通过下面的代码可以让大家更加明白这点：

 
  1. // 静态构造函数的例子  
  2.     public static class Outer<Tx>  
  3.     {  
  4.         // 嵌套类  
  5.         public class Inner<Ty>  
  6.         {  
  7.             // 静态构造函数  
  8.             static Inner()  
  9.             {  
  10.                 Console.WriteLine("Outer<{0}>.Inner<{1}>", typeof(Tx), typeof(Ty));  
  11.             }  
  12.  
  13.             public static void Print()  
  14.             {   
  15.             }  
  16.         }  
  17.     }  
  18. class Program  
  19.     {  
  20.         static void Main(string[] args)  
  21.         {  
  22.    #region 静态函数的演示  
  23.  
  24.             // 静态构造函数会运行多次  
  25.             // 因为每个封闭类型都有单独的一个静态构造函数  
  26.             Outer<int>.Inner<string>.Print();  
  27.             Outer<int>.Inner<int>.Print();  
  28.             Outer<string>.Inner<int>.Print();  
  29.             Outer<string>.Inner<string>.Print();  
  30.             Outer<object>.Inner<string>.Print();  
  31.             Outer<object>.Inner<object>.Print();  
  32.             Outer<string>.Inner<int>.Print();  
  33.             Console.Read();  
  34.             #endregion  
  35.         }  
  36.     } 
运行结果：[C# 基础知识系列]专题七: 泛型深入理解(一) _C# 基础知识_04

    从上图的运行结果可能会发现，我们代码中7个需要输出的，但是结果中只有6个结果输出的，这是因为任何封闭类型的静态构造函数只执行一次，最后一行的 Outer<string>.Inner<int>.Print();这行不会产生第7行输出， 因为Outer<string>.Inner<int>.Print();的静态构造函数在之前已经执行过的（第三行已经执行过了）。

三、编译器如何解析泛型

　　在上一个专题中，我只是贴出了泛型与非泛型的比较结果来说明泛型具有高性能的好处，却没有给出具体导致泛型比非泛型效率高的原因，所以在这个部分来剖析下泛型效率的具体原因。

这里先贴出上一个专题中说明泛型高性能好处的代码，然后再查看IL代码来说明泛型的高性能（针对泛型和非泛型，C#编译器是如何解析为IL代码的）：

  1. using System;  
  2. using System.Collections;  
  3. using System.Collections.Generic;  
  4. using System.Diagnostics;  
  5.  
  6. namespace GeneralDemo  
  7. {  
  8.     public class Program  
  9.     {  
  10.         static void Main(string[] args)  
  11.         {  
  12.             Stopwatch stopwatch = new Stopwatch();  
  13.  
  14.             // 非泛型数组  
  15.             ArrayList arraylist = new ArrayList();  
  16.  
  17.             // 泛型数组  
  18.             List<int> genericlist= new List<int>();  
  19.            
  20.             // 开始计时  
  21.             stopwatch.Start();  
  22.             for (int i = 1; i < 10000000; i++)  
  23.             {  
  24.                 //genericlist.Add(i);  
  25.                 arraylist.Add(i);  
  26.             }  
  27.  
  28.             // 结束计时  
  29.             stopwatch.Stop();  
  30.  
  31.             // 输出所用的时间  
  32.             TimeSpan ts = stopwatch.Elapsed;  
  33.             string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}",  
  34.              ts.Hours, ts.Minutes, ts.Seconds,  
  35.              ts.Milliseconds/10);  
  36.             Console.WriteLine("运行的时间： " + elapsedTime);  
  37.             Console.Read();  
  38.         }  
  39.     }  
  40. } 

当使用非泛型的的ArrayList数组时，IL的代码如下（这里只是贴出了部分主要的中间代码，具体的大家可以下载示例源码用IL反汇编程序查看的）：

  1. IL_001f:  ldloc.1  
  2. IL_0020:  ldloc.3  
  3. IL_0021:  box        [mscorlib]System.Int32  
  4. IL_0026:  callvirt   instance int32 [mscorlib]System.Collections.ArrayList::Add(object)  
  5. IL_002b:  pop  
  6. IL_002c:  nop  
  7. IL_002d:  ldloc.3  
  8. IL_002e:  ldc.i4.1  
  9. IL_002f:  add 
 
 

    在上面的IL代码中，我用红色的标记的代码主要是在执行装箱操作（装箱过程肯定是要消耗时间的吧， 就像生活中寄包裹一样，包装起来肯定是要花费一定时间， 装箱操作同样会，然而对于泛型类型就可以避免装箱操作，下面会贴出使用泛型类型的IL代码的截图）——这个操作也是影响非泛型的性能不如泛型类型的根本原因。然而为什么使用ArrayList类型在调用Add方法来向数组添加元素之前要装箱的呢？原因其实主要出在Add方法上的， 大家可以用Reflector反射工具查看ArrayList的Add方法定义，下面是一张Add方法原型的截图：

[C# 基础知识系列]专题七: 泛型深入理解(一) _C# 基础知识_05

    从上面截图可以看出，Add(objec value)需要接收object类型的参数，然而我们代码中需要传递的是int实参，此时就会发生装箱操作（值类型int转化为object引用类型,这个过程就是装箱操作），这样也就解释了为什么调用Add方法会执行装箱操作的， 同时也就说明泛型的高性能。

下面是使用泛型List<T>的IL代码截图（从图片中可以看出，使用泛型时，没有执行装箱的操作，这样就少了装箱的时间，这样当然就运行的快了，性能就好了。）：

[C# 基础知识系列]专题七: 泛型深入理解(一) _C# 基础知识_06

四、小结

　　说到这里本专题的内容也就介绍结束了，本专题主要是进一步介绍了泛型的其他内容的，由于篇幅的关于我将泛型的其他内容放在下一专题中，如果都在放在这个专题中内容会显得非常多，这样也不利于大家的消化和大家的阅读，所以我在下一个专题中继续介绍泛型的其他的一些内容。