timer计时器的问题

Posted 2023-05-07

在Global.asax中的代码如下：
<%@ Application Language="C#" %>
<%@ Import Namespace="System.Timers" %>

<script runat="server">

void Application_Start(object sender, EventArgs e)

// 在应用程序启动时运行的代码
Timer aTimer = new Timer(1000);
aTimer .Elapsed +=new ElapsedEventHandler(aTimer_Elapsed);
aTimer.AutoReset = true;
aTimer.Enabled = true;
Application.Lock();
Application["TimeStamp"] = DateTime.Now.ToString();
Application.UnLock();

private void aTimer_Elapsed( object sender,ElapsedEventArgs e)

Application.Lock();
Application["TimeStamp"] = DateTime.Now.ToString();
Application.UnLock();


请问各位高手如何在Default.aspx中写代码才能动态的显示时间
我写的是
response.write(Application["TimeStamp"]);但显示的只是一个不变的时间
这个例子是我从CSDN那里抄来的，大体是这样只是有些变量名或函数名我给改了，它的答案是：
<% response.write(Application["TimeStamp"]);%>
我也看不懂这是什么意思。这位大哥，可不可以给我做个具体点的实例呢。

参考技术A 因为你的 Timer 对象是的作用域为局部作用域，，在执行完Application_Start函数之后，就超出它的作用域了，，所以.net的垃圾回收机制可能会认为这个对象没有人使用了，会释放这个对象。

为了解决这个问题，你可以考虑用其它的办法使.net不删除该Timer对象，其实很简单，只要它的对象引用计数不为0就可以了。只要保证在你需要它运行的期间内的任意时刻，都有一个或者多个引用存在或者把它设为静态变量，增长它的生命周期。

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

【中文标题】在 Windows 服务中使用的最佳计时器

【英文标题】：Best Timer for using in a Windows service

【发布时间】：2010-09-19 18:56:03

【问题描述】：

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

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

【参考方案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 页面。

【讨论】：

为什么建议：GC.KeepAlive(aTimer);，aTimer是实例变量对的，比如如果是form的实例变量，只要有，总会有引用形式，不是吗？

【参考方案2】：

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

这是普遍采用的最佳做法。 Jon Galloway agrees with me. Or maybe its the other way around. 无论哪种方式，事实是创建一个 Windows 服务来执行一个不定时运行的间歇性任务并不是最佳实践。

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

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

【讨论】：

如果您的服务打算全天运行，那么也许服务比计划任务更有意义。或者，对于不像应用程序团队那么精明的基础设施组，拥有一项服务可能会简化管理和日志记录。然而，质疑需要服务的假设是完全正确的，这些负面评价是不值得的。对两者都 +1。

@m.r.废话。计划任务是操作系统的核心部分。请将您的 FUD 保密。

@M.R.：我不是传道者，我是现实主义者。现实告诉我，计划任务并不是“非常错误的”。事实上，这取决于你作为声称支持它的人。否则，你所做的只是散播恐惧、不确定性和怀疑。

我不想涉足这里的泥潭，但我必须为 M.R. 稍微辩护一下。我的公司中有几个关键应用程序正在运行，它们是 Windows 控制台应用程序。我已经使用 Windows 任务计划程序来运行所有这些。现在至少有 5 次，我们遇到了调度程序服务以某种方式“混淆”的问题。任务没有执行，有些处于奇怪的状态。唯一的解决方案是重新启动服务器或停止和启动调度程序服务。没有管理员权限，我不能做任何事情，并且在生产环境中是不可接受的。只是我的 0.02 美元。

这实际上发生在我的几台服务器上（到目前为止 3 台）。不会说这是常态。只是说有时候实现自己的做事方法也不错。

【参考方案3】：

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

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

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

【讨论】：

让我想知道为什么 Windows Phone 应用程序只能访问 System.Threading.Timer。

windows 手机可能有一个较轻版本的框架，可能不需要所有额外的代码来使用这两种方法，因此不包括在内。我认为尼克的回答为 Windows 手机无法访问System.Timers.Timer 提供了一个更好的理由，因为它不会处理抛出给它的异常。

【参考方案4】：

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

这将：

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

【讨论】：

但这需要登录用户？因此，如果它能够在服务器上 24/7 全天候运行，服务可能会更好。

【参考方案5】：

如前所述，System.Threading.Timer 和 System.Timers.Timer 都可以使用。两者之间的最大区别在于System.Threading.Timer 是另一个包装器。

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

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

【参考方案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();