使用Quartz.Extensions.Hosting简化Quartz的初始化工作

要求Quartz版本高于3.2

安装Install-Package Quartz.Extensions.Hosting

Quartz.Extensions.Hosting包中包含Quartz.Extensions.DependencyInjection, 详情请查询Quartz.Extensions.DependencyInjection Documents

下面是QuartzExtensions的代码,用于对Quartz的初始化

public static IServiceCollection AddMyQuartz(this IServiceCollection services)
    {
        services.AddQuartz(configure =>
        {
            configure.SchedulerId = "QRTZ";
            configure.UseMicrosoftDependencyInjectionJobFactory();
            configure.UseSimpleTypeLoader();
            configure.UseInMemoryStore();
            configure.UseDedicatedThreadPool(options =>
            {
                options.MaxConcurrency = 10;
            });
 
            var scriberPollingJobKey = JobKey.Create(IQuartzService.ScriberPolling);
            configure.AddJob<ScriberPollingJob>(scriberPollingJobKey);
            configure.AddTrigger(c =>
            {
                c.ForJob(scriberPollingJobKey)
                    .WithCronSchedule("*/1 * * * * ?");
            });
 
            var welder1PollingJobKey = JobKey.Create(IQuartzService.Welder1Polling);
            configure.AddJob<Welder1PollingJob>(welder1PollingJobKey);
            configure.AddTrigger(c =>
            {
                c.ForJob(welder1PollingJobKey)
                    .WithCronSchedule("*/1 * * * * ?");
            });
 
            var welder2PollingJobKey = JobKey.Create(IQuartzService.Welder2Polling);
            configure.AddJob<Welder2PollingJob>(welder2PollingJobKey);
            configure.AddTrigger(c =>
            {
                c.ForJob(welder2PollingJobKey)
                    .WithCronSchedule("*/1 * * * * ?");
            });
 
            var hslHealthJobKey = JobKey.Create(IQuartzService.HSLHealth);
            configure.AddJob<HSLHealthJob>(hslHealthJobKey);
            configure.AddTrigger(c =>
            {
                c.ForJob(hslHealthJobKey)
                    .StartNow()
                    .WithCronSchedule("*/10 * * * * ?");
            });
        });
        services.AddQuartzHostedService(options =>
        {
            options.WaitForJobsToComplete = true;
        });
 
        return services;
    }
}

下面是对于Job管理的代码

public interface IQuartzService
{
    const string HSLHealth = nameof(HSLHealth);
    const string ScriberPolling = nameof(ScriberPolling);
    const string Welder1Polling = nameof(Welder1Polling);
    const string Welder2Polling = nameof(Welder2Polling);
 
    /// <summary>
    /// 添加Job
    /// </summary>
    public void AddJob(IJobDetail jobDetail, ITrigger trigger);
    /// <summary>
    /// 暂停所有任务
    /// </summary>
    Task PauseAll();
    /// <summary>
    /// 恢复所有任务
    /// </summary>
    Task ResumeAll();
    /// <summary>
    /// 停止指定的任务
    /// </summary>
    Task PauseJob(string key);
    /// <summary>
    /// 恢复指定的任务
    /// </summary>
    Task ResumeJob(string key);
    /// <summary>
    /// 暂停指定的任务组
    /// </summary>
    Task PauseJobs(string group);
    /// <summary>
    /// 恢复指定的任务组
    /// </summary>
    Task ResumeJobs(string group);
    /// <summary>
    /// 停止调度器
    /// </summary>
    Task Shutdown();
       
}

public class QuartzService : IQuartzService
{
    private readonly ILogger<QuartzService> _logger;
    private IScheduler _scheduler;
 
    public QuartzService(ILogger<QuartzService> logger, ISchedulerFactory factory)
    {
        _logger = logger;
        Task.Run(async () => _scheduler = await factory.GetScheduler().ConfigureAwait(false));
    }
 
    public void AddJob(IJobDetail jobDetail, ITrigger trigger)
    {
        // DEMO
        //var key = JobKey.Create("JobName");
        //var _jobDetail = JobBuilder
        //    .Create<HSLHealthJob>()
        //    .WithIdentity(key)
        //    .Build();
        //var _trigger = TriggerBuilder.Create()
        //    .ForJob(key)
        //    .WithCronSchedule("*/5 * * * * ?")
        //    .Build();
        //_scheduler.ScheduleJob(_jobDetail, _trigger);
        _scheduler.ScheduleJob(jobDetail, trigger);
    }
 
    public async Task PauseAll()
    {
        await _scheduler.PauseAll();
    }
 
    public async Task ResumeAll()
    {
        await _scheduler.ResumeAll();
    }
 
    public async Task PauseJob(string key)
    {
        await _scheduler.PauseJob(JobKey.Create(key));
    }
 
