定时任务 Wpf.Quartz.Demo.4

最新推荐文章于 2024-05-23 13:34:30 发布
最新推荐文章于 2024-05-23 13:34:30 发布
阅读量446 收藏 2
点赞数
原文链接：http://www.cnblogs.com/akwkevin/p/10424081.html
版权

本文继续介绍定时任务 Wpf.Quartz.Demo.3的一些小细节， 代码也请前往第3节下载。

1.RichTextBox右键菜单

 <RichTextBox.ContextMenu>
                <ContextMenu>
                    <MenuItem Header="剪贴" Command="ApplicationCommands.Cut"/>                     
                    <MenuItem Header="复制" Command="ApplicationCommands.Copy"/>                                         
                    <MenuItem Header="粘贴" Command="ApplicationCommands.Paste"/>                                          
                    <MenuItem Header="清除" Click="MenuItemClear_Click"/>   
                    <MenuItem x:Name="menuPause" Header="暂停" Click="MenuItemPause_Click"/>   
                </ContextMenu>
            </RichTextBox.ContextMenu>

其中上面上个是系统默认的，自己要添加，可以自己定义。

2.右键DataGrid,选中该行。

 <i:Interaction.Triggers>
                <i:EventTrigger EventName="PreviewMouseRightButtonDown">
                    <local:ExInvokeCommandAction Command="{Binding PreviewMouseRightComamnd}" CommandParameter="{Binding SelectedItem, ElementName=table}"/>
                </i:EventTrigger>
            </i:Interaction.Triggers>

private void PreviewMouseRight(object para)
        {
            RoutedEventArgs e = ((ExCommandParameter)para).EventArgs as RoutedEventArgs;
            var treeViewItem = VisualUpwardSearch<UIElement>(e.OriginalSource as DependencyObject) as UIElement;

            if (treeViewItem == null) return;
            treeViewItem.Focus();
            e.Handled = true;
        }

        private static DependencyObject VisualUpwardSearch<M>(DependencyObject source)
        {
            while (source != null && source.GetType() != typeof(M))
            {
                if (source is Visual || source is Visual3D)
                    source = VisualTreeHelper.GetParent(source);
                else
                    source = LogicalTreeHelper.GetParent(source);
            }
            return source;
        }

3.任务的基本接口，主要是系统的启动，停止等命令

public interface IRun:IBaseRunner
    {
        [Newtonsoft.Json.JsonIgnore()]
        Action<string, LogLevel> LogOut { get; set; }

        Task Start();

        Task Stop();

        Task ReStart();

        Task Resume();

        Task Pause();

        Task RunNowOneTime();
    }
IRun

4.任务的设置的接口，主要是任务的配置保存。

 public interface IBaseRunner
    {
        string Name { get; }
        string DisplayName { get; set; }
        string Remark { get; set; }
        string CronExpression { get; set; }
        TriggerState TriggerState { get; set; }
        string SettingStr { get; set; }
        DateTime? NextRunTime { get; }
        DateTime[] NextRunTimes { get; set; }
        DateTime? StartTime { get; set; }
        DateTime? EndTime { get; set; }
        bool IsEdit { get; set; }
        CronSecondSet CronSecondSet { get; set; }
        CronMinuteSet CronMinuteSet { get; set; }
        CronHourSet CronHourSet { get; set; }
        CronDaySet CronDaySet { get; set; }
        CronMonthSet CronMonthSet { get; set; }
        CronWeekSet CronWeekSet { get; set; }
        CronYearSet CronYearSet { get; set; }
        EasyCronSet EasyCronSet { get; set; }
        Mode Mode { get; set; }
        void Info(string message);
        void DEBUG(string message);
        void ERROR(string message);
        void FATAL(string message);
        void WARN(string message);

    }
IBaseRunner

5.任务类，接口IRun的实现。

using Quartz;
using Quartz.Impl;
using Quartz.Spi;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Wpf.Quartz.Converters;

namespace Wpf.Quartz
{
    public class SimpleRunner<T> : BaseRunner,IRun where T : IJob
    {
        public SimpleRunner()
        {
            base.Name = this.Name;
        }

        private static readonly log4net.ILog log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
        public new string Name
        {
            //get { return GetType().Name; }
            get { return typeof(T).Name; }
        }


        private readonly SemaphoreSlim locker = new SemaphoreSlim(1);

        public virtual async Task Start()
        {
            if (StatusEnableConverter.IsEanbleState(TriggerState, "Start") == false)
            {
                return;
            }
            await locker.WaitAsync();
            try
            {

                if (string.IsNullOrEmpty(CronExpression))//如果为空，则设置为立刻执行一次
                {
                    CronExpression = CronHelper.DateTime2Cron(DateTime.Now.AddSeconds(3));
                }
                Info((DisplayName ?? Name) + "开始启动！");
                TriggerState= await QuartzHelper.Instance.StartJobExecuteByCron<T>(CronExpression, Name, this, this.StartTime, this.EndTime);
                Info((DisplayName ?? Name) + "启动完毕！");

                NextRunTimes = QuartzHelper.Instance.GetNextRunTime(CronExpression, StartTime, EndTime, 5);
                IsEdit = false;
            }
            catch (Exception ex)
            {
                log.Fatal(ex);
                Info((DisplayName ?? Name) + "启动失败！" + ex.Message);
            }
            finally
            {
                TriggerState = await QuartzHelper.Instance.GetJobState(Name);
                locker.Release();
            }
        }

        public virtual async Task ReStart()
        {
            if (StatusEnableConverter.IsEanbleState(TriggerState, "ReStart") == false)
            {
                return;
            }
            await locker.WaitAsync();
            try
            {
                if (string.IsNullOrEmpty(CronExpression))//如果为空，则设置为立刻执行一次
                {
                    CronExpression = CronHelper.DateTime2Cron(DateTime.Now.AddSeconds(3));
                }
                Info(DisplayName??Name + "开始重新启动！");
                TriggerState = await QuartzHelper.Instance.RemoveJob(Name);
                TriggerState = await QuartzHelper.Instance.StartJobExecuteByCron<T>(CronExpression, Name, this, this.StartTime, this.EndTime);
                Info((DisplayName ?? Name) + "重新启动完毕！");

                NextRunTimes = QuartzHelper.Instance.GetNextRunTime(CronExpression, StartTime, EndTime, 5);
                IsEdit = false;
            }
            catch (Exception ex)
            {
                log.Fatal(ex);
                Info((DisplayName ?? Name) + "重新启动失败！" + ex.Message);
            }
            finally
            {
                TriggerState = await QuartzHelper.Instance.GetJobState(Name);
                locker.Release();
            }
        }

        public virtual async Task Pause()
        {
            if (StatusEnableConverter.IsEanbleState(TriggerState, "Pause") == false)
            {
                return;
            }
            try
            {
                Info((DisplayName ?? Name) + "开始暂停！");
                TriggerState = await QuartzHelper.Instance.PauseJob(Name);
                Info((DisplayName ?? Name) + "暂停完毕！");
            }
            catch (Exception ex)
            {
                log.Fatal(ex);
                Info((DisplayName ?? Name) + "暂停失败！" + ex.Message);
            }
        }

        public virtual async Task Resume()
        {
            if (StatusEnableConverter.IsEanbleState(TriggerState, "Resume") == false)
            {
                return;
            }
            try
            {
                Info((DisplayName ?? Name) + "开始恢复！");
                TriggerState = await QuartzHelper.Instance.ResumeJob(Name);
                Info((DisplayName ?? Name) + "恢复完毕！");
            }
            catch (Exception ex)
            {
                log.Fatal(ex);
                Info((DisplayName ?? Name) + "恢复失败！" + ex.Message);
            }
        }

