.NET Emit 入門教程：第二部分：構建動態程式集（追加構建靜態程式集教程）

路过秋天發表於2024-03-21
MIT

前言：

在本部分中，我們將深入探討如何使用C# Emit 來建立動態程式集。

動態程式集是在執行時生成的，為我們提供了一種靈活、動態地構建和載入程式集的能力。

1. 程式集的概念

程式集是.NET中的基本部署單位，它包含了可執行程式碼、資源、後設資料等資訊，是.NET應用程式的基本組成單元之一。

與靜態程式集（即程式集持久化）不同，動態程式集是在執行時生成的，使得我們可以根據需要動態地構建和載入程式集。

動態程式集的重要性體現在多個方面，包括但不限於模組化、版本控制、程式碼複用等。

透過動態程式集，我們可以更好地管理和組織程式碼，實現更靈活的程式設計和開發。

2、Emit 構建程式集支援情況：

.Net 系列：動態程式集：支援；程式集持久化：支援。

.Net Core 系列：動態程式集：支援；程式集持久化：不支援。

3、Emit 建立動態程式集：

在C#中，操作程式集的核心類是：AssemblyBuilder。

在這過程，我們可以使用 AssemblyName 來定義程式集的名稱和版本等資訊。

AssemblyName assemblyName = new AssemblyName("MyDllName") { Version = new Version("1.0.0.0") };

建立程式集物件，在 .Net 和 .Net Core 中有所不同：

.NET 程式碼：透過 AppDomain.DefineDynamicAssembly 來建立動態程式集物件：

AssemblyBuilder assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);

AssemblyBuilderAccess 在 .Net 系列中的屬性：

AssemblyBuilderAccess.Run; 表示程式集可被執行，但不能被儲存。　　
AssemblyBuilderAccess.Save; 表示程式集可被儲存，但不能被執行。　　
AssemblyBuilderAccess.RunAndSave; 表示程式集可被儲存並能被執行。
AssemblyBuilderAccess.ReflectionOnly; 表示程式集只能用於反射上下文環境中，不能被執行。　
AssemblyBuilderAccess.RunAndCollect; 表示程式集可以被解除安裝並且記憶體會被回收

.NET Core 程式碼：透過 AssemblyBuilder.DefineDynamicAssembly 來建立動態程式集物件：

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

AssemblyBuilderAccess 在 .Net Core 系列中的屬性：

AssemblyBuilderAccess.Run; 表示程式集可被執行，但不能被儲存。　　
AssemblyBuilderAccess.Collect; 表示程式集可以被解除安裝並且記憶體會被回收

可以看到，目前版本是不支援持久化功能。

4：總結一：

在本章節中，我們討論瞭如何使用 C# Emit 來構建動態程式集，以獲得 AssemblyBuilder 這個程式集構建器，開啟構建程式集的第一步。

在之後的文章，我們會講解如何用它的 DefineDynamicModule 來定義模組，以之後構建類、成員、方法等，來實現構建完整的程式集。

當然，對於構建動態程式集，本文章到此會顯的有點簡單，為了避免被大夥說文章太水。

於是，打算追加一下對於構建靜態程式集（即持久化程式集）的相關知識。

構建靜態程式集的三種方式：

.Net 系列：使用 Emit 或 CodeDom（System.CodeDom.Compiler 系統整合）

.Net Core 系列：Roslyn（Microsoft.CodeAnalysis.CSharp 需要引用元件包）

5、Emit 構建靜態程式集：

在上述程式碼中，我們透過 AssemblyName 來指定程式集名稱和版本號。

如果我們希望持久化程式集，並將程式集分發給其它人呼叫，則需要補充更多的相關資訊：

比如：Taurus.MVC 微服務元件中就實現了動態生成 Rpc 呼叫程式集，以供其它微服務節點呼叫。

在定義完程式集名稱和版本後（AssemblyBuilderAccess 需要指定為 RunAndSave ）。

我們可以透過 AssemblyBuilder 的 SetCustomAttribute 方法，來新增自定義屬性，最後透過 Save 方法，來持久化程式集：

