免费开源的DotNet任务调度组件Quartz.NET（.NET组件介绍之五）

最新推荐文章于 2024-09-26 07:03:43 发布
最新推荐文章于 2024-09-26 07:03:43 发布
阅读量169 收藏
点赞数
文章标签： 数据库 网络 json
原文链接：http://www.cnblogs.com/pengze0902/p/6128558.html
版权

    很多的软件项目中都会使用到定时任务、定时轮询数据库同步，定时邮件通知等功能。.NET Framework具有“内置”定时器功能，通过System.Timers.Timer类。在使用Timer类需要面对的问题：计时器没有持久化机制；计时器具有不灵活的计划（仅能设置开始时间和重复间隔，没有基于日期，时间等）；计时器不使用线程池（每个定时器一个线程）；计时器没有真正的管理方案 - 你必须编写自己的机制，以便能够记住，组织和检索任务的名称等。

    如果需要在.NET实现定时器的功能，可以尝试使用以下这款开源免费的组件Quartz.Net组件。目前Quartz.NET版本为3.0，修改了原来的一些问题：修复由于线程本地存储而不能与AdoJobStore协同工作的调度器信令；线程局部状态完全删除；quartz.serializer.type是必需的，即使非序列化RAMJobStore正在使用；JSON序列化错误地称为序列化回调。

一.Quart.NET概述：  

     Quartz是一个作业调度系统，可以与任何其他软件系统集成或一起使用。作业调度程序是一个系统，负责在执行预处理程序时执行（或通知）其他软件组件 - 确定（调度）时间到达。Quartz是非常灵活的，并且包含多个使用范例，可以单独使用或一起使用，以实现您所需的行为，并使您能够以您的项目看起来最“自然”的方式编写代码。组件的使用非常轻便，并且需要非常少的设置/配置 - 如果您的需求相对基础，它实际上可以使用“开箱即用”。Quartz是容错的，并且可以在系统重新启动之间保留（记住）您的预定作业。尽管Quartz对于在给定的时间表上简单地运行某些系统进程非常有用，但当您学习如何使用Quartz来驱动应用程序的业务流程时，Quartz的全部潜能可以实现。

      Quartz是作为一个小的动态链接库（.dll文件）分发的，它包含所有的核心Quartz功能。 此功能的主要接口（API）是调度程序接口。 它提供简单的操作，如调度/非调度作业，启动/停止/暂停调度程序。如果你想安排你自己的软件组件执行，他们必须实现简单的Job接口，它包含方法execute（）。 如果希望在计划的触发时间到达时通知组件，则组件应实现TriggerListener或JobListener接口。主要的Quartz'进程'可以在您自己的应用程序或独立应用程序（使用远程接口）中启动和运行。

二.Quartz.NET主体类和方法解析：

    1.StdSchedulerFactory类：创建QuartzScheduler实例。
        /// <summary>
        /// 返回此工厂生成的调度程序的句柄。
        /// </summary>
        /// <remarks>
        ///如果<see cref =“Initialize（）”/>方法之一没有先前调用，然后是默认（no-arg）<see cref =“Initialize（）”/>方法将被这个方法调用。
        /// </remarks>
        public virtual IScheduler GetScheduler()
        {
            if (cfg == null)
            {
                Initialize();
            }

            SchedulerRepository schedRep = SchedulerRepository.Instance;

            IScheduler sched = schedRep.Lookup(SchedulerName);

            if (sched != null)
            {
                if (sched.IsShutdown)
                {
                    schedRep.Remove(SchedulerName);
                }
                else
                {
                    return sched;
                }
            }

            sched = Instantiate();

            return sched;
        }
