IL入门之旅（二）——动态包装

1.包装与为什么要包装

    oo的世界看起来很完美，但是也有不少缺点，尤其是遇到静态语言（例如：c#,java等），经常会受制于类型不匹配这样的问题。

    例如，某个类库需要一个INamedObject对象，而另一个类库仅仅提供了一个Thread对象，怎么办哪？在不可能修改类库的情况下，通常就会写一个Wrapper，把Thread包装成INamedObject，大概的代码如下：

public interface INamedObject

{

    string Name { get; }

}



public class ThreadWrapper : INamedObject

{

    private Thread m_thread;



    public ThreadWrapper(Thread thread)

    {

        m_thread = thread;

    }



    public string Name

    {

        get { return m_thread.Name; }

    }

}

    这样就把一个Thread包装成了一个INamedObject，但是，如果有一堆这样的类需要被包装的话，这也就以为之有一堆的包装类需要去写。说道这里，相信oo的缺点已经暴露了出来了。

2.Duck Typing与动态包装

    接下来看看另一套类型系统Duck Typing是如何处理这个问题的：

"when I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck."

    说白了，Duck Typing并不关心对象的真实类型，而仅仅是关心有没有对应的方法，换句话说，Duck Typing本身并不关心INamedObject，也根本不需要这个接口的存在，它所需要的仅仅是某个对象的Name属性。

    c# 4.0提供了dynamic关键字，可以很轻松的完成这样的工作，不过，4.0还没正式发布，而且就算发布了，也不会所有的项目都用4.0来写。

    那么，在2.0的时代就没法享受Duck Typing的思想了吗？

    其实只要那个Wrapper可以自动生成，那么，INamedObject就可以简单的生成一个包装，实现这个接口，这样就完成了一次伪装。而如何在运行时生成这样一个包装就是本文接下来要讲述的。

3.分析和目标制定

    在开工前，先分析一下要实现任意类->INamedObject的动态包装类需要完成和注意些什么问题。

    看一下ThreadWrapper类：

• 这个类需要实现INamedObject接口
• 需要一个原始对象的字段，来保存原始对象
• 一个构造函数，把这个原始对象放进去
• 一系列的方法，实现这个接口
• 在每个方法中，调用原始对象的同名方法

    因为INamedObject只有一个Name属性，所以，这一系列的方法就简化成一个Name属性的get方法。

    其次，因为这里需要动态生成一个类型（例如ThreadWrapper），所以这次不能像上一次那样偷工减料的用一个DynamicMethod，而是需要完整的DynamicAssembly。

    最后，因为是运行时动态生成的类型，显然不能在代码中依赖到这些类型，也就是无法直接用new去创建wrapper类，这时候，需要借用创建模式中的工厂方法来协助创建这些wrapper。

    （不难发现，设计模式总是在必要的时候，自然而然的被使用；而不是特意去套用那些设计模式，或者说滥用设计模式，这也是初学者最容易犯的错误之一）

4.实现目标

    首先，创建一个动态程序集和其他一些基本要素：

public static class DynamicWrapper

{

    private readonly static AssemblyBuilder s_assembly =

        AppDomain.CurrentDomain.DefineDynamicAssembly(

        new AssemblyName("DynamicWrapper"), AssemblyBuilderAccess.Run);

    private readonly static ModuleBuilder s_module =

        (ModuleBuilder)s_assembly.GetModules()[0];

    private static int s_typeId;



    public static TInterface Wrap<TClass, TInterface>(TClass obj)

    {

        throw new NotImplementedException();

    }



    internal static TypeBuilder DefineType()

    {

        return s_module.DefineType("DynamicWrapper" + (Interlocked.Increment(ref s_typeId)).ToString());

    }

}

    做个简单的说明：

• s_assembly用于保持对动态程序集实例的引用，可以看到创建参数用了Run，也就是这个动态程序集支持直接运行里面的类型，但是不支持把这个动态程序集保存到硬盘
• s_module则简单的直接引用了动态程序集的默认Module，当然也可以另外创建，不过这里没有这个必要
• s_typeId则记录了类型的个数，用于创建类型名称时避免重复。
• Wrap方法就是预留的工厂方法，当然暂时未实现
• DefineType这个内部方法用于创建一个类型

    现在问题变成如何实现Wrap方法，这里先不考虑创建类型的问题，先考虑一下性能问题，创建类型本身是一个比较消耗的CPU的，如果为相同的类型重复创建Wrapper类型，肯定得不偿失，因此必须要准备一个必要的缓存机制，如果有缓存机制的存在，那么同时也要考虑多线程并发的问题。

    当然，这不是本文的重点，因此直接使用一个最简单的缓存机制——泛型类型的静态字段：

internal static class WrapperImpl<TClass, TInterface>

{

    public readonly static Func<TClass, TInterface> WrapperCreator = CreateWrapperCreator();



    private static Type CreateWrapperType()

    {

        var type = DynamicWrapper.DefineType();

        // todo

        return type.CreateType();

    }



    private static Func<TClass, TInterface> CreateWrapperCreator()

    {

        Type type = CreateWrapperType();

        return o => (TInterface)Activator.CreateInstance(type, o);

    }

}

    这样，去掉参数检查的话，Wrap方法可以非常简单的写成：

public static TInterface Wrap<TClass, TInterface>(TClass obj)

