C#全局计划任务类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Threading;
/// <summary>
/// 计划任务代理
/// </summary>
public delegate void TaskSchedulerHandler();
public enum TaskSchedulerRule
{
    Second, Minute, Hour, Day, Week, Month, Year
}
/// <summary>
/// 任务执行间隔
/// 负责计算下一次执行任务的时间
/// </summary>
public class TaskSpan
{
    public TaskSchedulerRule Rule = TaskSchedulerRule.Day;
    private DateTime _TaskTime = DateTime.Now;
    public DateTime TaskTime
    {
        get { return _TaskTime; }
        set { if (value < DateTime.Now) { value = DateTime.Now; } _TaskTime = value; }
    }
    public DateTime _NextTaskTime;
    public DateTime NextTaskTime
    {
        get
        {
            if (_NextTaskTime > TaskTime)
            {
                return _NextTaskTime;
            }
            return Next();
        }
    }
    private Int32 _Number = 1;
    public Int32 Number
    {
        get { return _Number; }
        set { if (value < 1) { value = 1; } _Number = value; }
    }
    public TaskSpan(TaskSchedulerRule rule, Int32 number)
    {
        this.Rule = rule;
        this.Number = number;
    }
    public TaskSpan()
        : this(TaskSchedulerRule.Day, 1)
    {

    }
    public void BeginNext()
    {
        TaskTime = NextTaskTime;
    }
    public DateTime Next()
    {
        _NextTaskTime = TaskTime;
        switch (this.Rule)
        {
            case TaskSchedulerRule.Week:
                _NextTaskTime.AddDays(this.Number * 7);
                break;
            default:
                this._NextTaskTime = (DateTime)typeof(DateTime).GetMethod(String.Format("Add{0}s", this.Rule)).Invoke(this._NextTaskTime, new Object[] { Number });
                break;
        }
        return this._NextTaskTime;
    }
}
/// <summary>
/// 计划任务实体
/// 包含要执行的方法及执行区间
/// </summary>
public class TaskScheduler
{
    public Boolean Removed;
    public String TaskName;
    public TaskSpan Span;
    public event TaskSchedulerHandler TaskSchedulerEvent;
    public TaskScheduler(String name, TaskSchedulerHandler action, TaskSpan span)
    {
        this.TaskName = name;
        this.Span = span;
        this.TaskSchedulerEvent += action;
    }
    public void Run()
    {
        TaskSchedulerEvent();
    }

}
/// <summary>
/// 计划任务管理器
/// </summary>
public class TaskSchedulerManager
{
    public static Object locker = new Object();
    private static TaskSchedulerManager _Instance;
    Dictionary<String, TaskScheduler> TaskSchedulers = new Dictionary<String, TaskScheduler>();
    Dictionary<String, List<TaskScheduler>> TaskCollections = new Dictionary<String, List<TaskScheduler>>();
    private List<TaskScheduler> TaskListItems;
    private String TaskListKey;
    bool Runing = false;
    public static TaskSchedulerManager GetInstance()
    {
        if (_Instance == null)
        {
            lock (locker)
            {
                if (_Instance == null)
                {
                    _Instance = new TaskSchedulerManager();
                }
            }
        }
        return _Instance;
    }
    /// <summary>
    /// 新增计划任务
    /// </summary>
    /// <param name="task">计划任务实体</param>
    public void AddTask(TaskScheduler task)
    {
        AddTask(task, false);
    }
    /// <summary>
    /// 新增计划任务
    /// </summary>
    /// <param name="task">计划任务实体</param>
    /// <param name="start">是否当即开始</param>
    public void AddTask(TaskScheduler task, Boolean start)
    {
        TaskSchedulers.Add(task.TaskName, task);
        if (start)
        {
            task.Span.TaskTime = DateTime.Now;
            task.Run();
            task.Span.BeginNext();
        }
        InitTask(task);
    }
    /// <summary>
    /// 移除计划任务
    /// </summary>
    /// <param name="task">计划任务实体</param>
    public void RemoveTask(TaskScheduler task)
    {
        TaskSchedulers.Remove(task.TaskName);
        foreach (string key in TaskCollections.Keys)
        {
            TaskCollections[key].Remove(task);
        }
    }
    /// <summary>
    /// 移除计划任务
    /// </summary>
    /// <param name="name">计划任务名称</param>
    public void RemoveTask(string name)
    {
        foreach (string key in TaskCollections.Keys)
        {
            TaskCollections[key].Remove(TaskSchedulers[name]);
        }
        TaskSchedulers.Remove(name);
    }
    /// <summary>
    /// 清除全部计划任务
    /// </summary>
    public void ClearTask() {
        TaskSchedulers.Clear();
        TaskCollections.Clear();
    }
    /// <summary>
    /// 初始化计划任务，加入到计划任务集合中
    /// </summary>
    /// <param name="task"></param>
    private void InitTask(TaskScheduler task)
    {
        TaskListKey = task.Span.TaskTime.ToString("yyyyMMddHHmmss");
        if (TaskCollections.ContainsKey(TaskListKey))
        {
            TaskListItems = TaskCollections[TaskListKey] as List<TaskScheduler>;
            TaskListItems.Add(task);
        }
        else
        {
            TaskCollections.Add(TaskListKey, TaskListItems = new List<TaskScheduler> { task });
        }
    }
    /// <summary>
    /// 运行计划任务
    /// </summary>
    /// <param name="tasks">tasks</param>
    private void RunTask(List<TaskScheduler> tasks)
    {
        for (int i = 0; i < tasks.Count; i++)
        {
            TaskScheduler task = tasks[i];
            tasks[i] = null;
            new Thread(task.Run).Start();
            task.Span.BeginNext();
            InitTask(task);
        }
    }

