serverHelper/ServiceHelper/TaskControl.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Win32.TaskScheduler;
using System.IO;

namespace ServiceHelper
{
    /// <summary>
    /// 计划任务处理类
    /// </summary>
    public static class TaskControl
    {
        //触发时间
        private static short _daysInterval;
        //触发间隔
        private static string _startBoundary;
        private const string STOP = "sc stop Aca.Certain.MiddleService";
        private const string START = "sc start Aca.Certain.MiddleService";
        /// <summary>
        /// 设置计划任务
        /// </summary>
        /// <param name="daysInterval">触发间隔</param>
        /// <param name="startBoundary">触发时间</param>
        public static bool SetTask(short daysInterval, string startBoundary)
        {
            _daysInterval = daysInterval;
            _startBoundary = startBoundary;
            TaskService taskService = new TaskService();
            Task t = taskService.GetTask(@"Aca.Certain.MiddleServiceRestart");
            if (t == null)
            {
                return CreateTask(taskService);
            }
            else
            {
                return ChangeTask(taskService);
            }
        }
        /// <summary>
        /// 创建计划任务
        /// </summary>
        /// <param name="taskService"></param>
        private static bool CreateTask(TaskService taskService)
        {
            if (CreatBat())
            {
                // 创建一个计划任务
                TaskDefinition taskDefinition = taskService.NewTask();
                //描述
                taskDefinition.RegistrationInfo.Description = "Aca.Certain.MiddleServiceRestart服务重启计划";
                //创建者
                taskDefinition.RegistrationInfo.Author = "CERTAIN";
                //设置最高权限
                taskDefinition.Principal.RunLevel = TaskRunLevel.Highest;
                //设置并行运行新实例
                taskDefinition.Settings.MultipleInstances = TaskInstancesPolicy.Parallel;
                //每天启动
                Trigger dailyTrigger = new DailyTrigger
                {
                    DaysInterval = _daysInterval
                };
                //限制计划任务每次执行时间不能超过1小时
                dailyTrigger.ExecutionTimeLimit = TimeSpan.FromHours(1);
                //启动时间
                dailyTrigger.StartBoundary = DateTime.Parse(_startBoundary);
                //全天重复执行
                //dt.Repetition.Duration = TimeSpan.FromHours(24);
                //每隔30分钟重复一次
                //dt.Repetition.Interval = TimeSpan.FromMinutes(30);
                //将触发器添加到计划任务td的触发器中
                taskDefinition.Triggers.Add(dailyTrigger);

                //创建一个执行操作
                var bat = new ExecAction(System.Environment.CurrentDirectory + "\\restart.bat", "", null);
                //添加执行操作到计划任务的操作中
                taskDefinition.Actions.Add(bat);

                //注册计划任务
                taskService.RootFolder.RegisterTaskDefinition(@"Aca.Certain.MiddleServiceRestart", taskDefinition);
                return true;
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// 修改计划任务
        /// </summary>
        /// <param name="taskService"></param>
        private static bool ChangeTask(TaskService taskService)
        {
            DeleteTestTask();
            return CreateTask(taskService);
        }
        /// <summary>
        /// 删除计划任务
        /// </summary>
        public static void DeleteTestTask()
        {
            TaskService ts = new TaskService();
            Task t = ts.GetTask(@"Aca.Certain.MiddleServiceRestart");
            if (t != null)
            {
                // 计划任务服务
                ts.RootFolder.DeleteTask("Aca.Certain.MiddleServiceRestart");
            }
        }

        /// <summary>
        /// 查询计划任务
        /// </summary>
        private static Dictionary<string,string> RetrieveTestTask()
        {
            Dictionary<string,string> dt=new Dictionary<string,string>();
            // 计划任务服务
            TaskService ts = new TaskService();
            Task t = ts.GetTask(@"DicomeServiceRestart");
            if (null != t)
            {
                Console.WriteLine("Task Name={0}", t.Name);
                Console.WriteLine("Task Execution Time={0}", t.LastRunTime);
                Console.WriteLine("Task Last Run Result={0}", t.LastTaskResult);
                Console.WriteLine("Task Next Execution Time={0}", t.NextRunTime);
                return dt;
            }
            else
            {
                return null;
            }
        }
        /// <summary>
        /// 创建重启服务bat文件
        /// </summary>
        /// <returns>创建成功返回true,失败返回false</returns>
        private static bool CreatBat()
        {
            FileStream fs = null;
            StreamReader sr = null;
            StreamWriter sw = null;
            try
            {
                fs = new FileStream(System.Environment.CurrentDirectory + "\\restart.bat", FileMode.OpenOrCreate);
                try
                {
                    sr = new StreamReader(fs);
                    string stop = sr.ReadLine();
                    if (STOP.Equals(stop))
                    {
                        string start = sr.ReadLine();
                        if (START.Equals(start))
                        {
                            if (string.IsNullOrEmpty(sr.ReadLine()))
                            {
                                //文件已存在并且数据正确，返回true
                                return true;
                            }
                        }
                    }
                    fs.SetLength(0);
                }
                catch (Exception)
                {
                    fs.SetLength(0);
                    try
                    {
                        sr.Close();
                    }
                    catch
                    {
                    }
                    //文件流打开失败，返回false
                    return false;
                    throw;
                }
                try
                {
                    sw = new StreamWriter(fs);
                    sw.WriteLine(STOP);
                    sw.WriteLine(START);
                }
                catch (Exception)
                {
                    //文件流打开失败，返回false
                    return false;
                    throw;
                }
                finally
                {
                    try
                    {
                        sw.Close();
                    }
                    catch
                    {
                    }
                    try
                    {
                        sr.Close();
                    }
                    catch
                    {
                    }
                    
                }
            }
            catch (Exception)
            {
                //文件流打开失败，返回false
                return false;
                throw;
            }
            finally
            {
                try
                {
                    fs.Close();
                }
                catch
                {
                }
            }
            return true;
        }
    }
}