只要写过几年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往下翻，可以看到具体的调用范式。
好了，正文就啰嗦到这里吧。
在开始认真写文章之前总觉得没什么可写的，但是一旦开始之后总觉得有太多的东西可以写。
所以说，思路是需要整理的。
谢谢观看，点个赞呗？
网友评论