C# 反射與特性(十)：EMIT 構建程式碼

目錄

• 構建程式碼
  • 1,程式集(Assembly)
  • 2,模組（Module）
  • 3,型別(Type)
  • 4,DynamicMethod 定義方法與新增 IL

前面，本系列一共寫了 九 篇關於反射和特性相關的文章，講解了如何從程式集中通過反射將資訊解析出來，以及例項化型別。

前面的九篇文章中，重點在於讀資料，使用已經構建好的資料結構(後設資料等)，接下來，我們將學習 .NET Core 中，關於動態構建程式碼的知識。

其中表示式樹已經在另一個系列寫了，所以本系列主要是講述 反射，Emit ，AOP 等內容。

如果現在總結一下，反射，與哪些資料結構相關？

我們可以從 AttributeTargets 列舉中窺見：

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
}

分別是程式集、模組、類、結構體、列舉、建構函式、方法、屬性、欄位、事件、介面、引數、委託、返回值。

以往的文章中，已經對這些進行了很詳細的講解，我們可以中反射中獲得各種各樣的資訊。當然，我們也可以通過動態程式碼，生成以上資料結構。

動態程式碼的其中一種方式是表示式樹，我們還可以使用 Emit 技術、Roslyn 技術來編寫；相關的框架有 Natasha、CS-Script 等。

構建程式碼

首先我們引入一個名稱空間：

using System.Reflection.Emit;

Emit 名稱空間中裡面有很多用於構建動態程式碼的型別，例如 AssemblyBuilder，這個型別用於構建程式集。類推，構建其它資料結構例如方法屬性，則有 MethodBuilder、PropertyBuilder 。

1,程式集(Assembly)

AssemblyBuilder 型別定義並表示動態程式集，它是一個密封類，其定義如下：

public sealed class AssemblyBuilder : Assembly

AssemblyBuilderAccess 定義動態程式集的訪問模式，在 .NET Core 中，只有兩個列舉：

列舉	值	說明
Run	1	可以執行但無法儲存該動態程式集。
RunAndCollect	9	當動態程式集不再可供訪問時，將自動解除安裝該程式集，並回收其記憶體。

.NET Framework 中，有 RunAndSave 、Save 等列舉，可用於儲存構建的程式集，但是在 .NET Core 中，是沒有這些列舉的，也就是說，Emit 構建的程式集只能在記憶體中，是無法儲存成 .dll 檔案的。

另外，程式集的構建方式(API)也做了變更，如果你百度看到文章 AppDomain.CurrentDomain.DefineDynamicAssembly，那麼你可以關閉建立了，說明裡面的很多程式碼根本無法在 .NET Core 下跑。

好了，不再贅述，我們來看看建立一個程式集的程式碼：

            AssemblyName assemblyName = new AssemblyName("MyTest");
            AssemblyBuilder assBuilder = AssemblyBuilder.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);

構建程式集，分為兩部分：

• AssemblyName 完整描述程式集的唯一標識。
• AssemblyBuilder 構建程式集

一個完整的程式集，有很多資訊的，版本、作者、構建時間、Token 等，這些可以使用

AssemblyName 來設定。

一般一個程式集需要包含以下內容：

• 簡單名稱。
• 版本號。
• 加密金鑰對。
• 支援的區域性。

你可以參考以下示例：

            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());

最終程式集的 AssemblyName 顯示名稱是以下格式的字串：

Name <,Culture = CultureInfo> <,Version = Major.Minor.Build.Revision> <, StrongName> <,PublicKeyToken> '\0'

例如：

ExampleAssembly, Version=1.0.0.0, Culture=en, PublicKeyToken=a5d015c7d5a0b012

另外，建立程式集構建器使用 AssemblyBuilder.DefineDynamicAssembly() 而不是 new AssemblyBuilder() 。

2,模組（Module）

程式集和模組之間的區別可以參考

https://stackoverflow.com/questions/9271805/net-module-vs-assembly

https://stackoverflow.com/questions/645728/what-is-a-module-in-net

模組是程式集內程式碼的邏輯集合，每個模組可以使用不同的語言編寫，大多數情況下，一個程式集包含一個模組。程式集包括了程式碼、版本資訊、後設資料等。

MSDN指出：“模組是沒有 Assembly 清單的 Microsoft 中間語言（MSIL）檔案。”。

這些就不再扯淡了。

建立完程式集後，我們繼續來建立模組。

            AssemblyName assemblyName = new AssemblyName("MyTest");
            AssemblyBuilder assBuilder = AssemblyBuilder.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);

            ModuleBuilder moduleBuilder = assBuilder.DefineDynamicModule("MyTest");             // ⬅

3,型別(Type)