public interface ISchedulerFactory
    {
        /// <summary>
        /// Returns handles to all known Schedulers (made by any SchedulerFactory
        /// within this app domain.).
        /// </summary>
        ICollection<IScheduler> AllSchedulers { get; }

        /// <summary>
        /// Returns a client-usable handle to a <see cref="IScheduler" />.
        /// </summary>
        IScheduler GetScheduler();

        /// <summary>
        /// Returns a handle to the Scheduler with the given name, if it exists.
        /// </summary>
        IScheduler GetScheduler(string schedName);
    }
   2.JobDetailImpl：传递给定作业实例的详细信息属性。
 /// <summary>
        /// 获取或设置与<see cref =“IJob”/>相关联的<see cref =“JobDataMap”/>。
        /// </summary>
        public virtual JobDataMap JobDataMap
        {
            get
            {
                if (jobDataMap == null)
                {
                    jobDataMap = new JobDataMap();
                }
                return jobDataMap;
            }

            set { jobDataMap = value; }
        }
   3.JobKey：键由名称和组组成，名称必须是唯一的，在组内。 如果只指定一个组，则默认组将使用名称。
 [Serializable]
    public sealed class JobKey : Key<JobKey>
    {
        public JobKey(string name) : base(name, null)
        {
        }

        public JobKey(string name, string group) : base(name, group)
        {
        }

        public static JobKey Create(string name)
        {
            return new JobKey(name, null);
        }

        public static JobKey Create(string name, string group)
        {
            return new JobKey(name, group);
        }
    }
   4.StdSchedulerFactory.Initialize():
        /// <summary> 
        /// 使用初始化<see cref =“ISchedulerFactory”/>
         ///给定键值集合对象的内容。
        /// </summary>
        public virtual void Initialize(NameValueCollection props)
        {
            cfg = new PropertiesParser(props);
            ValidateConfiguration();
        }

        protected virtual void ValidateConfiguration()
        {
            if (!cfg.GetBooleanProperty(PropertyCheckConfiguration, true))
            {
                // should not validate
                return;
            }

            // determine currently supported configuration keys via reflection
            List<string> supportedKeys = new List<string>();
            List<FieldInfo> fields = new List<FieldInfo>(GetType().GetFields(BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy));
            // choose constant string fields
            fields = fields.FindAll(field => field.FieldType == typeof (string));

            // read value from each field
            foreach (FieldInfo field in fields)
            {
                string value = (string) field.GetValue(null);
                if (value != null && value.StartsWith(ConfigurationKeyPrefix) && value != ConfigurationKeyPrefix)
                {
                    supportedKeys.Add(value);
                }
            }

            // now check against allowed
            foreach (string configurationKey in cfg.UnderlyingProperties.AllKeys)
            {
                if (!configurationKey.StartsWith(ConfigurationKeyPrefix) || configurationKey.StartsWith(ConfigurationKeyPrefixServer))
                {
                    // don't bother if truly unknown property
                    continue;
                }

                bool isMatch = false;
                foreach (string supportedKey in supportedKeys)
                {
                    if (configurationKey.StartsWith(supportedKey, StringComparison.InvariantCulture))
                    {
                        isMatch = true;
                        break;
                    }
                }
                if (!isMatch)
                {
                    throw new SchedulerConfigException("Unknown configuration property '" + configurationKey + "'");
                }
            }

        }

 

