C#泛型内部工作机制详细解析

发布时间：2015-02-16 00:00 来源：田小计划

前面两篇文章介绍了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运行时自动调用，而不能人工调用，并且只能执行一次。

泛型中的静态构造函数的原理和非泛型类是一样的，只需把泛型中的不同的封闭类理解为不同的类即可。

总结

本篇文章介绍了泛型的工作机制，进一步的认识了泛型。同时，结合泛型工作原理，看到了为什么值类型使用泛型可以避免装箱和拆箱。