Timer Classe

Definição

Fornece um mecanismo para executar um método em um thread do pool de threads em intervalos especificados. Essa classe não pode ser herdada.

public ref class Timer sealed : IDisposable
public ref class Timer sealed : MarshalByRefObject, IAsyncDisposable, IDisposable
public ref class Timer sealed : MarshalByRefObject, System::Threading::ITimer
public ref class Timer sealed : MarshalByRefObject, IDisposable
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class Timer : IDisposable
public sealed class Timer : MarshalByRefObject, IAsyncDisposable, IDisposable
public sealed class Timer : MarshalByRefObject, System.Threading.ITimer
public sealed class Timer : MarshalByRefObject, IDisposable
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class Timer : MarshalByRefObject, IDisposable
[<System.Runtime.InteropServices.ComVisible(true)>]
type Timer = class
    interface IDisposable
type Timer = class
    inherit MarshalByRefObject
    interface IAsyncDisposable
    interface IDisposable
type Timer = class
    inherit MarshalByRefObject
    interface IAsyncDisposable
    interface IDisposable
    interface ITimer
type Timer = class
    inherit MarshalByRefObject
    interface IDisposable
[<System.Runtime.InteropServices.ComVisible(true)>]
type Timer = class
    inherit MarshalByRefObject
    interface IDisposable
Public NotInheritable Class Timer
Implements IDisposable
Public NotInheritable Class Timer
Inherits MarshalByRefObject
Implements IAsyncDisposable, IDisposable
Public NotInheritable Class Timer
Inherits MarshalByRefObject
Implements ITimer
Public NotInheritable Class Timer
Inherits MarshalByRefObject
Implements IDisposable
Herança
Timer
Herança
Atributos
Implementações

Exemplos

O exemplo a seguir define uma StatusChecker classe que inclui um CheckStatus método cuja assinatura é a mesma que o TimerCallback delegado. O state argumento do CheckStatus método é um AutoResetEvent objeto usado para sincronizar o thread do aplicativo e o thread do pool de threads que executa o delegado de retorno de chamada. A StatusChecker classe também inclui duas variáveis de estado:

invokeCount Indica o número de vezes que o método de retorno de chamada foi invocado.

maxCount Determina o número máximo de vezes que o método de retorno de chamada deve ser invocado.

O thread do aplicativo cria o temporizador, que aguarda um segundo e, em seguida, executa o método de retorno de chamada a CheckStatus cada 250 milissegundos. Em seguida, o thread do aplicativo é bloqueado até que o AutoResetEvent objeto seja sinalizado. Quando o CheckStatus método de retorno de chamada é executado maxCount vezes, ele chama o AutoResetEvent.Set método para definir o estado do AutoResetEvent objeto como sinalizado. Na primeira vez que isso acontece, o thread de aplicativo chama o Change(Int32, Int32) método para que o método de retorno de chamada agora seja executado a cada meio segundo. Ele é bloqueado mais uma vez até que o AutoResetEvent objeto seja sinalizado. Quando isso acontece, o temporizador é destruído chamando seu Dispose método e o aplicativo é encerrado.

using namespace System;
using namespace System::Threading;

ref class StatusChecker
{
private:
    int invokeCount, maxCount;

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

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

        if (invokeCount == maxCount) {
            // Reset the counter and signal the waiting thread.
            invokeCount  = 0;
            autoEvent->Set();
        }
    }
};

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

        StatusChecker^ statusChecker = gcnew StatusChecker(10);

        // Create a delegate that invokes methods for the timer.
        TimerCallback^ tcb =
           gcnew TimerCallback(statusChecker, &StatusChecker::CheckStatus);

        // 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);
        Timer^ stateTimer = gcnew Timer(tcb, autoEvent, 1000, 250);

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

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

int main()
{
    TimerExample::Main();
}
// 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.
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.

Comentários

