Are there any restrictions of nested Task.WhenAll?

Question

Let's imagine some abstract code

    private void Main()
    {
        var workTask1 = DoWork1();
        var workTask2 = DoWork2();
        var workTask3 = DoWork3();

        await Task.WhenAll(workTask1, workTask2, workTask3);

        AnalyzeWork(workTask1.Result, workTask2.Result, workTask3.Result);
    }

    private async Task<object> DoWork1()
    {
        var someOperationTask1 = someOperation1();
        var someOperationTask2 = someOperation2();

        await Task.WhenAll(someOperationTask1, someOperationTask2);

        return new object
        {
            SomeOperationResult1 = someOperationTask1.Result,
            SomeOperationResult2 = someOperationTask2.Result,
        };
    }

    private async Task<object> DoWork2()
    {
        var someOperationTask3 = someOperation3();
        var someOperationTask4 = someOperation4();

        await Task.WhenAll(someOperationTask3, someOperationTask4);

        return new object
        {
            SomeOperationResult3 = someOperationTask3.Result,
            SomeOperationResult4 = someOperationTask4.Result,
        };
    }

    private async Task<object> DoWork3()
    {
        var someOperationTask5 = someOperation5();
        var someOperationTask6 = someOperation6();

        await Task.WhenAll(someOperationTask5, someOperationTask6);

        return new object
        {
            SomeOperationResult5 = someOperationTask5.Result,
            SomeOperationResult6 = someOperationTask6.Result,
        };
    }

Where 3 methods are being run parallelly and each of them consists of 2 parallel's operations. And result of 3 methods is passed to some method.

My question is there are any restrictions? Is it ok to have nested Task.WhenAll and what's difference between nested Task.WhenAll and one level Task.WhenAll operations?

Answer 1

The only restrictions are the available memory of your system. The Task.WhenAll method attaches a continuation to each incomplete task, and this continuation is detached when that task completes. A continuation is a lightweight object similar to a Task. It's quite similar to what you get when you invoke the Task.ContinueWith method. Each continuation weights more or less about 100 bytes. It is unlikely that it will have any noticeable effect to your program, unless you need to Task.WhenAll tens of millions of tasks (or more) at once.

If you want a visual demonstration of what this method looks like inside, below is a rough sketch of its implementation:

// For demonstration purposes only. This code is full of bugs.
static Task WhenAll(params Task[] tasks)
{
    var tcs = new TaskCompletionSource();
    int completedCount = 0;
    foreach (var task in tasks)
    {
        task.ContinueWith(t =>
        {
            completedCount++;
            if (completedCount == tasks.Length) tcs.SetResult();
        });
    }
    return tcs.Task;
}