Timer Klasse

Definition

public ref class Timer : System::ComponentModel::Component, System::ComponentModel::ISupportInitialize

public class Timer : System.ComponentModel.Component, System.ComponentModel.ISupportInitialize

type Timer = class
    inherit Component
    interface ISupportInitialize

Public Class Timer
Inherits Component
Implements ISupportInitialize

Vererbung

Object

MarshalByRefObject

Component

Timer

Implementiert

ISupportInitialize

Beispiele

Im folgenden Beispiel wird ein System.Timers.Timer Objekt instanziiert, das sein Timer.Elapsed Ereignis alle zwei Sekunden auslöst (2.000 Millisekunden), einen Ereignishandler für das Ereignis einrichtet und den Timer startet. Der Ereignishandler zeigt den Wert der ElapsedEventArgs.SignalTime Eigenschaft jedes Mal an, wenn sie ausgelöst wird.

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...

open System
open System.Timers

let onTimedEvent source (e: ElapsedEventArgs) =
    printfn $"""The Elapsed event was raised at {e.SignalTime.ToString "HH:mm:ss.fff"}"""

// Create a timer with a two second interval.
let aTimer = new Timer 2000
// Hook up the Elapsed event for the timer. 
aTimer.Elapsed.AddHandler onTimedEvent
aTimer.AutoReset <- true
aTimer.Enabled <- true

printfn "\nPress the Enter key to exit the application...\n"
printfn $"""The application started at {DateTime.Now.ToString "HH:mm:ss.fff"}"""
stdin.ReadLine() |> ignore
aTimer.Stop()
aTimer.Dispose()

printfn "Terminating the application..."

// 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...

Imports System.Timers

Public Module Example
    Private aTimer As System.Timers.Timer

    Public Sub Main()
        SetTimer()

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

      Console.WriteLine("Terminating the application...")
    End Sub

    Private Sub SetTimer()
        ' Create a timer with a two second interval.
        aTimer = New System.Timers.Timer(2000)
        ' Hook up the Elapsed event for the timer. 
        AddHandler aTimer.Elapsed, AddressOf OnTimedEvent
        aTimer.AutoReset = True
        aTimer.Enabled = True
    End Sub

    ' The event handler for the Timer.Elapsed event. 
    Private Sub OnTimedEvent(source As Object, e As ElapsedEventArgs)
        Console.WriteLine("The Elapsed event was raised at {0:HH:mm:ss.fff}",
                          e.SignalTime)
    End Sub 
End Module
' 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...

Hinweise

Die Timer Komponente ist ein serverbasierter Timer, der ein Elapsed Ereignis in Ihrer Anwendung auslöst, nachdem die Anzahl der Millisekunden in der Interval Eigenschaft abgelaufen ist. Sie können das Timer Objekt so konfigurieren, dass das Ereignis nur einmal oder wiederholt mithilfe der AutoReset Eigenschaft ausgelöst wird. In der Regel wird ein Timer Objekt auf Klassenebene deklariert, sodass es im Bereich bleibt, solange es erforderlich ist. Anschließend können Sie das Elapsed Ereignis behandeln, um eine regelmäßige Verarbeitung bereitzustellen. Angenommen, Sie haben einen kritischen Server, der 24 Stunden pro Tag, 7 Tage pro Woche, ausgeführt werden muss. Sie können einen Dienst erstellen, der ein Timer Objekt verwendet, um den Server regelmäßig zu überprüfen und sicherzustellen, dass das System ausgeführt wird. Wenn das System nicht reagiert, kann der Dienst versuchen, den Server neu zu starten oder einen Administrator zu benachrichtigen.