    /// <summary>
    /// 启动运行计划任务管理
    /// </summary>
    public void Run() {
        Object _locker = new Object();
        Runing = true;
        string key;
        while (Runing)
        {
            Thread.Sleep(1000);
            lock(_locker)
            {
                key = DateTime.Now.ToString("yyyyMMddHHmmss");
                if (TaskCollections.ContainsKey(key.ToString()))
                {
                    RunTask(TaskCollections[key]);
                    TaskCollections.Remove(key);
                }
            }
        }
    }

    /// <summary>
    /// 中止计划任务管理
    /// </summary>
    public void Stop() {
        Runing = false;
    }
}

 

 

演示代码：

 

public partial class Pages_Begin : System.Web.UI.Page
{
    public String Message { get { return String.Format("显示时间为:{0:yyyy-MM-dd HH:mm:ss}", DateTime.Now); } }
    protected void Page_Load(object sender, EventArgs e)
    {
        #region 能够循环部分
        //建立计划任务
        TaskScheduler task = new TaskScheduler("TaskMethod", TaskMethod, new TaskSpan(TaskSchedulerRule.Second, 5) { TaskTime = DateTime.Now.AddSeconds(10) });
        //将计划任务并入到管理中
        TaskSchedulerManager.GetInstance().AddTask(task, true);

        //建立计划任务
        TaskScheduler task2 = new TaskScheduler("TashMethod2",TaskMethod2, new TaskSpan(TaskSchedulerRule.Second, 10) { TaskTime = DateTime.Now.AddSeconds(10) });
        //将计划任务并入到管理中
        TaskSchedulerManager.GetInstance().AddTask(task2, false);

        #endregion
        //启用计划任务管理
        TaskSchedulerManager.GetInstance().Run();
    }
    public void TaskMethod()
    {
        FileStream fs = new FileStream(Server.MapPath("~/File/TextFile.txt"), FileMode.Append, FileAccess.Write);
        StreamWriter sw = new StreamWriter(fs);
        sw.WriteLine(Message);
        sw.Close();
        sw.Dispose();
        fs.Close();
        fs.Dispose();
    }
    public void TaskMethod2()
    {
        FileStream fs = new FileStream(Server.MapPath("~/File/TextFile2.txt"), FileMode.Append, FileAccess.Write);
        StreamWriter sw = new StreamWriter(fs);
        sw.WriteLine(Message);
        sw.Close();
        sw.Dispose();
        fs.Close();
        fs.Dispose();
    }
}