C# 反射与特性(十)：EMIT 构建代码

用户东方红 發表於 2020-6-11 21:50:00

<div class="toc"><div class="toc-container-header">目录</div><ul><li>构建代码<ul><li>1,程序集(Assembly)</li><li>2,模块（Module）</li><li>3,类型(Type)</li><li>4,DynamicMethod 定义方法与添加 IL</li></ul></li></ul></div>
前面，本系列一共写了九篇关于反射和特性相关的文章，讲解了如何从程序集中通过反射将信息解析出来，以及实例化类型。
前面的九篇文章中，重点在于读数据，使用已经构建好的数据结构(元数据等)，接下来，我们将学习 .NET Core 中，关于动态构建代码的知识。
其中表达式树已经在另一个系列写了，所以本系列主要是讲述反射，Emit ，AOP 等内容。
如果现在总结一下，反射，与哪些数据结构相关？
我们可以从 AttributeTargets 枚举中窥见：
<pre><code>public enum AttributeTargets
{
All=16383,
Assembly=1,
Module=2,
Class=4,
Struct=8,
Enum=16,
Constructor=32,
Method=64,
Property=128,
Field=256,
Event=512,
Interface=1024,
Parameter=2048,
Delegate=4096,
ReturnValue=8192
}
</code></pre>
分别是程序集、模块、类、结构体、枚举、构造函数、方法、属性、字段、事件、接口、参数、委托、返回值。
以往的文章中，已经对这些进行了很详细的讲解，我们可以中反射中获得各种各样的信息。当然，我们也可以通过动态代码，生成以上数据结构。
动态代码的其中一种方式是表达式树，我们还可以使用 Emit 技术、Roslyn 技术来编写；相关的框架有 Natasha、CS-Script 等。
<h2 id="构建代码">构建代码</h2>
首先我们引入一个命名空间：
<pre><code class="language-csharp">using System.Reflection.Emit;
</code></pre>
Emit 命名空间中里面有很多用于构建动态代码的类型，例如 <code>AssemblyBuilder</code>，这个类型用于构建程序集。类推，构建其它数据结构例如方法属性，则有 <code>MethodBuilder</code>、<code>PropertyBuilder</code> 。
<h3 id="1程序集assembly">1,程序集(Assembly)</h3>
AssemblyBuilder 类型定义并表示动态程序集，它是一个密封类，其定义如下：
<pre><code class="language-csharp">public sealed class AssemblyBuilder : Assembly
</code></pre>
AssemblyBuilderAccess 定义动态程序集的访问模式，在 .NET Core 中，只有两个枚举：
<table>
<thead>
<tr>
<th>枚举</th>
<th>值</th>
<th>说明</th>
</tr>
</thead>
<tbody>
<tr>
<td>Run</td>
<td>1</td>
<td>可以执行但无法保存该动态程序集。</td>
</tr>
<tr>
<td>RunAndCollect</td>
<td>9</td>
<td>当动态程序集不再可供访问时，将自动卸载该程序集，并回收其内存。</td>
</tr>
</tbody>
</table>
.NET Framework 中，有 RunAndSave 、Save 等枚举，可用于保存构建的程序集，但是在 .NET Core 中，是没有这些枚举的，也就是说，Emit 构建的程序集只能在内存中，是无法保存成 .dll 文件的。
另外，程序集的构建方式(API)也做了变更，如果你百度看到文章 <code>AppDomain.CurrentDomain.DefineDynamicAssembly</code>，那么你可以关闭创建了，说明里面的很多代码根本无法在 .NET Core 下跑。
好了，不再赘述，我们来看看创建一个程序集的代码：
<pre><code class="language-csharp"> AssemblyName assemblyName = new AssemblyName("MyTest");
 AssemblyBuilder assBuilder = AssemblyBuilder.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
