Timer Clase

Definición

Espacio de nombres:

System.Timers

Ensamblados:

netstandard.dll, System.ComponentModel.TypeConverter.dll

Source:

Timer.cs

Genera un evento después de un intervalo establecido, con una opción para generar eventos periódicos.

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

Herencia

Object

MarshalByRefObject

Component

Timer

Implementaciones

ISupportInitialize

Ejemplos

En el ejemplo siguiente se crea una instancia de un System.Timers.Timer objeto que desencadena su Timer.Elapsed evento cada dos segundos (2000 milisegundos), configura un controlador de eventos para el evento e inicia el temporizador. El controlador de eventos muestra el valor de la ElapsedEventArgs.SignalTime propiedad cada vez que se genera.

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

Comentarios

El Timer componente es un temporizador basado en servidor que genera un Elapsed evento en la aplicación después de que haya transcurrido el número de milisegundos de la Interval propiedad. Puede configurar el Timer objeto para generar el evento una vez o repetidamente mediante la AutoReset propiedad . Normalmente, un Timer objeto se declara en el nivel de clase para que permanezca en el ámbito siempre que sea necesario. A continuación, puede controlar su Elapsed evento para proporcionar un procesamiento normal. Por ejemplo, supongamos que tiene un servidor crítico que debe mantenerse ejecutando 24 horas al día, 7 días a la semana. Puede crear un servicio que use un Timer objeto para comprobar periódicamente el servidor y asegurarse de que el sistema está en funcionamiento. Si el sistema no responde, el servicio podría intentar reiniciar el servidor o notificar a un administrador.

Importante

La Timer clase no está disponible para todas las implementaciones y versiones de .NET, como .NET Standard 1.6 y versiones anteriores. En estos casos, puede usar la System.Threading.Timer clase en su lugar.

