.NET Emit 入门教程：第二部分：构建动态程序集（追加构建静态程序集教程）

一路欢唱

前言：

在本部分中，我们将深入探讨如何使用C# Emit 来创建动态程序集。
动态程序集是在运行时生成的，为我们提供了一种灵活、动态地构建和加载程序集的能力。
1. 程序集的概念

程序集是.NET中的基本部署单位，它包含了可执行代码、资源、元数据等信息，是.NET应用程序的基本组成单元之一。
与静态程序集（即程序集持久化）不同，动态程序集是在运行时生成的，使得我们可以根据需要动态地构建和加载程序集。
动态程序集的重要性体现在多个方面，包括但不限于模块化、版本控制、代码复用等。
通过动态程序集，我们可以更好地管理和组织代码，实现更灵活的程序设计和开发。
2、Emit 构建程序集支持情况：

1. .Net 系列：动态程序集：<strong>支持</strong>；程序集持久化：<strong>支持</strong>。
3. .Net Core 系列：动态程序集：<strong>支持</strong>；程序集持久化<strong>：不支持</strong>。

复制代码

 3、Emit 创建动态程序集：

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

在这过程，我们可以使用  AssemblyName 来定义程序集的名称和版本等信息。

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

复制代码

创建程序集对象，在 .Net 和 .Net Core 中有所不同：
.NET 代码：通过 AppDomain.DefineDynamicAssembly 来创建动态程序集对象：

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

复制代码

AssemblyBuilderAccess 在 .Net 系列中的属性：

1. AssemblyBuilderAccess.Run; 表示程序集可被执行，但不能被保存。　　
2. AssemblyBuilderAccess.Save; 表示程序集可被保存，但不能被执行。　　
3. AssemblyBuilderAccess.RunAndSave; 表示程序集可被保存并能被执行。
4. AssemblyBuilderAccess.ReflectionOnly; 表示程序集只能用于反射上下文环境中，不能被执行。　
5. AssemblyBuilderAccess.RunAndCollect; 表示程序集可以被卸载并且内存会被回收

复制代码

.NET Core 代码：通过 AssemblyBuilder.DefineDynamicAssembly 来创建动态程序集对象：

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

复制代码

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

1. AssemblyBuilderAccess.Run; 表示程序集可被执行，但不能被保存。　　
2. AssemblyBuilderAccess.Collect; 表示程序集可以被卸载并且内存会被回收

复制代码

 可以看到，目前版本是不支持持久化功能。
4：总结一：

在本章节中，我们讨论了如何使用 C# Emit 来构建动态程序集，以获得 AssemblyBuilder 这个程序集构建器，开启构建程序集的第一步。
在之后的文章，我们会讲解如何用它的 DefineDynamicModule 来定义模块，以之后构建类、成员、方法等，来实现构建完整的程序集。
当然，对于构建动态程序集，本文章到此会显的有点简单，为了避免被大伙说文章太水。
于是，打算追加一下对于构建静态程序集（即持久化程序集）的相关知识。
构建静态程序集的三种方式：

1. .Net 系列：使用 <strong>Emit</strong> 或 <strong>CodeDom</strong>（System.CodeDom.Compiler 系统集成）
3. .Net Core 系列：<strong>Roslyn</strong>（Microsoft.CodeAnalysis.CSharp 需要引用组件包）

复制代码

5、Emit 构建静态程序集：

在上述代码中，我们通过 AssemblyName 来指定程序集名称和版本号。
如果我们希望持久化程序集，并将程序集分发给其它人调用，则需要补充更多的相关信息：

1. 比如：<a href="https://github.com/cyq1162/Taurus.MVC" target="_blank" rel="noopener">Taurus.MVC</a> 微服务组件中就实现了动态生成 Rpc 调用程序集，以供其它微服务节点调用。

复制代码

在定义完程序集名称和版本后（AssemblyBuilderAccess 需要指定为 RunAndSave ）。
我们可以通过 AssemblyBuilder  的 SetCustomAttribute 方法，来添加自定义属性，最后通过 Save 方法，来持久化程序集：

1. internal class Program
2. {
3.     static void Main(string[] args)
4.     {
5.         string dllName = "MyDynamic";
6.         string title = "This is a dynamic title.";
8.         AssemblyName assemblyName = new AssemblyName(dllName) { Version = new Version("3.0.0.0") };
9.         AssemblyBuilder assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.RunAndSave);
11.         // 添加自定义属性到程序集var titleAttr = new CustomAttributeBuilder(
12.            typeof(AssemblyTitleAttribute).GetConstructor(new Type[] { typeof(string) }),
13.            new object[] { title }
14.        );
15.         assemblyBuilder.SetCustomAttribute(titleAttr);
17.         assemblyBuilder.DefineVersionInfoResource();
18.       
19.         assemblyBuilder.Save(dllName + ".dll");
21.         Console.WriteLine("程序集已生成");
22.     }
23. }

