Timer Classe

Definição

Gera um evento após um intervalo definido, a opção de gerar eventos recorrentes.Generates an event after a set interval, with an option to generate recurring events.

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
Implementações

Exemplos

O exemplo a seguir instancia 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.The following example instantiates a System.Timers.Timer object that fires its Timer.Elapsed event every two seconds (2,000 milliseconds), sets up an event handler for the event, and starts the timer. O manipulador de eventos exibe o valor da ElapsedEventArgs.SignalTime Propriedade cada vez que é gerado.The event handler displays the value of the ElapsedEventArgs.SignalTime property each time it is raised.

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 Timer componente é um temporizador baseado em servidor que gera Elapsed um evento em seu aplicativo após o número Interval de milissegundos na propriedade ter decorrido.The Timer component is a server-based timer that raises an Elapsed event in your application after the number of milliseconds in the Interval property has elapsed. Você pode configurar o Timer objeto para gerar o evento apenas uma vez ou repetidamente usando AutoReset a propriedade.You can configure the Timer object to raise the event just once or repeatedly using the AutoReset property. Normalmente, um Timer objeto é declarado no nível de classe para que ele permaneça no escopo, desde que seja necessário.Typically, a Timer object is declared at the class level so that it stays in scope as long as it is needed. Em seguida, você pode Elapsed manipular seu evento para fornecer processamento regular.You can then handle its Elapsed event to provide regular processing. 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.For example, suppose you have a critical server that must be kept running 24 hours a day, 7 days a week. Você pode criar um serviço que usa um Timer objeto para verificar periodicamente o servidor e garantir que o sistema esteja em execução.You could create a service that uses a Timer object to periodically check the server and ensure that the system is up and running. Se o sistema não estiver respondendo, o serviço poderá tentar reiniciar o servidor ou notificar um administrador.If the system is not responding, the service could attempt to restart the server or notify an administrator.

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.The Timer class is not available for all .NET implementations and versions, such as .NET Standard 1.6 and lower versions. Nesses casos, você pode usar a System.Threading.Timer classe em vez disso.In these cases, you can use the System.Threading.Timer class instead.

