c# - 在 Windows 服务中使用的最佳计时器

Question

我需要创建一些 Windows 服务，它将每 N 段时间执行一次。
问题是：
我应该使用哪个计时器控件：System.Timers.Timer还是System.Threading.Timer一个？它对某事有影响吗？

我之所以问，是因为我听到了许多证据表明System.Timers.TimerWindows 服务中的工作不正确。
谢谢你。

Answer 1

两者都System.Timers.Timer将为System.Threading.Timer服务工作。

您要避免的计时器是System.Web.UI.Timer和System.Windows.Forms.Timer，它们分别用于 ASP 应用程序和 WinForms。使用这些将导致服务加载一个额外的程序集，这对于您正在构建的应用程序类型来说并不真正需要。

像以下示例一样使用System.Timers.Timer（另外，请确保使用类级别变量来防止垃圾收集，如 Tim Robinson 的回答中所述）：

using System;
using System.Timers;

public class Timer1
{
    private static System.Timers.Timer aTimer;

    public static void Main()
    {
        // Normally, the timer is declared at the class level,
        // so that it stays in scope as long as it is needed.
        // If the timer is declared in a long-running method,  
        // KeepAlive must be used to prevent the JIT compiler 
        // from allowing aggressive garbage collection to occur 
        // before the method ends. (See end of method.)
        //System.Timers.Timer aTimer;

        // Create a timer with a ten second interval.
        aTimer = new System.Timers.Timer(10000);

        // Hook up the Elapsed event for the timer.
        aTimer.Elapsed += new ElapsedEventHandler(OnTimedEvent);

        // Set the Interval to 2 seconds (2000 milliseconds).
        aTimer.Interval = 2000;
        aTimer.Enabled = true;

        Console.WriteLine("Press the Enter key to exit the program.");
        Console.ReadLine();

        // If the timer is declared in a long-running method, use
        // KeepAlive to prevent garbage collection from occurring
        // before the method ends.
        //GC.KeepAlive(aTimer);
    }

    // Specify what you want to happen when the Elapsed event is 
    // raised.
    private static void OnTimedEvent(object source, ElapsedEventArgs e)
    {
        Console.WriteLine("The Elapsed event was raised at {0}", e.SignalTime);
    }
}

/* This code example produces output similar to the following:

Press the Enter key to exit the program.
The Elapsed event was raised at 5/20/2007 8:42:27 PM
The Elapsed event was raised at 5/20/2007 8:42:29 PM
The Elapsed event was raised at 5/20/2007 8:42:31 PM
...
 */

如果选择System.Threading.Timer，可以按如下方式使用：

using System;
using System.Threading;

class TimerExample
{
    static void Main()
    {
        AutoResetEvent autoEvent     = new AutoResetEvent(false);
        StatusChecker  statusChecker = new StatusChecker(10);

        // Create the delegate that invokes methods for the timer.
        TimerCallback timerDelegate = 
            new TimerCallback(statusChecker.CheckStatus);

        // Create a timer that signals the delegate to invoke 
        // CheckStatus after one second, and every 1/4 second 
        // thereafter.
        Console.WriteLine("{0} Creating timer.\n", 
            DateTime.Now.ToString("h:mm:ss.fff"));
        Timer stateTimer = 
                new Timer(timerDelegate, autoEvent, 1000, 250);

        // When autoEvent signals, change the period to every 
        // 1/2 second.
        autoEvent.WaitOne(5000, false);
        stateTimer.Change(0, 500);
        Console.WriteLine("\nChanging period.\n");

        // When autoEvent signals the second time, dispose of 
        // the timer.
        autoEvent.WaitOne(5000, false);
        stateTimer.Dispose();
        Console.WriteLine("\nDestroying timer.");
    }
}

class StatusChecker
{
    int invokeCount, maxCount;

    public StatusChecker(int count)
    {
        invokeCount  = 0;
        maxCount = count;
    }

    // This method is called by the timer delegate.
    public void CheckStatus(Object stateInfo)
    {
        AutoResetEvent autoEvent = (AutoResetEvent)stateInfo;
        Console.WriteLine("{0} Checking status {1,2}.", 
            DateTime.Now.ToString("h:mm:ss.fff"), 
            (++invokeCount).ToString());

        if(invokeCount == maxCount)
        {
            // Reset the counter and signal Main.
            invokeCount  = 0;
            autoEvent.Set();
        }
    }
}

这两个示例都来自 MSDN 页面。

Answer 2

不要为此使用服务。创建一个普通的应用程序并创建一个计划任务来运行它。

