Timer Klasse

Definition

Stellt einen Mechanismus zum Ausführen einer Methode für einen Threadpoolthread in angegebenen Intervallen bereit. Diese Klasse kann nicht vererbt werden.

public ref class Timer sealed : IDisposable
public ref class Timer sealed : MarshalByRefObject, IAsyncDisposable, IDisposable
public ref class Timer sealed : MarshalByRefObject, System::Threading::ITimer
public ref class Timer sealed : MarshalByRefObject, IDisposable
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class Timer : IDisposable
public sealed class Timer : MarshalByRefObject, IAsyncDisposable, IDisposable
public sealed class Timer : MarshalByRefObject, System.Threading.ITimer
public sealed class Timer : MarshalByRefObject, IDisposable
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class Timer : MarshalByRefObject, IDisposable
[<System.Runtime.InteropServices.ComVisible(true)>]
type Timer = class
    interface IDisposable
type Timer = class
    inherit MarshalByRefObject
    interface IAsyncDisposable
    interface IDisposable
type Timer = class
    inherit MarshalByRefObject
    interface IAsyncDisposable
    interface IDisposable
    interface ITimer
type Timer = class
    inherit MarshalByRefObject
    interface IDisposable
[<System.Runtime.InteropServices.ComVisible(true)>]
type Timer = class
    inherit MarshalByRefObject
    interface IDisposable
Public NotInheritable Class Timer
Implements IDisposable
Public NotInheritable Class Timer
Inherits MarshalByRefObject
Implements IAsyncDisposable, IDisposable
Public NotInheritable Class Timer
Inherits MarshalByRefObject
Implements ITimer
Public NotInheritable Class Timer
Inherits MarshalByRefObject
Implements IDisposable
Vererbung
Timer
Vererbung
Attribute
Implementiert

Beispiele

Im folgenden Beispiel wird eine StatusChecker Klasse definiert, die eine CheckStatus Methode enthält, deren Signatur mit der des TimerCallback Delegaten identisch ist. Das state Argument der CheckStatus -Methode ist ein AutoResetEvent -Objekt, das verwendet wird, um den Anwendungsthread und den Threadpoolthread zu synchronisieren, der den Rückrufdelegat ausführt. Die StatusChecker -Klasse enthält auch zwei Zustandsvariablen:

invokeCount Gibt an, wie oft die Rückrufmethode aufgerufen wurde.

maxCount Bestimmt, wie oft die Rückrufmethode maximal aufgerufen werden soll.

Der Anwendungsthread erstellt den Timer, der eine Sekunde wartet und dann alle 250 Millisekunden die CheckStatus Rückrufmethode ausführt. Der Anwendungsthread blockiert dann, bis das AutoResetEvent Objekt signalisiert wird. Wenn die CheckStatus Rückrufmethode mal ausgeführt maxCount wird, ruft sie die AutoResetEvent.Set -Methode auf, um den Status des AutoResetEvent Objekts auf signalisiert festzulegen. Wenn dies zum ersten Mal geschieht, ruft der Anwendungsthread die Change(Int32, Int32) -Methode auf, sodass die Rückrufmethode jetzt alle halbe Sekunde ausgeführt wird. Es wird erneut blockiert, bis das AutoResetEvent Objekt signalisiert wird. In diesem Fall wird der Timer durch Aufrufen der Dispose -Methode zerstört, und die Anwendung wird beendet.

using namespace System;
using namespace System::Threading;

ref class StatusChecker
{
private:
    int invokeCount, maxCount;

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

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

        if (invokeCount == maxCount) {
            // Reset the counter and signal the waiting thread.
            invokeCount  = 0;
            autoEvent->Set();
        }
    }
};