Este tipo implementa la IDisposable interfaz . Cuando haya terminado de utilizar el tipo, debe desecharlo directa o indirectamente. Para eliminar el tipo directamente, llame a su método Dispose en un bloque try/catch. Para eliminarlo indirectamente, use una construcción de lenguaje como using (en C#) o Using (en Visual Basic). Para obtener más información, vea la sección "Using an Object that Implements IDisposable" (Usar un objeto que implementa IDisposable) en el tema de interfaz IDisposable .

La clase basada en System.Timers.Timer servidor está diseñada para su uso con subprocesos de trabajo en un entorno multiproceso. Los temporizadores de servidor pueden moverse entre subprocesos para controlar el evento generado Elapsed , lo que da lugar a una mayor precisión que los temporizadores de Windows para generar el evento a tiempo.

El System.Timers.Timer componente genera el Elapsed evento, en función del valor (en milisegundos) de la Interval propiedad . Puede controlar este evento para realizar el procesamiento que necesita. Por ejemplo, supongamos que tiene una aplicación de ventas en línea que publica continuamente pedidos de ventas en una base de datos. El servicio que compila las instrucciones para el envío funciona en un lote de pedidos en lugar de procesar cada pedido individualmente. Puede usar Timer para iniciar el procesamiento por lotes cada 30 minutos.

Importante

La clase System.Timers.Timer tiene la misma resolución que el reloj del sistema. Esto significa que el Elapsed evento se activará en un intervalo definido por la resolución del reloj del sistema si la Interval propiedad es menor que la resolución del reloj del sistema. Para obtener más información, consulte la propiedad Interval.

Nota:

El reloj del sistema que se usa es el mismo reloj usado por GetTickCount, que no se ve afectado por los cambios realizados con timeBeginPeriod y timeEndPeriod.

Cuando AutoReset se establece falseen , un System.Timers.Timer objeto genera el Elapsed evento una sola vez, una vez transcurrido el primero Interval . Para mantener la generación del Elapsed evento regularmente en el intervalo definido por Interval, establezca en AutoResettrue, que es el valor predeterminado.

El Timer componente detecta y suprime todas las excepciones producidas por controladores de eventos para el Elapsed evento. Este comportamiento está sujeto a cambios en futuras versiones de .NET Framework. Sin embargo, tenga en cuenta que esto no es cierto en los controladores de eventos que se ejecutan de forma asincrónica e incluyen el await operador (en C#) o el Await operador (en Visual Basic). Las excepciones producidas en estos controladores de eventos se propagan de nuevo al subproceso que realiza la llamada, como se muestra en el ejemplo siguiente. Para obtener más información sobre las excepciones producidas en métodos asincrónicos, vea Control de excepciones.

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

Si la SynchronizingObject propiedad es null, el Elapsed evento se genera en un ThreadPool subproceso. Si el Elapsed procesamiento del evento dura más tiempo que Interval, es posible que el evento se vuelva a generar en otro ThreadPool subproceso. En esta situación, el controlador de eventos debe ser reentrant.

Nota:

El método de control de eventos puede ejecutarse en un subproceso al mismo tiempo que otro subproceso llama al Stop método o establece la Enabled propiedad falseen . Esto puede dar lugar a que el Elapsed evento se genere después de que se detenga el temporizador. El código de ejemplo del Stop método muestra una manera de evitar esta condición de carrera.

Incluso si SynchronizingObject no nulles , Elapsed los eventos pueden producirse después de llamar al Dispose método o Stop después de establecer falsela Enabled propiedad en , porque la señal para generar el Elapsed evento siempre se pone en cola para su ejecución en un subproceso del grupo de subprocesos. Una manera de resolver esta condición de carrera es establecer una marca que indique al controlador de eventos que el Elapsed evento omita los eventos posteriores.

Si usa la System.Timers.Timer clase con un elemento de interfaz de usuario, como un formulario o control, sin colocar el temporizador en ese elemento de interfaz de usuario, asigne el formulario o control que contiene a Timer la SynchronizingObject propiedad , de modo que el evento se serializa en el subproceso de la interfaz de usuario.

Para obtener una lista de valores de propiedad predeterminados para una instancia de Timer, vea el Timer constructor .

Sugerencia

.NET incluye cuatro clases denominadas Timer, cada una de las cuales ofrece una funcionalidad diferente:

• System.Timers.Timer (este tema): desencadena un evento a intervalos regulares. La clase está pensada para su uso como componente de servicio o basado en servidor en un entorno multiproceso; no tiene ninguna interfaz de usuario y no está visible en tiempo de ejecución.
• System.Threading.Timer: ejecuta un único método de devolución de llamada en un subproceso de grupo de subprocesos a intervalos regulares. El método de devolución de llamada se define cuando se crea una instancia del temporizador y no se puede cambiar. Al igual que la System.Timers.Timer clase , esta clase está pensada para su uso como componente de servicio o basado en servidor en un entorno multiproceso; no tiene ninguna interfaz de usuario y no está visible en tiempo de ejecución.
• System.Windows.Forms.Timer: un componente de Windows Forms que desencadena un evento a intervalos regulares. El componente no tiene ninguna interfaz de usuario y está diseñada para su uso en un entorno de un solo subproceso.
• System.Web.UI.Timer (solo .NET Framework): un componente de ASP.NET que realiza postbacks de página web asincrónicas o sincrónicas a intervalos regulares.

Constructores

Nombre	Description
Timer()	Inicializa una nueva instancia de la Timer clase y establece todas las propiedades en sus valores iniciales.
Timer(Double)	Inicializa una nueva instancia de la Timer clase y establece la Interval propiedad en el número especificado de milisegundos.
Timer(TimeSpan)	Inicializa una nueva instancia de la Timer clase , estableciendo la Interval propiedad en el período especificado.

Propiedades

Nombre	Description
AutoReset	Obtiene o establece un valor booleano que indica si Timer debe generar el Elapsed evento solo una vez (false) o repetidamente (true).
CanRaiseEvents	Obtiene un valor que indica si el componente puede generar un evento. (Heredado de Component)
Container	Obtiene el IContainer objeto que contiene el Componentobjeto . (Heredado de Component)
DesignMode	Obtiene un valor que indica si Component el objeto está actualmente en modo de diseño. (Heredado de Component)
Enabled	Obtiene o establece un valor que indica si Timer debe generar el Elapsed evento.
Events	Obtiene la lista de controladores de eventos que están asociados a este Componentobjeto . (Heredado de Component)
Interval	Obtiene o establece el intervalo, expresado en milisegundos, en el que se va a generar el Elapsed evento.
Site	Obtiene o establece el sitio que enlaza al Timer contenedor en modo de diseño.
SynchronizingObject	Obtiene o establece el objeto utilizado para serializar las llamadas al controlador de eventos que se emiten cuando ha transcurrido un intervalo.

Métodos

Nombre	Description
BeginInit()	Comienza la inicialización en tiempo de ejecución de un Timer objeto que se usa en un formulario o en otro componente.
Close()	Libera los recursos usados por .Timer
Dispose()	Libera todos los recursos usados por .Component (Heredado de Component)
Dispose(Boolean)	Libera todos los recursos usados por el objeto actual Timer.
EndInit()	Finaliza la inicialización en tiempo de ejecución de un Timer objeto que se usa en un formulario o en otro componente.
Equals(Object)	Determina si el objeto especificado es igual al objeto actual. (Heredado de Object)
GetHashCode()	Actúa como función hash predeterminada. (Heredado de Object)
GetLifetimeService()	Obsoletos. Recupera el objeto de servicio de duración actual que controla la directiva de duración de esta instancia. (Heredado de MarshalByRefObject)
GetService(Type)	Devuelve un objeto que representa un servicio proporcionado por Component o por su Container. (Heredado de Component)
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
InitializeLifetimeService()	Obsoletos. Obtiene un objeto de servicio de duración para controlar la directiva de duración de esta instancia. (Heredado de MarshalByRefObject)
MemberwiseClone()	Crea una copia superficial del Objectactual. (Heredado de Object)
MemberwiseClone(Boolean)	Crea una copia superficial del objeto actual MarshalByRefObject . (Heredado de MarshalByRefObject)
Start()	Inicia la generación del Elapsed evento estableciendo trueEnabled en .
Stop()	Detiene la generación del Elapsed evento estableciendo falseEnabled en .
ToString()	Devuelve un String objeto que contiene el nombre de Component, si existe. Este método no se debe invalidar. (Heredado de Component)

Eventos

Nombre	Description
Disposed	Se produce cuando el componente se elimina mediante una llamada al Dispose() método . (Heredado de Component)
Elapsed	Se produce cuando transcurre el intervalo.

Seguridad para subprocesos

Los miembros públicos static de este tipo son seguros para subprocesos. No se garantiza que los miembros de instancia sean seguros para el acceso concurrente.

Consulte también

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