/// <summary>
        /// 停止任务调度
        /// </summary>
        /// <returns></returns>
        public async Task <JobResuleModel> StopScheduleAsync()
        {
            var result = new JobResuleModel();

            try
            {
                if (!this._scheduler.Result.IsShutdown)
                {
                    //等待任务运行完成
                    await this._scheduler.Result.Shutdown();

                    await Console.Out.WriteLineAsync("任务调度停止!");

                    result.IsSuccess = true;
                    result.Message   = $"任务调度停止成功";
                    return(result);
                }
                else
                {
                    result.IsSuccess = false;
                    result.Message   = $"任务调度已经停止";
                    return(result);
                }
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 暂停一个指定的计划任务
        /// </summary>
        /// <returns></returns>
        public async Task <JobResuleModel> StopScheduleJobAsync(SysSchedule sysSchedule)
        {
            var result = new JobResuleModel();

            try
            {
                JobKey jobKey = new JobKey(sysSchedule.Id.ToString(), sysSchedule.JobGroup);
                if (!await _scheduler.Result.CheckExists(jobKey))
                {
                    result.IsSuccess = false;
                    result.Message   = $"未找到要暂停的任务:【{sysSchedule.Name}】";
                    return(result);
                }
                else
                {
                    await this._scheduler.Result.PauseJob(jobKey);

                    result.IsSuccess = true;
                    result.Message   = $"暂停任务:【{sysSchedule.Name}】成功";
                    return(result);
                }
            }
            catch (Exception)
            {
                throw;
            }
        }
Ejemplo n.º 3
0
        /// <summary>
        /// 开启任务调度
        /// </summary>
        /// <returns></returns>
        public async Task <JobResuleModel> StartScheduleAsync()
        {
            var result = new JobResuleModel();

            try
            {
                this._scheduler.Result.JobFactory = this._iocjobFactory;
                if (!this._scheduler.Result.IsStarted)
                {
                    //等待任务运行完成
                    await this._scheduler.Result.Start();

                    await Console.Out.WriteLineAsync("任务调度开启!");

                    result.IsSuccess = true;
                    result.Message   = $"任务调度开启成功";
                    return(result);
                }
                else
                {
                    result.IsSuccess = false;
                    result.Message   = $"任务调度已经开启";
                    return(result);
                }
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 恢复指定的计划任务
        /// </summary>
        /// <param name="sysSchedule"></param>
        /// <returns></returns>
        public async Task <JobResuleModel> ResumeJob(SysSchedule sysSchedule)
        {
            var result = new JobResuleModel();

            try
            {
                JobKey jobKey = new JobKey(sysSchedule.Id.ToString(), sysSchedule.JobGroup);
                if (!await _scheduler.Result.CheckExists(jobKey))
                {
                    result.IsSuccess = false;
                    result.Message   = $"未找到要重新的任务:【{sysSchedule.Name}】,请先选择添加计划!";
                    return(result);
                }
                await this._scheduler.Result.ResumeJob(jobKey);

                result.IsSuccess = true;
                result.Message   = $"恢复计划任务:【{sysSchedule.Name}】成功";
                return(result);
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 添加一个计划任务(映射程序集指定IJob实现类)
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="sysSchedule"></param>
        /// <returns></returns>
        public async Task <JobResuleModel> AddScheduleJobAsync(SysSchedule sysSchedule)
        {
            var result = new JobResuleModel();

            try
            {
                if (sysSchedule != null)
                {
                    JobKey jobKey = new JobKey(sysSchedule.Id.ToString(), sysSchedule.JobGroup);
                    if (await _scheduler.Result.CheckExists(jobKey))
                    {
                        result.IsSuccess = false;
                        result.Message   = $"该任务计划已经在执行:【{sysSchedule.Name}】,请勿重复启动!";
                        return(result);
                    }
                    #region 设置开始时间和结束时间

                    if (sysSchedule.BeginTime == null)
                    {
                        sysSchedule.BeginTime = DateTime.Now;
                    }
                    DateTimeOffset starRunTime = DateBuilder.NextGivenSecondDate(sysSchedule.BeginTime, 1);//设置开始时间
                    if (sysSchedule.EndTime == null)
                    {
                        sysSchedule.EndTime = DateTime.MaxValue.AddDays(-1);
                    }
                    DateTimeOffset endRunTime = DateBuilder.NextGivenSecondDate(sysSchedule.EndTime, 1);//设置暂停时间

                    #endregion

                    #region 通过反射获取程序集类型和类

                    Assembly assembly = Assembly.Load(new AssemblyName(sysSchedule.AssemblyName));
                    Type     jobType  = assembly.GetType(sysSchedule.AssemblyName + "." + sysSchedule.ClassName);

                    #endregion
                    //判断任务调度是否开启
                    if (!_scheduler.Result.IsStarted)
                    {
                        await StartScheduleAsync();
                    }

                    //传入反射出来的执行程序集
                    IJobDetail job = new JobDetailImpl(sysSchedule.Id.ToString(), sysSchedule.JobGroup, jobType);
                    //Job执行时的参数还有待解决?????????????????????
                    ITrigger trigger;

                    #region 泛型传递
                    //IJobDetail job = JobBuilder.Create<T>()
                    //    .WithIdentity(sysSchedule.Name, sysSchedule.JobGroup)
                    //    .Build();
                    #endregion

                    if (!sysSchedule.Cron.IsNullOrEmpty() && CronExpression.IsValidExpression(sysSchedule.Cron) && sysSchedule.TriggerType > 0)
                    {
                        trigger = CreateCronTrigger(sysSchedule);
                    }
                    else
                    {
                        trigger = CreateSimpleTrigger(sysSchedule);
                    }
                    // 告诉Quartz使用我们的触发器来安排作业
                    await _scheduler.Result.ScheduleJob(job, trigger);

                    //await Task.Delay(TimeSpan.FromSeconds(120));
                    //await Console.Out.WriteLineAsync("关闭了调度器!");
                    //await _scheduler.Result.Shutdown();
                    result.IsSuccess = true;
                    result.Message   = $"启动任务:【{sysSchedule.Name}】成功";
                    return(result);
                }
                else
                {
                    result.IsSuccess = false;
                    result.Message   = $"任务计划不存在:【{sysSchedule.Name}】";
                    return(result);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }