Emit，更高级的反射用法（C#）

只要写过几年C#，你就不可能没用过反射。

如果要通过反射调用函数，最广泛的用法是使用Invoke。

比Invoke高效一些的做法是使用表达式预先编译一个委托，之后通过委托进行调用。

我此前做过一个粗略的测试来对比函数的直接调用、表达式委托、Invoke调用三者之间的性能差异。发现表达式方式比直接调用慢70倍，Invoke比直接调用慢2000倍。

当然，这只是在我的机器上跑出来的数据，不同的机器和不同的Framework版本可能会有不同的结果。

但是无论如何，可以看到Invoke方式是有很大的性能损失的。

为了挽救这种性能损失，可以考虑使用Emit技术。

Emit可以使用MSIL指令动态编写程序逻辑，然后将指令编译成程序集。

之后执行起来就跟原生调用没什么区别了，自然也就不会有太大的性能损失，这样既保证了灵活性，又保证了程序性能。

来一个最简单的示例，感受一下Emit的用法：


using System;
using System.Reflection;
using System.Reflection.Emit;

namespace EmitDemo
{
    public interface IConsole
    {
        void Say();
    }

    class Example1
    {
        public static void Run()
        {
            // 在看下面的代码之前，先明白这个依赖关系，即：
            // 方法->类型->模块->程序集


            //定义程序集的名称
            AssemblyName aName = new AssemblyName("DynamicAssemblyExample");

            // 创建一个程序集构建器
            // Framework应该这样：AppDomain.CurrentDomain.DefineDynamicAssembly
            AssemblyBuilder ab =
                AssemblyBuilder.DefineDynamicAssembly(
                    aName,
                    AssemblyBuilderAccess.Run);


            // 使用程序集构建器创建一个模块构建器
            ModuleBuilder mb = ab.DefineDynamicModule(aName.Name + ".dll");

            // 使用模块构建器创建一个类型构建器
            TypeBuilder tb = mb.DefineType("DynamicConsole");

            // 使类型实现IConsole接口
            tb.AddInterfaceImplementation(typeof(IConsole));

            var attrs = MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.NewSlot | MethodAttributes.HideBySig | MethodAttributes.Final;

            // 使用类型构建器创建一个方法构建器
            MethodBuilder methodBuilder = tb.DefineMethod("Say", attrs, typeof(void), Type.EmptyTypes);

            // 通过方法构建器获取一个MSIL生成器
            var IL = methodBuilder.GetILGenerator();

            // 开始编写方法的执行逻辑

            // 将一个字符串压入栈顶
            IL.Emit(OpCodes.Ldstr, "I'm here.");

            // 调用Console.Writeline函数
            IL.Emit(OpCodes.Call, typeof(Console).GetMethod("WriteLine", new[] { typeof(string) }));

            // 退出函数
            IL.Emit(OpCodes.Ret);

            //方法结束


            // 从类型构建器中创建出类型
            var dynamicType = tb.CreateType();


            // 通过反射创建出动态类型的实例
            var console = Activator.CreateInstance(dynamicType) as IConsole;

            console.Say();

            Console.ReadLine();
        }
    }
}

这段代码在.net core下可正常运行，在Framework下有部分代码需要调整，我已在注释中给出备注。

代码略长，不过概括起来说，这段代码主要做了这些事情：

动态的创建了一个程序集，然后在程序集中定义了模块和类。然后让这个类实现了IConsole接口，之后实现了Say方法。Say方法调用了静态方法“Console.WriteLine”，最终输出了一段字符。

示例程序最核心的代码是第48到59行，这几句代码使用MSIL指令编写了一段函数逻辑，理解这些指令是掌握Emit的关键。

通过上面这个示例可以习得动态创建程序集的基本步骤，即：

定义Assembly，在Assembly中定义Module，在Module中定义Type，在Type中定义方法，之后使用IL编写方法的执行逻辑。

下面再来看一个复杂一些的示例，更多的了解一些常用的IL指令的用法。


using System;
using System.Reflection;
using System.Reflection.Emit;

