Timer Classe

Referência

Definição

Namespace:: System.Threading

Assembly:: System.Threading.Timer.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Origem:: Timer.cs

Origem:: Timer.cs

Origem:: Timer.cs

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

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: Object
Timer

Herança: Object

MarshalByRefObject
Timer

Atributos: ComVisibleAttribute

Implementações: IDisposable IAsyncDisposable ITimer

Exemplos

O exemplo a seguir define uma classe StatusChecker que inclui um método CheckStatus cuja assinatura é a mesma do delegado TimerCallback. O argumento state do método CheckStatus é um objeto AutoResetEvent usado para sincronizar o thread do aplicativo e o thread do pool de threads que executa o delegado de retorno de chamada. A classe StatusChecker 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 CheckStatus a cada 250 milissegundos. Em seguida, o thread do aplicativo é bloqueado até que o objeto AutoResetEvent seja sinalizado. Quando o método de retorno de chamada CheckStatus é executado maxCount vezes, ele chama o método AutoResetEvent.Set para definir o estado do objeto AutoResetEvent como sinalizado. Na primeira vez que isso acontecer, o thread de aplicativo chama o método Change(Int32, Int32) para que o método de retorno de chamada agora seja executado a cada meio segundo. Ele bloqueia novamente até que o objeto AutoResetEvent seja sinalizado. Quando isso acontece, o temporizador é destruído chamando seu método Dispose 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 delegado TimerCallback para especificar o método que você deseja que o Timer execute. A assinatura do delegado TimerCallback é:

void TimerCallback(Object state)

void TimerCallback(Object state)

Sub TimerCallback(state As Object)

O delegado do 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 thread ThreadPool fornecido pelo sistema.

Ponta

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 multithreaded; ele não tem nenhuma interface do usuário e não está visível no 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 classe System.Timers.Timer, essa classe destina-se a ser usada como um componente baseado em servidor ou serviço em um ambiente multithread; ele não tem nenhuma interface do usuário e não está visível no runtime.
System.Windows.Forms.Timer, um componente do Windows Forms que aciona 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 à fila de Dispatcher. Esse temporizador é processado com uma prioridade especificada em um intervalo de tempo especificado.

Ao criar um temporizador, você pode especificar um período de tempo para aguardar antes da primeira execução do método (devido tempo) e um período de tempo para aguardar entre execuções subsequentes (período). A classe Timer 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 delegado TimerCallback 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 a hora e o período de conclusão ou desabilitar o temporizador usando o método Change.

Nota

Desde que você esteja usando um Timer, você deve manter uma referência a ela. 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.

Nota

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 método Dispose para liberar os recursos mantidos pelo temporizador. Observe que os retornos de chamada podem ocorrer depois que a sobrecarga do método Dispose() 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 método Dispose(WaitHandle) para aguardar até que todos os retornos de chamada tenham sido concluídos.

O método de retorno de chamada executado pelo temporizador deve ser reentrante, pois é chamado em threads ThreadPool. O retorno de chamada pode ser executado simultaneamente em dois threads de 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.

Nota

System.Threading.Timer é um temporizador simples e leve que usa métodos de retorno de chamada e é servido por threads de pool de threads. Não é recomendado para uso com o 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 o Windows Forms. Para a funcionalidade do temporizador baseado em servidor, você pode considerar o uso de System.Timers.Timer, 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 conclusão 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 inteiros 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 intervalos de tempo.

Propriedades

ActiveCount

Obtém o número de temporizadores que estão ativos no momento. Um temporizador ativo é registrado para funcionar 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 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 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 invocações de método para um temporizador, usando valores TimeSpan para medir intervalos de tempo.
Change(UInt32, UInt32)	Altera a hora de início e o intervalo entre invocações de método para um temporizador, usando inteiros sem sinal de 32 bits para medir 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 de Timer e sinaliza quando o temporizador foi 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 tempo de vida para essa 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 dessa instância. (Herdado de MarshalByRefObject)
MemberwiseClone()	Cria uma cópia superficial do Objectatual. (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 serão executadas.

Aplica-se a

Acesso thread-safe

Esse tipo é thread safe.

Partilhar via

Timer Classe

Definição

Exemplos

Comentários

Construtores

Propriedades

Métodos

Métodos de Extensão

Aplica-se a

Acesso thread-safe

Confira também

Recursos adicionais