在.NET生态中,反射(Reflection)是支撑众多高级框架与架构模式的技术。从依赖注入容器的类型自动发现,到ORM框架的对象关系映射,从序列化库的动态字段读取,到插件系统的运行时扩展,反射技术无处不在。与标准C++主要依赖RTTI进行有限的运行时类型识别、缺少通用成员枚举机制相比,.NET凭借程序集内置的标准化元数据(Metadata),将反射打造为运行时的一等公民能力。
一、反射:从编译期绑定到运行时动态绑定
1.1 早期绑定:编译期确定的调用路径
我们先从最基础的代码入手,理解常规调用的本质:
csharp
public class Camera
{
public string Name { get; set; } = "";
private int frameCount = 0;
public void Start(int fps)
{
Console.WriteLine($"Camera start: {fps} FPS");
}
}
常规调用方式为:
csharp
Camera camera = new Camera();
camera.Name = "RVC";
camera.Start(30);
在该模式下,编译器能够根据 camera 的静态类型 Camera 检查 Start(int) 方法与 Name 属性,并完成常规成员绑定。示例中的 Start 是非虚方法,调用目标可在编译期确定;若调用的是虚方法,实际执行的重写实现仍可能由运行时动态分派决定。因此,编译期绑定(Early Binding) 不等于所有方法的最终执行目标都在编译期固定。
1.2 反射:运行时的类型查询与动态调用
反射使程序不必在源码中固定每一条成员访问路径,就能在运行时探查类型信息并执行调用:
甚至可以完全动态地创建对象并执行逻辑:
csharp
Type type = typeof(Camera);
MethodInfo? method = type.GetMethod("Start"); //在 `Camera` 类型里,查找名字叫 `Start` 的方法
PropertyInfo? property = type.GetProperty("Name"); //在 `Camera` 类型里,查找名字叫 `Name` 的属性
typeof(类名)是运算符,编译期就拿到 Camera 这个类型的 Type 对象Type是反射的入口,里面存着这个类所有成员:方法、属性、字段、构造函数等信息
csharp
object? camera = Activator.CreateInstance(type); //根据前面拿到的`Type`类型,自动调用无参构造函数,new 出这个类的实例
property?.SetValue(camera, "RVC");
method?.Invoke(camera, new object[] { 30 });
- 返回类型是
object?,因为反射不知道这个类型是什么; ?.空条件运算符:如果前面GetProperty没找到属性(property 是 null),这一行直接跳过,不报空异常;
在这段代码中,Camera 类型本身已由 typeof(Camera) 指定,但指定名称的方法与属性是否存在、签名是否匹配,以及能否创建实例和执行调用,都需要在运行时处理 。若 Type 来自配置或动态加载的程序集,目标类型也可以在运行时才确定。这体现了反射的核心特征------运行时元数据探查与晚期绑定(Late Binding)。
System.Reflection 与 System.Type 提供了获取已加载程序集中类型信息的完整能力,并支持动态创建类型实例、调用方法、访问字段与属性等操作。二者的调用路径差异可以总结为:
普通非虚调用:编译期成员绑定 → 运行时执行直接调用
反射调用:运行时查找成员信息 → 动态校验与绑定 → Invoke执行
二、反射的基石:程序集元数据(Metadata)
2.1 .NET程序集的自描述特性
理解反射的前提,是理解.NET程序集的结构。在常见的托管编译流程中,C#代码编译为包含CIL与元数据的程序集(DLL/EXE),随后由运行时执行(通常涉及JIT编译);Native AOT等预编译方案属于另一种部署与执行路径:

