Task.WhenAll for parallel execution in C Sharp (C#) - Time & Space Complexity

Time Complexity: Task.WhenAll for parallel execution

O(1)

Understanding Time Complexity

When running multiple tasks at the same time, it is important to understand how the total time grows as we add more tasks.

We want to know how the overall execution time changes when using Task.WhenAll to run tasks in parallel.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

async Task RunMultipleTasksAsync(List<Func<Task>> taskFactories)
{
    var tasks = taskFactories.Select(factory => factory()).ToList();
    await Task.WhenAll(tasks);
}
    

This code runs many tasks in parallel and waits for all of them to finish.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Starting each task once by calling each factory function.
• How many times: Once per task, so as many times as there are tasks (n).
• Parallel wait: Task.WhenAll waits for all tasks to complete simultaneously.

How Execution Grows With Input

When tasks run truly in parallel, the total time depends mostly on the longest single task, not the number of tasks.

Input Size (n)	Approx. Operations
10	Starts 10 tasks, waits for all to finish together.
100	Starts 100 tasks, still waits roughly as long as the longest task.
1000	Starts 1000 tasks, total wait time depends on longest task, not sum.

Pattern observation: Total wait time grows with the longest task duration, not with the number of tasks.

Final Time Complexity

Time Complexity: O(1)

This means the total waiting time does not increase as you add more tasks, assuming they run in parallel.

Common Mistake

[X] Wrong: "Adding more tasks always makes the program take longer because it waits for each one in order."

[OK] Correct: Task.WhenAll waits for all tasks at the same time, so the total time depends on the slowest task, not the number of tasks.

Interview Connect

Understanding how parallel tasks affect total time helps you write efficient programs and explain your reasoning clearly in interviews.

Self-Check

"What if the tasks are not truly parallel but run one after another? How would the time complexity change?"

Practice

1.

What does Task.WhenAll do in C#?

easy

A. Runs multiple tasks at the same time and waits for all to finish

B. Runs tasks one after another in sequence

C. Cancels all running tasks immediately

D. Runs only the first task and ignores others

Solution

1. Step 1: Understand Task.WhenAll purpose

   Task.WhenAll is designed to run multiple tasks in parallel and wait until all complete.

2. Step 2: Compare options with behavior

   Only Runs multiple tasks at the same time and waits for all to finish correctly describes running tasks simultaneously and waiting for all to finish.

3. Final Answer:

   Runs multiple tasks at the same time and waits for all to finish -> Option A

4. Quick Check:

   Task.WhenAll = parallel run and wait [OK]

Hint: Think: all tasks run together and wait for all done [OK]

Common Mistakes:

• Thinking tasks run one by one
• Believing it cancels tasks
• Assuming it runs only one task

2.

Which of the following is the correct syntax to wait for multiple tasks task1 and task2 to complete using Task.WhenAll?

?

easy

A. await Task.WhenAll{task1, task2};

B. await Task.WhenAll(task1, task2);

C. await Task.WhenAll[task1, task2];

D. await Task.WhenAll();

Solution

1. Step 1: Recall Task.WhenAll syntax

   Task.WhenAll takes tasks as parameters inside parentheses and returns a Task to await.

2. Step 2: Check each option's syntax

   Only await Task.WhenAll(task1, task2); uses parentheses correctly and awaits the combined task.

3. Final Answer:

   await Task.WhenAll(task1, task2); -> Option B

4. Quick Check:

   Correct syntax uses parentheses () [OK]

Hint: Use parentheses () to pass tasks to WhenAll [OK]

Common Mistakes:

• Using square brackets [] instead of parentheses
• Using curly braces {} incorrectly
• Using angle brackets <> wrongly

3.

What will be the output of this C# code?

using System;
using System.Threading.Tasks;

class Program {
    static async Task Main() {
        Task<int> t1 = Task.FromResult(5);
        Task<int> t2 = Task.FromResult(10);
        int[] results = await Task.WhenAll(t1, t2);
        Console.WriteLine(string.Join(",", results));
    }
}

medium

A. Compilation error

B. 10,5

C. 5,10

D. Task[]

Solution

1. Step 1: Understand Task.FromResult and Task.WhenAll

   Task.FromResult creates completed tasks with values 5 and 10. Task.WhenAll waits and returns results as an int array.

2. Step 2: Check output of Console.WriteLine

   Results array contains [5, 10], so joining with comma prints "5,10".

3. Final Answer:

   5,10 -> Option C

4. Quick Check:

   Task.WhenAll returns array of results [OK]

Hint: Task.WhenAll returns array of results in order [OK]

Common Mistakes:

• Assuming results are reversed
• Expecting a string instead of array
• Thinking code causes error

4.

Identify the error in this code snippet using Task.WhenAll:

async Task RunTasks() {
    var t1 = Task.Delay(1000);
    var t2 = Task.Delay(2000);
    Task.WhenAll(t1, t2);
    Console.WriteLine("Done");
}

medium

A. Missing await before Task.WhenAll, so tasks run but not waited

B. Task.Delay cannot be used with Task.WhenAll

C. Console.WriteLine should be inside Task.WhenAll

D. Task.WhenAll requires a list, not separate tasks

Solution

1. Step 1: Check usage of Task.WhenAll

   Task.WhenAll returns a Task that must be awaited to wait for all tasks to finish.

2. Step 2: Identify missing await

   Code calls Task.WhenAll but does not await it, so "Done" prints immediately before delays finish.

3. Final Answer:

   Missing await before Task.WhenAll, so tasks run but not waited -> Option A

4. Quick Check:

   Always await Task.WhenAll to wait [OK]

Hint: Always await Task.WhenAll to wait for tasks [OK]

Common Mistakes:

• Not awaiting Task.WhenAll
• Thinking Task.Delay can't be used
• Misplacing Console.WriteLine

5.

You want to run three tasks that return strings: Task<string> t1, t2, and t3. You want to get all results as a list of strings after all finish. Which code correctly does this?

hard

A. var list = await Task.WhenAll(new List { t1, t2, t3 });

B. var list = await Task.WhenAll(t1, t2, t3).ToList();

C. var list = Task.WhenAll(t1, t2, t3).Result.ToList();

D. var results = await Task.WhenAll(t1, t2, t3); var list = results.ToList();

Solution

1. Step 1: Understand Task.WhenAll return type

   Task.WhenAll returns a string array when awaited on Task<string> tasks.

2. Step 2: Convert array to list correctly

   var results = await Task.WhenAll(t1, t2, t3); var list = results.ToList(); awaits Task.WhenAll, then converts the array to a list using ToList(), which is correct.

3. Final Answer:

   var results = await Task.WhenAll(t1, t2, t3); var list = results.ToList(); -> Option D

4. Quick Check:

   Await Task.WhenAll then convert array to list [OK]

Hint: Await Task.WhenAll first, then convert results to list [OK]

Common Mistakes:

• Trying to call ToList() before awaiting
• Using .Result causing blocking
• Passing list directly without awaiting