Question

I am writing some kind of a wrapper for WCF calls (using BackgroundWorker) to keep GUI from freezing while the call is ongoing. It is working mostly as it should, but I have a problem with the BackgroundWorker when the WCF call is throwing an exception. If an exception occurs in DoWork, I am able to detect it in RunWorkCompleted, but rethrowing it to the GUI does not work. I have read numerous threads with people mentioning that this should work.

Code for the wrapper (notice that the WCF call is symbolized by an exception being thrown):

private void GetSomething(Action<IEnumerable<int>> completedAction)
{
    BackgroundWorker b = new BackgroundWorker();

    b.DoWork += (s, evt) => { throw new Exception(); evt.Result = new List<int> { 1, 2, 3 }; };

    b.RunWorkerCompleted += (s, evt) =>
    {
        if (evt.Error == null && completedAction != null)
        {
           completedAction((IEnumerable<int>)evt.Result);
        }
        else if(evt.Error != null)
        {
           throw evt.Error;
        }
    };

    b.RunWorkerAsync();
}

Invoking code in a Windows form:

private void button3_Click(object sender, EventArgs e)
{
    try
    {
        GetSomething(list =>
        {
           foreach (int i in list)
           {
              listView1.Items.Add(new ListViewItem(i.ToString()));
           }
        });
    }
    catch (Exception ex)
    {
        MessageBox.Show(ex.Message);
    }
}

While debugging this, I get:

1. “Exception of type ‘System.Exception’ was thrown” in DoWork
2. “Exception of type ‘System.Exception’ was thrown” at throw evt.Error
3. “TargetInvocationException was unhandled” at Application.Run(new Form1()) in the Main method

What am I doing wrong? I would like to catch the exception in the Windows form.

Answer 1

The event b.RunWorkerCompleted is where you should do the error handling. You can pass in an Action<Exception> to do the error handling like

private void GetSomething(Action<IEnumerable<int>> completedAction, Action<Exception> exceptionAction)
{
    BackgroundWorker b = new BackgroundWorker();

    b.DoWork += (s, evt) => { throw new Exception(); evt.Result = new List<int> { 1, 2, 3 }; };

    b.RunWorkerCompleted += (s, evt) =>
    {
        if (evt.Error == null && completedAction != null)
            completedAction((IEnumerable<int>)evt.Result);
        else if(evt.Error != null)
            exceptionAction(evt.Error);
    };

    b.RunWorkerAsync();
}

However this tends to get ugly. If you use .Net 4 or 4.5 you can resort to Tasks. The Task<TResult> was created for exactly that case:

Task<IEnumerable<int>> GetSomething()
{
    return Task.Factory.StartNew(() => { 
        Thread.Sleep(2000);
        throw new Exception(); 
        return (new List<int> { 1, 2, 3 }).AsEnumerable(); 
        });
}

Task basically is a signalling construct with

• a .Result property
• an .Exception property
• a .ContinueWith() method

Within ContinueWith() you can check if the Task in a faulted state (Exception got thrown).

You can use it like

    private void button3_Click(object sender, EventArgs e)
    {
        GetSomething()
            .ContinueWith(task =>
                {
                    if (task.IsCanceled)
                    {
                    }
                    else if (task.IsFaulted)
                    {
                        var ex = task.Exception.InnerException;
                        MessageBox.Show(ex.Message);
                    }
                    else if (task.IsCompleted)
                    {
                        var list = task.Result;
                        foreach (int i in list)
                        {
                            listView1.Items.Add(new ListViewItem(i.ToString()));
                        }
                    }
                });
    }

If you use .Net 4.5 and C#5 (you need VS2012 or VS2010 and the Async CTP) you can even resort to async and await like

    private async void button3_Click(object sender, EventArgs e)
    {
        try
        {
            var list = await GetSomething();
            foreach (int i in list)
            {
                listView1.Items.Add(new ListViewItem(i.ToString()));
            }
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message);
        }
    }

… and all the magic is done by the compiler. Note that you can use try catch as you are used to.