[Programming IL]泛型, Generic Types

现在的位置: 首页 > 综合 > 正文

RSS

[Programming IL]泛型, Generic Types

2011年10月24日 ⁄ 综合 ⁄ 共 4727字 ⁄ 字号小中大 ⁄ 评论关闭

文章目录

引言:
1. 定义一个泛型类
2. 定义约束
参考

引言:

自从泛型那天诞生起，广大的面向对象程序员对于他的热爱普遍要高于其他数据结构. :). 然而各大面向对象对于他的支持却不太一样。在CPP中用的是静态编译，即在编译器决定泛型的类型，而.Net则是在运行时确定，他们有什么不一样呢?

和周围的同事谈起泛型，发现大伙对于这东西都是似懂非懂，觉得自己有必要作一次应用总结了. ，由于范型内容较多，请看这里:

我们从C#总定义一段基本的范型代码开始

public class GenericType<T> : IComparable<T>, IComparable<GenericType<T>>
                    where T: IComparable
{
    public T Value;
    
    public int CompareTo(T t)
    {
        return this.Value.CompareTo(t);
    }
    
    public int CompareTo(GenericType<T> t)
    {
        return this.Value.CompareTo(t.Value);
    }
}

反编译后的IL代码

.class public auto ansi beforefieldinit GenericType`1<([mscorlib]System.IComparable) T>
       extends [mscorlib]System.Object
       implements class [mscorlib]System.IComparable`1<!T>,
                  class [mscorlib]System.IComparable`1<class GenericType`1<!T>>
{
  .field public !T Value
  .method public hidebysig newslot virtual final 
          instance int32  CompareTo(!T t) cil managed
  {
    // Code size       24 (0x18)
    .maxstack  8
    IL_0000:  ldarg.0
    IL_0001:  ldflda     !0 class GenericType`1<!T>::Value
    IL_0006:  ldarg.1
    IL_0007:  box        !T
    IL_000c:  constrained. !T
    IL_0012:  callvirt   instance int32 [mscorlib]System.IComparable::CompareTo(object)
    IL_0017:  ret
  } // end of method GenericType`1::CompareTo
  
  .method public hidebysig newslot virtual final 
          instance int32  CompareTo(class GenericType`1<!T> t) cil managed
  {
    // Code size       29 (0x1d)
    .maxstack  8
    IL_0000:  ldarg.0
    IL_0001:  ldflda     !0 class GenericType`1<!T>::Value
    IL_0006:  ldarg.1
    IL_0007:  ldfld      !0 class GenericType`1<!T>::Value
    IL_000c:  box        !T
    IL_0011:  constrained. !T
    IL_0017:  callvirt   instance int32 [mscorlib]System.IComparable::CompareTo(object)
    IL_001c:  ret
  } // end of method GenericType`1::CompareTo
  
  .method public hidebysig specialname rtspecialname 
          instance void  .ctor() cil managed
  {
    // Code size       7 (0x7)
    .maxstack  8
    IL_0000:  ldarg.0
    IL_0001:  call       instance void [mscorlib]System.Object::.ctor()
    IL_0006:  ret
  } // end of method GenericType`1::.ctor
  
} // end of class GenericType`1

我们将之拆解为几个简单的部分来讨论

1. 定义一个泛型类

这个部分又大可以分拆为

声明一个类

.class public GenericType <([mscorlib]System.IComparable) T>
    extends [mscorlib]System.Object
    implements class [mscorlib]System.IComparable<!T>
               class [mscorlib]System.IComparable<class GenericType<T>> 
{
}

与声明一个非泛型类而言不同的就是

   1: <([mscorlib]System.IComparable) T>

声明变量

.class public value Pair<T>
{
    .field public !T x
    .field public !T y    // fields x and y have the same type T
}

声明方法

.class public List`1<T>
{
    .method public void Append(!T val) { ... }
    .method public !T GetLast() { ... }
    //...
}

隐藏与覆盖

这个部分，泛型的实现与非泛型一致，我们可以查看一个实例

我们为之前定义的GenericType定义两个方法

public void BaseRun()
{
    Console.WriteLine("This is the base Run");
}
  
public virtual void ParentMethod()
{
    Console.WriteLine("The is the parentVirtual Method");
}

再为他定义一个基类DerivedClass

public class DerivedClass<T> : GenericType<T> 
            where T : IComparable
{
    public new void BaseRun()
    {
        Console.WriteLine("This is the derived class running");
    }
    
    public override void ParentMethod()
    {
        Console.WriteLine("This is the derived class");
    }
}

对比下生成的IL代码

.method public hidebysig instance void  BaseRun() cil managed
{
  // Code size       11 (0xb)
  .maxstack  8
  IL_0000:  ldstr      "This is the derived class running"
  IL_0005:  call       void [mscorlib]System.Console::WriteLine(string)
  IL_000a:  ret
} // end of method DerivedClass`1::BaseRun
  
.method public hidebysig virtual instance void 
        ParentMethod() cil managed
{
  // Code size       11 (0xb)
  .maxstack  8
  IL_0000:  ldstr      "This is the derived class"
  IL_0005:  call       void [mscorlib]System.Console::WriteLine(string)
  IL_000a:  ret
} // end of method DerivedClass`1::ParentMethod

2. 定义约束

参考之前提到的几种约束，我们分别用IL来做一下解释

值类型约束

.class public ClassType`1<valuetype .ctor ([mscorlib]System.ValueType) T>
       extends [mscorlib]System.Object
{}

引用类型约束

   1: .class public ClassType`1<class T> extends [mscorlib]System.Object

接口类型约束
参考本文前面的代码

基类约束

   1: .class public BaseClass`1<(class GenericType`1<!T>, [mscorlib]System.IComparable) T>
   2:        extends [mscorlib]System.Object

无参构造函数约束

