Timer Classe

Référence

Définition

Espace de noms:: System.Timers

Assembly:: System.ComponentModel.TypeConverter.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Source:: Timer.cs

Source:: Timer.cs

Source:: Timer.cs

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Génère un événement au bout d'un intervalle défini, avec la possibilité de générer des événements récurrents.

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

Héritage: Object

MarshalByRefObject

Component
Timer

Implémente: ISupportInitialize

Exemples

L’exemple suivant instancie un System.Timers.Timer objet qui déclenche son Timer.Elapsed événement toutes les deux secondes (2 000 millisecondes), configure un gestionnaire d’événements pour l’événement et démarre le minuteur. Le gestionnaire d’événements affiche la valeur de la ElapsedEventArgs.SignalTime propriété chaque fois qu’elle est déclenchée.

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

Remarques

Le Timer composant est un minuteur basé sur un serveur qui déclenche un Elapsed événement dans votre application après l’expiration du nombre de millisecondes dans la Interval propriété. Vous pouvez configurer l’objet Timer pour déclencher l’événement une seule fois ou plusieurs fois à l’aide de la AutoReset propriété . En règle générale, un Timer objet est déclaré au niveau de la classe afin qu’il reste dans l’étendue aussi longtemps qu’il est nécessaire. Vous pouvez ensuite gérer son Elapsed événement pour fournir un traitement régulier. Par exemple, supposons que vous disposez d’un serveur critique qui doit être maintenu en cours d’exécution 24 heures sur 24, 7 jours sur 7. Vous pouvez créer un service qui utilise un Timer objet pour case activée périodiquement le serveur et vous assurer que le système est opérationnel. Si le système ne répond pas, le service peut tenter de redémarrer le serveur ou d’en avertir un administrateur.

Important

La Timer classe n’est pas disponible pour toutes les implémentations et versions de .NET, telles que .NET Standard 1.6 et versions inférieures. Dans ce cas, vous pouvez utiliser la classe à la System.Threading.Timer place.

Ce type implémente l'interface IDisposable. Une fois que vous avez fini d’utiliser le type, vous devez le supprimer directement ou indirectement. Pour supprimer directement le type Dispose, appelez sa méthode dans un bloc try/catch. Pour la supprimer indirectement, utilisez une construction de langage telle que using (dans C#) ou Using (dans Visual Basic). Pour plus d’informations, consultez la section « Utilisation d’un objet qui implémente IDisposable » dans la rubrique de l’interface IDisposable.

La classe basée sur System.Timers.Timer le serveur est conçue pour être utilisée avec des threads de travail dans un environnement multithread. Les minuteurs de serveur peuvent se déplacer entre les threads pour gérer l’événement déclenché Elapsed , ce qui entraîne une plus grande précision que les minuteurs Windows pour déclencher l’événement à temps.

Le System.Timers.Timer composant déclenche l’événement Elapsed , en fonction de la valeur (en millisecondes) de la Interval propriété. Vous pouvez gérer cet événement pour effectuer le traitement dont vous avez besoin. Par exemple, supposons que vous disposez d’une application de vente en ligne qui publie continuellement des commandes client dans une base de données. Le service qui compile les instructions d’expédition fonctionne sur un lot de commandes plutôt que de traiter chaque commande individuellement. Vous pouvez utiliser un Timer pour démarrer le traitement par lot toutes les 30 minutes.

Important

La classe System.Timers.Timer a la même résolution que l’horloge système. Cela signifie que l’événement Elapsed se déclenche à un intervalle défini par la résolution de l’horloge système si la Interval propriété est inférieure à la résolution de l’horloge système. Pour plus d'informations, consultez la propriété Interval.

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.

Quand AutoReset est défini sur false, un System.Timers.Timer objet déclenche l’événement Elapsed une seule fois, une fois le premier Interval écoulé. Pour continuer à déclencher l’événement Elapsed régulièrement à l’intervalle défini par , Intervaldéfini sur AutoResettrue, qui est la valeur par défaut.

