System.Threading.Timer en C #, il semble ne pas fonctionner. Il tourne très vite toutes les 3 secondes

J'ai un objet minuterie. Je veux qu'il soit exécuté toutes les minutes. Plus précisément, il doit exécuter une OnCallBackméthode et devient inactif lorsqu'une OnCallBackméthode est en cours d'exécution. Une fois qu'une OnCallBackméthode se termine, elle (a OnCallBack) redémarre une minuterie.

Voici ce que j'ai en ce moment:

private static Timer timer;

private static void Main()
{
    timer = new Timer(_ => OnCallBack(), null, 0, 1000 * 10); //every 10 seconds
    Console.ReadLine();
}

private static void OnCallBack()
{
    timer.Change(Timeout.Infinite, Timeout.Infinite); //stops the timer
    Thread.Sleep(3000); //doing some long operation
    timer.Change(0, 1000 * 10);  //restarts the timer
}

Cependant, cela semble ne pas fonctionner. Il fonctionne très vite toutes les 3 secondes. Même si augmenter une période (1000 * 10). On dirait que ça ferme les yeux sur1000 * 10

Qu'ai-je fait de mal?

Ce n'est pas l'utilisation correcte de System.Threading.Timer. Lorsque vous instanciez le minuteur, vous devez presque toujours effectuer les opérations suivantes:

_timer = new Timer( Callback, null, TIME_INTERVAL_IN_MILLISECONDS, Timeout.Infinite );

Cela demandera au chronomètre de ne cocher qu'une seule fois lorsque l'intervalle est écoulé. Ensuite, dans votre fonction de rappel, vous modifiez la minuterie une fois le travail terminé, pas avant. Exemple:

private void Callback( Object state )
{
    // Long running operation
   _timer.Change( TIME_INTERVAL_IN_MILLISECONDS, Timeout.Infinite );
}

Il n'y a donc pas besoin de mécanismes de verrouillage car il n'y a pas de concurrence. La minuterie déclenchera le prochain rappel après que l'intervalle suivant se soit écoulé + le temps de l'opération longue.

Si vous devez exécuter votre minuterie à exactement N millisecondes, je vous suggère de mesurer le temps de l'opération de longue durée à l'aide du chronomètre, puis d'appeler la méthode Change de manière appropriée:

private void Callback( Object state )
{
   Stopwatch watch = new Stopwatch();

   watch.Start();
   // Long running operation

   _timer.Change( Math.Max( 0, TIME_INTERVAL_IN_MILLISECONDS - watch.ElapsedMilliseconds ), Timeout.Infinite );
}

Je fortement encourage tous ceux qui font .NET et utilise le CLR qui n'a pas lu le livre de Jeffrey Richter - CLR via C # , lire est le plus tôt possible. Les minuteries et les pools de threads y sont expliqués en détail.

Il n'est pas nécessaire d'arrêter la minuterie, voir la belle solution de ce post :

"Vous pouvez laisser le chronomètre continuer à déclencher la méthode de rappel, mais envelopper votre code non réentrant dans un Monitor.TryEnter / Exit. Inutile d'arrêter / redémarrer le chronomètre dans ce cas; les appels qui se chevauchent n'acquièrent pas le verrou et ne reviennent pas immédiatement."

private void CreatorLoop(object state) 
 {
   if (Monitor.TryEnter(lockObject))
   {
     try
     {
       // Work here
     }
     finally
     {
       Monitor.Exit(lockObject);
     }
   }
 }

L'utilisation est-elle System.Threading.Timerobligatoire?

Sinon, System.Timers.Timera des méthodes pratiques Start()et Stop()(et une AutoResetpropriété que vous pouvez définir sur false, de sorte que le Stop()n'est pas nécessaire et que vous appelez simplement Start()après l'exécution).

Je ferais juste:

private static Timer timer;
 private static void Main()
 {
   timer = new Timer(_ => OnCallBack(), null, 1000 * 10,Timeout.Infinite); //in 10 seconds
   Console.ReadLine();
 }

  private static void OnCallBack()
  {
    timer.Dispose();
    Thread.Sleep(3000); //doing some long operation
    timer = new Timer(_ => OnCallBack(), null, 1000 * 10,Timeout.Infinite); //in 10 seconds
  }

Et ignorez le paramètre de période, car vous essayez de contrôler la périodicité vous-même.

Votre code d'origine s'exécute aussi vite que possible, car vous continuez à spécifier 0le dueTimeparamètre. De Timer.Change:

Si dueTime vaut zéro (0), la méthode de rappel est appelée immédiatement.

 var span = TimeSpan.FromMinutes(2);
 var t = Task.Factory.StartNew(async delegate / () =>
   {
        this.SomeAsync();
        await Task.Delay(span, source.Token);
  }, source.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default);

source.Cancel(true/or not);

// or use ThreadPool(whit defaul options thread) like this
Task.Start(()=>{...}), source.Token)

si vous aimez utiliser un fil de boucle à l'intérieur ...

public async void RunForestRun(CancellationToken token)
{
  var t = await Task.Factory.StartNew(async delegate
   {
       while (true)
       {
           await Task.Delay(TimeSpan.FromSeconds(1), token)
                 .ContinueWith(task => { Console.WriteLine("End delay"); });
           this.PrintConsole(1);
        }
    }, token) // drop thread options to default values;
}

// And somewhere there
source.Cancel();
//or
token.ThrowIfCancellationRequested(); // try/ catch block requred.