在典型.NET PE程序集中,元数据与CIL指令位于不同的数据区域;元数据描述类型与成员的定义、引用、签名及关系等结构信息,方法实现则主要由CIL指令表达。CLR会使用这些信息解析类型和成员,但元数据不等同于完整源代码或全部调试信息。
因此,反射本质上是CLR提供的一套查询与操作运行时元数据的高级API。这也是.NET程序集被称为自描述(self-describing)组件的原因------一个DLL本身就携带了完整的类型信息,无需依赖头文件、IDL等外部描述文件即可被其他程序动态探查。
2.2 元数据的内部结构:表、堆与元数据令牌
ECMA-335 CLI标准对元数据的物理布局、逻辑表结构与语义做了严格规范,其中Partition II专门定义元数据体系。我们可以将元数据粗略理解为一个内置的微型数据库,由一系列逻辑表与数据堆组成:
- 逻辑表:包括Assembly表、TypeDef表、MethodDef表、Field表、Property表、Event表、Param表、CustomAttribute表等数十种,分别记录不同维度的程序结构信息
- 数据堆:包括字符串堆(#Strings)、Blob堆(#Blob)、GUID堆(#GUID)、用户字符串堆(#US)等,用于存储字符串、二进制签名、GUID等变长数据
以 Camera 类为例,概念上对应的元数据记录如下(为方便理解而简化,Owner 等并非实际Field或MethodDef表中的同名列;所属关系由相关表的索引和行范围表示):

元数据中的许多定义与引用项,可以通过元数据令牌(Metadata Token) 进行标识。例如令牌 0x06000004 中,高1字节 0x06 表示所属表为MethodDef表,低3字节 000004 表示表中第4行记录。常见的元数据表标识包括:TypeDef表(0x02)、Field表(0x04)、MethodDef表(0x06)、Param表(0x08)、Property表(0x17)等。
当我们调用 type.GetMethod("Start") 时,从概念上看,运行时会利用类型及成员的元数据信息查找匹配的方法,并返回对应的 MethodInfo 对象;不能将这一过程等同于每次都直接线性扫描MethodDef表。当然真实CLR实现存在大量缓存与内部结构(如RuntimeType、MethodDesc),并非每次API调用都会重新扫描PE文件。
三、反射体系:System.Type
3.1 反射对象模型层级
System.Type 是整个反射体系的入口,是访问类型元数据的主要方式。整个反射对象模型遵循清晰的层级结构:
Assembly(程序集)
↓
Module(模块)
↓
Type(类型)
├── ConstructorInfo(构造函数)
├── MethodInfo(方法)
│ └── ParameterInfo(方法参数)
├── PropertyInfo(属性)
├── FieldInfo(字段)
└── EventInfo(事件)
程序集包含模块,模块包含类型,类型包含成员,反射为每一层实体提供了对应的封装对象。对应关系如下表:
| 程序概念 | 反射对象 |
|---|---|
| 程序集 DLL/EXE | Assembly |
| 类型 | Type |
| 构造函数 | ConstructorInfo |
| 方法 | MethodInfo |
| 属性 | PropertyInfo |
| 字段 | FieldInfo |
| 事件 | EventInfo |
| 参数 | ParameterInfo |
| 特性 | Attribute / CustomAttributeData |
3.2 获取Type对象的三种方式
获取Type对象是所有反射操作的起点,三种常用方式对应不同的使用场景:
(1)typeof 运算符:编译期已知类型
Type type = typeof(Camera);
适用于编译期已经明确目标类型的场景,直接获取对应类型的Type对象。
(2)GetType() 方法:运行时获取实例真实类型
object obj = new Camera();
Type type = obj.GetType();
通过对象实例获取其运行时的实际类型。即使变量静态类型为 object,运行时依然能得到真实的 Camera 类型,这也是多态体系下类型探查的基础。
(3)Type.GetType():通过类型名称解析类型
Type? type = Type.GetType("MyApp.Camera"); // 类型位于调用方程序集时可使用命名空间限定名
通过类型名称字符串解析 Type,名称可以来自配置文件、数据库或插件描述等外部输入。需要注意:仅提供命名空间限定名时,Type.GetType() 的默认查找范围主要是调用方程序集及核心库;查找其他程序集中的类型,通常应使用程序集限定名(例如 "MyApp.Camera, MyPlugin"),或者先取得目标 Assembly 再调用 assembly.GetType(...)。类型解析失败时可能返回 null,动态性并不意味着可以自动搜索任意DLL。
3.3 Type的运行时实现
需要注意的是,System.Type 本身是一个抽象类;在常见CLR实现中,通过 typeof 或对象 GetType() 得到的通常是运行时内部的 RuntimeType 对象,但具体实现不应作为公共API契约。RuntimeType 属于CLR内部实现细节,正常开发只需依赖 Type 公共抽象接口即可,无需关注底层实现差异。
Type 对象承载了类型的全维度信息,包括继承关系、成员列表、类型特征等:
Type(Camera)
│
┌──────────────┼───────────────┐
▼ ▼ ▼
继承关系 成员信息 类型信息
BaseType Methods Name
Interfaces Fields Namespace
Properties IsClass
Events IsGenericType
3.4 基础反射示例
我们通过完整示例直观感受反射的使用方式:
csharp
using System;
public class Camera
{
public string Name { get; set; } = "Unknown";
private int frameCount = 100;
public void Start(int fps)
{
Console.WriteLine($"{Name} starts at {fps} FPS");
}
public int Add(int a, int b)
{
return a + b;
}
}
获取类型基础信息:
csharp
Type type = typeof(Camera);
Console.WriteLine(type.Name); // Camera
Console.WriteLine(type.FullName); // Camera(本示例未声明命名空间)
Console.WriteLine(type.BaseType); // System.Object
枚举所有公共属性:
csharp
foreach (PropertyInfo property in type.GetProperties())
{
Console.WriteLine($"{property.Name}: {property.PropertyType}");
}
这里需要明确一层关键抽象:PropertyInfo 代表的不是某个对象的属性值,而是属性本身的元数据描述,包含名称、类型、读写权限、对应访问器方法等信息。反射本质上是在对象模型之上,再建立一套描述代码结构的元数据对象模型。
四、反射操作:动态创建与成员调用
4.1 动态创建对象:Activator.CreateInstance
常规对象创建依赖编译期已知类型:
csharp
Camera camera = new Camera();
反射模式下通过 Activator.CreateInstance 根据Type动态创建实例:
csharp
Type type = typeof(Camera);
object? obj = Activator.CreateInstance(type);
Activator.CreateInstance(Type) 会尝试调用指定类型可访问的无参构造函数来创建实例(也需满足类型可实例化等条件);其他重载可以传入参数,并按相应的构造函数绑定规则创建对象,查找或调用失败则可能抛出异常。
这一能力是插件系统、配置驱动架构的重要组成部分:程序可以在运行时读取配置中的类型名称,解析类型并创建实例;若具体实现位于外部DLL,还需要先解决程序集加载与依赖关系。
csharp
string className = "MyApp.RobotDriver, MyPlugin"; // 包含程序集名
Type? type = Type.GetType(className);
if (type == null) throw new TypeLoadException(className);
object driver = Activator.CreateInstance(type)!; // 要求类型可实例化且具备合适的构造函数
补充说明:除了
Activator.CreateInstance,也可以通过Type.GetConstructor()获取ConstructorInfo对象,再调用其Invoke方法创建实例。二者都利用运行时构造函数信息,但具体绑定、异常及实现细节不完全相同;Activator提供了更简洁的上层接口。
4.2 动态调用方法:MethodInfo
通过 Type.GetMethod() 可以获取方法的元数据对象 MethodInfo:
csharp
Type type = typeof(Camera);
MethodInfo? method = type.GetMethod("Start");
MethodInfo 提供方法名称、返回值类型、参数列表、访问修饰符、是否静态、声明类型等信息。对于重载方法,单独按名称调用 GetMethod() 可能出现歧义并抛出 AmbiguousMatchException;应通过参数类型数组、BindingFlags 等条件缩小匹配范围。
调用方法使用 Invoke 接口,格式为 method.Invoke(target, args):
csharp
Camera camera = new Camera();
method?.Invoke(camera, new object[] { 30 });
带返回值的方法调用示例:
csharp
MethodInfo method = typeof(Camera).GetMethod("Add")!;
Camera camera = new Camera();
object? result = method.Invoke(camera, new object[] { 10, 20 });
Console.WriteLine(result); // 输出 30
需要注意的是,通用反射API大量使用 object、Type、object[] 等类型,因为调用方可能在编译期无法确定目标签名;这会减少编译期类型检查,并带来参数数组分配、值类型装箱以及运行时参数检查等潜在开销。MethodInfo.Invoke() 中目标方法抛出的异常通常会包装为 TargetInvocationException,排查时应检查其 InnerException。
4.3 动态访问属性与字段:PropertyInfo与FieldInfo
常规属性读写:
csharp
camera.Name = "RVC";
反射模式下通过 PropertyInfo 操作:
csharp
PropertyInfo property = typeof(Camera).GetProperty("Name")!;
property.SetValue(camera, "RVC"); // 写入
object? value = property.GetValue(camera); // 读取
GetValue() 用于获取指定对象的属性值,SetValue() 用于设置属性值。
基于这一能力,我们可以实现完全通用的对象处理逻辑。例如实现一个无需知晓对象结构的通用打印器:
csharp
static void PrintObject(object obj)
{
Type type = obj.GetType();
foreach (PropertyInfo p in type.GetProperties())
{
if (!p.CanRead || p.GetIndexParameters().Length != 0) continue;
Console.WriteLine($"{p.Name} = {p.GetValue(obj)}");
}
}
调用效果:
csharp
var result = new PollenResult
{
Category = "Betula",
Confidence = 0.96f,
Area = 1350
};
PrintObject(result);
输出:
csharp
Category = Betula
Confidence = 0.96
Area = 1350
这段代码没有硬编码具体属性访问路径,而是通过反射动态探查对象结构;它还跳过了不可读属性与索引器。此处仅为演示,实际工程仍应处理属性getter抛出的异常以及敏感数据输出等问题。类似机制可用于序列化、ORM、对象检查器等场景(具体框架也可能使用表达式树或代码生成)。
五、精准成员查找:BindingFlags枚举
对于 GetMethod()、GetMethods()、GetProperty() 等常用成员查找API,不指定 BindingFlags 时通常会查找公共(public)的实例成员与静态成员,具体继承规则因成员类型而异。如果需要查找非公有成员,或显式限制实例/静态成员,应使用 BindingFlags 控制查找行为。
例如访问私有字段:
csharp
FieldInfo? field = type.GetField(
"frameCount",
BindingFlags.Instance | BindingFlags.NonPublic
);
BindingFlags 是控制反射成员搜索与绑定的标志枚举,支持按位组合使用。标志如下:
| BindingFlags | 意义 |
|---|---|
Public |
匹配 public 成员 |
NonPublic |
匹配 private/protected/internal 等非 public 成员 |
Instance |
匹配实例成员 |
Static |
匹配静态成员 |
DeclaredOnly |
仅匹配当前类型声明的成员,不包含继承成员 |
IgnoreCase |
在支持名称查找的相关重载中忽略大小写 |
常用组合示例:
BindingFlags.Instance | BindingFlags.NonPublic:查找所有非公有实例成员BindingFlags.Static | BindingFlags.Public:查找所有公有静态成员
不建议将反射访问私有成员作为常规架构接口。private 本身就是实现细节的语义标识,通过反射强行依赖私有成员会导致版本兼容风险------当实现细节变更时,编译器不会给出任何提示,问题会推迟到运行时才暴露,这是反射最主要的工程风险之一。
六、反射与特性
6.1 特性:元数据扩展
特性(Attribute)是可以附加到程序集、类型、成员、参数等程序元素上的声明性信息,最终会存储在程序集元数据中,可在运行时通过反射API访问。
最常见的特性示例:
csharp
[Serializable]
public class Camera { }
自定义特性示例:
csharp
[AttributeUsage(AttributeTargets.Class)]
public class DeviceAttribute : Attribute
{
public string Name { get; }
public DeviceAttribute(string name)
{
Name = name;
}
}
[Device("3D Camera")]
public class RvcCamera { }
这段代码相当于在元数据中为 RvcCamera 附加了一条额外记录:关联 DeviceAttribute,其 Name 参数为 "3D Camera"。
运行时通过反射读取特性:
csharp
Type type = typeof(RvcCamera);
DeviceAttribute? attr = type.GetCustomAttribute<DeviceAttribute>();
Console.WriteLine(attr?.Name); // 输出 3D Camera
特性声明编译后以元数据形式保存,不会因为应用程序启动就自动实例化。
GetCustomAttribute等需要返回特性对象的API通常会实例化特性;若只需读取特性构造参数等元数据,可使用CustomAttributeData,不必实例化特性对象。
6.2 反射+特性:插件系统的原理
特性提供声明式标记,反射负责发现并读取这些信息,二者经常用于声明式的注册与扩展机制。下面以同一程序集中的设备类型自动注册为例说明基本流程:
首先定义插件接口与标记特性:
csharp
public interface IDevice
{
void Start();
}
[Device("Camera")]
public class CameraDriver : IDevice
{
public void Start() => Console.WriteLine("Camera start");
}
[Device("Robot")]
public class RobotDriver : IDevice
{
public void Start() => Console.WriteLine("Robot start");
}
程序启动时通过反射发现当前执行程序集中的候选设备类型,并创建实例:
csharp
Assembly assembly = Assembly.GetExecutingAssembly();
foreach (Type type in assembly.GetTypes())
{
// 筛选实现了IDevice的非抽象类型
if (!typeof(IDevice).IsAssignableFrom(type)) continue;
if (type.IsAbstract || type.IsInterface) continue;
if (type.GetConstructor(Type.EmptyTypes) == null) continue;
// 检查设备特性
DeviceAttribute? attr = type.GetCustomAttribute<DeviceAttribute>();
if (attr == null) continue;
// 创建实例并启动
IDevice device = (IDevice)Activator.CreateInstance(type)!;
Console.WriteLine($"Found {attr.Name}");
device.Start();
}
上述示例只扫描 Assembly.GetExecutingAssembly() 返回的程序集,不会自动搜索或加载磁盘上的外部插件DLL。完整插件系统还需要处理程序集加载、依赖解析、隔离与生命周期;现代.NET通常可使用 AssemblyLoadContext,而.NET Framework采用不同的程序集加载机制。
这套"扫描程序集→筛选接口→检查特性→动态创建"的模式,是多类.NET框架可采用的实现机制之一:
- IoC/DI 容器的自动类型注册
- ASP.NET Core 的路由发现与控制器映射
- 单元测试框架的用例自动识别
- ORM 框架的实体与字段映射
- 序列化框架的字段控制
6.3 特性与反射
- 特性:在源码中声明附加信息,由编译器写入元数据
- 反射:在运行时查询类型和成员信息,并可读取特性元数据
二者可以配合形成声明式的发现与注册流程:开发者使用特性附加元信息,框架通过反射识别后执行相应逻辑。不过自动扫描并非所有框架的必选方案,实际还可能采用显式注册或编译期代码生成。
七、泛型类型的反射
反射同样支持泛型类型的探查与动态构造,对应一套专门的API。
7.1 泛型类型的元数据探查
csharp
Type type = typeof(List<int>);
Console.WriteLine(type.IsGenericType); // True
泛型类型包含两个概念:
- 泛型类型定义(Generic Type Definition) :未指定类型实参的泛型类型定义,如
List<> - 泛型类型实参(Generic Arguments) :封闭构造类型中的具体实参,如
List<int>的int;对开放泛型定义调用GetGenericArguments()则得到类型形参
对应的反射API:
csharp
// 获取泛型类型定义
Type definition = type.GetGenericTypeDefinition(); // 对应 List<>
// 获取泛型参数数组
Type[] arguments = type.GetGenericArguments(); // 得到 [System.Int32]
从反射视角看,泛型类型会关联一组类型参数或类型实参,IsGenericTypeDefinition、ContainsGenericParameters、GetGenericArguments() 等API均为此设计。
7.2 运行时构造封闭泛型类型
反射支持在运行时动态构造封闭泛型类型:
csharp
Type openType = typeof(List<>);
Type closedType = openType.MakeGenericType(typeof(int));
object list = Activator.CreateInstance(closedType)!;
执行流程为:
开放泛型定义 List<>
+
类型实参 int
↓
MakeGenericType
↓
封闭泛型类型 List<int>
↓
创建实例
泛型方法也支持同类操作,通过
MethodInfo.GetGenericMethodDefinition()获取开放泛型方法定义,再调用MakeGenericMethod()构造封闭泛型方法,最终执行调用。
八、性能分析与优化实践
8.1 反射调用的性能开销来源
反射调用通常比普通直接调用具有更高的开销,具体差异取决于运行时版本、调用方式、参数类型和优化情况,根源在于额外的绑定与参数处理:
普通直接调用流程:编译期完成成员绑定 → JIT编译/优化(常见托管模式) → 执行调用
反射调用流程:获取或复用MethodInfo → 检查目标对象及参数 → 运行时调用分派 → 实际执行方法 → 以object形式接收返回值(如有)(使用object\[\]可能分配数组;值类型参数/返回值可能发生装箱)
晚期绑定调用一般比直接调用开销更高,成员查找、特性获取等操作也存在成本。但不同.NET版本存在实现优化,具体性能应在目标环境中基准测试,不能把所有反射操作简单视为相同成本。
8.2 常见优化手段
(1)缓存反射对象
避免在循环中重复执行成员查找操作,将 MethodInfo、PropertyInfo 等对象缓存复用:
csharp
// 错误:每次循环都重复查找
for (int i = 0; i < 1_000_000; ++i)
{
MethodInfo method = typeof(Camera).GetMethod("Start")!;
method.Invoke(camera, new object[] { 30 });
}
// 正确:查找一次,缓存复用
MethodInfo method = typeof(Camera).GetMethod("Start")!;
for (int i = 0; i < 1_000_000; ++i)
{
method.Invoke(camera, new object[] { 30 });
}
(2)委托转换:CreateDelegate
对于高频调用场景,可将 MethodInfo 转换为强类型委托,后续调用性能接近原生调用:
csharp
MethodInfo method = typeof(Camera).GetMethod("Start")!;
Action<Camera, int> start = (Action<Camera, int>)method.CreateDelegate(typeof(Action<Camera, int>));
// 后续直接调用委托
start(camera, 30);
MethodInfo.CreateDelegate() 是官方提供的优化方式,可把匹配签名的方法绑定为委托,避免后续反复使用 Invoke();上述非泛型重载可用于.NET Framework 4.8。method.CreateDelegate<Action<Camera, int>>() 这样的泛型重载适用于.NET 5及更新版本。具体性能仍取决于运行时和调用场景。
(3)其他进阶优化手段
- 表达式树(Expression Tree) :通过
System.Linq.Expressions构建调用表达式并编译为委托,适合动态构建复杂调用逻辑的场景 - IL Emit:运行时动态生成IL代码,可降低某些重复调用场景的开销,但包含生成与JIT成本,不能笼统认定性能最高;Native AOT不支持这类运行时代码生成
- 源生成器(Source Generator):编译期生成已知结构的强类型代码,可以替代部分运行时反射路径并改善AOT适配性,但并非所有动态场景都能被替代,也不意味着整个应用完全没有反射开销
通用优化原则:尽量在初始化或低频阶段进行反射发现,对经性能验证的高频路径优先使用缓存、强类型委托或接口调用。
九、工程落地
9.1 反射的适用场景
反射的重要价值是使程序能够在运行时探查和操作类型信息。判断是否应该使用反射,应同时考虑:是否需要运行时元数据探查、能否使用静态类型约束、调用频率以及部署方式。
如果类型与调用路径在编译期已经明确,通常优先考虑直接调用、泛型或接口;即使类型已知,编写通用检查器、框架工具等场景也可能需要反射。适用场景如下:
| 场景 | 动态性需求说明 |
|---|---|
| 插件系统 | 编译期不知道用户后续会加载哪些扩展DLL |
| 序列化/反序列化 | 通用读取类型及成员映射信息;也可通过源生成实现 |
| ORM 框架 | 运行时建立实体属性与数据库列的映射;也可采用预编译模型 |
| IoC/DI 容器 | 自动扫描并发现接口实现类 |
| 单元测试框架 | 自动发现标记了测试特性的方法 |
| UI 数据绑定 | 运行时根据属性名动态绑定数据 |
| 配置驱动系统 | 根据配置字符串选择具体实现类 |
| 编辑器/Inspector | 自动展示任意对象的成员信息 |
9.2 反射的工程风险
(1)丢失编译期检查
普通代码中方法名拼写错误会直接触发编译报错,但反射中字符串硬编码的错误只会在运行时返回 null 或抛出异常,大量编译期可发现的问题被推迟到了运行时。
(2)重构兼容性差
IDE重命名成员时,普通调用会同步更新,但反射中的字符串硬编码无法被可靠识别,容易引入隐性bug。
对编译期已知的成员,尽量使用
nameof替代硬编码字符串,如GetMethod(nameof(Camera.Start)),可获得成员名称的编译期检查及部分重构支持;但它不能保证对应反射查找一定成功,尤其无法验证重载签名和绑定条件。
(3)性能开销
原生反射调用性能较差,不适合高频执行的路径。
9.3 工程分层建议
反射代码适合集中在程序初始化、插件扫描、类型注册等一次性执行阶段;实时性要求高的循环(如高频控制循环、图像处理流水线、逐帧渲染逻辑)应避免直接使用反射调用。
合理的分层模式为:
初始化阶段:反射扫描 → 构建强类型委托/接口 → 缓存结果
运行阶段:直接调用缓存的强类型逻辑
十、程序集裁剪与Native AOT
在未裁剪的常见JIT部署中,反射通常能访问程序集保留的元数据和可访问的成员,但仍受到可见性、运行时规则等限制。随着现代.NET的裁剪(Trimming)与Native AOT技术发展,反射的使用边界又增加了静态分析与元数据保留方面的约束;本章主要针对现代.NET,并不直接等同于.NET Framework 4.8的部署能力。
10.1 程序集裁剪对反射的影响
裁剪工具会通过静态分析移除未被引用的代码以减小程序体积。如果某个成员仅通过无法静态分析的反射路径访问,裁剪器可能将其判定为不可达并移除,导致运行时无法按预期通过反射访问;这属于静态分析可见性限制,不一定是裁剪工具的错误。
裁剪场景下应尽可能消除不必要的反射;必须保留的动态访问成员,可使用 DynamicallyAccessedMembersAttribute 告知静态分析器保留对应成员;无法静态分析的反射API则需要标注 RequiresUnreferencedCode 显式声明风险。
10.2 Native AOT的限制
Native AOT在发布时将应用编译为原生机器码,运行时无需JIT,但仍包含必要的.NET运行时支持组件;由于代码和元数据需要在发布时确定,对动态能力有更严格的限制:
- 不支持普通意义上的运行时动态程序集加载
- 不支持
System.Reflection.Emit运行时代码生成 - 可反射的成员取决于发布时的静态分析及保留配置;缺失必要元数据时,相应反射操作可能失败
10.3 从运行时反射到编译期生成
现代.NET的一种重要优化路线,是将部分原本依赖运行时反射的工作移至编译期,通过源生成器(Source Generator) 预先生成代码。例如System.Text.Json支持源生成序列化元数据,一些DI方案也能进行编译期注册。此类技术可以减少特定路径的反射开销,并通常更易适配裁剪与Native AOT,但能否完全避免反射、是否兼容AOT仍取决于具体实现和使用方式。
十一、C#反射 vs C++ RTTI
对于有C++背景的开发者,对比二者差异有助于更深刻地理解反射的本质:
| C++ | C#/.NET |
|---|---|
typeid |
GetType() / typeof(仅作类型识别层面的类比) |
| RTTI(有限的运行时类型识别) | Reflection(更完整的运行时元数据探查) |
dynamic_cast |
IsAssignableFrom / IsInstanceOfType 等 |
| 标准语言缺少完整成员枚举能力 | 内置 GetMethods/GetProperties/... 全量成员探查 |
| 标准C++无通用MethodInfo抽象 | 内置 MethodInfo 等完整元数据对象模型 |
| 标准C++无通用属性反射 | 内置 PropertyInfo 属性反射 |
| 常依赖宏/模板/代码生成/第三方库实现扩展 | CLR内建标准化元数据 + 完整反射API |
造成差异的重要原因在于标准语言能力与运行时模型不同:标准C++的RTTI由编译器与运行时支持,主要提供运行时类型识别与安全转换,不等同于逆向工程 ;C++也可通过模板、工具或第三方机制实现部分静态/动态反射能力。相比之下,典型.NET托管程序集包含ECMA-335标准化元数据,因而能提供更统一、完整的运行时成员探查API。
总结
C# 源码
↓
编译器
↓
.NET 程序集 = CIL 指令 + 标准化元数据
↓
CLR 加载与元数据解析
↓
反射 API 层:Type → MemberInfo 家族
↓
运行时能力:类型查询 → 对象创建 → 成员调用 → 特性读取
理解反射不能只停留在 GetMethod()、Invoke() 等API,还应认识.NET程序集中的标准化元数据体系,以及运行时如何利用这些信息提供动态操作能力。理解了这一点,就能将特性、依赖注入、插件系统、ASP.NET路由、ORM、序列化等众多技术点串联起来,形成完整的.NET架构认知。