async Methods, Cancellation and Task Status

Question

Given a method signature like

Taks<int> ComputeAsync(..., CancellationToken cancellationToken)

, one would expect the returned task to complete as

• RanToCompletion (and the Resultset) or
• Faulted (and Exception set) or
• Canceled if the cancellationToken requested cancellation

When implementing the method as an async method, how can this be achieved?

By testing I found out that throwing an OperationCanceledException from within the async method apparently completes the task in the Canceled status (regardless of what token is wrapped in the exception, regardless even of whether the token IsCancellationRequested):

var tasks = new[]
{
    Task.FromResult(42),
    Task.FromException<int>(new Exception("Boom!")),
    Task.FromCanceled<int>(new CancellationToken(true)),
    Task.FromException<int>(new OperationCanceledException(new CancellationToken(true)))
};

async Task<int> Await(Task<int> task) => await task;

foreach (var t in tasks)
    Console.WriteLine($"{t.Status} - {Await(t).Status}");

Output:

RanToCompletion - RanToCompletion
Faulted - Faulted
Canceled - Canceled
Faulted - Canceled

However, I can't seem to find any documentation nor other information on the above behavior. Can it be relied upon across framework versions?

If the answer is yes, then cancellationToken.ThrowIfCancellationRequested() would do the right thing, but not catching OperationCanceledExceptions (probably from awaited tasks) could set the task Canceled although !cancellationToken.IsCancellationRequested. So in order to have predictable and correct outcomes, do we need to wrap every cancellable async method into a try/catch making sure no OCE is thrown unless it's on the right CancellationToken, or is there a more elegant way?

If the answer is no, then do we have to fall back to TaskCompletionSource stuff?

Answer 1

From your example - it is not clear on the intent of your cancellationToken use. So I will have to speak from my usage of it. We use Windows services and need to know if the OnStop event has been used. TokenSource object has the Cancel method to signal to the Task that we need to stop operations. The Token boolean value indicates that cancellation is requested. By Throwing the OperationCancelled - you can catch that value and handle it gracefully. It is all in the name of Synchronization of controlling the task. Your scenario would have the same need in some way if you are doing this. Addtional Note 7/16/2018:

You call out in your question a signature ( with correct spelling on Task)

Task<int> ComputeAsync(..., CancellationToken cancellationToken)

But your example - builds an array of tasks that does not use that signature in any of the tasks. Your example is too incomplete to give an answer. (It seems you are not understanding signature of a task). When you invoke a task with a cancellation token your task action is where that elipses is in your signature example - and you are not showing what you are passing into the task.

You are using Task.FromResult which says - Return this result.

If you use Visual Studio F12 on the 'FromResult' method you will see the source code with this comment which states

Summary:
    //     Creates a System.Threading.Tasks.Task`1 that's completed 
successfully with the
    //     specified result.

It is a complete mismatch to your question. Here is a stackoverflow answer on what the FromResult is for What is the use for Task.FromResult<TResult> in C#