C# Language
Des minuteries

Syntaxe

• myTimer.Interval - définit la fréquence à laquelle l'événement "Tick" est appelé (en millisecondes)
• myTimer.Enabled - valeur booléenne qui définit le temporisateur à myTimer.Enabled / désactiver
• myTimer.Start() - Démarre la minuterie.
• myTimer.Stop() - Arrête le minuteur.

Remarques

Temporisateurs Multithread

System.Threading.Timer - Minuteur multithread le plus simple. Contient deux méthodes et un constructeur.

Exemple: une minuterie appelle la méthode DataWrite, qui écrit "multithread execute ..." au bout de cinq secondes, puis toutes les secondes jusqu'à ce que l'utilisateur appuie sur Enter:

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

Remarque: Publiera une section distincte pour disposer de minuteries multithread.

Change - Cette méthode peut être appelée lorsque vous souhaitez modifier l'intervalle du minuteur.

Timeout.Infinite - Si vous souhaitez tirer une seule fois. Spécifiez ceci dans le dernier argument du constructeur.

System.Timers - Une autre classe de temporisateur fournie par .NET Framework. Il enveloppe le System.Threading.Timer .

Caractéristiques:

• IComponent - IComponent dans le plateau de composants du concepteur de Visual Studio
• Propriété Interval au lieu d'une méthode Change
• event Elapsed au lieu d'un delegate rappel
• Propriété Enabled pour démarrer et arrêter le minuteur ( default value = false )
• Méthodes Start & Stop en cas de confusion avec la propriété Enabled (au-dessus du point)
• AutoReset - pour indiquer un événement récurrent ( default value = true )
• Propriété SynchronizingObject avec les méthodes Invoke et BeginInvoke pour appeler des méthodes en toute sécurité sur des éléments WPF et des contrôles Windows Forms

Exemple représentant toutes les fonctionnalités ci-dessus:

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 - utilisez le pool de threads pour permettre à quelques threads de servir plusieurs minuteries. Cela signifie que la méthode de rappel ou l'événement Elapsed peut se déclencher sur un thread différent à chaque appel.

Elapsed - Cet événement se déclenche toujours à l'heure - que l'événement Elapsed précédent ait ou non été exécuté. Pour cette raison, les rappels ou les gestionnaires d'événements doivent être sécurisés pour les threads. La précision des temporisateurs multithread dépend du système d'exploitation et se situe généralement entre 10 et 20 ms.

interop - quand vous avez besoin d'une plus grande précision, utilisez ceci et appelez le minuteur multimédia Windows. Cela a une précision de 1 ms et est défini dans winmm.dll .

timeBeginPeriod - Appelez ceci en premier pour informer OS que vous avez besoin d'une précision de synchronisation élevée

timeSetEvent - appelle cela après timeBeginPeriod pour démarrer une minuterie multimédia.

timeKillEvent - appelez cela lorsque vous avez terminé, cela arrête le minuteur

timeEndPeriod - Appelez ceci pour informer le système d'exploitation que vous n'avez plus besoin d'une précision de synchronisation élevée.

Vous pouvez trouver des exemples complets sur Internet qui utilisent la minuterie multimédia en recherchant les mots clés dllimport winmm.dll timesetevent .

Créer une instance d'un temporisateur

Les temporisateurs permettent d'effectuer des tâches à des intervalles de temps spécifiques (Do X toutes les Y secondes). Vous trouverez ci-dessous un exemple de création d'une nouvelle instance de Timer.

REMARQUE : Ceci s'applique aux minuteries utilisant WinForms. Si vous utilisez WPF, vous voudrez peut-être regarder dans 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();
        }

    }

Affectation du gestionnaire d'événements "Tick" à une minuterie

Toutes les actions effectuées dans une minuterie sont traitées dans l'événement "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.
    }
}

Exemple: utiliser une minuterie pour effectuer un simple compte à rebours.

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

Résulte en...

Etc...