C#开发系统服务时用的定时器组件

写服务时，都需要为定时器写不少的代码，感觉很麻烦，今天把这些代码封装一下，希望能简化一下这方面的工作，把精力都集中在功能上

本定时器组件，每次只启动一个服务实例进行处理，而不会同时多次执行服务代码。



下面是应用实例

从组件类派生一个子类，可以看到，需要写的代码很少

using System;   
using System.Collections.Generic;   
using System.IO;   
using System.Text.RegularExpressions;   
using System.Threading;
  
namespace BlueVision.SaYuan.WinService   
{   
    public class TestService : ServiceTimerContorl   
    {   
        protected override void StartService()   
        {   
            //需要做的事情的代码   
        }   
  
        protected override ServiceTimeConfig GetTimerConfig()   
        {   
            ServiceTimeConfig config = new ServiceTimeConfig();   
  
            // 如果该枚举是选择 Interval ，则表示，上述的 StartService 方法，将隔 config.ChkInterval 毫秒执行一次   
            config.TimerMode = TimerMode.Interval;   
            config.ChkInterval = 100000;   
  
  
            /// StartTime值为：   
            ///    
            /// TimerMode=TimerMode.Month   "09|04:30"  -表示每月9号的凌晨4点30分   
            /// TimerMode=TimerMode.Week     "0|04:30"  -表示每星期天的4点30分   
            /// TimerMode=TimerMode.Week     "6|04:00"  -表示每星期6的4点30分   
            /// TimerMode=TimerMode.Day       "|04:00"  -表示每天的4点00分   
            /// TimerMode=TimerMode.Date "08-10|04:00"  -表示每年8月10号的4点00分执行一次   
            /// TimerMode=TimerMode.Year   "246|04"     -表示每年第246天的4点00分执行一次（可以不填写分钟默认为00）   
  
            //如果是这样设置 则表示，每天的凌晨 4 点 00 执行一次   
            config.TimerMode = TimerMode.Day;   
            config.StartTime = "|04";   
  
            //如果是这样设置 则表示，每个星期的星期四那天的凌晨 6 点 35 执行一次   
            config.TimerMode = TimerMode.Week;   
            config.StartTime = "4|06:35";   
  
            //如果是这样设置 则表示，每个星期的星期天那天的凌晨 6 点 00 执行一次   
            config.TimerMode = TimerMode.Week;   
            config.StartTime = "0|06";   
  
            //如果是这样设置 则表示，每个月的9号凌晨 6 点 28 执行一次   
            config.TimerMode = TimerMode.Month;   
            config.StartTime = "09|06:28";   
  
            //如果是这样设置 则表示，每年8月10号的4点00分执行一次   
            config.TimerMode = TimerMode.Date;   
            config.StartTime = "08-10|04:00";   
  
            //如果是这样设置 则表示，每年第246天的4点27分执行一次   
            config.TimerMode = TimerMode.Year;   
            config.StartTime = "246|04:27";   
  
            return config;   
        }   
        /// <summary>   
        /// 当服务出错时，处理   
        /// </summary>   
        /// <param name="ex"></param>   
        protected override void  ServiceException(Exception ex)   
        {   
             //可以不实现   
        }   
    }   
}   
  
  
//要执行代码，以下这样就可以了
TestService testService = new TestService();   
testService.Start();

以下是组件的源代码

using System;
using System.Collections.Generic;
using System.IO;
using System.Text.RegularExpressions;
using System.Threading;

namespace BlueVision.SaYuan.WinService
{
	/// <summary>
	/// 服务定时器管理
	/// </summary>
	public abstract class ServiceTimerControl
	{
		#region 私有成员
		/// <summary>
		/// 定时器
		/// </summary>
		private Timer SysTimer { get; set; }
		/// <summary>
		/// 是否启用定时器
		/// </summary>
		private bool _EnabledTimer = true;
		/// <summary>
		/// 服务执行状态
		/// </summary>
		private ServiceStatus _serviceStatus = ServiceStatus.Sleep;
		/// <summary>
		/// 时间计算类
		/// </summary>
		private TimerControl _timerControl = null;
		/// <summary>
		/// 定时器配置
		/// </summary>
		ServiceTimeConfig Config;
		#endregion

