深入理解C#泛型

本网站用的阿里云ECS,推荐大家用。自己搞个学习研究也不错
前面两篇文章介绍了C#泛型的基本知识和特性,下面我们看看泛型是怎么工作的,了解一下泛型内部机制。

  1. http://www.linuxidc.com/Linux/2015-02/113465.htm
  2. http://www.linuxidc.com/Linux/2015-02/113466.htm

泛型内部机制

泛型拥有类型参数,通过类型参数可以提供”参数化”的类型,事实上,泛型类型的”类型参数”变成了泛型类型的元数据,”运行时”在需要的时候会利用他们构造恰当的类型,通过这些类型,我们有可以实例化不同类型的对象。也就是说,未绑定泛型类型是以构造泛型类型的蓝图,已构造泛型类型又是实际对象的蓝图。

分析泛型IL代码

下面看一个例子,在这个例子中定义了一个用于比较的泛型类和一个比较int的非泛型类:

namespace GenericTest
{
    class CompareUtil 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“的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在运行时支持,编译器在处理泛型的时候做了两件事情:

  1. 当编译器遇到”CompareUtil“这种泛型代码时,编译器会把泛型代码编译为IL代码和元数据时,采用特殊的占位符来表示类型参数
  2. 而真正的泛型实例化工作以”on-demand”的方式,也就是说当编译器遇到”CompareUtil 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()
{
    Console.WriteLine(typeof(T));

    Console.WriteLine(typeof(List<>));
    Console.WriteLine(typeof(Dictionary<,>));

    Console.WriteLine(typeof(List));
    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
    {
        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运行时自动调用,而不能人工调用,并且只能执行一次。

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

总结

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

C#多线程编程实例 线程与窗体交互【附源码】 http://www.linuxidc.com/Linux/2014-07/104294.htm

C#数学运算表达式解释器 http://www.linuxidc.com/Linux/2014-07/104289.htm

在C语言中解析JSON配置文件 http://www.linuxidc.com/Linux/2014-05/101822.htm

C++ Primer Plus 第6版 中文版 清晰有书签PDF+源代码 http://www.linuxidc.com/Linux/2014-05/101227.

未经允许不得转载:演道网 » 深入理解C#泛型

赞 (0)
分享到:更多 ()

评论 0

评论前必须登录!

登陆 注册