复制代码

自定义支持哪些属性，可以参考工程目录下的：AssemblyInfo.cs 信息：

没有指定完整的保存路径时，程序运行之后默认在运行目录下可以看到生成的程序集：

通过反编绎工具，可以看到程序集的相关信息：

在上面的示例代码中，我们追加了一行代码如下：

1. 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

1. /// <summary>
2. /// Rpc 客户端代理生成类
3. /// </summary>
4. internal static class RestProxyCreator
5. {
6.      /// <summary>
7.      /// 构建并保存程序集
8.      /// </summary>
9.      /// <param name="assName">程序集名称</param>
10.      /// <param name="savePath">保存路径</param>
11.      public static bool BuildAssembly(string assName, string savePath)
12.      {
13.          if (string.IsNullOrEmpty(assName)) { assName = "RpcProxy"; }
14.          if (string.IsNullOrEmpty(savePath))
15.          {
16.              savePath = AppConst.WebRootPath + assName + ".dll";
17.          }
18.          else if (!savePath.StartsWith(AppConst.WebRootPath))
19.          {
20.              savePath = AppConst.WebRootPath + savePath;
21.          }
22.          string version;
23.          var code = RestProxyCoder.CreateCode(assName, out version);
24.          var title = assName + " for Taurus MicroService, build on .net " + Environment.Version.ToString();
25.          var versionCode = RestProxyCoder.CreateVersionCode(title, title, version);
27.          CodeDomProvider provider = CodeDomProvider.CreateProvider("C#");
28.          CompilerParameters cp = new CompilerParameters();
29.          cp.ReferencedAssemblies.Add("System.dll");
30.          cp.ReferencedAssemblies.Add("System.Web.dll");
31.          cp.ReferencedAssemblies.Add("System.Xml.dll");
32.          cp.ReferencedAssemblies.Add("System.Data.dll");
33.          cp.ReferencedAssemblies.Add(AppConst.AssemblyPath + "CYQ.Data.dll");
34.          cp.ReferencedAssemblies.Add(AppConst.AssemblyPath + "Taurus.Core.dll");
35.          cp.GenerateExecutable = false;
36.          cp.GenerateInMemory = false;
37.          cp.OutputAssembly = savePath;
38.          CompilerResults cr = provider.CompileAssemblyFromSource(cp, versionCode, code);
39.          if (cr == null || cr.Errors.Count > 0) { return false; }
40.          return true;
42.      }
43. }

复制代码

7、 使用 Roslyn 生成静态程序集

Roslyn 需要引用组件，根据自己要支持的最低版本进行引用（如 4.1.0 就是最低支持.NET Core 2.1的版本）：

而且使用麻烦，两个距坑：

1. 1、Win32 资源信息如何显示。
3. 2、程序集引用路径错误问题。

复制代码

为解决这两个距坑问题，费了不少时间和精力，毕竟网上国内外只有零散的引导信息，还有那不靠谱的 GPT 系列。
使用示例代码来自 Taurus.MVC 微服务RPC代码生成（Roslyn 版本）：
更多源码：https://github.com/cyq1162/Taurus.MVC/tree/master/src/Taurus.Core/Plugin/MicroService/Client/Proxy/NetCore

