C# --- 反射

在.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架构认知。

相关推荐
soso196830 分钟前
低功耗设计与BMS开发指南
c语言·开发语言·汇编
Risehuxyc2 小时前
来自PHP项目devnexen的回信
开发语言·php
FRing032 小时前
vue2干货总结10(json-server、vant-ui、postcss插件、axios二次封装、图形验证码、toast轻提示)
开发语言·前端·vue.js·ui·json·vue2·postcss
我是大猴子2 小时前
分析sss
开发语言
geats人山人海2 小时前
现代c++4.1
java·开发语言·c++
布莱克6053 小时前
Swift 字符串详解:从基础用法到性能与最佳实践
服务器·开发语言·ssh·字符串·swift
饿了吃洗衣凝珠4 小时前
SELinux
服务器·开发语言·php
蜗牛一步步往上爬4 小时前
第四章 更多的bash shell命令
linux·开发语言·bash
普通人65 小时前
PHP多维数组排序完全指南
开发语言·php·1024程序员节