		#region 公共属性
		/// <summary>
		/// 获取服务状态
		/// </summary>
		public ServiceStatus ServiceStatus { get { return _serviceStatus; } }
		/// <summary>
		/// 计时模式
		/// </summary>
		public TimerMode TimerMode
		{
			get
			{
				if ( Config == null ) Config = this.GetTimerConfig();

				return Config.TimerMode;
			}
		}
		/// <summary>
		/// 计时配置
		/// </summary>
		public string StartTime { get { return ( Config == null ) ? "" : Config.StartTime; } }
		/// <summary>
		/// 时间计算类
		/// </summary>
		public TimerControl TimerControl
		{
			get
			{
				if ( Config == null )
					Config = this.GetTimerConfig();
				if ( _timerControl == null )
					_timerControl = new TimerControl( this.Config.StartTime, this.Config.TimerMode );

				return _timerControl;
			}
		}
		#endregion

		/// <summary>
		/// 停止
		/// </summary>
		public void Stop()
		{
			_EnabledTimer = false;

			SysTimer.Change( Timeout.Infinite, Timeout.Infinite );
		}
		/// <summary>
		/// 开始服务
		/// </summary>
		public void Start()
		{
			_EnabledTimer = true;
			Config = this.GetTimerConfig();

			SysTimer = new Timer( new TimerCallback( this.TimerProcess ), AppDomain.CurrentDomain, 0, this.Config.ChkInterval );
		}
		/// <summary>
		/// 处理间隔服务
		/// </summary>
		/// <param name="sender"></param>
		private void TimerProcess( object sender )
		{
			if ( !_EnabledTimer ) return;

			bool TimeIsUp = true;
			if ( this.Config.TimerMode != TimerMode.Interval )
			{
				// 如果定时方式不是定时轮询的话，就构造TimerControl类，该类用来计算每次执行完程序后
				// 到下次执行服务时需要休眠的时间
				try
				{
					_timerControl = new TimerControl( this.Config.StartTime, this.Config.TimerMode );
					TimeIsUp = _timerControl.TimeIsUp;	// 获取是否到了执行服务程序的时间了
				}
				catch ( Exception ex )
				{
					// 读取配置出错且TimerControl对象已不存在，则再抛出异常
					// 如果上一次读取配置成功，那就就算这次的配置有问题，则也不会停止程序的运行，仍用上一次的数据做为参数
					if ( _timerControl == null ) throw ex;
				}
			}

			try
			{
				if ( TimeIsUp )// 时间到了可以执行程序了
				{
					// 服务运行了
					_serviceStatus = ServiceStatus.Running;

					// 设置计时器，在无穷时间后再启用（实际上就是永远不启动计时器了--停止计时器计时）
					SysTimer.Change( Timeout.Infinite, this.Config.ChkInterval );

					//开始处理服务
					this.StartService();
				}
			}
			catch ( Exception ex ) { this.ServiceException( ex ); }	// 处理服务执行过程中出现的异常
			finally
			{
				// 如果计时器不为空，则重新设置休眠的时间
				if ( SysTimer != null )
				{
					if ( this.Config.TimerMode == TimerMode.Interval )// 定时轮询设置
					{
						// 重新启用计时器
						SysTimer.Change( this.Config.ChkInterval, this.Config.ChkInterval );
					}
					else// 定时设置
					{
						// 用cft类计算下一次到期的时间
						TimeSpan Interval = _timerControl.GetNextTimeUp();
						// 重新启用计时器
						SysTimer.Change( Interval, Interval );
					}
				}
				_serviceStatus = ServiceStatus.Sleep;
			}
		}
		/// <summary>
		/// 开始服务
		/// </summary>
		protected abstract void StartService();
		/// <summary>
		/// 定时器初始化
		/// </summary>
		/// <param name="TimerMode"></param>
		/// <param name="StartTime"></param>
		/// <param name="ChkInterval"></param>
		protected abstract ServiceTimeConfig GetTimerConfig();
		/// <summary>
		/// 系统服务错误
		/// </summary>
		/// <param name="ex"></param>
		protected virtual void ServiceException( Exception ex ) { return; }
	}

