public static TriggerBuilder WithIdentity_(this TriggerBuilder builder, string name, string group = null)
{
var res = ValidateHelper.IsNotEmpty(group) ?
builder.WithIdentity(name, group) :
builder.WithIdentity(name);
return(res);
}
//间隔一定时间重复一次执行指定的任务
public static async void WithInterval()
{
//--------------------------------1.准备调度者
//创建调度器工厂
ISchedulerFactory factory = new StdSchedulerFactory();
//创建调度者
IScheduler scheduler = await factory.GetScheduler();
//--------------------------------2.准备任务
//创建任务构造这：JobBuilder
JobBuilder jobBuilder = JobBuilder.Create <TestJob1>();
//创建任务，定义任务的名字和任务组
//IJobDetail job = jobBuilder.WithIdentity("job1", "grpup1").Build();
IJobDetail job1 = jobBuilder.Build();
//--------------------------------3.准备触发器
//创建触发器构造者：TriggerBuilder
TriggerBuilder triggerBuilder = TriggerBuilder.Create().StartNow().WithSimpleSchedule(x => x.WithIntervalInSeconds(5).WithRepeatCount(2));//此处RepeatForever()为重复无数次，使用.WithRepeatCount()可以设置重复的次数
//创建触发器，定义触发器的名字和触发组
ISimpleTrigger trigger = triggerBuilder.WithIdentity("trigger1", "group2").Build() as ISimpleTrigger;
//--------------------------------4、将任务与触发器添加到调度器中
await scheduler.ScheduleJob(job1, trigger);
//开始执行
await scheduler.Start();
//调度器延时调度，但是注意，在调度器延时的时候，定时任务可能计时已经开始了，
//一旦结束调度器的延时，定时任务会把之前延时的时间中应该执行的任务都一次性执行了
//await scheduler.StartDelayed(TimeSpan.FromSeconds(20));
}
/// <summary>
/// 应用触发器数据
/// </summary>
/// <param name="triggerName"></param>
/// <param name="trigger"></param>
/// <param name="triggerBuilder"></param>
/// <returns></returns>
private static TriggerBuilder ApplyTriggerData(string triggerName, TriggerType trigger, TriggerBuilder triggerBuilder)
{
if (!string.IsNullOrEmpty(triggerName))
{
triggerBuilder = triggerBuilder.WithIdentity(triggerName);
}
if (trigger is SimpleTriggerType simpleTrigger)
{
triggerBuilder = triggerBuilder.WithSimpleSchedule(x =>
{
if (simpleTrigger.RepeatCount == -1)
{
x.RepeatForever();
}
else
{
x.WithRepeatCount(simpleTrigger.RepeatCount);
}
x.WithInterval(TimeSpan.FromMilliseconds(simpleTrigger.RepeatInterval));
});
}
else if (trigger is CronTriggerType cronTriggerType)
{
triggerBuilder = triggerBuilder.WithCronSchedule(cronTriggerType.CronExpression);
}
else
{
throw new Exception("不支持的 trigger type: " + trigger.Code);
}
return(triggerBuilder);
}
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);
}
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);
}
//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);
}
}
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());
}
protected override async Task InternalExecute(AddTriggerInput input, CommandResultWithErrorDetails output)
{
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));
});
break;
case "Cron":
triggerBuilder = triggerBuilder.WithCronSchedule(input.CronExpression);
break;
default:
throw new ArgumentOutOfRangeException();
}
await(await Scheduler().ConfigureAwait(false)).ScheduleJob(triggerBuilder.Build()).ConfigureAwait(false);
}
/// <summary>
/// 根据数据采集计划来创建作业触发器
/// </summary>
/// <param name="jobDetail">采集计划</param>
/// <param name="clMethod">数据采集方法</param>
/// <param name="forJob">将此触发器添加到哪个作业</param>
/// <returns></returns>
public static ITrigger CreateTrigger(ScheduleJob_Details_Triggers trigger, IJobDetail forJob = null)
{
if (trigger == null)
{
throw new ArgumentNullException("『CreateTrigger』的trigger参数为空！");
}
TriggerBuilder builder = TriggerBuilder.Create();
builder =
builder
.WithIdentity(GetTriggerKey(trigger))
.WithDescription(trigger.description);
builder =
trigger.trigger_type.ToUpper() == "cron".ToUpper() ? (
string.IsNullOrEmpty(trigger.cronexpression) ?
builder.WithSimpleSchedule(x => x.WithIntervalInMinutes(string.IsNullOrEmpty(trigger.repeat_interval) ? 30 : int.Parse(trigger.repeat_interval)).WithRepeatCount(string.IsNullOrEmpty(trigger.repeat_count) ? 10 : int.Parse(trigger.repeat_count)))
: builder.WithCronSchedule(trigger.cronexpression)
) : builder.WithSimpleSchedule(x => x.WithIntervalInMinutes(string.IsNullOrEmpty(trigger.repeat_interval) ? 30 : int.Parse(trigger.repeat_interval)).WithRepeatCount(string.IsNullOrEmpty(trigger.repeat_count) ? 10 : int.Parse(trigger.repeat_count)));
if (forJob != null)
{
builder.ForJob(forJob);
}
return(builder.Build());
}
public void Init()
{
try
{
string devHotName = ConfigurationManager.AppSettings["DEVHOSTNAME"];//开发计算机
string hostName = HelperEnvironmentSetting.GetHostName();
string appName = ConfigurationManager.AppSettings["APPNAME"];
if (string.IsNullOrEmpty(appName))
{
appName = AppDomain.CurrentDomain.FriendlyName.Replace(".vshost", "");
}
string responservername = null;
string responservernameBydev = null;
responservername = hostName + "&" + appName;
responservernameBydev = devHotName + "&" + appName;
System.Console.WriteLine("responservername：" + responservername);
System.Console.WriteLine("devHotName：" + responservername);
List <JobEntity> jobEntityList = new List <JobEntity>();
using (IDbConnection dbConn = HelperConnection.GetConnectionFactory().OpenDbConnection())
{
SqlExpression <JobEntity> expression = dbConn.From <JobEntity>();
expression.And(x => x.STATE == "1");//加载启用状态的定时器
if (devHotName == hostName)
{
expression.And(x => x.RESPONSESVRNAMEBYDEV == responservernameBydev);
}
else
{
expression.And(x => x.RESPONSESVRNAME == responservername);
}
jobEntityList = dbConn.Select <JobEntity>(expression).OrderBy <JobEntity, int>((Func <JobEntity, int>)(x => x.JOBID)).ToList <JobEntity>();
if (jobEntityList == null || jobEntityList.Count == 0)
{
this.logger.Info((object)"启动定时服务失败，未查询到相关数据！");
}
else
{
this.logger.Info((object)(responservername + ",加载" + jobEntityList.Count.ToString() + "个JOB"));
this.scheduler = this.schedulerFactory.GetScheduler();
this.scheduler.Clear();
foreach (JobEntity jobEntity in jobEntityList)
{
Type type = Type.GetType(jobEntity.CLASSFULLNAME);
if (type == (Type)null)
{
this.logger.Info((object)("无法获取：" + jobEntity.CLASSFULLNAME));
}
else
{
int jobid = jobEntity.JOBID;
IJobDetail jobDetail = (IJobDetail) new JobDetailImpl(jobid.ToString() + "-" + jobEntity.JOBDESC, "CIMS.Server", type, true, true);
TriggerBuilder triggerBuilder = TriggerBuilder.Create();
jobid = jobEntity.JOBID;
string key = jobid.ToString() + "-" + jobEntity.JOBTRIGGER;
ITrigger trigger = triggerBuilder.WithIdentity(key).WithCronSchedule(jobEntity.JOBTRIGGERPARA).Build();
jobDetail.JobDataMap.Put("BASE_JOB", (object)jobEntity);
jobDetail.JobDataMap.Put("JobKey", jobEntity.JOBID);
JobDataMap jobDataMap = jobDetail.JobDataMap;
jobid = jobEntity.JOBID;
string str2 = jobid.ToString() + "-" + jobEntity.JOBTRIGGER;
jobDataMap.Put("TriggerKey", str2);
this.scheduler.ScheduleJob(jobDetail, trigger);
logger.Info(jobEntity.JOBID + "创建成功！");
}
}
this.logger.Info((object)(responservername + ",启动了" + jobEntityList.Count.ToString() + "个JOB"));
this.scheduler.Start();
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
this.logger.Info((object)ex.ToString());
this.logger.Error((object)ex.ToString());
}
}
private static void ScheduleJobs()
{
int priority = Jobs.Count;
foreach (var tsk in Jobs.Where(x => x.TaskType == "S" && x.Status == "Queued")) // O - On Demand ; S- Scheduled.
{
var schedule = Schedules.FirstOrDefault(x => x.taskID == tsk.taskID);
var client = Machines.FirstOrDefault(x => x.ID == tsk.ClientID);
IJobDetail job = JobBuilder.Create <Job>().WithIdentity(tsk.TaskName, tsk.ClientID.ToString()).Build();
job.JobDataMap["command"] = tsk.Command;
job.JobDataMap["taskname"] = tsk.TaskName;
job.JobDataMap["TaskId"] = tsk.taskID;
if (client != null)
{
job.JobDataMap["remotepc"] = "\\\\" + client.HostName;
job.JobDataMap["username"] = client.Username;
job.JobDataMap["password"] = client.Password;
}
if (schedule != null)
{
TriggerBuilder tb = TriggerBuilder.Create();
tb.WithIdentity(tsk.TaskName);
if (schedule.repeatforever <= 0)
{
tb.WithSimpleSchedule(a => a.WithIntervalInHours(schedule.intHours));
tb.WithSimpleSchedule(a => a.WithIntervalInSeconds(schedule.intSec));
tb.WithSimpleSchedule(a => a.WithIntervalInMinutes(schedule.intMin));
}
else
{
if (schedule.intHours > 0)
{
tb.WithSimpleSchedule(a => a.WithIntervalInHours(schedule.intHours).RepeatForever());
}
if (schedule.intHours > 0)
{
tb.WithSimpleSchedule(a => a.WithIntervalInSeconds(schedule.intSec).RepeatForever());
}
if (schedule.intHours > 0)
{
tb.WithSimpleSchedule(a => a.WithIntervalInMinutes(schedule.intMin).RepeatForever());
}
}
if (schedule.startAt != null)
{
tb.StartAt(new DateTimeOffset((DateTime)schedule.startAt));
}
if (schedule.endAt != null)
{
tb.EndAt(new DateTimeOffset((DateTime)schedule.endAt));
}
tb.ForJob(job);
ITrigger trigger = tb.Build();
Scheduler.ScheduleJob(job, trigger);
}
}
}
internal TriggerHelper WithIdentity(string name, string group)
{
trigger.WithIdentity(name, group);
return(this);
}
