I’ve had a couple of problems recently, where I’ve had tasks or asynchronous methods and they don’t quote fit into the architecture that I find myself in. I’d come across the TaskCompletionSource before, but hadn’t realised how useful it was. Basically, a TaskCompletionSource allows you to control when a task finishes; and allows you to do so in a synchronous, or asynchronous fashion. What this gives you is precise control over when an awaited task finishes.
UWP
Consider the following code in UWP. Basically, what this does is execute an anonymous function on the UI thread:
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, async () =>
{
await MyAyncFunc();
}
System.Diagnostics.Debug.WriteLine("After MyAsyncFunc");
The problem here is that executing an anonymous async function in the above scenario doesn’t work. However, using the TaskCompletionSource, we can bypass that whole conversation:
TaskCompletionSource<bool> tcs = new TaskCompletionSource<bool>();
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, async () =>
{
await MyAyncFunc();
System.Diagnostics.Debug.WriteLine("After MyAsyncFunc");
tcs.SetResult(true);
});
await tcs.Task;
Now the function will return when the the TaskCompletionSource.SetResult has been called.
Event based
The second scenario where this is useful is where you are trying to use an event based architecture within an async / await scenario. The following example is a little contrived, but it does illustrate the point:
class Program
{
private static Timer \_tmr = new Timer();
private static TaskCompletionSource<bool> \_tcs;
static void Main(string[] args)
{
var tmr = StartTimer();
Console.WriteLine("Before wait...");
tmr.Wait();
Console.WriteLine("After wait...");
}
private static async Task StartTimer()
{
\_tmr.Interval = 3000;
\_tmr.Elapsed += \_tmr\_Elapsed;
\_tmr.Start();
\_tcs = new TaskCompletionSource<bool>();
await \_tcs.Task;
}
private static void \_tmr\_Elapsed(object sender, ElapsedEventArgs e)
{
\_tcs.SetResult(true);
}
}
Potentially, a more real world example of this is when you might want to wrap an API in an async/await.
Control over exactly when a task finishes, and the ability to await async void methods
The final scenario where this can be useful is where you either want to await an `async void` method, or where you have a specific part of a method or process that you want to await.
The following code illustrates how to effectively await an async void method:
class Program
{
private static TaskCompletionSource<bool> \_tcs;
static void Main(string[] args)
{
\_tcs = new TaskCompletionSource<bool>();
BackgroundFunction();
\_tcs.Task.Wait();
Console.WriteLine("Done");
}
private static async void BackgroundFunction()
{
for (int i = 1; i <= 10; i++)
{
Console.WriteLine($"Processing: {i}");
await DoStuff();
}
\_tcs.SetResult(true);
}
private static async Task DoStuff()
{
await Task.Delay(500);
}
}
Finally, here is a parallel for loop:
static void Main(string[] args)
{
Parallel.For(1, 3, (i) =>
{
BackgroundFunction();
});
Console.WriteLine("Done");
}
Imagine that BackgroundFunction is performing a long running task where a specific condition needs to return control. There are obviously combinations of functions in the TPL (WaitAll, WhenAll, WhenAny and WhenAll), however, these rely on the whole task, or a set of tasks, completing. Again, the below example is contrived, but it illustrates the granular control over the task that you have.
static void Main(string[] args)
{
\_tcs = new TaskCompletionSource<bool>();
for (int i = 1; i <= 2; i++)
{
BackgroundFunction();
}
\_tcs.Task.Wait();
Console.WriteLine("Done");
}
private static async void BackgroundFunction()
{
for (int i = 1; i <= 10; i++)
{
Console.WriteLine($"Processing: {i}");
await DoStuff();
if (i == 7)
{
\_tcs.TrySetResult(true);
return;
}
}
}
I will re-iterate again, I realise that in the above example, there are better ways to achieve this, and the example is purely for illustration.
Conclusion
Generally speaking, the simplest and most robust code comes from using the task architecture in the way it was designed: that is, use async / await inside a method that returns a Task. I’m not suggesting in this post that the methods I’ve described should replace that; but there are situations where that might not fit.
Aknowledgements
I used the following posts heavily while writing this:
Awaiting the CoreDispatcher The Nature of TaskCompletionSource Real life scenarios for using TaskCompletionSource? Task Parallelism