Use um TimerCallback delegado para especificar o método que você deseja que o Timer execute. A assinatura do TimerCallback delegado é:

void TimerCallback(Object state)
void TimerCallback(Object state)
Sub TimerCallback(state As Object)

O delegado de temporizador é especificado quando o temporizador é construído e não pode ser alterado. O método não é executado no thread que criou o temporizador; ele é executado em um ThreadPool thread fornecido pelo sistema.

Dica

O .NET inclui várias classes de temporizador, cada uma das quais oferece funcionalidades diferentes:

  • System.Timers.Timer, que dispara um evento e executa o código em um ou mais coletores de eventos em intervalos regulares. A classe destina-se a ser usada como um componente de serviço ou baseado em servidor em um ambiente multithread; ele não tem interface do usuário e não está visível em runtime.
  • System.Threading.Timer, que executa um único método de retorno de chamada em um thread do pool de threads em intervalos regulares. O método de retorno de chamada é definido quando o temporizador é instanciado e não pode ser alterado. Assim como a System.Timers.Timer classe , essa classe destina-se a ser usada como um componente de serviço ou baseado em servidor em um ambiente multithread; ela não tem interface do usuário e não está visível em runtime.
  • System.Windows.Forms.Timer, um componente Windows Forms que dispara um evento e executa o código em um ou mais coletores de eventos em intervalos regulares. O componente não tem interface do usuário e foi projetado para uso em um ambiente de thread único; ele é executado no thread da interface do usuário.
  • System.Web.UI.Timer(somente .NET Framework), um componente ASP.NET que executa postbacks de página da Web assíncrona ou síncrona em um intervalo regular.
  • System.Windows.Threading.DispatcherTimer, um temporizador integrado à Dispatcher fila. Esse temporizador é processado com uma prioridade especificada em um intervalo de tempo especificado.

Ao criar um temporizador, você pode especificar uma quantidade de tempo para aguardar antes da primeira execução do método (devido tempo) e um período de tempo de espera entre as execuções subsequentes (período). A Timer classe tem a mesma resolução que o relógio do sistema. Isso significa que, se o período for menor que a resolução do relógio do sistema, o TimerCallback delegado será executado em intervalos definidos pela resolução do relógio do sistema, que é de aproximadamente 15 milissegundos nos sistemas Windows 7 e Windows 8. Você pode alterar o tempo e o período devidos ou desabilitar o temporizador usando o Change método .

Observação

Contanto que você esteja usando um Timer, você deve manter uma referência a ele. Assim como acontece com qualquer objeto gerenciado, um Timer está sujeito à coleta de lixo quando não há referências a ele. O fato de um Timer ainda estar ativo não o impede de ser coletado.

Observação

O relógio do sistema usado é o mesmo relógio usado por GetTickCount, que não é afetado por alterações feitas com timeBeginPeriod e timeEndPeriod.

Quando um temporizador não for mais necessário, use o Dispose método para liberar os recursos mantidos pelo temporizador. Observe que os retornos de chamada podem ocorrer depois que a sobrecarga do Dispose() método tiver sido chamada, porque o temporizador enfileira retornos de chamada para execução por threads do pool de threads. Você pode usar a sobrecarga do Dispose(WaitHandle) método para aguardar até que todos os retornos de chamada sejam concluídos.

O método de retorno de chamada executado pelo temporizador deve ser reentrante, pois é chamado em ThreadPool threads. O retorno de chamada poderá ser executado simultaneamente em dois threads do pool de threads se o intervalo de temporizador for menor do que o tempo necessário para executar o retorno de chamada ou se todos os threads do pool de threads estiverem em uso e o retorno de chamada for enfileirado várias vezes.

Observação