        public virtual async Task Stop()
        {
            if (StatusEnableConverter.IsEanbleState(TriggerState, "Stop") == false)
            {
                return;
            }
            try
            {
                Info((DisplayName ?? Name) + "开始停止！");
                TriggerState = await QuartzHelper.Instance.RemoveJob(Name);
                Info((DisplayName ?? Name) + "停止完毕！");               
            }
            catch (Exception ex)
            {
                log.Fatal(ex);
                Info((DisplayName ?? Name) + "停止失败！" + ex.Message);
            }
        }

        public virtual async Task RunNowOneTime()
        {
            if (StatusEnableConverter.IsEanbleState(TriggerState, "Run") == false)
            {
                return;
            }
            if (locker.CurrentCount == 0)
            {
                Info((DisplayName ?? Name) + "正在执行，请稍后再执行！");
                return;
            }
            await locker.WaitAsync();
            try
            {
                Info((DisplayName ?? Name) + "开始执行一次！");
                ISchedulerFactory sf = new StdSchedulerFactory();
                IScheduler scheduler = await sf.GetScheduler();
                await scheduler.Start();

                IJobDetail job = await scheduler.GetJobDetail(new JobKey(Name, "group1"));
                if (job == null)
                {
                    job = JobBuilder.Create<HelloJob>()
                   .WithIdentity(Name, "group1")
                   .Build();
                }

                ITrigger trigger = await scheduler.GetTrigger(new TriggerKey(Name, "group1"));
                if (trigger == null)
                {
                    trigger = TriggerBuilder.Create()
                       .WithIdentity(Name, "group1")
                       .StartNow()
                       .WithSimpleSchedule(x => x
                       .WithIntervalInSeconds(1))
                       .Build();
                }
              
                await scheduler.ScheduleJob(job, trigger);

                Info((DisplayName ?? Name) + string.Format("执行一次完毕"));

                
                //await Task.Delay(TimeSpan.FromSeconds(5));

                //await scheduler.Shutdown();              

                //SchedulerMetaData metaData = await scheduler.GetMetaData();
                //Info(string.Format("执行完毕{0}个任务.", metaData.NumberOfJobsExecuted));

            }
            catch (Exception ex)
            {
                log.Fatal(ex);
                Info((DisplayName ?? Name) + string.Format("执行一次失败") + ex.Message);
            }
            finally
            {
                locker.Release();
            }
        }
    }
}
SimpleRunner

6.BaseRunner，主要是设置Cron

using Quartz;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Wpf.Quartz.Models;

namespace Wpf.Quartz
{
    public class BaseRunner: BaseLog, INotifyPropertyChanged
    {
        public string Name { get; set;}

        private string displayName;
        public string DisplayName
        {
            get { return displayName; }
            set
            {
                if (displayName != value)
                {
                    displayName = value;
                    OnPropertyChanged("DisplayName");
                }
            }
        }

        private string remark;
        public string Remark
        {
            get { return remark; }
            set
            {
                if (remark != value)
                {
                    remark = value;
                    OnPropertyChanged("Remark");
                }
            }
        }

        private string cronExpression;
        public string CronExpression
        {
            get { return cronExpression; }
            set
            {
                if (cronExpression != value)
                {
                    cronExpression = value;
                    OnPropertyChanged("CronExpression");
                }
            }
        }

        private TriggerState triggerState = TriggerState.None;
        public TriggerState TriggerState
        {
            get { return triggerState; }
            set
            {
                if (triggerState != value)
                {
                    triggerState = value;
                    OnPropertyChanged("TriggerState");
                }
            }
        }

        private string settingStr = "手动执行";
        public string SettingStr
        {
            get { return settingStr; }
            set
            {
                if (settingStr != value)
                {
                    settingStr = value;
                    OnPropertyChanged("SettingStr");
                }
            }
        }

        public DateTime? NextRunTime
        {
            get
            {
                if (NextRunTimes != null && NextRunTimes.Length > 0)
                {
                    return NextRunTimes[0];                  
                }
                else
                {
                    return null;
                }
            }
           
        }

        private DateTime[] nextRunTimes;
        public DateTime[] NextRunTimes
        {
            get { return nextRunTimes; }
            set
            {
                if (nextRunTimes != value)
                {
                    nextRunTimes = value;
                    OnPropertyChanged("NextRunTimes");
                    OnPropertyChanged("NextRunTime");
                }
            }
        }

        private DateTime? startTime;
        public DateTime? StartTime
        {
            get { return startTime; }
            set
            {
                if (startTime != value)
                {
                    startTime = value;
                    OnPropertyChanged("StartTime");
                }
            }
        }

        private DateTime? endTime;
        public DateTime? EndTime
        {
            get { return endTime; }
            set
            {
                if (endTime != value)
                {
                    endTime = value;
                    OnPropertyChanged("EndTime");
                }
            }
        }

        private bool isEdit;
        public bool IsEdit
        {
            get { return isEdit; }
            set
            {
                if (isEdit != value)
                {
                    isEdit = value;
                    OnPropertyChanged("IsEdit");
                }
            }
        }

        public CronSecondSet CronSecondSet { get; set; } = new CronSecondSet();
        public CronMinuteSet CronMinuteSet { get; set; } = new CronMinuteSet();
        public CronHourSet CronHourSet { get; set; } = new CronHourSet();
        public CronDaySet CronDaySet { get; set; } = new CronDaySet();
        public CronMonthSet CronMonthSet { get; set; } = new CronMonthSet();
        public CronWeekSet CronWeekSet { get; set; } = new CronWeekSet();
        public CronYearSet CronYearSet { get; set; } = new CronYearSet();
        public EasyCronSet EasyCronSet { get; set; } = new EasyCronSet();

        private Mode mode;
        public Mode Mode
        {
            get { return mode; }
            set
            {
                if (mode != value)
                {
                    mode = value;
                    OnPropertyChanged("Mode");
                    CronSecondSet.UpdateExpression();
                }
            }
        }

        private SetMode setMode = SetMode.Easy;
        public SetMode SetMode
        {
            get { return setMode; }
            set
            {
                if (setMode != value)
                {
                    setMode = value;
                    OnPropertyChanged("SetMode");
                    CronSecondSet.UpdateExpression();
                }
            }
        }

        public event PropertyChangedEventHandler PropertyChanged;
        public void OnPropertyChanged(string propertyName)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
            }
        }

    }

    public class BaseLog
    {
        #region 日志输出
        [Newtonsoft.Json.JsonIgnore()]
        public Action<string, LogLevel> LogOut { get; set; }

        public void Info(string message)
        {
            if (LogOut != null)
            {
                App.Current.Dispatcher.Invoke((Action)delegate ()
                {
                    LogOut(message, LogLevel.INFO);
                });
            }
        }

        public void DEBUG(string message)
        {
            if (LogOut != null)
            {
                App.Current.Dispatcher.Invoke((Action)delegate ()
                {
                    LogOut(message, LogLevel.DEBUG);
                });
            }
        }

        public void ERROR(string message)
        {
            if (LogOut != null)
            {
                App.Current.Dispatcher.Invoke((Action)delegate ()
                {
                    LogOut(message, LogLevel.ERROR);
                });
            }
        }

        public void FATAL(string message)
        {
            if (LogOut != null)
            {
                App.Current.Dispatcher.Invoke((Action)delegate ()
                {
                    LogOut(message, LogLevel.FATAL);
                });
            }
        }

        public void WARN(string message)
        {
            if (LogOut != null)
            {
                App.Current.Dispatcher.Invoke((Action)delegate ()
                {
                    LogOut(message, LogLevel.WARN);
                });
            }
        }
        #endregion
    }
}
BaseRunner

