Quartz.NET 作业任务调动框架 单任务 多任务

Quartz.NET

1、Job 表示一个工作，要执行的具体内容。此接口中只有一个方法。
2、JobDetail 表示一个具体的可执行的调度程序，Job 是这个可执行程调度程序所要执行的内容，另外 JobDetail 还包含了这个任务调度的方案和策略。
3、Trigger 代表一个调度参数的配置，什么时候去调。
4、Scheduler 代表一个调度容器，一个调度容器中可以注册多个 JobDetail 和 Trigger。当 Trigger 与 JobDetail 组合，就可以被 Scheduler 容器调度了。

"0/10 * * * * ? *"  每10秒钟执行1次
"0/20 * * * * ? *"  每20秒钟执行1次
"0/30 * * * * ? *"  每30秒钟执行1次
"0 0/3 * * * ? *"   每3分钟执行1次

禁用Quartz日志

LogProvider.IsDisabled = true;

管理 NuGet 程序包(N)...

Quartz
NLog
NLog.Extensions.Logging
Microsoft.EntityFrameworkCore
Microsoft.EntityFrameworkCore.SqlServer
Microsoft.Extensions.Configuration

=========NET Core WinForms=========
1、Program.cs

using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using NLog.Extensions.Logging;
using Quartz;
using Quartz.Impl;
using Quartz.Spi;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace WinForms
{
    static class Program
    {
        /// 

        ///  The main entry point for the application.
        /// 
        [STAThread]
        static void Main()
        {
            Application.SetHighDpiMode(HighDpiMode.SystemAware);
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);

            NLog.LogManager.LoadConfiguration("nlog.config").GetCurrentClassLogger();

            var configuration = new ConfigurationBuilder().AddJsonFile("appsettings.json", optional: true, reloadOnChange: true).Build();

            IServiceCollection services = new ServiceCollection();

            services.AddTransient();
            services.AddSingleton();
            services.AddSingleton();
            services.AddSingleton();
            services.AddSingleton();
            services.AddSingleton();
            services.AddSingleton();
            services.AddSingleton();

            services.AddLogging(builder =>
            {
                builder.SetMinimumLevel(LogLevel.Information);
                builder.AddNLog(new NLogProviderOptions
                {
                    CaptureMessageTemplates = true,
                    CaptureMessageProperties = true
                });
                builder.AddNLog();
            });

            IServiceProvider serviceProvider = services.BuildServiceProvider();

            #region 单任务
            var quartz = serviceProvider.GetRequiredService();
            quartz.Start().Wait();
            #endregion

            #region 多任务
            var quartzMultiple = serviceProvider.GetRequiredService();
            quartzMultiple.Start().Wait();
            #endregion

            Application.Run(new Form1());
        }
    }
}

2、QuartzStartup.cs【单任务】

using Microsoft.Extensions.Logging;
using Quartz;
using Quartz.Spi;
using System.Threading.Tasks;

namespace WinForms
{
    /// 

    /// 单任务
    /// 
    public class QuartzStartup
    {
        private readonly ISchedulerFactory _schedulerFactory;
        private readonly IJobFactory _iocJobfactory;
        private IScheduler _scheduler;
        private readonly ILogger _logger;

        public QuartzStartup(IJobFactory iocJobfactory, ISchedulerFactory schedulerFactory, ILogger logger)
        {
            //1、声明一个调度工厂
            _schedulerFactory = schedulerFactory;
            _iocJobfactory = iocJobfactory;
            _logger = logger;
        }

