Discussion :

[shawn12]

Bonjour, je débute en C# et je voudrais dans un logiciel lancer plusieurs instances d'un exécutable qui écrit l'avancement de son exécution sur sa sortie d'erreur.

Voici ce que j'ai fait pour l'instant :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
            Process processus = new Process();
            ProcessStartInfo processusStartInfo = new ProcessStartInfo();
            processusStartInfo.FileName = commande;
            processusStartInfo.Arguments = arguments;
            processusStartInfo.UseShellExecute = false;
            processusStartInfo.RedirectStandardOutput = false;
            processusStartInfo.RedirectStandardError = true;
            processusStartInfo.CreateNoWindow = true;
            processus.StartInfo = processusStartInfo;
            // On définit un évènement pour intercepter ce qui est écrit par le processus
            processus.ErrorDataReceived += new DataReceivedEventHandler(Program.frmPrincipal.updateDownloadStatus);
            processus.Start();
            processus.BeginErrorReadLine();
            processus.Close();

J'aimerais pouvoir en lancer plusieurs et suivre leur état d'avancement simultanément.

J'aimerais associer à chaque processus un objet (qui existe déjà dans mon appli) pour indiquer ce qu'est le processus.

Pour stocker les processus que je lance, je peux les mettre dans une List mais comment associer un objet à chaque processus ?
J'avais aussi pensé à faire un Dictionnary<Processus, Objet> ce qui me permettrait dans mon DataReceivedEventHandler de retrouver facilement l'objet correspondant au processus qui a déclenché l'évènement.

Etant donné que je débute en C#, est-ce que quelqu'un peut m'indiquer quelle est la meilleure solution ?

[danuz]

Tu veux lancer plusieurs processus, et chaque processus dépend d'un objet.
L'idéal est de créer une méthode qui prend en paramètre un objet qui et qui en fonction de cet objet créé le processus adéquate.


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
20
21
22
23
24
 
public void RunProcess(object o) {
     Process p = new Process();
     ProcessStartInfo psi = new ProcessStartInfo();
     if(o is typeObjet1) {
          psi.FileName = commande pour objet 1;
          psi.Arguments = arguments pour objet 1;
     } else if (o is typeObjet2) (
          psi.FileName = commande pour objet 2;
          psi.Arguments = arguments pour objet 2;
     }
 
     psi.UseShellExecute = false;
     psi.RedirectStandardOutput = false;
     psi.RedirectStandardError = true;
     psi.CreateNoWindow = true;
     p.StartInfo = psi;
     // On définit un évènement pour intercepter ce qui est écrit par le processus
     p.ErrorDataReceived += 
new DataReceivedEventHandler(Program.frmPrincipal.updateDownloadStatus);
     p.Start();
     p.BeginErrorReadLine();
     p.Close();
}

Ce qu'il faut comprendre, c'est que le fait d’exécuter un processus est commun à chaque appel de processus que tu feras, chaque instance, donc, c'est le mieux de créer une méthode qui permettra d'en exécuter.

Ensuite, Si tes objets sont dans un tableau, tu fais une boucle sur ce tableau, et pour chaque item, tu appelles la méthode RunProcess créé précédemment en lui passant l'item en paramètre.

Code :

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

1
2
3
foreach(var item in tableauObjet) {
     RunProcess(item);
}

Si tes objets ne sont pas dans un tableau, tu n'as d'autres choix que de faire les appels manuellement

Code :

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

1
2
3
4
RunProcess(objet1);
RunProcess(objet2);
RunProcess(objet3);
etc...

En espérant que ça t'a éclairé,

Bon courage.

[ppphil]

Si tu veux lier un objet à chaque process, moi je ferais une classe qui hérite de Process

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class ProcessAndObj : Process
  {
    public object AnObject { get; set; }
 
    public ProcessAndObj(object anObject)
    {
      AnObject = anObject;
    }
 
    public void Run()
    {
      //fonction que tu as écrite pour lancer le process
    }
  }

Tu implémente la fonction Run comme ce que tu as fait plus haut.

La gestion des événement comme suit

Code :

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

1
2
3
4
5
6
7
void p_ErrorDataReceived(object sender, DataReceivedEventArgs e)
    {
      if (sender is ProcessAndObj)
      {
        (sender as ProcessAndObj).AnObject Tralalaitou........
      }
    }

Et pour la création de tes process, un truc comme ceci

Code :

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

1
2
3
4
5
6
7
8
9
 List<ProcessAndObj> listObj = new List<ProcessAndObj>();
      ProcessAndObj p;
 
      for (int i = 0; i < 10; i++)
      {
        p = new ProcessAndObj(monObject);
        p.Run();
        listObj.Add(p);
      }