Timer Construtores

public:
 Timer(System::Threading::TimerCallback ^ callback);

public Timer(System.Threading.TimerCallback callback);

new System.Threading.Timer : System.Threading.TimerCallback -> System.Threading.Timer

Public Sub New (callback As TimerCallback)

Parâmetros

Exemplos

O exemplo de código seguinte cria um novo temporizador, usando o próprio temporizador como objeto de estado. O Change método é usado para iniciar o temporizador. Quando ocorre o callback do temporizador, o objeto de estado é usado para desligar o temporizador.

using System;
using System.Threading;

public class Example
{
    public static void Main()
    {
        // Create an instance of the Example class, and start two
        // timers.
        Example ex = new Example();
        ex.StartTimer(2000);
        ex.StartTimer(1000);

        Console.WriteLine("Press Enter to end the program.");
        Console.ReadLine();
    }

    public void StartTimer(int dueTime)
    {
        Timer t = new Timer(new TimerCallback(TimerProc));
        t.Change(dueTime, 0);
    }

    private void TimerProc(object state)
    {
        // The state object is the Timer object.
        Timer t = (Timer) state;
        t.Dispose();
        Console.WriteLine("The timer callback executes.");
    }
}

Imports System.Threading

Public Class Example
    Public Shared Sub Main()
        ' Create an instance of the Example class, and start two
        ' timers.
        Dim ex As New Example()
        ex.StartTimer(2000)
        ex.StartTimer(1000)

        Console.WriteLine("Press Enter to end the program.")
        Console.ReadLine()
    End Sub

    Public Sub StartTimer(ByVal dueTime As Integer)
        Dim t As New Timer(AddressOf TimerProc)
        t.Change(dueTime, 0)
    End Sub

    Private Sub TimerProc(ByVal state As Object)
        ' The state object is the Timer object.
        Dim t As Timer = CType(state, Timer)
        t.Dispose()
        Console.WriteLine("The timer callback executes.")
    End Sub
End Class

Observações

Chame este construtor quando quiser usar o Timer próprio objeto como objeto de estado. Depois de criar o temporizador, use o Change método para definir o intervalo e o tempo de vencimento.

Este construtor especifica um tempo devido infinito antes do primeiro callback e um intervalo infinito entre callbacks, para evitar que o primeiro callback ocorra antes do Timer objeto ser atribuído ao objeto de estado.

O método especificado para callback deve ser reentrante, porque é chamado em ThreadPool threads. O método pode ser executado simultaneamente em dois threads do pool de threads se o intervalo do temporizador for inferior ao tempo necessário para executar o método, ou se todos os threads do pool de threads estiverem em uso e o método estiver em fila várias vezes.

public:
 Timer(System::Threading::TimerCallback ^ callback, System::Object ^ state, int dueTime, int period);

public Timer(System.Threading.TimerCallback callback, object state, int dueTime, int period);

new System.Threading.Timer : System.Threading.TimerCallback * obj * int * int -> System.Threading.Timer

Public Sub New (callback As TimerCallback, state As Object, dueTime As Integer, period As Integer)

Parâmetros

Exceções

Exemplos

O exemplo de código seguinte mostra como criar um TimerCallback delegado e inicializar uma nova instância da Timer classe.

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.

Imports System.Threading

Public Module Example
    Public Sub Main()
        ' Use an AutoResetEvent to signal the timeout threshold in the
        ' timer callback has been reached.
        Dim autoEvent As New AutoResetEvent(False)

        Dim statusChecker As 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." & vbCrLf, 
                          DateTime.Now)
        Dim stateTimer As New Timer(AddressOf statusChecker.CheckStatus, 
                                    autoEvent, 1000, 250)

        ' When autoEvent signals, change the period to every half second.
        autoEvent.WaitOne()
        stateTimer.Change(0, 500)
        Console.WriteLine(vbCrLf & "Changing period to .5 seconds." & vbCrLf)

        ' When autoEvent signals the second time, dispose of the timer.
        autoEvent.WaitOne()
        stateTimer.Dispose()
        Console.WriteLine(vbCrLf & "Destroying timer.")
    End Sub
End Module

Public Class StatusChecker
    Dim invokeCount, maxCount As Integer 

    Sub New(count As Integer)
        invokeCount  = 0
        maxCount = count
    End Sub

    ' The timer callback method.
    Sub CheckStatus(stateInfo As Object)
        Dim autoEvent As AutoResetEvent = DirectCast(stateInfo, AutoResetEvent)
        invokeCount += 1
        Console.WriteLine("{0:h:mm:ss.fff} Checking status {1,2}.", 
                          DateTime.Now, invokeCount)
        If invokeCount = maxCount Then
            ' Reset the counter and signal the waiting thread.
            invokeCount = 0
            autoEvent.Set()
        End If
    End Sub
End Class
' 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.

Observações