目前步驟：

Assembly -> Module -> Type 或 Enum

ModuleBuilder 中有個 DefineType 方法用於建立 class 和 struct；DefineEnum方法用於建立 enum。

這裡我們分別說明。

建立類或結構體：

TypeBuilder typeBuilder = moduleBuilder.DefineType("MyTest.MyClass",TypeAttributes.Public);

定義的時候，注意名稱是完整的路徑名稱，即名稱空間+型別名稱。

我們可以先通過反射，獲取已經構建的程式碼資訊：

            Console.WriteLine($"程式集資訊：{type.Assembly.FullName}");
            Console.WriteLine($"名稱空間：{type.Namespace} , 型別：{type.Name}");

結果：

程式集資訊：MyTest, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null
名稱空間：MyTest , 型別：MyClass

接下來將建立一個列舉型別，並且生成列舉。

我們要建立一個這樣的列舉：

namespace MyTest
{
    public enum MyEnum
    {
        Top = 1,
        Bottom = 2,
        Left = 4,
        Right = 8,
        All = 16
    }
}

使用 Emit 的建立過程如下：

EnumBuilder enumBuilder = moduleBuilder.DefineEnum("MyTest.MyEnum", TypeAttributes.Public, typeof(int));

TypeAttributes 有很多列舉，這裡只需要知道宣告這個列舉型別為 公開的(Public)；typeof(int) 是設定列舉數值基礎型別。

然後 EnumBuilder 使用 DefineLiteral 方法來建立列舉。

方法	說明
DefineLiteral(String, Object)	在列舉型別中使用指定的常量值定義命名的靜態欄位。

程式碼如下：

            enumBuilder.DefineLiteral("Top", 0);
            enumBuilder.DefineLiteral("Bottom", 1);
            enumBuilder.DefineLiteral("Left", 2);
            enumBuilder.DefineLiteral("Right", 4);
            enumBuilder.DefineLiteral("All", 8);

我們可以使用反射將建立的列舉列印出來：

        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]}");
                i++;
            }
            Console.WriteLine("}");
        }

Main 方法中呼叫：

 WriteEnum(enumBuilder.CreateTypeInfo());

接下來，型別建立成員，就複雜得多了。

4,DynamicMethod 定義方法與新增 IL

下面我們來為 型別建立一個方法，並通過 Emit 向程式集中動態新增 IL。這裡並不是使用 MethodBuider，而是使用 DynamicMethod。

在開始之前，請自行安裝反編譯工具 dnSpy 或者其它工具，因為這裡涉及到 IL 程式碼。

這裡我們先忽略前面編寫的程式碼，清空 Main 方法。

我們建立一個型別：

    public class MyClass{}

這個型別什麼都沒有。

然後使用 Emit 動態建立一個 方法，並且附加到 MyClass 型別中：

            // 動態建立一個方法並且附加到 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);

執行後會列印字串。

DynamicMethod 型別用於構建方法，定義並表示可以編譯、執行和丟棄的一種動態方法。 丟棄的方法可用於垃圾回收。。

ILGenerator 是 IL 程式碼生成器。

EmitWriteLine 作用是列印字串，

OpCodes.Ret 標記 結束方法的執行，

Invoke 將方法轉為委託執行。

上面的示例比較簡單，請認真記一下。

下面，我們要使用 Emit 生成一個這樣的方法：

        public int Add(int a,int b)
        {
            return a + b;
        }

看起來很簡單的程式碼，要用 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 程式碼：

  .method public hidebysig instance int32
    Add(
      int32 a,
      int32 b
    ) cil managed
  {
    .maxstack 2
    .locals init (
      [0] int32 V_0
    )

    // [14 9 - 14 10]
    IL_0000: nop

    // [15 13 - 15 26]
    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

    // [16 9 - 16 10]
    IL_0007: ldloc.0      // V_0
    IL_0008: ret

  } // end of method MyClass::Add

看不懂完全沒關係，因為筆者也看不懂。

目前我們已經獲得了上面兩大部分的資訊，接下來我們使用 DynamicMethod 來動態編寫方法。

定義 Add 方法並獲取 IL 生成工具：

            DynamicMethod dynamicMethod = new DynamicMethod("Add",typeof(int),new Type[] { typeof(int),typeof(int)});
            ILGenerator ilCode = dynamicMethod.GetILGenerator();

DynamicMethod 用於定義一個方法；ILGenerator是 IL 生成器。當然也可以將此方法附加到一個型別中，完整程式碼示例如下：

            // 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);

實際以上程式碼與我們反編譯出來的 IL 編寫有所差異，具體俺也不知道為啥，在群裡問了除錯了，註釋掉那麼幾行程式碼，才通過的。