Timer Classe

Definição

Namespace:

System.Timers

Assembly:

System.ComponentModel.TypeConverter.dll

Assembly:

netstandard.dll

Assembly:

System.dll

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 instalita um objeto que dispara seu evento a cada dois segundos System.Timers.Timer (2.000 milissegundos), configura um manipulador de eventos para o evento e inicia o Timer.Elapsed temporizador. O manipulador de eventos exibe o valor da ElapsedEventArgs.SignalTime propriedade sempre que é gerado.

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

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 componente é um temporizador baseado em servidor que gera um evento em seu aplicativo após o número de milissegundos na propriedade Timer Elapsed ter Interval decorrido. Você pode configurar o Timer objeto para auar o evento apenas uma vez ou repetidamente usando a AutoReset propriedade . Normalmente, um objeto é declarado no nível de classe para que ele Timer permaneça no escopo, desde que seja necessário. Em seguida, você pode manipular Elapsed seu 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 objeto para verificar periodicamente o servidor e garantir que o Timer sistema está em funcionamento. Se o sistema não estiver respondendo, o serviço poderá tentar reiniciar o servidor ou notificar um administrador.

Importante

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

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 System.Timers.Timer em 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, resultando em mais precisão do que Windows temporizadores na ação do evento Elapsed no horário.

O System.Timers.Timer componente gera o evento com base no valor Elapsed (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 poste 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 lotes 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 evento será a incêndio em um intervalo definido pela resolução do relógio do sistema se a propriedade for menor que Elapsed a resolução do relógio do Interval sistema. Para obter mais informações, consulte a propriedade Interval.

Quando AutoReset é definido como , um objeto gera o evento apenas uma false System.Timers.Timer Elapsed vez, depois que o primeiro tiver Interval decorrido. Para continuar a aumentar o evento regularmente no intervalo definido pelo , de definido como Elapsed , que é o valor Interval AutoReset true padrão.

O Timer componente captura e suprime todas as exceções lançadas pelos 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 operador (em C#) ou o operador await Await (em Visual Basic). Exceções lançadas 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 lançadas 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()

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 SynchronizingObject a propriedade for null , o evento será gerado em um Elapsed ThreadPool thread. Se o processamento do Elapsed evento durar mais do que , o evento poderá ser gerado novamente em outro Interval 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 método ou Stop define a propriedade como Enabled false . Isso pode fazer com que Elapsed o evento seja gerado depois que o temporizador é interrompido. O código de exemplo para Stop o método mostra uma maneira de evitar essa condição de corrida.

Mesmo se não for , os eventos poderão ocorrer depois que o método ou tiver sido chamado ou depois que a propriedade tiver sido definida como , porque o sinal para aumentá-lo sempre será en enrauado para execução em um thread de pool de SynchronizingObject null Elapsed Dispose Stop Enabled false Elapsed threads. Uma maneira de resolver essa condição de corrida é definir um sinalizador que diz ao manipulador de eventos para o Elapsed evento ignorar eventos subsequentes.

Se você usar a 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 à propriedade , para que o evento seja realizado marshaled para o thread da interface do System.Timers.Timer Timer SynchronizingObject usuário.

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

Dica

Esteja ciente de que 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 nenhuma 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 é instautado e não pode ser alterado. Assim como a 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 System.Timers.Timer 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(.NET Framework somente): um componente ASP.NET que executa postbacks de página da Web assíncronos ou síncronos 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.

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 static membros públicos 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