<think>我们正在讨论
C#中的反射（Reflection）作用。反射是
.NET框架提供的一种强大机制，它允许在运行
时检查、访问和操作程序集、类型及其成员。反射使得程序能够动态地获取类型信息、创建对象、调用方法、访问
字段和属性等，而
不需要在编译
时知道这些类型的具体信息。
反射的主要作用包括：
1
. 动态加载程序集
2
. 获取类型信息（类、结构、接口、枚举等）
3
. 动态创建对象实例
4
. 动态调用方法和属性
5
. 访问和修改
字段（包括私有
字段）
6
. 实现插件系统
7
. 实现依赖注入容器
8
. 序列化和反序列化
下面我们通过代码示例来详细解释反射的作用。
### 示例1：动态加载程序集并获取类型信息
```csharp
using System;
using System
.Reflection;
class Program
{
static void Main()
{
// 动态加载程序集（假设当前目录下有一个名为"ExampleAssembly
.dll"的程序集）
Assembly assembly = Assembly
.LoadFrom("ExampleAssembly
.dll");
// 获取程序集中所有公共类型
Type[] types = assembly
.GetTypes();
foreach (Type type in types)
{
Console
.WriteLine($"Type: {type
.FullName}");
}
}
}
```
### 示例2：动态创建对象实例
```csharp
using System;
class Program
{
static void Main()
{
// 获取类型（这里以System
.String为例）
Type type = Type
.GetType("System
.String");
// 创建
String对象实例（调用无参构造函数）
object strInstance = Activator
.CreateInstance(type);
Console
.WriteLine($"Instance of: {strInstance
.GetType()
.Name}"); // 输出:
String
// 创建带参数的实例（调用有参构造函数）
object strWithContent = Activator
.CreateInstance(type, new object[] { 'A', 5 });
Console
.WriteLine(strWithContent); // 输出: AAAAA
}
}
```
### 示例3：动态调用方法
```csharp
using System;
using System
.Reflection;
class Calculator
{
public int Add(int a, int b) => a + b;
private int Multiply(int a, int b) => a * b;
}
class Program
{
static void Main()
{
// 创建Calculator实例
Calculator calc = new Calculator();
Type calcType = typeof(Calculator);
// 调用公共方法Add
MethodInfo addMethod = calcType
.GetMethod("Add");
int result = (int)addMethod
.Invoke(calc, new object[] { 3, 5 });
Console
.WriteLine($"3 + 5 = {result}"); // 输出: 8
// 调用私有方法Multiply
MethodInfo multiplyMethod = calcType
.GetMethod("Multiply", BindingFlags
.NonPublic | BindingFlags
.Instance);
int product = (int)multiplyMethod
.Invoke(calc, new object[] { 3, 5 });
Console
.WriteLine($"3 * 5 = {product}"); // 输出: 15
}
}
```
### 示例4：访问和修改
字段（包括私有
字段）
```csharp
using System;
using System
.Reflection;
class Person
{
private
string name;
public int Age { get; set; }
public Person(
string name, int age)
{
this
.name = name;
Age = age;
}
}
class Program
{
static void Main()
{
Person person = new Person("Alice", 30);
Type personType = typeof(Person);
// 获取私有
字段name
FieldInfo nameField = personType
.GetField("name", BindingFlags
.NonPublic | BindingFlags
.Instance);
// 读取私有
字段的值
string nameValue = (
string)nameField
.GetValue(person);
Console
.WriteLine($"Original name: {nameValue}"); // 输出: Alice
// 修改私有
字段的值
nameField
.SetValue(person, "Bob");
nameValue = (
string)nameField
.GetValue(person);
Console
.WriteLine($"Updated name: {nameValue}"); // 输出: Bob
// 访问公共属性Age
PropertyInfo ageProp = personType
.GetProperty("Age");
int age = (int)ageProp
.GetValue(person);
Console
.WriteLine($"Age: {age}"); // 输出: 30
// 修改公共属性
ageProp
.SetValue(person, 31);
Console
.WriteLine($"Updated age: {person
.Age}"); // 输出: 31
}
}
```
### 示例5：实现简单的插件系统
```csharp
using System;
using System
.IO;
using System
.Reflection;
// 插件接口
public interface IPlugin
{
string Name { get; }
void Execute();
}
// 主程序
class PluginHost
{
static void Main()
{
// 加载插件目录
中的所有程序集
string pluginPath = Path
.Combine(Environment
.CurrentDirectory, "Plugins");
foreach (
string dll in Directory
.GetFiles(pluginPath, "*
.dll"))
{
Assembly assembly = Assembly
.LoadFrom(dll);
foreach (Type type in assembly
.GetTypes())
{
if (typeof(IPlugin)
.IsAssignableFrom(type))
{
// 创建插件实例
IPlugin plugin = (IPlugin)Activator
.CreateInstance(type);
Console
.WriteLine($"Loaded plugin: {plugin
.Name}");
plugin
.Execute();
}
}
}
}
}
// 插件实现（在另一个程序集中编译）
public class HelloPlugin : IPlugin
{
public
string Name => "Hello Plugin";
public void Execute()
{
Console
.WriteLine("Hello from the plugin!");
}
}
public class TimePlugin : IPlugin
{
public
string Name => "Time Plugin";
public void Execute()
{
Console
.WriteLine($"Current time: {
DateTime.Now}");
}
}
```
### 反射的注意事项
1
. **性能开销**：反射操作比直接代码调用慢，应避免在性能敏感的代码中过度使用。
2
. **安全性**：反射可以访问私有成员，可能破坏封装性，需要谨慎使用。
3
. **类型安全**：反射在编译
时不进行类型检查，容易导致运行
时错误。
4
. **维护性**：过度使用反射可能使代码难以理解和维护。
### 反射的典型应用场景
- 开发IDE的智能提示和代码分析
- 对象关系映射（ORM）框架
- 依赖注入容器（如ASP
.NET Core的DI）
- 序列化库（如JSON
.NET）
- 单元测试框架
- 插件架构
通过上述示例和解释，我们可以看到反射在
C#中提供了强大的动态编程能力，使得程序可以在运行
时探索和操作类型信息，实现高度灵活的系统设计。然而，反射也应该谨慎使用，避免
不必要的性能损失和代码可维护性问题。
§§相关问题§§:
1
. 反射的性能开销主要来自哪些方面？如何优化反射性能？
2
. 在
C#中如何通过反射获取泛型类型的信息？
3
. 反射在依赖注入框架中是如何应用的？
4
. C#的反射与动态编程（dynamic关键字）有何区别？</think>#
C# 反射详解：作用、原理与实战应用
反射是
C# 中一项强大的元编程能力，它允许程序在运行
时检查、分析和操作类型信息。反射是
.NET 框架的核心特性之一，为许多高级功能提供了基础支持。
## 反射的核心作用
| 作用 | 描述 | 应用场景 |
|------|------|----------|
| **类型检查** | 获取类型信息 | 动态加载插件 |
| **对象创建** | 动态实例化对象 | 依赖注入容器 |
| **成员访问** | 访问
字段、属性和方法 | 序列化/反序列化 |
| **元数据检查** | 读取特性信息 | ORM 框架 |
| **动态调用** | 调用方法 | 脚本引擎 |
| **程序集操作** | 加载和检查程序集 | 插件系统 |
## 反射基础：System
.Reflection 命名空间
### 1
. 获取类型信息
```csharp
using System;
using System
.Reflection;
class Program
{
static void Main()
{
// 获取类型信息的三种方式
Type
stringType1 = typeof(
string); // 编译
时已知类型
Type
stringType2 = Type
.GetType("System
.String"); // 通过类型名称
Type currentType = "Hello"
.GetType(); // 通过对象实例
Console
.WriteLine($"Type: {
stringType1
.FullName}");
Console
.WriteLine($"Is class: {
stringType1
.IsClass}");
Console
.WriteLine($"Is value type: {
stringType1
.IsValueType}");
Console
.WriteLine($"Namespace: {
stringType1
.Namespace}");
Console
.WriteLine($"Assembly: {
stringType1
.Assembly
.FullName}");
}
}
```
### 2
. 动态创建对象实例
```csharp
using System;
class Person
{
public
string Name { get; set; }
public int Age { get; set; }
public Person() { }
public Person(
string name, int age)
{
Name = name;
Age = age;
}
public void Introduce()
{
Console
.WriteLine($"Hello, I'm {Name}, {Age} years old
.");
}
}
class Program
{
static void Main()
{
// 获取Person类型
Type personType = typeof(Person);
// 使用无参构造函数创建实例
object person1 = Activator
.CreateInstance(personType);
// 使用有参构造函数创建实例
object person2 = Activator
.CreateInstance(
personType,
new object[] { "Alice", 30 }
);
// 访问属性
PropertyInfo nameProp = personType
.GetProperty("Name");
nameProp
.SetValue(person1, "Bob");
// 调用方法
MethodInfo introMethod = personType
.GetMethod("Introduce");
introMethod
.Invoke(person1, null); // 输出: Hello, I'm Bob, 0 years old
.
introMethod
.Invoke(person2, null); // 输出: Hello, I'm Alice, 30 years old
.
}
}
```
## 反射的核心应用场景
### 1
. 动态加载插件系统
```csharp
using System;
using System
.IO;
using System
.Reflection;
// 插件接口
public interface IPlugin
{
string Name { get; }
void Execute();
}
// 主程序
class PluginHost
{
static void Main()
{
string pluginPath = Path
.Combine(AppDomain
.CurrentDomain
.BaseDirectory, "Plugins");
if (!Directory
.Exists(pluginPath))
{
Directory
.CreateDirectory(pluginPath);
}
// 加载所有插件程序集
foreach (
string dll in Directory
.GetFiles(pluginPath, "*
.dll"))
{
try
{
Assembly assembly = Assembly
.LoadFrom(dll);
foreach (Type type in assembly
.GetTypes())
{
if (typeof(IPlugin)
.IsAssignableFrom(type) && !type
.IsInterface)
{
// 创建插件实例
IPlugin plugin = (IPlugin)Activator
.CreateInstance(type);
Console
.WriteLine($"Loaded plugin: {plugin
.Name}");
plugin
.Execute();
}
}
}
catch (Exception ex)
{
Console
.WriteLine($"Failed to load plugin from {dll}: {ex
.Message}");
}
}
}
}
// 插件实现 (在单独的插件项目中编译)
public class HelloPlugin : IPlugin
{
public
string Name => "Hello World Plugin";
public void Execute()
{
Console
.WriteLine("Hello from the plugin!");
}
}
public class CalculatorPlugin : IPlugin
{
public
string Name => "Calculator Plugin";
public void Execute()
{
Console
.WriteLine("Calculating: 2 + 3 = 5");
}
}
```
### 2
. 序列化与反序列化
```csharp
using System;
using System
.Collections
.Generic;
using System
.Reflection;
using System
.Text;
class SimpleSerializer
{
public static
string Serialize(object obj)
{
if (obj == null) return "null";
Type type = obj
.GetType();
var sb = new
StringBuilder();
sb
.AppendLine($"{{");
sb
.AppendLine($" \"$type\": \"{type
.FullName}, {type
.Assembly
.GetName()
.Name}\",");
// 序列化属性
PropertyInfo[] properties = type
.GetProperties();
for (int i = 0; i < properties
.Length; i++)
{
PropertyInfo prop = properties[i];
object value = prop
.GetValue(obj);
sb
.Append($" \"{prop
.Name}\": ");
if (value == null)
{
sb
.Append("null");
}
else if (value is
string)
{
sb
.Append($"\"{value}\"");
}
else if (value
.GetType()
.IsPrimitive)
{
sb
.Append(value
.To
String()
.ToLower()); // true/false for bool
}
else
{
// 递归序列化复杂对象
sb
.Append(Serialize(value));
}
if (i < properties
.Length - 1) sb
.Append(",");
sb
.AppendLine();
}
sb
.Append($"}}");
return sb
.To
String();
}
public static T Deserialize<T>(
string json) where T : new()
{
// 简化实现 - 实际应用中应使用完整JSON解析
// 这里仅演示反射的基本用法
var obj = new T();
Type type = typeof(T);
// 模拟解析JSON
var properties = new Dictionary<
string,
string>
{
{ "Name", "Alice" },
{ "Age", "30" }
};
foreach (var prop in properties)
{
PropertyInfo property = type
.GetProperty(prop
.Key);
if (property != null && property
.CanWrite)
{
object value = Convert
.ChangeType(prop
.Value, property
.PropertyType);
property
.SetValue(obj, value);
}
}
return obj;
}
}
class Person
{
public
string Name { get; set; }
public int Age { get; set; }
public override
string To
String() => $"{Name}, {Age}";
}
class Program
{
static void Main()
{
Person person = new Person { Name = "Bob", Age = 25 };
// 序列化
string json = SimpleSerializer
.Serialize(person);
Console
.WriteLine("Serialized JSON:");
Console
.WriteLine(json);
// 反序列化
Person deserialized = SimpleSerializer
.Deserialize<Person>(json);
Console
.WriteLine("\nDeserialized object:");
Console
.WriteLine(deserialized);
}
}
```
### 3
. 依赖注入容器
```csharp
using System;
using System
.Collections
.Generic;
using System
.Reflection;
// 简单依赖注入容器
public class DIContainer
{
private readonly Dictionary<Type, Type> _mappings = new Dictionary<Type, Type>();
private readonly Dictionary<Type, object> _instances = new Dictionary<Type, object>();
// 注册类型映射
public void Register<TInterface, TImplementation>() where TImplementation : TInterface
{
_mappings[typeof(TInterface)] = typeof(TImplementation);
}
// 注册单例
public void RegisterSingleton<TInterface, TImplementation>() where TImplementation : TInterface
{
Register<TInterface, TImplementation>();
_instances[typeof(TInterface)] = Resolve(typeof(TInterface));
}
// 解析实例
public T Resolve<T>()
{
return (T)Resolve(typeof(T));
}
private object Resolve(Type type)
{
// 如果是单例，直接返回实例
if (_instances
.TryGetValue(type, out object instance))
{
return instance;
}
// 获取实际实现类型
Type implementationType = _mappings
.ContainsKey(type) ? _mappings[type] : type;
// 获取构造函数
ConstructorInfo constructor = implementationType
.GetConstructors()[0];
// 获取构造函数参数
ParameterInfo[] parameters = constructor
.GetParameters();
List<object> paramInstances = new List<object>();
// 递归解析依赖
foreach (ParameterInfo param in parameters)
{
paramInstances
.Add(Resolve(param
.ParameterType));
}
// 创建实例
return constructor
.Invoke(paramInstances
.ToArray());
}
}
// 使用示例
public interface ILogger
{
void Log(
string message);
}
public class ConsoleLogger : ILogger
{
public void Log(
string message)
{
Console
.WriteLine($"[LOG] {
DateTime.Now}: {message}");
}
}
public interface IDataService
{
void FetchData();
}
public class DatabaseService : IDataService
{
private readonly ILogger _logger;
public DatabaseService(ILogger logger)
{
_logger = logger;
}
public void FetchData()
{
_logger
.Log("Fetching data from database
...");
// 实际
数据库操作
Console
.WriteLine("Data fetched successfully");
}
}
public class Application
{
private readonly IDataService _dataService;
public Application(IDataService dataService)
{
_dataService = dataService;
}
public void Run()
{
_dataService
.FetchData();
}
}
class Program
{
static void Main()
{
// 创建容器并注册依赖
var container = new DIContainer();
container
.Register<ILogger, ConsoleLogger>();
container
.Register<IDataService, DatabaseService>();
// 解析应用程序并运行
var app = container
.Resolve<Application>();
app
.Run();
}
}
```
## 反射的高级应用
### 1
. 特性（Attribute）处理
```csharp
using System;
using System
.Reflection;
// 自定义特性
[AttributeUsage(AttributeTargets
.Class | AttributeTargets
.Method, AllowMultiple = true)]
class AuthorAttribute : Attribute
{
public
string Name { get; }
public
string Date { get; }
public AuthorAttribute(
string name,
string date)
{
Name = name;
Date = date;
}
}
// 使用特性标记
[Author("Alice", "2023-01-15")]
[Author("Bob", "2023-02-20")]
class Calculator
{
[Author("Charlie", "2023-03-10")]
public int Add(int a, int b) => a + b;
public int Subtract(int a, int b) => a - b;
}
class AttributeProcessor
{
public static void ProcessAttributes(Type type)
{
// 获取类级别特性
var classAttributes = type
.GetCustomAttributes<AuthorAttribute>();
Console
.WriteLine($"Class: {type
.Name}");
foreach (var attr in classAttributes)
{
Console
.WriteLine($" Author: {attr
.Name}, Date: {attr
.Date}");
}
// 处理方法级别特性
foreach (MethodInfo method in type
.GetMethods())
{
var methodAttributes = method
.GetCustomAttributes<AuthorAttribute>();
if (methodAttributes
.Any())
{
Console
.WriteLine($"\nMethod: {method
.Name}");
foreach (var attr in methodAttributes)
{
Console
.WriteLine($" Author: {attr
.Name}, Date: {attr
.Date}");
}
}
}
}
}
class Program
{
static void Main()
{
AttributeProcessor
.ProcessAttributes(typeof(Calculator));
}
}
```
### 2
. 动态方法调用优化
```csharp
using System;
using System
.Diagnostics;
using System
.Reflection;
using System
.Reflection
.Emit;
// 传统反射调用
class ReflectionMethodCaller
{
public static void CallMethod(object obj,
string methodName, object[] args)
{
MethodInfo method = obj
.GetType()
.GetMethod(methodName);
method
.Invoke(obj, args);
}
}
// 动态方法调用（使用Delegate）
class DelegateMethodCaller
{
private delegate object MethodInvoker(object target, object[] args);
public static void CallMethod(object obj,
string methodName, object[] args)
{
MethodInfo method = obj
.GetType()
.GetMethod(methodName);
MethodInvoker invoker = CreateMethodInvoker(method);
invoker(obj, args);
}
private static MethodInvoker CreateMethodInvoker(MethodInfo method)
{
// 创建动态方法
DynamicMethod dm = new DynamicMethod(
name: "DynamicInvoker",
returnType: typeof(object),
parameterTypes: new[] { typeof(object), typeof(object[]) },
owner: method
.DeclaringType
.Module,
skipVisibility: true);
// 生成IL代码
ILGenerator il = dm
.GetILGenerator();
// 加载目标对象
il
.Emit(OpCodes
.Ldarg_0);
// 加载参数数组
il
.Emit(OpCodes
.Ldarg_1);
// 准备参数
ParameterInfo[] parameters = method
.GetParameters();
for (int i = 0; i < parameters
.Length; i++)
{
il
.Emit(OpCodes
.Ldarg_1); // 加载参数数组
il
.Emit(OpCodes
.Ldc_I4, i); // 加载索引
il
.Emit(OpCodes
.Ldelem_Ref); // 加载参数值
// 如果是值类型，需要拆箱
if (parameters[i]
.ParameterType
.IsValueType)
{
il
.Emit(OpCodes
.Unbox_Any, parameters[i]
.ParameterType);
}
}
// 调用方法
if (method
.IsVirtual)
{
il
.Emit(OpCodes
.Callvirt, method);
}
else
{
il
.Emit(OpCodes
.Call, method);
}
// 处理返回值
if (method
.ReturnType == typeof(void))
{
il
.Emit(OpCodes
.Ldnull);
}
else if (method
.ReturnType
.IsValueType)
{
il
.Emit(OpCodes
.Box, method
.ReturnType);
}
// 返回结果
il
.Emit(OpCodes
.Ret);
// 创建委托
return (MethodInvoker)dm
.CreateDelegate(typeof(MethodInvoker));
}
}
class Calculator
{
public int Add(int a, int b) => a + b;
}
class Program
{
static void Main()
{
var calculator = new Calculator();
var args = new object[] { 5, 3 };
// 测试传统反射性能
var stopwatch = Stopwatch
.StartNew();
for (int i = 0; i < 100000; i++)
{
ReflectionMethodCaller
.CallMethod(calculator, "Add", args);
}
Console
.WriteLine($"Traditional reflection: {stopwatch
.ElapsedMilliseconds} ms");
// 测试委托优化性能
stopwatch
.Restart();
for (int i = 0; i < 100000; i++)
{
DelegateMethodCaller
.CallMethod(calculator, "Add", args);
}
Console
.WriteLine($"Delegate optimized: {stopwatch
.ElapsedMilliseconds} ms");
// 测试直接调用性能
stopwatch
.Restart();
for (int i = 0; i < 100000; i++)
{
calculator
.Add(5, 3);
}
Console
.WriteLine($"Direct call: {stopwatch
.ElapsedMilliseconds} ms");
}
}
```
## 反射的性能考虑与优化
### 反射性能开销来源
1
. **类型发现**：查找类型和方法信息
2
. **安全检查**：验证访问权限
3
. **参数封送**：装箱/拆箱操作
4
. **方法调用**：间接调用开销
### 性能优化策略
| 策略 | 描述 | 适用场景 |
|------|------|----------|
| **缓存反射结果** | 存储类型、方法等信息 | 重复使用相同成员 |
| **使用Delegate** | 创建方法委托 | 频繁调用的方法 |
| **
表达式树** | 编译为可执行代码 | 高性能动态调用 |
| **动态方法** | 使用Reflection
.Emit | 生成动态代码 |
| **使用泛型** | 减少装箱操作 | 值类型操作 |
| **避免深度反射** | 减少嵌套反射调用 | 复杂对象处理 |
###
表达式树优化示例
```csharp
using System;
using System
.Diagnostics;
using System
.Linq
.Expressions;
using System
.Reflection;
class ExpressionTreeCaller
{
private delegate object MethodInvoker(object target, object[] args);
public static void CallMethod(object obj,
string methodName, object[] args)
{
MethodInfo method = obj
.GetType()
.GetMethod(methodName);
MethodInvoker invoker = CreateMethodInvoker(method);
invoker(obj, args);
}
private static MethodInvoker CreateMethodInvoker(MethodInfo method)
{
// 创建参数
表达式
var targetParam = Expression
.Parameter(typeof(object), "target");
var argsParam = Expression
.Parameter(typeof(object[]), "args");
// 转换目标对象类型
var instance = Expression
.Convert(targetParam, method
.DeclaringType);
// 准备方法参数
var parameters = method
.GetParameters();
var arguments = new Expression[parameters
.Length];
for (int i = 0; i < parameters
.Length; i++)
{
// 从数组中获取参数
var index = Expression
.Constant(i);
var arg = Expression
.ArrayIndex(argsParam, index);
// 转换为正确的类型
arguments[i] = Expression
.Convert(arg, parameters[i]
.ParameterType);
}
// 方法调用
var methodCall = Expression
.Call(instance, method, arguments);
// 处理返回值
Expression body;
if (method
.ReturnType == typeof(void))
{
body = Expression
.Block(
methodCall,
Expression
.Constant(null)
);
}
else
{
body = Expression
.Convert(methodCall, typeof(object));
}
// 创建lambda
表达式
var lambda = Expression
.Lambda<MethodInvoker>(body, targetParam, argsParam);
// 编译为委托
return lambda
.Compile();
}
}
class Program
{
static void Main()
{
var calculator = new Calculator();
var args = new object[] { 5, 3 };
// 测试
表达式树性能
var stopwatch = Stopwatch
.StartNew();
for (int i = 0; i < 100000; i++)
{
ExpressionTreeCaller
.CallMethod(calculator, "Add", args);
}
Console
.WriteLine($"Expression tree: {stopwatch
.ElapsedMilliseconds} ms");
}
}
```
## 反射的安全考虑
1
. **权限限制**：在部分信任环境（如沙箱）中反射可能受限
2
. **私有成员访问**：反射可以绕过访问修饰符，破坏封装性
3
. **代码注入风险**：动态加载程序集可能引入安全漏洞
4
. **类型安全**：反射操作绕过编译
时类型检查
### 安全最佳实践
- 避免在公开API中暴露反射功能
- 对动态加载的程序集进行强名称验证
- 限制反射访问敏感类型和成员
- 在沙箱环境中使用Code
Access Security (CAS)
## 反射在现代框架
中的应用
### 1
. ASP
.NET Core MVC
- 控制器发现与路由
- 模型绑定与验证
- 依赖注入
### 2
. Entity Framework Core
- 实体-
数据库映射
- 查询转换
- 变更跟踪
### 3
. JSON 序列化库 (如 System
.Text
.Json)
- 对象属性发现
- 自定义序列化器
- 特性驱动行为
### 4
. 单元测试框架 (如 xUnit/NUnit)
- 测试方法发现
- 测试夹具管理
- 数据驱动测试
## 总结：反射的核心作用
1
. **动态类型检查**：运行
时获取类型信息
2
. **对象实例化**：动态创建对象实例
3
. **成员访问**：读取/设置
字段、属性、调用方法
4
. **元数据探索**：检查程序集、模块、特性
5
. **插件系统支持**：动态加载和执行代码
6
. **泛型处理**：动态创建和操作泛型类型
7
. **代码生成**：通过Reflection
.Emit动态生成代码
反射是
C# 中一项强大的元编程能力，它为许多高级功能（如依赖注入、序列化、ORM 框架等）提供了基础支持。然而，反射也带来了性能开销和安全风险，应在必要
时谨慎使用，并考虑性能优化策略。
扫一扫
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
