.NETCore使用Quartz的实现示例

要在 .NET Core 里用上 Quartz.NET，其实没那么复杂，按下面这几步走就行。从安装包到配置服务，再到写作业、调度触发，一套流程走下来，你就能轻松管理定时任务了。

1. 安装 NuGet 包

dotnet add package Quartz
dotnet add package Quartz.Extensions.Hosting

2. 配置服务

在 Program.cs 或 Startup.cs 中配置 Quartz，常见的有两种写法：

.NET 6+ 使用 Minimal API：

var builder = WebApplication.CreateBuilder(args);

// 添加 Quartz 服务
builder.Services.AddQuartz(q =>
{
    // 可选：配置 Quartz 选项
    q.UseMicrosoftDependencyInjectionJobFactory();
    
    // 创建作业键
    var jobKey = new JobKey("HelloWorldJob");
    
    // 注册作业
    q.AddJob(opts => opts.WithIdentity(jobKey));
    
    // 创建触发器
    q.AddTrigger(opts => opts
        .ForJob(jobKey)
        .WithIdentity("HelloWorldJob-trigger")
        .WithCronSchedule("0/5 * * * * ?")); // 每5秒执行一次
});

// 添加 Quartz 托管服务
builder.Services.AddQuartzHostedService(q => q.WaitForJobsToComplete = true);

var app = builder.Build();
app.Run();

传统配置方式：

public void ConfigureServices(IServiceCollection services)
{
    services.AddQuartz(q =>
    {
        q.UseMicrosoftDependencyInjectionJobFactory();
        
        var jobKey = new JobKey("HelloWorldJob");
        q.AddJob(opts => opts.WithIdentity(jobKey));
        
        q.AddTrigger(opts => opts
            .ForJob(jobKey)
            .WithIdentity("HelloWorldJob-trigger")
            .WithCronSchedule("0 0/5 * * * ?")); // 每5分钟执行一次
    });
    services.AddQuartzHostedService(q => q.WaitForJobsToComplete = true);
}

3. 创建作业

写一个类实现 IJob 接口就行了，依赖注入也直接支持：

using Quartz;

public class HelloWorldJob : IJob
{
    private readonly ILogger _logger;

    public HelloWorldJob(ILogger logger)
    {
        _logger = logger;
    }

    public async Task Execute(IJobExecutionContext context)
    {
        _logger.LogInformation("HelloWorldJob 执行于: {Time}", DateTime.Now);
        
        // 你的业务逻辑
        await Task.Delay(1000);
        
        _logger.LogInformation("HelloWorldJob 完成于: {Time}", DateTime.Now);
    }
}

4. 使用依赖注入的作业

如果作业需要其他服务，直接通过构造函数注入——Quartz 会自动从容器里解析：

public class EmailJob : IJob
{
    private readonly IEmailService _emailService;
    private readonly ILogger _logger;

    public EmailJob(IEmailService emailService, ILogger logger)
    {
        _emailService = emailService;
        _logger = logger;
    }

    public async Task Execute(IJobExecutionContext context)
    {
        try
        {
            // 从 JobDataMap 获取参数
            var toEmail = context.JobDetail.JobDataMap.GetString("ToEmail");
            var subject = context.JobDetail.JobDataMap.GetString("Subject");
            
            await _emailService.SendAsync(toEmail, subject, "Hello from Quartz!");
            _logger.LogInformation("邮件发送成功");
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "邮件发送失败");
        }
    }
}

5. 配置多个作业和触发器

实际项目中往往不止一个定时任务，可以这样批量注册：

services.AddQuartz(q =>
{
    // 作业1：每5分钟执行
    var jobKey1 = new JobKey("ReportJob");
    q.AddJob(opts => opts.WithIdentity(jobKey1));
    q.AddTrigger(opts => opts
        .ForJob(jobKey1)
        .WithIdentity("ReportJob-trigger")
        .WithCronSchedule("0 0/5 * * * ?"));
    
    // 作业2：每天凌晨2点执行
    var jobKey2 = new JobKey("CleanupJob");
    q.AddJob(opts => opts.WithIdentity(jobKey2));
    q.AddTrigger(opts => opts
        .ForJob(jobKey2)
        .WithIdentity("CleanupJob-trigger")
        .WithCronSchedule("0 0 2 * * ?"));
    
    // 作业3：简单的间隔调度
    var jobKey3 = new JobKey("HealthCheckJob");
    q.AddJob(opts => opts.WithIdentity(jobKey3));
    q.AddTrigger(opts => opts
        .ForJob(jobKey3)
        .WithIdentity("HealthCheckJob-trigger")
        .StartNow()
        .WithSimpleSchedule(x => x
            .WithIntervalInSeconds(30)
            .RepeatForever()));
});

6. 使用配置文件

Quartz 支持从 appsettings.json 里读取配置，比如线程池大小、作业存储方式：

{
  "Quartz": {
    "scheduler": {
      "instanceName": "MyScheduler"
    },
    "threadPool": {
      "type": "Quartz.Simpl.SimpleThreadPool, Quartz",
      "threadCount": 10
    },
    "jobStore": {
      "type": "Quartz.Simpl.RAMJobStore, Quartz"
    }
  }
}

7. 动态调度作业

有时候需要在运行时临时加个任务，比如用户指定时间发通知。这时候可以写个服务动态调度：

public class JobSchedulerService
{
    private readonly ISchedulerFactory _schedulerFactory;

    public JobSchedulerService(ISchedulerFactory schedulerFactory)
    {
        _schedulerFactory = schedulerFactory;
    }

    public async Task ScheduleOneTimeJob(DateTimeOffset startTime) where T : IJob
    {
        var scheduler = await _schedulerFactory.GetScheduler();
        
        var job = JobBuilder.Create()
            .WithIdentity(Guid.NewGuid().ToString())
            .Build();
        
        var trigger = TriggerBuilder.Create()
            .WithIdentity(Guid.NewGuid().ToString())
            .StartAt(startTime)
            .Build();
        
        await scheduler.ScheduleJob(job, trigger);
    }
}

常用 Cron 表达式示例

• "0 0/5 * * * ?" - 每5分钟
• "0 0 * * * ?" - 每小时
• "0 0 2 * * ?" - 每天凌晨2点
• "0 0 9 ? * MON-FRI" - 工作日早上9点
• "0 30 9 ? * MON" - 每周一早上9:30

到这里，.NET Core 里集成 Quartz.NET 的基本配置就搞定了。实际用的时候，根据自己的业务需求调整作业逻辑和调度策略就行，这套框架应付大部分定时场景都绰绰有余。