Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Constructor Timer (TimerCallback, Object, Int32, Int32)

 

Publicado: octubre de 2016

Inicializa una nueva instancia de la Timer clase, utilizando un entero de 32 bits con signo para especificar el intervalo de tiempo.

Espacio de nombres:   System.Threading
Ensamblado:  mscorlib (en mscorlib.dll)

public Timer(
	TimerCallback callback,
	object state,
	int dueTime,
	int period
)

Parámetros

callback
Type: System.Threading.TimerCallback

Un TimerCallback delegado que representa un método que se ejecute.

state
Type: System.Object

Un objeto que contiene información que se utiliza el método de devolución de llamada, o null.

dueTime
Type: System.Int32

La cantidad de tiempo de retraso antes de callback se invoca, en milisegundos. Especificar Timeout.Infinite para impedir que se inicie el temporizador. Especifique cero (0) para iniciar inmediatamente el temporizador.

period
Type: System.Int32

El intervalo de tiempo entre invocaciones de callback, en milisegundos. Especificar Timeout.Infinite para deshabilitar la señalización periódica.

Exception Condition
ArgumentOutOfRangeException

El dueTime o period parámetro es negativo y no es igual a Timeout.Infinite.

ArgumentNullException

El parámetro callback es null.

El delegado especificado por la callback parámetro se invoca después dueTime transcurre y posteriormente cada vez que la period intervalo finaliza el tiempo.

Si dueTime es cero (0), callback se invoca inmediatamente. Si dueTime es Timeout.Infinite, callback no se invoca, el temporizador se deshabilita, pero puede volver a habilitar llamando a la Change (método).

Dado que la Timer clase tiene la misma resolución que el reloj del sistema, que es aproximadamente 15 milisegundos en sistemas de Windows 7 y Windows 8, la callback delegado se ejecuta a intervalos definidos por la resolución del reloj del sistema si period es menor que la resolución del reloj del sistema. Si period es cero (0) o Timeout.Infinite y dueTime no Timeout.Infinite, callback se invoca una vez; el comportamiento periódico del temporizador está deshabilitado, pero se puede volver a habilitar mediante el Change método.

El método especificado para callback debe ser de reentrada, porque se llama en ThreadPool subprocesos. El método se puede ejecutar simultáneamente en dos subprocesos del grupo de subprocesos si el intervalo del temporizador es menor que el tiempo necesario para ejecutar el método, o si todos los subprocesos del grupo de subprocesos están en uso y el método se pone en cola varias veces.

En el ejemplo de código siguiente se muestra cómo crear un TimerCallback delegar e inicializar una nueva instancia de la Timer clase.

using System;
using System.Threading;

class TimerExample
{
    static void Main()
    {
        // Create an AutoResetEvent to signal the timeout threshold in the
        // timer callback has been reached.
        var autoEvent = new AutoResetEvent(false);

        var statusChecker = new StatusChecker(10);

        // Create a timer that invokes CheckStatus after one second, 
        // and every 1/4 second thereafter.
        Console.WriteLine("{0:h:mm:ss.fff} Creating timer.\n", 
                          DateTime.Now);
        var stateTimer = new Timer(statusChecker.CheckStatus, 
                                   autoEvent, 1000, 250);

        // When autoEvent signals, change the period to every half second.
        autoEvent.WaitOne();
        stateTimer.Change(0, 500);
        Console.WriteLine("\nChanging period to .5 seconds.\n");

        // When autoEvent signals the second time, dispose of the timer.
        autoEvent.WaitOne();
        stateTimer.Dispose();
        Console.WriteLine("\nDestroying timer.");
    }
}

class StatusChecker
{
    private int invokeCount;
    private int  maxCount;

    public StatusChecker(int count)
    {
        invokeCount  = 0;
        maxCount = count;
    }

    // This method is called by the timer delegate.
    public void CheckStatus(Object stateInfo)
    {
        AutoResetEvent autoEvent = (AutoResetEvent)stateInfo;
        Console.WriteLine("{0} Checking status {1,2}.", 
            DateTime.Now.ToString("h:mm:ss.fff"), 
            (++invokeCount).ToString());

        if(invokeCount == maxCount)
        {
            // Reset the counter and signal the waiting thread.
            invokeCount = 0;
            autoEvent.Set();
        }
    }
}
// The example displays output like the following:
//       11:59:54.202 Creating timer.
//       
//       11:59:55.217 Checking status  1.
//       11:59:55.466 Checking status  2.
//       11:59:55.716 Checking status  3.
//       11:59:55.968 Checking status  4.
//       11:59:56.218 Checking status  5.
//       11:59:56.470 Checking status  6.
//       11:59:56.722 Checking status  7.
//       11:59:56.972 Checking status  8.
//       11:59:57.223 Checking status  9.
//       11:59:57.473 Checking status 10.
//       
//       Changing period to .5 seconds.
//       
//       11:59:57.474 Checking status  1.
//       11:59:57.976 Checking status  2.
//       11:59:58.476 Checking status  3.
//       11:59:58.977 Checking status  4.
//       11:59:59.477 Checking status  5.
//       11:59:59.977 Checking status  6.
//       12:00:00.478 Checking status  7.
//       12:00:00.980 Checking status  8.
//       12:00:01.481 Checking status  9.
//       12:00:01.981 Checking status 10.
//       
//       Destroying timer.

Plataforma universal de Windows
Disponible desde 8.1
.NET Framework
Disponible desde 1.1
Biblioteca de clases portable
Se admite en: plataformas portátiles de .NET
Silverlight
Disponible desde 2.0
Windows Phone Silverlight
Disponible desde 7.0
Windows Phone
Disponible desde 8.1
Volver al principio
Mostrar: