C# 运行时类型创建：深入探索动态类型生成技术

一、从"编译时"到"运行时"的思维转变

设想一个场景：你正在开发一个ORM框架，需要将数据库表动态映射为C#类；或者构建一个插件系统，允许用户上传JSON配置文件就能生成对应的实体类型。传统的C#开发思维是"先定义类型，再编译使用"，但在这些场景中，类型本身在编译时是未知的。

C#作为强类型语言，类型信息在编译后以元数据形式存储在程序集中，这为运行时动态创建类型提供了技术基础。 "动态创建"并非意味着放弃类型安全，而是在程序执行时，基于一定的规则和输入，生成和加载全新的类型。 其实现路径主要分为两大流派：反射驱动的类型创建 与IL Emit底层生成。

二、基础路径：利用反射进行映射与创建

反射是运行时类型操作的基石。虽然它主要用于获取已有类型的信息，但在动态对象创建中扮演着关键角色。

1. Activator.CreateInstance：最直接的实例化方式

当你知道类型的完全限定名称（字符串形式）时，Activator是创建对象的最快捷方式。

// 通过类型名称字符串动态创建控件
Type ctlType = Type.GetType("System.Windows.Forms.Button, System.Windows.Forms");
object dynamicButton = Activator.CreateInstance(ctlType);

这种方式广泛用于插件架构和脚本引擎中，它的局限也很明显：只能创建已编译存在的类型。想要创建一个全新的类型，则需要借助System.Reflection.Emit。

2. 理解dynamic与ExpandoObject的区别

很多开发者容易混淆"动态类型生成"与dynamic关键字。dynamic本质上是编译器的语法糖 ，它背后的真实类型是System.Object。当你在代码中写dynamic d = 10;时，编译器只是暂时放弃类型检查，将解析推迟到运行时。

而ExpandoObject则更进一步，它允许在运行时向一个对象添加成员 ，但这并非创建新类型，而是通过IDictionary<string, object>实现动态属性存储。

dynamic expando = new ExpandoObject();
expando.Name = "C# Dynamic";
expando.Age = 11;
// ExpandoObject可以随时添加属性，非常适合JSON转换场景

严格来说，ExpandoObject是"动态对象"而非"动态类型"，它无法生成具有明确类型结构的全新类。

三、底层核心：System.Reflection.Emit深度解析

要真正创造一个新类型，必须深入IL指令层级。System.Reflection.Emit命名空间提供了在运行时构建程序集、模块、类型和方法的完整API链。

1. 类型构建的流水线

动态创建新类型的标准流程分为四步：

// ① 定义动态程序集和模块
AssemblyName asmName = new AssemblyName("DynamicAssembly");
AssemblyBuilder asmBuilder = AssemblyBuilder.DefineDynamicAssembly(
    asmName, AssemblyBuilderAccess.Run);
ModuleBuilder modBuilder = asmBuilder.DefineDynamicModule("MainModule");

// ② 定义公开类
TypeBuilder typeBuilder = modBuilder.DefineType(
    "DynamicEntity", TypeAttributes.Public);

// ③ 定义字段和属性
FieldBuilder fieldBuilder = typeBuilder.DefineField(
    "_name", typeof(string), FieldAttributes.Private);
PropertyBuilder propBuilder = typeBuilder.DefineProperty(
    "Name", PropertyAttributes.HasDefault, typeof(string), null);

// 定义属性的get/set方法需要IL Generator生成方法体
MethodBuilder getMethod = typeBuilder.DefineMethod(
    "get_Name", MethodAttributes.Public, typeof(string), Type.EmptyTypes);
ILGenerator getIL = getMethod.GetILGenerator();
getIL.Emit(OpCodes.Ldarg_0);
getIL.Emit(OpCodes.Ldfld, fieldBuilder);
getIL.Emit(OpCodes.Ret);
propBuilder.SetGetMethod(getMethod);

// ④ 创建类型，使其可用
Type dynamicType = typeBuilder.CreateType();
object instance = Activator.CreateInstance(dynamicType);

2. IL代码生成实战

直接编写IL指令是Reflection.Emit的核心难点。IL是.NET的汇编语言，基于栈的运算模型对初学者极为抽象。来看一个更复杂的例子：生成一个接受两个整数并返回和的方法。

MethodBuilder method = typeBuilder.DefineMethod(
    "Add", MethodAttributes.Public | MethodAttributes.Static,
    typeof(int), new[] { typeof(int), typeof(int) });

ILGenerator il = method.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);  // 将第一个参数压栈
il.Emit(OpCodes.Ldarg_1);  // 将第二个参数压栈
il.Emit(OpCodes.Add);      // 执行加法运算
il.Emit(OpCodes.Ret);      // 返回结果

常用IL指令速查：

指令	说明
Ldarg_0	加载第0个参数（实例方法中为this）
Ldstr	将字符串压入栈
Stfld / Ldfld	设置/获取字段值
Call / Callvirt	调用静态/虚方法
Newobj	调用构造函数创建对象
Box / Unbox	值类型装箱/拆箱

3. 高级场景：实现接口继承

Reflection.Emit不仅能创建简单类，还支持接口实现、继承和特性标注。

// 实现IDisposable接口
typeBuilder.AddInterfaceImplementation(typeof(IDisposable));
MethodBuilder disposeMethod = typeBuilder.DefineMethod(
    "Dispose", MethodAttributes.Public | MethodAttributes.Virtual);
ILGenerator disposeIL = disposeMethod.GetILGenerator();
disposeIL.Emit(OpCodes.Ret);
// 绑定接口方法与实现
typeBuilder.DefineMethodOverride(disposeMethod, 
    typeof(IDisposable).GetMethod("Dispose"));

使用DefineMethodOverride将接口方法映射到具体实现时，必须确保方法签名完全匹配，否则运行时加载类型时会抛出TypeLoadException。

四、高级解决方案：Expression Tree与Source Generator

Reflection.Emit虽然强大，但调试和维护难度极大。微软在后续版本中提供了更友好的替代方案。

1. 表达式树：编译时代的动态生成

如果你不需要创建全新的类型，而只是动态生成方法逻辑，表达式树是更好的选择：

// 动态生成 (a, b) => a + b 的Lambda表达式
var paramA = Expression.Parameter(typeof(int), "a");
var paramB = Expression.Parameter(typeof(int), "b");
var body = Expression.Add(paramA, paramB);
var lambda = Expression.Lambda<Func<int, int, int>>(body, paramA, paramB);
Func<int, int, int> addFunc = lambda.Compile();

int result = addFunc(5, 3); // 输出 8

表达式树的可读性远超裸IL指令，且Compile()方法会在内部调用Reflection.Emit，性能与手写IL相同。

2. Source Generator：将生成提前到编译时

在.NET 9及之后版本中，微软大力推广Source Generator技术，它在编译时分析代码并生成新的C#源文件，完全避免了运行时Emit的性能开销。

[GenerateArguments] // 编译时标记
public partial class MyData
{
    public string Name { get; set; }
    public int Value { get; set; }
}
// Source Generator会自动生成优化的属性访问代码

Source Generator适用于生成代码体量确定、追求AOT编译支持的场景，与运行时动态类型形成完美互补。

五、方案对比与选型建议

技术方案	灵活性	性能	调试难度	典型场景
Activator.CreateInstance	低	中等	容易	插件加载、IoC容器
dynamic / ExpandoObject	中等	低（运行时绑定开销大）	一般	JSON序列化、动态配置
Reflection.Emit	极高	高（接近静态编译）	困难	ORM框架、AOP动态代理
表达式树	中等	高	中等	动态查询、规则引擎
Source Generator	低（仅限编译时）	最高（编译时优化）	容易	序列化器、映射器

选型决策树：

• 只需要从字符串创建已存在类型 的实例 → Activator
• 需要为对象动态添加属性 → ExpandoObject或继承DynamicObject
• 需要创建一个全新的类型 并长时间复用 → Reflection.Emit（将TypeBuilder.CreateType()结果缓存下来）
• 只需要动态执行一段逻辑 → 表达式树
• 生成大量重复性代码 且追求极致性能 → Source Generator

六、性能陷阱与内存优化

动态类型生成最容易被忽视的问题是内存泄漏 。每次调用DefineDynamicAssembly和CreateType都会生成新的程序集和类型元数据，而.NET的GC无法自动卸载程序集。

AssemblyBuilderAccess枚举的选择至关重要：

• Run：程序集仅用于执行，加载后无法卸载
• RunAndCollect：允许GC在确定程序集不再使用时回收它，仅限.NET Core 3.0+
• Save：将程序集保存到磁盘文件

最佳实践建议：

• 对动态类型按参数签名进行全局缓存，避免重复生成相同类型
• 如果必须频繁创建/销毁类型，考虑使用Collectible AssemblyLoadContext加载可回收程序集
• 避免在热路径上使用Type.GetProperties()等反射API，确有需要时配合PropertyInfo.SetValue的缓存委托使用

结语

C#的动态类型生成技术展现了这门语言从"静态强类型"向"灵活可扩展"融合的进化。Reflection.Emit是掌握底层运行机制的必经之路，而表达式树和Source Generator则让动态代码生成走向更高层次的抽象。在实际架构设计中，不必迷恋最底层的技术，针对具体场景选择最合适的方案，灵活性与性能的平衡才是动态编程的艺术所在。