Timer Classe

Definição

Gera um evento após um intervalo definido, a opção de gerar eventos recorrentes.

public class Timer : System.ComponentModel.Component, System.ComponentModel.ISupportInitialize
Herança
Implementações

Exemplos

O exemplo a seguir cria uma instância de um System.Timers.Timer objeto que dispara seu Timer.Elapsed evento a cada dois segundos (2.000 milissegundos), configura um manipulador de eventos para o evento e inicia o temporizador. O manipulador de eventos exibe o valor da ElapsedEventArgs.SignalTime propriedade sempre que ela é gerada.

using System;
using System.Timers;

public class Example
{
   private static System.Timers.Timer aTimer;
   
   public static void Main()
   {
      SetTimer();

      Console.WriteLine("\nPress the Enter key to exit the application...\n");
      Console.WriteLine("The application started at {0:HH:mm:ss.fff}", DateTime.Now);
      Console.ReadLine();
      aTimer.Stop();
      aTimer.Dispose();
      
      Console.WriteLine("Terminating the application...");
   }

   private static void SetTimer()
   {
        // Create a timer with a two second interval.
        aTimer = new System.Timers.Timer(2000);
        // Hook up the Elapsed event for the timer. 
        aTimer.Elapsed += OnTimedEvent;
        aTimer.AutoReset = true;
        aTimer.Enabled = true;
    }

    private static void OnTimedEvent(Object source, ElapsedEventArgs e)
    {
        Console.WriteLine("The Elapsed event was raised at {0:HH:mm:ss.fff}",
                          e.SignalTime);
    }
}
// The example displays output like the following:
//       Press the Enter key to exit the application...
//
//       The application started at 09:40:29.068
//       The Elapsed event was raised at 09:40:31.084
//       The Elapsed event was raised at 09:40:33.100
//       The Elapsed event was raised at 09:40:35.100
//       The Elapsed event was raised at 09:40:37.116
//       The Elapsed event was raised at 09:40:39.116
//       The Elapsed event was raised at 09:40:41.117
//       The Elapsed event was raised at 09:40:43.132
//       The Elapsed event was raised at 09:40:45.133
//       The Elapsed event was raised at 09:40:47.148
//
//       Terminating the application...

Comentários

O Timer componente é um temporizador baseado em servidor que gera um Elapsed evento em seu aplicativo depois que o número de milissegundos na Interval propriedade tiver decorrido. Você pode configurar o Timer objeto para acionar o evento apenas uma vez ou repetidamente usando a AutoReset propriedade . Normalmente, um Timer objeto é declarado no nível da classe para que ele permaneça no escopo desde que seja necessário. Em seguida, você pode manipular seu Elapsed evento para fornecer processamento regular. Por exemplo, suponha que você tenha um servidor crítico que deve ser mantido em execução 24 horas por dia, 7 dias por semana. Você pode criar um serviço que usa um Timer objeto para marcar periodicamente o servidor e garantir que o sistema esteja em execução. Se o sistema não estiver respondendo, o serviço poderá tentar reiniciar o servidor ou notificar um administrador.

Importante

A Timer classe não está disponível para todas as implementações e versões do .NET, como .NET Standard 1.6 e versões inferiores. Nesses casos, você pode usar a System.Threading.Timer classe .

