Timer Klasse

Definition

Namespace:

System.Threading

Assembly:

System.Runtime.dll

Quelle:

Timer.cs

Stellt einen Mechanismus zum Ausführen einer Methode in einem Threadpoolthread in bestimmten Intervallen bereit. Diese Klasse kann nicht geerbt werden.

public ref class Timer sealed : MarshalByRefObject, System::Threading::ITimer

public sealed class Timer : MarshalByRefObject, System.Threading.ITimer

type Timer = class
    inherit MarshalByRefObject
    interface IAsyncDisposable
    interface IDisposable
    interface ITimer

Public NotInheritable Class Timer
Inherits MarshalByRefObject
Implements ITimer

Vererbung

Object

MarshalByRefObject

Timer

Implementiert

IDisposable IAsyncDisposable ITimer

Beispiele

Im folgenden Beispiel wird eine StatusChecker Klasse definiert, die eine CheckStatus Methode enthält, deren Signatur mit dem TimerCallback Delegaten identisch ist. Das state-Argument der CheckStatus-Methode ist ein AutoResetEvent Objekt, das zum Synchronisieren des Anwendungsthreads und des Threadpoolthreads verwendet wird, der den Rückrufdelegat ausführt. Die StatusChecker Klasse enthält auch zwei Statusvariablen:

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

maxCount Bestimmt, wie oft die Rückrufmethode 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 wird dann blockiert, bis das AutoResetEvent-Objekt signalisiert wird. Wenn die CheckStatus Rückrufmethode maxCount Mal ausgeführt wird, ruft sie die AutoResetEvent.Set Methode auf, um den Status des AutoResetEvent Objekts zu signalisieren. Beim ersten Mal 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 vom 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 beim Erstellen des Timers angegeben und kann nicht geändert werden. Die Methode wird nicht für den Thread ausgeführt, der den Timer erstellt hat. sie wird auf einem vom System bereitgestellten ThreadPool Thread ausgeführt.

Trinkgeld

.NET enthält mehrere Timerklassen, von denen jede verschiedene Funktionen bietet:

• System.Timers.Timer, das ein Ereignis auslöst und den Code in einem oder mehreren Ereignisabständen in regelmäßigen Intervallen ausführt. Die Klasse ist für die Verwendung als serverbasierte oder Dienstkomponente in einer Multithreadumgebung vorgesehen; sie hat keine Benutzeroberfläche und ist zur Laufzeit nicht sichtbar.
• System.Threading.Timer, die eine einzelne Rückrufmethode in einem Threadpoolthread in regelmäßigen Intervallen ausführt. Die Rückrufmethode wird definiert, wenn der Timer instanziiert wird und nicht geändert werden kann. Wie die System.Timers.Timer Klasse ist diese Klasse für die Verwendung 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 Ereignisabständen in regelmäßigen Intervallen 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 asynchrone oder synchrone Webseitenpostbacks in regelmäßigen Intervallen 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 einen Zeitraum angeben, der vor der ersten Ausführung der Methode (Fälligkeitszeit) gewartet werden soll, und eine Zeitspanne, die zwischen nachfolgenden Ausführungen (Zeitraum) gewartet werden soll. Die Timer Klasse hat die gleiche Auflösung wie die Systemuhr. Dies bedeutet, dass der TimerCallback Delegat in Intervallen ausgeführt wird, die durch die Auflösung der Systemuhr definiert sind, die ungefähr 15 Millisekunden auf Windows 7- und Windows 8-Systemen beträgt. Sie können die Fälligkeitszeit und den Fälligkeitszeitraum ändern oder den Timer mithilfe der Change-Methode deaktivieren.

Anmerkung

Solange Sie eine 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 eine Timer noch aktiv ist, verhindert nicht, dass sie gesammelt wird.

Anmerkung

Die verwendete Systemuhr ist die gleiche Uhr, die von GetTickCountverwendet wird, die nicht von Änderungen betroffen ist, die mit timeBeginPeriod und timeEndPeriodvorgenommen wurden.

Wenn ein Timer nicht mehr benötigt wird, verwenden Sie die Dispose Methode, um die vom Timer gehaltenen Ressourcen freizugeben. Beachten Sie, dass Rückrufe auftreten können, nachdem die Dispose() Methodenüberladung aufgerufen wurde, da die Timerrückrufe für die Ausführung durch Threadpoolthreads in die Warteschlange gestellt werden. 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 gestellt wird.

