定时器辅助类TimerHelper，可指定运行间隔、延迟启动时间等操作

实现效果

1. 本辅助类主要是用来方便实现定时器辅助类，可指定运行间隔、延迟启动时间等操作。功能和另外一个定时器辅助类Timer差不多。
2. 定时器操作，都通过对象锁以及在运行处理事件的时候，动态改变间隔事件为无限等待，处理完成后修改为间隔时间的方式，实现对定时器的正常、安全执行，不会发生运行一半又跳到下一个的处理过程中。
3. .NET提供了3种定时器实现，他们的特点如下所示。TimerHelper是基于Threading.Timer的定时器实现。

名称	命名空间	描述
Server Timers	System.Timers.Timer	基于服务器的计时器，位于"工具箱"的“组件”选项卡上
Thread Timers	System.Threading.Timer	在编程时使用的线程计时器
Windows Timers	System.Windows.Forms.Timer	基于 Windows 的标准计时器，"工具箱"的"Windows 窗体"选项卡上；

实现步骤

在代码引用相关的代码实现动态调用。

实现代码

/// <summary>
/// 定时器执行操作的函数原型
/// </summary>
public delegate void TimerExecution();
/// <summary>
/// 定时器执行时调用的操作
/// </summary>
public event TimerExecution Execute;
/// <summary>
/// 创建一个指定时间间隔的定时器，并在指定的延迟后开始启动。（默认间隔为100毫秒）
/// </summary>
public TimerHelper()
/// <summary>
/// 创建一个指定时间间隔的定时器，并在指定的延迟后开始启动。
/// </summary>
public TimerHelper(long interval, int startDelay)
/// <summary>
/// 创建一个指定时间间隔的定时器
/// </summary>
public TimerHelper(long interval, bool start)
/// <summary>
/// 启动定时器并指定延迟时间（毫秒）
/// </summary>
public void Start(int delayBeforeStart)
/// <summary>
/// 立即启动定时器
/// </summary>
public void Start()
/// <summary>
/// 暂停定时器
/// </summary>
public void Pause()
/// <summary>
/// 停止定时器
/// </summary>
public void Stop()
/// <summary>
/// 定时器的处理时间
/// </summary>
public void Tick(object obj)
/// <summary>
/// 定时器的状态
/// </summary>
public TimerState State
/// <summary>
/// 获取或设置定时器的运行间隔
/// </summary>
public long Interval

2. 辅助类TimerHelper的使用例子代码如下所示：

public FrmNewForm()
{
InitializeComponent();
if (!this.DesignMode)
{
//使用定时器，定时刷新窗体的数据，并提示客户更新情况
int interval = Portal.gc.GetRefreshSecond();//获取定时间隔时间
TimerHelper timer = new TimerHelper(interval, true);
timer.Execute += new TimerHelper.TimerExecution(timer_Execute);
}
}
//通过Invoke来实现跨线程间的调用
void timer_Execute()
{
if (!this.InvokeRequired)
return;
this.Invoke(new MethodInvoker(delegate()
{
NotifyNewHouse();
}));
}

附上源码

     /// <summary>
    /// 定时器辅助类，可指定运行间隔、延迟启动时间等操作。
    /// </summary>
    [Serializable]
    public class TimerHelper : System.ComponentModel.Component
    {
        private System.Threading.Timer timer;
        private long timerInterval;
        private TimerState timerState;

        /// <summary>
        /// 定时器执行操作的函数原型
        /// </summary>
        public delegate void TimerExecution();

        /// <summary>
        /// 定时器执行时调用的操作
        /// </summary>
        public event TimerExecution Execute;

        /// <summary>
        /// 创建一个指定时间间隔的定时器，并在指定的延迟后开始启动。（默认间隔为100毫秒）
        /// </summary>
        public TimerHelper()
        {
            timerInterval = 100;
            timerState = TimerState.Stopped;
            timer = new System.Threading.Timer(new TimerCallback(Tick), null, Timeout.Infinite, timerInterval);
        }


        /// <summary>
        /// 创建一个指定时间间隔的定时器，并在指定的延迟后开始启动。
        /// </summary>
        /// <param name="interval">定时器执行操作的间隔时间（毫秒）</param>
        /// <param name="startDelay">指定的延迟时间（毫秒）</param>
        public TimerHelper(long interval, int startDelay)
        {
            timerInterval = interval;
            timerState = (startDelay == Timeout.Infinite) ? TimerState.Stopped : TimerState.Running;
            timer = new System.Threading.Timer(new TimerCallback(Tick), null, startDelay, interval);
        }

        /// <summary>
        /// 创建一个指定时间间隔的定时器
        /// </summary>
        /// <param name="interval">定时器执行操作的间隔时间（毫秒）</param>
        /// <param name="start">是否启动</param>
        public TimerHelper(long interval, bool start)
        {
            timerInterval = interval;
            timerState = (!start) ? TimerState.Stopped : TimerState.Running;
            timer = new System.Threading.Timer(new TimerCallback(Tick), null, 0, interval);
        }

        /// <summary>
        /// 启动定时器并指定延迟时间（毫秒）
        /// </summary>
        /// <param name="delayBeforeStart">指定延迟时间（毫秒）</param>
        public void Start(int delayBeforeStart)
        {
            timerState = TimerState.Running;
            timer.Change(delayBeforeStart, timerInterval);
        }

        /// <summary>
        /// 立即启动定时器
        /// </summary>
        public void Start()
        {
            timerState = TimerState.Running;
            timer.Change(0, timerInterval);
        }

        /// <summary>
        /// 暂停定时器
        /// 注意：运行中的线程不会被停止
        /// </summary>
        public void Pause()
        {
            timerState = TimerState.Paused;
            timer.Change(Timeout.Infinite, timerInterval);
        }

        /// <summary>
        /// 停止定时器
        /// 注意：运行中的线程不会被停止
        /// </summary>
        public void Stop()
        {
            timerState = TimerState.Stopped;
            timer.Change(Timeout.Infinite, timerInterval);
        }

        /// <summary>
        /// 定时器的处理时间
        /// </summary>
        /// <param name="obj"></param>
        public void Tick(object obj)
        {
            if (timerState == TimerState.Running && Execute != null)
            {
                lock (this)
                {
                    Execute();
                }
            }
        }

        /// <summary>
        /// 定时器的状态
        /// </summary>
        public TimerState State
        {
            get
            {
                return timerState;
            }
        }

        /// <summary>
        /// 获取或设置定时器的运行间隔
        /// </summary>
        public long Interval
        {
            get
            {
                return timerInterval;
            }
            set
            {
                timer.Change(((timerState == TimerState.Running) ? value : Timeout.Infinite), value);
            }
        }
    }

    /// <summary>
    /// 定时器状态
    /// </summary>
    public enum TimerState
    {
        /// <summary>
        /// 停止
        /// </summary>
        Stopped,
        /// <summary>
        /// 运行中
        /// </summary>
        Running,
        /// <summary>
        /// 暂停
        /// </summary>
        Paused
    }