Discussion :

[bong03]

Bonjour,

Voici ce que je souhaite faire dans mon programme :

Mon programme, lors d'un clic sur un bouton, lance x programmes (x est un nombre aléatoire) et désactive des boutons.

Ensuite quand l'utilisateur à fermer (quitter) les x programmes lancés, mon programme reprend la main et réactive tous les boutons désactivés.

Sauf à faire, dans la procédure/méthode

Code :

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

private void OnBoutonClicker(object sender, EventArgs e)

, une boucle infinie attendant que tous les processus liés aux x programmes soient terminés, boucle qui consomme beaucoup de ressources... je ne vois pas comment faire autrement.

Avez-vous une idée ?

Voici une partie de mon code :

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
 
        private void GenererBouton(string nomBouton, int PosX, int PosY, int Larg, int Haut, bool Visibilite, int DimXEcran, int DimYEcran)
        {
            // Instanciation du bouton
            Button bouton = new System.Windows.Forms.Button
            {
                // Paramètres fixes du bouton
                Size = new System.Drawing.Size(Larg, Haut),
                Font = new System.Drawing.Font("Microsoft Sans Serif", 8.25F, FontStyle.Bold, GraphicsUnit.Point, ((byte)(0))),
 
                // Paramètres propres à chaque bouton
                Name = nomBouton,
                Text = nomBouton,
 
                // Position sur l'écran
                Top = PosY,
                Left = PosX,
 
                // Visibilité
                Visible = Visibilite,
 
                // Curseur souris
                Cursor = Cursors.Hand
            };
 
            // Fonction du bouton sur son event Click
            bouton.Click += OnBoutonClicker;
 
            // Ajoute le bouton sur la fenêtre (VuePrincipale)
            listeBoutons.Add(bouton);
            this.Controls.Add(bouton); 
        }
 
        // Méthode appelée lorsqu'on clique sur un bouton
        private void OnBoutonClicker(object sender, EventArgs e)
        {
            // Récupération du bouton sollicité
            Button bouton = (Button)sender;
 
            // Initialise les boutons
            foreach (Button b in listeBoutons)
            {
                b.BackColor = SystemColors.Control;
                b.Enabled = false;
            }
 
            // Mofdification de la couleur du bouton
            bouton.BackColor = Color.SkyBlue;
 
            // Test si un processus Supervis est en cours d'exécution
            Process[] liste = Process.GetProcessesByName(K_nomProcess);
            foreach (Process p in liste)
            {
                p.Kill(); //tuer tout les processus recupérés
            }
 
            // Lancer les applications correspondantes au bouton sollicité
            // On boucle s'il y a plusieurs programme à lancer
            // cheminAppli = répertoire contenant le nombre de fichiers bat à lancer chaque bat lance un programme .exe avec des paramètres
            string cheminAppli = @"C:\" + bouton.Name;
            DirectoryInfo Dossier = new DirectoryInfo(cheminAppli);
            FileInfo[] fichiers = Dossier.GetFiles("*.bat", SearchOption.TopDirectoryOnly);
            int nbFichiersBat = Dossier.GetFiles("*.bat", SearchOption.TopDirectoryOnly).Length - 1;
 
            if (nbFichiersBat < 0)
            {
                message = "Le dossier \"" + cheminAppli + "\" ne contient aucun fichier à exécuter (*.bat).\n\r";
                caption = "Erreur";
                MessageBox.Show(message, caption, MessageBoxButtons.OK, MessageBoxIcon.Error);
                return;
            }
 
            int i = 0;
            ProcessStartInfo[] prog = new ProcessStartInfo[fichiers.Length];
            Process[] monProcess = new Process[fichiers.Length];
            foreach (FileInfo file in fichiers)
            {
                prog[i] = new ProcessStartInfo(cheminAppli + file.ToString())
                {
                    CreateNoWindow = true,
                    UseShellExecute = false
                };
 
                // Déclaration d'un nouveau processus : permet de faire un monProcess.WaitForExit() si besoin et démarrage de l'application supervis.exe
                monProcess[i] = Process.Start(prog[i]);
                Thread.Sleep(500);
                i += 1;
            }
 
            //i = 0;
            //liste = Process.GetProcessesByName(K_nomProcess);
            //monProcess = new Process[liste.Length];
            //foreach (Process p in liste)
            //{
            //    monProcess[i].WaitForExit();
            //    i += 1;
            //}
 
            // Vérification si des programmes en cours d'exécution
            bool flag = true;
            while (flag)
            {
                // On reste dans la boucle tant que tous les programmes lancés ne sont pas fermés
                flag = false;
                liste = Process.GetProcessesByName(K_nomProcess);
                foreach (Process p in liste)
                {
                    flag = true;
                }
            }
 
            // Si tous les programmes on été fermés : réinitialiser les boutons
            MessageBox.Show("L'application de supervision " + bouton.Name + " a été fermée.", "Info", MessageBoxButtons.OK, MessageBoxIcon.Information);
 
            // Initialise les boutons
            foreach (Button b in listeBoutons)
            {
                b.BackColor = SystemColors.Control;
                b.Enabled = true;
            }
 
        }

