Timer Timer Timer Timer Class

Definição

Fornece um mecanismo para executar um método em um thread do pool de threads em intervalos especificados.Provides a mechanism for executing a method on a thread pool thread at specified intervals. Essa classe não pode ser herdada.This class cannot be inherited.

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

Exemplos

O exemplo a seguir define uma StatusChecker classe inclui um CheckStatus método cuja assinatura é o mesmo como o TimerCallback delegar.The following example defines a StatusChecker class that includes a CheckStatus method whose signature is the same as the TimerCallback delegate. O state argumento do CheckStatus método é um AutoResetEvent objeto que é usado para sincronizar o thread do aplicativo e o pool de threads que executa o delegado de retorno de chamada.The state argument of the CheckStatus method is an AutoResetEvent object that is used to synchronize the application thread and the thread pool thread that executes the callback delegate. O StatusChecker classe também inclui duas variáveis de estado:The StatusChecker class also includes two state variables:

invokeCount
Indica o número de vezes que o método de retorno de chamada foi invocado.Indicates the number of times the callback method has been invoked.

maxCount
Determina o número máximo de vezes que o método de retorno de chamada deve ser invocado.Determines the maximum number of times the callback method should be invoked.

O thread do aplicativo cria o timer, que aguarda um segundo e, em seguida, executa o CheckStatus método de retorno de chamada cada 250 milissegundos.The application thread creates the timer, which waits one second and then executes the CheckStatus callback method every 250 milliseconds. Em seguida, bloqueia o thread do aplicativo até que o AutoResetEvent objeto é sinalizado.The application thread then blocks until the AutoResetEvent object is signaled. 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 a ser sinalizado.When the CheckStatus callback method executes maxCount times, it calls the AutoResetEvent.Set method to set the state of the AutoResetEvent object to signaled. Na primeira vez isso acontece, o thread do aplicativo chama o Change(Int32, Int32) método para que o método de retorno de chamada agora é executado a cada meio segundo.The first time this happens, the application thread calls the Change(Int32, Int32) method so that the callback method now executes every half second. Mais uma vez, ele bloqueia até que o AutoResetEvent objeto é sinalizado.It once again blocks until the AutoResetEvent object is signaled. Quando isso acontece, o temporizador for destruído, chamando seu Dispose método e o aplicativo é encerrado.When this happens, the timer is destroyed by calling its Dispose method, and the application terminates.

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 uma TimerCallback delegado para especificar o método que você deseja que o Timer para executar.Use a TimerCallback delegate to specify the method you want the Timer to execute. A assinatura do TimerCallback delegado é:The signature of the TimerCallback delegate is:

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

O delegado de timer é especificado quando o temporizador é construído e não pode ser alterado.The timer delegate is specified when the timer is constructed, and cannot be changed. O método não é executado no thread que criou o timer; ele é executado em um ThreadPool thread fornecido pelo sistema.The method does not execute on the thread that created the timer; it executes on a ThreadPool thread supplied by the system.

Dica

O .NET inclui quatro classes chamadas Timer, cada do que oferece uma funcionalidade diferente:.NET includes four classes named Timer, each of which offers different functionality:

  • System.Timers.Timer, que dispara um evento e executa o código em um ou mais eventos coletores em intervalos regulares.System.Timers.Timer, which fires an event and executes the code in one or more event sinks at regular intervals. A classe é destinada para uso como um servidor baseado em ou componente de serviço em um ambiente multithreaded; ele não tem nenhuma interface de usuário e não estiver visível no tempo de execução.The class is intended for use as a server-based or service component in a multithreaded environment; it has no user interface and is not visible at runtime.
  • System.Threading.Timer, que executa um método de retorno de chamada único em um pool de threads em intervalos regulares.System.Threading.Timer, which executes a single callback method on a thread pool thread at regular intervals. O método de retorno de chamada é definido quando o temporizador é instanciado e não pode ser alterado.The callback method is defined when the timer is instantiated and cannot be changed. Como o System.Timers.Timer classe, essa classe é destinada para uso como um componente baseado em servidor ou de serviço em um ambiente multithreaded; ele não tem nenhuma interface de usuário e não estiver visível no tempo de execução.Like the System.Timers.Timer class, this class is intended for use as a server-based or service component in a multithreaded environment; it has no user interface and is not visible at runtime.
  • System.Windows.Forms.Timer (.NET framework só), um componente de Windows Forms que dispara um evento e executa o código em um ou mais Coletores de eventos em intervalos regulares.System.Windows.Forms.Timer (.NET Framework only), a Windows Forms component that fires an event and executes the code in one or more event sinks at regular intervals. O componente não tem nenhuma interface de usuário e é projetado para uso em um ambiente single-threaded; ele executa no thread da interface do usuário.The component has no user interface and is designed for use in a single-threaded environment; it executes on the UI thread.
  • System.Web.UI.Timer (.NET framework só), um componente do ASP.NET que executa postbacks de página da web assíncrona ou síncrona em intervalos regulares.System.Web.UI.Timer (.NET Framework only), an ASP.NET component that performs asynchronous or synchronous web page postbacks at a regular interval.