1. /// <summary>
2. /// Rpc 客户端代理生成类
3. /// </summary>
4. internal static class RestProxyCreator
5. {
6.     /// <summary>
7.     /// 构建并保存程序集
8.     /// </summary>
9.     /// <param name="assName">程序集名称</param>
10.     /// <param name="savePath">保存路径</param>
11.     public static bool BuildAssembly(string assName, string savePath)
12.     {
13.         if (string.IsNullOrEmpty(assName)) { assName = "RpcProxy"; }
14.         if (string.IsNullOrEmpty(savePath))
15.         {
16.             savePath = AppConst.WebRootPath + assName + ".dll";
17.         }
18.         else if (!savePath.StartsWith(AppConst.WebRootPath))
19.         {
20.             savePath = AppConst.WebRootPath + savePath;
21.         }
22.         string version;
23.         var code = RestProxyCoder.CreateCode(assName, out version);
24.         var title = assName + " for Taurus MicroService, build on .netcore " + Environment.Version.ToString();
25.         var versionCode = RestProxyCoder.CreateVersionCode(title, title, version);
27.         SyntaxTree syntaxVersionTree = CSharpSyntaxTree.ParseText(versionCode);
28.         SyntaxTree syntaxCodeTree = CSharpSyntaxTree.ParseText(code);
31.         // 定义编译选项
32.         CSharpCompilationOptions compilationOptions = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)
33.         .WithOptimizationLevel(OptimizationLevel.Release); // 设置优化级别
35.         // 创建 Compilation
36.         CSharpCompilation compilation = CSharpCompilation.Create(assName,
37.             new[] { syntaxVersionTree, syntaxCodeTree },
38.             references: AddRef(),
39.             options: compilationOptions);
41.         // 编译并生成程序集
42.         using (MemoryStream ms = new MemoryStream())
43.         {
44.             using (Stream win32resStream = compilation.CreateDefaultWin32Resources(
45.                                                                         versionResource: true, // 生成版本号。
46.                                                                         noManifest: false,
47.                                                                         manifestContents: null,
48.                                                                         iconInIcoFormat: null))
49.             {
51.                 EmitResult result = compilation.Emit(ms, win32Resources: win32resStream);
53.                 if (!result.Success)
54.                 {
55.                     //foreach (var diagnostic in result.Diagnostics)
56.                     //{
57.                     //    Console.WriteLine(diagnostic);
58.                     //}
59.                     //Console.WriteLine("fail....");
60.                     return false;
61.                 }
62.                 else
63.                 {
64.                     // 保存程序集到文件
65.                     using (FileStream file = new FileStream(savePath, FileMode.Create))
66.                     {
67.                         ms.Seek(0, SeekOrigin.Begin);
68.                         ms.CopyTo(file);
69.                     }
70.                     //Console.WriteLine("OK....");
71.                 }
72.             }
73.         }
75.         return true;
77.     }
79.     /// <summary>
80.     /// 添加程序集引用
81.     /// </summary>
82.     /// <returns></returns>
83.     private static PortableExecutableReference[] AddRef()
84.     {
85.         List<PortableExecutableReference> exeRefs = new List<PortableExecutableReference>();
87.         string path = typeof(object).Assembly.Location;
89.         #region 引用路径修正
90.         path = Path.GetDirectoryName(path);
91.         if (path.Contains("\\shared\\Microsoft.NETCore.App"))
92.         {
93.             // windows 平台，这是nuget 实现程序集路径
94.             string refPath = path.Replace("\\shared\\Microsoft.NETCore.App", "\\\\packs\\Microsoft.NETCore.App.Ref") + "\\ref";
95.             if (Directory.Exists(refPath))
96.             {
97.                 string[] files = Directory.GetDirectories(refPath);
98.                 if (files.Length > 0) { path = files[0] + "\"; }
99.             }
100.         }
101.         #endregion
102.         foreach (string dllFilePath in Directory.GetFiles(path, "*.dll"))
103.         {
104.             var dll = Path.GetFileName(dllFilePath);
106.             if (dll.Split(".").Length > 4) { continue; }
107.             if (dll.StartsWith("Microsoft.")) { continue; }
108.             if (dll.StartsWith("System.Drawing.")) { continue; }
109.             if (dll.StartsWith("System.IO.")) { continue; }
110.             if (dll.StartsWith("System.Linq.")) { continue; }
111.             if (dll.StartsWith("System.Net.")) { continue; }
112.             if (dll.StartsWith("System.Reflection.")) { continue; }
113.             if (dll.StartsWith("System.Security.")) { continue; }
114.             if (dll.StartsWith("System.Text.")) { continue; }
115.             if (dll.StartsWith("System.Threading.")) { continue; }
116.             if (dll.StartsWith("System.Globalization.")) { continue; }
117.             if (dll.StartsWith("System.Resources.")) { continue; }
118.             if (dll.StartsWith("System.Transactions.")) { continue; }
119.             if (dll.StartsWith("System.Memory.")) { continue; }
120.             if (dll.StartsWith("System.Formats.")) { continue; }
121.             if (dll.StartsWith("System.ComponentModel.")) { continue; }
122.             if (dll.StartsWith("System.Windows.")) { continue; }
123.             if (dll.StartsWith("System.Diagnostics.")) { continue; }
124.             if (dll.Contains("VisualBasic")) { continue; }
127.             exeRefs.Add(MetadataReference.CreateFromFile(dllFilePath));
128.         }
131.         //添加引用程序集
132.         string cyqdata = AppConst.AssemblyPath + "CYQ.Data.dll";
133.         string taurus = AppConst.AssemblyPath + "Taurus.Core.dll";
135.         exeRefs.Add(MetadataReference.CreateFromFile(cyqdata));
136.         exeRefs.Add(MetadataReference.CreateFromFile(taurus));
137.         return exeRefs.ToArray();
138.     }
139. }

复制代码

8、总结：

在本章节中，我们讨论了如何使用 C# Emit 来构建动态程序集，以获得 AssemblyBuilder 这个程序集构建器，开启构建程序集的第一步。
同时我们也讨论了如何使用 C# Emit 来构建动态程序集以及程序集的持久化。
同时还分享了自己的干货，如何使用 CodeDom 和 Roslyn 来构建静态程序集。
通过本章节的内容，读者可以掌握如何利用 C# Emit 技术构建动态程序集和静态程序集，从而实现灵活、动态的程序设计和开发。
动态程序集的应用能够提升代码的模块化性、版本控制和代码复用性，为.NET应用程序的开发提供更多可能性。

来源:https://www.cnblogs.com/cyq1162/p/18085811
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！