.NET Core使用Quartz的实现方式示例实用指南

佚名 2026-08-28 15:10:01

平时做技术实践时，很多问题不是概念不会，而是细节没串起来。拿“.NET Core采用Quartz的实现方法示例”来说，它看着像小点，放到项目里常会牵出环境、配置、兼容性和维护成本。下面按实际采用顺序，把思路、关键写法和容易踩坑的地方讲清楚，便于大家直接对照操作。

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<HelloWorldJob>(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<HelloWorldJob>(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<HelloWorldJob> _logger;

    public HelloWorldJob(ILogger<HelloWorldJob> 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. 采用依赖注入的作业

若你的作业需其他服务，能够借助构造函数注入：

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

    public EmailJob(IEmailService emailService, ILogger<EmailJob> 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<ReportJob>(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<CleanupJob>(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<HealthCheckJob>(opts => opts.WithIdentity(jobKey3));
    q.AddTrigger(opts => opts
        .ForJob(jobKey3)
        .WithIdentity("HealthCheckJob-trigger")
        .StartNow()
        .WithSimpleSchedule(x => x
            .WithIntervalInSeconds(30)
            .RepeatForever()));
});

6. 采用设置文件

在 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<T>(DateTimeOffset startTime) where T : IJob
    {
        var scheduler = await _schedulerFactory.GetScheduler();
        
        var job = JobBuilder.Create<T>()
            .WithIdentity(Guid.NewGuid().ToString())
            .Build();
            
        var trigger = TriggerBuilder.Create()
            .WithIdentity(Guid.NewGuid().ToString())
            .StartAt(startTime)
            .Build();
            
        await scheduler.ScheduleJob(job, trigger);
    }
}