Run function after Thread has finished running

Question

I'm trying to run a function after a thread has completed running. My thread starts when an UI button is pressed and the thread takes a while to complete.
Once it's done running I want to call a function. Here is the code I tried so far. When I try to run my code the thread never executes and the application freezes. Any suggestion on how to fix this would be helpful.

public bool StartProbe()
{
    if (File.Exists(Path.Combine(ObsProbeFolder, "probePJM.exe")))
    {
        ThreadStart ProbeThreadStart = new ThreadStart(() =>
        // right side of lambda    
            {
               // does stuff
            });

            ProbeThread = new Thread(ProbeThreadStart);
            ProbeThread.Priority = ThreadPriority.BelowNormal;
            ProbeThread.SetApartmentState(ApartmentState.STA);
            ProbeThread.Start();

    }
    else
    {                      
        return false;
    }

    // waiting for thread to finish 
    ProbeThread.Join();
    // run a function
    loadData();

    return true;
}

I initially tired it without a for loop, but it was still giving me the same problem. So I tired it with a for loop to see if it would fix, but it didn't. — Satish, Feb 10 '17 at 15:15
The application freezes when you do a `someThread.Join();` on the UI thread, since the UI thread will block until the other thread has stopped. — Maarten, Feb 10 '17 at 15:16
To follow up what Maarten said, I recommend you look at async/await methods as they've been designed for this use case. — DiplomacyNotWar, Feb 10 '17 at 15:17
@mjhouseman the reason why I can't use a BackgroundWorker is because the Thread modifies some of the data in the UI. — Satish, Feb 10 '17 at 15:21
@Satish You can use the object's Dispatcher's invoke method to access the UI element you need to change (from within Worker_DoWork) — mjhouseman, Feb 10 '17 at 15:27

score 0 · Answer 1 · answered Feb 10 '17 at 15:23

0

I would use a BackgroundWorker:

Worker = new BackgroundWorker();
            Worker.RunWorkerCompleted += Worker_RunWorkerCompleted;
            Worker.DoWork += Worker_DoWork;

            Worker.RunWorkerAsync(new BackgroundArguments()
            {
                // arguments
            });

Work on alternate thread:

private void Worker_DoWork(object sender, DoWorkEventArgs e)
{       
    // do stuff
}

Return to UI thread:

private void Worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
    {
       // load data or whatever on UI thread
    }

answered Feb 10 '17 at 15:23

mjhouseman

154
2
18

Why use such an old structure as BackgroundWorker, if you can use TPL and/or await? – VMAtm Feb 10 '17 at 19:17
There is nothing wrong with using BackgroundWorker, especially for a single process such as the user described. I agree that TPL is better for running multiple processes, but for a single process they are virtually interchangeable. – mjhouseman Feb 13 '17 at 20:30

score 0 · Answer 2 · edited May 23 '17 at 10:29

Do not use the BackgroundWorker - it's quite an old class, which, I hope, will be called obsolete someday by MS.

As you say, that you have a button, create an async void event handler for fire-and-forget scenario. As you do check some exe file, I assume that you're running some Process in background. Also, you do not need a thread to run your process - you're joining it and that's why the UI is hanging.

private async void button_Click(object sender, EventArgs e)
{
    // wait for a result from outer process
    var result = await RunProcessInBackGround();
    //do whatever you need in the UI-context
    loadData(result);
}

// T is a type of the result, should be changed
private async Task<T> RunProcessInBackGround()
{
    var tcs = new TaskCompletionSource<T>();
    // run your process
    var process  new Process {/* your params here */};
    process.Exited += (sender, args) =>
        {
            // here your process has already done his job
            tcs.SetResult(result);
            process.Dispose();
        };
    // process will start as a separate process, no need to create a thread to wait for it
    process.Start();
    // return the task which will be awaited for
    return tcs.Task;
}

Run function after Thread has finished running

2 Answers2