From: 011netservice@gmail.com
Date: 2022-04-24
Date: 2020-02-19

----------
20200219

Item         System.Timers.Timer System.Threading.Timer System.Windows.Forms.Timer System.Web.UI.Timer
------------ ------------------- ---------------------- -------------------------- -------------------
UI           N                   N                      Y                          Y
定時啟動     Y                   Y                      N                          Y
重複啟動     Y                   Y                      N
多執行緒     Y                   Y                      N                          Y
控制方式     EventHandler        Callback function      EventHandler               ASP.NET Ajax         
首次執行時間 Y                   Y
IDisposable  Y                   N
相容舊版     N                   Y  
------------ ------------------- ---------------------- -------------------------- -------------------
* 重複啟動: 重複啟動: Timer工作逾時, 導致本次 Timer 工作未完成前, 就已經重複啟動下一次的 Timer 工作.
* 相容舊版: 可使用於較舊版的 .net framework. 例如.NET Standard 1.6 和較低版本.
* IDisposable: 可使用using 語法控制.


----------
20180927

http://paladinprogram.blogspot.tw/2013/09/rdlc.html


The .NET Framework Class Library includes four classes named Timer, each of which offers different functionality: 

•System.Timers.Timer, 
建議第一優先使用. 
which fires an event and executes the code in one or more event sinks at regular intervals. The class is intended for use as a server-based or service component in a multithreaded environment; it has no user interface and is not visible at runtime. 
1. 使用於server-based or service component的多執行緒環境中, 無UI.
2. 不適用於所有.NET 實作和版本，例如.NET Standard 1.6 和較低版本。 在這些情況下，您可以使用System.Threading.Timer類別
3. 使用 event 方式控制.
4. 定時發出 event. 只要時間一到, 就會呼叫 ElapseEventHandler,  即使 前次的event job尚未完成也會照樣發出event, 不受 event job的工作時間影響.
5. 可指定首次執行前的等待時間.
6. 已實作 IDisposable, 可使用using 語法控制.
7. 通常於 Class level 內宣告 Timer物件, 直到物件結束. 


•System.Threading.Timer, 
建議第二優先使用.
which executes a single callback method on a thread pool thread at regular intervals. The callback method is defined when the timer is instantiated and cannot be changed. Like the System.Timers.Timer class, this class is intended for use as a server-based or service component in a multithreaded environment; it has no user interface and is not visible at runtime. 
1. 使用於server-based or service component的多執行緒環境中, 無UI.
2. 不建議使用於 Windows Form, 因為其 callback 不會發生在使用者介面執行緒上.
3. 使用 callback函數 方式控制.
4. 定時呼叫 callback函數. 只要時間一到, 就會呼叫 callback函數,  即使 前次的 callback job尚未完成也會照樣呼叫 callback函數, 不受 callback job的工作時間影響.
5. 可指定首次執行前的等待時間.


•System.Windows.Forms.Timer, 
a Windows Forms component that fires an event and executes the code in one or more event sinks at regular intervals. The component has no user interface and is designed for use in a single-threaded environment; it executes on the UI thread. 
1. 使用於Windows.Form
2. 跟主執行緒使用同一個執行緒.
3. 循環時間為(Timer interval + job執行時間). 若Job執行時間, 超過Timer Interval時間, 則循環執行時間不固定.


•System.Web.UI.Timer, 
an ASP.NET component that performs asynchronous or synchronous web page postbacks at a regular interval. 
1. 使用於ASP.NET
2. 可定時以非同步方式更新網頁之UpdatePanel至client端.

----------
若需要準時於(每分鐘0秒)時, 或(每小時0分0秒)時執行, 應如何控制?
例如: 
若於01:01:01時啟動timer, 需要控制於01:02:00首次執行, 並且之後每分鐘0秒時循環執行, 應如何控制:
Ans:
參考如下, 設定於timer的首次執行/每次執行等待時間:
// 每分鐘0秒準時執行.
DateTime t1 = DateTime.Now;
DateTime t2 = t1.AddMinutes(1);
DateTime t3 = new DateTime(t2.Year, t2.Month, t2.Day, t2.Hour, t2.Minute, 0, 0);
double dDueTimeMs = (t3 - t1).TotalMilliseconds;  // 首次執行需要等待的ms.
double dPeriodMs = (t2 - t1).TotalMilliseconds;   // 每分鐘之ms, 這是固定值, 可訂為常數, 不需要每次計算.

