SGGL_HBAZ/SGGL/BLL/TaskScheduling/TimerTask/TimerTaskBase.cs


 using System;
 using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.Drawing.Printing;
using System.Linq;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
 using Quartz;
 using Quartz.Impl;

 namespace BLL
 {
    public class QuartzServices
    {

        public static async Task Init()
        {
          

            //初始化计划者
            StdSchedulerFactory factory = new StdSchedulerFactory();
           // StdSchedulerFactory factory = new StdSchedulerFactory(properties);
            IScheduler scheduler = await factory.GetScheduler();
            var jobAndTriggerMapping = new Dictionary<IJobDetail, IReadOnlyCollection<ITrigger>>(); 
            // 将映射关系包装成制度字典集合  
            var model = new Model.InterFaceTask();
            model.Enable = true;
            var list = InterFaceTaskService.GetInterFaceTaskByModle(model);
            foreach (var item in list)
            {

                var jobDetail1 = GetJobDetailByInterFaceTaskId(item.InterFaceTaskId);
                var trigger1 = GetTriggerByTime(item.InterFaceTaskId, item.Frequency);
                //给计划者添加Job和触发器
                jobAndTriggerMapping[jobDetail1] = trigger1;
                //keyValuePairs.Add(item.InterFaceTaskId, scheduler);
                //Funs.ScheduledTasks = keyValuePairs;
            }
            var readOnlyjobAndTriggerMapping = new ReadOnlyDictionary<IJobDetail, IReadOnlyCollection<ITrigger>>(jobAndTriggerMapping);
            await scheduler.ScheduleJobs(readOnlyjobAndTriggerMapping, true);
            await scheduler.Start(); //只有启动了，里面的任务才会定时触发
            Funs.ScheduledTasks = scheduler;

        }
 
        public static void ISchedulerShupDown(IScheduler scheduler)
        {
            scheduler.Shutdown();

        }
        /// <summary>
        /// 同步任务调度
        /// </summary>
        /// <param name="InterFaceTaskId"></param>
        /// <returns></returns>
        public static async Task SyncISchedulerById(string InterFaceTaskId)
        {
            try
            {
                StdSchedulerFactory factory = new StdSchedulerFactory();
                var model = InterFaceTaskService.GetInterFaceTaskById(InterFaceTaskId);
                // var item = Funs.ScheduledTasks.Where(x => x.Key == InterFaceTaskId).FirstOrDefault();
                IScheduler scheduler = Funs.ScheduledTasks;
                JobKey jk = new JobKey(InterFaceTaskId, "group1");
                if (model != null)
                {
                    if (model.Enable == true)
                    {
                        if (scheduler.GetJobDetail(jk, default) != null)
                        {
                            var jobDetail1 = GetJobDetailByInterFaceTaskId(model.InterFaceTaskId);
                            var trigger1 = GetTriggerByTime(model.InterFaceTaskId, model.Frequency);
                            await scheduler.ScheduleJob(jobDetail1, trigger1,true);

                        }
                        else
                        {
                           
                            var jobDetail1 = GetJobDetailByInterFaceTaskId(model.InterFaceTaskId);
                            var trigger1 = GetTriggerByTime(model.InterFaceTaskId, model.Frequency);
                            await scheduler.ScheduleJob(jobDetail1, trigger1,true);
                        }

                    }
                    else
                    {
                        if (scheduler.GetJobDetail(jk, default) != null)
                        {
                            await scheduler.DeleteJob(jk, default);
                          

                          //  SyncScheduledTasks(model.InterFaceTaskId, scheduler, 2);
                        }

                    }

                }
                Funs.ScheduledTasks = scheduler;

            }
            catch (Exception ex)
            {
                string a = ex.ToString();
                throw;
            }

        }
        /// <summary>
        /// 同步任务列表
        /// </summary>
        /// <param name="InterFaceTaskId"></param>
        /// <param name="scheduler"></param>
        /// <param name="type">0 增 1 修改 2删除</param>
        public static void SyncScheduledTasks(string InterFaceTaskId, IScheduler scheduler, int type)
        {
            if (type == 0)
            {
              //  Funs.ScheduledTasks.Add(InterFaceTaskId, scheduler);
            }
            else if (type == 1)
            {
             //   Funs.ScheduledTasks.Remove(InterFaceTaskId);
               // Funs.ScheduledTasks.Add(InterFaceTaskId, scheduler);
            }
            else if (type == 2)
            {
               // Funs.ScheduledTasks.Remove(InterFaceTaskId);
            }
        }
        public static IJobDetail GetJobDetailByInterFaceTaskId(string InterFaceTaskId)
        { //创建Job
            IJobDetail jobDetail1 = JobBuilder.Create<MyJob>()
                 .WithIdentity(InterFaceTaskId, "group1")//给Job身份
                 .WithDescription("任务的描述，方便查找")
                 .UsingJobData("InterFaceTaskId", InterFaceTaskId)
                 .Build();
            return jobDetail1;
        }
        public static ReadOnlyCollection<ITrigger> GetTriggerByTime(string InterFaceTaskId, string time)
        {
            string cron = "0 0 0/& * * ? ";
            cron = cron.Replace("&", time);
          //  cron = "0 0/1 * * * ? ";
            //创建触发器
            var trigger1 = new ReadOnlyCollection<ITrigger>(
                new List<ITrigger>()
            {
                TriggerBuilder.Create()
                .WithIdentity(InterFaceTaskId, "group1") //给触发器身份
                .WithDescription("触发器的描述，方便查找")
                .StartAt(new DateTimeOffset(DateTime.Now.AddSeconds(10))) //.StartNow()都是启动触发器方式
                .WithCronSchedule(cron) //定时策略，Cron表达式
                .Build()
        });
            return trigger1;

        }
    }
 }