在本章節中，我們討論瞭如何使用 C# Emit 來構建動態程式集，以獲得 AssemblyBuilder 這個程式集構建器，開啟構建程式集的第一步。同時我們也討論瞭如何使用 C# Emit 來構建動態程式集以及程式集的持久化。同時還分享了自己的乾貨，如何使用 CodeDom 和 Roslyn 來構建... ...

前言：

在本部分中，我們將深入探討如何使用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 版本）：

 /// <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 版本）：

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