        public async Task Start()
        {
            //2、通过调度工厂获得调度器
            _scheduler = await _schedulerFactory.GetScheduler();
            _scheduler.JobFactory = this._iocJobfactory;//  替换默认工厂
            //3、开启调度器
            await _scheduler.Start();

            //4、创建一个触发器
            //var trigger = TriggerBuilder.Create()
            //                .WithSimpleSchedule(x => x.WithIntervalInSeconds(2).RepeatForever())//每两秒执行一次
            //                .Build();
            ITrigger trigger = TriggerBuilder.Create()
             .WithIdentity("demojob")
             .WithCronSchedule("0/10 * * * * ? *")
             .Build()
             as ITrigger;

            //5、创建任务
            var jobDetail = JobBuilder.Create().WithIdentity("job", "group").Build();

            //6、将触发器和任务器绑定到调度器中
            await _scheduler.ScheduleJob(jobDetail, trigger);

            return await Task.FromResult("将触发器和任务器绑定到调度器中完成");
        }
        public void Stop()
        {
            if (_scheduler == null)
            {
                return;
            }

            if (_scheduler.Shutdown(waitForJobsToComplete: true).Wait(30000))
                _scheduler = null;
            else
            {
            }
            _logger.LogCritical("Schedule job upload as application stopped");
        }
    }
}

3、QuartzStartupMultiple.cs【多任务】

using Microsoft.Extensions.Logging;
using Quartz;
using Quartz.Spi;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Threading.Tasks;

namespace WinForms
{
    /// 

    /// 多任务
    /// 
    public class QuartzStartupMultiple
    {
        private readonly ISchedulerFactory _schedulerFactory;
        private readonly IJobFactory _iocJobfactory;
        private IScheduler _scheduler;
        private readonly ILogger _logger;

        public QuartzStartupMultiple(ISchedulerFactory schedulerFactory, IJobFactory iocJobfactory, ILogger logger)
        {
            //1、声明一个调度工厂
            _schedulerFactory = schedulerFactory;
            _iocJobfactory = iocJobfactory;
            _logger = logger;
        }
        public async Task Start()
        {
            //2、通过调度工厂获得调度器
            _scheduler = await _schedulerFactory.GetScheduler();
            _scheduler.JobFactory = this._iocJobfactory;//  替换默认工厂

            //5、创建任务
            IJobDetail monitoringJob = JobBuilder.Create().WithIdentity("job0").Build();
            IJobDetail taskJob = JobBuilder.Create().WithIdentity("job1").Build();

            List jobs = new List() { monitoringJob, taskJob };
            var jobAndTriggerMapping = new Dictionary>();

            for (int i = 0; i < jobs.Count; i++)
            {
                var job = jobs[i];

                //4、创建触发器
                var triggers = new ReadOnlyCollection(
                  new List()
                  {
                       TriggerBuilder.Create()
                       .WithIdentity("trigger_"+i)
                       .WithCronSchedule("0/10 * * * * ? *")
                       .Build()
                       as ITrigger
                  });

                // 建立映射关系
                jobAndTriggerMapping[job] = triggers;
            }

            //6、将触发器和任务器绑定到调度器中
            var readOnlyjobAndTriggerMapping = new ReadOnlyDictionary>(jobAndTriggerMapping);
            await _scheduler.ScheduleJobs(readOnlyjobAndTriggerMapping, true);

            //3、开启调度器
            await _scheduler.Start();

            return await Task.FromResult("将触发器和任务器绑定到调度器中完成");
        }
        public void Stop()
        {
            if (_scheduler == null)
            {
                return;
            }

            if (_scheduler.Shutdown(waitForJobsToComplete: true).Wait(30000))
                _scheduler = null;
            else
            {
            }
            _logger.LogCritical("Schedule job upload as application stopped");
        }
    }
}

*、DemoJobFactory.cs

using Quartz;
using Quartz.Spi;
using System;

namespace WinForms
{
    public class DemoJobFactory : IJobFactory
    {
        private readonly IServiceProvider _serviceProvider;

        public DemoJobFactory(IServiceProvider serviceProvider)
        {
            _serviceProvider = serviceProvider;
        }

        public IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler)
        {
            return _serviceProvider.GetService(bundle.JobDetail.JobType) as IJob;
        }

        public void ReturnJob(IJob job)
        {
            var disposable = job as IDisposable;
            disposable?.Dispose();
        }
    }
}

*、DemoJob.cs

using Quartz;
using System;
using System.Threading.Tasks;

namespace WinForms
{
    public class DemoJob : IJob
    {
        NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();

        public async Task Execute(IJobExecutionContext context)
        {
            //处理逻辑
            await Task.Factory.StartNew(() =>
                logger.Info($"DemoJob informational message {DateTime.Now}")
            );
        }
    }   
}

*、NetworkMonitoringJob.cs

using Quartz;
using System;
using System.Threading.Tasks;

namespace WinForms
{
    public class NetworkMonitoringJob : IJob
    {
        NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();

        public NetworkMonitoringJob()
        {
        }

        public async Task Execute(IJobExecutionContext context)
        {
            //await Task.Factory.StartNew(() => Check());

            await Task.Factory.StartNew(() =>
                logger.Info($"NetworkMonitoring informational message {DateTime.Now}")
            );
        }

        private void Check()
        {
            logger.Info($"NetworkMonitoring informational message {DateTime.Now}");
        }
    }
}

*、TaskJob.cs

using Quartz;
using System;
using System.Threading.Tasks;

namespace WinForms
{
    public class TaskJob : IJob
    {
        NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();

        public async Task Execute(IJobExecutionContext context)
        {
            //await Task.Factory.StartNew(() => Check());
            await Task.Factory.StartNew(() =>
                logger.Info($"TaskJob informational message {DateTime.Now}")
            );
        }

        private void Check()
        {
            logger.Info($"TaskJob informational message {DateTime.Now}");
        }
    }
}

*
=========WinForms窗体启动任务=========
1、Form1.cs窗体

using Huobi.WinForms.Jobs;
using System;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace WinForms
{
    public partial class Form1 : Form
    {
        NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();

        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            Task.Factory.StartNew(() => ScheduleManage.Show());
        }

        private void button1_Click(object sender, EventArgs e)
        {
            logger.Error($"{DateTime.Now}");
        }
    }
}

*、ScheduleManage.cs

using Microsoft.Extensions.Configuration;
using Quartz;
using Quartz.Impl;
using Quartz.Logging;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Configuration;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace WinForms.Jobs
{
    public class ScheduleManage
    {
        public static async Task Show()
        {
            IScheduler tsk = await StdSchedulerFactory.GetDefaultScheduler();
            IScheduler scheduler = tsk;

            LogProvider.IsDisabled = true;

            IJobDetail monitoringJob = JobBuilder.Create().WithIdentity("job1").Build();

            IJobDetail taskJob = JobBuilder.Create().WithIdentity("job2").Build();

            ITrigger _CronTrigger = TriggerBuilder.Create()
              .WithIdentity("定时确认")
              .WithCronSchedule("0/10 * * * * ? *")
              .Build()
              as ITrigger;
            #region 单任务
            //await scheduler.ScheduleJob(monitoringJob, _CronTrigger);
            #endregion

            #region 多任务
            List jobs = new List() { monitoringJob, taskJob };
            var jobAndTriggerMapping = new Dictionary>();

            for (int i = 0; i < jobs.Count; i++)
            {
                var job = jobs[i];
                // 只读的触发器集合
                //var triggers = new ReadOnlyCollection(
                //    new List()
                //    {
                // TriggerBuilder.Create()
                //     .WithIdentity("trigger_"+i)
                //     .WithSimpleSchedule(x => x.WithIntervalInSeconds(i++).RepeatForever())
                //     .Build()
                //    });

                var triggers = new ReadOnlyCollection(
                   new List()
                   {
                       TriggerBuilder.Create()
                       .WithIdentity("trigger_"+i)
                       .WithCronSchedule("0/10 * * * * ? *")
                       .Build()
                   });

                // 建立映射关系
                jobAndTriggerMapping[job] = triggers;
            }
            // 将映射关系包装成制度字典集合
            //var readOnlyjobAndTriggerMapping = new ReadOnlyDictionary>(jobAndTriggerMapping);
            //await scheduler.ScheduleJobs(readOnlyjobAndTriggerMapping, true);

            #endregion

            //await scheduler.Start();
        }
    }
}

*
*
*
*
*