C#实现自定义定时组件的方法

本文实例展示的是一个自定义的定时器组件，有别于.net framework里面提供的几个timer。首先说说该组件开发背景，发现现在手头上的工作离不开定时，定时做一个任务，什么都是定时去做什么什么，隔某段时间干某件事情，都离不开“定时”这个词。众所周知这个要用到多线程，在多篇关于多线程的文章里面有提过做一些周期性的操作时最好用timer，当然这个timer肯定是threading.timer，并不是winform控件里面的timer。但我觉得在我的应用中timer不够满足需求。

1.timer只能在做任务与任务之间相隔一段时间的操作，如下图

但我需要的是这次任务开始的时刻到下次任务开始时刻是相隔同等的时间，又如下图

这样的情况下timer则不能满足需求。

2.timer的时间间隔一般是定的，但是如果要每次执行完任务要变动一下休眠的时间， 则需要调用timer的change方法。

3.timer的休眠时间不是通过整形确定休眠的毫秒数，就是用一个timespan来确定，对于那种到每天多少多少时刻或者到每小时的多少分执行一次的任务来说也不能够完全方便使用

对于上面这三种，笔者对定时器封装了一下，弃用了timer，还是用回了原有的thread，定义了一种描述重复时间的模式字符串，计算出timespan，从而调用thread的sleep()方法来休眠。下面展示整个组件的类图

最底下是两个关于时间计算方面的类，两个代理是两种任务方法的委托，基类basecyclemission是周期任务的积累，实现了icycle接口，主要进行对任务线程的操控（开始，停止等），继承他的两个子类一个是实现上文第一点中我后来描述那种需求，一个类似于原有timer的功能。它们各自使用不同的委托。missionmanager只是对所有周期任务的一个管理，统一去开启或暂停某一类的任务。

时间计算模块

　　那首先来介绍一下定义的字符串模式。现在遇到的周期是有两种模式，

一种是每隔多长时间要执行一次的任务，这个是最普通的周期形式，以每个5分钟为例，完整的形式是“-99--99--99 -99:05:00”，“-99”是缺省的意思，当然还有其他简写的模式；

另一种是没到什么什么时候执行一次任务，例如没到中午12点为例完整的形式是“ff-ff-ff 12: ff:ff”，“ff”是默认的形式，当然也可以用“ff”，这里也有其他简写的模式。

所有字符串的模式如下表所示

	每到***时刻	每隔***时间
完整	ffff-ff-ff ff:ff:ff 或 ff-ff-ff ff:ff:ff	-99--99--99 -99:-99:-99
日期部分	ffff-ff-ff 或 ff-ff-ff	-99--99--99
时间部分	ff:ff:ff 或 ff:ff:ff	-99:-99:-99
时间简写	ff:ff 或 ff:ff	-99:-99

　　那么时间计算模块的处理流程是，给定了相应的模式字符串，timepointconverter借助正则表达式匹配出对应的模式，返回匹配出来的年月日时分秒各个值，得出结果之后就调用sleeptimeprovider来计算出线程所要休眠的时间。下面则展示一下两个类的部分代码

public class timepointconverter
{
//其他成员
private int[] datetimefixbuilder(string timestr)
{
int[] result = null;
string[] dtarray = timestr.split();
string[] datearray = dtarray[0].split('-');
string[] timearray = dtarray[1].split(':');

uint year,month,date;
uint hour, minute, second; 
uint.tryparse(datearray[0], out year);
uint.tryparse(datearray[1], out month);
uint.tryparse(datearray[2], out date);

uint.tryparse(timearray[0], out hour);
uint.tryparse(timearray[1], out minute);
uint.tryparse(timearray[2], out second);

//return innerfixbuilder(year, month, date, hour, minute, second);
result = new int[] { (int)year, (int)month, (int)date, (int)hour, (int)minute, (int)second };
return result;
}
//其他成员
}

public class sleeptimeprovider
{
//其他成员
public timespan innerfixbuilder(uint year, uint month, uint date, uint hour, uint minute, uint second)
{
uint[] uinttimearray = new uint[6] { year, month, date, hour, minute, second };
int[] intnowarray = new int[6] 
{ 
datetime.now.year,datetime.now.month,datetime.now.day,
datetime.now.hour,datetime.now.minute,datetime.now.second 
};
int[] inttimearray = new int[6];
inttimearray[0] = uinttimearray[0] == 0 ? -datetime.now.year : (int)uinttimearray[0];
for (int i = 1; i < uinttimearray.length; i++)
{
inttimearray[i] = inttimearray[i - 1] < 0 && uinttimearray[i] == 0 ?
-intnowarray[i] : (int)uinttimearray[i];
}
datetime goaltime = new datetime(math.abs(inttimearray[0]),
math.abs(inttimearray[1]),
math.abs(inttimearray[2]),
math.abs(inttimearray[3]),
math.abs(inttimearray[4]),
math.abs(inttimearray[5]));
if (goaltime < datetime.now)
{
int max = -1;
for (int i = inttimearray.length - 1; i >= 0; i--)
{
if (inttimearray[i] < 0 && i > max)
{
max = i;
inttimearray[i]--;
}
inttimearray[i] = math.abs(inttimearray[i]);
}
goaltime = new datetime(math.abs(inttimearray[0]),
math.abs(inttimearray[1]),
math.abs(inttimearray[2]),
math.abs(inttimearray[3]),
math.abs(inttimearray[4]),
math.abs(inttimearray[5]));
}
return goaltime - datetime.now;
}
//其他成员
}

