Visual C# GUI stops responding when process.WaitForExit(); is used

Question

I am creating a GUI application using Visual C# 2005 (net framework 2). I use the following code to start a process:

Process process = new Process();
process.StartInfo = new ProcessStartInfo("app.exe");
process.StartInfo.WorkingDirectory = "";
process.StartInfo.Arguments = "some arguments";
process.Start();
process.WaitForExit();

I want my application to wait until this process is finished, so I used WaitForExit. But the GUI Windows freezes while app.exe is running. I want it to respond (e.g. press a cancel button), but I don't want the code to continue, because there is another process to start after than. Thanks in advance!

score 5 · Accepted Answer · answered Nov 13 '09 at 09:21

5

You can capture the Exited event of the Process class:

void someMethod()
{
    //...possibly more code here
    Process process = new Process();
    process.StartInfo = new ProcessStartInfo("app.exe");
    process.StartInfo.WorkingDirectory = "";
    process.StartInfo.Arguments = "some arguments";
    process.Exited += new EventHandler(ProcessExited);
    process.Start();
}

void ProcessExited(object sender, System.EventArgs e)
{
  //Handle process exit here
}

answered Nov 13 '09 at 09:21

Konamiman

49,681
17
108
138

I tried that, but the code after process.Start(); is executed before app.exe finishes. – Nov 13 '09 at 09:32
I don't quite understand what you're trying to achieve. If you want ro run some other process, you have to do it asynchronously - handling proces.Exited as Konamiman suggested. If you use process.WaitForExit() you're running code synchronously, and therefore your application will freeze. – Bolek Tekielski Nov 13 '09 at 09:41
I want to run process 1. WHEN it exists I want process 2 to start. And the GUI not to freeze. – Nov 13 '09 at 13:53
Then, create and start process 1 in SomeMethod, then in the ProcessExited method, create and run process 2. – Konamiman Nov 13 '09 at 13:59
I thought of that before, if I don't find anything better I'll try it. The only problem is that I use a lot of "if" there, so it would be a little bit complicated. – Nov 13 '09 at 14:34

score 4 · Answer 2 · answered Nov 13 '09 at 09:25

Your waiting for the process on the only thread of your application that is also responsible for handling all GUI events. If you want to wait for some event (like some other process to finish) and still have your code notified of the event then you have to wait on another thread or use an event handler.

score 3 · Answer 3 · answered Nov 13 '09 at 09:38

This should help. Basically for windows forms and simple tasks like this, a BackgroundWorker is handy. Below is some simple code to launch notepad and wait for it to either close or the user can kill it by clicking cancel.

    public Form1()
    {
        InitializeComponent();
        backgroundWorker1.WorkerSupportsCancellation = true;
    }

    private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
    {
        Process process = new Process();
        process.StartInfo = new ProcessStartInfo("notepad.exe");
        process.Start();
        while (!process.HasExited)
        {
            if (backgroundWorker1.CancellationPending)
            {
                process.Kill();
                continue;
            }
            else
                Thread.Sleep(1000);
        }
    }

    private void Start_Click(object sender, EventArgs e)
    {
        backgroundWorker1.RunWorkerAsync();
    }

    private void Cancel_Click(object sender, EventArgs e)
    {
        backgroundWorker1.CancelAsync();
    }

I get an error: Thread does not exist in the current context. — , Nov 13 '09 at 10:01

score 2 · Answer 4 · answered May 24 '13 at 17:23

2

In order to receive a callback on Exited event, the EnableRaisingEvents must be set to true.

Process correctionProcess = Process.Start(startInfo);
correctionProcess.EnableRaisingEvents = true;
correctionProcess.Exited += new EventHandler(ProcessExited);

Using exited worked well for me and gave me great flexibility to either run sequentially, partially concurrently, or all at once - without locking the UI.

answered May 24 '13 at 17:23

shawn.mek

1,195
1
11
17

You saved me with EnableRisingEvents, Thank you so much! – Amr SubZero Aug 14 '15 at 06:28

score 1 · Answer 5 · edited May 23 '17 at 12:30

Perhaps you should implement a solution with the BackgroundWorker. It is easy to implement and does what you want.

What you have to do is add an instance of a BackgroundWorker in your form, and make the call to the Process running the App.exe from the BackgrondWorker RunWorkerAsync method. Then on you can monitor for a CancelationPending property to stop the process or RunWorkerCompleted event to perform whatever is necessary after the Process has exited.

There is another SO question, concerning the BackgroundWorker cancelation

score 0 · Answer 6 · answered Jul 05 '13 at 17:07

the solution for this is using a multi-threading start by adding:

using System.Threading;

then look at the code bellow :

    Process process = new Process();
    process.StartInfo = new ProcessStartInfo("app.exe");
    process.StartInfo.WorkingDirectory = "";
    process.StartInfo.Arguments = "some arguments";

//starts a new thread that starts the process so when you call WaitForExit it does not freez the main thread

    Thread th= new Thread(() =>
    {
        process.Start();
        process.WaitForExit();
    });
    th.Start();

if you want to run multiple process back to back it is another case you will need to use something like a List of process look at the code bellow

    List<Process> processes = new List<Process>();;

    Process process = new Process();
    process.StartInfo = new ProcessStartInfo("app.exe");
    process.StartInfo.WorkingDirectory = "";
    process.StartInfo.Arguments = "some arguments";

    processes.Add(process);

// i add another one manually but you can use a loop for exemple

    Process process2 = new Process();
    process.StartInfo = new ProcessStartInfo("app.exe");
    process.StartInfo.WorkingDirectory = "";
    process.StartInfo.Arguments = "some arguments";

    processes.Add(process2);

// then you will start them though your thread and the 2nd process will wait till the first finishes without blocking the UI

    Thread th= new Thread(() =>
    {
            for (int i = 0; i < processes.Count; i++)
            {
                    processes[i].Start();
                    processes[i].WaitForExit();
             }
    });
    th.Start();

Visual C# GUI stops responding when process.WaitForExit(); is used

6 Answers6

Linked