Le Timer composant intercepte et supprime toutes les exceptions levées par les gestionnaires d’événements pour l’événement Elapsed . Ce comportement est susceptible de changer dans les versions futures du .NET Framework. Notez toutefois que cela n’est pas vrai pour les gestionnaires d’événements qui s’exécutent de manière asynchrone et incluent l’opérateur await (en C#) ou l’opérateur Await (en Visual Basic). Les exceptions levées dans ces gestionnaires d’événements sont propagées vers le thread appelant, comme l’illustre l’exemple suivant. Pour plus d’informations sur les exceptions levées dans les méthodes asynchrones, consultez Gestion des exceptions.

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

Si la SynchronizingObject propriété est null, l’événement Elapsed est déclenché sur un ThreadPool thread. Si le traitement de l’événement Elapsed dure plus longtemps que Interval, l’événement peut être déclenché à nouveau sur un autre ThreadPool thread. Dans ce cas, le gestionnaire d’événements doit être réentrant.

Notes

La méthode de gestion des événements peut s’exécuter sur un thread en même temps qu’un autre thread appelle la Stop méthode ou définit la Enabled propriété sur false. Cela peut entraîner la levée de l’événement Elapsed après l’arrêt du minuteur. L’exemple de code de la Stop méthode montre un moyen d’éviter cette condition de race.

Même si SynchronizingObject n’a pas nullla valeur , Elapsed les événements peuvent se produire après l’appel de la Dispose méthode ou Stop après que la Enabled propriété a été définie falsesur , car le signal pour déclencher l’événement Elapsed est toujours mis en file d’attente pour l’exécution sur un thread de pool de threads. Une façon de résoudre cette condition de race consiste à définir un indicateur qui indique au gestionnaire d’événements pour l’événement d’ignorer Elapsed les événements suivants.

Si vous utilisez la System.Timers.Timer classe avec un élément d’interface utilisateur, tel qu’un formulaire ou un contrôle, sans placer le minuteur sur cet élément d’interface utilisateur, affectez le formulaire ou le contrôle qui contient à Timer la SynchronizingObject propriété, afin que l’événement soit marshalé sur le thread d’interface utilisateur.

Pour obtenir la liste des valeurs de propriété par défaut d’un instance de Timer, consultez le Timer constructeur.

Conseil

.NET comprend quatre classes nommées Timer, chacune offrant des fonctionnalités différentes :

System.Timers.Timer (cette rubrique) : déclenche un événement à 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: 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 : composant Windows Forms qui déclenche un événement à intervalles réguliers. Le composant ne possède pas d’interface utilisateur et est conçu pour une utilisation dans un environnement à thread unique.
System.Web.UI.Timer (.NET Framework uniquement) : composant ASP.NET qui effectue des publications de page web asynchrones ou synchrones à intervalles réguliers.

Constructeurs

Timer()	Initialise une nouvelle instance de la classe Timer et affecte à toutes les propriétés leurs valeurs initiales.
Timer(Double)	Initialise une nouvelle instance de la classe Timer et affecte le nombre spécifié de millisecondes à la propriété Interval.
Timer(TimeSpan)	Initialise une nouvelle instance de la Timer classe, en définissant la Interval propriété sur la période spécifiée.

Propriétés

AutoReset	Obtient ou définit une valeur booléenne indiquant si Timer doit déclencher l'événement Elapsed une seule fois (`false`) ou de façon répétée (`true`).
CanRaiseEvents	Obtient une valeur qui indique si le composant peut déclencher un événement. (Hérité de Component)
Container	Obtient le IContainer qui contient la Component. (Hérité de Component)
DesignMode	Obtient une valeur qui indique si Component est actuellement en mode design. (Hérité de Component)
Enabled	Obtient ou définit une valeur indiquant si Timer doit déclencher l'événement Elapsed.
Events	Obtient la liste des gestionnaires d'événements attachés à ce Component. (Hérité de Component)
Interval	Obtient ou définit l'intervalle, exprimé en millisecondes, auquel l'événement Elapsed doit être déclenché.
Site	Obtient ou définit le site qui lie Timer à son conteneur en mode design.
SynchronizingObject	Obtient ou définit l'objet utilisé pour marshaler les appels du gestionnaire d'événements émis quand un intervalle a expiré.

Méthodes

BeginInit()	Débute l'initialisation au moment de l'exécution d'un Timer utilisé sur un formulaire ou par un autre composant.
Close()	Libère les ressources utilisées par le Timer.
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 Component. (Hérité de Component)
Dispose(Boolean)	Libère toutes les ressources utilisées par le Timer actuel.
EndInit()	Met fin à l'initialisation au moment de l'exécution d'un Timer utilisé sur un formulaire ou par un autre composant.
Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
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)
GetService(Type)	Retourne un objet qui représente un service fourni par Component ou par son Container. (Hérité de Component)
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)
Start()	Lance le déclenchement de l'événement Elapsed en affectant à Enabled la valeur `true`.
Stop()	Arrête le déclenchement de l'événement Elapsed en affectant à Enabled la valeur `false`.
ToString()	Retourne un String contenant le nom du Component, s’il en existe un. Cette méthode ne doit pas être remplacée. (Hérité de Component)

Événements

Disposed	Se produit lorsque le composant est supprimé par un appel à la méthode Dispose(). (Hérité de Component)
Elapsed	Se produit quand l'intervalle est écoulé.

S’applique à

Cohérence de thread

Tous les membres publics static de ce type sont thread safe. Tous les membres de l'instance ne sont pas garantis comme étant thread-safe.

Partage via

Timer Classe

Définition

Exemples

Remarques

Constructeurs

Propriétés

Méthodes

Événements

S’applique à

Cohérence de thread

Voir aussi

Ressources supplémentaires