Exécution synchrone d'un programme console dans une application C#

public static int UnArj (string arjFileName, string outputPath)
{
    int exitCode;
    CancelForm winStop = new CancelForm();

    // on utilise show et non showdialog pour que le processus se poursuive
    winStop.Show();
    ProcessStartInfo processInfo = new ProcessStartInfo(@"d:\Arj.exe");
    processInfo.WindowStyle = ProcessWindowStyle.Normal;
    processInfo.Arguments = "e -y " + arjFileName + " " + outputPath; 
    Process arjProcess = Process.Start(processInfo);

    // on boucle tant que le processus n'est pas terminé ou que l'on n'a pas 
    // demandé l'arrêt.
    while (! arjProcess.HasExited && ! winStop.Canceled)
    {
        // on attend la fin du processus pendant 100 millisecondes
        arjProcess.WaitForExit(100);
        // on traite la file des messages
        Application.DoEvents();
    }

    // on vérifie qu'un arrêt est demandé
    if (winStop.Canceled)
    {
        // on arrête le processus
        arjProcess.Kill();

        // on attend qu'il soit complètement arrêté
        arjProcess.WaitForExit();
    }

    // on ferme la fenêtre
    winStop.Close();
    exitCode =  arjProcess.ExitCode ;
    arjProcess.Close();
    return exitCode ;
}

public class Arj
{
    private CancelForm winStop;
    
    public int UnArj(string arjFileName, string outputPath)
    {
        int exitCode ;

        // affichage de la fenêtre d'arrêt
        winStop = new CancelForm();
        
        ProcessStartInfo processInfo = new ProcessStartInfo("Arj.exe");
        processInfo.WindowStyle = ProcessWindowStyle.Hidden;
        processInfo.Arguments = "e -y " + arjFileName + " " + outputPath; 
        Process arjProcess = new Process();
        arjProcess.StartInfo = processInfo;

        // on utilise l'événement pour savoir quand le processus est terminé
        arjProcess.EnableRaisingEvents = true;
        arjProcess.Exited += new System.EventHandler(this.arjEnded);
        arjProcess.Start();
        winStop.ShowDialog();

        // on vérifie si le processus est fini
        // Si ce n'est pas le cas, l'utilisateur a appuyé sur stop
        // et il faut fermer le processus
        if ( ! arjProcess.HasExited )
        {
            arjProcess.Kill();
            arjProcess.WaitForExit();
        }

        // après le close, les infos sur le processus ne seront plus
        // disponible. La mémoire allouée pour conserver ces infos
        // est rendue disponible
        exitCode = arjProcess.ExitCode;
        arjProcess.Close();
        return exitCode;
    }
    
    private void arjEnded(object sender, System.EventArgs e)
    {
        winStop.Close();
    }
}

