使用库（dll）处理任务的异常

Question

I have a task which gets data using a data access library hooked up to a WCF service. layed out like so:

Data Access dll:

using (Service.ServiceClient client = new Service.ServiceClient(EndpointAddress))
{
    try
    {
        //Make my service call
        client.close()
        //return list
    }
    catch (FaultException fe)
    {
       client.Abort();
       throw fe;
    }
    catch (CommunicationException ce)
    {
        client.Abort();
        throw ce;
    }
    catch (TimeoutException te)
    {
        client.Abort();
        throw te;
    }
}

Main Program:

Task<List<Stuff>> loadOp = new Task<List<Stuff>>(() => dataAccessDllMethod());
loadOp.Start();
try
{
    loadOp.ContinueWith((Sender) =>
    {
        Sender.Result
    }
catch (Exception ex)
{
    //Notify User
    throw;
}

now my code keeps breaking in the lambda expression of the loadOp meaning the user never gets notified, but from what I've read this is the correct way of error handling in tasks. is this the correct way of doing this or is there a better way?

Answer 1

When you start a Task , in your case a Task<List<Stuff>> , you immediately get back the Task with a promise of it to finish sometime in the future, and your method continues execution , meaning it will finish the try block and exit. It doesn't block or wait for the Task to complete. There are a couple of things you may do:

1. Access Task.Result property which waits for the Result of the Task while blocking the thread.
2. Invoke Task.Wait() , which waits for the Task to complete also blocking the thread.
3. await on the Task , which doesn't block like the previous two, but yields control back to the caller, until the Task finishes execution . In order to be able to do that, the compiler generates a state machine which takes care of everything for us.
4. As Neel suggested, add a continuation which take care of the previous task faulting. Note that if you try to throw the exception to propogate it up the call stack it won't work unless someone accesses Result or Exception properties of the continued Task

What i would do instead of creating different continuations for success or failure, would simply await :

Task<List<Stuff>> loadOp = Task.Run<List<Stuff>>(() => dataAccessDllMethod());
try
{
    Task<List<Stuff>> loadOp = await Task.Run<List<Stuff>>(() => dataAccessDllMethod());

    // do stuff with the result
}
catch (Exception ex)
{
    //Notify User
    throw;
}

One last thing, the recommanded approach is to always use Task.Run or Task.Factory.Startnew when creating tasks so you accidentally forget to Start them and return a Cold Task which never executes (using new Task )

Answer 2

try below code I guess you don't require try catch you can directly write the code as shown below.. :-

 loadOp.ContinueWith((Sender) =>
        {
            ////this will be called on successful completion
            Sender.Result
        }, TaskContinuationOptions.OnlyOnRanToCompletion);

      loadOp.ContinueWith((Sender) =>
    {
        ////Notify user
        ////This will be called when error occures
        Sender.Result
    }, TaskContinuationOptions.OnlyOnFaulted);

The OnlyOnFaulted member of the TaskContinuationOptions enumeration indicates that the continuation should only be executed if the antecedent task threw an exception.