internal class Program
{
    static void Main(string[] args)
    {
        string dllName = "MyDynamic";
        string title = "This is a dynamic title.";

        AssemblyName assemblyName = new AssemblyName(dllName) { Version = new Version("3.0.0.0") };
        AssemblyBuilder assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.RunAndSave);

        // 新增自定義屬性到程式集var titleAttr = new CustomAttributeBuilder(
           typeof(AssemblyTitleAttribute).GetConstructor(new Type[] { typeof(string) }),
           new object[] { title }
       );
        assemblyBuilder.SetCustomAttribute(titleAttr);

        assemblyBuilder.DefineVersionInfoResource();
       
        assemblyBuilder.Save(dllName + ".dll");

        Console.WriteLine("程式集已生成");
    }
}

自定義支援哪些屬性，可以參考工程目錄下的：AssemblyInfo.cs 資訊：

沒有指定完整的儲存路徑時，程式執行之後預設在執行目錄下可以看到生成的程式集：

透過反編繹工具，可以看到程式集的相關資訊：

在上面的示例程式碼中，我們追加了一行程式碼如下：

assemblyBuilder.DefineVersionInfoResource();

它讓生成的程式集在 Window 平臺可以看到相關資訊，（不寫入的話，相關內容為空）：

6、使用 CodeDom 生成靜態程式集

CodeDom 的使用比較簡單，無需要引用元件，程式碼編寫也比較簡潔，唯一的缺點，就是不支援 .NET Core 系列。

使用示例程式碼來自Taurus.MVC 微服務RPC程式碼生成（CodeDom 版本）：

更多原始碼：https://github.com/cyq1162/Taurus.MVC/tree/master/src/Taurus.Core/Plugin/MicroService/Client/Proxy/DotNet

 /// <summary>
 /// Rpc 客戶端代理生成類
 /// </summary>
 internal static class RestProxyCreator
 {
     /// <summary>
     /// 構建並儲存程式集
     /// </summary>
     /// <param name="assName">程式集名稱</param>
     /// <param name="savePath">儲存路徑</param>
     public static bool BuildAssembly(string assName, string savePath)
     {
         if (string.IsNullOrEmpty(assName)) { assName = "RpcProxy"; }
         if (string.IsNullOrEmpty(savePath))
         {
             savePath = AppConst.WebRootPath + assName + ".dll";
         }
         else if (!savePath.StartsWith(AppConst.WebRootPath))
         {
             savePath = AppConst.WebRootPath + savePath;
         }
         string version;
         var code = RestProxyCoder.CreateCode(assName, out version);
         var title = assName + " for Taurus MicroService, build on .net " + Environment.Version.ToString();
         var versionCode = RestProxyCoder.CreateVersionCode(title, title, version);

         CodeDomProvider provider = CodeDomProvider.CreateProvider("C#");
         CompilerParameters cp = new CompilerParameters();
         cp.ReferencedAssemblies.Add("System.dll");
         cp.ReferencedAssemblies.Add("System.Web.dll");
         cp.ReferencedAssemblies.Add("System.Xml.dll");
         cp.ReferencedAssemblies.Add("System.Data.dll");
         cp.ReferencedAssemblies.Add(AppConst.AssemblyPath + "CYQ.Data.dll");
         cp.ReferencedAssemblies.Add(AppConst.AssemblyPath + "Taurus.Core.dll");
         cp.GenerateExecutable = false;
         cp.GenerateInMemory = false;
         cp.OutputAssembly = savePath;
         CompilerResults cr = provider.CompileAssemblyFromSource(cp, versionCode, code);
         if (cr == null || cr.Errors.Count > 0) { return false; }
         return true;

     }
 }

7、 使用 Roslyn 生成靜態程式集

Roslyn 需要引用元件，根據自己要支援的最低版本進行引用（如 4.1.0 就是最低支援.NET Core 2.1的版本）：

而且使用麻煩，兩個距坑：

1、Win32 資源資訊如何顯示。

