HOWTO · Csharp

Réinitialiser la minuterie en C#

Cet article explique comment réinitialiser une minuterie à l'aide du langage de programmation C#.

Sur cette page

Pour réinitialiser l’intervalle d’une minuterie en C#, appelez Stop() puis Start() sur un System.Timers.Timer. Ce type ne possède pas de méthode Reset(). Réglez AutoReset selon que vous souhaitez déclencher un seul événement ou des événements répétés ; cette propriété ne relance pas à la demande un compte à rebours en cours.

Quel comportement de minuterie en C# vous faut-il ?

Choisissez une minuterie à déclenchement unique lorsqu’une opération doit s’exécuter une seule fois après un délai, ou lorsque votre code planifiera explicitement l’intervalle suivant. Réglez AutoReset sur false, puis utilisez Stop() et Start() chaque fois que vous avez besoin d’un nouvel intervalle. Pour des opérations périodiques, réglez AutoReset sur true et laissez la minuterie déclencher Elapsed après chaque intervalle.

Si la minuterie est déjà en cours d’exécution et que vous devez retarder son prochain événement, arrêtez-la puis redémarrez-la. Démarrer une minuterie déjà activée ne constitue pas une opération distincte de réinitialisation. Configurez l’intervalle en millisecondes et choisissez une durée positive adaptée au travail ; une minuterie sert à planifier des rappels, pas à mesurer précisément le temps écoulé.

Comment System.Timers.Timer gère les événements écoulés

System.Timers.Timer déclenche son événement Elapsed après l’Interval configuré. Enabled indique si la minuterie est en cours d’exécution ; Start() l’active et Stop() la désactive. Le gestionnaire d’événement reçoit une valeur ElapsedEventArgs, qui comprend l’heure du signal. Les gestionnaires s’exécutent de manière asynchrone et peuvent donc se chevaucher si une opération récurrente dure plus longtemps que l’intervalle. Protégez l’état partagé et ne supposez pas que le rappel s’exécute sur le thread de l’interface utilisateur.

AutoReset est une propriété booléenne. Avec true, la minuterie planifie les événements Elapsed suivants selon l’intervalle. Avec false, elle déclenche un seul événement, puis s’arrête. Cette propriété contrôle la répétition ; elle ne commande pas la relance du compte à rebours en cours. Pour qu’une minuterie à déclenchement unique démarre un autre intervalle, appelez explicitement Start() après le traitement de l’événement.

Redémarrer une minuterie à déclenchement unique avec Stop et Start

Pour une minuterie à déclenchement unique en cours d’exécution, appelez Stop() afin d’annuler sa planification en attente, puis Start() pour lancer un nouvel intervalle. C’est la méthode pratique pour la réinitialiser. Si elle a déjà déclenché son événement avec AutoReset réglé sur false, appelez Start() pour en planifier un autre. Réglez AutoReset avant le démarrage si vous voulez que son comportement soit défini dès le départ.

N’oubliez pas que les rappels de minuterie sont asynchrones. Un rappel peut déjà être en attente lorsqu’une autre partie du programme arrête la minuterie ; coordonnez donc l’arrêt et l’accès aux données partagées lorsque cette distinction est importante. Gardez le gestionnaire court ou confiez les opérations longues à un processus de travail contrôlé, afin que les déclenchements récurrents ne se disputent pas les ressources avec les opérations encore en cours.

Utiliser AutoReset pour des intervalles récurrents

Réglez AutoReset = true pour obtenir un intervalle récurrent, par exemple pour interroger périodiquement une source ou actualiser une valeur. Chaque événement écoulé est planifié en fonction de l’intervalle de la minuterie. Réglez cette propriété sur false si vous voulez un seul événement et préférez décider explicitement du démarrage de l’intervalle suivant. Aucun des deux réglages ne donne accès à la valeur du compte à rebours ni ne modifie sur place l’intervalle d’un déclenchement déjà planifié ; arrêtez puis redémarrez la minuterie pour planifier un nouvel intervalle.

N’utilisez pas une minuterie récurrente comme horloge de précision. La charge du pool de threads peut retarder la planification, et le rappel peut ne pas commencer exactement à la milliseconde demandée. Si chaque opération doit se terminer avant le début de la suivante, planifiez un déclenchement unique après la fin de l’opération ou synchronisez les opérations.

Arrêter et libérer la minuterie en toute sécurité

Appelez Stop() lorsque la minuterie ne doit plus planifier d’événements. À la fin de l’opération qui en est responsable, appelez Dispose() pour libérer ses ressources. L’arrêt et la libération répondent à des besoins différents : Stop() met fin à la planification active, tandis que Dispose() met fin à la durée de vie de la minuterie. Ne redémarrez pas une minuterie libérée ; créez-en une nouvelle si une autre opération en a besoin.

Comme Elapsed s’exécute de manière asynchrone, arrêter la minuterie ne met pas fin à un gestionnaire déjà en cours d’exécution. Si l’arrêt doit attendre la fin d’un rappel, coordonnez-vous avec ce gestionnaire au moyen d’un mécanisme de synchronisation adapté à l’application. Gardez la minuterie en vie tant que son gestionnaire est susceptible de l’utiliser et désabonnez les gestionnaires lorsqu’une minuterie de longue durée n’en a plus besoin.

Exemple complet : redémarrer une minuterie à déclenchement unique

Cet exemple complet déclenche un événement après deux secondes, lance un nouvel intervalle depuis ce gestionnaire, puis se termine après le deuxième événement. AutoReset = false fait de chaque événement un déclenchement unique ; Stop() et Start() planifient explicitement le deuxième intervalle. Le signal de fin permet à Main d’attendre les deux rappels avant de procéder au nettoyage.

Exécutez cet exemple :

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

using System;
using System.Threading;
using System.Timers;

class TimerRestartExample
{
    static void Main()
    {
        using (var completed = new ManualResetEventSlim())
        using (var timer = new System.Timers.Timer(2000))
        {
            int eventCount = 0;
            timer.AutoReset = false;
            timer.Elapsed += (sender, args) =>
            {
                eventCount++;
                Console.WriteLine("Elapsed event " + eventCount);

                if (eventCount == 1)
                {
                    timer.Stop();
                    timer.Start();
                }
                else
                {
                    completed.Set();
                }
            };

            timer.Start();
            completed.Wait();
            timer.Stop();
        }
    }
}
Elapsed event 1
Elapsed event 2

L’exécution fournie a réussi et a affiché les deux événements écoulés indiqués ci-dessus. Les libellés visibles dans les blocs de code et de sortie restent en anglais, car ces blocs sont conservés à l’identique. Dans une application, choisissez un intervalle et une stratégie de fin adaptés à sa durée de vie ; un service ou une interface utilisateur peut continuer à fonctionner après un événement de minuterie, au lieu d’attendre puis de se terminer comme dans cette démonstration.