[PixelJuice]

Bonjour,

Il y a peut-être une façon + propre de gérer mais, si tu fais une boucle while, pense toujours à mettre

Code :

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

Thread.Sleep(100); // en millisecondes

a la toute fin de ta boucle. Cela permet d'attendre quelques temps, afin que le programme n’exécute pas ton code autant que possible.

Essaye déjà ça, les performances seront déjà bien meilleurs. Si jamais ce n'est pas suffisant, on pourra toujours trouver une meilleure solution.

[Pol63]

c'est exactement ca, déjà avec thread.sleep(1) on voit la différence sur une boucle d'attente, mais ici 100 ms ou même un peu plus ca suffit (sans sleep tu vérifies plusieurs fois par milliseconde c'est inutile)


au passage

Code :

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

1
2
3
4
5
6
7
8
9
10
 while (flag)
            {
                // On reste dans la boucle tant que tous les programmes lancés ne sont pas fermés
                flag = false;
                liste = Process.GetProcessesByName(K_nomProcess);
                foreach (Process p in liste)
                {
                    flag = true;
                }
            }

ca équivaut à

Code :

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

1
2
3
4
while (Process.GetProcessesByName(K_nomProcess).Count() > 0)
            {
                thread.sleep(100);                
            }

[bong03]

Merci pour vos propositions.

J'avais déjà testé avec le Sleep mais ça ne me plait pas vraiment. Je pensais qu'il y avait une autre solution en utilisant pas exemple la propriété

Code :

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

HasExited

en combinaison avec d'autres commandes comme par exemple les abonnements (mais là c'est très flou pour moi).

J'ai pour le moment contourné le problème en ne lançant qu'un ou deux programmes au lieu de x.

[François DORIN]

La méthode la plus propre est de passer par l'événement Process.Exited.

En gros, tu auras une méthode qui sera appelée automatiquement lorsque le processus fils se terminera (que ce soit avec ou sans erreur).

[bong03]

La méthode la plus propre est de passer par l'événement Process.Exited.

En gros, tu auras une méthode qui sera appelée automatiquement lorsque le processus fils se terminera (que ce soit avec ou sans erreur).

Oui, mais là ou je bloque c'est sur le nombre aléatoire x d'application qui peut-être ouverte (pour le moment limité à 2) : je vois pas trop comment utiliser

Code :

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

Process.Exited

sans faire des if ou une boucle infinie...

[François DORIN]

Tu évites les boucles (pas les if). Dès qu'un programme ferme, tu vérifies s'il existe encore des programmes qui tourne. Si oui, tu ne fais rien. Si non, tu lances ton action.

[bong03]

Tu évites les boucles (pas les if). Dès qu'un programme ferme, tu vérifies s'il existe encore des programmes qui tourne. Si oui, tu ne fais rien. Si non, tu lances ton action.

OK, mais comment dans le code avoir un nombre aléatoire de if ??? car x programmes (x aléatoires) = x if, non ?

[François DORIN]

Pas besoin d'avoir plusieurs conditionnelles. Une seule suffit pour déterminer s'il y a des programmes qui tournent encore ou pas. 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
 
void CheckRunningProcess(Process[] processes)
{
   bool isRunning = false;
   foreach(Process process in processes)
   {
      if (!process.HasExited)
      {
         isRunning = true;
      }
   }
 
   if (!isRunning)
   {
     // Ton code à exécuter quand les programmes sont terminés.
   }
}

Et quand tu crées un processus, tu enregistres un délégué avant de le lancer :

Code :

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

1
2
3
4
 
monProcess[i] = new Process();
monProcess[i].Exited += (sender, object) => {CheckRunningProcess(monPrcess);};
monProcess[i].Start();

[bong03]

Ah...Ok je vais essayer.

Merci.

[bong03]

C'est bon, grâce à vous je m'en suis sorti.

Merci à tous !