Esse tipo implementa a interface IDisposable.This type implements the IDisposable interface. Quando você terminar de usar o tipo, deverá descartá-lo direta ou indiretamente.When you have finished using the type, you should dispose of it either directly or indirectly. Para descartar o tipo diretamente, chame o método Dispose dele em um bloco try/catch.To dispose of the type directly, call its Dispose method in a try/catch block. Para descartá-lo indiretamente, use um constructo de linguagem como using ( em C#) ou Using (em Visual Basic).To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Saiba mais na seção "Como usar um objeto que implementa IDisposable" no tópico da interface IDisposable.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

A classe baseada System.Timers.Timer em servidor foi projetada para uso com threads de trabalho em um ambiente multithread.The server-based System.Timers.Timer class is designed for use with worker threads in a multithreaded environment. Os timers 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 para gerar o evento no tempo.Server timers can move among threads to handle the raised Elapsed event, resulting in more accuracy than Windows timers in raising the event on time.

O System.Timers.Timer componente gera o Elapsed evento, com base no valor (em Interval milissegundos) da propriedade.The System.Timers.Timer component raises the Elapsed event, based on the value (in milliseconds) of the Interval property. Você pode lidar com esse evento para executar o processamento de que precisa.You can handle this event to perform the processing you need. Por exemplo, suponha que você tenha um aplicativo de vendas online que posta continuamente pedidos de vendas em um banco de dados.For example, suppose that you have an online sales application that continuously posts sales orders to a database. O serviço que compila as instruções de envio opera em um lote de pedidos, em vez de processar cada pedido individualmente.The service that compiles the instructions for shipping operates on a batch of orders rather than processing each order individually. Você pode usar um Timer para iniciar o processamento em lotes a cada 30 minutos.You could use a Timer to start the batch processing every 30 minutes.

Importante

A classe System. Timers. Timer tem a mesma resolução que o relógio do sistema.The System.Timers.Timer class has the same resolution as the system clock. 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 do que a resolução do relógio do sistema.This means that the Elapsed event will fire at an interval defined by the resolution of the system clock if the Interval property is less than the resolution of the system clock. Para obter mais informações, consulte a propriedade Interval.For more information, see the Interval property.

Quando AutoReset é definido como false, um System.Timers.Timer objeto gera o Elapsed evento apenas uma vez, depois que Interval o primeiro tiver decorrido.When AutoReset is set to false, a System.Timers.Timer object raises the Elapsed event only once, after the first Interval has elapsed. Para continuar gerando Elapsed o evento regularmente no intervalo definido Intervalpelo, defina AutoReset como true, que é o valor padrão.To keep raising the Elapsed event regularly at the interval defined by the Interval, set AutoReset to true, which is the default value.

O Timer componente captura e suprime todas as exceções geradas pelos manipuladores de eventos Elapsed para o evento.The Timer component catches and suppresses all exceptions thrown by event handlers for the Elapsed event. Esse comportamento está sujeito a alterações em versões futuras do .NET Framework.This behavior is subject to change in future releases of the .NET Framework. No entanto, observe que isso não é verdadeiro para manipuladores de eventos que são executados de await forma assíncrona C#e incluem o Await operador (in) ou o operador (em Visual Basic).Note, however, that this is not true of event handlers that execute asynchronously and include the await operator (in C#) or the Await operator (in 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.Exceptions thrown in these event handlers are propagated back to the calling thread, as the following example illustrates. Para obter mais informações sobre exceções geradas em métodos assíncronos, consulte tratamento de exceção.For more information on exceptions thrown in asynchronous methods, see Exception Handling.

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 a SynchronizingObject propriedade for null, o Elapsed evento será gerado em um ThreadPool thread.If the SynchronizingObject property is null, the Elapsed event is raised on a ThreadPool thread. Se o processamento do Elapsed evento durar mais que Interval, o evento poderá ser gerado novamente em outro ThreadPool thread.If processing of the Elapsed event lasts longer than Interval, the event might be raised again on another ThreadPool thread. Nessa situação, o manipulador de eventos deve ser reentrante.In this situation, the event handler should be reentrant.

Observação

O método de manipulação de eventos pode ser executado em um thread ao mesmo tempo em que outro thread Stop chama o método ou Enabled define a falsePropriedade como.The event-handling method might run on one thread at the same time that another thread calls the Stop method or sets the Enabled property to false. Isso pode fazer com que Elapsed o evento seja gerado depois que o temporizador for interrompido.This might result in the Elapsed event being raised after the timer is stopped. O código de exemplo para Stop o método mostra uma maneira de evitar essa condição de corrida.The example code for the Stop method shows one way to avoid this race condition.

Mesmo se SynchronizingObject não nullfor, Elapsed os eventos poderão ocorrer depois Dispose que Stop o método ou tiver sido chamado ou Enabled depois que a propriedade tiver falsesido definida como, porque o sinal para gerar o Elapsed o evento é sempre enfileirado para execução em um thread do pool de threads.Even if SynchronizingObject is not null, Elapsed events can occur after the Dispose or Stop method has been called or after the Enabled property has been set to false, because the signal to raise the Elapsed event is always queued for execution on a thread pool thread. Uma maneira de resolver essa condição de corrida é definir um sinalizador que informa ao manipulador de eventos para Elapsed que o evento ignore os eventos subsequentes.One way to resolve this race condition is to set a flag that tells the event handler for the Elapsed event to ignore subsequent events.

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 timer nesse elemento da interface do usuário, atribua o formulário ou controle que Timer contém o SynchronizingObject à propriedade, para que o evento seja marshaled para o thread da interface do usuário.If you use the System.Timers.Timer class with a user interface element, such as a form or control, without placing the timer on that user interface element, assign the form or control that contains the Timer to the SynchronizingObject property, so that the event is marshaled to the user interface thread.

Para obter uma lista de valores de propriedade padrão para uma Timerinstância do, Timer consulte o construtor.For a list of default property values for an instance of Timer, see the Timer constructor.

Dica

Lembre-se de que o .NET inclui Timerquatro classes chamadas, e cada uma delas oferece diferentes funcionalidades:Be aware that .NET includes four classes named Timer, each of which offers different functionality:

  • System.Timers.Timer(este tópico): dispara um evento em intervalos regulares.System.Timers.Timer (this topic): fires an event at regular intervals. A classe destina-se ao uso 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 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: executa um único método de retorno de chamada em um thread de pool de threads em intervalos regulares.System.Threading.Timer: 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. Assim como System.Timers.Timer a classe, essa classe é destinada ao uso como um componente de serviço ou baseado em servidor em um ambiente multi-threaded; ela não tem nenhuma interface do usuário e não está 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(Somente .NET Framework): um componente Windows Forms que dispara um evento em intervalos regulares.System.Windows.Forms.Timer (.NET Framework only): a Windows Forms component that fires an event at regular intervals. O componente não tem nenhuma interface do usuário e é projetado para ser usado em um ambiente single-threaded.The component has no user interface and is designed for use in a single-threaded environment.
  • System.Web.UI.Timer(Somente .NET Framework): um componente ASP.NET que executa postbacks de página da Web assíncronos ou síncronos 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.

Construtores

Timer()

Inicializa uma nova instância da classe Timer e define todas as propriedades para seus valores iniciais.Initializes a new instance of the Timer class, and sets all the properties to their initial values.

Timer(Double)

Inicializa uma nova instância da classe Timer e define a propriedade Interval como o número especificado de milissegundos.Initializes a new instance of the Timer class, and sets the Interval property to the specified number of milliseconds.

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).Gets or sets a Boolean indicating whether the Timer should raise the Elapsed event only once (false) or repeatedly (true).

