引言
在软件开发中，我们通常编写静态代码——编译器在构建时就知道所有类型和方法。但有时，我们需要在运行时动态地探索和操作类型，比如加载插件、实现依赖注入或动态调用方法。这时，.NET 反射就派上了用场。
反射机制允许在运行时检查类型信息、动态创建对象、调用方法，甚至访问私有成员。虽然反射功能强大，但它也有一定的性能开销，需要谨慎使用。
本文将介绍 .NET 反射的基本概念、常见用法、性能优化技巧，以及一些实际应用场景。
反射基础
.Net 反射的核心是 System.Type 类，它代表一个类型的元数据，可以通过它来获取类的名称、基类、实现的接口、方法、属性等信息。
System.Reflection 命名空间提供了几个关键类：
Assembly：表示一个程序集（DLL 或 EXE）。MethodInfo：描述一个方法。PropertyInfo：描述一个属性。FieldInfo：描述一个字段。
在 .NET 中，获取 Type 对象有三种常见方式。
第一种，通过 typeof 运算符（针对编译时已知类型）：
Type type = typeof(string);
Console.WriteLine(type.Name); // Output: String
第二种，通过 GetType() 方法（针对运行时已知对象）：
string name = "Hello";
Type type = name.GetType();
Console.WriteLine(type.Name);
第三种，通过类型名称动态加载：
Type? type = Type.GetType("System.String");
if (type != null) {
Console.WriteLine(type.Name);
}
反射的常见操作
获取类型信息
可以通过 Type 对象获取类的各种信息：
Type type = typeof(List<int>);
Console.WriteLine($"类名: {type.Name}"); // List`1
Console.WriteLine($"基类: {type.BaseType?.Name}"); // Object
Console.WriteLine($"是否泛型: {type.IsGenericType}"); // True
动态调用方法
假设有一个类：
public class Calculator
{
public int Add(int a, int b) => a + b;
}
借助反射，可以用动态调用 Add 方法：
Calculator calc = new Calculator();
Type type = calc.GetType();
MethodInfo? method = type.GetMethod("Add");
if (method != null) {
int result = (int)method.Invoke(calc, new object[] { 5, 3 })!;
Console.WriteLine(result); // Output: 8
}
访问私有成员
反射可以绕过访问修饰符的限制，访问私有字段或方法：
public class SecretHolder
{
private string _secret = "Hidden Data";
}
var holder = new SecretHolder();
Type type = holder.GetType();
FieldInfo? field = type.GetField("_secret", BindingFlags.NonPublic | BindingFlags.Instance);
if (field != null) {
string secret = (string)field.GetValue(holder)!;
Console.WriteLine(secret); // Output: Hidden Data
}
获取枚举类型的所有名称和值
反射可以获取 enum 类型的名称和值，包括枚举项的名字、对应的整型值等。
public enum Color
{
Red = 1,
Green = 2,
Blue = 3
}
/*
Output:
Name: Red, Value: 1
Name: Green, Value: 2
Name: Blue, Value: 3
*/
Type enumType = typeof(Color);
FieldInfo[] fields = enumType.GetFields(BindingFlags.Public | BindingFlags.Static);
foreach (FieldInfo field in fields)
{
string name = field.Name;
object? value = field.GetRawConstantValue();
Console.WriteLine($"Name: {name}, Value: {value}");
}
获取类成员信息
.Net 反射可以很简单地遍历类的成员信息（字段和方法）。
例如：
public struct Point
{
public int x;
public int y;
public void Print()
{
Console.WriteLine($"x = {x}, y = {y}");
}
}
/*
Output:
Struct Name: Point
Fields:
x : Int32
y : Int32
Methods:
Print()
*/
Type type = typeof(Point);
Console.WriteLine($"Struct Name: {type.Name}");
Console.WriteLine("\nFields:");
foreach (var field in type.GetFields(BindingFlags.Public | BindingFlags.Instance))
{
Console.WriteLine($" {field.Name} : {field.FieldType.Name}");
}
Console.WriteLine("\nMethods:");
foreach (var method in type.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly))
{
Console.WriteLine($" {method.Name}()");
}
动态创建对象
可以使用 Activator.CreateInstance 动态实例化对象：
Type type = typeof(StringBuilder);
object? instance = Activator.CreateInstance(type);
StringBuilder sb = (StringBuilder)instance!;
sb.Append("Hello");
Console.WriteLine(sb.ToString()); // Output: Hello
高级反射技巧
调用泛型方法
如果方法带有泛型参数，我们需要先使用 MakeGenericMethod 指定类型：
public class GenericHelper
{
public T Echo<T>(T value) => value;
}
var helper = new GenericHelper();
Type type = helper.GetType();
MethodInfo method = type.GetMethod("Echo")!;
MethodInfo genericMethod = method.MakeGenericMethod(typeof(string));
string result = (string)genericMethod.Invoke(helper, new object[] { "Hello" })!;
Console.WriteLine(result); // Output: Hello
性能优化
反射调用比直接调用慢很多，因此在高性能场景下，可以缓存 MethodInfo 或使用 Delegate 优化：
MethodInfo method = typeof(Calculator).GetMethod("Add")!;
var addDelegate = (Func<Calculator, int, int, int>)Delegate.CreateDelegate(
typeof(Func<Calculator, int, int, int>),
method
);
Calculator calc = new Calculator();
int result = addDelegate(calc, 5, 3);
Console.WriteLine($"result: {result}"); // result: 8
在某些涉及加密、版权保护的敏感反射操作中，还可以结合代码保护工具使用，以防止IL层被逆向。国内的 Virbox Protector 便提供了成熟的 .NET 动态代码保护方案，可以有效防护反射与动态调用的敏感代码。
动态加载插件
假设我们有一个插件系统，所有插件都实现 IPlugin 接口：
public interface IPlugin
{
void Execute();
}
public class HelloPlugin : IPlugin
{
public void Execute() => Console.WriteLine("Hello from Plugin!");
}
我们可以扫描 DLL 文件并加载所有插件：
Assembly assembly = Assembly.LoadFrom("MyPlugins.dll");
var pluginTypes = assembly.GetTypes()
.Where(t => typeof(IPlugin).IsAssignableFrom(t) && !t.IsAbstract);
foreach (Type type in pluginTypes)
{
IPlugin plugin = (IPlugin)Activator.CreateInstance(type);
plugin.Execute();
}
对于通过反射加载的 DLL 插件，也可以使用 Virbox Protector 这类软件保护工具进行加密与加载时解密保护，以防止插件被静态或动态提取。
代码生成
在某些高级场景中，可能不仅需要动态地调用代码，还希望在运行时生成新的类型或方法。这可以通过 .NET 提供的 System.Reflection.Emit 命名空间实现，它允许在运行时构建程序集、模块、类型和方法。
这项技术适用于动态代理、序列化器生成、脚本引擎等场景。
下面是一个简单示例，展示如何使用 Reflection.Emit 生成一个动态类 Person，并添加一个 SayHello 方法：
using System;
using System.Reflection;
using System.Reflection.Emit;
public class DynamicTypeDemo
{
public static void Main()
{
// 创建一个动态程序集
AssemblyName assemblyName = new AssemblyName("DynamicAssembly");
AssemblyBuilder assemblyBuilder =
AssemblyBuilder.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
// 创建一个模块
ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("MainModule");
// 定义一个类：public class Person
TypeBuilder typeBuilder = moduleBuilder.DefineType(
"Person",
TypeAttributes.Public
);
// 定义一个方法：public void SayHello()
MethodBuilder methodBuilder = typeBuilder.DefineMethod(
"SayHello",
MethodAttributes.Public,
returnType: typeof(void),
parameterTypes: Type.EmptyTypes
);
// 生成 IL 代码，等价于 Console.WriteLine("Hello from dynamic type!");
ILGenerator il = methodBuilder.GetILGenerator();
il.Emit(OpCodes.Ldstr, "Hello from dynamic type!");
il.Emit(OpCodes.Call, typeof(Console).GetMethod("WriteLine", new[] { typeof(string) })!);
il.Emit(OpCodes.Ret);
// 创建类型
Type personType = typeBuilder.CreateType();
// 实例化并调用方法
object personInstance = Activator.CreateInstance(personType)!;
personType.GetMethod("SayHello")!.Invoke(personInstance, null);
}
}
编译运行，将输出：
Hello from dynamic type!
可见，代码生成是 .NET 反射机制的一个高阶应用，通过 System.Reflection.Emit，可以在运行时动态构建类型、定义方法并生成中间语言（IL）指令。这种能力为某些特定场景提供了极大的灵活性，比如实现动态代理、构建脚本引擎、生成序列化器或在运行时创建优化过的类型逻辑。
不过，使用 Emit 生成代码也存在一些明显的局限性。一是其可读性差，调试难度大，需要对 IL 指令有较深的理解；二是虽然它的功能强大，但维护成本较高，一般不适用于普通业务逻辑开发。通常只有在对灵活性有极高要求时才会考虑使用。
在实际开发中，如果只是希望在运行时生成代码行为，又不希望深入 IL 层，表达式树（System.Linq.Expressions）是一个更现代、更安全的替代方案。而对于需要在编译期生成代码、避免运行时反射开销的场景，可以使用 .NET 的 Source Generator，它兼具性能和可维护性，已成为现代 .NET 应用中越来越常见的选择。
下面是一个表达式树生成代码的示例：
using System;
using System.Linq.Expressions;
public class ExpressionTreeDemo
{
public static void Main()
{
// 表达式：() => Console.WriteLine("Hello from expression tree!");
var writeLineMethod = typeof(Console).GetMethod("WriteLine", new[] { typeof(string) });
// 构建常量表达式 "Hello from expression tree!"
var messageExpr = Expression.Constant("Hello from expression tree!");
// 调用 Console.WriteLine(string) 的表达式
var callExpr = Expression.Call(writeLineMethod!, messageExpr);
// 构建 lambda 表达式：() => Console.WriteLine(...)
var lambda = Expression.Lambda<Action>(callExpr);
// 编译成委托并执行
Action sayHello = lambda.Compile();
sayHello();
}
}
表达式树主要用于构造方法体，不能定义类结构，编译后的委托效率接近手写代码。如果只需要动态地构建方法逻辑，而不涉及定义新的类型结构，表达式树是一个更简单、更安全的选择。它既避免了操作 IL 的复杂性，又提供了接近手写代码的执行效率。在许多现代框架（如 Entity Framework、AutoMapper）中，表达式树都被广泛用于动态代码生成。
Source Generator 则是 .NET 提供的一种编译期代码生成工具，可以在编译过程中注入额外的源代码，不依赖反射、无运行时开销，适合构建高性能、可维护的自动化代码逻辑。
假设想为类自动生成一个 SayHello() 方法，可以创建一个 Source Generator，在编译时为带有特定特性 [GenerateHello] 的类注入该方法。
首先，在主项目中创建一个标记用的 attribute：
// HelloGenerator.Attributes.csproj
namespace HelloGenerator
{
[System.AttributeUsage(System.AttributeTargets.Class)]
public class GenerateHelloAttribute : System.Attribute { }
}
然后，创建 Generator 类：
// HelloGenerator.Source/HelloMethodGenerator.cs
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;
using System.Text;
[Generator]
public class HelloMethodGenerator : ISourceGenerator
{
public void Initialize(GeneratorInitializationContext context)
{
// 注册一个语法接收器，用于筛选出标记了 [GenerateHello] 的类
context.RegisterForSyntaxNotifications(() => new SyntaxReceiver());
}
public void Execute(GeneratorExecutionContext context)
{
if (context.SyntaxReceiver is not SyntaxReceiver receiver)
return;
// 遍历所有被标记的类，生成 SayHello 方法
foreach (var classDecl in receiver.CandidateClasses)
{
var model = context.Compilation.GetSemanticModel(classDecl.SyntaxTree);
var symbol = model.GetDeclaredSymbol(classDecl) as INamedTypeSymbol;
if (symbol is null) continue;
string className = symbol.Name;
string namespaceName = symbol.ContainingNamespace.ToDisplayString();
string source = $@"
namespace {namespaceName}
{{
public partial class {className}
{{
public void SayHello()
{{
System.Console.WriteLine(""Hello from Source Generator!"");
}}
}}
}}";
context.AddSource($"{className}_Hello.g.cs", SourceText.From(source, Encoding.UTF8));
}
}
// 语法接收器
class SyntaxReceiver : ISyntaxReceiver
{
public List<ClassDeclarationSyntax> CandidateClasses { get; } = new();
public void OnVisitSyntaxNode(SyntaxNode syntaxNode)
{
if (syntaxNode is ClassDeclarationSyntax classDecl &&
classDecl.AttributeLists.Count > 0)
{
CandidateClasses.Add(classDecl);
}
}
}
}
最后，在主项目中引用刚才的 Source Generator 项目，并使用 partial class 和 [GenerateHello]：
using HelloGenerator;
namespace MyApp
{
[GenerateHello]
public partial class Greeter { }
class Program
{
static void Main()
{
var g = new Greeter();
g.SayHello(); // 自动生成的方法
}
}
}
与反射和表达式树相比，Source Generator 更适合静态分析和生成结构性代码，是一种现代、高性能的代码生成方式，但实现起来略显麻烦。
总结
反射是 .NET 中一个强大的工具，它允许在运行时动态探索和操作类型，适用于插件系统、依赖注入、序列化等场景。然而，动态反射也有性能开销，应谨慎使用。
在需要高性能的场景下，可以考虑使用 Delegate 缓存、表达式树，或 .NET 6 的 Source Generators 来替代反射。