Task.WhenAll for parallel execution in C Sharp (C#) - Step-by-Step Execution

Concept Flow - Task.WhenAll for parallel execution

Start multiple tasks

↓

Tasks run in parallel

↓

Wait for all tasks to complete

↓

Continue after all tasks finish

Start several tasks at once, let them run at the same time, then wait until all are done before moving on.

Execution Sample

C Sharp (C#)

async Task Example()
{
  var task1 = Task.Delay(1000);
  var task2 = Task.Delay(2000);
  await Task.WhenAll(task1, task2);
  Console.WriteLine("All done");
}

Starts two delay tasks in parallel and waits for both to finish before printing.

Execution Table

Step	Action	Task1 Status	Task2 Status	Output
1	Start task1 and task2	Running	Running
2	Wait for tasks to complete	Running	Running
3	task1 completes after 1s	Completed	Running
4	task2 completes after 2s	Completed	Completed
5	Continue after all tasks done	Completed	Completed	All done

💡 Both tasks completed, so Task.WhenAll finishes and program continues.

Variable Tracker

Variable	Start	After Step 1	After Step 3	After Step 4	Final
task1	null	Running	Completed	Completed	Completed
task2	null	Running	Running	Completed	Completed

Key Moments - 2 Insights

Why does the program wait before printing "All done"?

Because Task.WhenAll waits until both task1 and task2 are completed, as shown in execution_table steps 2 to 5.

Do task1 and task2 run one after another or at the same time?

They run in parallel, both start immediately at step 1 and run simultaneously until they finish.

Visual Quiz - 3 Questions

Look at the execution table, what is the status of task1 at step 3?

A Running

B Completed

C Not started

D Faulted

💡 Hint

Check the 'Task1 Status' column at step 3 in the execution_table.

At which step do both tasks complete?

A Step 4

B Step 3

C Step 2

D Step 5

💡 Hint

Look for when both 'Task1 Status' and 'Task2 Status' show 'Completed' in the execution_table.

If task2 took only 500ms instead of 2000ms, when would Task.WhenAll complete?

A After 2 seconds

B After 500ms

C After 1 second

D Immediately

💡 Hint

Task.WhenAll waits for all tasks; the longest task duration controls completion time.

Concept Snapshot

Task.WhenAll runs multiple tasks at the same time.
It waits until all tasks finish before continuing.
Use await Task.WhenAll(task1, task2, ...).
This helps do work in parallel efficiently.
The program pauses at await until all tasks complete.

Full Transcript

This example shows how Task.WhenAll runs tasks in parallel and waits for all to finish. First, two tasks start running at the same time. Task1 finishes after 1 second, task2 after 2 seconds. The program waits until both are done, then prints "All done". This lets you do multiple things at once and continue only when all are ready.

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