</code></pre>
构建程序集，分为两部分：
<ul>
<li>AssemblyName 完整描述程序集的唯一标识。</li>
<li>AssemblyBuilder 构建程序集</li>
</ul>
一个完整的程序集，有很多信息的，版本、作者、构建时间、Token 等，这些可以使用
AssemblyName 来设置。
一般一个程序集需要包含以下内容：
<ul>
<li>简单名称。</li>
<li>版本号。</li>
<li>加密密钥对。</li>
<li>支持的区域性。</li>
</ul>
你可以参考以下示例：
<pre><code class="language-csharp"> AssemblyName assemblyName = new AssemblyName("MyTest");
 assemblyName.Name = "MyTest"; // 构造函数中已经设置，此处可以忽略

 // Version 表示程序集、操作系统或公共语言运行时的版本号.
 // 构造函数比较多，可以选用主版本号、次版本号、内部版本号和修订号
 // 请参考 https://docs.microsoft.com/zh-cn/dotnet/api/system.version?view=netcore-3.1
 assemblyName.Version = new Version("1.0.0");
 assemblyName.CultureName = CultureInfo.CurrentCulture.Name; // = "zh-CN"
 assemblyName.SetPublicKeyToken(new Guid().ToByteArray());
</code></pre>
最终程序集的 AssemblyName 显示名称是以下格式的字符串：
<pre><code>Name <,Culture = CultureInfo> <,Version = Major.Minor.Build.Revision> <, StrongName> <,PublicKeyToken> '\0'
</code></pre>
例如：
<pre><code>ExampleAssembly, Version=1.0.0.0, Culture=en, PublicKeyToken=a5d015c7d5a0b012
</code></pre>
另外，创建程序集构建器使用 <code>AssemblyBuilder.DefineDynamicAssembly()</code> 而不是 <code>new AssemblyBuilder()</code> 。
<h3 id="2模块module">2,模块（Module）</h3>
程序集和模块之间的区别可以参考
https://stackoverflow.com/questions/9271805/net-module-vs-assembly
https://stackoverflow.com/questions/645728/what-is-a-module-in-net
模块是程序集内代码的逻辑集合，每个模块可以使用不同的语言编写，大多数情况下，一个程序集包含一个模块。程序集包括了代码、版本信息、元数据等。
MSDN指出：“模块是没有 Assembly 清单的 Microsoft 中间语言（MSIL）文件。”。
这些就不再扯淡了。
创建完程序集后，我们继续来创建模块。
<pre><code class="language-csharp"> AssemblyName assemblyName = new AssemblyName("MyTest");
 AssemblyBuilder assBuilder = AssemblyBuilder.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);

 ModuleBuilder moduleBuilder = assBuilder.DefineDynamicModule("MyTest"); // ⬅
</code></pre>
<h3 id="3类型type">3,类型(Type)</h3>
目前步骤：
<pre><code>Assembly -> Module -> Type 或 Enum
</code></pre>
ModuleBuilder 中有个 <code>DefineType</code> 方法用于创建 <code>class</code> 和 <code>struct</code>；<code>DefineEnum</code>方法用于创建 <code>enum</code>。
这里我们分别说明。
创建类或结构体：
<pre><code class="language-csharp">TypeBuilder typeBuilder = moduleBuilder.DefineType("MyTest.MyClass",TypeAttributes.Public);
</code></pre>
定义的时候，注意名称是完整的路径名称，即命名空间+类型名称。
我们可以先通过反射，获取已经构建的代码信息：
<pre><code class="language-csharp"> Console.WriteLine($"程序集信息：{type.Assembly.FullName}");
 Console.WriteLine($"命名空间：{type.Namespace} , 类型：{type.Name}");