Quando você cria um temporizador, você pode especificar uma quantidade de tempo de espera antes da primeira execução do método (hora de vencimento,) e um valor de tempo de espera entre as execuções subsequentes (período).When you create a timer, you can specify an amount of time to wait before the first execution of the method (due time), and an amount of time to wait between subsequent executions (period). O Timer classe tem a mesma resolução do relógio do sistema.The Timer class has the same resolution as the system clock. 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 em sistemas Windows 7 e Windows 8.This means that if the period is less than the resolution of the system clock, the TimerCallback delegate will execute at intervals defined by the resolution of the system clock, which is approximately 15 milliseconds on Windows 7 and Windows 8 systems. Você pode alterar o devido tempo e período ou desabilitar o temporizador, usando o Change método.You can change the due time and period, or disable the timer, by using the Change method.

Observação

Enquanto você estiver usando um Timer, você deve manter uma referência a ele.As long as you are using a Timer, you must keep a reference to it. Assim como acontece com qualquer objeto gerenciado, um Timer está sujeita à coleta de lixo quando não houver nenhuma referência a ele.As with any managed object, a Timer is subject to garbage collection when there are no references to it. O fato de que um Timer é o Active Directory ainda não impede que ele seja coletado.The fact that a Timer is still active does not prevent it from being collected.

Quando um temporizador não for mais necessário, use o Dispose método para liberar os recursos mantidos pelo temporizador.When a timer is no longer needed, use the Dispose method to free the resources held by the timer. Observe que os retornos de chamada podem ocorrer após o Dispose() sobrecarga de método foi chamada, porque o temporizador enfileira retornos de chamada para execução por threads do pool.Note that callbacks can occur after the Dispose() method overload has been called, because the timer queues callbacks for execution by thread pool threads. Você pode usar o Dispose(WaitHandle) sobrecarga de método para aguardar até que todos os retornos de chamada sejam concluídas.You can use the Dispose(WaitHandle) method overload to wait until all callbacks have completed.

O método de retorno de chamada executado pelo temporizador deve ser reentrante, porque ele é chamado no ThreadPool threads.The callback method executed by the timer should be reentrant, because it is called on ThreadPool threads. O retorno de chamada pode ser executado simultaneamente em dois threads de pool se o intervalo do temporizador for menor que o tempo necessário para executar o retorno de chamada, ou se todos os threads do pool estão em uso e o retorno de chamada é colocada na fila várias vezes.The callback can be executed simultaneously on two thread pool threads if the timer interval is less than the time required to execute the callback, or if all thread pool threads are in use and the callback is queued multiple times.

Observação

System.Threading.Timer é um temporizador leve e simple que usa métodos de retorno de chamada e é fornecido por threads do pool.System.Threading.Timer is a simple, lightweight timer that uses callback methods and is served by thread pool threads. Não é recomendável para uso com o Windows Forms, porque seus retornos de chamada não ocorrem no thread da interface do usuário.It is not recommended for use with Windows Forms, because its callbacks do not occur on the user interface thread. System.Windows.Forms.Timer é uma opção melhor para uso com o Windows Forms.System.Windows.Forms.Timer is a better choice for use with Windows Forms. Para a funcionalidade de temporizador com base em servidor, você pode considerar usar System.Timers.Timer, que gera eventos e tem recursos adicionais.For server-based timer functionality, you might consider using System.Timers.Timer, which raises events and has additional features.

Construtores

Timer(TimerCallback) Timer(TimerCallback) Timer(TimerCallback) 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.Initializes a new instance of the Timer class with an infinite period and an infinite due time, using the newly created Timer object as the state object.

Timer(TimerCallback, Object, Int32, Int32) Timer(TimerCallback, Object, Int32, Int32) Timer(TimerCallback, Object, Int32, Int32) 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.Initializes a new instance of the Timer class, using a 32-bit signed integer to specify the time interval.

Timer(TimerCallback, Object, Int64, Int64) Timer(TimerCallback, Object, Int64, Int64) Timer(TimerCallback, Object, Int64, Int64) 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.Initializes a new instance of the Timer class, using 64-bit signed integers to measure time intervals.

Timer(TimerCallback, Object, TimeSpan, TimeSpan) Timer(TimerCallback, Object, TimeSpan, TimeSpan) Timer(TimerCallback, Object, TimeSpan, TimeSpan) Timer(TimerCallback, Object, TimeSpan, TimeSpan)

Inicializa uma nova instância da classe Timer, usando valores TimeSpan para medir intervalos de tempo.Initializes a new instance of the Timer class, using TimeSpan values to measure time intervals.

Timer(TimerCallback, Object, UInt32, UInt32) Timer(TimerCallback, Object, UInt32, UInt32) Timer(TimerCallback, Object, UInt32, UInt32) 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.Initializes a new instance of the Timer class, using 32-bit unsigned integers to measure time intervals.

Métodos

Change(Int32, Int32) Change(Int32, Int32) Change(Int32, Int32) 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.Changes the start time and the interval between method invocations for a timer, using 32-bit signed integers to measure time intervals.

Change(Int64, Int64) Change(Int64, Int64) Change(Int64, Int64) 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.Changes the start time and the interval between method invocations for a timer, using 64-bit signed integers to measure time intervals.

Change(TimeSpan, TimeSpan) Change(TimeSpan, TimeSpan) Change(TimeSpan, TimeSpan) 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.Changes the start time and the interval between method invocations for a timer, using TimeSpan values to measure time intervals.

Change(UInt32, UInt32) Change(UInt32, UInt32) Change(UInt32, UInt32) 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.Changes the start time and the interval between method invocations for a timer, using 32-bit unsigned integers to measure time intervals.

CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type) 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.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Inherited from MarshalByRefObject)
Dispose() Dispose() Dispose() Dispose()

Libera todos os recursos usados pela instância atual do Timer.Releases all resources used by the current instance of Timer.

Dispose(WaitHandle) Dispose(WaitHandle) Dispose(WaitHandle) Dispose(WaitHandle)

Libera todos os recursos usados pela instância atual do Timer e indica quando o temporizador for descartado.Releases all resources used by the current instance of Timer and signals when the timer has been disposed of.

DisposeAsync() DisposeAsync() DisposeAsync() DisposeAsync()
Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.Determines whether the specified object is equal to the current object.

(Inherited from Object)
Finalize() Finalize() Finalize() Finalize()

Permite que um objeto tente liberar recursos e executar outras operações de limpeza antes de ser recuperado pela coleta de lixo.Allows an object to try to free resources and perform other cleanup operations before it is reclaimed by garbage collection.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Serve como a função de hash padrão.Serves as the default hash function.

(Inherited from Object)
GetLifetimeService() GetLifetimeService() GetLifetimeService() GetLifetimeService()

Recupera o objeto de serviço de tempo de vida atual que controla a política de ciclo de vida para esta instância.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Inherited from MarshalByRefObject)
GetType() GetType() GetType() GetType()

Obtém o Type da instância atual.Gets the Type of the current instance.

(Inherited from Object)
InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService()

Obtém um objeto de serviço de tempo de vida para controlar a política de tempo de vida para essa instância.Obtains a lifetime service object to control the lifetime policy for this instance.

(Inherited from MarshalByRefObject)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

(Inherited from Object)
MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean)

Cria uma cópia superficial do objeto MarshalByRefObject atual.Creates a shallow copy of the current MarshalByRefObject object.

(Inherited from MarshalByRefObject)
ToString() ToString() ToString() ToString()

Retorna uma cadeia de caracteres que representa o objeto atual.Returns a string that represents the current object.

(Inherited from Object)

Aplica-se a

Acesso thread-safe

Este tipo é thread-safe.This type is thread safe.

Veja também