Comment ajouter une minuterie à une application c # console

utiliser le système.Le filetage.Classe Timer.

.Windows.Forme.Timer est conçu principalement pour une utilisation dans un thread simple, habituellement les formes de Windows UI thread.

il y a aussi un système.La classe Timers a été ajoutée au début du développement du framework .NET. Toutefois, il est généralement recommandé d'utiliser le Système.Le filetage.Classe de minuterie à la place, car c'est juste un système d'enroulement.Le filetage.Minuterie de toute façon.

il est également recommandé pour toujours utiliser un statique (partagé en VB.NET) système.Le filetage.Minuterie si vous développez un Service Windows et nécessitent une minuterie pour exécuter périodiquement. Cela évitera peut-être la collecte prématurée des ordures de votre objet de minuterie.

voici un exemple de minuterie dans une application de console:

using System; 
using System.Threading; 
public static class Program 
{ 
    public static void Main() 
    { 
       Console.WriteLine("Main thread: starting a timer"); 
       Timer t = new Timer(ComputeBoundOp, 5, 0, 2000); 
       Console.WriteLine("Main thread: Doing other work here...");
       Thread.Sleep(10000); // Simulating other work (10 seconds)
       t.Dispose(); // Cancel the timer now
    }
    // This method's signature must match the TimerCallback delegate
    private static void ComputeBoundOp(Object state) 
    { 
       // This method is executed by a thread pool thread 
       Console.WriteLine("In ComputeBoundOp: state={0}", state); 
       Thread.Sleep(1000); // Simulates other work (1 second)
       // When this method returns, the thread goes back 
       // to the pool and waits for another task 
    }
}

du livre CLR Via C# par Jeff Richter. Par la façon dont ce livre décrit le raisonnement derrière les 3 types de minuteries dans le Chapitre 23, fortement recommandé.

voici le code pour créer un simple ticker d'une seconde:

  using System;
  using System.Threading;

  class TimerExample
  {
      static public void Tick(Object stateInfo)
      {
          Console.WriteLine("Tick: {0}", DateTime.Now.ToString("h:mm:ss"));
      }

      static void Main()
      {
          TimerCallback callback = new TimerCallback(Tick);

          Console.WriteLine("Creating timer: {0}\n", 
                             DateTime.Now.ToString("h:mm:ss"));

          // create a one second timer tick
          Timer stateTimer = new Timer(callback, null, 0, 1000);

          // loop here forever
          for (; ; )
          {
              // add a sleep for 100 mSec to reduce CPU usage
              Thread.Sleep(100);
          }
      }
  }

Et voici le résultat:

    c:\temp>timer.exe
    Creating timer: 5:22:40

    Tick: 5:22:40
    Tick: 5:22:41
    Tick: 5:22:42
    Tick: 5:22:43
    Tick: 5:22:44
    Tick: 5:22:45
    Tick: 5:22:46
    Tick: 5:22:47

EDIT: Il n'est jamais une bonne idée d'ajouter dur spin boucles dans le code en tant qu'ils consomment de cycles CPU pour aucun gain. Dans ce cas, cette boucle a été ajoutée juste pour empêcher l'application de se fermer, permettant ainsi d'observer les actions du thread. Mais pour l'amour de l'exactitude et de réduire la Utilisation du CPU un simple appel de veille a été ajouté à cette boucle.

vous Permet d'Avoir Un peu de Plaisir

using System;
using System.Timers;

namespace TimerExample
{
    class Program
    {
        static Timer timer = new Timer(1000);
        static int i = 10;

        static void Main(string[] args)
        {            
            timer.Elapsed+=timer_Elapsed;
            timer.Start();
            Console.Read();
        }

        private static void timer_Elapsed(object sender, ElapsedEventArgs e)
        {
            i--;

            Console.Clear();
            Console.WriteLine("=================================================");
            Console.WriteLine("                  DIFFUSE THE BOMB");
            Console.WriteLine(""); 
            Console.WriteLine("                Time Remaining:  " + i.ToString());
            Console.WriteLine("");        
            Console.WriteLine("=================================================");

            if (i == 0) 
            {
                Console.Clear();
                Console.WriteLine("");
                Console.WriteLine("==============================================");
                Console.WriteLine("         B O O O O O M M M M M ! ! ! !");
                Console.WriteLine("");
                Console.WriteLine("               G A M E  O V E R");
                Console.WriteLine("==============================================");

                timer.Close();
                timer.Dispose();
            }

            GC.Collect();
        }
    }
}

ou en utilisant Rx, court et doux:

static void Main()
{
Observable.Interval(TimeSpan.FromSeconds(10)).Subscribe(t => Console.WriteLine("I am called... {0}", t));

for (; ; ) { }
}

vous pouvez également utiliser vos propres mécanismes de synchronisation si vous voulez un peu plus de contrôle, mais peut-être moins de précision et plus de code/complexité, mais je recommande toujours une minuterie. Utilisez ceci cependant si vous avez besoin d'avoir le contrôle sur le fil de synchronisation réel:

private void ThreadLoop(object callback)
{
    while(true)
    {
        ((Delegate) callback).DynamicInvoke(null);
        Thread.Sleep(5000);
    }
}

serait votre fil de synchronisation(modifiez ceci pour arrêter au besoin, et à n'importe quel intervalle de temps que vous voulez).

et pour utiliser / démarrer vous pouvez faire:

Thread t = new Thread(new ParameterizedThreadStart(ThreadLoop));

t.Start((Action)CallBack);

Callback est votre méthode sans paramètre de vide que vous voulez appelé à chaque intervalle. Par exemple:

private void CallBack()
{
    //Do Something.
}

vous pouvez également créer votre propre (si vous n'êtes pas satisfait des options disponibles).

créer son propre Timer l'implémentation est assez basique.

ceci est un exemple pour une application qui avait besoin D'un accès COM object sur le même thread que le reste de ma base de code.

/// <summary>
/// Internal timer for window.setTimeout() and window.setInterval().
/// This is to ensure that async calls always run on the same thread.
/// </summary>
public class Timer : IDisposable {

    public void Tick()
    {
        if (Enabled && Environment.TickCount >= nextTick)
        {
            Callback.Invoke(this, null);
            nextTick = Environment.TickCount + Interval;
        }
    }

    private int nextTick = 0;

    public void Start()
    {
        this.Enabled = true;
        Interval = interval;
    }

    public void Stop()
    {
        this.Enabled = false;
    }

    public event EventHandler Callback;

    public bool Enabled = false;

    private int interval = 1000;

    public int Interval
    {
        get { return interval; }
        set { interval = value; nextTick = Environment.TickCount + interval; }
    }

    public void Dispose()
    {
        this.Callback = null;
        this.Stop();
    }

}

Vous pouvez ajouter des événements comme suit:

Timer timer = new Timer();
timer.Callback += delegate
{
    if (once) { timer.Enabled = false; }
    Callback.execute(callbackId, args);
};
timer.Enabled = true;
timer.Interval = ms;
timer.Start();
Window.timers.Add(Environment.TickCount, timer);

pour s'assurer que la minuterie fonctionne besoin de créer une boucle sans fin comme suit:

while (true) {
     // Create a new list in case a new timer
     // is added/removed during a callback.
     foreach (Timer timer in new List<Timer>(timers.Values))
     {
         timer.Tick();
     }
}