   1: .class public auto ansi beforefieldinit CtorType`1<.ctor T>
   2:        extends [mscorlib]System.Object

多个泛型类型关系约束

.class public ParentChild`2<T, (!T)U> // U must bedescendant of T
{
    //TODO:: Implement this ...
}

(!T)U代表了U必须是可以通过类型转换变成T,即U为T的子类
来个复杂点的

   1: .class public auto ansi beforefieldinit ComplexType`1<class .ctor ([mscorlib]System.IComparable) T>
   2:        extends [mscorlib]System.Object

可以看到，几种类型定义的不同只存在于 <类型定义>

走到这里，我还是不明白，虽然在IL层次上的东西做的相当的简洁，那泛型那些优势又是如何实现的呢，去看了下元数据定义也没啥惊喜

元数据定义:

Generic Param(泛型参数), 即<类型定义>:

GenericParam Metadata Table:

名称	作用
Number(2-byte unsigned integer).	泛型类型中泛型参数的位置
Flags(2-byte bit field).	代表泛型约束
Owner(coded token of type TypeOrMethodDef).	泛型参数所对应的泛型类型
Name(offset in the #Strings stream).	泛型参数名称

Generic Method(泛型方法):

<gen_method_def> ::=
.method <flags> <call_conv> <ret_type> <name>< <gen_params> > (<arg_list>) <impl>
{ <method_body> }
For example:
.method public static !!T GetMedian<T>(!!T[] tarray)
{
    ldarg.0
    dup
    ldlen
    ldc.i4.1
    shr
    ldelem !!T
    ret
}

关于CLR对于运行时创建好像很难找到相关资料，有待进一步深入了 :), 本文断断续续也写了很久了，先画上一个句号吧

参考

Expert IL Assembler 2.0
Professional.Net 2.0 Generic
ECMA Partion II

【上篇】确定机器上装有哪些.net framework版本
【下篇】Microsoft Sync Framework下的快速开发同步程序

作者: squirter

该日志由 squirter 于13年前发表在综合分类下，最后更新于 2011年10月24日.
转载请注明: [Programming IL]泛型, Generic Types | 学步园 +复制链接

抱歉!评论已关闭.

学步园