使用C#开发计划任务调度服务

在系统运维中常常需要定期去跑一些计划任务，比如扫描服务器监控其性能、检查SQL Server作业是否正常、监控MQ队列是否存在堵塞现象等。如果使用Windows计划任务调度，一来管理起来就比较松散，二来如需更改计划任务的配置就必须登录到服务器上进行修改，造成很大的不便。因此笔者在实际工作中自行开发计划任务调度服务来处理这些任务，将调度周期、任务配置等经常需要修改的配置信息保存到数据库中，并开发一个前台界面进行维护和管理。

一、基本结构

计划任务调度服务使用插件的方式处理各类不同的计划任务，插件必须继承自服务框架提供的MonitorTask抽象类，并在数据库中注册任务名、调度周期等信息，这样就可以由该服务调度执行。为方便起见，要求任务名、插件的dll文件名、插件对象的类型名必须一致，各插件都放在同一个命名空间MonitorTask下。

在工作中，各类监控任务主要有3种配置：

1.调度周期，以xml形式保存在数据库中。

2.监控项，以键值对的方式保存在数据库中。

3.基本不会修改的一些个性化配置，以xml文件方式保存在插件同级目录下，名称与插件名一致。

二、插件的父类

所有插件都必须继承自MonitorTask抽象类，这里之所以使用抽象类而不使用接口是考虑到可以在这个抽象类中实现一些共性的东西，如参数配置的加载、错误日志的记录等。

   public abstract class MonitorTask
    {
        protected XElement _configElement;
        public List<Schedule> Schedules;
        protected List<MonitorSetting> MonitorSettings;
        private bool _isRunning = false;

        protected MonitorTask()
        {
            LoadParameters();
        }

        public void Execute()
        {
            try
            {
                if (CouldExecute())
                {
                    _isRunning = true;
                    ExecuteTask();
                    ExecuteLog();
                }
            }
            catch (Exception e)
            {
                new LogText(AppDomain.CurrentDomain.BaseDirectory + @"log.log").Write(GetType().Name + "插件执行异常", e.ToString());
            }
            finally
            {
                _isRunning = false;
            }
        }

        private bool CouldExecute()
        {
            if (_isRunning || Schedules == null)
            {
                return false;
            }
            foreach (var schedule in Schedules)
            {
                if (schedule.TimeUp())
                {
                    return true;
                }
            }
            return false;
        }

        protected abstract void ExecuteTask();

        private void ExecuteLog()
        {
            if (ConfigManagement.GetConfig().GetAppSetting("ExecuteLog") == "1")
            {
                new LogText(AppDomain.CurrentDomain.BaseDirectory + @"executelog.log").Write(GetType().Name + "插件执行完毕");
            }
        }

        protected void LoadParameters()
        {
            if (File.Exists(GetConfigFile()))
            {
                _configElement = XElement.Load(GetConfigFile());
                LoadXMLParameters();
            }
            LoadMonitorSettings();
        }

        private string GetConfigFile()
        {
            return AppDomain.CurrentDomain.BaseDirectory + GetType().Name + ".xml";
        }

        protected virtual void LoadXMLParameters()
        {
        }

        protected void LoadMonitorSettings()
        {
            MonitorSettings = new List<MonitorSetting>();
            string sql = "SELECT Name, Value FROM MonitorTaskSetting WHERE MonitorTaskID IN (SELECT ID FROM MonitorTask WHERE Name = '" + GetType().Name + "')";
            using (SqlDataReader reader = SqlAssist.Select("SOMP", sql))
            {
                while (reader.Read())
                {
                    MonitorSettings.Add(new MonitorSetting(reader.GetString(0), reader.GetString(1)));
                }
            }
        }
    }

在开发计划任务插件时只需要继承该类，并实现ExecuteTask方法就行了。在这里ConfigManagement.GetConfig().GetAppSetting(string name)、new LogText(string filename).Write(string value)以及SqlAssist.Select(string dbname, string sql)这三个方法都是笔者在开发过程中自行封装的，为了避免重复劳动，一看名字就该知道这些方法的作用吧。

二、任务调度周期

在MonitorTask抽象类中还有一个List<Schedule>，用于保存任务调度的周期，Schedule也是一个抽象类，该抽象类主要由3个方法：

public static List<Schedule> CreateSchedule(XElement element)

该方法根据保存在数据库中的xml数据构建出Schedule。

public abstract bool TimeUp()

由子类实现该方法，判断是否已到达需要调度任务的时间。

public abstract XElement ToXML()

由子类实现该方法，用于将任务调度周期序列化成xml，便于保存到数据库中。

三、管理类

该类主要根据数据库中的配置利用反射构建出相应的计划任务对象，并将其缓存在Dictionary对象里避免多次构建，同时创建线程执行这些插件。

    public static class MonitorTaskManagement
    {
        private static Dictionary<string, MonitorTask> _tasks = new Dictionary<string, MonitorTask>();

        private static MonitorTask GetMonitorTask(string fileName, string taskType, XElement element)
        {
            Assembly assembly = Assembly.LoadFrom(AppDomain.CurrentDomain.BaseDirectory + fileName);
            Type type = assembly.GetType(taskType);
            if (type.IsSubclassOf(typeof(MonitorTask)))
            {
                MonitorTask task = Activator.CreateInstance(type) as MonitorTask;
                task.Schedules = Schedule.CreateSchedule(element);
                return task;
            }
            else
            {
                throw new Exception("程序集" + taskType + "有误。");
            }
        }

        private static MonitorTask GetMonitorTask(string taskName, XElement element)
        {
            MonitorTask task;
            if (_tasks.ContainsKey(taskName))
            {
                task = _tasks[taskName];
            }
            else
            {
                task = GetMonitorTask(taskName + ".dll", "MonitorTask." + taskName, element);
                _tasks.Add(taskName, task);
            }
            return task;
        }

        public static void ExecuteTask()
        {
            string sql = "SELECT Name, Schedule FROM MonitorTask WHERE Enable = 1";
            using (SqlDataReader reader = SqlAssist.Select("SOMP", sql))
            {
                while (reader.Read())
                {
                    try
                    {
                        MonitorTask task = GetMonitorTask(reader.GetString(0), XElement.Parse(reader.GetString(1)));
                        Thread childThread = new Thread(task.Execute);
                        childThread.IsBackground = true;
                        childThread.Start();
                    }
                    catch (Exception e)
                    {
                        new LogText(AppDomain.CurrentDomain.BaseDirectory + @"log.log").Write(reader.GetString(0) + "插件异常", e.ToString());
                    }
                }
            }
        }
    }