我应该使用常规任务还是延续任务？

Question

Suppose the following method is defined:

Task<TResult> DoStuffAsync() 
{
    // ...
}

Consider the following code (snippet 1):

void MyFunction()
{
    Task<TResult> task = DoStuffAsync();
    task.ContinueWith(async () => {
        TResult result = await task;
        // do stuff with result
    });
    // poll `task` status...
}

in comparison to the following code (snippet 2):

void MyFunction() 
{
    Task<TResult> task = DoStuffAsync();
    Task.Run(async () => {
        TResult result = await task;
        // do stuff with result
    });
    // poll `task` status...
}

(Note how I do not care about the status of the lambda function (fire-and-forget). But I do care if it raises any exceptions.)

The first difference between the two options seems clear: in (snippet 1) the code in the lambda will only begin execution after DoStuffAsync() has completed, whereas in (snippet 2) the code in the lambda will attempt to begin execution immediately and proceed when DoStuffAsync() has completed.

However, apart from this difference, when should you use ContinueWith and when should you use Task.Run ? What happens if an exception is raised in DoStuffAsync() or in the lambda function? Will it be swallowed or is every potential exception guaranteed to be raised to a block where it can be handled?

Answer 1

In your first case there's no need for the lambda to be async . There is no need to await the task. You can just use Result because you know that the task has already completed by that point in time.

For your second example, you're scheduling the thread pool thread to perform the creation of a state machine that will merely schedule some code to run when the task finishes. There's no real need for this at all. The Task.Run is adding nothing here.

Most likely the method itself should be an async method:

private async Task MyFunction() {
    var result = await DoStuffAsync();
    // do stuff with result
}

All that said, while both of your solutions have a lot of superfluous work, both will propagate exceptions from your underlying work to the tasks that each operation computes (although you don't store that task anywhere in your first example, so you have no way of inspecting that task to see if it faulted).