2、程式集引用路徑錯誤問題。

為解決這兩個距坑問題，費了不少時間和精力，畢竟網上國內外只有零散的引導資訊，還有那不靠譜的 GPT 系列。

使用示例程式碼來自 Taurus.MVC 微服務RPC程式碼生成（Roslyn 版本）：

更多原始碼：https://github.com/cyq1162/Taurus.MVC/tree/master/src/Taurus.Core/Plugin/MicroService/Client/Proxy/NetCore

/// <summary>
/// Rpc 客戶端代理生成類
/// </summary>
internal static class RestProxyCreator
{
    /// <summary>
    /// 構建並儲存程式集
    /// </summary>
    /// <param name="assName">程式集名稱</param>
    /// <param name="savePath">儲存路徑</param>
    public static bool BuildAssembly(string assName, string savePath)
    {
        if (string.IsNullOrEmpty(assName)) { assName = "RpcProxy"; }
        if (string.IsNullOrEmpty(savePath))
        {
            savePath = AppConst.WebRootPath + assName + ".dll";
        }
        else if (!savePath.StartsWith(AppConst.WebRootPath))
        {
            savePath = AppConst.WebRootPath + savePath;
        }
        string version;
        var code = RestProxyCoder.CreateCode(assName, out version);
        var title = assName + " for Taurus MicroService, build on .netcore " + Environment.Version.ToString();
        var versionCode = RestProxyCoder.CreateVersionCode(title, title, version);

        SyntaxTree syntaxVersionTree = CSharpSyntaxTree.ParseText(versionCode);
        SyntaxTree syntaxCodeTree = CSharpSyntaxTree.ParseText(code);


        // 定義編譯選項
        CSharpCompilationOptions compilationOptions = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)
        .WithOptimizationLevel(OptimizationLevel.Release); // 設定最佳化級別

        // 建立 Compilation
        CSharpCompilation compilation = CSharpCompilation.Create(assName,
            new[] { syntaxVersionTree, syntaxCodeTree },
            references: AddRef(),
            options: compilationOptions);

        // 編譯並生成程式集
        using (MemoryStream ms = new MemoryStream())
        {
            using (Stream win32resStream = compilation.CreateDefaultWin32Resources(
                                                                        versionResource: true, // 生成版本號。
                                                                        noManifest: false,
                                                                        manifestContents: null,
                                                                        iconInIcoFormat: null))
            {

                EmitResult result = compilation.Emit(ms, win32Resources: win32resStream);

                if (!result.Success)
                {
                    //foreach (var diagnostic in result.Diagnostics)
                    //{
                    //    Console.WriteLine(diagnostic);
                    //}
                    //Console.WriteLine("fail....");
                    return false;
                }
                else
                {
                    // 儲存程式集到檔案
                    using (FileStream file = new FileStream(savePath, FileMode.Create))
                    {
                        ms.Seek(0, SeekOrigin.Begin);
                        ms.CopyTo(file);
                    }
                    //Console.WriteLine("OK....");
                }
            }
        }

