Discussion :

[Dudule70]

Bonjour à tous,
Je dois déclencher à des heures précises une réinstallation de mes compteurs. J'utilise l'objet TimeSpan pour faire la différence entre l'heure attendue et l'heure courant (DateTime.Now)
Comme ci-dessous:

TimeSpan ts = heureAttendue.ToUniversalTime() - heureCourante.ToUniversalTime();

if ((Convert.ToInt64(ts.Ticks) >= 0) && !heure)
heure = true;

Je souhaiterai plutôt utiliser un déclenchement par événement ( à mon sens plus sûr).

En vous remerciant pour votre aide.
Cordialement

[DotNetMatt]

Tu peux utiliser un Timer. L'idée étant de le déclencher, et de définir sa propriété Interval à l'aide du nombre de millisecondes qui vont s'écouler entre l'échéance (l'heure à laquelle tu souhaites déclencher l'évènement), et l'heure actuelle. Lorsque l'échéance sera atteinte, il te suffira de gérer l'évènement Tick du Timer.

Voici un exemple :

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
private System.Windows.Forms.Timer _timer;
 
void SetTimer(DateTime limit)
{
    var interval = limit - DateTime.Now;
 
    this._timer.Interval = Convert.ToInt32(interval.TotalMilliseconds);
    this._timer.Tick += new EventHandler(timer_Tick);
    this._timer.Start();
}
 
void timer_Tick(object sender, EventArgs e)
{
    // Ton code...
}

Dans le paramètre limit de SetTime, il te suffit de passer par exemple DateTime.Now.AddHour(1) afin que ton évènement se déclenche dans une heure.

[Dudule70]

Bonjour DotNetMatt,
Merci pour ta réactivité et pour ton idée géniale !!!

Je reviens vers toi tout en bossant dessus, je recherche une solution pour résoudre le cas ou la date est révolue mais doit être activé pour le lendemain.

Je m’explique :
L’application peut être démarrée à n’importe quel moment de la journée et mes heures journalières vont de 5h45’ -> 14h15’ -> 22h45’ -> 5h45…
Si « interval » est négatif je l’écarte par un test, donc les événements pour les heures antérieures ne sont pas instanciés

if (Convert.ToInt32(interval.TotalMilliseconds) > 0)
{
this._timer.Interval = Convert.ToInt32(interval.TotalMilliseconds);
this._timer.Tick += new EventHandler(timer_Tick);
this._timer.Start();
}


voilà la méthode:

double[] h = { 5.45, 14.25, 22.75, 5.75 };
DateTime dateValue = new DateTime(DateTime.Now.Year,dateTime.Now.Month, DateTime.Now.Day, 0, 0, 0);

foreach (double xh in h)
SetTimer(dateValue.AddHours(xh));

Cordialement

[DotNetMatt]

N'oublie pas d'utiliser la balise CODE afin de faciliter la lecture

Concernant ta question, si tu veux aller plus loin et gérer plusieurs Timers, il faut revoir le code. Voici ce que je te propose.

Tout d'abord une liste de Timer, qui te permettra de stocker tes timers en cours :

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

private List<Timer> _timers;

Ensuite on crée une méthode ConfigureTimer() qui sera responsable d'initialiser les Timer :

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
private void ConfigureTimer()
{
    double[] h = { 5.75, 14.25, 22.75, 5.75 };
    DateTime dateValue = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, 0, 0, 0);
 
    foreach (double xh in h)
    {
        // On crée un nouveau Timer
        var timer = new Timer();
 
        // On récupère l'heure à laquelle on veut le programmer
        var scheduledTimeValue = dateValue.AddHours(xh);
        if (scheduledTimeValue < DateTime.Now)
        {
            // Si on a déjà dépassé l'heure, alors on rajoute 1 jour
            this.SetTimer(timer, scheduledTimeValue.AddDays(1));
        }
        else
        {
            // Sinon, on utilise l'heure de programmation prévue
            this.SetTimer(timer, scheduledTimeValue);
        }
    }
}

La méthode SetTimer() est un peu revue :

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
private void SetTimer(Timer timer, DateTime limit)
{
    var interval = limit - DateTime.Now;
 
    // Vérification pour écarter les intervalles négatifs
    if (Convert.ToInt32(interval.TotalMilliseconds) > 0)
    {
        // On ajoute le timer à la liste des timers
        this._timers.Add(timer);
 
        // On configure le timer
        timer.Interval = Convert.ToInt32(interval.TotalMilliseconds);
 
        // On s'abonne au traitement désiré
        timer.Tick += new EventHandler(timer_Tick);
 
        // On le lance (on pourrait aussi le lancer à postériori en passant par la liste de timers)
        timer.Start();
    }
}

Et enfin on a toujours notre handler :

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
void timer_Tick(object sender, EventArgs e)
{
    // Ton code...
}

Attention : comme Interval est de type Int32, la limite vaut donc int.MaxValue, ce qui équivaut à environ 27 jours... En clair il ne te sera pas possible de programmer un timer avec un interval supérieur à 27 jours.

[Dudule70]

Bonjour DotNetMatt,
L'application ne sera jamais redémarrée et la limite de l'interval reste un problème entier pour moi.
Est-ce que je peux résoudre ce problème en faisant chaque jour un RemoveAll de List<Timer> et relancer ConfigureTimer() ???

Je n'ai pas encore eu le temps de tout tester et explorer toutes les solutions.

Merci pour ton aide précieuse.

Cordialement

[DotNetMatt]

Oui tu peux utiliser RemoveAll afin de faire la mise à jour régulièrement.

Tu peux jetter un oeil à la librairie Quartz.NET, qui permet de définir des jobs et de les scheduler, entièrement en C#. Je pense que cette solution sera plus propre et t'offrira plus de possibilités si tu souhaites faire évoluer ton application ultérieurement.

[Dudule70]

Merci pour tout DotNetMatt !!!

[DotNetMatt]

De rien C'est vrai que comme au début on parlait d'un seul évènement, puis que tu as commencé à mentionner plusieurs déclenchements, et que là tu souhaites faire des déclenchements au-delà de 27 jours, on n'est plus vraiment sur les mêmes problématiques.

Donc là Quartz.NET est ce qu'il te faut. Good luck