namespace EmitDemo
{
    class Example2
    {
        public static void Run()
        {
            AssemblyName aName = new AssemblyName("ChefDynamicAssembly");

            AssemblyBuilder ab =
                AssemblyBuilder.DefineDynamicAssembly(
                    aName,
                    AssemblyBuilderAccess.Run);

            ModuleBuilder mb = ab.DefineDynamicModule(aName.Name + ".dll");

            TypeBuilder tb = mb.DefineType("Commander");

            var attrs = MethodAttributes.Public;

            // 使用类型构建器创建一个方法构建器
            MethodBuilder methodBuilder = tb.DefineMethod("Do", attrs, typeof(string), Type.EmptyTypes);

            // 通过方法构建器获取一个MSIL生成器
            var IL = methodBuilder.GetILGenerator();

            // 开始编写方法的执行逻辑

            // var vegetables = new string[3];
            var vegetables = IL.DeclareLocal(typeof(string[]));
            IL.Emit(OpCodes.Ldc_I4, 3);
            IL.Emit(OpCodes.Newarr, typeof(string));
            IL.Emit(OpCodes.Stloc, vegetables);

            //vegetables[0] = "土豆"
            IL.Emit(OpCodes.Ldloc, vegetables);
            IL.Emit(OpCodes.Ldc_I4, 0);
            IL.Emit(OpCodes.Ldstr, "土豆");
            IL.Emit(OpCodes.Stelem, typeof(string));

            //vegetables[1] = "青椒"
            IL.Emit(OpCodes.Ldloc, vegetables);
            IL.Emit(OpCodes.Ldc_I4, 1);
            IL.Emit(OpCodes.Ldstr, "青椒");
            IL.Emit(OpCodes.Stelem, typeof(string));

            //vegetables[2] = "木耳"
            IL.Emit(OpCodes.Ldloc, vegetables);
            IL.Emit(OpCodes.Ldc_I4, 2);
            IL.Emit(OpCodes.Ldstr, "木耳");
            IL.Emit(OpCodes.Stelem, typeof(string));

            // IChef chef = new GoodChef();
            var chef = IL.DeclareLocal(typeof(IChef));
            IL.Emit(OpCodes.Newobj, typeof(GoodChef).GetConstructor(Type.EmptyTypes));
            IL.Emit(OpCodes.Stloc, chef);

            //var dish = chef.Cook(vegetables);
            var dish = IL.DeclareLocal(typeof(string));
            IL.Emit(OpCodes.Ldloc, chef);
            IL.Emit(OpCodes.Ldloc, vegetables);
            IL.Emit(OpCodes.Callvirt, typeof(IChef).GetMethod("Cook"));
            IL.Emit(OpCodes.Stloc, dish);

            // return dish;
            IL.Emit(OpCodes.Ldloc, dish);
            IL.Emit(OpCodes.Ret);

            //方法结束


            // 从类型构建器中创建出类型
            var dynamicType = tb.CreateType();


            // 通过反射创建出动态类型的实例
            var commander = Activator.CreateInstance(dynamicType);

            Console.WriteLine(dynamicType.GetMethod("Do").Invoke(commander, null).ToString());

            Console.ReadLine();
        }
    }

    public interface IChef
    {
        string Cook(string[] vegetables);
    }

    public class GoodChef : IChef
    {
        public string Cook(string[] vegetables)
        {
            return "good:" + string.Join("+", vegetables);
        }
    }
}

这个示例有如下输出：

good:土豆+青椒+木耳

除开一些基础设施的定义，以第30至72行为主要关注点。

代码其实没有什么复杂的逻辑，就是定义了一个数组，创建一个实现了IChef的接口的实例，将数组传递给实例的Cook方法，获得输出后返回。

不过，逻辑虽然简单，但是却展示了多种常用的IL指令的使用方法。例如，创建数组，给数组赋值，创建对象，调用实例方法等等……

每一段IL指令对应的C#语法都已在注释中进行了说明，建议对照起来看。

对于这些指令的具体用法，建议参考MSDN。要是MSDN看的云里雾里，可以看一下文章末尾介绍的MSDN查阅指南。

另外，我再介绍两点编程技巧：

第一、如果不知道某些语句怎么写，可以先把你想要写的逻辑用C#表达出来之后编译成DLL，之后使用微软提供的ILDAsm（VS自带）工具打开这个DLL查看具体的IL指令，然后对照着翻译成Emit IL。

第二、如果要验证Emit生成的DLL是否是自己想要表的的逻辑，可以使用ILSpy反编译工具将生成的DLL反编译出来看一看具体的逻辑。

实际应用中，除了使用Emit来提升反射的执行效率外，还可以用它来实现动态代理或者应用到AOP编程技术中，可谓不得不掌握的C#高级编程技术。

MSDN查阅指南之OpCodes

MSDN找到System.Reflection.Emit命名空间，找到OpCodes类，定位到Fields部分。

这里可以全局总览所有的IL指令，可以大致浏览一下每个指令的作用。

然后选择一个指令进入子页面查看对该指令的详细介绍。

接下来以Call指令为例进行介绍。

这里大致描述了这个指令的作用

Remarks是关注的重点，这里描述了参数和栈的操作，想要正确的使用指令全靠这里了。

随着Remarks往下翻，可以看到具体的调用范式。

好了，正文就啰嗦到这里吧。

在开始认真写文章之前总觉得没什么可写的，但是一旦开始之后总觉得有太多的东西可以写。

所以说，思路是需要整理的。

谢谢观看，点个赞呗？