text: Timers
  .NET provides two timers to use in a multithreaded environment:
  - System.Threading.Timer, which executes a single callback method on a ThreadPool thread at regular intervals.
  - System.Timers.Timer, which by default raises an event on a ThreadPool thread at regular intervals.
  Note
  Some .NET implementations may include additional timers:
  - System.Windows.Forms.Timer: a Windows Forms component that fires an event at regular intervals. The component has no user interface and is designed for use in a single-threaded environment.
  - System.Web.UI.Timer: an ASP.NET component that performs asynchronous or synchronous web page postbacks at a regular interval.
  - System.Windows.Threading.DispatcherTimer: a timer that is integrated into the Dispatcher queue which is processed at a specified interval of time and at a specified priority.
  The System.Threading.Timer class
  The System.Threading.Timer class enables you to continuously call a delegate at specified time intervals. You can also use this class to schedule a single call to a delegate in a specified time interval. The delegate is executed on a ThreadPool thread.
  When you create a System.Threading.Timer object, you specify a TimerCallback delegate that defines the callback method, an optional state object that is passed to the callback, the amount of time to delay before the first invocation of the callback, and the time interval between callback invocations. To cancel a pending timer, call the Timer.Dispose method.
  The following example creates a timer that calls the provided delegate for the first time after one second (1000 milliseconds) and then calls it every two seconds. The state object in the example is used to count how many times the delegate is called. The timer is stopped when the delegate has been called at least 10 times.
  using namespace System; using namespace System::Threading; ref class TimerState { public: int counter; }; ref class Example { private: static Timer^ timer; public: static void TimerTask(Object^ state) { Console::WriteLine("{0:HH:mm:ss.fff}: starting a new callback.", DateTime::Now); TimerState^ timerState = dynamic_cast<TimerState^>(state); Interlocked::Increment(timerState->counter); } static void Main() { TimerCallback^ tcb = gcnew TimerCallback(&TimerTask); TimerState^ state = gcnew TimerState(); state->counter = 0; timer = gcnew Timer(tcb, state, 1000, 2000); while (state->counter <= 10) { Thread::Sleep(1000); } timer->~Timer(); Console::WriteLine("{0:HH:mm:ss.fff}: done.", DateTime::Now); } }; int main() { Example::Main(); }
  using System; using System.Threading; using System.Threading.Tasks; class Program { private static Timer timer; static void Main(string[] args) { var timerState = new TimerState { Counter = 0 }; timer = new Timer( callback: new TimerCallback(TimerTask), state: timerState, dueTime: 1000, period: 2000); while (timerState.Counter <= 10) { Task.Delay(1000).Wait(); } timer.Dispose(); Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: done."); } private static void TimerTask(object timerState) { Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: starting a new callback."); var state = timerState as TimerState; Interlocked.Increment(ref state.Counter); } class TimerState { public int Counter; } }
  Imports System.Threading Module Program Private Timer As Timer Sub Main(args As String()) Dim StateObj As New TimerState StateObj.Counter = 0 Timer = New Timer(New TimerCallback(AddressOf TimerTask), StateObj, 1000, 2000) While StateObj.Counter <= 10 Task.Delay(1000).Wait() End While Timer.Dispose() Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: done.") End Sub Private Sub TimerTask(ByVal StateObj As Object) Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: starting a new callback.") Dim State As TimerState = CType(StateObj, TimerState) Interlocked.Increment(State.Counter) End Sub Private Class TimerState Public Counter As Integer End Class End Module
  For more information and examples, see System.Threading.Timer.
  The System.Timers.Timer class
  Another timer that can be used in a multithreaded environment is System.Timers.Timer that by default raises an event on a ThreadPool thread.
  When you create a System.Timers.Timer object, you may specify the time interval in which to raise an Elapsed event. Use the Enabled property to indicate if a timer should raise an Elapsed event. If you need an Elapsed event to be raised only once after the specified interval has elapsed, set the AutoReset to
  false. The default value of the AutoReset property is
  true, which means that an Elapsed event is raised regularly at the interval defined by the Interval property.
  For more information and examples, see System.Timers.Timer.