Timer Clase

Referencia

Definición

Espacio de nombres:: System.Timers

Ensamblado:: System.ComponentModel.TypeConverter.dll

Ensamblado:: System.dll

Ensamblado:: netstandard.dll

Source:: Timer.cs

Source:: Timer.cs

Source:: Timer.cs

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Genera un evento después de un intervalo establecido, con la opción de generar eventos recurrentes.

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), se configura un controlador de eventos para el evento y se 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 seguir ejecutándose 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 interfaz IDisposable. 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 deshacerse de él indirectamente, use una construcción de lenguaje como using (en C#) o Using (en Visual Basic). Para más información, vea la sección "Uso de objetos que implementan IDisposable" en el tema de la 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, vea la propiedad Interval.

Nota

El reloj del sistema que se usa es el mismo reloj utilizado 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 AutoResettrueen , que es el valor predeterminado.

El Timer componente detecta y suprime todas las excepciones producidas por los 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 para 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, consulte 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 procesamiento del Elapsed 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 se puede ejecutar en un subproceso al mismo tiempo que otro subproceso llama al Stop método o establece la Enabled propiedad falseen . Esto podría dar lugar a que el Elapsed evento se genere después de detener 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 o después de que la Enabled propiedad se haya establecido falseen , 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 el 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 del 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 es visible en tiempo de ejecución.
System.Windows.Forms.Timer: un componente de Windows Forms que produce un evento a intervalos regulares. El componente no tiene interfaz de usuario y está diseñado para su uso en un entorno de un único subproceso.
System.Web.UI.Timer (solo .NET Framework): un componente de ASP.NET que realiza postbacks de página web asincrónica o sincrónica a intervalos regulares.

Constructores

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

Propiedades

AutoReset	Obtiene o establece un valor booleano que indica si Timer debe generar el evento Elapsed 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 la interfaz IContainer que contiene la clase Component. (Heredado de Component)
DesignMode	Obtiene un valor que indica si Component está actualmente en modo de diseño. (Heredado de Component)
Enabled	Obtiene o establece un valor que indica si Timer debe generar el evento Elapsed.
Events	Obtiene la lista de controladores de eventos asociados a Component. (Heredado de Component)
Interval	Obtiene o establece el intervalo, expresado en milisegundos, en el que se generará el evento Elapsed.
Site	Obtiene o establece el sitio que enlaza el objeto Timer a su contenedor en modo de diseño.
SynchronizingObject	Obtiene o establece el objeto que se utiliza para calcular las referencias de las llamadas del controlador de eventos que se emiten al transcurrir un intervalo.

Métodos

BeginInit()	Comienza la inicialización en tiempo de ejecución de un objeto Timer que se usa en un formulario o que lo usa otro componente.
Close()	Libera los recursos que usa Timer.
CreateObjRef(Type)	Crea un objeto que contiene toda la información relevante necesaria para generar un proxy utilizado para comunicarse con un objeto remoto. (Heredado de MarshalByRefObject)
Dispose()	Libera todos los recursos que usa Component. (Heredado de Component)
Dispose(Boolean)	Libera todos los recursos que usa la clase Timer actual.
EndInit()	Finaliza la inicialización en tiempo de ejecución de un objeto Timer que se usa en un formulario o que lo usa otro componente.
Equals(Object)	Determina si el objeto especificado es igual que el objeto actual. (Heredado de Object)
GetHashCode()	Sirve como la 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 el servicio suministrado por Component o por 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 Object actual. (Heredado de Object)
MemberwiseClone(Boolean)	Crea una copia superficial del objeto MarshalByRefObject actual. (Heredado de MarshalByRefObject)
Start()	Empieza a generar el evento Elapsed al establecer Enabled en `true`.
Stop()	Deja de generar el evento Elapsed al establecer Enabled en `false`.
ToString()	Devuelve una String que contiene el nombre del Component, si existe. Este método no se debe invalidar. (Heredado de Component)

Eventos

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

Se aplica a

Seguridad para subprocesos

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

Compartir a través de

Timer Clase

Definición

Ejemplos

Comentarios

Constructores

Propiedades

Métodos

Eventos

Se aplica a

Seguridad para subprocesos

Consulte también

Recursos adicionales