.NET, événement chaque minute (à la minute). Est une minuterie la meilleure option?

Bâtiment sur la réponse de thomas d'aquin, qui peuvent se déplacer et qui ne la cochez pas exactement à la minute dans la seconde de la minute:

static System.Timers.Timer t;

static void Main(string[] args)
{
    t = new System.Timers.Timer();
    t.AutoReset = false;
    t.Elapsed += new System.Timers.ElapsedEventHandler(t_Elapsed);
    t.Interval = GetInterval();
    t.Start();
    Console.ReadLine();
}

static double GetInterval()
{
    DateTime now = DateTime.Now;
    return ((60 - now.Second) * 1000 - now.Millisecond);
}

static void t_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
{
    Console.WriteLine(DateTime.Now.ToString("o"));
    t.Interval = GetInterval();
    t.Start();
}

Sur ma boîte ce code tiques de façon cohérente .02 de chaque minute:

2010-01-15T16:42:00.0040001-05:00
2010-01-15T16:43:00.0014318-05:00
2010-01-15T16:44:00.0128643-05:00
2010-01-15T16:45:00.0132961-05:00

La création d'un Timer de contrôle qui se déclenche toutes les 1 seconde (et n'a généralement rien mais une simple vérification) permettra d'ajouter négligeable surcharge à votre application.

Il suffit de comparer la valeur de de l'Environnement.TickCount ou DateTime.Maintenant à la dernière stockées temps (la dernière minute cochez la case"), et vous devriez avoir une assez précise de la solution. La résolution de ces deux valeurs de temps est d'environ 15ms, qui doit être suffisant pour vos besoins.

Faire, toutefois, de noter que l'intervalle de la Timer de contrôle est pas garanti pour être précise ou même n'importe où maintenant, car il fonctionne sur Windows boucle de message, qui est lié à la réactivité de l'INTERFACE utilisateur. Ne jamais compter sur elle, même modérément moment précis - même si il est assez bon pour un tir de répétition des événements où vous pouvez vérifier le temps à l'aide d'un méthode plus sensible comme l'un des deux ci-dessus.

J'ai juste écrit cette classe à l'aide de la WPF DispatcherTimer mais vous pouvez changer le répartiteur de toute minuterie qui prend en charge la modification quand il est réveillé du sommeil à l'état.

La classe est construit avec un fixe pas de temps et supprts Start/Stop/Reset, Start/Stop/Start fonctionne comme un résumé de l'opération. La minuterie est comme un chronomètre à cet égard.

Une horloge de mise en œuvre serait tout simplement de créer la classe avec un intervalle de 1 seconde et écouter l'événement. Méfiez-vous cependant que c'est une horloge en temps réel, si l'événement tick prend plus de temps que l'intervalle pour finir, vous remarquerez que l'horloge va essayer de se rattraper en temps réel ce sera la cause d'une rafale de cocher les événements qui se posent.

public class FixedStepDispatcherTimer
{
///<summary>
///Occurs when the timer interval has elapsed.
///</summary>
public event EventHandler Tick;
DispatcherTimer timer;
public bool IsRunning { get { return timer.IsEnabled; } }
long step, nextTick, n;
public TimeSpan Elapsed { get { return new TimeSpan(n * step); } }
public FixedStepDispatcherTimer(TimeSpan interval)
{
if (interval < TimeSpan.Zero)
{
throw new ArgumentOutOfRangeException("interval");
}
this.timer = new DispatcherTimer();
this.timer.Tick += new EventHandler(OnTimerTick);
this.step = interval.Ticks;
}
TimeSpan GetTimerInterval()
{
var interval = nextTick - DateTime.Now.Ticks;
if (interval > 0)
{
return new TimeSpan(interval);
}
return TimeSpan.Zero; //yield
}
void OnTimerTick(object sender, EventArgs e)
{
if (DateTime.Now.Ticks >= nextTick)
{
n++;
if (Tick != null)
{
Tick(this, EventArgs.Empty);
}
nextTick += step;
}
var interval = GetTimerInterval();
Trace.WriteLine(interval);
timer.Interval = interval;
}
public void Reset()
{
n = 0;
nextTick = 0;
}
public void Start()
{
var now = DateTime.Now.Ticks;
nextTick = now + (step - (nextTick % step));
timer.Interval = GetTimerInterval();
timer.Start();
}
public void Stop()
{
timer.Stop();
nextTick = DateTime.Now.Ticks % step;
}
}

Un peu de code pour voir si la minute qui a changé une fois par seconde ne devrait pas exiger beaucoup de temps CPU, et devrait être acceptable.

En faisant usage de ReactiveExtensions vous pouvez utiliser le code suivant si vous étiez intéressé à faire quelque chose d'aussi simple que l'impression à la console.

using System;
using System.Reactive.Linq;
namespace ConsoleApplicationExample
{
class Program
{
static void Main()
{
Observable.Interval(TimeSpan.FromMinutes(1))
.Subscribe(_ =>
{                   
Console.WriteLine(DateTime.Now.ToString());
});
Console.WriteLine(DateTime.Now.ToString()); 
Console.ReadLine();
}
}
}

Alternativement, vous pouvez dormir à suspendre l'exécution jusqu'à l'expiration du délai qui devrait être proche de votre temps désiré. Cela ne fera que réveiller l'ordinateur lorsque le sommeil finitions de sorte qu'il vous permettra de gagner du temps CPU et de laisser la puissance du PROCESSEUR vers le bas entre le traitement des événements.

Cela a l'avantage de modifier le délai d'attente afin qu'il ne dérive pas.

int timeout = 0;
while (true)  {
timeout = (60 - DateTime.Now.Seconds) * 1000 - DateTime.Now.Millisecond;
Thread.Sleep(timeout);
//do your stuff here
}

Ce que j'utilise pour les tâches planifiées est un Système.Le filetage.Minuterie(Système D'.Le filetage.TimerCallback, objet, int, int) avec le rappel pour le code je veux exécuter en fonction d'un intervalle qui est fourni en millisecondes pour la période valeur.