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. Cette classe ne peut pas être héritée.

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
Héritage
Timer
Héritage
Attributs
Implémente

Exemples

L’exemple suivant définit une StatusChecker classe qui inclut une CheckStatus méthode dont la signature est identique à celle du TimerCallback délégué. L’argument state de la CheckStatus méthode est un AutoResetEvent objet utilisé pour synchroniser le thread d’application et le thread de pool de threads qui exécute le délégué de rappel. La StatusChecker classe comprend également deux variables d’état :

invokeCount Indique le nombre de fois où la méthode de rappel a été appelée.

maxCount Détermine le nombre maximal d’appels de la méthode de rappel.

Le thread d’application crée le minuteur, qui attend une seconde, puis exécute la méthode de CheckStatus rappel toutes les 250 millisecondes. Le thread d’application se bloque ensuite jusqu’à ce que l’objet AutoResetEvent soit signalé. Lorsque la méthode de CheckStatus rappel s’exécute maxCount , elle appelle la AutoResetEvent.Set méthode pour définir l’état de l’objet AutoResetEvent sur signal. La première fois que cela se produit, le thread d’application appelle la Change(Int32, Int32) méthode afin que la méthode de rappel s’exécute désormais toutes les demi-secondes. Il se bloque à nouveau jusqu’à ce que l’objet AutoResetEvent soit signalé. Dans ce cas, le minuteur est détruit en appelant sa Dispose méthode et l’application se termine.

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 TimerCallback délégué pour spécifier la méthode à Timer exécuter. La signature du délégué est la TimerCallback suivante :

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

Le délégué du minuteur est spécifié lorsque le minuteur est construit et ne peut pas être modifié. La méthode ne s’exécute pas sur le thread qui a créé le minuteur ; il s’exécute sur un ThreadPool thread fourni par le système.

Conseil

.NET comprend plusieurs classes de minuteur, chacune offrant des fonctionnalités différentes :

  • 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. La classe est destinée à être utilisée en tant que composant de service ou de serveur dans un environnement multithread ; il n’a pas d’interface utilisateur et n’est pas visible au moment de l’exécution.
  • System.Threading.Timer, qui exécute une méthode de rappel unique sur un thread de pool de threads à intervalles réguliers. La méthode de rappel est définie lorsque le minuteur est instancié et ne peut pas être modifié. Comme la System.Timers.Timer classe, cette classe est destinée à être utilisée en tant que composant de serveur ou de service dans un environnement multithread ; elle n’a pas d’interface utilisateur et n’est pas visible au moment de l’exécution.
  • System.Windows.Forms.Timer, 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. 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.
  • System.Web.UI.Timer (.NET Framework uniquement), un composant ASP.NET qui effectue des publications de page web asynchrones ou synchrones à intervalles réguliers.
  • System.Windows.Threading.DispatcherTimer, un minuteur intégré à la file d’attente Dispatcher . Ce minuteur est traité avec une priorité spécifiée à un intervalle de temps spécifié.

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 (délai d’échéance) et un délai d’attente entre les exécutions suivantes (période). La Timer classe a la même résolution que l’horloge système. Cela signifie que si la période est inférieure à la résolution de l’horloge système, le TimerCallback délégué s’exécute à des intervalles définis par la résolution de l’horloge système, qui est d’environ 15 millisecondes sur les systèmes Windows 7 et Windows 8. Vous pouvez modifier l’heure et la période d’échéance, ou désactiver le minuteur à l’aide de la Change méthode .

Notes

Tant que vous utilisez un Timer, vous devez conserver une référence à celui-ci. Comme pour tout objet managé, un Timer est soumis au garbage collection lorsqu’il n’y a aucune référence à celui-ci. Le fait qu’un Timer soit toujours actif n’empêche pas sa collecte.

Notes

L’horloge système utilisée est la même horloge que celle utilisée par GetTickCount, qui n’est pas affectée par les modifications apportées avec timeBeginPeriod et timeEndPeriod.

Lorsqu’un minuteur n’est plus nécessaire, utilisez la Dispose méthode pour libérer les ressources détenues par le minuteur. Notez que les rappels peuvent se produire après l’appel de la Dispose() surcharge de méthode, car le minuteur met en file d’attente les rappels pour l’exécution par les threads du pool de threads. Vous pouvez utiliser la surcharge de Dispose(WaitHandle) méthode pour attendre que tous les rappels soient terminés.

La méthode de rappel exécutée par le minuteur doit être réentrée, car elle est appelée sur ThreadPool les threads. Le rappel peut être exécuté simultanément sur deux threads de pool de threads si l’intervalle du minuteur est inférieur au temps nécessaire à l’exécution du rappel, ou si tous les threads du pool de threads sont en cours d’utilisation et que le rappel est mis en file d’attente plusieurs fois.

Notes

System.Threading.Timer est un minuteur simple et léger qui utilise des méthodes de rappel et est pris en charge par des threads de pool de threads. Il n’est pas recommandé d’utiliser avec Windows Forms, car ses rappels ne se produisent pas sur le thread d’interface utilisateur. System.Windows.Forms.Timerest un meilleur choix pour une utilisation avec Windows Forms. Pour la fonctionnalité du minuteur basé sur le serveur, vous pouvez envisager d’utiliser System.Timers.Timer, qui déclenche des événements et dispose de fonctionnalités supplémentaires.

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.

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.

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.

Timer(TimerCallback, Object, TimeSpan, TimeSpan)

Initialise une nouvelle instance de la classe Timer utilisant des valeurs TimeSpan pour mesurer les intervalles de temps.

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.

Propriétés

ActiveCount

Obtient le nombre de minuteries actuellement actives. Une minuterie active est inscrite pour sonner à un moment donné dans le futur et n’a pas encore été annulée.

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.

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.

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.

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.

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.

(Hérité de MarshalByRefObject)
Dispose()

Libère toutes les ressources utilisées par l'instance actuelle de 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.

DisposeAsync()

Libère toutes les ressources utilisées par l'instance actuelle de Timer.

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.

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

GetHashCode()

Fait office de fonction de hachage par défaut.

(Hérité de Object)
GetLifetimeService()
Obsolète.

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.

(Hérité de MarshalByRefObject)
GetType()

Obtient le Type de l'instance actuelle.

(Hérité de Object)
InitializeLifetimeService()
Obsolète.

Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance.

(Hérité de MarshalByRefObject)
MemberwiseClone()

Crée une copie superficielle du Object actuel.

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

Crée une copie superficielle de l'objet MarshalByRefObject actuel.

(Hérité de MarshalByRefObject)
ToString()

Retourne une chaîne qui représente l'objet actuel.

(Hérité de Object)

Méthodes d’extension

ConfigureAwait(IAsyncDisposable, Boolean)

Configure la façon dont les attentes sur les tâches retournées à partir d’un élément supprimable asynchrone sont effectuées.

S’applique à

Cohérence de thread

Ce type est thread-safe.

Voir aussi