Timer Classe

Definição

Namespace:

System.Timers

Assembly:

System.ComponentModel.TypeConverter.dll

Origem:

Timer.cs

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

public ref class Timer : System::ComponentModel::Component, System::ComponentModel::ISupportInitialize

public class Timer : System.ComponentModel.Component, System.ComponentModel.ISupportInitialize

type Timer = class
    inherit Component
    interface ISupportInitialize

Public Class Timer
Inherits Component
Implements ISupportInitialize

Herança

Object

MarshalByRefObject

Component

Timer

Implementações

ISupportInitialize

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

open System
open System.Timers

let onTimedEvent source (e: ElapsedEventArgs) =
    printfn $"""The Elapsed event was raised at {e.SignalTime.ToString "HH:mm:ss.fff"}"""

// Create a timer with a two second interval.
let aTimer = new Timer 2000
// Hook up the Elapsed event for the timer. 
aTimer.Elapsed.AddHandler onTimedEvent
aTimer.AutoReset <- true
aTimer.Enabled <- true

printfn "\nPress the Enter key to exit the application...\n"
printfn $"""The application started at {DateTime.Now.ToString "HH:mm:ss.fff"}"""
stdin.ReadLine() |> ignore
aTimer.Stop()
aTimer.Dispose()

printfn "Terminating the application..."

// 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...

Imports System.Timers

Public Module Example
    Private aTimer As System.Timers.Timer

    Public Sub Main()
        SetTimer()

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

      Console.WriteLine("Terminating the application...")
    End Sub

    Private Sub SetTimer()
        ' Create a timer with a two second interval.
        aTimer = New System.Timers.Timer(2000)
        ' Hook up the Elapsed event for the timer. 
        AddHandler aTimer.Elapsed, AddressOf OnTimedEvent
        aTimer.AutoReset = True
        aTimer.Enabled = True
    End Sub

    ' The event handler for the Timer.Elapsed event. 
    Private Sub OnTimedEvent(source As Object, e As ElapsedEventArgs)
        Console.WriteLine("The Elapsed event was raised at {0:HH:mm:ss.fff}",
                          e.SignalTime)
    End Sub 
End Module
' 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()

open System
open System.Threading.Tasks
open System.Timers

let handleTimer () =
    printfn "\nHandler not implemented..."
    raise (NotImplementedException()): Task

let timer = new Timer 1000
timer.Elapsed.AddHandler(fun sender e -> task { do! handleTimer () } |> ignore)
timer.Start()
printf "Press any key to exit... "
Console.ReadKey() |> ignore

// 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()

Imports System.Threading.Tasks
Imports System.Timers

Public Module Example
   Public Sub Main()
      Dim timer As New Timer(1000)  
      AddHandler timer.Elapsed, AddressOf Example.HandleTimer     
      'timer.Elapsed = Async ( sender, e ) => await HandleTimer()
      timer.Start()
      Console.Write("Press any key to exit... ")
      Console.ReadKey()
   End Sub

   Private Async Sub HandleTimer(sender As Object, e As EventArgs)
      Await Task.Run(Sub()
                        Console.WriteLine()
                        Console.WriteLine("Handler not implemented..." )
                        Throw New NotImplementedException()
                     End Sub)   
   End Sub
End Module
' 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._Lambda$__1()
'      at System.Threading.Tasks.Task.Execute()
'   --- End of stack trace from previous location where exception was thrown ---
'      at System.Runtime.CompilerServices.TaskAwaiter.ThrowForNonSuccess(Task task)
'      at System.Runtime.CompilerServices.TaskAwaiter.HandleNonSuccessAndDebuggerNotification(Task task)
'      at Example.VB$StateMachine_0_HandleTimer.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.

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

• AutoReset
• Interval
• Elapsed
• Timer()
• Timer