C# 反射结合 Quartz 实现动态流程处理

结果与目标

我们的目标是构建一个能够接收“类名”、“方法名”及“输入参数”的系统模块。当模块接收到这些请求后，能够：
1. 准确找到对应的类与方法。
2. 正确实例化该类，并自动解决其构造函数中的依赖关系。
3. 填充所需的参数对象，并动态执行目标方法返回结果。

准备条件

• 程序集环境： 需要访问的类位于当前执行程序集中，或者通过特定配置可加载的外部 DLL 中。
• 依赖注入容器： 项目需配置标准的依赖注入体系（如 .NET Core 内置的 DI），以便后续解决类实例化时的依赖。
• 方法规范： 待调用的类方法应包含合理的参数，通常通过一个包含多个属性的 Input 类作为入参。

真实操作顺序

第1步：获取程序集下的所有类

目的： 建立可用类的索引，供外部查询。
入口： 工具类函数
动作： 使用 Assembly.GetExecutingAssembly() 获取当前程序集，提取其中的 ExportedTypes 并转为名称列表。

public List<string> GetClass(string assembyName = null)
{
    Assembly asm = Assembly.GetExecutingAssembly();
    var allclass = asm.ExportedTypes.ToList();
    return allclass.Select(u => u.Name).ToList();
}

第2步：筛选类的具体方法

目的： 从某个类中提取出真正可供业务调用的方法，排除系统默认继承的非虚方法或内部测试方法。
入口： 获取 Type 对象
动作： 使用 GetMethods()，过滤掉虚拟方法以及名称中包含 "GetType" 的自带方法。

public List<string> GetMethod(Type type, string assembyName = null)
{
    // 去除自带的 GetType 方法等干扰项
    List<MethodInfo> methods = type.GetMethods()
        .Where(u => u.IsVirtual == false)
        .Where(u => !u.Name.Contains("GetType"))
        .ToList();
    return methods.Select(u => u.Name).ToList();
}

第3步：解析方法的输入参数结构

目的： 确定被调用方法期望的参数类及其属性，以便后续进行模拟传值。
入口： MethodInfo 对象
动作： 由于直接通过 ToString() 有时难以精确识别参数类型信息，此处采用正则表达式从方法签名字符串中提取参数类型的名称，再回查程序集获取该类型的所有属性。

public List<string> GetParameter(MethodInfo methodInfo, Assembly assembly)
{
    // 由方法获取输入类, 创建类
    var method_FullName = methodInfo.ToString();
    // 方法中找不到 input 类的信息，只能从 fullname 中解析出来
    Regex reg = new Regex(@"(?is)(?<=\()(.*)(?=\))");
    Match m = reg.Match(method_FullName);
    string inputName = m.Value.Split(".").Last();
    
    Type input_class = assembly.ExportedTypes.Where(u => u.Name.Contains(inputName)).First();
    PropertyInfo[] propertyInfos = input_class.GetProperties();
    List<string> result = new List<string>();
    
    foreach (var item in propertyInfos)
    {
        var returnType = item.GetGetMethod().ReturnType;
        var name = returnType.ToString();
        result.Add(name);
    }
    return result;
}

第4步：建立全局服务提供者静态类

目的： 在非控制器、非上下文中也能随时获取依赖注入容器的服务能力，这是避免手动处理复杂构造函数依赖的关键。
入口： 启动项目时
动作： 创建一个静态类持有 IServiceProvider 实例。

public static class ServiceHelper
{
    public static IServiceProvider Instance { get; set; }
}

第5步：在主程序中注入服务提供者

目的： 将 ASP.NET Core 或其他框架生成的服务容器实例赋值给静态变量，使其全局可用。
入口： Program 的 Main 方法
动作： 构建 Host，创建作用域并从中获取 Service Provider。

public static void Main(string[] args)
{
    var webhost = CreateHostBuilder(args).Build();
    using (var scope = webhost.Services.CreateScope())
    {
        ServiceHelper.Instance = webhost.Services;
    }
    webhost.Run();
}

第6步：获取类实例并调用方法

目的： 利用上一步获取的服务提供者直接拿类实例，绕过反射实例化带来的构造参数难题；随后填充参数并执行反射调用。
入口： 动态执行引擎逻辑
动作：
1. 从 ServiceHelper 获取具体的类实例（依赖 DI 解决构造依赖）。
2. 根据之前解析出的参数类型，创建一个模拟的参数对象并填充测试数据。
3. 使用 MethodInfo.Invoke() 执行目标方法。

// 获取依赖注入中类
var api = ServiceHelper.Instance.GetService(do_class); 

PropertyInfo[] propertyInfos = input_class.GetProperties();
Object Args = Activator.CreateInstance(input_class);

// 填充参数对象的属性（示例仅为简单匹配）
foreach (var item in propertyInfos)
{
    var returnType = item.GetGetMethod().ReturnType;
    var name = returnType.ToString();
    // 匹配类型并赋予默认值
    if (name.ToLower().Contains("string"))
    {
        item.SetValue(Args, "test");
    }
    else if (name.ToLower().Contains("int"))
    {
        item.SetValue(Args, 1);
    }
}

// 模拟某方法进行执行
object[] inputArgs = new object[] { Args };
try
{
    // do_method 为 MethodInfo 对象，api 为已实例化的类对象
    var result = method.Invoke(api, inputArgs);
} 
catch (Exception ex)
{
    Console.WriteLine(ex.Message);
}

完成判断与排错

• 异常捕获： 在执行 Invoke 时必须包裹 try-catch，防止因方法不存在、参数类型不匹配或方法内部报错导致整个进程崩溃。
• 参数类型匹配： 上述代码中对参数的赋值（如字符串赋 "test"，整型赋 1）是简化演示。实际生产中，应根据外部传入的具体 JSON 或配置来填充真实的参数值，而非硬编码。
• 泛型与非公有成员： 默认的 GetMethods() 仅获取公共方法。如果目标方法是泛型或非公有的，需添加相应的 BindingFlags 参数。

简要总结

这种通过反射 + 依赖注入 + Quartz 的组合方式，非常适合用于低代码平台、动态脚本引擎或复杂的后台调度系统中。结合 Quartz 的 JobDataMap，可以将触发任务的元数据（类名、方法名、参数包）传递进来，再配合 HTTP Client 发起跨服务调用，即可形成一个极其灵活的流程处理闭环。

以上就是C# 反射结合 Quartz 实现动态流程处理的详细内容，更多关于C# 动态调用方法与架构设计的资料请关注本站其它相关文章！