ref class TimerExample
{
public:
    static void Main()
    {
        // Create an AutoResetEvent to signal the timeout threshold in the
        // timer callback has been reached.
        AutoResetEvent^ autoEvent = gcnew AutoResetEvent(false);

        StatusChecker^ statusChecker = gcnew StatusChecker(10);

        // Create a delegate that invokes methods for the timer.
        TimerCallback^ tcb =
           gcnew TimerCallback(statusChecker, &StatusChecker::CheckStatus);

        // Create a timer that invokes CheckStatus after one second, 
        // and every 1/4 second thereafter.
        Console::WriteLine("{0:h:mm:ss.fff} Creating timer.\n",
                           DateTime::Now);
        Timer^ stateTimer = gcnew Timer(tcb, autoEvent, 1000, 250);

        // When autoEvent signals, change the period to every half second.
        autoEvent->WaitOne(5000, false);
        stateTimer->Change(0, 500);
        Console::WriteLine("\nChanging period to .5 seconds.\n");

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

int main()
{
    TimerExample::Main();
}
// 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.
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.
        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.
        autoEvent.WaitOne();
        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;
    private int  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 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.
Imports System.Threading

Public Module Example
    Public Sub Main()
        ' Use an AutoResetEvent to signal the timeout threshold in the
        ' timer callback has been reached.
        Dim autoEvent As New AutoResetEvent(False)

        Dim statusChecker As New StatusChecker(10)

        ' Create a timer that invokes CheckStatus after one second, 
        ' and every 1/4 second thereafter.
        Console.WriteLine("{0:h:mm:ss.fff} Creating timer." & vbCrLf, 
                          DateTime.Now)
        Dim stateTimer As New Timer(AddressOf statusChecker.CheckStatus, 
                                    autoEvent, 1000, 250)

        ' When autoEvent signals, change the period to every half second.
        autoEvent.WaitOne()
        stateTimer.Change(0, 500)
        Console.WriteLine(vbCrLf & "Changing period to .5 seconds." & vbCrLf)

        ' When autoEvent signals the second time, dispose of the timer.
        autoEvent.WaitOne()
        stateTimer.Dispose()
        Console.WriteLine(vbCrLf & "Destroying timer.")
    End Sub
End Module

Public Class StatusChecker
    Dim invokeCount, maxCount As Integer 

    Sub New(count As Integer)
        invokeCount  = 0
        maxCount = count
    End Sub

    ' The timer callback method.
    Sub CheckStatus(stateInfo As Object)
        Dim autoEvent As AutoResetEvent = DirectCast(stateInfo, AutoResetEvent)
        invokeCount += 1
        Console.WriteLine("{0:h:mm:ss.fff} Checking status {1,2}.", 
                          DateTime.Now, invokeCount)
        If invokeCount = maxCount Then
            ' Reset the counter and signal the waiting thread.
            invokeCount = 0
            autoEvent.Set()
        End If
    End Sub
End Class
' 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.

Hinweise

Verwenden Sie einen TimerCallback Delegaten, um die Methode anzugeben, die Timer ausgeführt werden soll. Die Signatur des TimerCallback Delegaten lautet:

void TimerCallback(Object state)
void TimerCallback(Object state)
Sub TimerCallback(state As Object)

Der Zeitgeberdelegat wird angegeben, wenn der Timer erstellt wird, und kann nicht geändert werden. Die -Methode wird nicht für den Thread ausgeführt, der den Timer erstellt hat. Sie wird in einem ThreadPool thread ausgeführt, der vom System bereitgestellt wird.

Tipp

.NET enthält mehrere Zeitgeberklassen, von denen jede unterschiedliche Funktionen bietet:

  • System.Timers.Timer, das ein Ereignis auslöst und den Code in einem oder mehreren Ereignissenken in regelmäßigen Abständen ausführt. Die Klasse ist für den Einsatz als serverbasierte oder Dienstkomponente in einer Multithreadumgebung vorgesehen. Sie hat keine Benutzeroberfläche und ist zur Laufzeit nicht sichtbar.
  • System.Threading.Timer, die in regelmäßigen Abständen eine einzelne Rückrufmethode für einen Threadpoolthread ausführt. Die Rückrufmethode wird definiert, wenn der Timer instanziiert wird, und kann nicht geändert werden. Wie die System.Timers.Timer-Klasse ist diese Klasse für den Einsatz als serverbasierte oder Dienstkomponente in einer Multithreadumgebung vorgesehen. Sie hat keine Benutzeroberfläche und ist zur Laufzeit nicht sichtbar.
  • System.Windows.Forms.Timer, eine Windows Forms Komponente, die ein Ereignis auslöst und den Code in einem oder mehreren Ereignissenken in regelmäßigen Abständen ausführt. Die Komponente verfügt über keine Benutzeroberfläche und ist für die Verwendung in einer Singlethread-Umgebung konzipiert. Sie wird im UI-Thread ausgeführt.
  • System.Web.UI.Timer(nur .NET Framework), eine ASP.NET Komponente, die in regelmäßigen Abständen asynchrone oder synchrone Webseiten-Postbacks ausführt.
  • System.Windows.Threading.DispatcherTimer, ein Timer, der in die Dispatcher Warteschlange integriert ist. Dieser Timer wird mit einer angegebenen Priorität in einem angegebenen Zeitintervall verarbeitet.

Wenn Sie einen Timer erstellen, können Sie festlegen, wie lange vor der ersten Ausführung der Methode gewartet werden soll (Fälligkeitszeit) und eine Wartezeit zwischen nachfolgenden Ausführungen (Zeitraum). Die Timer -Klasse hat die gleiche Auflösung wie die Systemuhr. Dies bedeutet, dass, wenn der Zeitraum kleiner als die Auflösung der Systemuhr ist, der TimerCallback Delegat in Intervallen ausgeführt wird, die durch die Auflösung der Systemuhr definiert sind, die auf Windows 7- und Windows 8-Systemen ungefähr 15 Millisekunden beträgt. Sie können die fällige Zeit und den zeitraum ändern oder den Timer deaktivieren, indem Sie die Change -Methode verwenden.

Hinweis

Solange Sie einen Timerverwenden, müssen Sie einen Verweis darauf beibehalten. Wie bei jedem verwalteten Objekt unterliegt ein Timer der Garbage Collection, wenn keine Verweise darauf vorhanden sind. Die Tatsache, dass ein Timer noch aktiv ist, verhindert nicht, dass es gesammelt wird.

Hinweis

Die verwendete Systemuhr ist die gleiche Uhr, die von GetTickCount verwendet wird, die nicht von Änderungen betroffen ist, die mit timeBeginPeriod und timeEndPeriod vorgenommen wurden.

Wenn ein Timer nicht mehr benötigt wird, verwenden Sie die Dispose -Methode, um die vom Timer gespeicherten Ressourcen freizugeben. Beachten Sie, dass Rückrufe auftreten können, nachdem die Dispose() Methodenüberladung aufgerufen wurde, da der Timer Rückrufe für die Ausführung durch Threadpoolthreads in die Warteschlange stellt. Sie können die Dispose(WaitHandle) Methodenüberladung verwenden, um zu warten, bis alle Rückrufe abgeschlossen sind.

Die vom Timer ausgeführte Rückrufmethode sollte erneut ausgeführt werden, da sie für ThreadPool Threads aufgerufen wird. Der Rückruf kann gleichzeitig in zwei Threadpoolthreads ausgeführt werden, wenn das Zeitgeberintervall kleiner ist als die Zeit, die zum Ausführen des Rückrufs erforderlich ist, oder wenn alle Threadpoolthreads verwendet werden und der Rückruf mehrmals in die Warteschlange eingereiht wird.

Hinweis

System.Threading.Timer ist ein einfacher, einfacher Timer, der Rückrufmethoden verwendet und von Threadpoolthreads bereitgestellt wird. Die Verwendung mit Windows Forms wird nicht empfohlen, da die Rückrufe nicht im Benutzeroberflächenthread erfolgen. System.Windows.Forms.Timerist eine bessere Wahl für die Verwendung mit Windows Forms. Für serverbasierte Timerfunktionen können Sie die Verwendung von System.Timers.Timerin Betracht ziehen, die Ereignisse auslöst und über zusätzliche Features verfügt.

Konstruktoren

Timer(TimerCallback)

Initialisiert eine neue Instanz der Timer-Klasse mit einem unendlichen Zeitraum und einer unendlichen Vorlaufzeit, wobei das neu erstellte Timer-Objekt als Zustandsobjekt verwendet wird.

Timer(TimerCallback, Object, Int32, Int32)

Initialisiert eine neue Instanz der Timer-Klasse unter Verwendung einer 32-Bit-Ganzzahl mit Vorzeichen zum Angeben des Zeitintervalls.

Timer(TimerCallback, Object, Int64, Int64)

Initialisiert eine neue Instanz der Timer-Klasse unter Verwendung von 64-Bit-Ganzzahlen mit Vorzeichen zum Messen von Zeitintervallen.

Timer(TimerCallback, Object, TimeSpan, TimeSpan)

Initialisiert eine neue Instanz der Timer-Klasse unter Verwendung von TimeSpan-Werten zum Messen von Zeitintervallen.

Timer(TimerCallback, Object, UInt32, UInt32)

Initialisiert eine neue Instanz der Timer-Klasse unter Verwendung von 32-Bit-Ganzzahlen ohne Vorzeichen zum Messen von Zeitintervallen.

Eigenschaften

ActiveCount

Ruft die Anzahl der derzeit aktiven Timer ab. Ein aktiver Timer wird dafür registriert, zu einem späteren Zeitpunkt zu laufen, und dieser wurde noch nicht abgebrochen.

Methoden

Change(Int32, Int32)

Ändert die Startzeit und das Intervall zwischen Methodenaufrufen für einen Timer unter Verwendung von 32-Bit-Ganzzahlen mit Vorzeichen zum Messen von Zeitintervallen.

Change(Int64, Int64)

Ändert die Startzeit und das Intervall zwischen Methodenaufrufen für einen Zeitgeber unter Verwendung von 64-Bit-Ganzzahlen mit Vorzeichen zum Messen von Zeitintervallen.

Change(TimeSpan, TimeSpan)

Ändert die Startzeit und das Intervall zwischen Methodenaufrufen für einen Zeitgeber unter Verwendung von TimeSpan-Werten zum Messen von Zeitintervallen.

Change(UInt32, UInt32)

Ändert die Startzeit und das Intervall zwischen Methodenaufrufen für einen Timer unter Verwendung von 32-Bit-Ganzzahlen ohne Vorzeichen zum Messen von Zeitintervallen.

CreateObjRef(Type)

Erstellt ein Objekt mit allen relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind.

(Geerbt von MarshalByRefObject)
Dispose()

Gibt alle von der aktuellen Instanz von Timer verwendeten Ressourcen frei.

Dispose(WaitHandle)

Gibt alle von der aktuellen Instanz von Timer verwendeten Ressourcen frei, und signalisiert das Freigeben des Zeitgebers.

DisposeAsync()

Gibt alle von der aktuellen Instanz von Timer verwendeten Ressourcen frei.

Equals(Object)

Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist.

(Geerbt von Object)
Finalize()

Gibt einem Objekt Gelegenheit zu dem Versuch, Ressourcen freizugeben und andere Bereinigungen durchzuführen, bevor es von der Garbage Collection freigegeben wird.

GetHashCode()

Fungiert als Standardhashfunktion.

(Geerbt von Object)
GetLifetimeService()
Veraltet.

Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert.

(Geerbt von MarshalByRefObject)
GetType()

Ruft den Type der aktuellen Instanz ab.

(Geerbt von Object)
InitializeLifetimeService()
Veraltet.

Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinie für diese Instanz ab.

(Geerbt von MarshalByRefObject)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.

(Geerbt von Object)
MemberwiseClone(Boolean)

Erstellt eine flache Kopie des aktuellen MarshalByRefObject-Objekts.

(Geerbt von MarshalByRefObject)
ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.

(Geerbt von Object)

Erweiterungsmethoden

ConfigureAwait(IAsyncDisposable, Boolean)

Konfiguriert, wie Wartezeiten auf die Aufgaben angewandt werden, die von einem asynchronen verwerfbaren Element zurückgegeben werden.

Gilt für:

Threadsicherheit

Dieser Typ ist threadsicher.

Weitere Informationen