Timer Classe

Définition

Fournit un mécanisme permettant d'exécuter une méthode sur un thread de pool de threads à intervalles spécifiés.Provides a mechanism for executing a method on a thread pool thread at specified intervals. Cette classe ne peut pas être héritée.This class cannot be inherited.

public ref class Timer sealed : MarshalByRefObject, IDisposable
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class Timer : MarshalByRefObject, IDisposable
public sealed class Timer : MarshalByRefObject, IDisposable
type Timer = class
    inherit MarshalByRefObject
    interface IDisposable
Public NotInheritable Class Timer
Inherits MarshalByRefObject
Implements IDisposable
Héritage
Timer
Héritage
Attributs
Implémente

Exemples

L’exemple suivant définit une classe StatusChecker qui comprend une méthode CheckStatus dont la signature est identique au délégué TimerCallback.The following example defines a StatusChecker class that includes a CheckStatus method whose signature is the same as the TimerCallback delegate. L’argument state de la méthode CheckStatus est un objet AutoResetEvent qui est utilisé pour synchroniser le thread d’application et le thread de pool de threads qui exécute le délégué de rappel.The state argument of the CheckStatus method is an AutoResetEvent object that is used to synchronize the application thread and the thread pool thread that executes the callback delegate. La classe StatusChecker comprend également deux variables d’État :The StatusChecker class also includes two state variables:

invokeCount
Indique le nombre de fois où la méthode de rappel a été appelée.Indicates the number of times the callback method has been invoked.

maxCount
Détermine le nombre maximal de fois où la méthode de rappel doit être appelée.Determines the maximum number of times the callback method should be invoked.

Le thread d’application crée la minuterie, qui attend une seconde, puis exécute l' CheckStatus méthode de rappel toutes les 250 millisecondes.The application thread creates the timer, which waits one second and then executes the CheckStatus callback method every 250 milliseconds. Le thread d’application est ensuite bloqué jusqu’à ce que l’objet AutoResetEvent soit signalé.The application thread then blocks until the AutoResetEvent object is signaled. Quand la méthode de rappel CheckStatus s’exécute maxCount fois, elle appelle la méthode AutoResetEvent.Set pour définir l’état de l’objet AutoResetEvent à signalé.When the CheckStatus callback method executes maxCount times, it calls the AutoResetEvent.Set method to set the state of the AutoResetEvent object to signaled. La première fois que cela se produit, le thread d’application appelle la méthode Change(Int32, Int32) pour que la méthode de rappel s’exécute à présent toutes les demi-secondes.The first time this happens, the application thread calls the Change(Int32, Int32) method so that the callback method now executes every half second. Une fois encore, il se bloque jusqu’à ce que l’objet AutoResetEvent soit signalé.It once again blocks until the AutoResetEvent object is signaled. Dans ce cas, la minuterie est détruite en appelant sa méthode Dispose et l’application se termine.When this happens, the timer is destroyed by calling its Dispose method, and the application terminates.

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.

Remarques

Utilisez un délégué TimerCallback pour spécifier la méthode que vous souhaitez que le Timer exécuter.Use a TimerCallback delegate to specify the method you want the Timer to execute. La signature du délégué TimerCallback est :The signature of the TimerCallback delegate is:

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

Le délégué de minuteur est spécifié lorsque la minuterie est construite et ne peut pas être modifié.The timer delegate is specified when the timer is constructed, and cannot be changed. La méthode ne s’exécute pas sur le thread qui a créé la minuterie. Il s’exécute sur un thread de ThreadPool fourni par le système.The method does not execute on the thread that created the timer; it executes on a ThreadPool thread supplied by the system.

Conseil

.NET inclut quatre classes nommées Timer, chacune offrant des fonctionnalités différentes :.NET includes four classes named Timer, each of which offers different functionality:

  • System.Timers.Timer, qui déclenche un événement et exécute le code dans un ou plusieurs récepteurs d’événements à intervalles réguliers.System.Timers.Timer, which fires an event and executes the code in one or more event sinks at regular intervals. La classe est destinée à être utilisée comme composant serveur ou service dans un environnement multithread. elle n’a pas d’interface utilisateur et n’est pas visible au moment de l’exécution.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.
  • System.Threading.Timer, qui exécute une méthode de rappel unique sur un thread de pool de threads à intervalles réguliers.System.Threading.Timer, which executes a single callback method on a thread pool thread at regular intervals. La méthode de rappel est définie lorsque la minuterie est instanciée et ne peut pas être modifiée.The callback method is defined when the timer is instantiated and cannot be changed. À l’instar de la classe System.Timers.Timer, cette classe est destinée à être utilisée comme composant serveur ou service dans un environnement multithread. elle n’a pas d’interface utilisateur et n’est pas visible au moment de l’exécution.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.
  • System.Windows.Forms.Timer (.NET Framework uniquement), un composant Windows Forms qui déclenche un événement et exécute le code dans un ou plusieurs récepteurs d’événements à intervalles réguliers.System.Windows.Forms.Timer (.NET Framework only), a Windows Forms component that fires an event and executes the code in one or more event sinks at regular intervals. Le composant n’a pas d’interface utilisateur et est conçu pour être utilisé dans un environnement à thread unique ; Il s’exécute sur le thread d’interface utilisateur.The component has no user interface and is designed for use in a single-threaded environment; it executes on the UI thread.
  • System.Web.UI.Timer (.NET Framework uniquement), un composant ASP.NET qui effectue des publications asynchrones ou synchrones de pages Web à intervalles réguliers.System.Web.UI.Timer (.NET Framework only), an ASP.NET component that performs asynchronous or synchronous web page postbacks at a regular interval.