线程调用模块

　　线程调用模块是任务执行的核心部分，missionentiy是对线程操作的封装，主要负责开始，停止，暂停等操作。thread用的是后台线程，对线程操作时也多做几个判断。例如暂停那个操作的定义如下

public bool pause()
{
if (actionthread == null) return false;
if (actionthread.threadstate == (system.threading.threadstate.running | threadstate.background) ||
actionthread.threadstate == (system.threading.threadstate.waitsleepjoin | threadstate.background))
{
actionthread.suspend();
return true;
}
return false;
}

cyclemission是真正的任务载体，里面都同样有对线程的操作，但是又外加了一些时间处理，最核心的是让线程的buildmainaction方法，这个方法是计算出要休眠的时间，让线程休眠，到点时调用适当的方法委托。

public class basecyclemission:icyclemission
{
//其他成员
protected void buildmainaction(string normalcycle, string overtimecycle, object overtimedelegate, bool issleepbefore,bool isinclude)
{
mainaction = () =>
{
timespan sleeptime=timespan.minvalue;
bool result = true;
timepointconvert.circletype type ;
#region 提前休眠
if (issleepbefore)
{
type = timepointconvert.default.prasetype(normalcycle); 
if (type == timepointconvert.circletype.interval)
sleeptime = sleeptimeprovider.defult.innerintervalbuilder(
timepointconvert.default.convertcircle(normalcycle));
else
sleeptime = sleeptimeprovider.defult.innerfixbuilder(
timepointconvert.default.convertcircle(normalcycle));
if (sleeptime.totalmilliseconds > 0)
thread.sleep(sleeptime);
}
#endregion
while (true)
{
#region 计算时间
if (isinclude)
{
if (result)
{
type = timepointconvert.default.prasetype(normalcycle); 
type = timepointconvert.default.prasetype(overtimecycle); 
sleeptime = type == timepointconvert.circletype.interval ?
sleeptimeprovider.defult.innerintervalbuilder(
timepointconvert.default.convertcircle(overtimecycle)) :
sleeptimeprovider.defult.innerfixbuilder(
timepointconvert.default.convertcircle(overtimecycle));
}
}
#endregion

#region 执行方法

if(overtimedelegate is overtimecycledelegate)
result = (overtimedelegate as overtimecycledelegate).invoke();
else
{
(overtimedelegate as cycledelegate).invoke();
result = true;
}
#endregion

#region 计算时间
if (!isinclude)
{
if (result)
{

type = timepointconvert.default.prasetype(normalcycle);


sleeptime = type == timepointconvert.circletype.interval ?
sleeptimeprovider.defult.innerintervalbuilder(
timepointconvert.default.convertcircle(normalcycle)) :
sleeptimeprovider.defult.innerfixbuilder(
timepointconvert.default.convertcircle(normalcycle));
}
else
{
type = timepointconvert.default.prasetype(overtimecycle);

sleeptime = type == timepointconvert.circletype.interval ?
sleeptimeprovider.defult.innerintervalbuilder(
timepointconvert.default.convertcircle(overtimecycle)) :
sleeptimeprovider.defult.innerfixbuilder(
timepointconvert.default.convertcircle(overtimecycle));
}
}
#endregion

if (sleeptime.totalmilliseconds > 0)
thread.sleep(sleeptime);
}
};
}
//其他成员
}

当然调用不是调用这个方法，调用只是调用它两个几类exceptcyclemission和includecyclemission，分别代表任务执行的时间不包括在周期里面和包括在周期里面两种。

管理器部分

　　管理器主要是一个字典集，是一个icyclemission和字符串的字典集，里面包含了对集合里面所有元素的操作：增加，删除，运行，恢复，暂停，停止。除了删除和增加，其他都包含了类似下面的方法

runallmission()
runallincludecyclemission()
runallexceptcyclemission()
runmissionamong(params string[] missionnames)
runmissionexcept(params string[] missionnames)

但是这堆方法里面都调用了callaction这个方法，

private void callaction(ienumerable<icyclemission> missioncollection,action method)
{
if (missioncollection == null || method == null||missioncollection.count()==0) return;

foreach (icyclemission item in missioncollection)
{
method.method.invoke(item, null);
}
}

例如在runallexceptcyclemission()方法里面调用如下

public void runallexceptcyclemission()
{
callaction(this.values.where(c => c is exceptcyclemission), basecyclemission.default.runmission);
}

　　感兴趣的朋友可以测试一下本文所述实例代码，相信会有不小的收获！