private static async Task DoJobEvery5Minutes <T>(string jobName, string triggerName, string groupName) where T : IJob
{
try
{
// Grab the Scheduler instance from the Factory
var factory = new StdSchedulerFactory(new NameValueCollection
{
{ "quartz.serializer.type", "binary" }
});
var scheduler = await factory.GetScheduler();
// and start it off
await scheduler.Start();
// define the job and tie it to our HelloJob class
var job = JobBuilder.CreateForAsync <T>().WithIdentity(jobName, groupName).Build();
// Trigger the job to run now, and then repeat every 10 seconds
var trigger = TriggerBuilder.Create().WithIdentity(triggerName, groupName).WithCronSchedule("0 0/2 * * * ?").Build();
// Tell quartz to schedule the job using our trigger
await scheduler.ScheduleJob(job, trigger);
// some sleep to show what's happening
// await Task.Delay(TimeSpan.FromSeconds(10));
// and last shut down the scheduler when you are ready to close your program
// await scheduler.Shutdown();
}
catch (System.Exception ex)
{
_log.Error(ex);
}
}
/// <summary>
/// 添加任务指定实现IJob接口的类
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="quartz"></param>
/// <returns></returns>
public async Task <String> AddJob <T>(QuartzMap quartz) where T : IJob
{
try
{
await Instance.Result.Start();
JobKey key = new JobKey(quartz.JobName, quartz.JobGroup);
//任务存在则先删除
if (await Instance.Result.CheckExists(key))
{
await Instance.Result.DeleteJob(key);
}
IJobDetail job = JobBuilder.CreateForAsync <T>().WithIdentity(quartz.JobName, quartz.JobGroup).Build();
if (!string.IsNullOrEmpty(quartz.Cron) && CronExpression.IsValidExpression(quartz.Cron))
{
await Instance.Result.ScheduleJob(job, CreateCronTrigger(quartz));
}
else
{
await Instance.Result.ScheduleJob(job, CreateSimpleTrigger(quartz));
}
return("添加任务成功!");
}
catch (Exception)
{
throw new Exception("添加任务出错!");
}
}
private async Task <SchedulingResult> ScheduleScramblingJob <JobType>(string jobName, string jobGroup, string triggerDescription,
string cronExpression, string description, DatabasesConfig jobConfig)
where JobType : IJob
{
if (!CronExpression.IsValidExpression(cronExpression))
{
return(new SchedulingResult {
IsSuccessful = false, ErrorMessage = "The cron expression is invalid."
});
}
var jobDetail = _scheduler.GetJobDetail(new JobKey(jobName, jobGroup));
if (_scheduler.GetJobDetail(new JobKey(jobName, jobGroup)).Status != TaskStatus.WaitingForActivation)
{
return(new SchedulingResult {
IsSuccessful = false, ErrorMessage = "The jobname is already taken."
});
}
var job = JobBuilder.CreateForAsync <JobType>()
.WithIdentity(jobName, jobGroup)
.UsingJobData("configStr", JsonConvert.SerializeObject(jobConfig))
.WithDescription(description)
.RequestRecovery()
.Build();
var trigger = (ICronTrigger)TriggerBuilder.Create()
.WithDescription(triggerDescription)
.WithCronSchedule(cronExpression)
.Build();
//Console.WriteLine($"Trigger before: name: {trigger.Key.Name} group: {trigger.Key.Group}" );
try
{
await _scheduler.ScheduleJob(job, trigger);
//Console.WriteLine($"Trigger after: name: {trigger.Key.Name} group: {trigger.Key.Group}");
}
catch (ObjectAlreadyExistsException ex)
{
return(new SchedulingResult
{
IsSuccessful = false,
ErrorMessage = ex.Message
});
}
catch (JobPersistenceException ex)
{
return(new SchedulingResult
{
IsSuccessful = false,
ErrorMessage = ex.Message
});
}
return(new SchedulingResult {
IsSuccessful = true, JobKey = job.Key, TriggerKey = trigger.Key
});
}
/// <summary>
/// 添加一个工作调度
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public async Task <ApiResult <string> > AddScheduleJobAsync(ScheduleEntity entity)
{
var result = new ApiResult <string>()
{
statusCode = (int)ApiEnum.Error
};
try
{
//检查任务是否已存在
var jobKey = new JobKey(entity.JobName, entity.JobGroup);
if (await Scheduler.CheckExists(jobKey))
{
result.message = "任务已存在";
return(result);
}
//http请求配置
var httpDir = new Dictionary <string, string>()
{
{ "RequestUrl", entity.RequestUrl },
{ "RequestParameters", entity.RequestParameters },
{ "RequestType", ((int)entity.RequestType).ToString() },
{ Constant.HEADERS, entity.Headers },
{ Constant.MAILMESSAGE, ((int)entity.MailMessage).ToString() },
};
// 定义这个工作，并将其绑定到我们的IJob实现类
IJobDetail job = JobBuilder.CreateForAsync <HttpJob>()
.SetJobData(new JobDataMap(httpDir))
.WithDescription(entity.Description)
.WithIdentity(entity.JobName, entity.JobGroup)
.Build();
// 创建触发器
ITrigger trigger;
//校验是否正确的执行周期表达式
if (entity.TriggerType == TriggerTypeEnum.Cron)//CronExpression.IsValidExpression(entity.Cron))
{
trigger = CreateCronTrigger(entity);
}
else
{
trigger = CreateSimpleTrigger(entity);
}
// 告诉Quartz使用我们的触发器来安排作业
await Scheduler.ScheduleJob(job, trigger);
//判断是否暂停的任务
if (entity.TriggerState == TriggerState.Paused)
{
await Scheduler.PauseJob(new JobKey(entity.JobGroup, entity.JobName));
}
result.statusCode = (int)ApiEnum.Status;
}
catch (Exception ex)
{
result.message = ex.Message;
}
return(result);
}
private static IJobDetail CreateJobDetail <T>(QuartzOption QuartzOptions) where T : IJob
{
IJobDetail jobDetail = JobBuilder.CreateForAsync <T>().WithIdentity(QuartzOptions.TaskName, QuartzOptions.GroupName).Build();
if (QuartzOptions.TaskData != null)
{
jobDetail.JobDataMap.Add(typeof(T).Name, QuartzOptions.TaskData);
}
return(jobDetail);
}
/// <summary>
/// 添加一个工作调度
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public async Task <ResultValue> AddScheduleHttpJobAsync(ScheduleEntity entity)
{
var result = new ResultValue();
try
{
//检查任务是否已存在
var jobKey = new JobKey(entity.JobName, entity.JobGroup);
if (await Scheduler.CheckExists(jobKey))
{
result.MsgCode = 3;
result.Msg = "任务已存在";
return(result);
}
//http请求配置
var httpDir = new Dictionary <string, string>()
{
{ Constant.REQUESTURL, entity.RequestUrl },
{ Constant.TARGETTYPE, entity.TargetType },
{ Constant.REQUESTPARAMETERS, entity.RequestParameters },
{ Constant.REQUESTTYPE, ((int)entity.RequestType).ToString() },
{ Constant.HEADERS, entity.Headers },
{ Constant.MAILMESSAGE, ((int)entity.MailMessage).ToString() },
};
// 定义这个工作，并将其绑定到我们的IJob实现类
IJobDetail job = JobBuilder.CreateForAsync <HttpJob>()
.SetJobData(new JobDataMap(httpDir))
.WithDescription(entity.Description)
.WithIdentity(entity.JobName, entity.JobGroup)
.Build();
// 创建触发器
ITrigger trigger;
//校验是否正确的执行周期表达式
if (entity.TriggerType == TriggerTypeEnum.Cron || entity.TriggerType == TriggerTypeEnum.None)//CronExpression.IsValidExpression(entity.Cron))
{
trigger = CreateCronTrigger(entity);
}
else
{
trigger = CreateSimpleTrigger(entity);
}
// 告诉Quartz使用我们的触发器来安排作业
await Scheduler.ScheduleJob(job, trigger);
result.MsgCode = 1;
result.Msg = "添加成功";
}
catch (Exception ex)
{
result.MsgCode = 3;
result.Msg = ex.Message;
}
return(result);
}
public virtual async Task Run()
{
ILog log = LogProvider.GetLogger(typeof(AsyncExample));
var properties = new NameValueCollection
{
["quartz.serializer.type"] = "json"
};
ISchedulerFactory sf = new StdSchedulerFactory(properties);
IScheduler sched = await sf.GetScheduler();
log.Info("------- Initialization Complete -----------");
log.Info("------- Scheduling Jobs -------------------");
IJobDetail job = JobBuilder
.CreateForAsync <AsyncJob>()
.WithIdentity("asyncJob")
.Build();
ITrigger trigger = TriggerBuilder.Create()
.WithIdentity("triggerForAsyncJob")
.StartAt(DateTimeOffset.UtcNow.AddSeconds(1))
.WithSimpleSchedule(x => x.WithIntervalInSeconds(20).RepeatForever())
.Build();
await sched.ScheduleJob(job, trigger);
log.Info("------- Starting Scheduler ----------------");
// start the schedule
await sched.Start();
log.Info("------- Started Scheduler -----------------");
await Task.Delay(TimeSpan.FromSeconds(5));
log.Info("------- Cancelling job via scheduler.Interrupt() -----------------");
await sched.Interrupt(job.Key);
log.Info("------- Waiting five minutes... -----------");
// wait five minutes to give our job a chance to run
await Task.Delay(TimeSpan.FromMinutes(5));
// shut down the scheduler
log.Info("------- Shutting Down ---------------------");
await sched.Shutdown(true);
log.Info("------- Shutdown Complete -----------------");
}
/// <summary>
/// 添加一个工作调度
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public async Task <BaseResult> AddScheduleJobAsync(ScheduleEntity entity)
{
var result = new BaseResult();
try
{
//检查任务是否已存在
var jobKey = new JobKey(entity.JobName, entity.JobGroup);
if (await Scheduler.CheckExists(jobKey))
{
result.Code = 500;
result.Msg = "任务已存在";
return(result);
}
//http请求配置
var httpDir = new Dictionary <string, string>()
{
{ "RequestUrl", entity.RequestUrl },
{ "RequestParameters", entity.RequestParameters },
{ "RequestType", ((int)entity.RequestType).ToString() },
};
// 定义这个工作，并将其绑定到我们的IJob实现类
IJobDetail job = JobBuilder.CreateForAsync <HttpJob>()
.SetJobData(new JobDataMap(httpDir))
.WithDescription(entity.Description)
.WithIdentity(entity.JobName, entity.JobGroup)
.Build();
// 创建触发器
ITrigger trigger;
//校验是否正确的执行周期表达式
if (entity.TriggerType == TriggerTypeEnum.Cron)//CronExpression.IsValidExpression(entity.Cron))
{
trigger = CreateCronTrigger(entity);
}
else
{
trigger = CreateSimpleTrigger(entity);
}
// 告诉Quartz使用我们的触发器来安排作业
await Scheduler.ScheduleJob(job, trigger);
result.Code = 200;
}
catch (Exception ex)
{
result.Code = 505;
result.Msg = ex.Message;
}
return(result);
}
/// <summary>
/// 添加任务调度（指定IJob实现类）
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="m"></param>
/// <returns></returns>
public async Task <BaseResult> AddScheduleJobAsync <T>(ScheduleEntity entity) where T : IJob
{
var result = new BaseResult();
try
{
//检查任务是否已存在
var jobKey = new JobKey(entity.JobName, entity.JobGroup);
if (await Scheduler.CheckExists(jobKey))
{
//删除已经存在任务
await this.Scheduler.DeleteJob(jobKey);
}
//http请求配置
var jobData = new JobDataMap();
jobData.Add("RequestUrl", entity.RequestUrl);
// 定义这个工作，并将其绑定到我们的IJob实现类
IJobDetail job = JobBuilder.CreateForAsync <T>()
.SetJobData(jobData)
.WithDescription(entity.Description)
.WithIdentity(entity.JobName, entity.JobGroup)
.Build();
// 创建触发器
ITrigger trigger;
//校验是否正确的执行周期表达式
if (!string.IsNullOrEmpty(entity.Cron) && CronExpression.IsValidExpression(entity.Cron))
{
trigger = CreateCronTrigger(entity);
}
else
{
trigger = CreateSimpleTrigger(entity);
}
// 告诉Quartz使用我们的触发器来安排作业
await Scheduler.ScheduleJob(job, trigger);
result.Code = MsgCode.Success;
result.Msg = "计划任务添加成功";
}
catch (Exception ex)
{
await Console.Out.WriteLineAsync(string.Format("添加任务出错", ex.Message));
result.Code = MsgCode.Unknow;
result.Msg = ex.Message;
}
return(result);
}
/// <summary>
/// 添加任务调度（指定IJob实现类）
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="m"></param>
/// <returns></returns>
private async Task <BaseQuartzNetResult> AddScheduleJob <T>(ScheduleEntity m) where T : IJob
{
var result = new BaseQuartzNetResult()
{
Code = -1, Msg = ""
};
try
{
//检查任务是否已存在
var jk = new JobKey(m.JobName, m.JobGroup);
if (await(await Scheduler()).CheckExists(jk))
{
//删除已经存在任务
await(await Scheduler()).DeleteJob(jk);
ScheduleList.Remove(m.Id, out ScheduleEntity value);
}
// 定义这个工作，并将其绑定到我们的IJob实现类
IJobDetail job = JobBuilder.CreateForAsync <T>().WithIdentity(m.JobName, m.JobGroup).Build();
// 创建触发器
ITrigger trigger;
//校验是否正确的执行周期表达式
if (!string.IsNullOrEmpty(m.Cron) && CronExpression.IsValidExpression(m.Cron))
{
trigger = CreateCronTrigger(m);
}
else
{
trigger = CreateSimpleTrigger(m);
}
// 设置监听器
JobListener listener = new JobListener();
// IMatcher<JobKey> matcher = KeyMatcher<JobKey>.KeyEquals(job.Key);
(await Scheduler()).ListenerManager.AddJobListener(listener, GroupMatcher <JobKey> .AnyGroup());
// 告诉Quartz使用我们的触发器来安排作业
await(await Scheduler()).ScheduleJob(job, trigger);
ScheduleList.GetOrAdd(m.Id, m);
result.Code = 200;
}
catch (Exception ex)
{
await Console.Out.WriteLineAsync(string.Format("添加任务出错", ex.Message));
result.Code = 1001;
result.Msg = ex.Message;
}
return(result);
}
/// <summary>
/// 添加一个工作调度
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public async Task <HttpResponseModel> AddScheduleJobAsync(ScheduleModel model)
{
var result = new HttpResponseModel();
try
{
//检查任务是否已存在
var jobKey = new JobKey(model.JobName, model.JobGroup);
if (await Scheduler.CheckExists(jobKey))
{
result.Code = HttpStatusCode.OK;
result.Message = "任务已存在";
return(result);
}
//http请求配置
var setting = new Dictionary <string, string>()
{
{ Constant.CmdPath, model.CmdPath.ToString() },
{ Constant.IsExcuteCmd, model.IsExcuteCmd.ToString() },
{ Constant.RequestUrl, model.RequestUrl },
{ Constant.RequestParameters, model.RequestParameters },
{ Constant.RequestType, ((int)model.RequestType).ToString() },
{ Constant.Headers, model.Headers },
{ Constant.MailMessage, ((int)model.MailMessage).ToString() },
};
// 定义这个工作，并将其绑定到我们的IJob实现类
var job = JobBuilder.CreateForAsync <ExcuteJob>()
.SetJobData(new JobDataMap(setting))
.WithDescription(model.Description)
.WithIdentity(model.JobName, model.JobGroup)
.Build();
var trigger = model.TriggerType == TriggerTypeEnum.Cron ? CreateCronTrigger(model) : CreateSimpleTrigger(model);
await Scheduler.ScheduleJob(job, trigger);
result.Code = HttpStatusCode.OK;
}
catch (Exception ex)
{
result.Code = HttpStatusCode.InternalServerError;
result.Message = ex.Message + Environment.NewLine + ex.StackTrace;
}
return(result);
}
public Task StartJob(IScheduler scheduler)
{
//use JobBuilder to Create a jobDetail
var jobDetails = JobBuilder
.CreateForAsync <FireForgetJob>()
.WithIdentity("FireForgetJob")
.WithDescription("My First Fire and Forget job")
.Build();
//use TriggerBuilder to create a Trigger
var trigger = TriggerBuilder
.Create()
.StartNow()
.Build();
//call the scheduler.ScheduleJob
return(scheduler.ScheduleJob(jobDetails, trigger));
}
public Task StartJob(IScheduler scheduler)
{
//use JobBuilder to Create a jobDetail
var jobDetails = JobBuilder
.CreateForAsync <DelayJob>()
.WithIdentity("DelayJob")
.WithDescription("My First Delay job")
.Build();
//use TriggerBuilder to create a Trigger
var trigger = TriggerBuilder
.Create()
.StartAt(DateTimeOffset.Now.AddSeconds(5))// start a job after 5 seconds
.Build();
//call the scheduler.ScheduleJob
return(scheduler.ScheduleJob(jobDetails, trigger));
}
/// <summary>
/// 添加任务调度（指定IJob实现类）
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="m"></param>
/// <returns></returns>
private async Task <BaseQuartzNetResult> AddScheduleJob <T>(ScheduleEntity m) where T : IJob
{
var result = new BaseQuartzNetResult();
try
{
//检查任务是否已存在
var jk = new JobKey(m.JobName, m.JobGroup);
if (await this.Scheduler.Result.CheckExists(jk))
{
//删除已经存在任务
await this.Scheduler.Result.DeleteJob(jk);
}
//反射获取任务执行类
// var jobType = FileHelper.GetAbsolutePath(m.AssemblyName, m.AssemblyName + "." + m.ClassName);
// 定义这个工作，并将其绑定到我们的IJob实现类
//IJobDetail job = new JobDetailImpl(m.JobName, m.JobGroup, jobType);
IJobDetail job = JobBuilder.CreateForAsync <T>().WithIdentity(m.JobName, m.JobGroup).Build();
// 创建触发器
ITrigger trigger;
//校验是否正确的执行周期表达式
if (!string.IsNullOrEmpty(m.Cron) && CronExpression.IsValidExpression(m.Cron))
{
trigger = CreateCronTrigger(m);
}
else
{
trigger = CreateSimpleTrigger(m);
}
// 告诉Quartz使用我们的触发器来安排作业
await this.Scheduler.Result.ScheduleJob(job, trigger);
result.Code = 1000;
}
catch (Exception ex)
{
await Console.Out.WriteLineAsync(string.Format("添加任务出错", ex.Message));
result.Code = 1001;
result.Msg = ex.Message;
}
return(result);
}
private async Task <BaseResult> AddScheduleJobAsync(TaskScheduleModel entity)
{
var result = new BaseResult();
try
{
if (await this.scheduler.CheckExists(entity.JobKey))
{
result.Code = 500;
result.Msg = "任务已存在";
return(result);
}
var map = new Dictionary <string, string>()
{
{ nameof(Constant.RequestUrl), entity.Url },
{ nameof(Constant.RequestParameters), entity.Parameters },
{ nameof(Constant.RequestType), entity.HttpMethod.ToString() },
{ Constant.Headers, "" },
{ Constant.MailMessage, entity.Id.ToString() },
};
IJobDetail job = JobBuilder.CreateForAsync <HttpJob>()
.SetJobData(new JobDataMap(map))
.WithDescription(entity.Description)
.WithIdentity(entity.Name, entity.Group)
.Build();
ITrigger trigger = this.CreateTrigger(entity);
await this.scheduler.ScheduleJob(job, trigger);
result.Code = 200;
}
catch (Exception ex)
{
result.Code = 505;
result.Msg = ex.Message;
}
return(result);
}
public Task StartJob(IScheduler scheduler)
{
//use JobBuilder to Create a jobDetail
var jobDetails = JobBuilder
.CreateForAsync <RecurringJob>()
.WithIdentity("RecurringJob")
.WithDescription("My First Recurring job")
.Build();
//use TriggerBuilder to create a Trigger
var trigger = TriggerBuilder
.Create()
.StartNow()
.WithSimpleSchedule(builder =>
builder.WithIntervalInSeconds(3)// start a job every 3 seconds
.RepeatForever()
)
.Build();
//call the scheduler.ScheduleJob
return(scheduler.ScheduleJob(jobDetails, trigger));
}
public bool Start(HostControl hostControl)
{
_logger.LogWarning("SchedulerService started.");
_scheduler.Start().ConfigureAwait(false).GetAwaiter().GetResult();
// define the job and tie it to our HelloJob class
IJobDetail job = JobBuilder.CreateForAsync <FootballImportJob>()
.WithIdentity("job1", "group1")
.Build();
// Trigger the job to run now, and then repeat every 10 seconds
ITrigger trigger = TriggerBuilder.Create()
.WithIdentity("trigger1", "group1")
.StartNow()
.WithSimpleSchedule(x => x
.WithIntervalInHours(importFootballDataIntervalInHours)
.RepeatForever())
.Build();
_scheduler.ScheduleJob(job, trigger).ConfigureAwait(false).GetAwaiter().GetResult();
return(true);
}
static async Task Main(string[] args)
{
var scheduler = await StdSchedulerFactory.GetDefaultScheduler();
await scheduler.Start();
var job = JobBuilder
.CreateForAsync <WanikaniStatsJob>()
.Build();
var trigger = TriggerBuilder
.Create()
//.StartNow()
.StartAt(DateTime.UtcNow.Date.AddDays(1))
.WithSimpleSchedule(builder =>
builder
.WithIntervalInHours(24)
.RepeatForever())
.Build();
await scheduler.ScheduleJob(job, trigger);
await Task.Delay(-1);
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
var scheduler = await _factory.GetScheduler(stoppingToken);
scheduler.JobFactory = _jobFactory;
var helloJob = JobBuilder.CreateForAsync <HelloJob>()
.WithIdentity(nameof(HelloJob))
.Build();
var trigger = TriggerBuilder.Create()
.WithIdentity("EveryMinuteTrigger")
//.StartNow()
.WithCronSchedule("0/5 * * * * ?")
//.WithSimpleSchedule(builder => builder.WithIntervalInSeconds(5)
// .RepeatForever())
.Build();
await scheduler.ScheduleJob(helloJob, trigger, stoppingToken);
await scheduler.Start(stoppingToken);
await Task.Delay(Timeout.Infinite, stoppingToken);
}
/// <summary>
/// 添加一个任务
/// </summary>
/// <returns></returns>
public async Task <ApiResult <string> > Add(ScheduleEntity entity)
{
var result = new ApiResult <string>()
{
statusCode = (int)ApiEnum.Error
};
try
{
//检查任务是否已存在
var jobKey = new JobKey(entity.JobName, entity.JobGroup);
if (await Scheduler.CheckExists(jobKey))
{
result.message = "任务已存在";
return(result);
}
//http请求配置
var httpDir = new Dictionary <string, string>()
{
{ "RequestUrl", entity.RequestUrl },
{ "RequestParameters", entity.RequestParameters },
{ "RequestType", ((int)entity.RequestType).ToString() },
{ Constant.HEADERS, entity.Headers },
{ Constant.MAILMESSAGE, ((int)entity.MailMessage).ToString() },
};
// 定义这个工作，并将其绑定到我们的IJob实现类
IJobDetail job = JobBuilder.CreateForAsync <HttpJob>()
.SetJobData(new JobDataMap(httpDir))
.WithDescription(entity.Description)
.WithIdentity(entity.JobName, entity.JobGroup)
.Build();
// 创建触发器
ITrigger trigger;
//校验是否正确的执行周期表达式
if (entity.TriggerType == TriggerTypeEnum.Cron)//CronExpression.IsValidExpression(entity.Cron))
{
trigger = CreateCronTrigger(entity);
}
else
{
trigger = CreateSimpleTrigger(entity);
}
// 告诉Quartz使用我们的触发器来安排作业
await Scheduler.ScheduleJob(job, trigger);
//将作业增加到Redis里面
var redisTask = RedisHelper.Get <List <ScheduleEntity> >(KeyHelper.TaskSchedulerList);
if (redisTask == null)
{
//实例数组
redisTask = new List <ScheduleEntity>();
}
if (!redisTask.Any(m => m.JobId == entity.JobId))
{
entity.JobId = Utils.GetOrderNumber();
redisTask.Add(entity);
//保存到Redis中
RedisHelper.Set(KeyHelper.TaskSchedulerList, redisTask);
}
result.statusCode = (int)ApiEnum.Status;
}
catch (Exception ex)
{
result.message = ex.Message;
}
return(result);
}