// 每小時0分0秒準時執行.
DateTime th1 = DateTime.Now;
DateTime th2 = th1.AddHours(1);
DateTime th3 = new DateTime(th2.Year, th2.Month, th2.Day, th2.Hour, 0, 0, 0);
double dhDueTimeMs = (th3 - th1).TotalMilliseconds;  // 首次執行需要等待的ms.
double dhPeriodMs = (th2 - th1).TotalMilliseconds;   // 每小時之ms, 這是固定值, 可訂為常數, 不需要每次計算


----------
System.Timers.Timer

ref:
https://docs.microsoft.com/zh-tw/dotnet/api/system.timers.timer?view=netframework-4.7.2

Sample1: 常用.
同步方式執行

using System;
using System.Timers;

public class Example
{
   private static System.Timers.Timer aTimer;
   
   public static void Main()
   {
      SetTimer();

      Console.WriteLine("\nPress the Enter key to exit the application...\n");
      Console.WriteLine("The application started at {0:HH:mm:ss.fff}", DateTime.Now);
      Console.ReadLine();
      aTimer.Stop();
      aTimer.Dispose();
      
      Console.WriteLine("Terminating the application...");
   }

   private static void SetTimer()
   {
        // Create a timer with a two second interval.
        aTimer = new System.Timers.Timer(2000);
        // Hook up the Elapsed event for the timer. 
        aTimer.Elapsed += OnTimedEvent;
        aTimer.AutoReset = true;
        aTimer.Enabled = true;
    }

    private static void OnTimedEvent(Object source, ElapsedEventArgs e)
    {
        Console.WriteLine("The Elapsed event was raised at {0:HH:mm:ss.fff}",
                          e.SignalTime);
    }
}
// The example displays output like the following:
//       Press the Enter key to exit the application...
//
//       The application started at 09:40:29.068
//       The Elapsed event was raised at 09:40:31.084
//       The Elapsed event was raised at 09:40:33.100
//       The Elapsed event was raised at 09:40:35.100
//       The Elapsed event was raised at 09:40:37.116
//       The Elapsed event was raised at 09:40:39.116
//       The Elapsed event was raised at 09:40:41.117
//       The Elapsed event was raised at 09:40:43.132
//       The Elapsed event was raised at 09:40:45.133
//       The Elapsed event was raised at 09:40:47.148
//
//       Terminating the application...


Sample2: 常用
非同步方式執行

The Timer component catches and suppresses all exceptions thrown by event handlers for the Elapsed event. This behavior is subject to change in future releases of the .NET Framework. Note, however, that this is not true of event handlers that execute asynchronously and include the await operator (in C#) or the Await operator (in Visual Basic). Exceptions thrown in these event handlers are propagated back to the calling thread, as the following example illustrates. For more information on exceptions thrown in asynchronous methods, see Exception Handling. 
Timer元件會攔截，且會抑制所有的事件處理常式所擲回的例外狀況Elapsed事件。 
此行為是在.NET Framework 的未來版本中有所變更。 
不過請注意，這不是 true，以非同步方式執行，並包含事件處理常式await（在 C# 中) 的運算子或Await運算子 （Visual Basic 中）。 在這些事件處理常式中擲回的例外狀況會傳播回呼叫執行緒，如下列範例所示。
 如需有關非同步方法中擲回的例外狀況的詳細資訊，請參閱例外狀況處理。 

using System;
using System.Threading.Tasks;
using System.Timers;

class Example
{
   static void Main()
   {
	 // 當以非同步方式執行，並包含事件處理常式await, 例外狀況會傳播回呼叫執行緒, 不會被Timer元件攔截且抑制來自事件處理常式所擲回的例外狀況.
      Timer timer = new Timer(1000);
      timer.Elapsed += async ( sender, e ) => await HandleTimer();
      timer.Start();
      Console.Write("Press any key to exit... ");
      Console.ReadKey();
   }

   private static Task HandleTimer()
   {
     Console.WriteLine("\nHandler not implemented..." );
     throw new NotImplementedException();
   }
}
// The example displays output like the following:
//   Press any key to exit...
//   Handler not implemented...
//   
//   Unhandled Exception: System.NotImplementedException: The method or operation is not implemented.
//      at Example.HandleTimer()
//      at Example.<<Main>b__0>d__2.MoveNext()
//   --- End of stack trace from previous location where exception was thrown ---
//      at System.Runtime.CompilerServices.AsyncMethodBuilderCore.<>c__DisplayClass2.<ThrowAsync>b__5(Object state)
//      at System.Threading.ExecutionContext.RunInternal(ExecutionContext executionContext, ContextCallback callback, Object state, Boolean preserveSyncCtx)
//      at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state, Boolean preserveSyncCtx)
//      at System.Threading.QueueUserWorkItemCallback.System.Threading.IThreadPoolWorkItem.ExecuteWorkItem()
//      at System.Threading.ThreadPoolWorkQueue.Dispatch()


Sample3:
若 timer 宣告在長時間執行的方法中時, 則需要呼叫 GC.KeepAlive(), 以避免垃圾收集器在函數結束之前將 timer 回收.

// From command line, compile with /r:System.dll
using System;
using System.Timers;

public class Timer2
{
    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 event handler for the Elapsed event.
        aTimer.Elapsed += new ElapsedEventHandler(OnTimedEvent);

        // Only raise the event the first time Interval elapses.
        aTimer.AutoReset = false;
        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("Hello World!");
    }
}