Lorsque vous créez un minuteur, vous pouvez spécifier un délai d’attente avant la première exécution de la méthode (heure d’échéance) et un délai d’attente entre les exécutions suivantes (période).When you create a timer, you can specify an amount of time to wait before the first execution of the method (due time), and an amount of time to wait between subsequent executions (period). La classe Timer a la même résolution que l’horloge système.The Timer class has the same resolution as the system clock. Cela signifie que si la période est inférieure à la résolution de l’horloge système, le délégué TimerCallback s’exécutera à des intervalles définis par la résolution de l’horloge système, soit environ 15 millisecondes sur les systèmes Windows 7 et Windows 8.This means that if the period is less than the resolution of the system clock, the TimerCallback delegate will execute at intervals defined by the resolution of the system clock, which is approximately 15 milliseconds on Windows 7 and Windows 8 systems. Vous pouvez modifier la durée et le délai d’attente, ou désactiver le minuteur, à l’aide de la méthode Change.You can change the due time and period, or disable the timer, by using the Change method.

Notes

Tant que vous utilisez un Timer, vous devez conserver une référence à celui-ci.As long as you are using a Timer, you must keep a reference to it. Comme pour tout objet managé, un Timer est soumis à garbage collection lorsqu’il n’y a aucune référence à celui-ci.As with any managed object, a Timer is subject to garbage collection when there are no references to it. Le fait qu’une Timer soit toujours active ne l’empêche pas de la collecter.The fact that a Timer is still active does not prevent it from being collected.

Lorsqu’un minuteur n’est plus nécessaire, utilisez la méthode Dispose pour libérer les ressources détenues par le minuteur.When a timer is no longer needed, use the Dispose method to free the resources held by the timer. Notez que les rappels peuvent se produire après l’appel de la surcharge de méthode Dispose(), car la minuterie met en file d’attente les rappels pour l’exécution par les threads de pool de threads.Note that callbacks can occur after the Dispose() method overload has been called, because the timer queues callbacks for execution by thread pool threads. Vous pouvez utiliser la surcharge de méthode Dispose(WaitHandle) pour attendre la fin de tous les rappels.You can use the Dispose(WaitHandle) method overload to wait until all callbacks have completed.

La méthode de rappel exécutée par la minuterie doit être réentrante, car elle est appelée sur ThreadPool threads.The callback method executed by the timer should be reentrant, because it is called on ThreadPool threads. Le rappel peut être exécuté simultanément sur deux threads de pool de threads si l’intervalle de minuterie est inférieur au temps requis pour exécuter le rappel, ou si tous les threads de pool de threads sont en cours d’utilisation et que le rappel est mis en file d’attente plusieurs fois.The callback can be executed simultaneously on two thread pool threads if the timer interval is less than the time required to execute the callback, or if all thread pool threads are in use and the callback is queued multiple times.

Notes

System.Threading.Timer est une minuterie simple et légère qui utilise des méthodes de rappel et qui est fournie par les threads du pool de threads.System.Threading.Timer is a simple, lightweight timer that uses callback methods and is served by thread pool threads. Il n’est pas recommandé de l’utiliser avec Windows Forms, car ses rappels ne se produisent pas sur le thread d’interface utilisateur.It is not recommended for use with Windows Forms, because its callbacks do not occur on the user interface thread. System.Windows.Forms.Timer est un meilleur choix pour une utilisation avec Windows Forms.System.Windows.Forms.Timer is a better choice for use with Windows Forms. Pour la fonctionnalité de minuteur basée sur le serveur, vous pouvez envisager d’utiliser System.Timers.Timer, qui déclenche des événements et comporte des fonctionnalités supplémentaires.For server-based timer functionality, you might consider using System.Timers.Timer, which raises events and has additional features.