</code></pre>
结果：
<pre><code>程序集信息：MyTest, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null
命名空间：MyTest , 类型：MyClass
</code></pre>
接下来将创建一个枚举类型，并且生成枚举。
我们要创建一个这样的枚举：
<pre><code class="language-csharp">namespace MyTest
{
public enum MyEnum
{
 Top = 1,
 Bottom = 2,
 Left = 4,
 Right = 8,
 All = 16
}
}
</code></pre>
使用 Emit 的创建过程如下：
<pre><code class="language-csharp">EnumBuilder enumBuilder = moduleBuilder.DefineEnum("MyTest.MyEnum", TypeAttributes.Public, typeof(int));
</code></pre>
TypeAttributes 有很多枚举，这里只需要知道声明这个枚举类型为公开的(Public)；<code>typeof(int)</code> 是设置枚举数值基础类型。
然后 EnumBuilder 使用 <code>DefineLiteral</code> 方法来创建枚举。
<table>
<thead>
<tr>
<th>方法</th>
<th>说明</th>
</tr>
</thead>
<tbody>
<tr>
<td>DefineLiteral(String, Object)</td>
<td>在枚举类型中使用指定的常量值定义命名的静态字段。</td>
</tr>
</tbody>
</table>
代码如下：
<pre><code class="language-csharp"> enumBuilder.DefineLiteral("Top", 0);
 enumBuilder.DefineLiteral("Bottom", 1);
 enumBuilder.DefineLiteral("Left", 2);
 enumBuilder.DefineLiteral("Right", 4);
 enumBuilder.DefineLiteral("All", 8);
</code></pre>
我们可以使用反射将创建的枚举打印出来：
<pre><code class="language-csharp"> public static void WriteEnum(TypeInfo info)
 {
 var myEnum = Activator.CreateInstance(info);
 Console.WriteLine($"{(info.IsPublic ? "public" : "private")} {(info.IsEnum ? "enum" : "class")} {info.Name}");
 Console.WriteLine("{");
 var names = Enum.GetNames(info);
 int[] values = (int[])Enum.GetValues(info);
 int i = 0;
 foreach (var item in names)
 {
 Console.WriteLine($" {item} = {values}");
 i++;
 }
 Console.WriteLine("}");
 }
</code></pre>
Main 方法中调用：
<pre><code class="language-csharp"> WriteEnum(enumBuilder.CreateTypeInfo());
</code></pre>
接下来，类型创建成员，就复杂得多了。
<h3 id="4dynamicmethod-定义方法与添加-il">4,DynamicMethod 定义方法与添加 IL</h3>
下面我们来为类型创建一个方法，并通过 Emit 向程序集中动态添加 IL。这里并不是使用 MethodBuider，而是使用 DynamicMethod。
在开始之前，请自行安装反编译工具 dnSpy 或者其它工具，因为这里涉及到 IL 代码。
这里我们先忽略前面编写的代码，清空 Main 方法。
我们创建一个类型：
<pre><code class="language-csharp"> public class MyClass{}
</code></pre>
这个类型什么都没有。
然后使用 Emit 动态创建一个方法，并且附加到 MyClass 类型中：
<pre><code class="language-csharp"> // 动态创建一个方法并且附加到 MyClass 类型中
 DynamicMethod dyn = new DynamicMethod("Foo",null,null,typeof(MyClass));
 ILGenerator iLGenerator = dyn.GetILGenerator();

 iLGenerator.EmitWriteLine("HelloWorld");
 iLGenerator.Emit(OpCodes.Ret);

 dyn.Invoke(null,null);
</code></pre>
运行后会打印字符串。
DynamicMethod 类型用于构建方法，定义并表示可以编译、执行和丢弃的一种动态方法。丢弃的方法可用于垃圾回收。。
ILGenerator 是 IL 代码生成器。
EmitWriteLine 作用是打印字符串，
OpCodes.Ret 标记结束方法的执行，
Invoke 将方法转为委托执行。
上面的示例比较简单，请认真记一下。
下面，我们要使用 Emit 生成一个这样的方法：
<pre><code class="language-csharp"> public int Add(int a,int b)
 {
 return a + b;
 }