CanRaiseEvents

Obtém um valor que indica se o componente pode acionar um evento.Gets a value indicating whether the component can raise an event.

(Herdado de Component)
Container

Obtém o IContainer que contém o Component.Gets the IContainer that contains the Component.

(Herdado de Component)
DesignMode

Obtém um valor que indica se o Component está no modo de design no momento.Gets a value that indicates whether the Component is currently in design mode.

(Herdado de Component)
Enabled

Obtém ou define um valor que indica se o Timer deve acionar o evento Elapsed.Gets or sets a value indicating whether the Timer should raise the Elapsed event.

Events

Obtém a lista de manipuladores de eventos que estão anexados a este Component.Gets the list of event handlers that are attached to this Component.

(Herdado de Component)
Interval

Obtém ou define o intervalo, expressado em milissegundos, no qual gerar o evento Elapsed.Gets or sets the interval, expressed in milliseconds, at which to raise the Elapsed event.

Site

Obtém ou define o site que associa o Timer ao respectivo contêiner no modo de design.Gets or sets the site that binds the Timer to its container in design mode.

SynchronizingObject

Obtém ou define o objeto usado para realizar marshaling das chamadas do manipulador de eventos emitidas ao término de um intervalo.Gets or sets the object used to marshal event-handler calls that are issued when an interval has elapsed.

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.Begins the run-time initialization of a Timer that is used on a form or by another component.

Close()

Libera os recursos usados pelo Timer.Releases the resources used by the 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.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Herdado de MarshalByRefObject)
Dispose()

Libera todos os recursos usados pelo Component.Releases all resources used by the Component.

(Herdado de Component)
Dispose(Boolean)

Libera todos os recursos usados pelo Timer atual.Releases all resources used by the current Timer.

EndInit()

Termina a inicialização do tempo de execução de um Timer que é usado em um formulário ou por outro componente.Ends the run-time initialization of a Timer that is used on a form or by another component.

Equals(Object)

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

(Herdado de Object)
GetHashCode()

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

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

(Herdado de MarshalByRefObject)
GetService(Type)

Retorna um objeto que representa um serviço fornecido pelo Component ou pelo seu Container.Returns an object that represents a service provided by the Component or by its Container.

(Herdado de Component)
GetType()

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

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

(Herdado de MarshalByRefObject)
MemberwiseClone()

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

(Herdado de Object)
MemberwiseClone(Boolean)

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

(Herdado de MarshalByRefObject)
Start()

Começa a acionar o evento Elapsed definindo Enabled como true.Starts raising the Elapsed event by setting Enabled to true.

Stop()

Para de acionar o evento Elapsed definindo Enabled como false.Stops raising the Elapsed event by setting Enabled to false.

ToString()

Retorna um String que contém o nome do Component, se houver.Returns a String containing the name of the Component, if any. Esse método não deve ser substituído.This method should not be overridden.

(Herdado de Component)

Eventos

Disposed

Ocorre quando o componente é disposto por uma chamada para o método Dispose().Occurs when the component is disposed by a call to the Dispose() method.

(Herdado de Component)
Elapsed

Ocorre quando o intervalo termina.Occurs when the interval elapses.

Aplica-se a

Acesso thread-safe

Todos os static membros públicos desse tipo são thread-safe.Any public static members of this type are thread safe. Não há garantia de que qualquer membro de instância seja thread-safe.Any instance members are not guaranteed to be thread safe.

Veja também