C# winform 任务计划程序疑问，高手来！

[wuyt2007]

声明:此段程序是在其他人博客里拷贝过来的，现在有些疑问希望大家给点提示，第一次做，很生疏！

using System;
using System.Collections;
using System.Threading;
namespace POSTiming
{
#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;
}
}

publc 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

[wuyt2007]

#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>
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();
}

[wuyt2007]

/// <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>
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
}
namespace POSTiming
{
//测试代码
using System;
using System.Threading;
/// <summary>
/// 解释怎么创建自己的任务类，和使用它们
/// </summary>
class TestTask : Task
{
public TestTask(ISchedule schedule)
: base(schedule)
{

}

public override void Execute(object param)
{
//一定要保留
base.Execute(param);

Console.WriteLine("Begin to execute a long job...NextExecuteTime:{0}", this.NextExecuteTime);

Thread.Sleep(5000);

Console.WriteLine("Test Tast execute job.Last ExecuteTime {0}, ",
this.LastExecuteTime
);
}

[STAThread]
static void Main(string[] args)
{
TaskCenter center = new TaskCenter();

//Test immediate task
Task newTask = new TestTask(new ImmediateExecution());
newTask.JobParam = "Test immedialte task";

//Test excute once task
DateTime sheduleTime = DateTime.Now.AddSeconds(10);
ScheduleExecutionOnce future = new ScheduleExecutionOnce(sheduleTime);
Task sheduleTask = new TestTask(future);
sheduleTask.JobParam = "Test excute once task";

//Test cyc task at once
CycExecution cyc = new CycExecution(new TimeSpan(0, 0, 2));
Task cysTask = new TestTask(cyc);
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 TestTask(cycShedule);
cycSheduleTask.JobParam = "Test cyc Shedule task";
center.AddTask(newTask);
center.AddTask(sheduleTask);
center.AddTask(cysTask);
center.AddTask(cycSheduleTask);
center.StartAllTask();
Console.ReadLine();
Console.WriteLine("terminate all task");
center.TerminateAllTask();
Console.ReadLine();
}
}
}
问题：当添加多个计划任务的时候，一旦有符合的时间就开始执行托管程序，这时在TestTask类的重写方法中Execute() 如何得知正在运行的计划任务时多个中的哪一个？？？ 万分感谢！

[wuyt2007]

真不容易发上来，帮忙看看了！

[daviddcy]

需要你自己管理它

[gtiroy]

先顶再看

[wuyt2007]

谢谢你们的回答！我已经看过并调试了，但就时不知道触发托管方法时启用的是多个计划任务中的哪个？？

[hanguoji84]

看看，不知阁下要实现什么？自己做个简单的管理定时执行函数不就可以了么？

[erdoszhao]

新手飘过~~

[wuyt2007]

自己顶！