</code></pre>
看起来很简单的代码，要用 IL 来写，就变得复杂了。
ILGenerator 正是使用 C# 代码的形式去写 IL，但是所有过程都必须按照 IL 的步骤去写。
其中最重要的，便是 OpCodes 枚举了，OpCodes 有几十个枚举，代表了 IL 的所有操作功能。
请参考：https://docs.microsoft.com/zh-cn/dotnet/api/system.reflection.emit.opcodes?view=netcore-3.1
如果你点击上面的链接查看 OpCodes 的枚举，你可以看到，很多功能码，这么多功能码是记不住的。我们现在刚开始学习 Emit，这样就会难上加难。
所以，我们要先下载能够查看 IL 代码的工具，方便我们探索和调整写法。
我们看看此方法生成的 IL 代码：
<pre><code class="language-csharp">.method public hidebysig instance int32
Add(
 int32 a,
 int32 b
) cil managed
{
.maxstack 2
.locals init (
 int32 V_0
)

//
IL_0000: nop

//
IL_0001: ldarg.1 // a
IL_0002: ldarg.2 // b
IL_0003: add
IL_0004: stloc.0 // V_0
IL_0005: br.s IL_0007

//
IL_0007: ldloc.0 // V_0
IL_0008: ret

} // end of method MyClass::Add
</code></pre>
看不懂完全没关系，因为笔者也看不懂。
目前我们已经获得了上面两大部分的信息，接下来我们使用 <code>DynamicMethod</code> 来动态编写方法。
定义 Add 方法并获取 IL 生成工具：
<pre><code class="language-csharp"> DynamicMethod dynamicMethod = new DynamicMethod("Add",typeof(int),new Type[] { typeof(int),typeof(int)});
 ILGenerator ilCode = dynamicMethod.GetILGenerator();
</code></pre>
DynamicMethod 用于定义一个方法；ILGenerator是 IL 生成器。当然也可以将此方法附加到一个类型中，完整代码示例如下：
<pre><code class="language-csharp"> // typeof(Program)，表示将此动态编写的方法附加到 MyClass 中
 DynamicMethod dynamicMethod = new DynamicMethod("Add", typeof(int), new Type[] { typeof(int), typeof(int) },typeof(MyClass));

 ILGenerator ilCode = dynamicMethod.GetILGenerator();

 ilCode.Emit(OpCodes.Ldarg_0); // a,将索引为 0 的自变量加载到计算堆栈上。
 ilCode.Emit(OpCodes.Ldarg_1); // b,将索引为 1 的自变量加载到计算堆栈上。
 ilCode.Emit(OpCodes.Add); // 将两个值相加并将结果推送到计算堆栈上。

 // 下面指令不需要，默认就是弹出计算堆栈的结果
 //ilCode.Emit(OpCodes.Stloc_0); // 将索引 0 处的局部变量加载到计算堆栈上。
 //ilCode.Emit(OpCodes.Br_S); // 无条件地将控制转移到目标指令（短格式）。
 //ilCode.Emit(OpCodes.Ldloc_0); // 将索引 0 处的局部变量加载到计算堆栈上。

 ilCode.Emit(OpCodes.Ret); // 即 return，从当前方法返回，并将返回值（如果存在）从被调用方的计算堆栈推送到调用方的计算堆栈上。

 // 方法1
 Func<int, int, int> test = (Func<int, int, int>)dynamicMethod.CreateDelegate(typeof(Func<int, int, int>));
 Console.WriteLine(test(1, 2));

 // 方法2
 int sum = (int)dynamicMethod.Invoke(null, BindingFlags.Public, null, new object[] { 1, 2 }, CultureInfo.CurrentCulture);
 Console.WriteLine(sum);
</code></pre>
实际以上代码与我们反编译出来的 IL 编写有所差异，具体俺也不知道为啥，在群里问了调试了，注释掉那么几行代码，才通过的。

</div>
<div id="MySignature" role="contentinfo">
痴者工良(https://whuanle.cn) 
来源：https://www.cnblogs.com/whuanle/p/13096311.html

頁: [1]

琼殿技术论坛's Archiver

C# 反射与特性(十)：EMIT 构建代码