Comment puis-je arrêter gracieusement un System.Threading.Timer?

J’ai un service Windows implémenté en C # qui a besoin de travailler de temps en temps. J’ai implémenté cela à l’aide de System.Threading.Timer avec une méthode de rappel responsable de la planification du prochain rappel. Je ne parviens pas à arrêter le chronomètre avec élégance. Voici un code simplifié que vous pouvez exécuter dans une application console qui illustre mon problème:

 const int tickInterval = 1000; // one second timer = new Timer( state => { // simulate some work that takes ten seconds Thread.Sleep( tickInterval * 10 ); // when the work is done, schedule the next callback in one second timer.Change( tickInterval, Timeout.Infinite ); }, null, tickInterval, // first callback in one second Timeout.Infinite ); // simulate the Windows Service happily running for a while before the user tells it to stop Thread.Sleep( tickInterval * 3 ); // try to gracefully dispose the timer while a callback is in progress var waitHandle = new ManualResetEvent( false ); timer.Dispose( waitHandle ); waitHandle.WaitOne(); 

Le problème est que je reçois une timer.Change ObjectDisposedException de timer.Change sur le thread de rappel pendant que waitHandle.WaitOne bloque. Qu’est-ce que je fais mal?

La documentation relative à la surcharge Dispose j’utilise indique:

La timer n’est pas supprimée tant que tous les rappels actuellement en queue ne sont pas terminés.

• Quelle est la meilleure pratique pour capturer tous les détails des exceptions internes?
• Comportement non intuitif avec l’initialisation de la structure et les arguments par défaut
• .net SqlConnection n’étant pas fermé même dans un using {}
• LINQ to SQL: exception intermittente AccessViolationException encapsulée dans TargetInvocationException
• Rechercher et activer la fenêtre d’une application

Edit: Il semble que cette déclaration de la documentation soit peut-être incorrecte. Quelqu’un peut vérifier?

Je sais que je pourrais contourner le problème en ajoutant une certaine signalisation entre le code de rappel et le code d’élimination, comme suggéré ci-dessous par Henk Holterman, mais je ne souhaite pas procéder ainsi sauf si c’est absolument nécessaire.

• Le bloc de capture n’est pas en cours d’évaluation lorsque des exceptions sont levées à partir de finally
• Automapper: passage du paramètre à la méthode Map
• Devrais-je privilégier IEnumerable ou les tableaux?
• Désactiver l’optimisation du compilateur pour une fonction ou un bloc de code spécifique (C #)
• PUSH ne s’affiche pas lorsque l’application est ouverte

  timer = new Timer( state => { // simulate some work that takes ten seconds Thread.Sleep( tickInterval * 10 ); // when the work is done, schedule the next callback in one second timer.Change( tickInterval, Timeout.Infinite ); }, null, tickInterval, // first callback in one second Timeout.Infinite ); 

 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using System.ComponentModel; using System.Data; using System.Diagnostics; using System.Threading; namespace MyNameSpace { class InvalidWaitHandle : WaitHandle { } } 

 public static void DisposeTimer() { MyTimer.Dispose(new InvalidWaitHandle()); MyTimer = null; }