Serializing async task and async continuation

Your original code is not working because the async lambda is being translated into an async void method underneath, which has no built-in way to notify any other code that it has completed. So, what you're seeing is the difference between async void and async Task. This is one of the reasons that you should avoid async void.

That said, if it's possible to do with your code, use Task.Run instead of the Task constructor and Start; and use await rather than ContinueWith:

var task = Task.Run(async () =>
{
  DebugLog("TASK Starting");
  await Task.Delay(1000);     // actual work here
  DebugLog("TASK Finishing");
});
await task;
DebugLog("CONTINUATION Starting");
await Task.Delay(100);      // actual work here
DebugLog("CONTINUATION Ending");

Task.Run and await work more naturally with async code.

• -1: The original code is not working because it does not use the Unwrap() method where necessary. The creation of an async void lambda is certainly not desired, but also nothing more than a side-effect of failing to use new Task<Task>(...) so the Unwrap() would work. - Sam Harwell
• @280Z28: Yes, the original code could be hacked to use new Task<Task> and Unwrap; however, the new code would work because it would avoid an async void lambda. And it still wouldn't be as good as a Task.Run-based solution. - Stephen Cleary
• +1 I ended up using Task.Run and the original continuation. Thank you for the insight into why my existing code doesn't work: that the lambda becomes async void. Of course everything made a lot more sense when you said that. So why am I using the continuation? Well, it is too much to try to explain here although it has a lot to do with this question. - chue x

You shouldn't be using the Task constructor directly to start tasks, especially when starting async tasks. If you want to offload work to be executed in the background use Task.Run instead:

var task = Task.Run(async () =>
{
    DebugLog("TASK Starting");
    await Task.Delay(1000);     // actual work here
    DebugLog("TASK Finishing");
});

About the continuation, it would be better to just append it's logic to the end of the lambda expression. But if you're adamant on using ContinueWith you need to use Unwrap to get the actual async task and store the it so you could handle exceptions:

task = task.ContinueWith(async (x) =>
{
    DebugLog("CONTINUATION Starting");
    await Task.Delay(100);      // actual work here
    DebugLog("CONTINUATION Ending");
}).Unwrap();

try
{
    await task;
}
catch
{
    // handle exceptions
}

• +1 Thank you, Task.Run is what I needed. I never considered it because the MSDN continuation examples that I saw like this one use new Task. I am accepting Stephen's answer because he explains why my code above doesn't work: my initial task lambda becomes an async void instead of async Task. So why am I using the continuation? Well, it is too much to try to explain here although it has a lot to do with this question. - chue x

Change your code to

        // Setup task and continuation
        var t1 = new Task(() =>
        {
            Console.WriteLine("TASK Starting");
            Task.Delay(1000).Wait();     // actual work here
            Console.WriteLine("TASK Finishing");
        });

        var t2 = t1.ContinueWith((x) =>
        {
            Console.WriteLine("C1");
            Task.Delay(100).Wait();      // actual work here
            Console.WriteLine("C2");
        });

        t1.Start();

        // Exception will be swallow without the line below
        await Task.WhenAll(t1, t2);

• I usually try to avoid the use of Wait because it blocks the executing thread, and it could potentially cause the thread to deadlock. See this post for more information about the deadlocks. The post uses Result instead of Wait, but both block the executing thread and both potentially cause deadlocks. - chue x