System.Threading.Timer é um temporizador simples e leve que usa métodos de retorno de chamada e é servido por threads do pool de threads. Não é recomendável usar com Windows Forms, pois seus retornos de chamada não ocorrem no thread da interface do usuário. System.Windows.Forms.Timeré uma opção melhor para uso com Windows Forms. Para a funcionalidade de temporizador baseada em servidor, você pode considerar o uso System.Timers.Timerde , que gera eventos e tem recursos adicionais.

Construtores

Timer(TimerCallback)

Inicializa uma nova instância da classe Timer com um período infinito e um tempo de validade infinito usando o objeto Timer recém-criado como o objeto de estado.

Timer(TimerCallback, Object, Int32, Int32)

Inicializa uma nova instância da classe Timer, usando um inteiro com sinal de 32 bits para especificar o intervalo de tempo.

Timer(TimerCallback, Object, Int64, Int64)

Inicializa uma nova instância da classe Timer, usando um inteiro com sinal de 64 bits para medir intervalos de tempo.

Timer(TimerCallback, Object, TimeSpan, TimeSpan)

Inicializa uma nova instância da classe Timer, usando valores TimeSpan para medir intervalos de tempo.

Timer(TimerCallback, Object, UInt32, UInt32)

Inicializa uma nova instância da classe Timer, usando inteiros sem sinal de 32 bits para medir os intervalos de tempo.

Propriedades

ActiveCount

Obtém o número de temporizadores ativos no momento. Um temporizador ativo está registrado para efetuar tique em algum momento no futuro e ainda não foi cancelado.

Métodos

Change(Int32, Int32)

Altera a hora de início e o intervalo entre as invocações de método para um temporizador, usando inteiros com sinal de 32 bits para medir intervalos de tempo.

Change(Int64, Int64)

Altera a hora de início e o intervalo entre as invocações de método para um temporizador, usando inteiros com sinal de 64 bits para medir intervalos de tempo.

Change(TimeSpan, TimeSpan)

Altera a hora de início e o intervalo entre as invocações de método para um temporizador, usando valores de TimeSpan para medir os intervalos de tempo.

Change(UInt32, UInt32)

Altera a hora de início e o intervalo entre as invocações de método de um temporizador, usando inteiros sem sinal de 32 bits para medir os intervalos de tempo.

CreateObjRef(Type)

Cria um objeto que contém todas as informações relevantes necessárias para gerar um proxy usado para se comunicar com um objeto remoto.

(Herdado de MarshalByRefObject)
Dispose()

Libera todos os recursos usados pela instância atual do Timer.

Dispose(WaitHandle)

Libera todos os recursos usados pela instância atual do Timer e indica quando o temporizador for descartado.

DisposeAsync()

Libera todos os recursos usados pela instância atual do Timer.

Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.

(Herdado de Object)
Finalize()

Permite que um objeto tente liberar recursos e executar outras operações de limpeza antes de ser recuperado pela coleta de lixo.

GetHashCode()

Serve como a função de hash padrão.

(Herdado de Object)
GetLifetimeService()
Obsoleto.

Recupera o objeto de serviço de tempo de vida atual que controla a política de ciclo de vida para esta instância.

(Herdado de MarshalByRefObject)
GetType()

Obtém o Type da instância atual.

(Herdado de Object)
InitializeLifetimeService()
Obsoleto.

Obtém um objeto de serviço de tempo de vida para controlar a política de tempo de vida para essa instância.

(Herdado de MarshalByRefObject)
MemberwiseClone()

Cria uma cópia superficial do Object atual.

(Herdado de Object)
MemberwiseClone(Boolean)

Cria uma cópia superficial do objeto MarshalByRefObject atual.

(Herdado de MarshalByRefObject)
ToString()

Retorna uma cadeia de caracteres que representa o objeto atual.

(Herdado de Object)

Métodos de Extensão

ConfigureAwait(IAsyncDisposable, Boolean)

Configura como as esperas nas tarefas retornadas de um descartável assíncrono são realizadas.

Aplica-se a

Acesso thread-safe

Este tipo é thread-safe.

Confira também