C# Chained ContinueWith Not Waiting for Previous Task to Complete

Question

I am testing the asynchronousity of C# async/await and came across a surprise where the subsequent code for ContinueWith does not wait for the previous task to complete:

public async Task<int> SampleAsyncMethodAsync(int number,string id)
  {
            Console.WriteLine($"Started work for {id}.{number}");
            ConcurrentBag<int> abc = new ConcurrentBag<int>();

            await Task.Run(() => { for (int count = 0; count < 30; count++) { Console.WriteLine($"[{id}] Run: {number}"); abc.Add(count); } });

            Console.WriteLine($"Completed work for {id}.{number}");
            return abc.Sum();
        }

Which is executed with the below test method:

        [Test]
        public void TestAsyncWaitForPreviousTask()
        {
            for (int count = 0; count < 3; count++)
            {
                int scopeCount = count;

                var c = SampleAsyncMethodAsync(0, scopeCount.ToString())
                .ContinueWith((prevTask) =>
                {
                    return SampleAsyncMethodAsync(1, scopeCount.ToString());
                })
                .ContinueWith((prevTask2) =>
                {
                    return SampleAsyncMethodAsync(2, scopeCount.ToString());
                });
            }
        }

The output shows execution for runs 0.0,1.0 and 2.0 executes asynchronously correctly but subsequent x.1 and x.2 get started almost immediately and x.2 actually completes before x.1. E.g. as logged below:

[2] Run: 0
[2] Run: 0
[2] Run: 0
Completed work for 2.0
Started work for 0.1
Started work for 0.2  <-- surprise!
[0] Run: 2
[0] Run: 2
[0] Run: 2
[0] Run: 2
[0] Run: 2

It seems the continueWith will only wait on the first task (0) regardless of subsequent chains. I can solve the problem by nesting the second ContinueWith within the first Continuewith block.

Is there something wrong with my code? I'm assuming Console.WriteLine respects FIFO.

[`ContinueWith` is an extremely low-level plumbing method](http://blog.stephencleary.com/2013/10/continuewith-is-dangerous-too.html). You should use `await` instead of `ContinueWith`. — Stephen Cleary, Sep 15 '17 at 12:31

Yeldar Kurmangaliyev · Accepted Answer · 2017-09-15T09:37:43.110

In short, you expect ContinueWith to wait for a previously returned object. Returning an object (even a Task) in ContinueWith action does nothing with returned value, it does not wait for it to complete, it returns it and passes to the continuation if exists.

The following thing does happen:

You run SampleAsyncMethodAsync(0, scopeCount.ToString())
When it is completed, you execute the continuation 1:
```
return SampleAsyncMethodAsync(1, scopeCount.ToString());
```
and when it stumbles upon await Task.Run, it returns a task. I.e., it does not wait for SampleAsyncMethodAsync to complete.
Then, continuation 1 is considered to be completed, since it has returned a value (task)
Continuation 2 is run.

If you wait for every asynchronous method manually, then it will run consequently:

for (int count = 0; count < 3; count++)
{
    int scopeCount = count;

    var c = SampleAsyncMethodAsync(0, scopeCount.ToString())
    .ContinueWith((prevTask) =>
    {
        SampleAsyncMethodAsync(1, scopeCount.ToString()).Wait();
    })
    .ContinueWith((prevTask2) =>
    {
        SampleAsyncMethodAsync(2, scopeCount.ToString()).Wait();
    });
}

Using ContinueWith(async t => await SampleAsyncMethodAsync... doesn't work as well, since it results into wrapped Task<Task> result (explained well here).

Also, you can do something like:

for (int count = 0; count < 3; count++)
{
    int scopeCount = count;

    var c = SampleAsyncMethodAsync(0, scopeCount.ToString())
        .ContinueWith((prevTask) =>
        {
            SampleAsyncMethodAsync(1, scopeCount.ToString())
                .ContinueWith((prevTask2) =>
                {
                    SampleAsyncMethodAsync(2, scopeCount.ToString());
                });
        });   
}

However, it creates some sort of callback hell and looks messy.

You can use await to make this code a little cleaner:

for (int count = 0; count < 3; count++)
{
    int scopeCount = count;

    var d = Task.Run(async () => {
        await SampleAsyncMethodAsync(0, scopeCount.ToString());
        await SampleAsyncMethodAsync(1, scopeCount.ToString());
        await SampleAsyncMethodAsync(2, scopeCount.ToString());
    });
}

Now, it runs 3 tasks for 3 counts, and each task will consequently run asynchronous method with number equal to 1, 2, and 3.

Yes, the behaviour of the ContinueWith does confirm that behaviour but MSDN states the method returns a new Continuation Task. https://msdn.microsoft.com/en-us/library/dd270696(v=vs.110).aspx — TropicalFruitz, Sep 15 '17 at 08:54
@TropicalFruitz Ok, now I see what you mean and you are right. `ContinueWith` does return a completely new task. It looks like it is somehow related to using `async`. Making `SampleAsyncMethodAsync` not async does make your code run correclty. Very interesting, I will update my answer if I understand it or remove it. — Yeldar Kurmangaliyev, Sep 15 '17 at 09:16
@TropicalFruitz Could you please see the updated answer. I cannot explain it well :( — Yeldar Kurmangaliyev, Sep 15 '17 at 09:37
No worries. I think I understood it. So it looks like ContinueWith returns Task of Task and therefore the Unwrap function is required to get to the bottom task else the subsequent ContinueWith is still applied on the first Task object. It explains the strange unexpected behaviour. Thanks for the help and link! — TropicalFruitz, Sep 15 '17 at 09:54

C# Chained ContinueWith Not Waiting for Previous Task to Complete

1 Answers1

Linked