如何写任务计划

在一些需要定时执行的任务时，比如：定时备份数据库，定时的获取网络数据等都需要计划任务。Window也有计划任务但是有很多的缺点，必须手动配置，而 且部署起来也很麻烦，时间的精度为一分钟，只能对应用程序配置任务。这里实现的任务计划是可以自己编程，可以很灵活，时间的精度为一秒，而且不是通过轮询 时间实现的，效率比较高，。你可以在Windows 服务中写一个服务，用它来管理所有的计划任务逻辑。 

类库源代码如下： /******************************************************************************************** 
* (C)2003-2005 C2217 Studio 
*  保留所有权利 
*   
*  文件名称:                task.cs 
*  文件ID:           
*  编程语言:                C# 
*  文件说明:                实现计划任务的调度机制。可以显示多种任务调度机制(定义时间精确到秒)： 
*                            1.立即执行(一次) 
*                            2.计划执行(一次,可定义任务开始执行的日期) 
*                            3.立即执行(循环执行,多次) 
*                            4.计划执行(循环执行,多次,可定义任务开始执行的日期) 
*                            可以通过实现接口ISchedule 制定自己的执行计划 
*                    
* 当前版本:                    1.0 
* 替换版本:         
*  
* 作者:                        邓杨均 
* EMail:                    [email protected] 
* 创建日期:                    2005-4-8 
* 最后修改日期:                2005-4-8 
*  
*历史修改记录: 
 
********************************************************************************************/ 
using System; 
using System.Collections; 
using System.Threading; 
using NUnit.Framework; 
 
namespace Ibms.Utility.Task 
{ 
 
    #region 任务计划接口和一些标准实现 
    /// <summary> 
    /// 计划的接口 
    /// </summary> 
    public interface ISchedule 
    { 
        /// <summary> 
        /// 返回最初计划执行时间 
        /// </summary> 
        DateTime ExecutionTime 
        { 
            get; 
            set; 
        } 
         
        /// <summary> 
        /// 初始化执行时间于现在时间的时间刻度差 
        /// </summary> 
        long DueTime 
        { 
            get; 
        } 
 
        /// <summary> 
        /// 循环的周期 
        /// </summary> 
        long Period 
        { 
            get; 
        } 
 
         
    } 
 
 
    /// <summary> 
    /// 计划立即执行任务 
    /// </summary> 
    public class ImmediateExecution:ISchedule 
    { 
        #region ISchedule 成员 
 
        public DateTime ExecutionTime 
        { 
            get 
            { 
                // TODO:  添加 ImmediatelyShedule.ExecutionTime getter 实现 
                return DateTime.Now; 
            } 
            set 
            { 
                ; 
            } 
        } 
 
        public long DueTime 
        { 
            get 
            { 
                return 0; 
            } 
        } 
 
         
        public long Period 
        { 
            get 
            { 
                // TODO:  添加 ImmediatelyShedule.Period getter 实现 
                return Timeout.Infinite; 
            } 
        } 
 
        #endregion 
    } 
 
 
    /// <summary> 
    /// 计划在某一未来的时间执行一个操作一次，如果这个时间比现在的时间小，就变成了立即执行的方式 
    /// </summary> 
    public class ScheduleExecutionOnce:ISchedule 
    { 
 
        /// <summary> 
        /// 构造函数 
        /// </summary> 
        /// <param name="schedule">计划开始执行的时间</param> 
        public ScheduleExecutionOnce( DateTime schedule) 
        { 
            m_schedule = schedule; 
        } 
 
        private DateTime m_schedule; 
 
        #region ISchedule 成员 
 
        public DateTime ExecutionTime 
        { 
            get 
            { 
                // TODO:  添加 ScheduleExecutionOnce.ExecutionTime getter 实现 
                return m_schedule; 
            } 
            set 
            { 
                m_schedule = value; 
            } 
        } 
 
 
        /// <summary> 
        /// 得到该计划还有多久才能运行 
        /// </summary> 
        public long DueTime 
        { 
            get 
            { 
                long ms=( m_schedule.Ticks- DateTime.Now.Ticks)/10000; 
 
                if( ms < 0 ) ms=0; 
                return  ms; 
            } 
        } 
 
 
        public long Period 
        { 
            get 
            { 
                // TODO:  添加 ScheduleExecutionOnce.Period getter 实现 
                return Timeout.Infinite; 
            } 
        } 
 
 
        #endregion 
    } 
 
 
    /// <summary> 
    /// 周期性的执行计划 
    /// </summary> 
    public class CycExecution:ISchedule 
    { 
        /// <summary> 
        /// 构造函数，在一个将来时间开始运行 
        /// </summary> 
        /// <param name="shedule">计划执行的时间</param> 
        /// <param name="period">周期时间</param> 
        public CycExecution(DateTime shedule,TimeSpan period) 
        { 
            m_schedule = shedule; 
            m_period = period; 
        } 
 
