.Net Core 定时器Quartz

最近因为项目需要用到了Quartz，下面简单记录一下。

一、首先需要安装Quartz。

二、定义一个执行的Job类，实现IJob接口，接口有一个方法Execute，用来执行定时任务的实现内容。

    public class HelloJob : IJob
    {
        public async Task Execute(IJobExecutionContext context)
        {
            Console.WriteLine("作业执行!");
        }
    }

三、定时触发，根据设定的时间间隔触发。

            //从工厂中获取一个调度器实例化
            IScheduler scheduler = await StdSchedulerFactory.GetDefaultScheduler();

            await scheduler.Start();       //开启调度器

            //==========例子1（简单使用）===========

            IJobDetail job1 = JobBuilder.Create<HelloJob>()  //创建一个作业
                .WithIdentity("job", "group1")
                .Build();

            ITrigger trigger1 = TriggerBuilder.Create()
                .WithIdentity("trigger", "group1")
                .StartNow()                        //现在开始
                .WithSimpleSchedule(x => x         //触发时间，5秒一次。
                    .WithIntervalInSeconds(5)
                    .RepeatForever())              //不间断重复执行
                .Build();


            await scheduler.ScheduleJob(job1, trigger1);      //把作业，触发器加入调度器。

四、仅触发一次，定时器在设定时间内，只触发一次。

            IScheduler scheduler = await StdSchedulerFactory.GetDefaultScheduler();

            IJobDetail job = JobBuilder.Create<HelloJob>()  //创建一个作业
                .WithIdentity("job3", "group3")
                .Build();

            ITrigger trigger = trigger = (ISimpleTrigger)TriggerBuilder.Create()
                .WithIdentity("trigger3", "group3")
                .StartAt(DateBuilder.FutureDate(1, IntervalUnit.Second)) //使用DateBuilder将来创建一个时间日期
                .ForJob(job) //通过JobKey识别作业
                .Build();

            await scheduler.ScheduleJob(job,trigger);
            await scheduler.Start();

五、移除定时任务

调用公共方法，实现定时任务移除

  JobKey JKey = new JobKey("job", "group1");
  TriggerKey TKey = new TriggerKey("trigger", "group1");
  await QuartzHelper.RemoveJob(JKey, TKey);

封装了一个定时器的公共类，方便程序复用。

    public static class QuartzHelper
    {
        public static async Task RemoveJob(JobKey jobKey, TriggerKey triggerKey)
        {
            try
            {
                var scheduler = await TaskDeadLineEndJob.GetSchedulerAsync();
                var state = await scheduler.GetTriggerState(triggerKey);
                if (state == TriggerState.None)
                {
                    return;
                }
                await scheduler.PauseTrigger(triggerKey);// 停止触发器
                await scheduler.UnscheduleJob(triggerKey);// 移除触发器
                await scheduler.DeleteJob(jobKey);// 删除任务
            }
            catch (Exception)
            {
                throw;
            }
        }
    }

 定义一个工厂类，用来保证定时任务是唯一的，如果每次都new一个新实例，后面可能会出问题。

   public class TaskDeadLineEndJob
    {
        private static IScheduler scheduler;
        private static Task<IScheduler> TaskScheduler;
        private static readonly object padlock = new object();

        public static async Task<IScheduler> GetSchedulerAsync()
        {
            lock (padlock)
            {
                // 如果类的实例不存在则创建，否则直接返回
                if (scheduler == null)
                {
                    ISchedulerFactory schedf = new StdSchedulerFactory();
                    TaskScheduler = schedf.GetScheduler();
                }
                else
                {
                    return scheduler;
                }
            }
            return await TaskScheduler;
        }

        public TaskDeadLineEndJob()
        {
            try
            {
                Task.Run(async () =>
                {
                    // 开启调度器
                    scheduler = await GetSchedulerAsync();
                    await scheduler.Start();
                });
            }
            catch (Exception)
            {
                throw;
            }
        }
    }