O delegado especificado pelo callback parâmetro é invocado uma vez após dueTime o decorrer e, a partir daí, cada vez que o period intervalo de tempo decorre.

Se dueTime for zero (0), callback é invocado imediatamente. Se dueTime for Timeout.Infinite, callback não é invocado; o temporizador está desativado, mas pode ser reativado chamando o Change método.

Como a classe Timer tem a mesma resolução do relógio do sistema, que é aproximadamente 15 milissegundos em sistemas Windows 7 e Windows 8, o delegado callback executa em intervalos definidos pela resolução do relógio do sistema se period for inferior à resolução do relógio do sistema. Se period for zero (0) ou Timeout.Infinite e dueTime não Timeout.Infinitefor , callback é invocado uma vez; o comportamento periódico do temporizador é desativado, mas pode ser reativado usando o Change método.

O método especificado para callback deve ser reentrante, porque é chamado em ThreadPool threads. O método pode ser executado simultaneamente em dois threads do pool de threads se o intervalo do temporizador for inferior ao tempo necessário para executar o método, ou se todos os threads do pool de threads estiverem em uso e o método estiver em fila várias vezes.

Ver também

• temporizadores

public:
 Timer(System::Threading::TimerCallback ^ callback, System::Object ^ state, long dueTime, long period);

public Timer(System.Threading.TimerCallback callback, object state, long dueTime, long period);

new System.Threading.Timer : System.Threading.TimerCallback * obj * int64 * int64 -> System.Threading.Timer

Public Sub New (callback As TimerCallback, state As Object, dueTime As Long, period As Long)

Parâmetros

Exceções

Observações

O delegado especificado pelo callback parâmetro é invocado uma vez após dueTime o decorrer e, a partir daí, cada vez que o period intervalo de tempo decorre.

Se dueTime for zero (0), callback é invocado imediatamente. Se dueTime for Timeout.Infinite, callback não é invocado; o temporizador está desativado, mas pode ser reativado chamando o Change método.

Como a classe Timer tem a mesma resolução do relógio do sistema, que é aproximadamente 15 milissegundos em sistemas Windows 7 e Windows 8, o delegado callback executa em intervalos definidos pela resolução do relógio do sistema se period for inferior à resolução do relógio do sistema.

Se period for zero (0) ou Timeout.Infinite e dueTime não Timeout.Infinitefor , callback é invocado uma vez; o comportamento periódico do temporizador é desativado, mas pode ser reativado usando o Change método.

O método especificado para callback deve ser reentrante, porque é chamado em ThreadPool threads. O método pode ser executado simultaneamente em dois threads do pool de threads se o intervalo do temporizador for inferior ao tempo necessário para executar o método, ou se todos os threads do pool de threads estiverem em uso e o método estiver em fila várias vezes.

Ver também

• temporizadores

public:
 Timer(System::Threading::TimerCallback ^ callback, System::Object ^ state, TimeSpan dueTime, TimeSpan period);

public Timer(System.Threading.TimerCallback callback, object state, TimeSpan dueTime, TimeSpan period);

new System.Threading.Timer : System.Threading.TimerCallback * obj * TimeSpan * TimeSpan -> System.Threading.Timer

Public Sub New (callback As TimerCallback, state As Object, dueTime As TimeSpan, period As TimeSpan)

Parâmetros

Exceções

Exemplos

O exemplo de código seguinte mostra como criar um TimerCallback delegado e inicializar uma nova instância da Timer classe.

using System;
using System.Threading;

class TimerExample
{
    static void Main()
    {
        AutoResetEvent autoEvent     = new AutoResetEvent(false);
        StatusChecker  statusChecker = new StatusChecker(10);

        // Create the delegate that invokes methods for the timer.
        TimerCallback timerDelegate = 
            new TimerCallback(statusChecker.CheckStatus);

        TimeSpan delayTime = new TimeSpan(0, 0, 1);
        TimeSpan intervalTime = new TimeSpan(0, 0, 0, 0, 250);

        // Create a timer that signals the delegate to invoke 
        // CheckStatus after one second, and every 1/4 second 
        // thereafter.
        Console.WriteLine("{0} Creating timer.\n", 
            DateTime.Now.ToString("h:mm:ss.fff"));
        Timer stateTimer = new Timer(
            timerDelegate, autoEvent, delayTime, intervalTime);

        // When autoEvent signals, change the period to every 
        // 1/2 second.
        autoEvent.WaitOne(5000, false);
        stateTimer.Change(new TimeSpan(0), 
            intervalTime + intervalTime);
        Console.WriteLine("\nChanging period.\n");

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

class StatusChecker
{
    int invokeCount, 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 Main.
            invokeCount  = 0;
            autoEvent.Set();
        }
    }
}

Imports System.Threading