具体的请自行查看对应的类。

        public CronSecondSet CronSecondSet { get; set; } = new CronSecondSet();
        public CronMinuteSet CronMinuteSet { get; set; } = new CronMinuteSet();
        public CronHourSet CronHourSet { get; set; } = new CronHourSet();
        public CronDaySet CronDaySet { get; set; } = new CronDaySet();
        public CronMonthSet CronMonthSet { get; set; } = new CronMonthSet();
        public CronWeekSet CronWeekSet { get; set; } = new CronWeekSet();
        public CronYearSet CronYearSet { get; set; } = new CronYearSet();


        public EasyCronSet EasyCronSet { get; set; } = new EasyCronSet();

 

主要代码就是用户自定义设置，大家运行程序看效果。

另外，这种设置太专业了，不适合用户使用，因此设计了用户常用的模式。

是不是简单友好多了。

至此完结。

 

下次打算写一个wcf的Demo，当自己学习的动力。

 

转载于:https://www.cnblogs.com/akwkevin/p/10424081.html

Just do it
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
定时任务 Wpf.Quartz.Demo.5 (升级版）
weixin_30454481的博客
03-19 240
老规矩：先把全部源码上传，见本文底部。 相对于Demo3的区别，就是能自动加载继承了IJob的任务，任务主体程序分离。 在exe执行文件的同级下建一个MyJobs的文件夹，每次会自动扫描该文件夹下的Job，添加到系统中来。 举例如下：现在有两个在系统中的任务。 复制一个编译好的Job dll文件放在MyJobs 按下工具菜单栏中的扫描，会有一个新增的任务出现。（是不影响其它正在...
WPF-23 基于Timer任务调度
dotNET跨平台
12-30 178
.NET的FCL中提供了几个计时器，大多数初学者都不清楚他们有什么不同，那我们这节来剖解一下每个计时器的本质：1.System.Threading.Timer如果在一个线程池上执行一个定时的周期性的后台线程任务他是最好的选择，这个类是和线程池相关联的，它告诉线程池(ThreadPool)在指定的时间执行指定的方法2.System.Timers.Timer这个类是对System.Threading....
WPF--几种常用定时器Timer汇总
最新发布
Blue
05-23 1737
WPF--几种常用定时器Timer汇总
C#WPF 启动后到某个时间点定时任务
qq_14971901的博客
01-30 2201
private static string updateTime = ConfigurationManager.AppSettings[“updateTime”];//每天定时启动更新时间 public MainWindow() { try { TimeSpan dtNow = DateTime.Now.TimeOfDay; DateTime start = Con...
C# Timer使用（WPF、Winform）
YouyoMei的博客
12-14 2399
概述 C#中的框架中，为我们提供了几种定时器，其实是3类。下面就通过自己的学习和应用简单介绍下： 首先，定时器的原理：等待一段时间之后，开始执行任务；到了等待时间后，开始执行任务……一直循环。 System.Threading.Timer 简介 这个定时器是一个单独的线程，执行任务（定时器回调任务）的线程分配由线程池管理。如果要使用定时器，他是最好的选择。优点：独立线程，等待周期变化稳定，不会受其...
定时任务 Wpf.Quartz.Demo.3
weixin_30590285的博客
02-23 131
先把全部源码上传，只是一个Demo，希望大家指点一下不足之处，见本文底部。 1.设置界面 2.详情页面 好了，现在慢慢叙述里面的一些方法。 3.实现拷贝的方法： (1) public static void LeftCopyRight(object left, object right) { var Properties = left.Get...
WPF Extended.Wpf.Toolkit 加载界面 Demo
04-16
**WPF Extended.Wpf.Toolkit加载界面Demo** WPF（Windows Presentation Foundation）是.NET框架的一部分，用于构建具有丰富图形、多媒体和数据绑定功能的桌面应用程序。在开发WPF应用时，我们常常需要为用户提供一...
WPF_MahApps.Metro界面主题使用demo
09-08
在Windows Presentation Foundation (WPF)开发中，创建美观、现代的用户界面是一项重要任务。MahApps.Metro是一个流行的开源库，它为WPF应用提供了Material Design和Metro风格的主题，使得开发者可以轻松地构建具有...
ChartsDemo.Wpf.zip
09-17
《ChartsDemo.Wpf.zip——构建高效直观的WPF图表应用》 在软件开发中，数据可视化扮演着至关重要的角色，它能将复杂的数据转化为易于理解的图形，帮助用户快速掌握信息。本文将深入探讨"ChartsDemo.Wpf.zip"这个...
WPF.HtmlEditor富文本编辑器Demo
01-02
**WPF.HtmlEditor富文本编辑器Demo**是一个用于Windows Presentation Foundation (WPF)应用程序的示例项目，它展示了如何在WPF环境中实现一个功能丰富的HTML编辑器。这个编辑器允许用户进行基本的文本编辑，查看HTML...
xceed.wpf.toolkit库
05-12
4. **国际化的项目**：支持多语言的特性使得Xceed.WPF.Toolkit适合全球化项目。 ### 结论 Xceed.WPF.Toolkit是一个高效、功能丰富的库，能够显著提高WPF开发效率，为开发者提供了一套完整的解决方案，以创建出具有...
cron表达式(quartz中时间表达式)
03-20
一个demo 博文链接：https://sosuny.iteye.com/blog/462742
C#WPF自动关机程序
12-10
C#写的WPF界面的自动关机程序，。使用方法：将debug文件夹的exe文件加入到Windows的计划任务中，让程序定时启动即可。可以再扩展为开机自启动，然后隐藏到后台运行，定时关机。有时间我再修改。
C#定时检测是否当前程序是否有人操作（WPF实现）
02-28
C#定时检测是否当前程序是否有人操作（WPF实现），winform中也一样，其中的核心类可通用。
C#定时调用的Quartz项目设计和实现
weixin_30752377的博客
10-07 242
1.首先必须清楚一些概念:调度器,作业,定时触发器,如下 2.关于一个Quartz定时调用的项目的设计和实现 　　把需要的东西抽象出来,比如把作业的一些属性,如作业的名称等,如下 1 public int id { get; set; } 2 /// 任务名称 3 public string jobname { get; set; } 4 5 /// job配...
好玩的WPF第二弹：电子表字体显示时间+多彩呼吸灯特效按钮
weixin_34110749的博客
06-11 274
我们先来看看Quartz MS字体动态显示系统时间的效果，难度相较于上一篇也要简单许多。 首先是定义一个TextBlock如下。 <Grid> <TextBlock Name="tBlockTime" HorizontalAlignment="Center" VerticalAlignment="Center" Fon...
quartz定时器依赖_定时任务schedule(quartz)
weixin_39808143的博客
12-22 1318
1, 简介Quartz是一个任务调度框架。核心类：Scheduler ：调度器，所有Job的调度都是由它控制;JobDetail ：生成Job对象的实例，存储Job对象需要的参数;Job ：执行业务逻辑;Trigger ：定义触发的条件;帮助类SimpleScheduleBuilder：用于构建Scheduler：JobBuilder ：用于...
WPF-定时器
u014683488的专栏
03-12 1510
wpf中有四种定时器 1.System.Threading.Timer 1 private System.Threading.Timer timerClose; 2 timerClose = new System.Threading.Timer(new TimerCallback(timerCall), this, 5000, 0); 3 private void timerCall(Ob...
Java定时 spring Schedule cron表达式
qq_42222736的博客
03-31 768
定时任务实现方式 Java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务。 最早的时候就是这样写定时任务的。 开源的第三方框架： Quartz 或者 elastic-job ， 但是这个比较复杂和重量级，适用于分布式场景下的定时任务，可以根据需要多实例部署定时任务。 使用Spring提供的注解： @Schedule 。 如果定时任务执行时间...
actipro.wpf.studio.v11.2
10-13
Actipro.WPF.Studio是一个用于开发Windows Presentation Foundation（WPF）应用程序的工具包。它提供了丰富的界面控件和功能，可以帮助开发人员快速构建功能强大的用户界面。 Actipro.WPF.Studio v11.2是版本号为...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值