        /// <summary> 
        /// 构造函数,马上开始运行 
        /// </summary> 
        /// <param name="period">周期时间</param> 
        public CycExecution(TimeSpan period) 
        { 
            m_schedule = DateTime.Now; 
            m_period = period; 
        } 
 
        private DateTime m_schedule; 
        private TimeSpan m_period; 
 
        #region ISchedule 成员 
 
        public long DueTime 
        { 
            get 
            { 
                long ms=( m_schedule.Ticks- DateTime.Now.Ticks)/10000; 
 
                if( ms < 0 ) ms=0; 
                return  ms; 
            } 
        } 
 
        public DateTime ExecutionTime 
        { 
            get 
            { 
                // TODO:  添加 CycExecution.ExecutionTime getter 实现 
                return m_schedule; 
            } 
            set 
            { 
                m_schedule = value; 
            } 
 
         
        } 
     
        public long Period 
        { 
            get 
            { 
                // TODO:  添加 CycExecution.Period getter 实现 
                return m_period.Ticks/10000; 
            } 
        } 
 
        #endregion 
 
    } 
 
     
    #endregion 
 
    #region 任务实现 
    /// <summary> 
    /// 计划任务基类 
    /// 启动的任务会在工作工作线程中完成，调用启动方法后会立即返回。 
    ///  
    /// 用法： 
    /// (1)如果你要创建自己的任务，需要从这个类继承一个新类，然后重载Execute(object param)方法． 
    /// 实现自己的任务,再把任务加入到任务管理中心来启动和停止。 
    /// 比如： 
    /// TaskCenter center = new TaskCenter(); 
    /// Task newTask = new Task( new ImmediateExecution()); 
    /// center.AddTask(newTask); 
    /// center.StartAllTask(); 
 
    /// (2)直接把自己的任务写入TimerCallBack委托，然后生成一个Task类的实例， 
    /// 设置它的Job和JobParam属性，再Start就可以启动该服务了。此时不能够再使用任务管理中心了。 
    /// 比如： 
    /// Task newTask = new Task( new ImmediateExecution()); 
    ///    newTask.Job+= new TimerCallback(newTask.Execute); 
    ///    newTask.JobParam = "Test immedialte task"; //添加自己的参数 
    ///    newTask.Start(); 
    ///     
    /// </summary> 
    public class Task 
    { 
        /// <summary> 
        /// 构造函数 
        /// </summary> 
        /// <param name="schedule">为每个任务制定一个执行计划</param> 
        public Task(ISchedule schedule) 
        { 
            if(schedule==null) 
            { 
                throw (new ArgumentNullException("schedule") ); 
            } 
 
            m_schedule =schedule; 
        } 
 
 
        /// <summary> 
        /// 启动任务 
        /// </summary> 
        public void Start() 
        { 
            //启动定时器 
            m_timer = new Timer (m_execTask, m_param,m_schedule.DueTime ,m_schedule.Period); 
        } 
 
 
        /// <summary> 
        /// 停止任务 
        /// </summary> 
        public void Stop() 
        { 
            //停止定时器 
            m_timer.Change(Timeout.Infinite,Timeout.Infinite); 
             
        } 
 
 
        /// <summary> 
        /// 任务内容 
        /// </summary> 
        /// <param name="param">任务函数参数</param> 
        public  virtual void Execute(object param) 
        { 
            //你需要重载该函数,但是需要在你的新函数中调用base.Execute(); 
            m_lastExecuteTime = DateTime.Now; 
 
            if(m_schedule.Period == Timeout.Infinite) 
            { 
                m_nextExecuteTime = DateTime.MaxValue; //下次运行的时间不存在 
            } 
            else 
            { 
                TimeSpan period = new TimeSpan(m_schedule.Period * 1000); 
  
                m_nextExecuteTime = m_lastExecuteTime +period; 
            } 
                 
        } 
         
 
        /// <summary> 
        /// 任务下执行时间 
        /// </summary> 
        public DateTime NextExecuteTime 
        { 
            get 
            { 
                return m_nextExecuteTime; 
            } 
        } 
 
        DateTime m_nextExecuteTime; 
        /// <summary> 
        /// 执行任务的计划 
        /// </summary> 
        public ISchedule Shedule 
        { 
            get 
            { 
                return m_schedule; 
            }     
        } 
 
        private ISchedule m_schedule; 
 
        /// <summary> 
        /// 系统定时器 
        /// </summary> 
        private Timer m_timer; 
         
        /// <summary> 
        /// 任务内容 
        /// </summary> 
        public TimerCallback Job 
        { 
            get 
            { 
                return m_execTask; 
            } 
            set 
            { 
                m_execTask= value; 
            } 
        } 
 
        private TimerCallback m_execTask; 
 
        /// <summary> 
        /// 任务参数 
        /// </summary> 
        public object JobParam 
        { 
            set 
            { 
                m_param = value; 
            } 
        } 
        private object m_param; 
 
