Discussion :

[synolog]

Bonjour,

J'aimerai lancer une méthode, ou même le contenu entier de mon programme à une heure précise.
Le planificateur de tâche pourrait me permettre cela, mais cela ne fonctionne pas comme je le souhaite (vu dans mon dernier post : http://www.developpez.net/forums/d12...che-planifiee/ )
Le but n'est pas de consommé de la mémoire à boucler sans cesse pour tomber sur l'heure voulue pour lancer mon programme.
Existe-t-il une façon simple de lancer le contenu de mon .exe à une heure précise de la journée?

Merci d'avance...

[MaximePalmisano]

Je pense qu'une tâche planifiée est la meilleure manière de procéder.

Il doit juste y avoir un bug dans ton programme. Essaye de mettre à chaque ligne une fonction de log qui enregistre l'état des variables: Tu auras un truc super verbeux mais au moins tu pourras détecter le problème assez facilement.

Sinon, même en tâche planifiée, rien ne t'empêche de t'attacher au processus pour débugger je pense.

[synolog]

Merci pour ta réponse,

Le problème vient en faite du paramètre "Exécuter même si l'utilisateur n'est pas connecté" qui est pour moi indispensable. Lorsque celui-ci est coché, la tâche s'exécute en non-visible ce qui empêche le lancement de mes exécutables appelés avec Process.start().
Alors que si l'option "N'exécuter que si l'utilisateur est connecté", la tâche s'exécute en visible ce qui lance correctement mes .exe.
Je suis donc bloqué sur ce point, car selon Google il n'y a pas d'alternative à cette non-visibilité de la tâche...
La seul semble une boucle qui me fait froid dans le dos!
Exemple :

Code :

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
            DateTime now;
            while (true)
            {
                now = DateTime.Now;
                if (now.DayOfWeek == DayOfWeek.Monday)
                {
                    if (now.Hour == 20)
                    {
                        if (now.Minute == 30)
                            break;
                        else
                            Thread.Sleep(30000); //Tout les 30s
                    }
                    else
                        Thread.Sleep(1800000); //Tout les 30min
                }
                else
                    Thread.Sleep(21600000); //Tout les 6h
            }

J'aimerai évité d'insérer ce code mais j'ai l'impression que je n'aurais pas le choix malheureusement...

[MaximePalmisano]

Je viens de penser à un truc. Que donne le code suivant :

Code :

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

1
2
3
4
5
6
7
8
 
TimeSpan triggerTime = new TimeSpan(20, 30, 0); // Starting at 20h30
DateTime triggerDate = DateTime.Today.Add(triggerTime); // Today's occurence
 
TimeSpan timeRemainingBeforeTrigger = triggerDate - DateTime.Now;
 
Timer t = new Timer(timeRemainingBeforeTrigger.TotalMilliseconds);
t.Start();

Bon le code est bien pourri mais c'est pour donner l'idée quoi. Lancer un timer avec en param le nombre de milliseconde entre l'heure qu'il est et la prochaine occurence.

Du coup, une fois dans la callback, tu changes la duration du timer à 24h et tu es peinard

Je sais pas ce que ça vaut mais c'est peut être une piste à explorer.

[synolog]

Je l'exploiterai demain, mais ca me semble déjà moins lourd que ma boucle
Merci pour ton aide

[DotNetMatt]

Code C# :

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

1
2
3
4
while (true) 
{ 
    // 
}

C'est le genre de truc qu'on voit dans les pires exemples de code

[EDIT] Ca m'a fait marrer. Mais ceci dit, c'est vrai que ça s'utilise je viens d'en discuter avec des collègues et de faire quelques recherches sur Google, qui confirment, genre ça.

[synolog]

LOL, oui c'était plus qu'horrible comme début!
Mais voilà ou j'en suis:

Code :

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
            DateTime now = DateTime.Now;
            now = new DateTime(now.Year, now.Month, now.Day, 0, 0, 0);
 
            List<DateTime> nextWednesday = new List<DateTime>();
            for (int i=0; i<100; i++)                                  
            {
                if (now.AddDays(i).DayOfWeek == DayOfWeek.Wednesday)
                    nextWednesday.Add(now.AddDays(i));
            }
 
            foreach (DateTime nextDate in nextWednesday)
            {
                TimeSpan triggerTime = new TimeSpan(20, 30, 0);
                DateTime nextWed = nextDate + triggerTime;
                TimeSpan interval = nextWed - DateTime.Now;
 
                Console.WriteLine(interval.TotalMilliseconds);
 
                //System.Timers.Timer t = new System.Timers.Timer(interval.TotalMilliseconds);
                //t.Start();
                Thread.Sleep((int)interval.TotalMilliseconds);
            }

Je remet à zéro l'heure, les minutes et secondes du jour. Suivis du calcul des prochains mercredis (durant les 3 prochains mois) ensuite je calcul l'intervalle entre la date actuelle et les mercredis listés.
Jusqu'ici tout va bien, mais je me trouve bloqué avec le timer! N'ayant jamais utiliser Timer, je suis un peu perdu car il ne se lance pas
Je peux le faire avec Thread.Sleep() en arrondissant le nombre de ms, mais laquelle de ces 2 méthodes consomment le moins de ressource?

[Invité]

Jusqu'ici tout va bien, mais je me trouve bloqué avec le timer! N'ayant jamais utiliser Timer, je suis un peu perdu car il ne se lance pas

Il y a normalement une méthode Start() qui démarre le Timer et surtout une propriété Interval qui te permet de paramétrer la périodicité.

Je peux le faire avec Thread.Sleep() en arrondissant le nombre de ms, mais laquelle de ces 2 méthodes consomment le moins de ressource?

L'utilisation de Thread.Sleep() pour déclencher une tâche périodique n'est pas... comment dirais-je... élégant. Il faut passer par le Timer ou j'aime bien la librairie Quartz.Net qui te permet de faire ces genres de trucs très facilement.

[synolog]

Il y a normalement une méthode Start() qui démarre le Timer et surtout une propriété Interval qui te permet de paramétrer la périodicité.

Oui, mais il passe tout droit sans prendre en compte l'intervalle fixé pour le timer. C'est une application console, peut être est-ce du à ca?

L'utilisation de Thread.Sleep() pour déclencher une tâche périodique n'est pas... comment dirais-je... élégant. Il faut passer par le Timer ou j'aime bien la librairie Quartz.Net qui te permet de faire ces genres de trucs très facilement.

Pour ce qui concerne Thread.Sleep(), dans tout les cas je ne pourrais pas l'utiliser car le nombre de ms est supérieur à la valeur max d'un entier...
Je vais jeter un coup d'oeil sur la librairie Quartz si elle peut résoudre mon problème.
Merci

Edit : Le timer ne fonctionne pas tel que je m'y attendais, mais fonctionne tout de même. Or le problème concernant les limites des entiers reste toujours le même... Il me reste à m'assurer de ne pas dépasser cette limite.

[MaximePalmisano]

Pour ce qui est des timers c'est un long que l'on passe, donc tu devrais déjà être plus peinard niveau limites.

[synolog]

Pour ce qui est des timers c'est un long que l'on passe, donc tu devrais déjà être plus peinard niveau limites.

Le Timer fonctionne!!
Par contre je ne suis pas convaincu que ce soit un long, l'erreur suivante appuie le contraire:

Le nombre doit être soit non négatif et inférieur ou égal à Int32.MaxValue, soit -1.
Nom du paramètre : dueTime

L'erreur survient à la ligne t.Enabled = true ou la valeur passée est supérieure à la valeur max d'un int:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
            foreach (DateTime nextDate in nextWednesday)
            {
                TimeSpan triggerTime = new TimeSpan(20, 30, 0);
                DateTime nextWed = nextDate + triggerTime;
                TimeSpan interval = nextWed - DateTime.Now;
 
                Console.WriteLine(interval.TotalMilliseconds);
 
                System.Timers.Timer t = new System.Timers.Timer();
                t.Elapsed += new System.Timers.ElapsedEventHandler(OnTimedEvent);
                t.Interval = interval.TotalMilliseconds;
                t.AutoReset = false;
                t.Enabled = true;
                t.Start();
            }

Si quelqu'un a une idée...

[MaximePalmisano]

En effet, c'est avec le Timer de System.Timers que l'on passe un double (et pas un long )

Sinon ce que tu peux faire:

- Tu regardes la durée entre ta prochaine échéance et maintenant. Si c'est plus d'un jour, tu lances un timer de 24h, sinon tu lances le timer avec le temps qu'il reste.

Voici ce que ça devrait donner (je l'ai pas fait sous un IDE):

Code :

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 void PrepareNextTimer()
{
    TimeSpan interval = triggerDate - DateTime.Now;
 
    if(interval.TotalDays > 1)
        timer.Duration = new TimeSpan(24,0,0).TotalMilliseconds;
    else
        time.Duration = interval.TotalMilliseconds;
 
    // Ou alors interval = interval.TotalDays > 1 ? new TimeSpan(24,0,0) : interval;
    // timer.Duration = interval.TotalMilliseconds;
 
    timer.Start();
}

Tu appelles cela une première fois et pour chaque callback appelé par le timer, tu fais un check de si on est à ta date d'échéance (oublie pas de prévoir un delta) et tu réarmes le timer avec cette fonction.

Ca devrait éviter le dépassement du int.

[synolog]

Merci pour ta piste, je vais l'étudier
Sinon j'avais pensé d'utiliser le Timer pour relancer une planification, mais qui pourrait finir en usine à gaz
Du genre:

Code :

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
25
26
27
28
29
30
        private static void planning()
        {
            foreach (DateTime nextDate in nextWednesday)                
            {
                TimeSpan triggerTime = new TimeSpan(20, 30, 0);
                DateTime nextTues = nextDate + triggerTime;
                TimeSpan interval = nextTues - DateTime.Now;
 
                Console.WriteLine("- Mardi {0}", nextTues);
 
                int MaxValue = 2147483640;
                if ((long)interval.TotalMilliseconds > MaxValue)
                {
                    System.Timers.Timer timeOut = new System.Timers.Timer();
                    timeOut.Elapsed += new System.Timers.ElapsedEventHandler(OnTimedTerminate);
                    timeOut.Interval = MaxValue;
                    timeOut.Enabled = true;
                    timeOut.AutoReset = false;
                    timeOut.Start();
                    break;
                }
 
 
                /* Traitement du planning en dessous de la limites Max int */
            }
 
         private static void OnTimedTerminate(object sender, ElapsedEventArgs e)
        {
            planning();
        }

Ce qui me recherche, une fois la limite dépassée, les prochaines dates... Je ne suis pas convaincu de la sûreté du code qui n'est pas au point, mais cela fonctionne
Par contre, les timers consomment de la mémoire vive? Car depuis le lancement (environ 2h) les ressources utilisées ont augmenté de 11Mo. Ou cela est une coïncidence?

Merci encore pour votre aide

[Invité]

Ce qui me recherche, une fois la limite dépassée, les prochaines dates... Je ne suis pas convaincu de la sûreté du code qui n'est pas au point, mais cela fonctionne

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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
class Program
    {
        class WednesdayTimer
        {
            private System.Timers.Timer timer;
            private DateTime dueDate;
 
            public WednesdayTimer(DateTime dueDate)
            {
                this.dueDate = dueDate;
                this.timer = new System.Timers.Timer(TimeSpan.FromMinutes(1).TotalMilliseconds);
                this.timer.Elapsed += this.timerElapsed;
                this.timer.AutoReset = false;
                this.timer.Enabled = true;
            }
 
            private void timerElapsed(object sender, System.Timers.ElapsedEventArgs e)
            {
                if (DateTime.Now < this.dueDate) return;
 
                this.timer.Stop();
                this.timer.Elapsed -= this.timerElapsed;
                this.timer.Dispose();
 
                // Ta logique ici.
            }
 
            public void Start()
            {
                this.timer.Start();
            }
        }
 
        static void Main(string[] args)
        {
            foreach (DateTime nextDate in nextWednesday)
            {
                TimeSpan triggerTime = new TimeSpan(20, 30, 0);
                DateTime nextWed = nextDate + triggerTime;
                WednesdayTimer wednesdayTimer = new WednesdayTimer(nextWed);
                nextWed.Start();
            }
        }
    }

Là ça évite de dépasser vu que je fixe l’intervalle à 1 minute et le code est plus propre à maintenir.

Par contre, les timers consomment de la mémoire vive? Car depuis le lancement (environ 2h) les ressources utilisées ont augmenté de 11Mo. Ou cela est une coïncidence?

Pense à libérer les ressources après que tu ais terminé une tâche.

Un excellent article qui pourrait t'intéresser.

[synolog]

Merci pour la simplification, et pour la lecture
Il est vrai que ton code est plus clair que le mien!!
Je vais m'en inspiré, Merci!

[Invité]

Tu pourrais même bien améliorer la performance de ton application. Comment ?
Vu que touts les mercredis ne tombent en même temps alors je me dis que le plus performant serait de démarrer le timer du mercredi suivant uniquement si le timer du mercredi courant est stoppé.

[synolog]

Tu pourrais même bien améliorer la performance de ton application. Comment ?
Vu que touts les mercredis ne tombent en même temps alors je me dis que le plus performant serait de démarrer le timer du mercredi suivant uniquement si le timer du mercredi courant est stoppé.

Oui, très bonne idée!
Je pense que j'ai de quoi faire pour arriver à mes fins!
Merci