动态加载——C#开发者的“魔法口袋”

在软件开发中，模块化和可扩展性是永恒的主题。想象一下：你的程序像一个“积木工厂”，需要时加载模块，用完即卸载，内存不涨、功能不限。这正是C#动态加载依赖的核心魅力！

你是否遇到过这些问题？

• 插件系统需要热更新，但重新编译主程序太麻烦？
• 依赖的DLL版本冲突，导致程序崩溃？
• 想用反射调用外部类，但方法调用总报空引用？

本文将通过3大核心模块（动态加载DLL、反射调用、依赖注入），结合真实业务场景与C# 12新特性，带你彻底掌握动态加载的“黑科技”。

---

模块1：动态加载DLL——让程序“热插拔”

场景：按需加载插件模块

目标：实现运行时加载外部DLL，并调用其方法。

1. 使用Assembly.LoadFrom加载程序集

// 定义插件接口
public interface IPlugin
{
    string Execute();
}

// 主程序逻辑
class Program
{
    static void Main()
    {
        string pluginPath = @"C:\Plugins\MyPlugin.dll";

        try
        {
            // 动态加载DLL
            Assembly pluginAssembly = Assembly.LoadFrom(pluginPath);

            // 获取所有实现IPlugin的类型
            Type[] types = pluginAssembly.GetTypes();
            foreach (Type type in types)
            {
                if (typeof(IPlugin).IsAssignableFrom(type) && !type.IsInterface)
                {
                    // 创建实例
                    IPlugin plugin = (IPlugin)Activator.CreateInstance(type);
                    Console.WriteLine($"插件输出: {plugin.Execute()}");
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"加载插件失败: {ex.Message}");
        }
    }
}

代码注释：

1. Assembly.LoadFrom：从指定路径加载程序集，适用于非强名称的DLL。
2. GetTypes()：获取程序集中所有公共类型，筛选出实现IPlugin的类。
3. Activator.CreateInstance：动态创建实例，需确保目标类有无参构造函数。
4. 异常处理：动态加载可能因路径错误或类型缺失抛出异常，需兜底处理。

---

2. 高级技巧：卸载程序集（通过子域）

// 创建子AppDomain（需.NET Framework，.NET Core不支持）
AppDomain domain = AppDomain.CreateDomain("PluginDomain");

// 加载插件到子域
string pluginPath = @"C:\Plugins\MyPlugin.dll";
domain.DoCallBack(() =>
{
    Assembly pluginAssembly = Assembly.LoadFrom(pluginPath);
    Type pluginType = pluginAssembly.GetType("MyPlugin.MyPluginImpl");
    dynamic plugin = Activator.CreateInstance(pluginType);
    Console.WriteLine(plugin.Execute());
});

// 卸载子域（释放DLL）
AppDomain.Unload(domain);

代码注释：

1. AppDomain：通过子域隔离插件，卸载时可释放资源（仅限.NET Framework）。
2. dynamic：动态调用方法，避免硬编码类型名。
3. 限制：.NET Core/5+移除了AppDomain，需改用AssemblyLoadContext。

---

模块2：反射调用——让代码“自省”

场景：动态调用外部类的方法

目标：通过反射调用DLL中的方法，并传递参数。

1. 获取方法并调用

// 假设MyPlugin.dll中有如下类
// public class MyPluginImpl : IPlugin
// {
//     public string Execute(string input) => $"Processed: {input}";
// }

// 反射调用带参数的方法
Assembly pluginAssembly = Assembly.LoadFrom(@"C:\Plugins\MyPlugin.dll");
Type pluginType = pluginAssembly.GetType("MyPlugin.MyPluginImpl");
object pluginInstance = Activator.CreateInstance(pluginType);

// 获取方法信息
MethodInfo method = pluginType.GetMethod("Execute", new[] { typeof(string) });

// 调用方法并传参
string result = (string)method.Invoke(pluginInstance, new object[] { "Hello Dynamic!" });
Console.WriteLine(result); // 输出: Processed: Hello Dynamic!

代码注释：

1. GetMethod：需明确参数类型和顺序，否则可能找不到方法。
2. Invoke：第一个参数是实例，第二个是参数数组。
3. 性能优化：频繁调用时建议缓存MethodInfo对象。

---

2. 高级技巧：反射缓存（提升性能）

// 使用字典缓存MethodInfo
private static readonly Dictionary<string, MethodInfo> _methodCache = new();

public static object CallCachedMethod(object instance, string typeName, string methodName, object[] args)
{
    string key = $"{typeName}.{methodName}";
    if (!_methodCache.TryGetValue(key, out MethodInfo method))
    {
        Type type = Type.GetType(typeName);
        method = type?.GetMethod(methodName, BindingFlags.Public | BindingFlags.Instance, null, args.Select(a => a.GetType()).ToArray(), null);
        _methodCache[key] = method;
    }
    return method?.Invoke(instance, args);
}

代码注释：

1. 缓存MethodInfo：避免重复调用GetMethod，减少反射开销。
2. BindingFlags：指定搜索范围（实例方法/静态方法）。
3. 适用场景：高频调用动态方法时，性能提升显著。

---

模块3：依赖注入——让代码“松耦合”

场景：动态注册服务并管理生命周期

目标：通过依赖注入容器动态加载服务。

1. 使用Microsoft.Extensions.DependencyInjection

// 定义服务接口
public interface IService
{
    void DoWork();
}

// 实现类
public class MyService : IService
{
    public void DoWork() => Console.WriteLine("服务执行中...");
}

// 注册服务到容器
var services = new ServiceCollection();
services.AddTransient<IService, MyService>(); // 每次请求创建新实例
var serviceProvider = services.BuildServiceProvider();

// 使用服务
using (var scope = serviceProvider.CreateScope())
{
    IService service = scope.ServiceProvider.GetService<IService>();
    service.DoWork(); // 输出: 服务执行中...
}

代码注释：

1. AddTransient：瞬态模式，每次请求返回新实例。
2. CreateScope：创建作用域，适用于Web请求或事务场景。
3. GetService：从容器中获取已注册的服务实例。

---

2. 动态注册外部服务

// 动态加载DLL并注册服务
Assembly pluginAssembly = Assembly.LoadFrom(@"C:\Plugins\MyPlugin.dll");
Type pluginType = pluginAssembly.GetType("MyPlugin.MyPluginImpl");

if (typeof(IService).IsAssignableFrom(pluginType))
{
    services.AddTransient(typeof(IService), pluginType);
}

代码注释：

1. 动态注册：通过反射获取类型后，将其注册到DI容器。
2. 生命周期控制：支持AddTransient、AddScoped、AddSingleton。
3. 适用场景：插件系统中按需加载服务，无需硬编码依赖。

---

进阶技巧：C# 12的“隐藏技能”

1. 文件作用域命名空间（减少嵌套）

namespace MyNamespace;
// 替代传统写法：
// namespace MyNamespace { class MyClass { } }
class MyClass { }

2. 原始字符串字面量（简化配置）

string config = """
{
    "PluginPath": "C:\\Plugins\\MyPlugin.dll",
    "LogLevel": "Debug"
}
""";

3. 模式匹配优化（类型判断更简洁）

if (obj is MyType myInstance)
{
    myInstance.DoSomething();
}

---

常见问题与解决方案

问题	解决方案
动态加载的DLL无法卸载	使用AppDomain（.NET Framework）或AssemblyLoadContext（.NET Core）隔离加载。
反射调用方法时报“找不到方法”	检查方法签名（参数类型/数量）是否匹配，或使用BindingFlags调整搜索范围。
依赖注入冲突	明确注册服务的生命周期（Transient/Scoped/Singleton），避免作用域污染。
DLL路径错误导致崩溃	使用File.Exists验证路径，或通过Assembly.Load加载已引用的程序集。

---

动态加载的“黄金法则”

“动态加载不是炫技，而是为了解耦和扩展！”

1. DLL动态加载：用Assembly.LoadFrom实现热插拔，搭配子域或AssemblyLoadContext隔离资源。
2. 反射调用：通过MethodInfo.Invoke动态执行方法，结合缓存优化性能。
3. 依赖注入：用DI容器管理服务生命周期，动态注册外部类型。

“记住：动态加载的核心是‘灵活性’，但也要警惕‘过度设计’！”

• 如果是插件系统，Assembly.LoadFrom + 接口契约 是首选。
• 如果是微服务架构，依赖注入 + 配置驱动 更优雅。
• 如果是数据处理工具，反射 + 缓存 可以兼顾灵活性与性能。

---