Quartz Net.Core 3.0 实现方便的定时任务 简约版框架 方便调用

Quartz  这个任务调度，挺不错的，就是，创建任务的时候，每次都得定义一个Ijob 类，来执行，比较麻烦。我这边通过一个简单的封装实现对任务的轻松调用和实现。

下载地址 : https://download.csdn.net/download/kesshei/12231473

 

        static void Main(string[] args)
        {
            TaskProcess taskProcess = new TaskProcess("0/5 * * * * ?", "Print");
            taskProcess.Start();
            TaskProcess bb = new TaskProcess("0/5 * * * * ?", typeof(Print2));
            bb.Start();
            TaskProcess bbb = new TaskProcess("0/5 * * * * ?", typeof(Print2));
            bbb.Start();
            Console.ReadLine();
        }

两个参数，一个是Cron表达式，一个是继承了 ITask的接口类的类名或者类型。

下边是一个标准的Quartz 任务

    /// 

    /// 任务
    /// 
    public class TaskJob : IJob
    {
        public Task Execute(IJobExecutionContext context)
        {
            string type = string.Empty;
            JobDataMap data = context.JobDetail.JobDataMap;
            if (data.ContainsKey("Type"))
            {
                type = data["Type"].ToString();
            }
            return Task.Factory.StartNew(() =>
            {
                TypeFactory.Make(type)?.Run();
            });
        }
    }

任务处理器

    public class TaskProcess
    {
        /// 

        /// 任务调度器(单例)
        /// 
        static IScheduler scheduler = null;
        /// 

        /// 对象锁
        /// 
        static object LockObj = new object();
        /// 

        ///  内置唯一Key
        /// 
        string JobKey = Guid.NewGuid().ToString("N");
        /// 

        /// 内置唯一Key
        /// 
        string TriggerKey = Guid.NewGuid().ToString("N");
        /// 

        /// cron表达式
        /// 
        public string cron { get; set; }
        /// 

        /// 对象类型
        /// 
        public string TypeName { get; set; }

        /// 

        /// 获取调度器
        /// 
        /// 
        IScheduler GetScheduler()
        {
            if (scheduler == null)
            {
                lock (LockObj)
                {
                    if (scheduler == null)
                    {
                        StdSchedulerFactory factory = new StdSchedulerFactory();
                        scheduler = factory.GetScheduler().GetAwaiter().GetResult();
                        scheduler.Start();
                    }
                }
            }
            return scheduler;
        }
        public TaskProcess(string Cron, Type type)
        {
            this.cron = Cron;
            this.TypeName = type.Name;
        }
        public TaskProcess(string Cron, string TypeName)
        {
            this.cron = Cron;
            this.TypeName = TypeName;
        }
        public void Start()
        {
            AddJob(cron, TypeName).GetAwaiter().GetResult();
            Console.WriteLine($"{TypeName} 任务启动!");
        }
        /// 

        /// 增加任务
        /// 
        /// 
        public async Task AddJob(string cron, string typeName)
        {
            var IScheduler = GetScheduler();
            IJobDetail jobDetail = JobBuilder.Create()
            .WithIdentity(JobKey)
            .Build();
            jobDetail.JobDataMap.Put("Type", typeName);

            ITrigger trigger = TriggerBuilder.Create()
            .WithIdentity(TriggerKey)
            .WithCronSchedule(cron)
            .ForJob(jobDetail)
            .Build();

            await IScheduler.ScheduleJob(jobDetail, trigger);
        }
        /// 

        /// 关闭任务
        /// 
        public void Close()
        {
            var IScheduler = GetScheduler();
            TriggerKey triggerKey = new TriggerKey(TriggerKey);
            IScheduler.PauseTrigger(triggerKey);
            var unschedule = IScheduler.UnscheduleJob(triggerKey).GetAwaiter().GetResult();
            var result = IScheduler.DeleteJob(new JobKey(JobKey)).GetAwaiter().GetResult();
            if (unschedule || result)
            {
                Console.WriteLine("任务关闭成功!");
            }
            else
            {
                Console.WriteLine("任务关闭失败!");
            }
        }
    }

以及，重要的类型工厂

    /// 

    /// 类型工厂
    /// 
    public static class TypeFactory
    {
        static TypeFactory()
        {
            CollectAllEntityClasses();
        }
        /// 

        /// 类型字典
        /// 
        static Dictionary Types = new Dictionary();
        /// 

        /// 收集当前所有实例类名字 
        /// 
        public static void CollectAllEntityClasses()
        {
            var AS = AppDomain.CurrentDomain.GetAssemblies().ToList();

            foreach (var item in AS)
            {
                var types = item.GetTypes().ToList();
                foreach (var type in types)
                {
                    string className = type.Name;
                    if (typeof(ITask).IsAssignableFrom(type))
                    {
                        Types.Add(className, type);
                    }
                }
            }
        }
        /// 

        ///类型工厂
        /// 
        /// 
        public static ITask Make(Type Type)
        {
            Type t;
            if (Types.TryGetValue(Type.Name, out t))
            {
                return (ITask)Activator.CreateInstance(t);
            }
            return null;
        }
        /// 

        ///类型工厂
        /// 
        /// 
        public static ITask Make(string Name)
        {
            Type t;
            if (Types.TryGetValue(Name, out t))
            {
                return (ITask)Activator.CreateInstance(t);
            }
            return null;
        }
        /// 

        /// 增加一个类型
        /// 
        /// 
        /// 
        public static void AddType(Type type)
        {
            if (!Types.ContainsKey(type.Name))
            {
                Types.Add(type.Name, type);
            }
        }
    }

加上实际继承的接口类

    public interface ITask
    {
        void Run();
    }

以及任意一个 实现的类

    class Print2 : ITask
    {
        public void Run()
        {
            Console.WriteLine(DateTime.Now.ToString()  + " Print2");
        }
    }

查看具体的结果:

运行效果，符合预期，使用简单方便。