        /// <summary> 
        /// 任务名称 
        /// </summary> 
        public string Name 
        { 
            get 
            { 
                return m_name; 
            } 
            set 
            { 
                m_name = value; 
            } 
        } 
        private string m_name; 
         
         
        /// <summary> 
        /// 任务描述 
        /// </summary> 
        public string Description 
        { 
            get 
            { 
                return m_description; 
            } 
            set 
            { 
                m_description = value; 
            } 
        } 
        private string m_description; 
 
        /// <summary> 
        /// 该任务最后一次执行的时间 
        /// </summary> 
        public DateTime LastExecuteTime 
        { 
            get 
            { 
                return m_lastExecuteTime; 
            } 
        } 
        private DateTime m_lastExecuteTime; 
 
         
    } 
 
    #endregion 
 
    #region 启动任务 
     
    /// <summary> 
    /// 任务管理中心 
    /// 使用它可以管理一个或则多个同时运行的任务 
    /// </summary> 
    [TestFixture] 
    public class TaskCenter 
    { 
        /// <summary> 
        /// 构造函数 
        /// </summary> 
        public TaskCenter() 
        { 
            m_scheduleTasks = new ArrayList(); 
        } 
 
        /// <summary> 
        /// 添加任务 
        /// </summary> 
        /// <param name="newTask">新任务</param> 
        public void AddTask(Task newTask) 
        { 
            m_scheduleTasks.Add(newTask); 
        } 
 
        /// <summary> 
        /// 删除任务 
        /// </summary> 
        /// <param name="delTask">将要删除的任务，你可能需要停止掉该任务</param> 
        public void DelTask(Task delTask) 
        { 
            m_scheduleTasks.Remove(delTask); 
        } 
 
        /// <summary> 
        /// 启动所有的任务 
        /// </summary> 
        public void StartAllTask() 
        { 
            foreach(Task task in ScheduleTasks) 
            { 
                StartTask(task); 
            } 
        } 
 
        /// <summary> 
        /// 启动一个任务 
        /// </summary> 
        /// <param name="task"></param> 
        public void StartTask(Task task) 
        { 
            //标准启动方法 
            if(task.Job == null) 
            { 
                task.Job+= new TimerCallback(task.Execute); 
            } 
 
            task.Start(); 
        } 
 
        /// <summary> 
        /// 终止所有的任务 
        /// </summary> 
        public void TerminateAllTask() 
        { 
            foreach(Task task in ScheduleTasks) 
            { 
                TerminateTask(task); 
            } 
        } 
 
        /// <summary> 
        /// 终止一个任务 
        /// </summary> 
        /// <param name="task"></param> 
        public void TerminateTask(Task task) 
        { 
            task.Stop(); 
        } 
         
        /// <summary> 
        /// 获得所有的 
        /// </summary> 
        ArrayList ScheduleTasks 
        { 
            get 
            { 
                return m_scheduleTasks; 
            } 
        } 
        private ArrayList m_scheduleTasks; 
 
        /// <summary> 
        /// 单元测试代码 
        /// </summary> 
        [Test] 
        public  void TestTaskCenter() 
        { 
            TaskCenter center = new TaskCenter(); 
 
            //Test immedialte task 
            Task newTask = new Task( new ImmediateExecution()); 
            newTask.Job+= new TimerCallback(newTask.Execute); 
            newTask.JobParam = "Test immedialte task"; 
 
            //Test excute once task 
            DateTime sheduleTime = DateTime.Now.AddSeconds(10); 
  
            ScheduleExecutionOnce future= new ScheduleExecutionOnce(sheduleTime); 
 
            Task sheduleTask = new Task( future); 
            sheduleTask.Job+= new TimerCallback(sheduleTask.Execute); 
            sheduleTask.JobParam = "Test excute once task"; 
             
            //Test cyc task at once 
 
            CycExecution cyc = new CycExecution( new TimeSpan(0,0,2)); 
            Task cysTask = new Task(cyc); 
             
            cysTask.Job+= new TimerCallback(cysTask.Execute); 
            cysTask.JobParam = "Test cyc task"; 
 
            //Test cys task at schedule 
 
            CycExecution cycShedule = new CycExecution( DateTime.Now.AddSeconds(8),new TimeSpan(0,0,2)); 
 
            Task cycSheduleTask = new Task(cycShedule); 
             
            cycSheduleTask.Job+= new TimerCallback(cysTask.Execute); 
            cycSheduleTask.JobParam = "Test cyc Shedule task"; 
 
 
            center.AddTask(newTask); 
            center.AddTask(sheduleTask); 
            center.AddTask(cysTask); 
 
            center.AddTask(cycSheduleTask); 
 
            center.StartAllTask(); 
 
            Console.ReadLine(); 
 
            Console.WriteLine(newTask.LastExecuteTime); 
        } 
    } 
 
    #endregion 
}