public async Task Execute(IJobExecutionContext context)
{
var executeTime = DateTime.Now;
ConsoleExtend.WriteLineDebug($"【{executeTime}】 开始执行作业 作业【{context.JobDetail.Key}】 触发器【{context.Trigger.Key}】");
try
{
for (int i = 0; i < 5; i++)
{
LockAction(() => ExecutedCount++);
await Task.Delay(TimeSpan.FromSeconds(10));
if (context.CancellationToken.IsCancellationRequested)
{
ConsoleExtend.WriteLineDebug1($"【{DateTime.Now}】 作业被打断 作业【{context.JobDetail.Key}】 触发器【{context.Trigger.Key}】 触发时间【{executeTime}】");
// 也可以抛出JobExecutionException异常
LockAction(() => InterruptlCount++);
}
else
{
LockAction(() => SuccessfulCount++);
}
}
}
finally
{
ConsoleExtend.WriteLineDebug2($"【{DateTime.Now}】 作业执行完成 作业【{context.JobDetail.Key}】 触发器【{context.Trigger.Key}】 触发时间【{executeTime}】");
}
}
public Task SchedulerStarting(CancellationToken cancellationToken = default(CancellationToken))
{
return(new TaskFactory().StartNew(() =>
{
ConsoleExtend.WriteLine(ConsoleColor.Cyan, "调度监听 调度器开启中");
}));
}
public Task Execute(IJobExecutionContext context)
{
IJobDetail jobDetail = context.JobDetail;
JobDataMap jobDataMap = jobDetail.JobDataMap;
JobDataMap dataMap = context.MergedJobDataMap; // 触发器中的惨覆盖作业中的参数
string color = dataMap.GetString(ColorKey);
int colorCount = dataMap.GetIntValue(ColorCountKey);
ConsoleExtend.WriteLineNextDebug($"【{DateTime.Now}】作业【{jobDetail.Key}】 描述【{jobDetail.Description}】" +
$"触发器【{context.Trigger.Key}】 " +
$"MergedJobDataMap中喜欢颜色【{color}】 jobDataMap中喜欢颜色【{jobDataMap.GetString(ColorKey)}】 " +
$"作业MergedJobDataMap中计数【{colorCount}】 jobDataMap中计数【{jobDataMap.GetIntValue(ColorCountKey)}】 作业成员属性计数【{Count}】" +
$"触发器jobDataMap中计数【{context.Trigger.JobDataMap.GetIntValue(ColorCountKey)}】 ");
colorCount++;
context.Trigger.JobDataMap.Put(ColorCountKey, colorCount);
//dataMap.Put(ColorCountKey, colorCount);
jobDataMap.Put(ColorCountKey, jobDataMap.GetIntValue(ColorCountKey) + 1);
Count++;
return(Task.FromResult(true));
}
public async Task Execute(IJobExecutionContext context)
{
JobDataMap map = context.JobDetail.JobDataMap;
int executeCount = 0;
if (map.ContainsKey(NumExecutions))
{
executeCount = map.GetInt(NumExecutions);
}
executeCount++;
map.Put(NumExecutions, executeCount);
int delay = 5;
if (map.ContainsKey(ExecutionDelay))
{
delay = map.GetInt(ExecutionDelay);
}
ConsoleExtend.WriteLineDebug1($"【{DateTime.Now}】 开始执行 触发器【{context.Trigger.Key}】 作业【{context.JobDetail.Key}】 执行次数【{executeCount}】");
await Task.Delay(TimeSpan.FromSeconds(delay));
ConsoleExtend.WriteLineDebug2($"【{DateTime.Now}】 执行完成 触发器【{context.Trigger.Key}】 作业【{context.JobDetail.Key}】 执行次数【{executeCount}】");
}
public Task SchedulingDataCleared(CancellationToken cancellationToken = default(CancellationToken))
{
return(new TaskFactory().StartNew(() =>
{
ConsoleExtend.WriteLine(ConsoleColor.Cyan, "调度监听 调度数据清除");
}));
}
public Task JobToBeExecuted(IJobExecutionContext context, CancellationToken cancellationToken = default(CancellationToken))
{
return(new TaskFactory().StartNew(() =>
{
ConsoleExtend.WriteLineYellow(@"监听器名称【{0}】作业【{1}=》{2}】作业将被执行 作业描述【{3}】
作业参数【{4}】 作业类型【{5}】 作业实体【{6}】 触发器【{7}=》{8}】 恢复触发器【{9}=》{10}】
触发器参数【{11}】 合并参数【{12}】 调度触发时间【{18}】 作业触发时间【{13}】 触发实体ID【{14}】
作业运行时间【{15}】 下次执行时间【{16}】 之前触发时间【{17}】"
, Name
, context.JobDetail.Key.Group
, context.JobDetail.Key.Name
, context.JobDetail.Description
, Newtonsoft.Json.JsonConvert.SerializeObject(context.JobDetail.JobDataMap)
, context.JobDetail.JobType.FullName
, context.JobInstance.GetType().FullName
, context.Trigger.Key.Group
, context.Trigger.Key.Name
, context.Recovering ? context.RecoveringTriggerKey.Group : String.Empty
, context.Recovering ? context.RecoveringTriggerKey.Name : String.Empty
, Newtonsoft.Json.JsonConvert.SerializeObject(context.Trigger.JobDataMap)
, Newtonsoft.Json.JsonConvert.SerializeObject(context.MergedJobDataMap)
, context.FireTimeUtc.LocalDateTime
, context.FireInstanceId
, /*new DateTime(context.JobRunTime.Ticks)*/ TimeSpan.FromTicks(context.JobRunTime.Ticks).Seconds + "s"
, context.NextFireTimeUtc.HasValue ? context.NextFireTimeUtc.Value.LocalDateTime.ToString() : String.Empty
, context.PreviousFireTimeUtc.HasValue ? context.PreviousFireTimeUtc.Value.LocalDateTime.ToString() : String.Empty
, context.ScheduledFireTimeUtc.HasValue ? context.ScheduledFireTimeUtc.Value.LocalDateTime.ToString() : String.Empty);
}));
}
public Task JobsResumed(string jobGroup, CancellationToken cancellationToken = default(CancellationToken))
{
return(new TaskFactory().StartNew(() =>
{
ConsoleExtend.WriteLine(ConsoleColor.Cyan, "调度监听 Jobs恢复作业【{0}】 ",
jobGroup
);
}));
}
public Task TriggersResumed(string triggerGroup, CancellationToken cancellationToken = default(CancellationToken))
{
return(new TaskFactory().StartNew(() =>
{
ConsoleExtend.WriteLine(ConsoleColor.Cyan, @"调度监听 Triggers触发恢复 触发器【{0}】 ",
triggerGroup
);
}));
}
public Task JobResumed(JobKey jobKey, CancellationToken cancellationToken = default(CancellationToken))
{
return(new TaskFactory().StartNew(() =>
{
ConsoleExtend.WriteLine(ConsoleColor.Cyan, "调度监听 作业恢复【{0}=》{1}】 ",
jobKey.Group
, jobKey.Name
);
}));
}
public Task TriggerResumed(TriggerKey triggerKey, CancellationToken cancellationToken = default(CancellationToken))
{
return(new TaskFactory().StartNew(() =>
{
ConsoleExtend.WriteLine(ConsoleColor.Cyan, @"调度监听 触发恢复 触发器【{0}=》{1}】 ",
triggerKey.Group
, triggerKey.Name
);
}));
}
public Task JobUnscheduled(TriggerKey triggerKey, CancellationToken cancellationToken = default(CancellationToken))
{
return(new TaskFactory().StartNew(() =>
{
ConsoleExtend.WriteLine(ConsoleColor.Cyan, "调度监听 未调度的作业 触发器【{0}=》{1}】 ",
triggerKey.Group
, triggerKey.Name
);
}));
}
public Task SchedulerError(string msg, SchedulerException cause, CancellationToken cancellationToken = default(CancellationToken))
{
return(new TaskFactory().StartNew(() =>
{
ConsoleExtend.WriteLine(ConsoleColor.Cyan, "调度监听 调度异常 消息【{0}】 调度异常消息【{1}】 异常帮助链接【{2}】 ",
msg
, cause.Message
, cause.HelpLink
);
}));
}
public Task JobAdded(IJobDetail jobDetail, CancellationToken cancellationToken = default(CancellationToken))
{
return(new TaskFactory().StartNew(() =>
{
ConsoleExtend.WriteLine(ConsoleColor.Cyan, "调度监听 添加作业【{0}=》{1}】 类型【{2}】 描述【{3}】 参数【{4}】",
jobDetail.Key.Group
, jobDetail.Key.Name
, jobDetail.JobType.FullName
, jobDetail.Description
, Newtonsoft.Json.JsonConvert.SerializeObject(jobDetail.JobDataMap == null ? new object() : jobDetail.JobDataMap)
);
}));
}
public async Task RunAsync()
{
IScheduler scheduler = await StdSchedulerFactory.GetDefaultScheduler();
#region 添加日历
AnnualCalendar holidays = new AnnualCalendar(); // 创建一个年度假日日历
// 元旦 1月1日
DateTime NewYearDay = new DateTime(DateTime.UtcNow.Year, 1, 1);
holidays.SetDayExcluded(NewYearDay, true); // true 排除元旦执行 false 在元旦执行
// 劳动节 5月1日
DateTime LaborDay = new DateTime(DateTime.UtcNow.Year, 5, 1);
holidays.SetDayExcluded(LaborDay, true); // true 排除元旦执行 false 在元旦执行
// 国庆节 10月1日
DateTime NationalDay = new DateTime(DateTime.UtcNow.Year, 10, 1);
holidays.SetDayExcluded(NationalDay, true); // true 排除元旦执行 false 在元旦执行
await scheduler.AddCalendar("holidays", holidays, true, true);
#endregion
DateTimeOffset runDate = DateBuilder.DateOf(10, 0, 0, 1, 10);
IJobDetail job = JobBuilder.Create <HelloJob2>()
.WithIdentity("job1", "jobGroup1")
.Build();
ISimpleTrigger trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("trigger1", "triggerGroup1")
.StartAt(runDate)
.WithSimpleSchedule(x => x.WithIntervalInHours(2).RepeatForever())
.ModifiedByCalendar("holidays")
.Build();
DateTimeOffset df = await scheduler.ScheduleJob(job, trigger);
ConsoleExtend.WriteLineDebug1($"作业【{job.Key}】 触发器【{trigger.Key}】 将在【{df.LocalDateTime}】执行" +
$"，重复执行时间间隔【{trigger.RepeatInterval.Hours}】小时 重复【{trigger.RepeatCount}】次");
await scheduler.Start();
Console.WriteLine("等待30秒。。。");
await Task.Delay(TimeSpan.FromSeconds(30));
await scheduler.Shutdown(true);
ConsoleExtend.WriteLineDebug2($"共执行了{(await scheduler.GetMetaData()).NumberOfJobsExecuted}个作业");
}
public Task JobScheduled(ITrigger trigger, CancellationToken cancellationToken = default(CancellationToken))
{
return(new TaskFactory().StartNew(() =>
{
ConsoleExtend.WriteLine(ConsoleColor.Cyan, @"调度监听 作业调度 触发器【{0}=》{1}】
触发器描述【{2}】 触发器参数【{3}】 作业【{4}=》{5}】 触发器开始时间【{6}】",
trigger.Key.Group
, trigger.Key.Name
, trigger.Description
, Newtonsoft.Json.JsonConvert.SerializeObject(trigger.JobDataMap)
, trigger.JobKey.Group
, trigger.JobKey.Name
, trigger.StartTimeUtc.LocalDateTime
);
}));
}
public async Task RunAsync()
{
IScheduler scheduler = await StdSchedulerFactory.GetDefaultScheduler();
DateTimeOffset startTime = DateBuilder.NextGivenSecondDate(null, 10);
IJobDetail job = JobBuilder.Create <InterruptJob>()
.WithIdentity("job1", "jobGroup1")
.Build();
ISimpleTrigger trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("trigger1", "triggerGroup1")
.StartAt(startTime)
.WithSimpleSchedule(x => x.WithIntervalInSeconds(3).RepeatForever())
.Build();
DateTimeOffset df = await scheduler.ScheduleJob(job, trigger);
ConsoleExtend.WriteLineRed($"作业【{job.Key}】 触发器【{trigger.Key}】 执行时间【{df.LocalDateTime}】 " +
$"执行时间间隔【{trigger.RepeatInterval.Seconds}】s 重复执行次数【{trigger.RepeatCount}】");
await scheduler.Start();
Console.WriteLine("每7秒中断一次调度");
for (int i = 0; i < 50; i++)
{
await Task.Delay(TimeSpan.FromSeconds(7));
try
{
await scheduler.Interrupt(job.Key);
}
catch (Exception ex)
{
ConsoleExtend.WriteLineError(ex.Message);
}
}
await scheduler.Shutdown(true);
SchedulerMetaData metaData = await scheduler.GetMetaData();
ConsoleExtend.WriteLineDebug2($"执行了 {metaData.NumberOfJobsExecuted} 次作业.");
ConsoleExtend.WriteLineDebug2($"作业【{job.Key}】 中循环共执行了【{InterruptJob.ExecutedCount}】次" +
$"，其中成功【{InterruptJob.SuccessfulCount}】次，中断【{InterruptJob.InterruptlCount}】次");
}
public async Task RunAsync()
{
IScheduler scheduler = await StdSchedulerFactory.GetDefaultScheduler();
IJobDetail job = JobBuilder.Create <SimpleJob1>()
.WithIdentity("job1", "jobGroup1")
.Build();
ISimpleTrigger trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("trigger1", "triggerGroup1")
.StartNow()
.WithSimpleSchedule(x => x.WithIntervalInSeconds(20).RepeatForever())
.Build();
scheduler.ListenerManager.AddJobListener(new JobListener(), KeyMatcher <JobKey> .KeyEquals(job.Key));
DateTimeOffset df = await scheduler.ScheduleJob(job, trigger);
ConsoleExtend.WriteLineRed($"作业【{job.Key}】 触发器【{trigger.Key}】 下次执行时间【{df.LocalDateTime}】 " +
$"执行时间间隔【{trigger.RepeatInterval.Seconds}】s 重复次数【{trigger.RepeatCount}】");
//job = JobBuilder.Create<SimpleJob2>()
// .WithIdentity("job2","jobGroup")
// .Build();
//trigger = (ISimpleTrigger)TriggerBuilder.Create()
// .WithIdentity("trigger2","triggerGroup1")
// .StartNow()
// .WithSimpleSchedule(x=>x.WithIntervalInSeconds(15).RepeatForever())
// .Build();
//df = await scheduler.ScheduleJob(job, trigger);
//ConsoleExtend.WriteLineRed($"作业【{job.Key}】 触发器【{trigger.Key}】 下次执行时间【{df.LocalDateTime}】 " +
// $"执行时间间隔【{trigger.RepeatInterval.Seconds}】s 重复次数【{trigger.RepeatCount}】");
await scheduler.Start();
Console.WriteLine("等待1分钟。。。");
await Task.Delay(TimeSpan.FromMinutes(1));
await scheduler.Shutdown();
}
public Task Execute(IJobExecutionContext context)
{
return(new TaskFactory().StartNew(() =>
{
var jobContext = context as IJobExecutionContext;
var jobKey = jobContext.JobDetail.Key;
//JobDataMap dataMap = jobContext.JobDetail.JobDataMap; //使用作业中的参数
JobDataMap dataMap = jobContext.MergedJobDataMap; // 触发器中的惨覆盖作业中的参数
string dataBaseCon = dataMap.GetString("dataBaseCon");
string JsonParameter = dataMap.GetString("jsonParameter");
ConsoleExtend.WriteLineDebug2($"【{DateTime.Now.ToLongTimeString()}】 作业【{jobKey}】 " +
$"描述【{jobContext.JobDetail.Description}】 数据库配置【{dataBaseCon}】 " +
$"json参数【{JsonParameter}】");
}));
}
public Task Execute(IJobExecutionContext context)
{
try
{
int denominator = context.JobDetail.JobDataMap.GetIntValue(denominatorKey);
ConsoleExtend.WriteLineDebug1($"【{DateTime.Now}】 开始执行作业 作业【{context.JobDetail.Key}】 触发器【{context.Trigger.Key}】 参数【分母：{denominator}】");
var i = 10 / denominator;
}
catch (Exception e)
{
ConsoleExtend.WriteLineError($"{GetType().FullName}作业执行异常：{e.Message}");
context.JobDetail.JobDataMap.Put(denominatorKey, 1);
JobExecutionException e2 = new JobExecutionException();
e2.RefireImmediately = true; // 设置作业马上重新开始
throw e2;
}
ConsoleExtend.WriteLineDebug2($"【{DateTime.Now}】 作业执行完成 作业【{context.JobDetail.Key}】 触发器【{context.Trigger.Key}】");
return(Task.FromResult(true));
}
public Task TriggerMisfired(ITrigger trigger, CancellationToken cancellationToken = default(CancellationToken))
{
return(new TaskFactory().StartNew(() =>
{
ConsoleExtend.WriteLineDebug2(@"监听器名称【{0}】 触发器【{1}=>{2}】触发丢失 触发器描述【{3}】 作业【{4}=》{5}】 触发器参数【{6}】
触发器日历名称【{7}】 最后执行时间【{8}】 下次执行时间【{9}】"
, Name
, trigger.Key.Group
, trigger.Key.Name
, trigger.Description
, trigger.JobKey.Group
, trigger.JobKey.Name
, Newtonsoft.Json.JsonConvert.SerializeObject(trigger.JobDataMap)
, trigger.CalendarName
, trigger.FinalFireTimeUtc.HasValue ? trigger.FinalFireTimeUtc.Value.LocalDateTime.ToString() : String.Empty //最终执行时间
, trigger.GetFireTimeAfter(DateTimeOffset.Now).HasValue
? trigger.GetFireTimeAfter(DateTimeOffset.Now).Value.LocalDateTime.ToString("yyyy-MM-dd HH:mm:ss") : String.Empty //下次执行时间
);
}));
}
public Task Execute(IJobExecutionContext context)
{
ConsoleExtend.WriteLineDebug1($"【{DateTime.Now}】 开始执行作业 作业【{context.JobDetail.Key}】 触发器【{context.Trigger.Key}】");
int denominator = 0;
try
{
var i = 10 / denominator;
}
catch (Exception e)
{
ConsoleExtend.WriteLineError($"{GetType().FullName}作业执行异常：{e.Message}");
denominator = 1;
JobExecutionException e2 = new JobExecutionException();
e2.UnscheduleAllTriggers = true; // Quartz 会自动取消与此工作相关的所有触发器，这样它就不会再次运行了。
throw e2;
}
ConsoleExtend.WriteLineDebug2($"【{DateTime.Now}】 作业执行完成 作业【{context.JobDetail.Key}】 触发器【{context.Trigger.Key}】");
return(Task.FromResult(true));
}
public Task TriggerComplete(ITrigger trigger, IJobExecutionContext context, SchedulerInstruction triggerInstructionCode, CancellationToken cancellationToken = default(CancellationToken))
{
return(new TaskFactory().StartNew(() =>
{
ConsoleExtend.WriteLineDebug(@"监听器名称【{0}】 触发器【{1}=>{2}】触发完成 触发器描述【{3}】 作业【{4}=》{5}】 触发器参数【{6}】
触发器日历名称【{7}】 最后执行时间【{8}】 下次执行时间【{9}】 作业执行时间【{10}】 触发的实际时间【{11}】 context中下次执行时间【{12}】"
, Name
, trigger.Key.Group
, trigger.Key.Name
, trigger.Description
, trigger.JobKey.Group
, trigger.JobKey.Name
, Newtonsoft.Json.JsonConvert.SerializeObject(trigger.JobDataMap)
, trigger.CalendarName
, trigger.FinalFireTimeUtc.HasValue ? trigger.FinalFireTimeUtc.Value.LocalDateTime.ToString() : String.Empty //最终执行时间
, trigger.GetFireTimeAfter(DateTimeOffset.Now).HasValue
? trigger.GetFireTimeAfter(DateTimeOffset.Now).Value.LocalDateTime.ToString("yyyy-MM-dd HH:mm:ss") : String.Empty //下次执行时间
, new DateTime(context.JobRunTime.Ticks) //作业执行时间
, context.FireTimeUtc.LocalDateTime
, context.NextFireTimeUtc.HasValue ? context.NextFireTimeUtc.Value.LocalDateTime.ToString() : String.Empty
);
}));
}
public async Task RunAsync()
{
IScheduler scheduler = await StdSchedulerFactory.GetDefaultScheduler();
DateTimeOffset startTime = DateTimeOffset.Now.AddSeconds(10);
#region 错误作业1 带参数 设置作业失败后马上重新开始
IJobDetail job = JobBuilder.Create <BadJob1>()
.WithIdentity("job1", "jobGroup1")
.UsingJobData(BadJob1.denominatorKey, 0)
.Build();
ISimpleTrigger trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("trigger1", "trrigerGroup1")
.StartAt(startTime)
.WithSimpleSchedule(x => x.WithIntervalInSeconds(10).RepeatForever())
.Build();
DateTimeOffset df = await scheduler.ScheduleJob(job, trigger);
ConsoleExtend.WriteLineRed($"作业【{job.Key}】 触发器【{trigger.Key}】 执行时间【{df.LocalDateTime}】 " +
$"执行时间间隔【{trigger.RepeatInterval.Seconds}】 重复执行次数【{trigger.RepeatCount}】");
#endregion
#region 错误作业2 不带参数 设置作业失败后停止相关触发器执行
job = JobBuilder.Create <BadJob2>()
.WithIdentity("job2", "jobGroup2")
.Build();
trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("trigger2", "triggerGroup1")
.StartAt(startTime)
.WithSimpleSchedule(x => x.WithIntervalInSeconds(10).RepeatForever())
.Build();
df = await scheduler.ScheduleJob(job, trigger);
ConsoleExtend.WriteLineRed($"作业【{job.Key}】 触发器【{trigger.Key}】 执行时间【{df.LocalDateTime}】 " +
$"执行时间间隔【{trigger.RepeatInterval.Seconds}】 重复执行次数【{trigger.RepeatCount}】");
#endregion
#region 给错误作业2添加新的触发器
trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("trigger3", "triggerGroup1")
.StartAt(startTime)
.WithSimpleSchedule(x => x.WithIntervalInSeconds(10).RepeatForever())
.ForJob("job2", "jobGroup2")
.Build();
df = await scheduler.ScheduleJob(trigger);
ConsoleExtend.WriteLineRed($"作业【{trigger.JobKey}】 触发器【{trigger.Key}】 执行时间【{df.LocalDateTime}】 " +
$"执行时间间隔【{trigger.RepeatInterval.Seconds}】 重复执行次数【{trigger.RepeatCount}】");
#endregion
await scheduler.Start();
await Task.Delay(TimeSpan.FromMinutes(1));
await scheduler.Shutdown();
}
public Task TriggerMisfired(ITrigger trigger, CancellationToken cancellationToken = default(CancellationToken))
{
ConsoleExtend.WriteLineRed($"插件【{Name}】 触发器【{trigger.Key}】 触发失败 触发时间【{SystemTime.UtcNow()}】 下次触发时间【{trigger.GetNextFireTimeUtc()}】");
return(Task.FromResult(true));
}
public Task <bool> VetoJobExecution(ITrigger trigger, IJobExecutionContext context, CancellationToken cancellationToken = default(CancellationToken))
{
ConsoleExtend.WriteLineRed($"插件【{Name}】 触发器【{trigger.Key}】 取消作业【{context.JobDetail.Key}】执行:false 触发时间【{SystemTime.UtcNow()}】 下次触发时间【{trigger.GetNextFireTimeUtc()}】");
return(Task.FromResult(false));
}
public Task TriggerFired(ITrigger trigger, IJobExecutionContext context, CancellationToken cancellationToken = default(CancellationToken))
{
ConsoleExtend.WriteLineRed($"插件【{Name}】 触发器【{trigger.Key}】 触发作业【{context.JobDetail.Key}】 触发时间【{SystemTime.UtcNow()}】");
return(Task.FromResult(true));
}
public Task TriggerComplete(ITrigger trigger, IJobExecutionContext context, SchedulerInstruction triggerInstructionCode, CancellationToken cancellationToken = default(CancellationToken))
{
ConsoleExtend.WriteLineRed($"插件【{Name}】 触发器【{trigger.Key}】 触发作业【{context.JobDetail.Key}】完成 触发时间【{SystemTime.UtcNow()}】 下次触发时间【{trigger.GetNextFireTimeUtc()}】");
return(Task.FromResult(true));
}
public async Task RunAsync()
{
IScheduler scheduler = await StdSchedulerFactory.GetDefaultScheduler();
DateTimeOffset startTime = DateTimeOffset.Now.AddSeconds(3);
#region 作业1 每3秒执行一次
IJobDetail job = JobBuilder.Create <LogTimeJob>()
.WithIdentity("job1", "jobGroup1")
.SetJobData(new JobDataMap {
{ LogTimeJob.NumExecutions, 0 },
{ LogTimeJob.ExecutionDelay, 10 }
})
.Build();
ISimpleTrigger trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("trigger1", "triggerGroup1")
.StartAt(startTime)
.WithSimpleSchedule(x => x.WithInterval(TimeSpan.FromSeconds(3)).RepeatForever())
.Build();
DateTimeOffset df = await scheduler.ScheduleJob(job, trigger);
ConsoleExtend.WriteLineRed($"触发器【{trigger.Key}】 作业【{job.Key}】 下次执行时间【{df.LocalDateTime.ToString("r")}】" +
$" 执行时间间隔【{trigger.RepeatInterval.Seconds}】 重复次数【{trigger.RepeatCount}】");
#endregion
#region 作业2 每3秒执行一次
job = JobBuilder.Create <LogTimeJob>()
.WithIdentity("job2", "jobGroup1")
.SetJobData(new JobDataMap {
{ LogTimeJob.NumExecutions, 0 },
{ LogTimeJob.ExecutionDelay, 10 }
})
.Build();
trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("trigger2", "triggerGroup1")
.StartAt(startTime)
.WithSimpleSchedule(x => x.WithInterval(TimeSpan.FromSeconds(3)).RepeatForever().WithMisfireHandlingInstructionNowWithExistingCount())
.Build();
df = await scheduler.ScheduleJob(job, trigger);
ConsoleExtend.WriteLineRed($"触发器【{trigger.Key}】 作业【{job.Key}】 下次执行时间【{df.LocalDateTime.ToString("r")}】" +
$" 执行时间间隔【{trigger.RepeatInterval.Seconds}】 重复次数【{trigger.RepeatCount}】");
#endregion
#region 给作业1 添加一个新的触发器
trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("trigger3", "triggerGroup1")
.StartAt(startTime)
.WithSimpleSchedule(x => x.WithInterval(TimeSpan.FromSeconds(3)).RepeatForever().WithMisfireHandlingInstructionNowWithExistingCount())
.ForJob("job1", "jobGroup1")
.Build();
df = await scheduler.ScheduleJob(trigger);
ConsoleExtend.WriteLineRed($"触发器【{trigger.Key}】 作业【{trigger.JobKey}】 下次执行时间【{df.LocalDateTime.ToString("r")}】" +
$" 执行时间间隔【{trigger.RepeatInterval.Seconds}】 重复次数【{trigger.RepeatCount}】");
#endregion
await scheduler.Start();
await Task.Delay(TimeSpan.FromMinutes(2));
await scheduler.Shutdown();
}
public async Task RunAsync()
{
// 获取默认调度器
IScheduler scheduler = await StdSchedulerFactory.GetDefaultScheduler();
// 获取一个15秒后执行的时间
DateTimeOffset startTime = DateBuilder.NextGivenSecondDate(null, 15);
#region 作业1 15秒后执行，只执行一次
// 创建带参数作业
IJobDetail job = JobBuilder.Create <ParameterJob>()
.WithIdentity("job1", "jobGroup1")
.WithDescription("带参数作业")
.SetJobData(new JobDataMap()
{
{ "dataBaseCon", "数据库配置字符串" },
{ "jsonParameter", "json参数字符串" }
})
.Build();
// 创建一个15秒后执行的触发器,只执行一次
ISimpleTrigger trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("trigger1", "triggerGroup1")
.WithDescription("15秒后执行，只执行一次")
.StartAt(startTime)
.UsingJobData("jsonParameter", "trigger json参数字符串")
.Build();
// 调度作业执行
DateTimeOffset?ft = await scheduler.ScheduleJob(job, trigger);
ConsoleExtend.WriteLineRed($"{job.Key} 将在以下时间运行【{ft.Value.LocalDateTime}】 重复【{trigger.RepeatCount}】次，每【{trigger.RepeatInterval.TotalSeconds}】秒重复一次。");
#endregion
#region 作业2 15秒后执行，然后每过10秒执行一次，共执行5次
// 创建带参数作业
job = JobBuilder.Create <ParameterJob>()
.WithIdentity("job2", "jobGroup1")
.WithDescription("带参数作业")
.SetJobData(new JobDataMap()
{
{ "dataBaseCon", "数据库配置字符串" },
{ "jsonParameter", "json参数字符串" }
})
.Build();
// 创建一个15秒后执行的触发器，每过10秒触发一次，共触发5次
trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("trigger2", "triggerGroup1")
.WithDescription("15秒后执行，然后每过10秒触发一次，共触发5次")
.StartAt(startTime)
.UsingJobData("jsonParameter", "trigger json参数字符串")
.WithSimpleSchedule(x => x.WithIntervalInSeconds(10).WithRepeatCount(5))
.Build();
// 调度作业执行
ft = await scheduler.ScheduleJob(job, trigger);
ConsoleExtend.WriteLineYellow($"{job.Key} 将在以下时间运行【{ft.Value.LocalDateTime}】 重复【{trigger.RepeatCount}】次，每【{trigger.RepeatInterval.TotalSeconds}】秒重复一次。");
//logProvider.GetLogger(typeof(SimpleTriggerTest).FullName).Invoke(LogLevel.Info
// , () => $"{job.Key} 将在以下时间运行【{ft.Value.LocalDateTime}】 重复【{trigger.RepeatCount}】次，每【{trigger.RepeatInterval.TotalSeconds}】秒重复一次。");
#endregion
#region 相同的作业2可以被其他触发器执行，每5秒执行一次，共执行10次
trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("trigger3_2", "triggerGroup1")
.WithDescription("相同的作业2可以被其他触发器执行，每5秒执行一次，共执行10次")
.ForJob("job2", "jobGroup1") // 根据job名称和组绑定
//.ForJob(new JobKey("job2", "jobGroup1")) // 根据jobKey绑定
//.ForJob(job) // 根据job绑定
.StartAt(startTime)
.WithSimpleSchedule(x => x.WithIntervalInSeconds(5).WithRepeatCount(10))
.Build();
ft = await scheduler.ScheduleJob(trigger);
ConsoleExtend.WriteLineRed($"{job.Key} 将在以下时间运行【{ft.Value.LocalDateTime}】 重复【{trigger.RepeatCount}】次，每【{trigger.RepeatInterval.TotalSeconds}】秒重复一次。");
#endregion
#region 作业3 将无限执行，每20秒执行一次
job = JobBuilder.Create <ParameterJob>()
.WithIdentity("job3", "jobGroup1")
.WithDescription("带参数作业")
.SetJobData(new JobDataMap()
{
{ "dataBaseCon", "数据库配置字符串" },
{ "jsonParameter", "json参数字符串" }
})
.Build();
trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("trigger4", "triggerGroup1")
.WithDescription("将无限执行，每20秒执行一次")
.WithSimpleSchedule(x => x.WithIntervalInSeconds(20).RepeatForever())
.Build();
ft = await scheduler.ScheduleJob(job, trigger);
ConsoleExtend.WriteLineDarkMagenta($"{job.Key} 将在以下时间运行【{ft.Value.LocalDateTime}】 重复【{trigger.RepeatCount}】次，每【{trigger.RepeatInterval.TotalSeconds}】秒重复一次。");
#endregion
await scheduler.Start();
#region 作业4 作业也可以在调度开始后添加进调度
job = JobBuilder.Create <ParameterJob>()
.WithIdentity("job4", "jobGroup1")
.WithDescription("带参数作业")
.SetJobData(new JobDataMap()
{
{ "dataBaseCon", "数据库配置字符串" },
{ "jsonParameter", "json参数字符串" }
})
.Build();
trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("trigger5", "triggerGroup1")
.WithDescription("作业也可以在调度开始后添加进调度 将无限执行，每20秒执行一次")
.WithSimpleSchedule(x => x.WithIntervalInSeconds(20).RepeatForever())
.Build();
ft = await scheduler.ScheduleJob(job, trigger);
ConsoleExtend.WriteLineYellow($"{job.Key} 将在以下时间运行【{ft.Value.LocalDateTime}】 重复【{trigger.RepeatCount}】次，每【{trigger.RepeatInterval.TotalSeconds}】秒重复一次。");
#endregion
#region 作业也可以直接出发(而不是通过触发器)
job = JobBuilder.Create <ParameterJob>()
.WithIdentity("job4", "jobGroup1")
.WithDescription("带参数作业")
.SetJobData(new JobDataMap()
{
{ "dataBaseCon", "数据库配置字符串" },
{ "jsonParameter", "json参数字符串" }
})
.StoreDurably() //设置没有触发器纸箱改作业，调度不存储改作业
.Build();
await scheduler.AddJob(job, true);
await scheduler.TriggerJob(new JobKey("job4", "jobGroup1")
, new JobDataMap { { "jsonParameter", "手动出发作业传入 json参数字符串" } });// 手动出发作业
ConsoleExtend.WriteLineRed($"{job.Key} 手动触发作业。");
#endregion
#region 手动触发之前作业
await scheduler.TriggerJob(new JobKey("job3", "jobGroup1")
, new JobDataMap { { "jsonParameter", "手动出发作业传入 json参数字符串" } });// 手动出发作业
ConsoleExtend.WriteLineRed("手动出发之前作业job3");
#endregion
#region 重新安排之前作业
trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("trigger3_2", "triggerGroup1")
.WithDescription("重新安排触发器3_2的作业，每20秒执行一次，共执行5次")
.StartAt(startTime)
.WithSimpleSchedule(x => x.WithIntervalInSeconds(20).WithRepeatCount(5))
.Build();
ft = await scheduler.RescheduleJob(trigger.Key, trigger);
ConsoleExtend.WriteLineRed($" 重新安排触发器3_2 job2 将在以下时间运行【{ft.Value.LocalDateTime}】 重复【{trigger.RepeatCount}】次，每【{trigger.RepeatInterval.TotalSeconds}】秒重复一次。");
#endregion
Console.WriteLine("等待3分钟");
await Task.Delay(TimeSpan.FromMinutes(3)).ConfigureAwait(false);
// 关闭调度
await scheduler.Shutdown(false);
}
public async Task RunAsync()
{
IScheduler scheduler = await StdSchedulerFactory.GetDefaultScheduler();
#region 作业1 每20秒执行一次
var job = JobBuilder.Create <ParameterJob>()
.WithIdentity("job1", "jobGroup1")
.WithDescription("每20秒执行一次")
.SetJobData(new JobDataMap {
{ "dataBaseCon", "数据库配置字符串" },
{ "jsonParameter", "Jons 参数" },
})
.Build();
ICronTrigger trigger = (ICronTrigger)TriggerBuilder.Create()
.WithIdentity("trigger1", "triggerGroup")
.WithCronSchedule("0/20 * * * * ?")
.Build();
// 调度作业执行
DateTimeOffset?ft = await scheduler.ScheduleJob(job, trigger);
ConsoleExtend.WriteLineRed($"{job.Key} 将在以下时间运行【{ft.Value.LocalDateTime}】 基于重复表达式【{trigger.CronExpressionString}】。");
#endregion
#region 每2分钟的15秒执行一次
job = JobBuilder.Create <ParameterJob>()
.WithIdentity("job2", "jobGroup1")
.WithDescription("每2分钟的15秒执行一次")
.SetJobData(new JobDataMap {
{ "dataBaseCon", "数据库配置字符串" },
{ "jsonParameter", "Jons 参数" },
})
.Build();
trigger = (ICronTrigger)TriggerBuilder.Create()
.WithIdentity("trigger2", "triggerGroup")
.WithCronSchedule("15 0/2 * * * ?")
.Build();
// 调度作业执行
ft = await scheduler.ScheduleJob(job, trigger);
ConsoleExtend.WriteLineRed($"{job.Key} 将在以下时间运行【{ft.Value.LocalDateTime}】 基于重复表达式【{trigger.CronExpressionString}】。");
#endregion
#region 在每天的 12点到18点 之间，每1分钟的20秒执行一次
job = JobBuilder.Create <ParameterJob>()
.WithIdentity("job3", "jobGroup1")
.WithDescription("在每天的12点到18点之间，每1分钟的20秒执行一次")
.SetJobData(new JobDataMap {
{ "dataBaseCon", "数据库配置字符串" },
{ "jsonParameter", "Jons 参数" },
})
.Build();
trigger = (ICronTrigger)TriggerBuilder.Create()
.WithIdentity("trigger3", "triggerGroup")
.WithCronSchedule("20 0/1 12-18 * * ?")
.Build();
// 调度作业执行
ft = await scheduler.ScheduleJob(job, trigger);
ConsoleExtend.WriteLineRed($"{job.Key} 将在以下时间运行【{ft.Value.LocalDateTime}】 基于重复表达式【{trigger.CronExpressionString}】。");
#endregion
#region 在每月的1号29号的下午4点执行
job = JobBuilder.Create <ParameterJob>()
.WithIdentity("job4", "jobGroup1")
.WithDescription("在每月的29号1号的下午4点执行")
.SetJobData(new JobDataMap {
{ "dataBaseCon", "数据库配置字符串" },
{ "jsonParameter", "Jons 参数" },
})
.Build();
trigger = (ICronTrigger)TriggerBuilder.Create()
.WithIdentity("trigger4", "triggerGroup")
.WithCronSchedule("0 0 16 1,29 * ?", x => x.InTimeZone(TimeZoneInfo.Local))
.Build();
// 调度作业执行
ft = await scheduler.ScheduleJob(job, trigger);
ConsoleExtend.WriteLineRed($"{job.Key} 将在以下时间运行【{ft.Value.LocalDateTime}】 基于重复表达式【{trigger.CronExpressionString}】。");
#endregion
#region 在每个星期一到星期六，每30秒执行一次
job = JobBuilder.Create <ParameterJob>()
.WithIdentity("job5", "jobGroup1")
.WithDescription("在每个星期一到星期六，每30秒执行一次")
.SetJobData(new JobDataMap {
{ "dataBaseCon", "数据库配置字符串" },
{ "jsonParameter", "Jons 参数" },
})
.Build();
trigger = (ICronTrigger)TriggerBuilder.Create()
.WithIdentity("trigger5", "triggerGroup")
.WithCronSchedule("0/30 * * ? * MON,SAT", x => x.InTimeZone(TimeZoneInfo.Local))
.Build();
// 调度作业执行
ft = await scheduler.ScheduleJob(job, trigger);
ConsoleExtend.WriteLineRed($"{job.Key} 将在以下时间运行【{ft.Value.LocalDateTime}】 基于重复表达式【{trigger.CronExpressionString}】。");
#endregion
#region 在每个星期天，每1小时执行一次
job = JobBuilder.Create <ParameterJob>()
.WithIdentity("job6", "jobGroup1")
.WithDescription("在每个星期天，每1小时执行一次")
.SetJobData(new JobDataMap {
{ "dataBaseCon", "数据库配置字符串" },
{ "jsonParameter", "Jons 参数" },
})
.Build();
trigger = (ICronTrigger)TriggerBuilder.Create()
.WithIdentity("trigger6", "triggerGroup")
.WithCronSchedule("0 0 1 ? * SUN")
.Build();
// 调度作业执行
ft = await scheduler.ScheduleJob(job, trigger);
ConsoleExtend.WriteLineRed($"{job.Key} 将在以下时间运行【{ft.Value.LocalDateTime}】 基于重复表达式【{trigger.CronExpressionString}】。");
#endregion
#region 在每天的10点42份执行
job = JobBuilder.Create <ParameterJob>()
.WithIdentity("job7", "jobGroup1")
.WithDescription("在每个星期天，每1小时执行一次")
.SetJobData(new JobDataMap {
{ "dataBaseCon", "数据库配置字符串" },
{ "jsonParameter", "Jons 参数" },
})
.Build();
trigger = (ICronTrigger)TriggerBuilder.Create()
.WithIdentity("trigger7", "triggerGroup")
.WithSchedule(CronScheduleBuilder.DailyAtHourAndMinute(10, 42).InTimeZone(TimeZoneInfo.Local))
//.WithCronSchedule("0 42 10 * * ?", x => x.InTimeZone(TimeZoneInfo.Local))
.Build();
// 调度作业执行
ft = await scheduler.ScheduleJob(job, trigger);
ConsoleExtend.WriteLineRed($"{job.Key} 将在以下时间运行【{ft.Value.LocalDateTime}】 基于重复表达式【{trigger.CronExpressionString}】。");
#endregion
await scheduler.Start();
Console.WriteLine("等待3分钟");
await Task.Delay(TimeSpan.FromMinutes(3)).ConfigureAwait(false);
// 关闭调度
await scheduler.Shutdown(false);
}