Anmerkung

System.Threading.Timer ist ein einfacher, einfacher Timer, der Rückrufmethoden verwendet und von Threadpoolthreads bereitgestellt wird. Es wird nicht für die Verwendung mit Windows Forms empfohlen, da die Rückrufe nicht im Benutzeroberflächenthread auftreten. System.Windows.Forms.Timer ist eine bessere Wahl für die Verwendung mit Windows Forms. Für serverbasierte Zeitgeberfunktionen 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 einer unendlichen Periode und einer unendlichen Fälligkeitszeit, wobei das neu erstellte Timer -Objekt als Zustandsobjekt verwendet wird.
Timer(TimerCallback, Object, Int32, Int32)	Initialisiert eine neue Instanz der Timer Klasse, wobei eine 32-Bit-Ganzzahl verwendet wird, um das Zeitintervall anzugeben.
Timer(TimerCallback, Object, Int64, Int64)	Initialisiert eine neue Instanz der Timer-Klasse, wobei 64-Bit-ganzzahlige Ganzzahlen verwendet werden, um Zeitintervalle zu messen.
Timer(TimerCallback, Object, TimeSpan, TimeSpan)	Initialisiert eine neue Instanz der Timer Klasse, wobei TimeSpan Werte verwendet werden, um Zeitintervalle zu messen.
Timer(TimerCallback, Object, UInt32, UInt32)	Initialisiert eine neue Instanz der Timer Klasse, wobei 32-Bit-ganzzahlen ohne Vorzeichen verwendet werden, um Zeitintervalle zu messen.

Eigenschaften

ActiveCount

Ruft die Anzahl der Zeitgeber ab, die derzeit aktiv sind. Ein aktiver Timer wird registriert, um irgendwann in Zukunft zu ticken und wurde noch nicht abgebrochen.

Methoden

Change(Int32, Int32)	Ändert die Startzeit und das Intervall zwischen Methodenaufrufen für einen Timer, wobei 32-Bit-ganzzahlige Ganzzahlen verwendet werden, um Zeitintervalle zu messen.
Change(Int64, Int64)	Ändert die Startzeit und das Intervall zwischen Methodenaufrufen für einen Timer, wobei 64-Bit-ganzzahlige Ganzzahlen verwendet werden, um Zeitintervalle zu messen.
Change(TimeSpan, TimeSpan)	Ändert die Startzeit und das Intervall zwischen Methodenaufrufen für einen Timer, wobei TimeSpan Werte verwendet werden, um Zeitintervalle zu messen.
Change(UInt32, UInt32)	Ändert die Startzeit und das Intervall zwischen Methodenaufrufen für einen Timer, wobei 32-Bit-ganzzahlen ohne Vorzeichen verwendet werden, um Zeitintervalle zu messen.
CreateObjRef(Type)	Erstellt ein Objekt, das alle relevanten Informationen enthält, die zum Generieren eines Proxys erforderlich sind, der für die Kommunikation mit einem Remoteobjekt verwendet wird. (Geerbt von MarshalByRefObject)
Dispose()	Veröffentlicht alle Ressourcen, die von der aktuellen Instanz von Timerverwendet werden.
Dispose(WaitHandle)	Gibt alle Ressourcen frei, die von der aktuellen Instanz von Timer und Signalen verwendet werden, wenn der Timer verworfen wurde.
DisposeAsync()	Veröffentlicht alle Ressourcen, die von der aktuellen Instanz von Timerverwendet werden.
Equals(Object)	Bestimmt, ob das angegebene Objekt dem aktuellen Objekt entspricht. (Geerbt von Object)
GetHashCode()	Dient als Standardhashfunktion. (Geerbt von Object)
GetLifetimeService()	Veraltet. Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinie für diese Instanz steuert. (Geerbt von MarshalByRefObject)
GetType()	Ruft die Type der aktuellen Instanz ab. (Geerbt von Object)
InitializeLifetimeService()	Veraltet. Ruft ein Lebensdauerdienstobjekt ab, um die Lebensdauerrichtlinie für diese Instanz zu steuern. (Geerbt von MarshalByRefObject)
MemberwiseClone()	Erstellt eine flache Kopie der 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 auf die von einem asynchronen Einweg zurückgegebenen Aufgaben gewartet wird.

Threadsicherheit

Dieser Typ ist threadsicher.

Weitere Informationen

• TimerCallback
• Timer
• des verwalteten Threadpools