三.Quartz.NET的基本应用：

    下面提供一些较为通用的任务处理代码：

  1.任务处理帮助类：
    /// <summary>
    /// 任务处理帮助类
    /// </summary>
    public class QuartzHelper
    {
        public QuartzHelper() { }

        public QuartzHelper(string quartzServer, string quartzPort)
        {
            Server = quartzServer;
            Port = quartzPort;
        }

        /// <summary>
        /// 锁对象
        /// </summary>
        private static readonly object Obj = new object();

        /// <summary>
        /// 方案
        /// </summary>
        private const string Scheme = "tcp";

        /// <summary>
        /// 服务器的地址
        /// </summary>
        public static  string Server { get; set; }

        /// <summary>
        /// 服务器的端口
        /// </summary>
        public static  string Port { get; set; }

        /// <summary>
        /// 缓存任务所在程序集信息
        /// </summary>
        private static readonly Dictionary<string, Assembly> AssemblyDict = new Dictionary<string, Assembly>();

        /// <summary>
        /// 程序调度
        /// </summary>
        private static IScheduler _scheduler;

        /// <summary>
        /// 初始化任务调度对象
        /// </summary>
        public static void InitScheduler()
        {
            try
            {
                lock (Obj)
                {
                    if (_scheduler != null) return;
                    //配置文件的方式，配置quartz实例
                    ISchedulerFactory schedulerFactory = new StdSchedulerFactory();
                    _scheduler = schedulerFactory.GetScheduler();
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }

        /// <summary>
        /// 启用任务调度
        /// 启动调度时会把任务表中状态为“执行中”的任务加入到任务调度队列中
        /// </summary>
        public static void StartScheduler()
        {
            try
            {
                if (_scheduler.IsStarted) return;
                //添加全局监听
                _scheduler.ListenerManager.AddTriggerListener(new CustomTriggerListener(), GroupMatcher<TriggerKey>.AnyGroup());
                _scheduler.Start();

                //获取所有执行中的任务
                List<TaskModel> listTask = TaskHelper.GetAllTaskList().ToList();

                if (listTask.Count > 0)
                {
                    foreach (TaskModel taskUtil in listTask)
                    {
                        try
                        {
                            ScheduleJob(taskUtil);
                        }
                        catch (Exception e)
                        {
                          throw new Exception(taskUtil.TaskName,e);
                        }
                    }
                }              
            }
            catch (Exception ex)
            {
               throw new Exception(ex.Message);
            }
        }

        /// <summary>
        /// 启用任务
        /// <param name="task">任务信息</param>
        /// <param name="isDeleteOldTask">是否删除原有任务</param>
        /// <returns>返回任务trigger</returns>
        /// </summary>
        public static void ScheduleJob(TaskModel task, bool isDeleteOldTask = false)
        {
            if (isDeleteOldTask)
            {
                //先删除现有已存在任务
                DeleteJob(task.TaskID.ToString());
            }
            //验证是否正确的Cron表达式
            if (ValidExpression(task.CronExpressionString))
            {
                IJobDetail job = new JobDetailImpl(task.TaskID.ToString(), GetClassInfo(task.AssemblyName, task.ClassName));
                //添加任务执行参数
                job.JobDataMap.Add("TaskParam", task.TaskParam);

                CronTriggerImpl trigger = new CronTriggerImpl
                {
                    CronExpressionString = task.CronExpressionString,
                    Name = task.TaskID.ToString(),
                    Description = task.TaskName
                };
                _scheduler.ScheduleJob(job, trigger);
                if (task.Status == TaskStatus.STOP)
                {
                    JobKey jk = new JobKey(task.TaskID.ToString());
                    _scheduler.PauseJob(jk);
                }
                else
                {
                    List<DateTime> list = GetNextFireTime(task.CronExpressionString, 5);
                    foreach (var time in list)
                    {
                        LogHelper.WriteLog(time.ToString(CultureInfo.InvariantCulture));
                    }
                }
            }
            else
            {
                throw new Exception(task.CronExpressionString + "不是正确的Cron表达式,无法启动该任务!");
            }
        }


        /// <summary>
        /// 初始化 远程Quartz服务器中的，各个Scheduler实例。
        /// 提供给远程管理端的后台，用户获取Scheduler实例的信息。
        /// </summary>
        public static void InitRemoteScheduler()
        {
            try
            {
                NameValueCollection properties = new NameValueCollection
                {
                    ["quartz.scheduler.instanceName"] = "ExampleQuartzScheduler",
                    ["quartz.scheduler.proxy"] = "true",
                    ["quartz.scheduler.proxy.address"] =string.Format("{0}://{1}:{2}/QuartzScheduler", Scheme, Server, Port)
                };

                ISchedulerFactory sf = new StdSchedulerFactory(properties);

                _scheduler = sf.GetScheduler();
            }
            catch (Exception ex)
            {
               throw new Exception(ex.StackTrace);
            }
        }

        /// <summary>
        /// 删除现有任务
        /// </summary>
        /// <param name="jobKey"></param>
        public static void DeleteJob(string jobKey)
        {
            try
            {
                JobKey jk = new JobKey(jobKey);
                if (_scheduler.CheckExists(jk))
                {
                    //任务已经存在则删除
                    _scheduler.DeleteJob(jk);
                   
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }

      

        /// <summary>
        /// 暂停任务
        /// </summary>
        /// <param name="jobKey"></param>
        public static void PauseJob(string jobKey)
        {
            try
            {
                JobKey jk = new JobKey(jobKey);
                if (_scheduler.CheckExists(jk))
                {
                    //任务已经存在则暂停任务
                    _scheduler.PauseJob(jk);
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }

        /// <summary>
        /// 恢复运行暂停的任务
        /// </summary>
        /// <param name="jobKey">任务key</param>
        public static void ResumeJob(string jobKey)
        {
            try
            {
                JobKey jk = new JobKey(jobKey);
                if (_scheduler.CheckExists(jk))
                {
                    //任务已经存在则暂停任务
                    _scheduler.ResumeJob(jk);
                }
            }
            catch (Exception ex)
            {
              throw new Exception(ex.Message);
            }
        }

        /// <summary> 
        /// 获取类的属性、方法  
        /// </summary>  
        /// <param name="assemblyName">程序集</param>  
        /// <param name="className">类名</param>  
        private static Type GetClassInfo(string assemblyName, string className)
        {
            try
            {
                assemblyName = FileHelper.GetAbsolutePath(assemblyName + ".dll");
                Assembly assembly = null;
                if (!AssemblyDict.TryGetValue(assemblyName, out assembly))
                {
                    assembly = Assembly.LoadFrom(assemblyName);
                    AssemblyDict[assemblyName] = assembly;
                }
                Type type = assembly.GetType(className, true, true);
                return type;
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }

        /// <summary>
        /// 停止任务调度
        /// </summary>
        public static void StopSchedule()
        {
            try
            {
                //判断调度是否已经关闭
                if (!_scheduler.IsShutdown)
                {
                    //等待任务运行完成
                    _scheduler.Shutdown(true);
                }
            }
            catch (Exception ex)
            {
               throw new Exception(ex.Message);
            }
        }

        /// <summary>
        /// 校验字符串是否为正确的Cron表达式
        /// </summary>
        /// <param name="cronExpression">带校验表达式</param>
        /// <returns></returns>
        public static bool ValidExpression(string cronExpression)
        {
            return CronExpression.IsValidExpression(cronExpression);
        }

        /// <summary>
        /// 获取任务在未来周期内哪些时间会运行
        /// </summary>
        /// <param name="CronExpressionString">Cron表达式</param>
        /// <param name="numTimes">运行次数</param>
        /// <returns>运行时间段</returns>
        public static List<DateTime> GetNextFireTime(string CronExpressionString, int numTimes)
        {
            if (numTimes < 0)
            {
                throw new Exception("参数numTimes值大于等于0");
            }
            //时间表达式
            ITrigger trigger = TriggerBuilder.Create().WithCronSchedule(CronExpressionString).Build();
            IList<DateTimeOffset> dates = TriggerUtils.ComputeFireTimes(trigger as IOperableTrigger, null, numTimes);
            List<DateTime> list = new List<DateTime>();
            foreach (DateTimeOffset dtf in dates)
            {
                list.Add(TimeZoneInfo.ConvertTimeFromUtc(dtf.DateTime, TimeZoneInfo.Local));
            }
            return list;
        }


        public static object CurrentTaskList()
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// 获取当前执行的Task 对象
        /// </summary>
        /// <param name="context"></param>
        /// <returns></returns>
        public static TaskModel GetTaskDetail(IJobExecutionContext context)
        {
            TaskModel task = new TaskModel();

            if (context != null)
            {

                task.TaskID = Guid.Parse(context.Trigger.Key.Name);
                task.TaskName = context.Trigger.Description;
                task.RecentRunTime = DateTime.Now;
                task.TaskParam = context.JobDetail.JobDataMap.Get("TaskParam") != null ? context.JobDetail.JobDataMap.Get("TaskParam").ToString() : "";
            }
            return task;
        }
    }
    2.设置执行中的任务：
public class TaskBll
    {
        private readonly TaskDAL _dal = new TaskDAL();

        /// <summary>
        /// 获取任务列表
        /// </summary>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <returns></returns>
        public PageOf<TaskModel> GetTaskList(int pageIndex, int pageSize)
        {
            return _dal.GetTaskList(pageIndex, pageSize);
        }

        /// <summary>
        /// 读取数据库中全部的任务
        /// </summary>
        /// <returns></returns>
        public List<TaskModel> GetAllTaskList()
        {
            return _dal.GetAllTaskList();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="taskId"></param>
        /// <returns></returns>
        public TaskModel GetById(string taskId)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// 删除任务
        /// </summary>
        /// <param name="taskId"></param>
        /// <returns></returns>
        public bool DeleteById(string taskId)
        {
            return _dal.UpdateTaskStatus(taskId, -1);
        }

        /// <summary>
        /// 修改任务
        /// </summary>
        /// <param name="taskId"></param>
        /// <param name="status"></param>
        /// <returns></returns>
        public bool UpdateTaskStatus(string taskId, int status)
        {
            return _dal.UpdateTaskStatus(taskId, status);
        }

        /// <summary>
        /// 修改任务的下次启动时间
        /// </summary>
        /// <param name="taskId"></param>
        /// <param name="nextFireTime"></param>
        /// <returns></returns>
        public bool UpdateNextFireTime(string taskId, DateTime nextFireTime)
        {
            return _dal.UpdateNextFireTime(taskId, nextFireTime);
        }

        /// <summary>
        /// 根据任务Id 修改 上次运行时间
        /// </summary>
        /// <param name="taskId"></param>
        /// <param name="recentRunTime"></param>
        /// <returns></returns>
        public bool UpdateRecentRunTime(string taskId, DateTime recentRunTime)
        {
            return _dal.UpdateRecentRunTime(taskId, recentRunTime);
        }

        /// <summary>
        /// 根据任务Id 获取任务
        /// </summary>
        /// <param name="taskId"></param>
        /// <returns></returns>
        public TaskModel GetTaskById(string taskId)
        {
            return _dal.GetTaskById(taskId);
        }

        /// <summary>
        /// 添加任务
        /// </summary>
        /// <param name="task"></param>
        /// <returns></returns>
        public bool Add(TaskModel task)
        {
            return _dal.Add(task);
        }

        /// <summary>
        /// 修改任务
        /// </summary>
        /// <param name="task"></param>
        /// <returns></returns>
        public bool Edit(TaskModel task)
        {
            return _dal.Edit(task);
        }
    }
   3.任务实体：
    /// <summary>
    /// 任务实体
    /// </summary>
    public class TaskModel
    {
        /// <summary>
        /// 任务ID
        /// </summary>
        public Guid TaskID { get; set; }

        /// <summary>
        /// 任务名称
        /// </summary>
        public string TaskName { get; set; }

        /// <summary>
        /// 任务执行参数
        /// </summary>
        public string TaskParam { get; set; }

        /// <summary>
        /// 运行频率设置
        /// </summary>
        public string CronExpressionString { get; set; }

        /// <summary>
        /// 任务运频率中文说明
        /// </summary>
        public string CronRemark { get; set; }

        /// <summary>
        /// 任务所在DLL对应的程序集名称
        /// </summary>
        public string AssemblyName { get; set; }

        /// <summary>
        /// 任务所在类
        /// </summary>
        public string ClassName { get; set; }

        public TaskStatus Status { get; set; }

        /// <summary>
        /// 任务创建时间
        /// </summary>
        public DateTime? CreatedTime { get; set; }

        /// <summary>
        /// 任务修改时间
        /// </summary>
        public DateTime? ModifyTime { get; set; }

        /// <summary>
        /// 任务最近运行时间
        /// </summary>
        public DateTime? RecentRunTime { get; set; }

        /// <summary>
        /// 任务下次运行时间
        /// </summary>
        public DateTime? NextFireTime { get; set; }

        /// <summary>
        /// 任务备注
        /// </summary>
        public string Remark { get; set; }

        /// <summary>
        /// 是否删除
        /// </summary>
        public int IsDelete { get; set; }
    }
  4.配置文件：
# You can configure your scheduler in either <quartz> configuration section
# or in quartz properties file
# Configuration section has precedence

quartz.scheduler.instanceName = ExampleQuartzScheduler

# configure thread pool info
quartz.threadPool.type = Quartz.Simpl.SimpleThreadPool, Quartz
quartz.threadPool.threadCount = 10
quartz.threadPool.threadPriority = Normal

# job initialization plugin handles our xml reading, without it defaults are used
# quartz.plugin.xml.type = Quartz.Plugin.Xml.XMLSchedulingDataProcessorPlugin, Quartz
# quartz.plugin.xml.fileNames = ~/quartz_jobs.xml

# export this server to remoting context
quartz.scheduler.exporter.type = Quartz.Simpl.RemotingSchedulerExporter, Quartz
quartz.scheduler.exporter.port = 555
quartz.scheduler.exporter.bindName = QuartzScheduler
quartz.scheduler.exporter.channelType = tcp
quartz.scheduler.exporter.channelName = httpQuartz

四.总结：

     在项目中比较多的使用到定时任务的功能，今天的介绍的组件可以很好的完成一些定时任务的要求。这篇文章主要是作为引子，简单的介绍了组件的背景和组件的使用方式，如果项目中需要使用，可以进行更加深入的了解。

 

.NET组件介绍系列：

    一款开源免费的.NET文档操作组件DocX（.NET组件介绍之一）http://www.cnblogs.com/pengze0902/p/6122311.html

    高效而稳定的企业级.NET Office 组件Spire（.NET组件介绍之二）http://www.cnblogs.com/pengze0902/p/6125570.html

    最好的.NET开源免费ZIP库DotNetZip（.NET组件介绍之三）http://www.cnblogs.com/pengze0902/p/6124659.html

    免费开源的DotNet二维码操作组件ThoughtWorks.QRCode（.NET组件介绍之四）http://www.cnblogs.com/pengze0902/p/6134506.html

    免费开源的DotNet任务调度组件Quartz.NET（.NET组件介绍之五）http://www.cnblogs.com/pengze0902/p/6128558.html

    免费高效实用的Excel操作组件NPOI（.NET组件介绍之六）http://www.cnblogs.com/pengze0902/p/6150070.html

转载于:https://www.cnblogs.com/pengze0902/p/6128558.html

dfkqtok82472315
关注
Quartz.NET开源库实现作业定时调度——简单示例
CoffeMilk的博客
06-29 958
一、Quartz.NET简介 1.1、.NET Framework自带的Timer定时器介绍 很多的软件项目中都会使用到定时任务、定时轮询数据库同步，定时邮件通知等功能。.NET Framework具有“内置”定时器功能，通过System.Timers.Timer类实现。 自带定时器的缺点： ①在使用Timer类需要面对的问题：计时器没有持久化机制； ②计时器具有不灵活的计划（仅能设置开始时间和重复间隔，没有基于日期，时间等）； ③计时器不使用线程池（每个定时器一个线程）；计时器没有真正..
quartznet任务调度和消息调度
06-28
quartznet任务调度和消息调度 定时或定期执行任务的一套框架。 1）分任务，调度器，触发器。 2）任务，触发器是多对多关系。 3）可以保存任务到数据库。
Quartz.NET——作业调度组件
冷月宫主的专栏
01-05 899
之前有个旧同事说他在项目中碰到某些功能需要使用到作业调度，于是找到了这个组件，据说相当好用，叫我有时间的话去了解一下。哈，于是小了解了一下，基本的使用算是明白了，深层次的东西就不了解了，本文简单记录一下最基本的使用！     关于Quartz.NET，请访问它的网站：http://quartznet.sourceforge.net     下载Quartz.NET，请直接进这里：http:
开源的作业调度框架 - Quartz.NET
weixin_34247155的博客
08-25 111
Quartz.NET是一个开源的作业调度框架，是OpenSymphony 的 Quartz API的.NET移植，它用C#写成，可用于winform和asp.net应用中。它提供了巨大的灵活性而不牺牲简单性。你能够用它来为执行一个作业而创建简单的或复杂的调度。它有很多特征，如：数据库支持，集群，插件，支持cron-like表达式等等。 你曾经需要应用执行一个任务...
定时处理组件---Quartz.net
weixin_30725467的博客
11-03 143
1.认识任务调度 所谓任务调度，就是以将业务区块任务化（即抽象成每一个独立的任务，执行每个任务便完成某种业务的需求）。比如，我们有一个订单系统，现在有这样的一个需求，就是需要在某一时间点去扫描数据库，删掉垃圾订单。又比如，我们想要在某一时刻去批量给用户推送信息，等等等等。如何去解决那？？我们首先想到的是利用定时器或者是开线程独立扫描。这可以说是解决方案，但是如果是自己去实现，难免考虑的...
详解免费开源的DotNet任务调度组件Quartz.NET（.NET组件介绍之五）
01-20
Quartz.NET是一个强大的任务调度框架，专为.NET环境设计，旨在替代系统内建的定时器功能，解决诸如持久化、灵活计划和线程管理等问题。Quartz.NET允许开发者定义作业（Jobs）和触发器（Triggers），以实现复杂的定时...
Calamus.TaskScheduler:基于Asp.Net Core 5.0采用Quartz.Net编写的开源任务调度Web管理平台
03-22
基于Asp.Net Core 5.0采用Quartz.Net编写的开源任务调度Web管理平台 部署步骤 1，创建持久化数据库（以MySQL为例） -创建数据库石英，Charset为utf8mb4 -根据数据库/表/表_mysql_innodb.sql语句创建表结构 2，启动...
Quartz.Net 组件在DotNetCore平台的封装使用-详细步骤Quartz.AspNetCore
iTheoChan的博客
01-12 890
Quartz.Net 组件在DotNetCore平台的封装使用-详细步骤Quartz.AspNetCore 本文介绍了`Quartz.Net`组件在`DotNetCore`平台封装使用的详细步骤。 把`Quartz.AspNetCore`封装到了单独DotNetCore项目中，与其他业务代码解耦。并实现了作业调度计划的配置化，和服务运行中实时监控配置文件功能。可以在运行中动态禁用/启用作业，添加新的作业，修改现有作业的调度计划(cron表达式)。 附示例源码
QuartzNetJob 开源项目教程
最新发布
gitblog_00002的博客
09-26 603
QuartzNetJob 开源项目教程 QuartzNetJob Asp.Net Core 2.0 后端任务管理 项目地址: https://gitcode.com/gh_mirrors/qu/QuartzNetJob ...
.net 简单任务调度平台
07-28
.net 简单任务调度平台，用于.net dll,exe的任务的挂载，任务的隔离，调度执行，访问权限控制，监控，管理，日志，错误预警，性能分析等。 1) 平台基于quartz.net进行任务调度功能开发，采用C#代码编写, 支持corn表达式和第三方自定义的corn表达式扩展。 2) 架构以插件形式开发，具有良好的功能扩展性，稳定性，简单性，便于第三方开发人员进一步进行功能扩展。 3) 支持多节点集群，便于集群服务器的资源有效分配，任务的相互隔离。 4) 支持邮件形式的错误预警，便于运维及时处理任务异常等。 开源项目地址: http://git.oschina.net/chejiangyi/Dyd.BaseService.TaskManager/
Quartz相关插件
07-24
经过测试能够使用，可以用作Job测试。dll好用dll好用dll好用dll好用
dotnet-基于QuartzNET30的web管理界面
08-15
基于Quartz.NET 3.0的web管理界面。docker打包开箱即用、内置SQLite持久化、语言无关、业务代码零污染、支持 RESTful风格接口、傻瓜式配置
详解.NET Core使用Quartz执行调度任务进阶
01-02
一、前言运用场景  Quartz.Net是一个强大、开源、轻量的作业调度框架,在平时的项目开发当中也会时不时的需要运用到定时调度方面的功能，例如每日凌晨需要统计前一天的数据，又或者每月初需要统计上月的数据。当然也会出现既要统计日的也统计月的还需要进行其他的操作。那我们改如何来写这样的调度任务呢？ 二、实际运用(.Net Core 2.2) 在一个解决方案中创建一个.Net控制台应用程序及一个类库，控制台应用程序用来作为程序的启动点。类库用来作为调度任务的执行程序。 然后我们需要完善一下项目的结构，首先我们得在控制台应用程序中创建一个Startup类，这个类也是任务启动的一个重要条件。 pu
.NET中使用Quartz
weixin_50478033的博客
09-21 1401
.NET中使用Quartz
DotNetCore跨平台~Quartz热部署的福音～监控文件夹的变化
weixin_34015860的博客
08-31 172
回到目录 在DotNetCore出来之后，同时也使用了quartz进行调度中心的设计，将它做到docker里方便部署，在之前的quartz版本里支持配置文件的方式，而现在不支持了，我们应该去想一下，为什么不去支持配置文件？当然大叔也为配置文件设计了支持的方式，但我们还是应该想想作者为什么不去支持配置？ 热插拔，服务发现？ 和上面两个概念可能有点关系，热插拔很容易理解，就是把dll模块放到正在...
DotNetCore跨平台~Quartz定时单次任务
weixin_34015860的博客
09-15 145
回到目录 之前写过一篇文件《DotNetCore跨平台~Quartz热部署的福音～监控文件夹的变化》，今天主要把框架优化了一下，支持外部触发，并支持外部将参数以JobDataMap形式进行输入，然后在咱们的Job里进行使用它，故称参数化任务。 Quartz使用场景： 定时单次任务：在未来某个时间去执行一次 定点任务　　：在某个时间去执行，可以是轮询的 周期任务　　：按某个时间间隔去轮...
.NET 轻量级、高效任务调度器ScheduleTask 从零打造
dotNET跨平台
07-05 153
任务调度是业务系统中的基础功能，用于执行定时任务。虽然市面上存在许多成熟的任务调度库，如 Quartz 和 Hangfire，但本文将引导读者从零开始创建一个简易的任务调度器。我们将使用 `BackgroundService` 和 `NCrontab` 库来实现一个轻量级、高效的任务调度器，适用于分钟级别的任务调度。引言任务调度器对于业务系统至关重要，用于执行定时任务。在本文中，我们将不依赖任何第...
ThoughtWorks.QRCode组件详解：免费开源的DotNet二维码生成与解码
ThoughtWorks.QRCode 是一个专为 .NET 平台设计的免费开源二维码操作组件，它提供了 QR 码的编码和解码功能。该组件源于日本 Denso-Wave 公司在1994年创建的二维码标准，旨在提高数据读取速度和效率，现在广泛应用在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值