C#泛型内部工作机制详细解析
泛型内部机制
泛型拥有类型参数，通过类型参数可以提供 参数化 的类型，事实上，泛型类型的 类型参数 变成了泛型类型的元数据， 运行时 在需要的时候会利用他们构造恰当的类型，通过这些类型，我们有可以实例化不同类型的对象。也就是说，未绑定泛型类型是以构造泛型类型的蓝图，已构造泛型类型又是实际对象的蓝图。
分析泛型IL代码
下面看一个例子，在这个例子中定义了一个用于比较的泛型类和一个比较int的非泛型类：
namespace GenericTest
{
class CompareUtil<T> where T: IComparable
{
public T ItemOne { get; set; }
public T ItemTwo { get; set; }
public CompareUtil(T itemOne, T itemTwo)
{
this.ItemOne = itemOne;
this.ItemTwo = itemTwo;
}
public T GetBiggerOne()
{
if (ItemOne.CompareTo(ItemTwo) > 0)
{
return ItemOne;
}
return ItemTwo;
}
}
class IntCompareUtil
{
public int ItemOne { get; set; }
public int ItemTwo { get; set; }
public IntCompareUtil(int itemOne, int itemTwo)
{
this.ItemOne = itemOne;
this.ItemTwo = itemTwo;
}
public int GetBiggerOne()
{
if (ItemOne.CompareTo(ItemTwo) > 0)
{
return ItemOne;
}
return ItemTwo;
}
}
class Program
{
static void Main(string[] args)
{
CompareUtil<int> compareInt = new CompareUtil<int>(3, 6);
int bigInt = compareInt.GetBiggerOne();
IntCompareUtil intCompareUtil = new IntCompareUtil(4, 7);
int big = intCompareUtil.GetBiggerOne();
Console.Read();
}
}
}
首先，通过ILSpy查看一下泛型类 CompareUtil<T> 的IL代码（只列出了一部分IL代码）
.class private auto ansi beforefieldinit GenericTest.CompareUtil`1<([mscorlib]System.IComparable) T>
extends [mscorlib]System.Object
{
.method public hidebysig specialname rtspecialname
instance void .ctor (
!T itemOne,
!T itemTwo
) cil managed
{ }
// Properties
.property instance !T ItemOne()
{
.get instance !0 GenericTest.CompareUtil`1::get_ItemOne()
.set instance void GenericTest.CompareUtil`1::set_ItemOne(!0)
}
.property instance !T ItemTwo()
{
.get instance !0 GenericTest.CompareUtil`1::get_ItemTwo()
.set instance void GenericTest.CompareUtil`1::set_ItemTwo(!0)
}
} // end of class GenericTest.CompareUtil`1
大家可以查看非泛型类 IntCompareUtil 的IL代码，你会发现泛型类的IL代码跟非泛型类的IL代码基本一致，只是泛型类的IL代码中多了一些类型参数元数据。
下面看看泛型类IL代码中的几个特殊点：
GenericTest.CompareUtil`1<([mscorlib]System.IComparable) T>
`1表示元数，也就是类型参数的数量
<([mscorlib]System.IComparable) T>就是我们加在泛型类型上的类型约束
!T和!0
!T就是类型参数的占位符
!0代表第一个类型参数（当泛型的元数为2时，!1就代表第二个类型参数）
同时，大家也可以比较一下泛型类和非泛型类的实例构造IL代码
IL_0003: newobj instance void class GenericTest.CompareUtil`1<int32>::.ctor(!0, !0)
IL_0012: newobj instance void GenericTest.IntCompareUtil::.ctor(int32, int32)
泛型机制
根据上面的分析可以得到， C#泛型能力有CLR在运行时支持，编译器在处理泛型的时候做了两件事情：
当编译器遇到 CompareUtil<T> 这种泛型代码时，编译器会把泛型代码编译为IL代码和元数据时，采用特殊的占位符来表示类型参数
而真正的泛型实例化工作以 on-demand 的方式，也就是说当编译器遇到 CompareUtil<int> compareInt 指定类型实参的代码时，根据类型实参JIT将泛型类型的IL转换成本机代码，这个本地代码中已经使用了实际的数据类型，等同于用实际类型声明的类
值类型和引用类型的实例化
JIT为所有类型参数为 引用类型 的泛型类型产生同一份本机代码，之所以能这么做，是由于所有的引用具有相同的大小。
但是如果类型参数为 值类型 ，对每一个不同的 值类型 ，JIT将为其产生一份独立的本机代码。
至于说为什么使用泛型类可以避免值类型的装箱和拆箱操作：
List<int> intList = new List<int>();
相信大家看到下面的IL代码就明白了，在泛型类中，都是通过类型参数直接使用值类型。
// Fields
.field private !T[] _items
对泛型类型使用typeof
在C#中，我们经常使用typeof操作符来获得一个System.Type对象的引用。
对于泛型类型，我们也可以通过两种方式使用typeof：
获取泛型类型定义（未绑定泛型类型）
为了获取泛型类型的定义，只需要提供声明的类型名称，删除所有的类型参数，但保留逗号
获取特定的已构造类型（也就是获取封闭类型的类型引用）
只需要指定类型实参
下面看一个简单的例子，
static void DemonstrateTypeOf<T>()
{
Console.WriteLine(typeof(T));
Console.WriteLine(typeof(List<>));
Console.WriteLine(typeof(Dictionary<,>));
Console.WriteLine(typeof(List<T>));
Console.WriteLine(typeof(Dictionary<string, T>));
Console.WriteLine(typeof(List<long>));
Console.WriteLine(typeof(Dictionary<string, int>));
}
函数的输出如下：
System.Double
System.Collections.Generic.List`1[T]
System.Collections.Generic.Dictionary`2[TKey,TValue]
System.Collections.Generic.List`1[System.Double]
System.Collections.Generic.Dictionary`2[System.String,System.Double]
System.Collections.Generic.List`1[System.Int64]
System.Collections.Generic.Dictionary`2[System.String,System.Int32]
通过输出的结果，我们也可以看到每个泛型的元数，以及泛型类型（未绑定泛型类型和封闭类型）的类型。
静态字段和静态构造函数
泛型中的静态字段
在C#中，类的静态成员变量在不同的类实例间是共享的，并且可以通过类名访问。C# 2.0中引入了泛型，导致静态成员变量的机制出现了一些变化：静态成员变量在相同封闭类型间共享，不同的封闭类型间不共享。这也非常容易理解，因为不同的封闭类型虽然有相同的类名称，但由于分别传入了不同的数据类型，他们是完全不同的类型。
看一个简单的例子：
namespace GenericTest
{
class TypeWithField<T>
{
public static string field;
public static void PrintField()
{
Console.WriteLine(field);
}
}
class Program
{
static void Main(string[] args)
{
TypeWithField<int>.field = "Int Field";
TypeWithField<string>.field = "String Field";
TypeWithField<int>.PrintField();
TypeWithField<string>.PrintField();
Console.Read();
}
}
}
泛型中的静态构造函数
静态构造函数的规则：只能有一个，且不能有参数，他只能被.NET运行时自动调用，而不能人工调用，并且只能执行一次。
泛型中的静态构造函数的原理和非泛型类是一样的，只需把泛型中的不同的封闭类理解为不同的类即可。
总结
本篇文章介绍了泛型的工作机制，进一步的认识了泛型。同时，结合泛型工作原理，看到了为什么值类型使用泛型可以避免装箱和拆箱。