Public Class TimerExample

    <MTAThread> _
    Shared Sub Main()
    
        Dim autoEvent As New AutoResetEvent(False)
        Dim statusChecker As New StatusChecker(10)

        ' Create the delegate that invokes methods for the timer.
        Dim timerDelegate As TimerCallback = _
            AddressOf statusChecker.CheckStatus

        Dim delayTime As New TimeSpan(0, 0, 1)
        Dim intervalTime As New TimeSpan(0, 0, 0, 0, 250)

        ' Create a timer that signals the delegate to invoke 
        ' CheckStatus after one second, and every 1/4 second 
        ' thereafter.
        Console.WriteLine("{0} Creating timer." & vbCrLf, _
            DateTime.Now.ToString("h:mm:ss.fff"))
        Dim stateTimer As Timer = New Timer( _
            timerDelegate, autoEvent, delayTime, intervalTime)

        ' When autoEvent signals, change the period to every 
        ' 1/2 second.
        autoEvent.WaitOne(5000, False)
        stateTimer.Change( _
            new TimeSpan(0), intervalTime.Add(intervalTime))
        Console.WriteLine(vbCrLf & "Changing period." & vbCrLf)

        ' When autoEvent signals the second time, dispose of 
        ' the timer.
        autoEvent.WaitOne(5000, False)
        stateTimer.Dispose()
        Console.WriteLine(vbCrLf & "Destroying timer.")
    
    End Sub
End Class

Public Class StatusChecker

    Dim invokeCount, maxCount As Integer 

    Sub New(count As Integer)
        invokeCount  = 0
        maxCount = count
    End Sub

    ' This method is called by the timer delegate.
    Sub CheckStatus(stateInfo As Object)
        Dim autoEvent As AutoResetEvent = _
            DirectCast(stateInfo, AutoResetEvent)
        invokeCount += 1
        Console.WriteLine("{0} Checking status {1,2}.", _
            DateTime.Now.ToString("h:mm:ss.fff"), _
            invokeCount.ToString())

        If invokeCount = maxCount Then
        
            ' Reset the counter and signal to stop the timer.
            invokeCount  = 0
            autoEvent.Set()
        End If
    End Sub

End Class

Observações

O delegado especificado pelo callback parâmetro é invocado uma vez após dueTime o decorrer e, a partir daí, cada vez que o period intervalo de tempo decorre.

Se dueTime for zero (0), callback é invocado imediatamente. Se dueTime for menos um (-1) milissegundos, callback não é invocado; o temporizador está desativado, mas pode ser reativado chamando o Change método.

Como a classe Timer tem a mesma resolução do relógio do sistema, que é aproximadamente 15 milissegundos em sistemas Windows 7 e Windows 8, o delegado callback executa em intervalos definidos pela resolução do relógio do sistema se period for inferior à resolução do relógio do sistema. Se period for zero (0) ou menos um (-1) milissegundos e dueTime for positivo, callback é invocado uma vez; o comportamento periódico do temporizador está desativado, mas pode ser reativado usando o Change método.

O método especificado para callback deve ser reentrante, porque é chamado em ThreadPool threads. O método pode ser executado simultaneamente em dois threads do pool de threads se o intervalo do temporizador for inferior ao tempo necessário para executar o método, ou se todos os threads do pool de threads estiverem em uso e o método estiver em fila várias vezes.

Ver também

• temporizadores

public:
 Timer(System::Threading::TimerCallback ^ callback, System::Object ^ state, System::UInt32 dueTime, System::UInt32 period);

[System.CLSCompliant(false)]
public Timer(System.Threading.TimerCallback callback, object state, uint dueTime, uint period);

[<System.CLSCompliant(false)>]
new System.Threading.Timer : System.Threading.TimerCallback * obj * uint32 * uint32 -> System.Threading.Timer

Public Sub New (callback As TimerCallback, state As Object, dueTime As UInteger, period As UInteger)

Parâmetros

Atributos

CLSCompliantAttribute

Exceções

Observações

O delegado especificado pelo callback parâmetro é invocado uma vez após dueTime o decorrer e, a partir daí, cada vez que o period intervalo de tempo decorre.

Se dueTime for zero (0), callback é invocado imediatamente. Se dueTime for Timeout.Infinite, callback não é invocado; o temporizador está desativado, mas pode ser reativado chamando o Change método.

Como a classe Timer tem a mesma resolução do relógio do sistema, que é aproximadamente 15 milissegundos em sistemas Windows 7 e Windows 8, o delegado callback executa em intervalos definidos pela resolução do relógio do sistema se period for inferior à resolução do relógio do sistema. Se period for zero (0) ou Timeout.Infinite e dueTime não Timeout.Infinitefor , callback é invocado uma vez; o comportamento periódico do temporizador é desativado, mas pode ser reativado usando o Change método.

O método especificado para callback deve ser reentrante, porque é chamado em ThreadPool threads. O método pode ser executado simultaneamente em dois threads do pool de threads se o intervalo do temporizador for inferior ao tempo necessário para executar o método, ou se todos os threads do pool de threads estiverem em uso e o método estiver em fila várias vezes.

Ver também

• temporizadores