/* This code example produces the following output:

Press the Enter key to exit the program.
Hello World!
 */
----------
global.asax每10分鐘執行一次task

protected void Application_Start(object sender, EventArgs e)
{
  // 每10分鐘執行一次task
  System.Timers.Timer Timer = new System.Timers.Timer(600000);//10分鍾
  Timer.Elapsed += new ElapsedEventHandler(Task);
  Timer.Enabled = true;
  Timer.AutoReset = true;
  Timer.Start();
}
void Task(object source, ElapsedEventArgs e)
{
}

----------
System.Threading.Timer

ref:
https://docs.microsoft.com/zh-tw/dotnet/api/system.threading.timer?view=netframework-4.7.2


using System;
using System.Threading;

class TimerExample
{
    static void Main()
    {
        // Create an AutoResetEvent to signal the timeout threshold in the
        // timer callback has been reached.
        var autoEvent = new AutoResetEvent(false);
        
        var statusChecker = new StatusChecker(10);

        // Create a timer that invokes CheckStatus after one second, 
        // and every 1/4 second thereafter.
		// 建立計時器, 先等待1秒, 然後執行 CheckStatus callback函數 250 毫秒.
        Console.WriteLine("{0:h:mm:ss.fff} Creating timer.\n", 
                          DateTime.Now);
        var stateTimer = new Timer(statusChecker.CheckStatus, 
                                   autoEvent, 1000, 250);

        // When autoEvent signals, change the period to every half second.
		// 然後應用程式執行緒會 block 封鎖直到 AutoResetEvent 收到訊號後再繼續執行. 
        autoEvent.WaitOne();
		
		// 變更timer 為每隔半秒, 同樣的block 封鎖直到 AutoResetEvent 收到訊號後再繼續執行.
        stateTimer.Change(0, 500);
        Console.WriteLine("\nChanging period to .5 seconds.\n");

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

class StatusChecker
{
    private int invokeCount;  // 呼叫callback函數的次數
    private int  maxCount;    // 呼叫callback函數的最大次數

    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());

		// 當 達到 最大呼叫次數, 則會觸動 AutoResetEvent.Set 方法, 通知 WaitOne() 收到訊號, 繼續執行主執行緒.
        if(invokeCount == maxCount)
        {
            // Reset the counter and signal the waiting thread.
            invokeCount = 0;
            autoEvent.Set();
        }
    }
}
// The example displays output like the following:
//       11:59:54.202 Creating timer.
//       
//       11:59:55.217 Checking status  1.
//       11:59:55.466 Checking status  2.
//       11:59:55.716 Checking status  3.
//       11:59:55.968 Checking status  4.
//       11:59:56.218 Checking status  5.
//       11:59:56.470 Checking status  6.
//       11:59:56.722 Checking status  7.
//       11:59:56.972 Checking status  8.
//       11:59:57.223 Checking status  9.
//       11:59:57.473 Checking status 10.
//       
//       Changing period to .5 seconds.
//       
//       11:59:57.474 Checking status  1.
//       11:59:57.976 Checking status  2.
//       11:59:58.476 Checking status  3.
//       11:59:58.977 Checking status  4.
//       11:59:59.477 Checking status  5.
//       11:59:59.977 Checking status  6.
//       12:00:00.478 Checking status  7.
//       12:00:00.980 Checking status  8.
//       12:00:01.481 Checking status  9.
//       12:00:01.981 Checking status 10.
//       
//       Destroying timer.