        return true;

    }

    /// <summary>
    /// 新增程式集引用
    /// </summary>
    /// <returns></returns>
    private static PortableExecutableReference[] AddRef()
    {
        List<PortableExecutableReference> exeRefs = new List<PortableExecutableReference>();

        string path = typeof(object).Assembly.Location;

        #region 引用路徑修正
        path = Path.GetDirectoryName(path);
        if (path.Contains("\\shared\\Microsoft.NETCore.App"))
        {
            // windows 平臺，這是nuget 實現程式集路徑
            string refPath = path.Replace("\\shared\\Microsoft.NETCore.App", "\\\\packs\\Microsoft.NETCore.App.Ref") + "\\ref";
            if (Directory.Exists(refPath))
            {
                string[] files = Directory.GetDirectories(refPath);
                if (files.Length > 0) { path = files[0] + "\\"; }
            }
        }
        #endregion
        foreach (string dllFilePath in Directory.GetFiles(path, "*.dll"))
        {
            var dll = Path.GetFileName(dllFilePath);

            if (dll.Split(".").Length > 4) { continue; }
            if (dll.StartsWith("Microsoft.")) { continue; }
            if (dll.StartsWith("System.Drawing.")) { continue; }
            if (dll.StartsWith("System.IO.")) { continue; }
            if (dll.StartsWith("System.Linq.")) { continue; }
            if (dll.StartsWith("System.Net.")) { continue; }
            if (dll.StartsWith("System.Reflection.")) { continue; }
            if (dll.StartsWith("System.Security.")) { continue; }
            if (dll.StartsWith("System.Text.")) { continue; }
            if (dll.StartsWith("System.Threading.")) { continue; }
            if (dll.StartsWith("System.Globalization.")) { continue; }
            if (dll.StartsWith("System.Resources.")) { continue; }
            if (dll.StartsWith("System.Transactions.")) { continue; }
            if (dll.StartsWith("System.Memory.")) { continue; }
            if (dll.StartsWith("System.Formats.")) { continue; }
            if (dll.StartsWith("System.ComponentModel.")) { continue; }
            if (dll.StartsWith("System.Windows.")) { continue; }
            if (dll.StartsWith("System.Diagnostics.")) { continue; }
            if (dll.Contains("VisualBasic")) { continue; }


            exeRefs.Add(MetadataReference.CreateFromFile(dllFilePath));
        }


        //新增引用程式集
        string cyqdata = AppConst.AssemblyPath + "CYQ.Data.dll";
        string taurus = AppConst.AssemblyPath + "Taurus.Core.dll";

        exeRefs.Add(MetadataReference.CreateFromFile(cyqdata));
        exeRefs.Add(MetadataReference.CreateFromFile(taurus));
        return exeRefs.ToArray();
    }
}

8、總結：

在本章節中，我們討論瞭如何使用 C# Emit 來構建動態程式集，以獲得 AssemblyBuilder 這個程式集構建器，開啟構建程式集的第一步。

同時我們也討論瞭如何使用 C# Emit 來構建動態程式集以及程式集的持久化。

同時還分享了自己的乾貨，如何使用 CodeDom 和 Roslyn 來構建靜態程式集。

透過本章節的內容，讀者可以掌握如何利用 C# Emit 技術構建動態程式集和靜態程式集，從而實現靈活、動態的程式設計和開發。

動態程式集的應用能夠提升程式碼的模組化性、版本控制和程式碼複用性，為.NET應用程式的開發提供更多可能性。

9、補充： Emit 在 .NET 9 開始重新支援持久化程式集：

示例程式碼：

public void CreateAndSaveAssembly(string assemblyPath)
{
    AssemblyBuilder ab = AssemblyBuilder.DefinePersistedAssembly(
        new AssemblyName("MyAssembly"),
        typeof(object).Assembly
        );
    TypeBuilder tb = ab.DefineDynamicModule("MyModule")
        .DefineType("MyType", TypeAttributes.Public | TypeAttributes.Class);

    MethodBuilder mb = tb.DefineMethod(
        "SumMethod",
        MethodAttributes.Public | MethodAttributes.Static,
        typeof(int), [typeof(int), typeof(int)]
        );
    ILGenerator il = mb.GetILGenerator();
    il.Emit(OpCodes.Ldarg_0);
    il.Emit(OpCodes.Ldarg_1);
    il.Emit(OpCodes.Add);
    il.Emit(OpCodes.Ret);

    tb.CreateType();
    ab.Save(assemblyPath); // or could save to a Stream
}

public void UseAssembly(string assemblyPath)
{
    Assembly assembly = Assembly.LoadFrom(assemblyPath);
    Type type = assembly.GetType("MyType");
    MethodInfo method = type.GetMethod("SumMethod");
    Console.WriteLine(method.Invoke(null, [5, 10]));
}

.NET 9 新功能相關連結：https://learn.microsoft.com/zh-tw/dotnet/core/whats-new/dotnet-9/overview?source=recommendations

相關文章