Dieser Typ implementiert die IDisposable Schnittstelle. Nach Abschluss der Verwendung sollten Sie den Typ entweder direkt oder indirekt löschen. Rufen Sie die Methode Dispose in einem try/catch-Block auf, um den Typ direkt zu entsorgen. Verwenden Sie zum indirekten Löschen ein Sprachkonstrukt wie using (in C#) oder Using (in Visual Basic). Weitere Informationen finden Sie im Abschnitt "Verwenden eines Objekts, das IDisposable implementiert" im IDisposable Schnittstellenthema.

Die serverbasierte System.Timers.Timer Klasse wurde für die Verwendung mit Workerthreads in einer Multithreadumgebung entwickelt. Servertimer können zwischen Threads wechseln, um das ausgelöste Elapsed Ereignis zu behandeln, was zu einer größeren Genauigkeit als Windows-Timern beim Auslösen des Ereignisses zur Zeit führt.

Die System.Timers.Timer Komponente löst das Elapsed Ereignis basierend auf dem Wert (in Millisekunden) der Interval Eigenschaft aus. Sie können dieses Ereignis behandeln, um die benötigte Verarbeitung durchzuführen. Angenommen, Sie verfügen über eine Online-Vertriebsanwendung, die fortlaufend Verkaufsaufträge an eine Datenbank sendet. Der Dienst, der die Versandanweisungen kompiliert, betreibt eine Reihe von Aufträgen, anstatt jede Bestellung einzeln zu verarbeiten. Sie können die Batchverarbeitung alle 30 Minuten starten Timer .

Wenn AutoReset dieses Objekt auf false festgelegt ist, löst ein System.Timers.Timer Objekt das Elapsed Ereignis nur einmal aus, nachdem der erste Interval verstrichen ist. Um das Elapsed Ereignis regelmäßig in dem durch den IntervalWert ", set to true" definierten Intervall, auf das der Standardwert festgelegt AutoReset ist, zu erhöhen.

Die Timer Komponente erfasst und unterdrückt alle Ausnahmen, die von Ereignishandlern für das Elapsed Ereignis ausgelöst werden. Dieses Verhalten kann in zukünftigen Versionen von .NET Framework geändert werden. Beachten Sie jedoch, dass dies nicht für Ereignishandler gilt, die asynchron ausgeführt werden und den await Operator (in C#) oder den Await Operator (in Visual Basic) enthalten. Ausnahmen, die in diesen Ereignishandlern ausgelöst werden, werden zurück an den aufrufenden Thread weitergegeben, wie das folgende Beispiel veranschaulicht. Weitere Informationen zu Ausnahmen, die in asynchronen Methoden ausgelöst werden, finden Sie unter Exception Handling.

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

class Example
{
   static void Main()
   {
      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()

open System
open System.Threading.Tasks
open System.Timers

let handleTimer () =
    printfn "\nHandler not implemented..."
    raise (NotImplementedException()): Task

let timer = new Timer 1000
timer.Elapsed.AddHandler(fun sender e -> task { do! handleTimer () } |> ignore)
timer.Start()
printf "Press any key to exit... "
Console.ReadKey() |> ignore

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

Imports System.Threading.Tasks
Imports System.Timers

Public Module Example
   Public Sub Main()
      Dim timer As New Timer(1000)  
      AddHandler timer.Elapsed, AddressOf Example.HandleTimer     
      'timer.Elapsed = Async ( sender, e ) => await HandleTimer()
      timer.Start()
      Console.Write("Press any key to exit... ")
      Console.ReadKey()
   End Sub

   Private Async Sub HandleTimer(sender As Object, e As EventArgs)
      Await Task.Run(Sub()
                        Console.WriteLine()
                        Console.WriteLine("Handler not implemented..." )
                        Throw New NotImplementedException()
                     End Sub)   
   End Sub
End Module
' 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._Lambda$__1()
'      at System.Threading.Tasks.Task.Execute()
'   --- End of stack trace from previous location where exception was thrown ---
'      at System.Runtime.CompilerServices.TaskAwaiter.ThrowForNonSuccess(Task task)
'      at System.Runtime.CompilerServices.TaskAwaiter.HandleNonSuccessAndDebuggerNotification(Task task)
'      at Example.VB$StateMachine_0_HandleTimer.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()

Wenn die SynchronizingObject Eigenschaft lautet null, wird das Elapsed Ereignis in einem ThreadPool Thread ausgelöst. Wenn die Verarbeitung des Elapsed Ereignisses länger dauert als Interval, wird das Ereignis möglicherweise erneut in einem anderen ThreadPool Thread ausgelöst. In diesem Fall sollte der Ereignishandler erneut ausgeführt werden.

Selbst wenn SynchronizingObject dies nicht nullder Fall ist, können Ereignisse auftreten, Elapsed nachdem die StopDispose Eigenschaft aufgerufen oder auf die Enabled Eigenschaft festgelegt falsewurde, da das Signal zum Auslösen des Elapsed Ereignisses immer für die Ausführung in einem Threadpoolthread in die Warteschlange gestellt wird. Eine Möglichkeit, diese Racebedingung zu beheben, besteht darin, ein Flag festzulegen, das dem Ereignishandler für das Elapsed Ereignis angibt, nachfolgende Ereignisse zu ignorieren.

Wenn Sie die System.Timers.Timer Klasse mit einem Benutzeroberflächenelement wie einem Formular oder Steuerelement verwenden, ohne den Timer für dieses Benutzeroberflächenelement zu platzieren, weisen Sie das Formular oder Steuerelement, das die TimerSynchronizingObject Eigenschaft enthält, zu, damit das Ereignis an den Benutzeroberflächenthread gemarstet wird.

Eine Liste der Standardeigenschaftenwerte für eine Instanz von Timer, finden Sie im Timer Konstruktor.

Threadsicherheit

Alle öffentlichen static Member dieses Typs sind threadsicher. Instanzenmitglieder sind nicht garantiert threadsicher.

Weitere Informationen

• AutoReset
• Interval
• Elapsed
• Timer()
• Timer