Configuring the continuation behaviour of a TaskCompletionSource's Task

Question

Consider the following code:

public Task SomeAsyncMethod()
{
    var tcs = new TaskCompletionSource();
    ... do something, NOT setting the TaskCompletionSource...

    return tcs.Task
}

public void Callsite1()
{
    await SomeAsyncMethod();
    Debug.WriteLine(Thread.CurrentThread.ManagedThreadId);
}

public void Callsite2()
{
    SomeAsyncMethod().ContinueWith((task) =>
    {
        Debug.WriteLine(Thread.CurrentThread.ManagedThreadId);
    });
}

At some point in time, the TaskCompletionSource created in SomeAsyncMethod is set on a ThreadPool Thread:

Debug.WriteLine(Thread.CurrentThread.ManagedThreadId);
tcs.SetResult();

When the Task from the TaskCompletionSource is awaited (as in Callsite1), the continuation executes synchronously on the Thread that called SetResult. When ContinueWith is called (as in Callsite2), the continuation executes asynchronously on a different thread.

It does not help to call configure the await, as in

public void Callsite1()
{
    await SomeAsyncMethod().ConfigureAwait(true or false);
}

and this is not even the point of this question. As the implementor of SomeAsyncMethod, I do not want to call some potentially unknown code by calling SetResult. I want to have the continuation always scheduled asynchronously. And I cannot rely on the caller to configure the await properly (if that would even work).

How can a TaskCompletionSource be configured such that its Task doesn't execute its continuation synchronously when it's awaited?

Stephen Cleary · Accepted Answer · 2012-10-04T02:32:09.880

12

There is no way to prevent synchronous task continuations. Normally, this is not a problem.

However, there are some situations where you do need this, e.g., if you are completing the task while holding a lock. In those cases, you can just Task.Run the task completion, as such:

// Set the result on a threadpool thread, so any synchronous continuations
//  will execute in the background.
Task.Run(() => tcs.TrySetResult(result));

// Wait for the TCS task to complete; note that the continuations
//  may not be complete.
tcs.Task.Wait();

This is an advanced technique. It is an exception to the guideline "Don't block on async code (async all the way down)" as expounded on my blog.

It's part of my AsyncEx library, as an extension method:

public static void TrySetResultWithBackgroundContinuations<TResult>(
    this TaskCompletionSource<TResult> @this, TResult result);

This technique was first published by Stephen Toub on his blog.

edited Oct 04 '12 at 02:32

answered Oct 02 '12 at 17:00

Stephen Cleary

437,863
77
675
810

You need to indicate that you are involved whenever you mention AsyncEx library as per: http://stackoverflow.com/faq#promotion - Please update your answers that mention this. Right now [I see 23 that should contain a disclaimer](http://stackoverflow.com/search?q=user%3A263693+url%3A%22http%3A%2F%2Fnitoasyncex.codeplex.com*%22&submit=search) (they may, or may not, but they all *should*). – casperOne Oct 03 '12 at 03:15
I see. Thanks for the blog post link. I wish the documentation on TaskCompletionSource.SetResult were clearer on this, it does not mention that the continuations might execute synchronously. Also, it might break existing code: Until now, I expected that changing the C# 4-"ContinueWith"-style to the await pattern everywhere would be only a syntactic change rather than a semantic one (I'm aware that await captures SynchronizationContext but that's not the issue here, SynchronizationContext is always that of ThreadPool, the continuation could as well execute on a different ThreadPool Thread). – Daniel C. Weber Oct 04 '12 at 07:17
Right. It's not an exact replacement - just a conceptually similar one. You may also find [this question](http://stackoverflow.com/questions/8767218/is-async-await-keyword-equivalent-to-a-continuewith-lambda) interesting. – Stephen Cleary Oct 04 '12 at 11:51

score 3 · Answer 2 · answered May 27 '16 at 20:52

As of .NET 4.6, TaskCreationOption.RunContinuationsAsynchronously was added for just this sort or case:

[It forces] continuations added to the current task to be executed asynchronously.

So, you can create a TaskCompletionSource with TaskCreationOptions.RunContinuationsAsynchronously and be sure that calling its .SetResult() won't synchronously execute random code.

var tcs = new TaskCompletionSource<bool>(
    TaskCreationOptions.RunContinuationsAsynchronously);

// some time later, somewhere else
tcs.SetResult(true);
DoMoreStuffWithoutWorryingThatSetResultJustRanRandomCode();

More details are available in Stephen Toub's blog post "New Task APIs in .NET 4.6".

When a Task created with this option completes, it won't even try to invoke continuations synchronously... it'll simply invoke all of the continuations asynchronously as if none had asked to be executed synchronously if possible.

There's also TaskContinuationOptions.RunContinuationsAsynchronously if you need similar behavior for things like .ContinueWith().

[TaskContinuationOptions.RunContinuationsAsynchronously specifies] that the continuation task should be run asynchronously. This option has precedence over TaskContinuationOptions.ExecuteSynchronously.

Which is bugged https://support.microsoft.com/en-us/help/3118695/runcontinuationsasynchronously-does-not-run-continuations-asynchronous Yay!!! — MoonStom, Jul 13 '17 at 17:02

score 2 · Answer 3 · answered Oct 02 '12 at 15:39

How can a TaskCompletionSource be configured such that its Task doesn't execute its continuation synchronously when it's awaited?

It can't be. You are exposing the Task publicly, and once you do that anyone is free to attach a synchronous continuation (they just need to use another overload of ContinueWith, they don't need to use async/await).

Configuring the continuation behaviour of a TaskCompletionSource's Task

3 Answers3

Linked