Esse tipo implementa a interface IDisposable. Quando você terminar de usar o tipo, deverá descartá-lo direta ou indiretamente. Para descartar o tipo diretamente, chame o método Dispose dele em um bloco try/catch. Para descartá-lo indiretamente, use um constructo de linguagem como using ( em C#) ou Using (em Visual Basic). Saiba mais na seção "Como usar um objeto que implementa IDisposable" no tópico da interface IDisposable.

A classe baseada em System.Timers.Timer servidor foi projetada para uso com threads de trabalho em um ambiente multithread. Os temporizadores de servidor podem se mover entre threads para lidar com o evento gerado Elapsed , resultando em mais precisão do que os temporizadores do Windows na geração do evento a tempo.

O System.Timers.Timer componente aciona o Elapsed evento, com base no valor (em milissegundos) da Interval propriedade . Você pode manipular esse evento para executar o processamento necessário. Por exemplo, suponha que você tenha um aplicativo de vendas online que publica continuamente pedidos de vendas em um banco de dados. O serviço que compila as instruções para envio opera em um lote de pedidos em vez de processar cada pedido individualmente. Você pode usar um Timer para iniciar o processamento em lote a cada 30 minutos.

Importante

A classe System.Timers.Timer tem a mesma resolução que o relógio do sistema. Isso significa que o Elapsed evento será acionado em um intervalo definido pela resolução do relógio do sistema se a Interval propriedade for menor que a resolução do relógio do sistema. Para obter mais informações, consulte a propriedade Interval.

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 AutoReset é definido falsecomo , um System.Timers.Timer objeto aciona o Elapsed evento apenas uma vez, depois que o primeiro Interval tiver decorrido. Para continuar gerando o Elapsed evento regularmente no intervalo definido pelo Interval, defina AutoReset como true, que é o valor padrão.

O Timer componente captura e suprime todas as exceções geradas por manipuladores de eventos para o Elapsed evento. Esse comportamento está sujeito a alterações em versões futuras do .NET Framework. Observe, no entanto, que isso não é verdadeiro para manipuladores de eventos que são executados de forma assíncrona e incluem o await operador (em C#) ou o Await operador (no Visual Basic). As exceções geradas nesses manipuladores de eventos são propagadas de volta para o thread de chamada, como ilustra o exemplo a seguir. Para obter mais informações sobre exceções geradas em métodos assíncronos, consulte Tratamento de exceções.

using System;
using System.Threading.Tasks;
using System.Timers;

class Example
{
   static void Main()
   {
      Timer timer = new Timer(1000);
      timer.Elapsed += async ( sender, e ) => await HandleTimer();
      timer.Start();
      Console.Write("Press any key to exit... ");
      Console.ReadKey();
   }

   private static Task HandleTimer()
   {
     Console.WriteLine("\nHandler not implemented..." );
     throw new NotImplementedException();
   }
}
// The example displays output like the following:
//   Press any key to exit...
//   Handler not implemented...
//   
//   Unhandled Exception: System.NotImplementedException: The method or operation is not implemented.
//      at Example.HandleTimer()
//      at Example.<<Main>b__0>d__2.MoveNext()
//   --- End of stack trace from previous location where exception was thrown ---
//      at System.Runtime.CompilerServices.AsyncMethodBuilderCore.<>c__DisplayClass2.<ThrowAsync>b__5(Object state)
//      at System.Threading.ExecutionContext.RunInternal(ExecutionContext executionContext, ContextCallback callback, Object state, Boolean preserveSyncCtx)
//      at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state, Boolean preserveSyncCtx)
//      at System.Threading.QueueUserWorkItemCallback.System.Threading.IThreadPoolWorkItem.ExecuteWorkItem()
//      at System.Threading.ThreadPoolWorkQueue.Dispatch()

Se a SynchronizingObject propriedade for null, o Elapsed evento será gerado em um ThreadPool thread. Se o processamento do Elapsed evento durar mais do que Interval, o evento poderá ser gerado novamente em outro ThreadPool thread. Nessa situação, o manipulador de eventos deve ser reentrante.

Observação

O método de manipulação de eventos pode ser executado em um thread ao mesmo tempo em que outro thread chama o Stop método ou define a Enabled propriedade como false. Isso pode fazer com que o Elapsed evento seja gerado depois que o temporizador for interrompido. O código de exemplo para o Stop método mostra uma maneira de evitar essa condição de corrida.

Mesmo se SynchronizingObject não nullfor , Elapsed os eventos poderão ocorrer depois que o Dispose método ou Stop tiver sido chamado ou depois que a Enabled propriedade tiver sido definida falsecomo , porque o sinal para acionar o Elapsed evento sempre será enfileirado para execução em um thread do pool de threads. Uma maneira de resolve essa condição de corrida é definir um sinalizador que informa ao manipulador de eventos para que o Elapsed evento ignore os eventos subsequentes.

Se você usar a System.Timers.Timer classe com um elemento de interface do usuário, como um formulário ou controle, sem colocar o temporizador nesse elemento de interface do usuário, atribua o formulário ou controle que contém o Timer à SynchronizingObject propriedade para que o evento seja realizado em marshaling para o thread da interface do usuário.

Para obter uma lista de valores de propriedade padrão para uma instância do Timer, consulte o Timer construtor .

Dica

O .NET inclui quatro classes chamadas Timer, cada uma das quais oferece funcionalidades diferentes:

  • System.Timers.Timer (este tópico): dispara um evento 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: 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 do Windows Forms que dispara um evento em intervalos regulares. O componente não tem nenhuma interface do usuário e é projetado para ser usado em um ambiente single-threaded.
  • 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.

Construtores

Timer()

Inicializa uma nova instância da classe Timer e define todas as propriedades para seus valores iniciais.

Timer(Double)

Inicializa uma nova instância da classe Timer e define a propriedade Interval como o número especificado de milissegundos.

Timer(TimeSpan)

Inicializa uma nova instância da Timer classe , definindo a Interval propriedade como o período especificado.

Propriedades

AutoReset

Obtém ou define um valor booliano que indica se Timer deve acionar o evento Elapsed apenas uma vez (false) ou repetidamente (true).

CanRaiseEvents

Obtém um valor que indica se o componente pode acionar um evento.

(Herdado de Component)
Container

Obtém o IContainer que contém o Component.

(Herdado de Component)
DesignMode

Obtém um valor que indica se o Component está no modo de design no momento.

(Herdado de Component)
Enabled

Obtém ou define um valor que indica se o Timer deve acionar o evento Elapsed.

Events

Obtém a lista de manipuladores de eventos que estão anexados a este Component.

(Herdado de Component)
Interval

Obtém ou define o intervalo, expressado em milissegundos, no qual gerar o evento Elapsed.

Site

Obtém ou define o site que associa o Timer ao respectivo contêiner no modo de design.

SynchronizingObject

Obtém ou define o objeto usado para realizar marshaling das chamadas do manipulador de eventos emitidas ao término de um intervalo.

Métodos

BeginInit()

Começa a inicialização do tempo de execução de um Timer que é usado em um formulário ou por outro componente.

Close()

Libera os recursos usados pelo Timer.

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 pelo Component.

(Herdado de Component)
Dispose(Boolean)

Libera todos os recursos usados pelo Timer atual.

EndInit()

Termina a inicialização do tempo de execução de um Timer que é usado em um formulário ou por outro componente.

Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.

(Herdado de Object)
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)
GetService(Type)

Retorna um objeto que representa um serviço fornecido pelo Component ou pelo seu Container.

(Herdado de Component)
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)
Start()

Começa a acionar o evento Elapsed definindo Enabled como true.

Stop()

Para de acionar o evento Elapsed definindo Enabled como false.

ToString()

Retorna um String que contém o nome do Component, se houver. Esse método não deve ser substituído.

(Herdado de Component)

Eventos

Disposed

Ocorre quando o componente é disposto por uma chamada ao método Dispose().

(Herdado de Component)
Elapsed

Ocorre quando o intervalo termina.

Aplica-se a

Produto Versões
.NET Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 2.0, 2.1

Acesso thread-safe

Todos os membros públicos static desse tipo são thread-safe. Não há garantia de que qualquer membro de instância seja seguro para threads.

Confira também