C# Language
Temporizadores

Sintaxis

• myTimer.Interval : establece la frecuencia con la que se llama al evento "Tick" (en milisegundos)
• myTimer.Enabled : valor booleano que establece que el temporizador se habilite / deshabilite
• myTimer.Start() : inicia el temporizador.
• myTimer.Stop() : detiene el temporizador.

Observaciones

Temporizadores multiproceso

System.Threading.Timer - El temporizador multihilo más simple. Contiene dos métodos y un constructor.

Ejemplo: un temporizador llama al método DataWrite, que escribe "multihilo ejecutado ..." después de que hayan transcurrido cinco segundos, y luego cada segundo después de eso hasta que el usuario presiona Intro:

using System;
using System.Threading;
class Program
{
  static void Main()
  {
    // First interval = 5000ms; subsequent intervals = 1000ms
    Timer timer = new Timer (DataWrite, "multithread executed...", 5000, 1000);
    Console.ReadLine();
    timer.Dispose(); // This both stops the timer and cleans up.
  }

  static void DataWrite (object data)
  {
    // This runs on a pooled thread
    Console.WriteLine (data); // Writes "multithread executed..."
  }
}

Nota: publicará una sección separada para disponer de temporizadores multiproceso.

Change : este método puede llamarse cuando desee cambiar el intervalo del temporizador.

Timeout.Infinite - Si quieres disparar solo una vez. Especifique esto en el último argumento del constructor.

System.Timers - Otra clase de temporizador proporcionada por .NET Framework. Envuelve el System.Threading.Timer .

caracteristicas:

• IComponent : permitir que se ubique en la bandeja de componentes del Diseñador de Visual Studio
• Propiedad de Interval lugar de un método de Change
• event Elapsed lugar de un delegate devolución de llamada
• Propiedad Enabled para iniciar y detener el temporizador ( default value = false )
• Métodos de Start y Stop en caso de que se confunda con la propiedad Enabled (punto anterior)
• AutoReset : para indicar un evento recurrente ( default value = true )
• Propiedad SynchronizingObject con los métodos Invoke y BeginInvoke para llamar de forma segura a los elementos de WPF y los controles de Windows Forms

Ejemplo que representa todas las características anteriores:

using System;
using System.Timers; // Timers namespace rather than Threading
class SystemTimer
{
  static void Main()
  {
    Timer timer = new Timer(); // Doesn't require any args
    timer.Interval = 500;
    timer.Elapsed += timer_Elapsed; // Uses an event instead of a delegate
    timer.Start(); // Start the timer
    Console.ReadLine();
    timer.Stop(); // Stop the timer
    Console.ReadLine();
    timer.Start(); // Restart the timer
    Console.ReadLine();
    timer.Dispose(); // Permanently stop the timer
 }

 static void timer_Elapsed(object sender, EventArgs e)
 {
   Console.WriteLine ("Tick");
 }
}

Multithreaded timers : use el grupo de subprocesos para permitir que algunos subprocesos sirvan para muchos temporizadores. Significa que el método de devolución de llamada o Elapsed evento Elapsed pueden activarse en un hilo diferente cada vez que se llama.

Elapsed : este evento siempre se activa a tiempo, independientemente de si el evento Elapsed anterior terminó de ejecutarse. Debido a esto, las devoluciones de llamada o los controladores de eventos deben ser seguros para subprocesos. La precisión de los temporizadores multiproceso depende del sistema operativo, y suele ser de 10 a 20 ms.

interop : cuando necesite una mayor precisión, use esto y llame al temporizador multimedia de Windows. Esto tiene una precisión de hasta 1 ms y se define en winmm.dll .

timeBeginPeriod : llame a este primero para informar al sistema operativo que necesita una alta precisión de sincronización

timeSetEvent : llame a esto después de timeBeginPeriod para iniciar un temporizador multimedia.

timeKillEvent : llama a esto cuando hayas terminado, esto detiene el temporizador

timeEndPeriod : llame a esto para informar al sistema operativo que ya no necesita una alta precisión de tiempo.

Puede encontrar ejemplos completos en Internet que utilizan el temporizador multimedia buscando las palabras clave dllimport winmm.dll timesetevent .

Creando una instancia de un temporizador

Los temporizadores se utilizan para realizar tareas en intervalos de tiempo específicos (hacer X cada Y segundos). A continuación se muestra un ejemplo de cómo crear una nueva instancia de un temporizador.

NOTA : Esto se aplica a los temporizadores que usan WinForms. Si usa WPF, puede querer mirar DispatcherTimer

    using System.Windows.Forms; //Timers use the Windows.Forms namespace

    public partial class Form1 : Form
    {

        Timer myTimer = new Timer(); //create an instance of Timer named myTimer

    
        public Form1()
        {
            InitializeComponent();
        }

    }

Asignación del controlador de eventos "Tick" a un temporizador

Todas las acciones realizadas en un temporizador se manejan en el evento "Tick".

public partial class Form1 : Form
{

    Timer myTimer = new Timer();

    
    public Form1()
    {
        InitializeComponent();

        myTimer.Tick += myTimer_Tick; //assign the event handler named "myTimer_Tick"
    }

    private void myTimer_Tick(object sender, EventArgs e)
    {
        // Perform your actions here.
    }
}

Ejemplo: usar un temporizador para realizar una cuenta regresiva simple.

    public partial class Form1 : Form
    {

    Timer myTimer = new Timer();
    int timeLeft = 10;
    
        public Form1()
        {
            InitializeComponent();

            //set properties for the Timer
            myTimer.Interval = 1000;
            myTimer.Enabled = true;

            //Set the event handler for the timer, named "myTimer_Tick"
            myTimer.Tick += myTimer_Tick;

            //Start the timer as soon as the form is loaded
            myTimer.Start();

            //Show the time set in the "timeLeft" variable
            lblCountDown.Text = timeLeft.ToString();

        }

        private void myTimer_Tick(object sender, EventArgs e)
        {
            //perform these actions at the interval set in the properties.
            lblCountDown.Text = timeLeft.ToString();
            timeLeft -= 1;

            if (timeLeft < 0)
            {
                myTimer.Stop();
            }
        }
    }

Resultados en ...

Y así...