这是通常持有的最佳实践。 乔恩·加洛韦同意我的看法。或者也许它反过来。 无论哪种方式，事实是创建 Windows 服务来执行间歇性任务运行计时器不是最佳实践。

“如果你正在编写一个运行计时器的 Windows 服务，你应该重新评估你的解决方案。”

——Jon Galloway，ASP.NET MVC 社区项目经理，作家，兼职超级英雄

Answer 3

任何一个都应该可以正常工作。事实上，System.Threading.Timer 在内部使用 System.Timers.Timer。

话虽如此，很容易误用 System.Timers.Timer。如果您不将 Timer 对象存储在某个变量中，那么它很可能被垃圾收集。如果发生这种情况，您的计时器将不再触发。调用 Dispose 方法来停止计时器，或者使用 System.Threading.Timer 类，它是一个稍微好一点的包装器。

到目前为止，您发现了哪些问题？

Answer 4

我同意之前可能最好考虑不同方法的评论。我的建议是编写一个控制台应用程序并使用 Windows 调度程序：

这会：

• 减少复制调度程序行为的管道代码
• 在调度行为方面提供更大的灵活性（例如仅在周末运行），所有调度逻辑都从应用程序代码中抽象出来
• 利用命令行参数作为参数，而无需在配置文件等中设置配置值
• 在开发过程中更容易调试/测试
• 允许支持用户通过直接调用控制台应用程序来执行（例如，在支持情况下很有用）

Answer 5

如前所述，两者都System.Threading.Timer将System.Timers.Timer起作用。两者之间的最大区别在于System.Threading.Timer另一个包装器。

System.Threading.Timer将有更多的异常处理，同时 System.Timers.Timer会吞下所有的异常。

这在过去给了我很大的问题，所以我总是使用'​​System.Threading.Timer'并且仍然很好地处理你的异常。

Answer 6

我知道这个线程有点旧，但它在我遇到的特定场景中派上了用场，我认为值得一提的是，还有另一个原因System.Threading.Timer可能是一个好方法。当您必须定期执行可能需要很长时间的作业并且您希望确保在作业之间使用整个等待时间，或者您不希望作业在前一个作业完成之前再次运行时作业花费的时间比计时器周期长。您可以使用以下内容：

using System;
using System.ServiceProcess;
using System.Threading;

    public partial class TimerExampleService : ServiceBase
    {
        private AutoResetEvent AutoEventInstance { get; set; }
        private StatusChecker StatusCheckerInstance { get; set; }
        private Timer StateTimer { get; set; }
        public int TimerInterval { get; set; }

        public CaseIndexingService()
        {
            InitializeComponent();
            TimerInterval = 300000;
        }

        protected override void OnStart(string[] args)
        {
            AutoEventInstance = new AutoResetEvent(false);
            StatusCheckerInstance = new StatusChecker();

            // Create the delegate that invokes methods for the timer.
            TimerCallback timerDelegate =
                new TimerCallback(StatusCheckerInstance.CheckStatus);

            // Create a timer that signals the delegate to invoke 
            // 1.CheckStatus immediately, 
            // 2.Wait until the job is finished,
            // 3.then wait 5 minutes before executing again. 
            // 4.Repeat from point 2.
            Console.WriteLine("{0} Creating timer.\n",
                DateTime.Now.ToString("h:mm:ss.fff"));
            //Start Immediately but don't run again.
            StateTimer = new Timer(timerDelegate, AutoEventInstance, 0, Timeout.Infinite);
            while (StateTimer != null)
            {
                //Wait until the job is done
                AutoEventInstance.WaitOne();
                //Wait for 5 minutes before starting the job again.
                StateTimer.Change(TimerInterval, Timeout.Infinite);
            }
            //If the Job somehow takes longer than 5 minutes to complete then it wont matter because we will always wait another 5 minutes before running again.
        }

        protected override void OnStop()
        {
            StateTimer.Dispose();
        }
    }

    class StatusChecker
        {

            public StatusChecker()
            {
            }

            // This method is called by the timer delegate.
            public void CheckStatus(Object stateInfo)
            {
                AutoResetEvent autoEvent = (AutoResetEvent)stateInfo;
                Console.WriteLine("{0} Start Checking status.",
                    DateTime.Now.ToString("h:mm:ss.fff"));
                //This job takes time to run. For example purposes, I put a delay in here.
                int milliseconds = 5000;
                Thread.Sleep(milliseconds);
                //Job is now done running and the timer can now be reset to wait for the next interval
                Console.WriteLine("{0} Done Checking status.",
                    DateTime.Now.ToString("h:mm:ss.fff"));
                autoEvent.Set();
            }
        }