Question

Following this question, I am trying to implement an async method using the TPL, and trying to follow TAP guidelines.

I want my async method to perform a callback when it’s finished. As far as I can see there are three ways I can do this.

1) Callback manually in my task delegate

public Task DoWorkAsync(DoWorkCompletedCallback completedCallback)
{
    return Task.Factory.StartNew(
    { 
        //do work

        //call callback manually
        completedCallback();
    });
}

2) Assign callback to task in task delegate

public Task DoWorkAsync(DoWorkCompletedCallback completedCallback)
{
    return Task.Factory.StartNew(
    { 
        //do work
    }
    ).ContinueWith(completedCallback); //assign callback to Task
}

3) Assign callback to task in caller

public Task DoWorkAsync()
{
    return Task.Factory.StartNew(
    { 
        //do work
    });
}

public void SomeClientCode()
{
    Task doingWork = DoWorkAsync();
    doingWork.ContinueWith(OnWorkCompleted);
}

My gut feeling is that 3 is more correct, because it decouples the callback from the method, and means that client code can manage the task any way it sees fit (using callbacks, polling etc), which seems to be what Tasks are all about. However, what happens if DoWorkAsync() completes its work before the client code hooks up its callback?

Is there a generally accepted way to do this or is it all too new?

Is there any advantage of doing 2) over 1)?

Answer 1

The generally accepted way is 3.

Users of TPL generally know that they can continue a Task with ContinueWith. 1 and 2 provide the same functionality, but with a non-standard interface; the user has to figure out what the delegate parameter means and what to pass e.g. if they don’t want to continue — all that while the method still returns a Task that can be continued in the standard way.