class Schedule : IDisposable
{
private class Task
{
public TimeSpan Start; //每天任务开始的时间点，从00:00开始算起
public TimeSpan End; //每天任务结束的时间点，从00:00开始算起
public bool Once = false; //指定任务是否每天只执行一次
public DateTime Executed = DateTime.MinValue; //任务在最后一次执行的时间点
public TimeSpan Interval; //任务执行频率
public Action action; //匿名委托，用于任务计算
public override string ToString()
{
return string.Format(@"Task({0}) Start:{1},End:{2},Once:{3},Interval:{4},Action:{5},Executed:{6}", this.GetHashCode(), this.Start, this.End, this.Once, this.Interval, this.action, this.Executed);
}
}
/// <summary>
/// 在每天指定的时间段内以相对固定的频率执行任务
/// </summary>
/// <param name="start">任务开始时间点，从00:00开始算起</param>
/// <param name="end">任务结束时间点，从00:00开始算起</param>
/// <param name="interval">任务调试效率</param>
/// <param name="action">匿名委托，用于任务计算</param>
public void Execute(TimeSpan start, TimeSpan end, TimeSpan interval, Action action)
{
AddTask(new Task()
{
action = action,
End = end,
Interval = interval,
Once = false,
Start = start
});
}
/// <summary>
/// 在每天指定的时间段内执行一次任务
/// </summary>
/// <param name="start">任务开始时间点，从00:00开始算起</param>
/// <param name="end">任务结束时间点，从00:00开始算起</param>
/// <param name="action">匿名委托，用于任务计算</param>
public void ExecuteOnce(TimeSpan start, TimeSpan end, Action action)
{
AddTask(new Task()
{
action = action,
End = end,
Once = true,
Start = start
});
}
/// <summary>
/// 开始调度任务
/// </summary>
public void Start()
{
this.onGoing = true;
this.timer.Enabled = true;
}
/// <summary>
/// 结束高度任务
/// </summary>
public void Stop()
{
this.onGoing = false;
this.timer.Enabled = false;
}
private System.Timers.Timer timer;//timer对象，用于定时检时任务执行点
private volatile bool onGoing = false; //指示任务调度是否持续运行
private List<Task> tasks = new List<Task>(); //任务列表，用于任务排序
/// <summary>
/// 构造函数，默认以5秒的频率检查任务执行时间点
/// </summary>
public Schedule()
: this(5000)
{
}
/// <summary>
/// 构造函数，默认以指定的频率检查任务执行时间点
/// </summary>
/// <param name="interval"></param>
public Schedule(double interval)
{
timer = new System.Timers.Timer(interval);
timer.AutoReset = false; //这是整个框架实现的关键所在，后面会进一步说明
timer.Enabled = false;
timer.Elapsed += new System.Timers.ElapsedEventHandler(timer_Elapsed); //用于检查任务时间点的匿名委托
}
/// <summary>
/// 添加一个任务到任务列表
/// </summary>
/// <param name="task"></param>
private void AddTask(Task task)
{
if (task.Once == true)
tasks.Insert(0, task); //每天一次的任务优先
else
tasks.Add(task);
}
/// <summary>
/// 用于检查任务时间点的匿名委托
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
{
if (this.onGoing == true) //判断调度是否继续
{
if (tasks.Count > 0)
{
int index = 0;
while (true)
{
Task task = tasks[index++]; //获取任务列表中的第一个任务
if (this.onGoing == false) break; //判断调度是否继续
if (CompareTime(task)) //比较任务时间点
{
ExecuteTask(task); //执行任务，同时更新任务最后执行时间点
SortTasks(); //对任务列表进行排序，确定下一次最先执行的任务
break;
}
}
}
}
if (this.onGoing == true)//判断调度是否继续
{
this.timer.Enabled = true; //激活timer,在指定时间再进一次任务时间点检查
}
}
/// <summary>
/// 任务列表排序，将一次性的任务排在前面，将最近已执行的任务放在最后
/// </summary>
private void SortTasks()
{
if (tasks.Count <= 1) return;
tasks.Sort(new Comparison<Task>(delegate(Task Task0, Task Task1)
{
if (Task0.Once == true && Task1.Once == false)
{
return -1;
}
if (Task0.Once = true && Task1.Once == true)
{
return Task0.Executed < Task1.Executed ? -1 : 1;
}
if (Task0.Once == false && Task1.Once == true)
{
return 1;
}
return Task0.Executed < Task1.Executed ? -1 : 1;
}));
}
/// <summary>
/// 比较任务时间点
/// </summary>
/// <param name="task">任务</param>
/// <returns></returns>
private bool CompareTime(Task task)
{
DateTime Now = DateTime.Now; //当前时间点
//计算任务在当天内开始执行时间
DateTime startTime = new DateTime(Now.Year, Now.Month, Now.Day, task.Start.Hours, task.Start.Minutes, task.Start.Seconds);
//计算任务在当天内结束执行时间
DateTime endTime = new DateTime(Now.Year, Now.Month, Now.Day, task.End.Hours, task.End.Minutes, task.End.Seconds);
//任务跨天执行，调整时间点
if (startTime > endTime) endTime += new TimeSpan(24, 0, 0);
//如果是每天一次的任务，而且已经执行过一次
if (task.Once == true && startTime <= task.Executed && task.Executed <= endTime)
{
return false;
}
return startTime <= Now && Now <= endTime; //如果当前时间点，在任务执行时间段内，则返真
}
/// <summary>
/// 执行任务
/// </summary>
/// <param name="task"></param>
private void ExecuteTask(Task task)
{
if (task.action != null)
{
//如果当前时间在任务执行频率内，则执行
if (task.Executed == DateTime.MinValue || DateTime.Now - task.Executed >= task.Interval)
{
task.action();
task.Executed = DateTime.Now; //更新任务最后执行时间
}
}
}
#region IDisposable Members
public void Dispose()
{
this.timer.Dispose();
}
#endregion
}