	#region 定时器相关实体类
	/// <summary>
	/// 服务定时器配置
	/// </summary>
	public class ServiceTimeConfig
	{
		/// <summary>
		/// 轮询目录时间间隔（单位：毫秒）
		/// </summary>
		public int ChkInterval { get; set; }
		/// <summary>
		/// StartTime值为：
		/// 
		/// TimerMode=TimerMode.Month	"09|04:30"	-表示每月9号的凌晨4点30分
		///	TimerMode=TimerMode.Week	 "0|04:30"	-表示每星期天的4点30分
		/// TimerMode=TimerMode.Week	 "6|04:00"	-表示每星期6的4点30分
		///	TimerMode=TimerMode.Day		  "|04:00"	-表示每天的4点00分
		///	TimerMode=TimerMode.Date "08-10|04:00"	-表示每年8月10号的4点00分执行一次
		///	TimerMode=TimerMode.Year   "246|04"		-表示每年第246天的4点00分执行一次（可以不填写分钟默认为00）
		/// </summary>
		public string StartTime { get; set; }
		/// <summary>
		/// 服务器定时处理模型
		/// </summary>
		public TimerMode TimerMode { get; set; }
	}
	/// <summary>
	/// 服务处理方法
	/// </summary>
	public enum TimerMode
	{
		/// <summary>
		/// 轮询方式
		/// </summary>
		Interval = 0,
		/// <summary>
		/// 一个月中某个天数的指定时间
		/// </summary>
		Month = 1,
		/// <summary>
		/// 一周中的周几的指定时间
		/// </summary>
		Week = 2,
		/// <summary>
		/// 一天中的指定时间
		/// </summary>
		Day = 3,
		/// <summary>
		/// 一年中第几天的指定时间
		/// </summary>
		Year = 4,
		/// <summary>
		/// 一年中的指定日期的指定时间
		/// </summary>
		Date = 5,
		/// <summary>
		/// 未设置
		/// </summary>
		NoSet
	}
	/// <summary>
	/// 服务处理方法
	/// </summary>
	public enum ServiceStatus
	{
		/// <summary>
		/// 休眠中
		/// </summary>
		Sleep = 0,
		/// <summary>
		/// 服务在执行过程中
		/// </summary>
		Running = 1
	}
	#endregion

	#region 定时服务休眠时间计算类
	/// <summary>
	/// 定时服务休眠时间计算类
	/// </summary>
	public class TimerControl
	{
		#region 私有成员
		/// <summary>
		/// 间隔单位
		/// </summary>
		private TimerMode type;
		/// <summary>
		/// 月份
		/// </summary>
		private int Month;
		/// <summary>
		/// 天
		/// </summary>
		private int Day;
		/// <summary>
		/// 小时
		/// </summary>
		private int Hour;
		/// <summary>
		/// 分钟
		/// </summary>
		private int Minute = 0;
		#endregion

