C# Task 任务计划

using System;
using System.Threading;
using System.Collections.Generic;

namespace Rocky
{
    #region Task
    public class Task : IDisposable
    {
        #region Fields
        private string taskName;
        private Timer timer;
        private TimerCallback execTask;
        private ISchedule schedule;
        private DateTime lastExecuteTime;
        private DateTime nextExecuteTime;
        #endregion

        #region Properties
        /// <summary> 
        /// 任务名称 
        /// </summary> 
        public string Name
        {
            set { taskName = value; }
            get { return taskName; }
        }
        /// <summary> 
        /// 执行任务的计划 
        /// </summary> 
        public ISchedule Shedule
        {
            get { return schedule; }
        }
        /// <summary> 
        /// 该任务最后一次执行的时间 
        /// </summary> 
        public DateTime LastExecuteTime
        {
            get { return lastExecuteTime; }
        }
        /// <summary> 
        /// 任务下执行时间 
        /// </summary> 
        public DateTime NextExecuteTime
        {
            get { return nextExecuteTime; }
        }
        #endregion

        #region Methods
        /// <summary> 
        /// 构造函数 
        /// </summary> 
        /// <param name="schedule">为每个任务制定一个执行计划</param> 
        public Task(TimerCallback callback, ISchedule schedule)
        {
            if (callback == null || schedule == null)
            {
                throw new ArgumentNullException();
            }
            this.execTask = callback;
            this.schedule = schedule;
            execTask += new TimerCallback(Execute);
            TaskScheduler.Register(this);
        }

        /// <summary> 
        /// 任务内容 
        /// </summary> 
        /// <param name="state">任务函数参数</param> 
        private void Execute(object state)
        {
            lastExecuteTime = DateTime.Now;
            if (schedule.Period == Timeout.Infinite)
            {
                nextExecuteTime = DateTime.MaxValue; //下次运行的时间不存在 
            }
            else
            {
                TimeSpan period = new TimeSpan(schedule.Period * 1000);
                nextExecuteTime = lastExecuteTime + period;
            }
            if (!(schedule is CycExecution))
            {
                this.Close();
            }
        }

        public void Start()
        {
            Start(null);
        }
        public void Start(object execTaskState)
        {
            if (timer == null)
            {
                timer = new Timer(execTask, execTaskState, schedule.DueTime, schedule.Period);
            }
            <;span style="color: #0000ff;">else
            {
                timer.Change(schedule.DueTime, schedule.Period);
            }
        }
        public void RefreshSchedule()
        {
            if (timer != null)
            {
                timer.Change(schedule.DueTime, schedule.Period);
            }
        }
        public void Stop()
        {
            if (timer != null)
            {
                timer.Change(Timeout.Infinite, Timeout.Infinite);
            }
        }

        public void Close()
        {
            ((IDisposable)this).Dispose();
        }

        void IDisposable.Dispose()
        {
            if (execTask != null)
            {
                taskName = null;
                if (timer != null)
                {
                    timer.Dispose();
                    timer = null;
                }
                execTask = null;
                TaskScheduler.Deregister(this);
            }
        }

        public override string ToString()
        {
            return taskName;
        }
        #endregion
    }
    #endregion

    #region TaskScheduler
    /// <summary> 
    /// 任务管理中心 
    /// 使用它可以管理一个或则多个同时运行的任务 
    /// </summary> 
    public static class TaskScheduler
    {
        private static List<Task> taskScheduler;

        public static int Count
        {
            get { return taskScheduler.Count; }
        }

        static TaskScheduler()
        {
            taskScheduler = new List<Task>();
        }

        /// <summary>
        /// 查找任务
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public static Task Find(string name)
        {
            return taskScheduler.Find(task => task.Name == name);
        }

        public static IEnumerator<Task> GetEnumerator()
        {
            return taskScheduler.GetEnumerator();
        }

        /// <summary> 
        /// 终止任务 
        /// </summary> 
        public static void TerminateAllTask()
        {
            lock (taskScheduler)
            {
                taskScheduler.ForEach(task => task.Close());
                taskScheduler.Clear();
                taskScheduler.TrimExcess();
            }
        }

        internal static void Register(Task task)
        {
            lock (taskScheduler)
            {
                taskScheduler.Add(task);
            }
        }
        internal static void Deregister(Task task)
        {
            lock (taskScheduler)
            {
                taskScheduler.Remove(task);
            }
        }
    }
    #endregion

    #region ISchedule
    /// <summary> 
    /// 计划立即执行任务 
    /// </summary> 
    public struct ImmediateExecution : ISchedule
    {
        public DateTime ExecutionTime
        {
            get { return DateTime.Now; }
            set { }
        }
        public long DueTime
        {
            get { return 0; }
        }
        public long Period
        {
            get { return Timeout.Infinite; }
        }
    }

    /// <summary> 
    /// 计划在某一未来的时间执行一个操作一次，如果这个时间比现在的时间小，就变成了立即执行的方式 
    /// </summary> 
    public struct ScheduleExecutionOnce : ISchedule
    {
        private DateTime schedule;

        public DateTime ExecutionTime
        {
            get { return schedule; }
            set { schedule = value; }
        }
        /// <summary> 
        /// 得到该计划还有多久才能运行 
        /// </summary> 
        public long DueTime
        {
            get
            {
                long ms = (schedule.Ticks - DateTime.Now.Ticks) / 10000;
                if (ms < 0)
                {
                    ms = 0;
                }
                return ms;
            }
        }
        public long Period
        {
            get { return Timeout.Infinite; }
        }

        /// <summary> 
        /// 构造函数 
        /// </summary> 
        /// <param name="schedule">计划开始执行的时间</param> 
        public ScheduleExecutionOnce(DateTime time)
        {
            schedule = time;
        }
    }

    /// <summary> 
    /// 周期性的执行计划 
    /// </summary> 
    public struct CycExecution : ISchedule
    {
        private DateTime schedule;
        private TimeSpan period;

        public DateTime ExecutionTime
        {
            get { return schedule; }
            set { schedule = value; }
        }
        public long DueTime
        {
            get
            {
                long ms = (schedule.Ticks - DateTime.Now.Ticks) / 10000;
                if (ms < 0)
                {
                    ms = 0;
                }
                return ms;
            }
        }
        public long Period
        {
            get { return period.Ticks / 10000; }
        }

        /// <summary> 
        /// 构造函数,马上开始运行 
        /// </summary> 
        /// <param name="period">周期时间</param> 
        public CycExecution(TimeSpan period)
        {
            this.schedule = DateTime.Now;
            this.period = period;
        }
        /// <summary> 
        /// 构造函数，在一个将来时间开始运行 
        /// </summary> 
        /// <param name="shedule">计划执行的时间</param> 
        /// <param name="period">周期时间</param> 
        public CycExecution(DateTime shedule, TimeSpan period)
        {
            this.schedule = shedule;
            this.period = period;
        }
    }

    /// <summary> 
    /// 计划的接口 
    /// </summary> 
    public interface ISchedule
    {
        /// <summary> 
        /// 返回最初计划执行时间 
        /// </summary> 
        DateTime ExecutionTime { set; get; }
        /// <summary> 
        /// 初始化执行时间于现在时间的时间刻度差 
        /// </summary> 
        long DueTime { get; }
        /// <summary> 
        /// 循环的周期 
        /// </summary> 
        long Period { get; }
    }
    #endregion
}