/// <summary>
/// 开启任务
/// </summary>
public void Start()
{
ISchedulerFactory factory = new StdSchedulerFactory();
IScheduler scheduler = factory.GetScheduler().Result;
foreach (TaskInfo info in tasks)
{
if (info.IsEnabled)
{
Type type = Type.GetType(info.TaskType);
if (type != null)
{
string name = type.Name + "_trigger";
IJobDetail jobDetail = JobBuilder.Create(typeof(QuartzTask)).WithIdentity(type.Name).Build();
jobDetail.JobDataMap.Add(new KeyValuePair <string, object>("Id", info.Id));
TriggerBuilder builder = TriggerBuilder.Create().WithIdentity(name).WithCronSchedule(info.TaskRule);
if (info.StartDate > DateTime.MinValue)
{
builder.StartAt(new DateTimeOffset(info.StartDate));
}
DateTime?endDate = info.EndDate;
DateTime startDate = info.StartDate;
if (endDate.HasValue ? (endDate.GetValueOrDefault() > startDate) : false)
{
DateTime?nullable2 = info.EndDate;
builder.EndAt(nullable2.HasValue ? new DateTimeOffset?(nullable2.GetValueOrDefault()) : null);
}
ICronTrigger trigger = (ICronTrigger)builder.Build();
DateTime dateTime = scheduler.ScheduleJob(jobDetail, trigger).Result.DateTime;
info.NextDate = new DateTime?(TimeZoneInfo.ConvertTime(dateTime, trigger.TimeZone));
}
}
}
scheduler.Start();
}
/// <summary>
/// 运行任務
/// </summary>
/// <param name="stoppingToken"></param>
/// <returns></returns>
protected override Task ExecuteAsync(CancellationToken stoppingToken) => Task.Run(() =>
{
TaskServicesManager.GetOrAdd("單次任務", token => Task.Delay(1000));
TaskServicesManager.GetOrAdd("周期任務", token => Task.Delay(1000), TriggerBuilder.Default.WithInterval(10000).Build());
TaskServicesManager.GetOrAdd("Cron 任務", token => Task.Delay(1000), TriggerBuilder.Build(Cron.Secondly(5)));
TaskServicesManager.GetOrAdd("超時任務", token => Task.Delay(2000), TriggerBuilder.Default.WithTimeout(1000).WithInterval(1000).WithRepeatCount(2).Build());
// 本機調試時此處會抛出異常，配置文件中預設开啟了任務持久化到物理文件，此處異常只有首次加載時會抛出
// 此處異常是示例自定义任務内部未進行捕獲異常時任務仍然能继续运行，不會導致整個進程崩溃退出
// 此處程式碼可注释掉
//TaskServicesManager.GetOrAdd("故障任務", token => throw new Exception("故障任務"));
TaskServicesManager.GetOrAdd("取消任務", token => Task.Delay(1000)).Triggers.First().Enabled = false;
// 創建任務并禁用
TaskServicesManager.GetOrAdd("禁用任務", token => Task.Delay(1000)).Status = SchedulerStatus.Disabled;
// 真實任務负责批次写入資料執行腳本到日誌中
TaskServicesManager.GetOrAdd <DBLogTask>("SQL日誌", TriggerBuilder.Build(Cron.Minutely()));
// 真實人物负责周期性設置健康檢查结果开關為开啟
TaskServicesManager.GetOrAdd("健康檢查", token => Task.FromResult(DictHelper.SaveSettings(new BootstrapDict[] {
new BootstrapDict()
{
Category = "網站設置",
Name = "健康檢查",
Code = "1",
Define = 0
}
})), TriggerBuilder.Build(Cron.Minutely(10)));
});
private static QuartzKey Start(Action<Dictionary<string, object>> action, Action<TriggerBuilder> action2, Dictionary<string, object> dataMap, string jobName)
{
QuartzKey key = new QuartzKey();
if (jobName != null)
{
if (quartzCache.ContainsKey(jobName))
{
key = quartzCache[jobName];
}
else
{
quartzCache.Add(jobName, key);
}
}
jobName = jobName ?? Guid.NewGuid().ToString("D");
string group = "group_" + jobName;
string name = "trigger_" + jobName;
IJobDetail jobDetail = JobBuilder.Create(typeof(QuartzJob)).WithIdentity(jobName, group).Build();
TriggerBuilder builder = TriggerBuilder.Create().WithIdentity(name, group);
action2(builder);
ITrigger trigger = builder.Build();
if (quartzCache.ContainsKey(jobName))
{
quartzCache[jobName].JobKey = jobDetail.Key;
quartzCache[jobName].TriggerKey = trigger.Key;
quartzCache[jobName].Logs.Add(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + " 调度任务已经启动。");
}
jobDetail.JobDataMap.Add("dataMap", dataMap);
jobDetail.JobDataMap.Add("action", action);
jobDetail.JobDataMap.Add("jobName", jobName);
jobDetail.JobDataMap.Add("quartzCache", quartzCache);
sched.ScheduleJob(jobDetail, new Quartz.Collection.HashSet<ITrigger> { trigger }, true);
sched.Start();
return key;
}
private ITrigger CreateTrigger(Customer_JobInfo jobInfo)
{
TriggerBuilder tiggerBuilder = TriggerBuilder.Create().WithIdentity(jobInfo.JobName, jobInfo.JobGroupName);
//错过的不管了，剩下的按正常执行。
//tiggerBuilder.WithCronSchedule(jobInfo.Cron, c => c.WithMisfireHandlingInstructionDoNothing());
////错过的合并为一次执行，后续正常执行。
tiggerBuilder.WithCronSchedule(jobInfo.Cron, c => c.WithMisfireHandlingInstructionFireAndProceed());
////错过的马上执行掉，后续正常执行
//tiggerBuilder.WithCronSchedule(jobInfo.Cron, c => c.WithMisfireHandlingInstructionIgnoreMisfires());
//if (jobInfo.StartTime > DateTime.Now)
//{
// tiggerBuilder.StartAt(jobInfo.StartTime);
//}
//else
//{
// tiggerBuilder.StartNow();
//}
ITrigger trigger = tiggerBuilder.Build();
return(trigger);
}
/// <summary>
/// 运行任务
/// </summary>
/// <param name="stoppingToken"></param>
/// <returns></returns>
protected override Task ExecuteAsync(CancellationToken stoppingToken) => Task.Run(() =>
{
TaskServicesManager.GetOrAdd("单次任务", token => Task.Delay(1000));
TaskServicesManager.GetOrAdd("周期任务", token => Task.Delay(1000), TriggerBuilder.Default.WithInterval(10000).Build());
TaskServicesManager.GetOrAdd("Cron 任务", token => Task.Delay(1000), TriggerBuilder.Build(Cron.Secondly(5)));
TaskServicesManager.GetOrAdd("超时任务", token => Task.Delay(2000), TriggerBuilder.Default.WithTimeout(1000).WithInterval(1000).WithRepeatCount(2).Build());
// 本机调试时此处会抛出异常，配置文件中默认开启了任务持久化到物理文件，此处异常只有首次加载时会抛出
// 此处异常是示例自定义任务内部未进行捕获异常时任务仍然能继续运行，不会导致整个进程崩溃退出
// 此处代码可注释掉
//TaskServicesManager.GetOrAdd("故障任务", token => throw new Exception("故障任务"));
TaskServicesManager.GetOrAdd("取消任务", token => Task.Delay(1000)).Triggers.First().Enabled = false;
// 创建任务并禁用
TaskServicesManager.GetOrAdd("禁用任务", token => Task.Delay(1000)).Status = SchedulerStatus.Disabled;
// 真实任务负责批次写入数据执行脚本到日志中
TaskServicesManager.GetOrAdd <DBLogTask>("SQL日志", TriggerBuilder.Build(Cron.Minutely()));
// 真实人物负责周期性设置健康检查结果开关为开启
TaskServicesManager.GetOrAdd("健康检查", token => Task.FromResult(DictHelper.SaveSettings(new BootstrapDict[] {
new BootstrapDict()
{
Category = "网站设置",
Name = "健康检查",
Code = "1",
Define = 0
}
})), TriggerBuilder.Build(Cron.Minutely(10)));
});
/// <summary>
/// Load DB Job and Trigger
/// </summary>
public virtual void GetJobTriggerFromDb()
{
var item = GetJobList();
_logger.Info(string.Format("创建任务触发，JobUID={0}，JobName={1}", item.JobUID, item.JobName));
Type type = Type.GetType(item.JobClass);
var job = JobBuilder.Create(type)
.WithIdentity(item.JobUID)
.UsingJobData("JobName", item.JobName)
.Build();
TriggerBuilder simpleTriggerBuilder = TriggerBuilder.Create()
.WithIdentity(Guid.NewGuid().ToString())
.ForJob(job).StartNow();
int simpleRepeatInterval = 6;
if (!string.IsNullOrWhiteSpace(item.SimpleRepeatInterval))
{
simpleRepeatInterval = Convert.ToInt32(item.SimpleRepeatInterval);
}
simpleTriggerBuilder = simpleTriggerBuilder.WithSimpleSchedule(x => x
.WithIntervalInSeconds(simpleRepeatInterval)//触发时间，秒
.RepeatForever());
var trigger = simpleTriggerBuilder.Build();
if (scheduler.CheckExists(job.Key))
{
//schedule the job
scheduler.ScheduleJob(trigger);
}
else
{
scheduler.ScheduleJob(job, trigger);
}
}
//间隔一定时间重复一次执行指定的任务
public static async void WithInterval()
{
//--------------------------------1.准备调度者
//创建调度器工厂
ISchedulerFactory factory = new StdSchedulerFactory();
//创建调度者
IScheduler scheduler = await factory.GetScheduler();
//--------------------------------2.准备任务
//创建任务构造这：JobBuilder
JobBuilder jobBuilder = JobBuilder.Create <TestJob>();
//创建任务，定义任务的名字和任务组
//IJobDetail job = jobBuilder.WithIdentity("job1", "grpup1").Build();
IJobDetail job1 = jobBuilder.Build();
//--------------------------------3.准备触发器
//创建触发器构造者：TriggerBuilder
TriggerBuilder triggerBuilder = TriggerBuilder.Create().StartNow().WithSimpleSchedule(x => x.WithIntervalInSeconds(5).RepeatForever());
//创建触发器，定义触发器的名字和触发组
//ISimpleTrigger trigger1 = triggerBuilder.WithIdentity("trigger1","group2").Build() as ISimpleTrigger;
ITrigger trigger = triggerBuilder.Build();
//--------------------------------4、将任务与触发器添加到调度器中
await scheduler.ScheduleJob(job1, trigger);
//开始执行
await scheduler.Start();
}
/// <summary>
/// 运行任务
/// </summary>
/// <param name="stoppingToken"></param>
/// <returns></returns>
protected override Task ExecuteAsync(CancellationToken stoppingToken)
{
TaskServicesManager.GetOrAdd("Clear Upload Files", token =>
{
if (_env != null)
{
var webSiteUrl = $"images{Path.DirectorySeparatorChar}uploader{Path.DirectorySeparatorChar}";
var filePath = Path.Combine(_env.WebRootPath, webSiteUrl);
if (Directory.Exists(filePath))
{
Directory.EnumerateFiles(filePath).Take(10).ToList().ForEach(file =>
{
try
{
if (token.IsCancellationRequested)
{
return;
}
File.Delete(file);
}
catch { }
});
}
}
return(Task.CompletedTask);
}, TriggerBuilder.Build(Cron.Minutely(10)));
return(Task.CompletedTask);
}
ITrigger CreateTrigger(RecurringSchedule message, IJobDetail jobDetail, TriggerKey triggerKey)
{
TimeZoneInfo tz = TimeZoneInfo.Local;
if (!string.IsNullOrWhiteSpace(message.TimeZoneId) && message.TimeZoneId != tz.Id)
{
tz = TimeZoneInfo.FindSystemTimeZoneById(message.TimeZoneId);
}
TriggerBuilder triggerBuilder = TriggerBuilder.Create()
.ForJob(jobDetail)
.WithIdentity(triggerKey)
.StartAt(message.StartTime)
.WithCronSchedule(message.CronExpression, x =>
{
x.InTimeZone(tz);
switch (message.MisfirePolicy)
{
case MissedEventPolicy.Skip:
x.WithMisfireHandlingInstructionDoNothing();
break;
case MissedEventPolicy.Send:
x.WithMisfireHandlingInstructionFireAndProceed();
break;
}
});
if (message.EndTime.HasValue)
{
triggerBuilder.EndAt(message.EndTime);
}
return(triggerBuilder.Build());
}
public static void CreateJob <T>(JobInfo jInfo, ref IScheduler scheduler) where T : IJob
{
JobBuilder jbuilder = JobBuilder.Create <T>();
jbuilder.WithIdentity(jInfo.JobName, jInfo.GroupName);
if (jInfo.DataParamters != null && jInfo.DataParamters.Any())
{
foreach (var item in jInfo.DataParamters)
{
jbuilder.UsingJobData(GetDataMap(item));
}
}
IJobDetail jobDetail = jbuilder.Build();
TriggerBuilder tBuilder = TriggerBuilder.Create();
tBuilder.WithIdentity(jInfo.TriggerName, jInfo.GroupName)
.StartNow()
.WithCronSchedule(jInfo.CronExpression);
//.WithSimpleSchedule(x => x
// .WithIntervalInSeconds(10)
// .RepeatForever());
ITrigger trigger = tBuilder.Build();
scheduler.ScheduleJob(jobDetail, trigger);
}
protected override void OnStart(string[] args)
{
string DateNow, DateNext;
base.OnStart(args);
if (Scheduler == null)
{
Scheduler = StdSchedulerFactory.GetDefaultScheduler();
}
Scheduler.Start();
TriggerBuilder Builder = TriggerBuilder.Create();
Builder = Builder.WithCronSchedule(AutoOrderEmail_CronExpr, (CronSchBuilder) => {
CronSchBuilder.InTimeZone(TimeZoneInfo.Utc);
CronSchBuilder.WithMisfireHandlingInstructionFireAndProceed();
});
ITrigger AutoEmailTrigger = Builder.Build();
IJobDetail AutoOrderEmailJob = JobBuilder.Create(typeof(TranslatorOfferEmailJob)).Build();
AutoOrderEmailJob.JobDataMap["ServiceLog"] = this.ServiceLog;
Scheduler.ScheduleJob(AutoOrderEmailJob, AutoEmailTrigger);
DateNow = DateTime.UtcNow.ToString("F");
DateNext = AutoEmailTrigger.GetNextFireTimeUtc().Value.DateTime.ToString("F");
ServiceLog.WriteEntry(string.Format(FRMT_INIT, DateNow, DateNext), EventLogEntryType.Information);
if (this.ServiceLog.MaximumKilobytes < 51200)
{
this.ServiceLog.MaximumKilobytes = 51200; // Set our custom EventLog size to 50MB
}
}
public static void ScheduleJob <TJob>(this IApplicationBuilder app, TriggerBuilder triggerBuilder) where TJob : class, IJob
{
var scheduler = app.ApplicationServices.GetRequiredService <IScheduler>();
var jobName = typeof(TJob).FullName;
var job = JobBuilder.Create <TJob>()
.WithIdentity(jobName)
.Build();
triggerBuilder = triggerBuilder
.ForJob(job)
.WithIdentity($"{jobName}.trigger");
var trigger = triggerBuilder.Build();
// TODO: Fix this issue - currently probably only in tests
if (scheduler.CheckExists(job.Key).Result)
{
Log.Logger.Warning("Job should not exist but it does. {@JobKey}", job.Key);
scheduler.DeleteJob(job.Key).Wait();
}
scheduler.ScheduleJob(job, trigger).Wait();
}
public static ITrigger CreateTrigger(TaskRuntimeInfo taskinfo)
{
TriggerBuilder trigger = null;
//暂停自定义task category想法
/*
* switch (taskinfo.task.taskCategory)
* {
* case "Cron":
* trigger = TriggerBuilder.Create()
* .WithIdentity(taskinfo.task.taskName, taskinfo.task.taskCategory)
* .WithCronSchedule(taskinfo.task.taskCron);
* break;
* case "Sample":
* default:
* trigger = TriggerBuilder.Create()
* .WithIdentity(taskinfo.task.taskName, taskinfo.task.taskCategory)
* .WithSimpleSchedule();
* trigger.StartAt(taskinfo.task.taskCreateTime);
*
* trigger.WithDailyTimeIntervalSchedule();
* break;
* }
*/
//默认cron job
trigger = TriggerBuilder.Create()
.WithIdentity(taskinfo.task.taskName, "Cron")
.WithCronSchedule(taskinfo.task.taskCron);
return(trigger.Build());
}
public void Add(Task task)
{
if (task.next_date > DateTime.Now)
{
IJobDetail taskToNotify = JobBuilder.Create <Notification>().WithIdentity(task.JobKey).Build();
taskToNotify.JobDataMap["Task"] = task;
TriggerBuilder builder = TriggerBuilder.Create()
.StartAt(task.next_date);
if (task.period_min > 0)
{
builder.WithSimpleSchedule(x => x
.WithIntervalInMinutes(task.period_min)
.RepeatForever())
.EndAt(task.next_date.AddMinutes(task.duration_min));
}
ITrigger trigger = builder
.Build();
scheduler.ScheduleJob(taskToNotify, trigger);
}
}
private ITrigger EveryDayOneTimeAt(TimeOfDay timeOfDay)
{
TriggerBuilder triggerBuilder = TriggerBuilder.Create();
triggerBuilder.WithCronSchedule(String.Format("0 {0} {1} ? * *", timeOfDay.Minute, timeOfDay.Hour));
return(triggerBuilder.Build());
}
public ScheduleJobResult ScheduleJob <T>(string jobId, string jobGroup, string cronExpression, Dictionary <string, string> jobData = null, string timeZone = null)
where T : IJob
{
var ret = new ScheduleJobResult();
// a. build job
JobBuilder jobBuilder = JobBuilder.Create <T>()
.WithIdentity(jobId, jobGroup);
if (jobData != null)
{
foreach (KeyValuePair <string, string> pair in jobData)
{
jobBuilder.UsingJobData(pair.Key, pair.Value);
}
}
IJobDetail job = jobBuilder.Build();
ret.Job = job;
//
// b. build trigger
TimeZoneInfo timeZoneInfo = string.IsNullOrWhiteSpace(timeZone) ? TimeZoneInfo.Local : TimeZoneInfo.FindSystemTimeZoneById(timeZone);
TriggerBuilder triggerBuilder = TriggerBuilder.Create()
.WithIdentity(jobId, jobGroup)
.WithCronSchedule(cronExpression, x => x.InTimeZone(timeZoneInfo));
if (jobData != null)
{
foreach (KeyValuePair <string, string> pair in jobData)
{
jobBuilder.UsingJobData(pair.Key, pair.Value);
}
}
ITrigger trigger = triggerBuilder.Build();
ret.Trigger = trigger;
//
// c. schedule job
if (trigger.GetNextFiringTimes(DateTimeOffset.Now).FirstOrDefault() == default(DateTime))
{
ret.Success = false;
_log.Info($"Job WILL NEVER START for \"{jobId}\"");
}
else
{
_scheduler.ScheduleJob(job, trigger).Wait();
ret.Success = true;
_log.Debug($"Job scheduled OK for \"{jobId}\"");
}
return(ret);
}
public async override Task StartAsync(CancellationToken cancellationToken)
{
Log.Information("Starting JobWorker...");
await _fFmpegInitializer.Intitialize();
IScheduler scheduler = await _schedulerFactory
.GetScheduler(cancellationToken);
scheduler.JobFactory = _jobFactory;
foreach (IJob job in _jobs)
{
Type jobType = job.GetType();
Log.Information("Scheduling job {Name}", jobType.Name);
JobScheduleOptions?options = _scheduleOptions
.FirstOrDefault(x => x.Name == jobType.Name);
if (options != null && options.Enabled)
{
IJobDetail jobDetail = JobBuilder
.Create(jobType)
.WithIdentity(jobType.Name)
.Build();
TriggerBuilder triggerBuilder = TriggerBuilder
.Create()
.WithIdentity(jobType.Name);
if (options.Interval.HasValue)
{
triggerBuilder.WithSimpleSchedule(s => s
.WithInterval(options.Interval.Value)
.RepeatForever());
Log.Information("Schedule job {Name} with intervall: {Interval}",
jobType.Name,
options.Interval);
}
else
{
triggerBuilder.WithCronSchedule(options.Cron !);
Log.Information("Schedule job {Name} with cron expression: {Cron}",
jobType.Name,
options.Cron);
}
await scheduler.ScheduleJob(jobDetail, triggerBuilder.Build(), cancellationToken);
}
else
{
Log.Information("Job {Name} is not enabled", jobType.Name);
}
}
await scheduler.Start();
}
public BaseResult AddTrigger(AddTriggerInput input)
{
var result = new BaseResult();
try
{
TriggerBuilder triggerBuilder = TriggerBuilder
.Create()
.ForJob(input.Job, input.Group);
if (!string.IsNullOrEmpty(input.Name))
{
triggerBuilder = triggerBuilder.WithIdentity(input.Name);
}
switch (input.TriggerType)
{
case "Simple":
triggerBuilder = triggerBuilder.WithSimpleSchedule(x =>
{
if (input.RepeatForever)
{
x.RepeatForever();
}
else
{
x.WithRepeatCount(input.RepeatCount);
}
x.WithInterval(TimeSpan.FromMilliseconds(input.RepeatInterval));
});
if (!string.IsNullOrEmpty(input.StartDate))
{
var startDate = DateTimeOffset.Parse(input.StartDate);
triggerBuilder.StartAt(startDate);
}
break;
case "Cron":
triggerBuilder = triggerBuilder.WithCronSchedule(input.CronExpression);
break;
default:
throw new ArgumentOutOfRangeException();
}
_schedulerProvider.Scheduler.ScheduleJob(triggerBuilder.Build());
result.Success = true;
}
catch (Exception ex)
{
result.ErrorMessage = ex.Message;
}
return(result);
}
/// <summary>
/// 启动任务
/// </summary>
public void Start()
{
if (_tasks.Count() == 0)
{
return;
}
TaskService taskService = new TaskService();
ISchedulerFactory sf = new StdSchedulerFactory();
IScheduler sched = sf.GetScheduler();
foreach (var task in _tasks)
{
if (!task.Enabled)
{
continue;
}
Type type = Type.GetType(task.ClassType);
if (type == null)
{
continue;
}
string triggerName = type.Name + "_trigger";
IJobDetail job = JobBuilder.Create(typeof(QuartzTask))
.WithIdentity(type.Name)
.Build();
job.JobDataMap.Add(new KeyValuePair <string, object>("Id", task.Id));
TriggerBuilder tb = TriggerBuilder.Create()
.WithIdentity(triggerName)
.WithCronSchedule(task.TaskRule);
if (task.StartDate > DateTime.MinValue)
{
tb.StartAt(new DateTimeOffset(task.StartDate));
}
if (task.EndDate > task.StartDate)
{
tb.EndAt(task.EndDate);
}
ICronTrigger trigger = (ICronTrigger)tb.Build();
DateTime ft = sched.ScheduleJob(job, trigger).DateTime;
task.NextStart = TimeZoneInfo.ConvertTime(ft, trigger.TimeZone);
}
sched.Start();
}
public static ITrigger GetTrigger()
{
//创建一个触发器
TriggerBuilder triggerBuilder = TriggerBuilder.Create();
triggerBuilder.StartNow(); //现在开始
//triggerBuilder.WithCronSchedule("/5 * * ? * *");//时间表达式
triggerBuilder.WithSimpleSchedule(x => x.WithIntervalInSeconds(5).RepeatForever()); //触发时间，5秒一次。
ITrigger jobTrigger = triggerBuilder.Build();
return(jobTrigger);
}
/// <summary>
/// 启动定时器框架-自动扫描注入启动
/// </summary>
/// <param name="app"></param>
public static void UseQuartz(this IApplicationBuilder app)
{
var serviceProvider = app.ApplicationServices;
var scheduler = serviceProvider.GetRequiredService <IScheduler>();
var jobFactory = serviceProvider.GetRequiredService <IJobFactory>();
scheduler.JobFactory = jobFactory;
// add jobdetail with trigger to scheduler
var jobs = app.ApplicationServices.GetServices <IJob>();
foreach (var job in jobs)
{
var jobDesc = job.GetType().GetCustomAttribute <JobDescriptionAttribute>();
var jobBuilder = JobBuilder.Create(job.GetType());
if (jobDesc != null)
{
jobBuilder.WithIdentity(jobDesc.Key, jobDesc.Group).WithDescription(jobDesc.Description);
}
var jobDetail = jobBuilder.Build();
ITrigger trigger;
var triggerDesc = job.GetType().GetCustomAttribute <IntervalTriggerAttribute>();
if (triggerDesc == null)
{
// default trigger
trigger = TriggerBuilder.Create().StartNow()
.WithSimpleSchedule(x => x.WithIntervalInSeconds(60).RepeatForever()).Build();
}
else
{
TriggerBuilder temp = TriggerBuilder.Create().WithIdentity(triggerDesc.Key, triggerDesc.Group).WithDescription(triggerDesc.Description);
if (triggerDesc.StartNow)
{
temp = temp.StartNow();
}
if (triggerDesc.IsRepeatForever)
{
temp = temp.WithSimpleSchedule(x => x.WithIntervalInSeconds(triggerDesc.IntervalInSeconds)
.RepeatForever());
}
else
{
temp = temp.WithSimpleSchedule(x => x.WithIntervalInSeconds(triggerDesc.IntervalInSeconds)
.WithRepeatCount(triggerDesc.RepeatCount));
}
trigger = temp.Build();
}
scheduler.ScheduleJob(jobDetail, trigger).Wait();
}
scheduler.Start().Wait();
}
public void Update(TaskDetail task)
{
if (task == null)
{
return;
}
int index = _tasks.FindIndex((TaskDetail n) => n.Id == task.Id);
if (_tasks[index] == null)
{
return;
}
task.ClassType = _tasks[index].ClassType;
task.LastEnd = _tasks[index].LastEnd;
task.LastStart = _tasks[index].LastStart;
task.LastIsSuccess = _tasks[index].LastIsSuccess;
_tasks[index] = task;
Type type = Type.GetType(task.ClassType);
if (type == null)
{
return;
}
Remove(type.Name);
if (!task.Enabled)
{
return;
}
string name = type.Name + "_trigger";
ISchedulerFactory schedulerFactory = new StdSchedulerFactory();
IScheduler scheduler = schedulerFactory.GetScheduler();
IJobDetail jobDetail = JobBuilder.Create(typeof(QuartzTask)).WithIdentity(type.Name).Build();
jobDetail.JobDataMap.Add(new KeyValuePair <string, object>("Id", task.Id));
TriggerBuilder triggerBuilder = TriggerBuilder.Create().WithIdentity(name).WithCronSchedule(task.TaskRule);
if (task.StartDate > DateTime.MinValue)
{
triggerBuilder.StartAt(new DateTimeOffset(task.StartDate));
}
if (task.EndDate.HasValue && task.EndDate > task.StartDate)
{
TriggerBuilder arg_233_0 = triggerBuilder;
DateTime? endDate = task.EndDate;
arg_233_0.EndAt(endDate.HasValue ? new DateTimeOffset?(endDate.GetValueOrDefault()) : null);
}
var cronTrigger = (ICronTrigger)triggerBuilder.Build();
DateTime dateTime = scheduler.ScheduleJob(jobDetail, cronTrigger).DateTime;
task.NextStart = TimeZoneInfo.ConvertTime(dateTime, cronTrigger.TimeZone);
}
//WithSimpleSchedule
private static void Scheduler1()
{
try
{
Console.ReadLine();
//开启日志输出
Common.Logging.LogManager.Adapter = new Common.Logging.Simple.ConsoleOutLoggerFactoryAdapter {
Level = Common.Logging.LogLevel.Info
};
ILog log = LogManager.GetLogger(typeof(Program));
//从计划器工作实例化一个计划实例；
IScheduler scheduler = StdSchedulerFactory.GetDefaultScheduler();
//定义一个job
IJobDetail job = JobBuilder.Create <Job1>()
.WithIdentity("job1", "grop1")
.UsingJobData("jobSays", "Hello World!")
.UsingJobData("myFloatValue", 3.141f)
.Build();
//定义一个trigger
ITrigger trigger = null;
TriggerBuilder triggerBuilder = TriggerBuilder.Create();
triggerBuilder.WithIdentity("trigger1", "group1");
triggerBuilder.StartNow(); //按当前时间立即执行
triggerBuilder.WithSimpleSchedule(x => x.WithIntervalInSeconds(3).RepeatForever()); //每3秒执行，永远重复
trigger = triggerBuilder.Build();
//开始为任务做计划
DateTimeOffset dto = scheduler.ScheduleJob(job, trigger);
// 计划任务开始
scheduler.Start();
// some sleep to show what's happening
//Thread.Sleep(TimeSpan.FromSeconds(2));
// and last shut down the scheduler when you are ready to close your program
//scheduler.Shutdown();
//Console.ReadLine();
}
catch (SchedulerException se)
{
Console.WriteLine(se);
}
}
/// <summary>
/// 执行任务
/// </summary>
/// <typeparam name="TJob"></typeparam>
/// <param name="configureJob"></param>
/// <param name="configureTrigger"></param>
/// <returns></returns>
public async Task ScheduleAsync <TJob>(Action <JobBuilder> configureJob, Action <TriggerBuilder> configureTrigger) where TJob : IJob
{
JobBuilder jobToBuild = JobBuilder.Create <TJob>();
configureJob(jobToBuild);
IJobDetail job = jobToBuild.Build();
TriggerBuilder triggerToBuild = TriggerBuilder.Create();
configureTrigger(triggerToBuild);
ITrigger trigger = triggerToBuild.Build();
await _quartzConfiguration.Scheduler.ScheduleJob(job, trigger);
}
static IScheduler scheduler = null;// sf.GetScheduler();
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="jobName"></param>
/// <param name="triggerName"></param>
/// <param name="item"></param>
/// <param name="seconds">多久执行一次,</param>
/// <param name="count">执行多少次</param>
/// <param name="date"></param>
public static void JobsEx <T>(string jobName, string triggerName, KeyValuePair <string, object>?item = null,
int seconds = 1, int count = 1, DateTimeOffset?date = null)
{
#if NET40 || NET45
scheduler = sf.GetScheduler();
#else
scheduler = sf.GetScheduler().Result;
#endif
scheduler.Start();
IJobDetail detail = JobBuilder.Create(typeof(T)).WithIdentity(jobName).Build(); //new JobDetailImpl(jobName, typeof(T));
if (item.HasValue)
{
detail.JobDataMap.Add(item.Value);
}
TriggerBuilder builder = TriggerBuilder.Create().WithIdentity(triggerName); //TriggerBuilder.Create().WithIdentity(triggerName).StartAt(date.HasValue ? date.Value : DateTimeOffset.Now);
if (date.HasValue)
{
builder = builder.StartAt(date.Value);
}
else
{
builder = builder.StartNow();
}
if (count > 1)
{
if (seconds < 1)
{
seconds = 1;
}
builder = builder.WithSimpleSchedule(x => x.WithIntervalInSeconds(seconds).WithRepeatCount(count - 1));
}
else
{
builder = builder.WithSimpleSchedule();
}
ITrigger trigger = builder.Build();
scheduler.ScheduleJob(detail, trigger);
LogHelper.Info("scheduler is start " + DateTime.Now.ToStringEx());
//if (item.HasValue)
// logger.Info("scheduler param[" + JsonConvert.SerializeObject(item.Value) + "]", nameof(JobExtend));
//logger.Info("scheduler is shutdown:" + scheduler.IsShutdown);
//Console.WriteLine("scheduler is start" + DateTime.Now.ToString());
}
public void TriggerJob(
string jobName,
string jobGroup,
string triggerName,
TriggerType trigger,
IDictionary <string, object> jobData)
{
TriggerBuilder triggerBuilder = TriggerBuilder
.Create()
.ForJob(jobName, jobGroup);
if (!string.IsNullOrEmpty(triggerName))
{
triggerBuilder = triggerBuilder.WithIdentity(triggerName);
}
SimpleTriggerType simpleTrigger = trigger as SimpleTriggerType;
if (simpleTrigger != null)
{
triggerBuilder = triggerBuilder.WithSimpleSchedule(x =>
{
if (simpleTrigger.RepeatCount == -1)
{
x.RepeatForever();
}
else
{
x.WithRepeatCount(simpleTrigger.RepeatCount);
}
x.WithInterval(TimeSpan.FromMilliseconds(simpleTrigger.RepeatInterval));
});
}
else
{
CronTriggerType cronTriggerType = trigger as CronTriggerType;
if (cronTriggerType != null)
{
triggerBuilder = triggerBuilder.WithCronSchedule(cronTriggerType.CronExpression);
}
}
if (jobData != null)
{
triggerBuilder = triggerBuilder.UsingJobData(new JobDataMap(jobData));
}
_scheduler.ScheduleJob(triggerBuilder.Build());
}
/// <summary>
/// 给现有的job 创建一个触发器
/// </summary>
/// <param name="jobName"></param>
/// <param name="jobGroup"></param>
/// <param name="triggerName"></param>
/// <param name="trigger"></param>
/// <param name="jobData"></param>
public void ScheduleJob(string jobName, string jobGroup, string triggerName, TriggerType trigger, IDictionary <string, object> jobData)
{
TriggerBuilder triggerBuilder = ApplyTriggerData(
triggerName,
trigger,
TriggerBuilder.Create().ForJob(jobName, jobGroup));
if (jobData != null)
{
triggerBuilder = triggerBuilder.UsingJobData(new JobDataMap(jobData));
}
//将给定的trigger与由trigger的设置标识的Job一起调度。
_scheduler.ScheduleJob(triggerBuilder.Build());
}
/// <summary>
/// 两个问题有QuartzModel 有了对象还要这个做什么？二考虑把 QuartzModelList 这个分出去
/// </summary>
public bool Update(string jobName)
{
if (this.QuartzSchedule == null || string.IsNullOrEmpty(jobName))
{
return(false);
}
string dllName = jobName + "QuartzTask.dll";
string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, jobName, dllName);
byte[] assemblyBuf = File.ReadAllBytes(path);
Assembly assembly = Assembly.Load(assemblyBuf);
Type type = assembly.GetType(dllName + "." + jobName);
if (type == null)
{
return(false);
}
object[] objs = type.GetCustomAttributes(typeof(ScanSignal), true);
if (objs != null && objs.Length > 0)
{
JobBase job1 = Activator.CreateInstance(type) as JobBase;
QuartzModel model = null;
ScanSignal customScanSignal = objs[0] as ScanSignal;
if (customScanSignal != null)
{
IJobDetail job = JobBuilder.Create(type)
.WithIdentity(customScanSignal.JobName, QuartzGroupLevel.GetGroupLevelName(customScanSignal.GroupLevel))
.UsingJobData(new JobDataMap(job1.map))
.Build();
TriggerBuilder triggerBuilder = TriggerBuilder.Create()
.WithIdentity(customScanSignal.JobName + "trigger", QuartzGroupLevel.GetGroupLevelName(customScanSignal.GroupLevel))
.StartNow();
if (String.IsNullOrEmpty(customScanSignal.CronExpression))
{
triggerBuilder.WithSimpleSchedule(x => x.WithInterval(customScanSignal.TimeSpan).RepeatForever());
}
else
{
triggerBuilder.WithCronSchedule(customScanSignal.CronExpression);
}
ITrigger trigger = triggerBuilder.Build();
model = new QuartzModel(customScanSignal.JobName, job, trigger);
return(this.QuartzSchedule.UpdateJob(model, model) != null);
}
}
return(false);
}
/// <summary>
/// 创建只触发一次的触发器
/// </summary>
/// <param name="secondBase">时间</param>
/// <param name="forJob">此触发器将关联到哪一个作业</param>
/// <returns></returns>
public static ISimpleTrigger CreateOnceTrigger(int secondBase, IJobDetail forJob = null)
{
DateTimeOffset startTime = DateBuilder.NextGivenSecondDate(null, secondBase);
TriggerBuilder builder =
TriggerBuilder.Create()
.WithIdentity(System.Guid.NewGuid().ToString())
.WithDescription("此触发器只执行一次.")
.StartAt(startTime);
if (forJob != null)
{
builder = builder.ForJob(forJob);
}
return((ISimpleTrigger)builder.Build());
}
private ITrigger CreateTrigger(JobInfo jobInfo)
{
TriggerBuilder triggerBuilder = TriggerBuilder.Create().WithIdentity(jobInfo.JobName, jobInfo.JobGroup);
if (!string.IsNullOrEmpty(jobInfo.Crons))
{
//失火策略
triggerBuilder.WithCronSchedule(jobInfo.Crons);
}
triggerBuilder.StartNow();
ITrigger trigger = triggerBuilder.Build();
return(trigger);
}