		#region 公共成员方法
		/// <summary>
		/// StartTime值为：
		/// 
		/// TimerMode=TimerMode.Month	"09|04:30"	-表示每月9号的凌晨4点30分
		///	TimerMode=TimerMode.Week	 "0|04:30"	-表示每星期天的4点30分
		/// TimerMode=TimerMode.Week	 "6|04:00"	-表示每星期6的4点30分
		///	TimerMode=TimerMode.Day		  "|04:00"	-表示每天的4点00分
		///	TimerMode=TimerMode.Date "08-10|04:00"	-表示每年8月10号的4点00分执行一次
		///	TimerMode=TimerMode.Year   "246|04"		-表示每年第246天的4点00分执行一次（可以不填写分钟默认为00）
		/// </summary>
		/// <param name="StartTime"></param>
		/// <param name="timeMode"></param>
		public TimerControl( string StartTime, TimerMode timeMode )
		{
			//Regex regEx = new Regex( @"(?<Type>[MWDY])(?<Days>/d+)?/|(?<Hour>/d+):?(?<Minute>[0-5]/d?)?", RegexOptions.Compiled | RegexOptions.IgnoreCase );
			Regex regEx = new Regex( @"^(?:(?<Month>[0]?/d|1[0-2])-)?(?<Days>/d{1,3})?/|(?<Hour>[01]?/d|2[0-3])(?::(?<Minute>[0-5]/d?))?$", RegexOptions.Compiled | RegexOptions.IgnoreCase );

			this.type = timeMode;

			Match m = regEx.Match( StartTime );
			if ( m.Success )
			{
				if ( String.IsNullOrEmpty( m.Groups["Month"].Value ) && this.type == TimerMode.Date )
					throw new Exception( "定时器时间配置异常！" );

				if ( !String.IsNullOrEmpty( m.Groups["Month"].Value ) )
					this.Month = Convert.ToInt32( m.Groups["Month"].Value );

				if ( !String.IsNullOrEmpty( m.Groups["Days"].Value ) )
					this.Day = Convert.ToInt32( m.Groups["Days"].Value );

				this.Hour = Convert.ToInt32( m.Groups["Hour"].Value );

				if ( !String.IsNullOrEmpty( m.Groups["Minute"].Value ) )
					this.Minute = Convert.ToInt32( m.Groups["Minute"].Value );
			}
			else
				throw new Exception( "定时器时间配置异常！" );
		}
		/// <summary>
		/// 判断时间是否到了
		/// </summary>
		/// <returns></returns>
		public bool TimeIsUp
		{
			get
			{
				DateTime dt = DateTime.Now;
				switch ( type )
				{
					case TimerMode.Day:
						return ( dt.Hour == this.Hour && dt.Minute == this.Minute );
					case TimerMode.Month:
						return ( dt.Day == this.Day && dt.Hour == this.Hour && dt.Minute == this.Minute );
					case TimerMode.Week:
						return ( ( ( int )dt.DayOfWeek ) == this.Day && dt.Hour == this.Hour && dt.Minute == this.Minute );
					case TimerMode.Date:
						return ( dt.Month == this.Month && dt.Day == this.Day && dt.Hour == this.Hour && dt.Minute == this.Minute );
					case TimerMode.Year:
						return ( dt.DayOfYear == this.Day && dt.Hour == this.Hour && dt.Minute == this.Minute );
				}
				return false;
			}
		}
		/// <summary>
		/// 从现在起到下次时间到还有多少时间
		/// </summary>
		/// <returns></returns>
		public TimeSpan GetNextTimeUp()
		{
			///目标时间
			DateTime _NextDateTime = this.GetNextDateTime();	// 保存下一次要执行的时间
			TimeSpan NextCrtFileTime = _NextDateTime - DateTime.Now;

			if ( ( int )NextCrtFileTime.TotalMilliseconds > int.MaxValue )	// 如果要休眠的时间间隔超过int类型可以表示的毫秒时，先休眠到int.MaxValue,然后再次休眠
				NextCrtFileTime = new TimeSpan( int.MaxValue );

			return NextCrtFileTime;
		}
		/// <summary>
		/// 获取下一次指定配置的时间是多少
		/// </summary>
		/// <returns></returns>
		public DateTime GetNextDateTime()
		{
			DateTime dt = DateTime.Now;
			DateTime now, target;
			switch ( this.type )
			{
				case TimerMode.Day:
					#region 每天指定某时执行一次
					now = new DateTime( 1, 1, 1, dt.Hour, dt.Minute, 0 );
					target = new DateTime( 1, 1, 1, this.Hour, this.Minute, 0 );
					if ( now.Ticks >= target.Ticks ) dt = dt.AddDays( 1.0 );	//如果当前时间小于指定时刻，则不需要加天

					dt = new DateTime( dt.Year, dt.Month, dt.Day, this.Hour, this.Minute, 0 );
					#endregion
					break;
				case TimerMode.Month:
					#region 每月指定某天某时执行一次
					now = new DateTime( 1, 1, dt.Day, dt.Hour, dt.Minute, 0 );
					target = new DateTime( 1, 1, this.Day, this.Hour, this.Minute, 0 );
					if ( now.Ticks >= target.Ticks ) dt = dt.AddMonths( 1 );

					dt = new DateTime( dt.Year, dt.Month, this.Day, this.Hour, this.Minute, 0 );
					#endregion
					break;
				case TimerMode.Week:
					#region 每星期指定星期某时执行一次
					int dow = ( int )dt.DayOfWeek;
					now = new DateTime( 1, 1, dow + 1, dt.Hour, dt.Minute, 0 );
					target = new DateTime( 1, 1, this.Day + 1, this.Hour, this.Minute, 0 );

					if ( now.Ticks >= target.Ticks )
						dt = dt.AddDays( this.Day - dow + 7 );
					else
						dt = dt.AddDays( this.Day - dow );

					dt = new DateTime( dt.Year, dt.Month, dt.Day, this.Hour, this.Minute, 0 );
					#endregion
					break;
				case TimerMode.Date:
					#region 每年指定某月某日某时执行一次
					now = new DateTime( 1, dt.Month, dt.Day, dt.Hour, dt.Minute, 0 );
					target = new DateTime( 1, this.Month, this.Day, this.Hour, this.Minute, 0 );
					if ( now.Ticks >= target.Ticks ) dt = dt.AddYears( 1 );

					dt = new DateTime( dt.Year, this.Month, this.Day, this.Hour, this.Minute, 0 );
					#endregion
					break;
				case TimerMode.Year:
					#region 每年指定第N天某时执行一次
					now = new DateTime( 1, 1, 1, dt.Hour, dt.Minute, 0 );
					target = new DateTime( 1, 1, 1, this.Hour, this.Minute, 0 );
					if ( dt.DayOfYear > this.Day || dt.DayOfYear == this.Day && now.Ticks >= target.Ticks ) dt = dt.AddYears( 1 );
					dt = dt.AddDays( this.Day - dt.DayOfYear );

					dt = new DateTime( dt.Year, dt.Month, dt.Day, this.Hour, this.Minute, 0 );
					#endregion
					break;
				default:
					throw new Exception( "定时器时间配置异常！" );
			}

			return dt;
		}
		#endregion
	}
	#endregion
}