Compartir a través de

Temporizadores

.NET proporciona tres temporizadores para usarlos en un entorno multiproceso:

Nota:

Algunas implementaciones de .NET pueden incluir temporizadores adicionales:

  • System.Windows.Forms.Timer: un componente de Windows Forms que desencadena un evento a intervalos regulares. El componente no tiene ninguna interfaz de usuario y está diseñada para su uso en un entorno de un solo subproceso.
  • System.Web.UI.Timer: un componente de ASP.NET que realiza devoluciones de página web, ya sean asincrónicas o sincrónicas, a intervalos regulares.
  • System.Windows.Threading.DispatcherTimer: un temporizador integrado en la Dispatcher cola que se procesa en un intervalo de tiempo especificado y con una prioridad especificada.

La clase System.Threading.Timer

La System.Threading.Timer clase permite llamar continuamente a un delegado en intervalos de tiempo especificados. También puede usar esta clase para programar una sola llamada a un delegado en un intervalo de tiempo especificado. El delegado se ejecuta en un ThreadPool subproceso.

Al crear un objeto System.Threading.Timer, se especifica un delegado TimerCallback que define el método de devolución de llamada, un objeto de estado opcional que se pasa a la devolución de llamada, la cantidad de tiempo que se retrasará antes de invocar por primera vez la devolución de llamada y el intervalo entre las invocaciones de devolución de llamada. Para cancelar un temporizador pendiente, llame al Timer.Dispose método .

En el ejemplo siguiente se crea un temporizador que llama al delegado proporcionado por primera vez después de un segundo (1000 milisegundos) y, a continuación, lo llama cada dos segundos. El objeto de estado del ejemplo se usa para contar cuántas veces se llama al delegado. El temporizador se detiene cuando se llama al delegado al menos 10 veces.

using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    private static Timer timer;

    static void Main(string[] args)
    {
        var timerState = new TimerState { Counter = 0 };

        timer = new Timer(
            callback: new TimerCallback(TimerTask),
            state: timerState,
            dueTime: 1000,
            period: 2000);

        while (timerState.Counter <= 10)
        {
            Task.Delay(1000).Wait();
        }

        timer.Dispose();
        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: done.");
    }

    private static void TimerTask(object timerState)
    {
        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: starting a new callback.");
        var state = timerState as TimerState;
        Interlocked.Increment(ref state.Counter);
    }

    class TimerState
    {
        public int Counter;
    }
}

Imports System.Threading

Module Program

    Private Timer As Timer

    Sub Main(args As String())

        Dim StateObj As New TimerState
        StateObj.Counter = 0

        Timer = New Timer(New TimerCallback(AddressOf TimerTask), StateObj, 1000, 2000)

        While StateObj.Counter <= 10
            Task.Delay(1000).Wait()
        End While

        Timer.Dispose()
        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: done.")
    End Sub

    Private Sub TimerTask(ByVal StateObj As Object)

        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: starting a new callback.")

        Dim State As TimerState = CType(StateObj, TimerState)
        Interlocked.Increment(State.Counter)
    End Sub

    Private Class TimerState
        Public Counter As Integer
    End Class
End Module

Para obtener más información y ejemplos, vea System.Threading.Timer.

La clase System.Timers.Timer

Otro temporizador que se puede usar en un entorno multiproceso es System.Timers.Timer que, de forma predeterminada, genera un evento en un ThreadPool subproceso.

Al crear un System.Timers.Timer objeto, puede especificar el intervalo de tiempo en el que se va a generar un Elapsed evento. Use la Enabled propiedad para indicar si un temporizador debe generar un Elapsed evento. Si necesita que se active un Elapsed evento solo una vez transcurrido el intervalo especificado, establezca el AutoReset en false. El valor predeterminado de la AutoReset propiedad es true, lo que significa que un Elapsed evento se genera regularmente en el intervalo definido por la Interval propiedad .

Para obtener más información y ejemplos, vea System.Timers.Timer.

La clase System.Threading.PeriodicTimer

La System.Threading.PeriodicTimer clase le permite esperar tiempos individuales de un intervalo especificado, ejecutando tareas después de llamar a PeriodicTimer.WaitForNextTickAsync.

Al crear un System.Threading.PeriodicTimer objeto, se especifica un TimeSpan objeto que determina el período de tiempo entre cada tic del temporizador. En lugar de pasar un callback o establecer un controlador de eventos como en las clases de temporizador anteriores, realiza el trabajo directamente dentro del contexto, mientras espera que WaitForNextTickAsync avance el temporizador en el intervalo especificado.

El WaitForNextTickAsync método devuelve un ValueTask<bool>; true tras la activación correcta del temporizador y false cuando el temporizador se ha cancelado llamando a PeriodicTimer.Dispose. WaitForNextTickAsync opcionalmente, acepta un CancellationToken, que da como resultado un TaskCanceledException cuando se ha solicitado una cancelación.

Para obtener más información, consulte System.Threading.PeriodicTimer.

Consulte también