{

    return WrapperImpl<TClass, TInterface>.WrapperCreator(obj);

}

    看到CreateWrapperCreator方法了吧，是不是想起了上一集讨论的如何创建实例，对了，这也就是上一集为什么要讨论创建实例的问题，还记得几个实现的速度差异吧（当然CreateInstance<T>方法用不上，这个方式没法带参数），如果想改用DynamicMethod，当然也可以，只不过，这里就用CreateInstance方式简化非重点内容了。

    好，回到重点的CreateWrapperType方法上，这里真正需要创建一个Wrapper类型了，使用DynamicWrapper类预先提供的DefineType方法可以获得一个继承自Object的空类型，那么首先要实现TInterface：

type.AddInterfaceImplementation(typeof(TInterface));

    是不是很容易，别急，这里只是相当于在ThreadWrapper类型后面加了个”: INamedObject”，方法还没哪，这样的一个类型在type.CreateType()时会报错的（除非这个接口本来就是一个空接口。。。），因此，接下来是实现接口，完整地代码如下：

private static Type CreateWrapperType()

{

    var type = DynamicWrapper.DefineType();

    type.AddInterfaceImplementation(typeof(TInterface));

    var impl = type.DefineField("impl", typeof(TClass), FieldAttributes.Private | FieldAttributes.InitOnly);

    CreateCtor(type, impl);

    foreach (MethodInfo mi in typeof(TInterface).GetMethods(BindingFlags.Public | BindingFlags.Instance))

    {

        ImplInterface(type, impl, mi);

    }

    return type.CreateType();

}



private static void CreateCtor(TypeBuilder type, FieldBuilder impl)

{

    var ctor = type.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new Type[] { typeof(TClass) });

    var il = ctor.GetILGenerator();

    il.Emit(OpCodes.Ldarg_0);

    il.Emit(OpCodes.Ldarg_1);

    il.Emit(OpCodes.Stfld, impl);

    il.Emit(OpCodes.Ret);

}



private static void ImplInterface(TypeBuilder type, FieldBuilder impl, MethodInfo mi)

{

    Type[] methodParams = (from p in mi.GetParameters()

                           select p.ParameterType).ToArray();

    var method = type.DefineMethod(mi.Name,

        MethodAttributes.Public | MethodAttributes.NewSlot |

        MethodAttributes.Virtual | MethodAttributes.Final);

    method.SetReturnType(mi.ReturnType);

    method.SetParameters(methodParams);

    var il = method.GetILGenerator();

    var implMethod = typeof(TClass).GetMethod(mi.Name,

        BindingFlags.Public | BindingFlags.Instance, null, methodParams, null);

    if (implMethod != null && implMethod.ReturnType == mi.ReturnType)

    {

        il.Emit(OpCodes.Ldarg_0);

        il.Emit(OpCodes.Ldfld, impl);

        for (int i = 0; i < methodParams.Length; i++)

        {

            il.Emit(OpCodes.Ldarg, i + 1);

        }

        il.Emit(OpCodes.Callvirt, implMethod);

        il.Emit(OpCodes.Ret);

    }

    else

    {

        il.Emit(OpCodes.Ldstr, typeof(TClass).FullName);

        il.Emit(OpCodes.Ldstr, mi.Name);

        il.Emit(OpCodes.Newobj, typeof(MissingMethodException).GetConstructor(

            new Type[] { typeof(string), typeof(string) }));

        il.Emit(OpCodes.Throw);

    }

}

    这里需要注意几点：

    首先，声明了一个叫impl的字段，类型为TClass，并且是Private和InitOnly（没有声明为Static，所以为实例字段）。InitOnly就相当于c#的readonly，也就是仅仅在构造函数中才能够设置其值。

    其次，调用了一个CreateCtor的方法，用于创建构造函数，参数为一个TClass。

    最后，为每一个接口方法Delegate到一个实现类的方法。当然前提是方法名称、参数和返回值都一样。

    不过这里有个问题，如果方法对应不到实现哪？

    当然，这种情况有两种解决方案：

• 认为这个对象无法转换成接口，直接throw new InvalidCastException();
• 不过也可以运用Duck Typing的一个原则：

In other words, don't check whether it IS-a duck: check whether it QUACKS-like-a duck, WALKS-like-a duck, etc, etc, depending on exactly what subset of duck-like behaviour you need to play your language-games with.

    也就是这里用的认为实现了这个接口，而是在真正调用这个方法时抛出MissingMethodException来代表这个方法其实没有实现。

5.简单测试

    一个初步的实现已经完成了，来看看运行起来的效果如何：

static void Main(string[] args)

{

    Thread.CurrentThread.Name = "Hello world!";

    INamedObject namedObj = DynamicWrapper.Wrap<Thread, INamedObject>(Thread.CurrentThread);

    Console.WriteLine(namedObj.Name);

    INamedObject duckObj = DynamicWrapper.Wrap<object, INamedObject>(new object());

    try

    {

        Console.WriteLine(duckObj.Name);

    }

    catch (MissingMethodException ex)

    {

        Console.WriteLine(ex.Message);

    }

}

    看看执行的结果：

Hello world!
未找到方法“System.Object.get_Name”。

    看起来还不错吧。

6.缺陷

    写到这里，有没有发现问题？

    什么，没发现。。。好吧，再仔细想一想：

• 值类型和引用类型，对了，这里把所有的TClass当成了引用类型，在遇到值类型的时候就会出错，这是第一个问题
• 接口如果有泛型方法的时候，并没有对应的处理，这是第二个问题
• 接口如果有要求实现其他接口的话，创建包装的时候需要吧要求实现的接口一起实现，这是第三个问题

    当然这些问题是可以解决的，至于怎么解决，就是留给大家的思考题。