System.Threading.Timer en C # parece no estar funcionando. Corre muy rápido cada 3 segundos.

Tengo un objeto de temporizador. Quiero que se ejecute cada minuto. Específicamente, debería ejecutar un OnCallBackmétodo y permanecer inactivo mientras OnCallBackse ejecuta un método. Una vez que finaliza un OnCallBackmétodo, (a OnCallBack) reinicia un temporizador.

Esto es lo que tengo ahora mismo:

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
}

Sin embargo, parece que no funciona. Corre muy rápido cada 3 segundos. Incluso cuando se eleva un punto (1000 * 10). Parece que se hace de la vista gorda1000 * 10

¿Qué hice mal?

Este no es el uso correcto de System.Threading.Timer. Cuando crea una instancia del temporizador, casi siempre debe hacer lo siguiente:

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

Esto le indicará al temporizador que marque solo una vez cuando haya transcurrido el intervalo. Luego, en su función de devolución de llamada, cambia el temporizador una vez que se ha completado el trabajo, no antes. Ejemplo:

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

Por tanto, no hay necesidad de mecanismos de bloqueo porque no hay concurrencia. El temporizador disparará la siguiente devolución de llamada después de que haya transcurrido el siguiente intervalo + el tiempo de la operación de larga duración.

Si necesita ejecutar su temporizador exactamente en N milisegundos, le sugiero que mida el tiempo de la operación de larga duración usando Cronómetro y luego llame al método Cambiar de manera apropiada:

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 );
}

Recomiendo encarecidamente a cualquiera que esté usando .NET y esté usando CLR que no haya leído el libro de Jeffrey Richter: CLR a través de C # , que lo lea lo antes posible. Los temporizadores y los grupos de hilos se explican con gran detalle allí.

No es necesario detener el temporizador, vea una buena solución en esta publicación :

"Puede dejar que el temporizador continúe activando el método de devolución de llamada, pero envuelva su código no reentrante en un Monitor. TryEnter / Exit. No es necesario detener / reiniciar el temporizador en ese caso; las llamadas superpuestas no adquirirán el bloqueo y regresarán inmediatamente".

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

¿Es System.Threading.Timerobligatorio el uso ?

Si no es así, System.Timers.Timertiene métodos prácticos Start()y Stop()(y una AutoResetpropiedad que puede establecer en falso, para que Stop()no sea necesario y simplemente llame Start()después de ejecutar).

Yo solo haría:

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
  }

E ignore el parámetro de período, ya que está intentando controlar la periodicidad usted mismo.

Su código original se está ejecutando lo más rápido posible, ya que sigue especificando 0el dueTimeparámetro. De Timer.Change:

Si dueTime es cero (0), el método de devolución de llamada se invoca inmediatamente.

 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 quieres usar un hilo de bucle dentro ...

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.