    public async Task ResumeJob(string key)
    {
        await _scheduler.ResumeJob(JobKey.Create(key));
    }
 
    public async Task PauseJobs(string group)
    {
        await _scheduler.PauseJobs(GroupMatcher<JobKey>.GroupEquals(group));
    }
 
    public async Task ResumeJobs(string group)
    {
        await _scheduler.ResumeJobs(GroupMatcher<JobKey>.GroupEquals(group));
    }
 
    public async Task Shutdown()
    {
        await _scheduler.Shutdown(true);
    }
}

拿出初始化中的一个Job来查看效果

[DisallowConcurrentExecution]
public class HSLHealthJob : IJob
{
    private readonly ILogger<HSLHealthJob> _logger;
    private readonly HSLService _hsl;
    private readonly SettingViewModel _setting;
 
    public HSLHealthJob(ILogger<HSLHealthJob> logger, HSLService hsl, SettingViewModel setting)
    {
        _logger = logger;
        _hsl = hsl;
        _setting = setting;
 
        _hsl.ScriberS7Net.ReceiveTimeOut = 500;
        _hsl.Welder1S7Net.ReceiveTimeOut = 500;
        _hsl.Welder2S7Net.ReceiveTimeOut = 500;
    }
 
    public async Task Execute(IJobExecutionContext context)
    {
        //_logger.LogInformation($"{Thread.GetCurrentProcessorId()} in HSLHealth Job");
        var status = _hsl.ScriberS7Net.IpAddressPing();
        if (status == IPStatus.Success)
        {
            if (!_hsl.ScriberS7NetConnected)
            {
                var result = await _hsl.ScriberS7Net.ConnectServerAsync();
                if (result.IsSuccess)
                {
                    _hsl.ScriberS7NetConnected = true;
                    _setting.ScriberConnectionState = "连接成功";
                    _setting.ScriberConnectionColor = Colors.GreenYellow;
                }
 
                if (!_hsl.ScriberS7NetConnected)
                {
                    _setting.ScriberConnectionState = "网络异常";
                    _setting.ScriberConnectionColor = Colors.OrangeRed;
                }
            }
        }
        else
        {
            _logger.LogWarning($"Ping {_hsl.ScriberS7Net.IpAddress} {status}");
            if (_hsl.ScriberS7NetConnected)
                await _hsl.ScriberS7Net.ConnectCloseAsync();
            _hsl.ScriberS7NetConnected = false;
            _setting.ScriberConnectionState = "网络异常";
            _setting.ScriberConnectionColor = Colors.OrangeRed;
        }
 
        status = _hsl.Welder1S7Net.IpAddressPing();
        if (status == IPStatus.Success)
        {
            if (!_hsl.Welder1S7NetConnected)
            {
                var result = await _hsl.Welder1S7Net.ConnectServerAsync();
                if (result.IsSuccess)
                {
                    _hsl.Welder1S7NetConnected = true;
                    _setting.Welder1ConnectionState = "连接成功";
                    _setting.Welder1ConnectionColor = Colors.GreenYellow;
                }
 
                if (!_hsl.Welder1S7NetConnected)
                {
                    _setting.Welder1ConnectionState = "网络异常";
                    _setting.Welder1ConnectionColor = Colors.OrangeRed;
                }
            }
        }
        else
        {
            _logger.LogWarning($"Ping {_hsl.Welder1S7Net.IpAddress} {status}");
            if (_hsl.Welder1S7NetConnected)
                await _hsl.Welder1S7Net.ConnectCloseAsync();
            _hsl.Welder1S7NetConnected = false;
            _setting.Welder1ConnectionState = "网络异常";
            _setting.Welder1ConnectionColor = Colors.OrangeRed;
        }
 
        status = _hsl.Welder2S7Net.IpAddressPing();
        if (status == IPStatus.Success)
        {
            if (!_hsl.Welder2S7NetConnected)
            {
                var result = await _hsl.Welder2S7Net.ConnectServerAsync();
                if (result.IsSuccess)
                {
                    _hsl.Welder2S7NetConnected = true;
                    _setting.Welder2ConnectionState = "连接成功";
                    _setting.Welder2ConnectionColor = Colors.GreenYellow;
                }
 
                if (!_hsl.Welder2S7NetConnected)
                {
                    _setting.Welder2ConnectionState = "网络异常";
                    _setting.Welder2ConnectionColor = Colors.OrangeRed;
                }
            }
        }
        else
        {
            _logger.LogWarning($"Ping {_hsl.Welder2S7Net.IpAddress} {status}");
            if (_hsl.Welder2S7NetConnected)
                await _hsl.Welder2S7Net.ConnectCloseAsync();
            _hsl.Welder2S7NetConnected = false;
            _setting.Welder2ConnectionState = "网络异常";
            _setting.Welder2ConnectionColor = Colors.OrangeRed;
        }
    }
}

这个Job运行效果图如下