Constructeurs

Timer(TimerCallback)

Initialise une nouvelle instance de la classe Timer avec une période infinie et un délai d'attente infini, à l'aide de l'objet Timer créé récemment comme objet d'état.Initializes a new instance of the Timer class with an infinite period and an infinite due time, using the newly created Timer object as the state object.

Timer(TimerCallback, Object, Int32, Int32)

Initialise une nouvelle instance de la classe Timer utilisant un entier signé 32 bits pour spécifier l'intervalle de temps.Initializes a new instance of the Timer class, using a 32-bit signed integer to specify the time interval.

Timer(TimerCallback, Object, Int64, Int64)

Initialise une nouvelle instance de la classe Timer utilisant des entiers 64 bits signés pour mesurer les intervalles de temps.Initializes a new instance of the Timer class, using 64-bit signed integers to measure time intervals.

Timer(TimerCallback, Object, TimeSpan, TimeSpan)

Initialise une nouvelle instance de la classe Timer utilisant des valeurs TimeSpan pour mesurer les intervalles de temps.Initializes a new instance of the Timer class, using TimeSpan values to measure time intervals.

Timer(TimerCallback, Object, UInt32, UInt32)

Initialise une nouvelle instance de la classe Timer utilisant des entiers 32 bits non signés pour mesurer les intervalles de temps.Initializes a new instance of the Timer class, using 32-bit unsigned integers to measure time intervals.

Propriétés

ActiveCount

Obtient le nombre de minuteries actuellement actives.Gets the number of timers that are currently active. Une minuterie active est inscrite pour sonner à un moment donné dans le futur et n’a pas encore été annulée.An active timer is registered to tick at some point in the future, and has not yet been canceled.

Méthodes

Change(Int32, Int32)

Modifie l'heure de début et l'intervalle entre les appels de méthode d'une minuterie ; les intervalles de temps sont mesurés à l'aide d'entiers 32 bits signés.Changes the start time and the interval between method invocations for a timer, using 32-bit signed integers to measure time intervals.

Change(Int64, Int64)

Modifie l'heure de début et l'intervalle entre les appels de méthode d'une minuterie ; les intervalles de temps sont mesurés à l'aide d'entiers 64 bits signés.Changes the start time and the interval between method invocations for a timer, using 64-bit signed integers to measure time intervals.

Change(TimeSpan, TimeSpan)

Modifie l'heure de début et l'intervalle entre les appels de méthode d'une minuterie ; les intervalles de temps sont mesurés à l'aide de valeurs TimeSpan.Changes the start time and the interval between method invocations for a timer, using TimeSpan values to measure time intervals.

Change(UInt32, UInt32)

Modifie l'heure de début et l'intervalle entre les appels de méthode d'une minuterie ; les intervalles de temps sont mesurés à l'aide d'entiers 32 bits non signés.Changes the start time and the interval between method invocations for a timer, using 32-bit unsigned integers to measure time intervals.

CreateObjRef(Type)

Crée un objet contenant toutes les informations appropriées requises pour générer un proxy permettant de communiquer avec un objet distant.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Hérité de MarshalByRefObject)
Dispose()

Libère toutes les ressources utilisées par l'instance actuelle de Timer.Releases all resources used by the current instance of Timer.

Dispose(WaitHandle)

Libère toutes les ressources utilisées par l'instance actuelle de Timer et signale le moment où la minuterie a été supprimée.Releases all resources used by the current instance of Timer and signals when the timer has been disposed of.

DisposeAsync()

Libère toutes les ressources utilisées par l'instance actuelle de Timer.Releases all resources used by the current instance of Timer.

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
Finalize()

Autorise un objet à tenter de libérer des ressources et à exécuter d'autres opérations de nettoyage avant qu'il ne soit récupéré par une opération garbage collection.Allows an object to try to free resources and perform other cleanup operations before it is reclaimed by garbage collection.

GetHashCode()

Sert de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetLifetimeService()

Récupère l'objet de service de durée de vie en cours qui contrôle la stratégie de durée de vie de cette instance.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Hérité de MarshalByRefObject)
GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
InitializeLifetimeService()

Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance.Obtains a lifetime service object to control the lifetime policy for this instance.

(Hérité de MarshalByRefObject)
MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
MemberwiseClone(Boolean)

Crée une copie superficielle de l'objet MarshalByRefObject actuel.Creates a shallow copy of the current MarshalByRefObject object.

(Hérité de MarshalByRefObject)
ToString()

Retourne une chaîne qui représente l'objet actif.Returns a string that represents the current object.

(Hérité de Object)

S’applique à

Cohérence de thread

Ce type est thread-safe.This type is thread safe.

Voir aussi