// On récupère le code retourné par arj et on fait un traitement différencié.
// Pour l'exercice, on traite uniquement réussi ou échec, mais
// vous pouvez compléter le switch pour effectuer un traitement distinct
// pour chaque code d'erreur.
Arj arj = new Arj();
switch (arj.UnArj(@"d:\test.arj", @"d:\"))
{
    case -1:
        {
            MessageBox.Show("La décompression a été annulée par l'opérateur");
            break;
        }
    case 0:
        {
            MessageBox.Show("Décompression terminée.");
            break;
        }
    default:
        {
            MessageBox.Show("La décompression a échoué.");
            break;                
        }
}

public int UnArj(string arjFileName, string outputPath)
{
    int exitCode ;

    // affichage de la fenêtre d'arrêt
    winStop = new CancelForm();
    Timer timer = new Timer();
    timer.Interval = 50;
    timer.Tick += new EventHandler(readOutput);
    
    ProcessStartInfo processInfo = new ProcessStartInfo("Arj.exe");
    processInfo.Arguments = "e -y " + arjFileName + " " + outputPath; 

    // on déroute la sortie standard
    processInfo.UseShellExecute = false;
    processInfo.CreateNoWindow = true;
    processInfo.RedirectStandardOutput = true;

    arjProcess = new Process();
    arjProcess.StartInfo = processInfo;

    // on utilise l'événement pour savoir quand le processus est terminé
    arjProcess.EnableRaisingEvents = true;
    arjProcess.Exited += new System.EventHandler(this.arjEnded);

    arjProcess.Start();
    timer.Start();
    winStop.ShowDialog();

    // On vérifie si le processus est fini.
    // Si ce n'est pas le cas, l'utilisateur a appuyé sur stop
    // et il faut fermer le processus
    timer.Stop();
    if ( ! arjProcess.HasExited )
    {
        arjProcess.Kill();
        arjProcess.WaitForExit();
    }

    // Après le close, les infos sur le processus ne seront plus
    // disponible. La mémoire allouée pour conserver ces infos
    // est rendue disponible
    exitCode = arjProcess.ExitCode;
    arjProcess.Close();
    return exitCode;
}

private void readOutput(object sender, System.EventArgs e)
{
    if (! arjProcess.HasExited)
    {
        char[] buffer = new char[10];
        int ind = arjProcess.StandardOutput.Read(buffer,0,10);
        int i = ind - 1;
        bool notFound = true;
        char, car = '%';
        while (i>=0 && notFound)
        {
            if (buffer[i]==,car)
            {
                notFound=false;
            }
            else
            {
                i--;
            }
        }
        if (! notFound)
        {
            winStop.lblInfo.Text = 
                Convert.ToString(buffer[i-2])+Convert.ToString(buffer[i-1])+"%";
        }
    }
}

public int UnArj(string arjFileName, string outputPath)
{
    int exitCode ;

    // affichage de la fenêtre d'arrêt
    winStop = new CancelForm();

    // on crée le thread de lecture des infos
    Thread readInfo = new Thread(new ThreadStart(this.readOutput));
    
    ProcessStartInfo processInfo = new ProcessStartInfo("Arj.exe");
    processInfo.Arguments = "e -y " + arjFileName + " " + outputPath; 

    // on déroute la sortie standard
    processInfo.UseShellExecute = false;
    processInfo.CreateNoWindow = true;
    processInfo.RedirectStandardOutput = true;

    arjProcess = new Process();
    arjProcess.StartInfo = processInfo;

    // on utilise l'événement pour savoir quand le processus est terminé
    arjProcess.EnableRaisingEvents = true;
    arjProcess.Exited += new System.EventHandler(this.arjEnded);

    arjProcess.Start();

    // on démarre le thread de lecture
    readInfo.Start();

    // on affiche la fenêtre de dialogue
    winStop.ShowDialog();

    // On vérifie si le processus est fini.
    // Si ce n'est pas le cas, l'utilisateur a appuyé sur stop
    // et il faut fermer le processus. Le thread est fermé après l'arrêt 
    // du processus
    if ( ! arjProcess.HasExited )
    {
        arjProcess.Kill();
        arjProcess.WaitForExit();
    }

    // Après le close, les infos sur le processus ne seront plus
    // disponible. La mémoire allouée pour conserver ces infos
    // est rendue disponible
    exitCode = arjProcess.ExitCode;
    arjProcess.Close();
    return exitCode;
}

private void arjEnded(object sender, System.EventArgs e)
{
    winStop.Close();
}

private void readOutput()
{
    char[] buffer = new char[1];
    char car1 = ' ';
    char car2 = ' ';
    char, car = '%';
    while (! arjProcess.HasExited)
    {
        arjProcess.StandardOutput.Read(buffer,0,1);
        if (buffer[0] ==, car)
        {
            winStop.lblInfo.Text = 
                        Convert.ToString(car1)+Convert.ToString(car2) + "%";
        }
        car1 = car2;
        car2 = buffer[0];
    }
}