Task.WhenAny for first completion in C Sharp (C#) - Step-by-Step Execution

Concept Flow - Task.WhenAny for first completion

Start multiple tasks

↓

Wait for any task to complete

↓

Identify first completed task

↓

Process result of first completed task

↓

Optionally wait for others or continue

Start several tasks, wait until the first one finishes, then handle its result before continuing.

Execution Sample

C Sharp (C#)

var task1 = Task.Delay(3000);
var task2 = Task.Delay(1000);
var first = await Task.WhenAny(task1, task2);
Console.WriteLine($"First finished: {first.Id}");

Starts two delay tasks and prints which one finishes first.

Execution Table

Step	Action	Task1 Status	Task2 Status	Task Completed	Output
1	Start task1 (3s delay)	Running	Not started	None
2	Start task2 (1s delay)	Running	Running	None
3	Wait for any task to complete	Running	Running	None
4	After 1 second, task2 completes	Running	Completed	task2	First finished: task2.Id
5	Continue after first completion	Running	Completed	task2	First finished: task2.Id
6	Optionally wait for task1	Completed	Completed	task2

💡 Task2 completes first after 1 second, so Task.WhenAny returns task2.

Variable Tracker

Variable	Start	After Step 2	After Step 4	Final
task1.Status	Not started	Running	Running	Completed
task2.Status	Not started	Running	Completed	Completed
first	null	null	task2	task2

Key Moments - 3 Insights

Why does Task.WhenAny return the task that finished first, not the result?

Task.WhenAny returns the Task object that completed first, not its result value. You can then await that task to get its result. See execution_table step 4 where 'first' is assigned the completed task.

What happens to the other tasks after Task.WhenAny completes?

Other tasks keep running unless you explicitly wait or cancel them. In the example, task1 continues running after task2 finishes (see execution_table steps 4 and 5).

Can Task.WhenAny complete if multiple tasks finish at the same time?

Yes, but it returns one of the completed tasks (usually the first detected). The exact one is not guaranteed. This is why you check which task completed by inspecting the returned task.

Visual Quiz - 3 Questions

Look at the execution_table, what is the status of task1 at step 4?

A Running

B Completed

C Not started

D Faulted

💡 Hint

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

At which step does Task.WhenAny return the first completed task?

A Step 2

B Step 3

C Step 4

D Step 6

💡 Hint

Look for when 'Task Completed' column shows a task and output is produced.

If task2 had a 5 second delay instead of 1 second, which task would Task.WhenAny return first?

A Neither, it would wait forever

B task1

C task2

D Both at the same time

💡 Hint

Refer to variable_tracker to see which task finishes earlier based on delay times.

Concept Snapshot

Task.WhenAny(tasks...) waits for the first task to finish.
It returns the completed Task object, not its result.
You can await the returned task to get its result.
Other tasks keep running unless awaited or cancelled.
Useful to react as soon as any task completes.

Full Transcript

This example shows how Task.WhenAny works by starting two delay tasks. Task1 delays 3 seconds, task2 delays 1 second. The program waits for the first task to complete using Task.WhenAny. After 1 second, task2 finishes first, so Task.WhenAny returns task2. The program then prints the ID of the first finished task. Task1 continues running until it finishes. This demonstrates that Task.WhenAny returns the first completed task object, allowing you to handle its result or continue processing.

Practice

1. What does Task.WhenAny do in C#?

easy

A. It creates a new task that never completes.

B. It waits for all tasks to complete before continuing.

C. It cancels all running tasks immediately.

D. It waits for the first task to complete among multiple tasks.

Solution

1. Step 1: Understand Task.WhenAny purpose

   Task.WhenAny waits for the first task to finish among many tasks.

2. Step 2: Compare with other options

   Unlike Task.WhenAll, it does not wait for all tasks, nor does it cancel tasks or create infinite tasks.

3. Final Answer:

   It waits for the first task to complete among multiple tasks. -> Option D

4. Quick Check:

   Task.WhenAny = first task completion [OK]

Hint: Remember: WhenAny means wait for one task only [OK]

Common Mistakes:

• Confusing Task.WhenAny with Task.WhenAll
• Thinking it cancels other tasks
• Assuming it waits for all tasks

2. Which of the following is the correct syntax to use Task.WhenAny with two tasks task1 and task2?

easy

A. var first = await Task.WhenAny(task1, task2);

B. var first = await Task.WhenAny([task1, task2]);

C. var first = await Task.WhenAny{task1, task2};

D. var first = await Task.WhenAny task1, task2;

Solution

1. Step 1: Check correct method call syntax

   Task.WhenAny accepts params array of tasks, so calling with (task1, task2) is correct.

2. Step 2: Identify invalid syntax

   Square brackets, curly braces, or missing parentheses cause syntax errors.

3. Final Answer:

   var first = await Task.WhenAny(task1, task2); -> Option A

4. Quick Check:

   Correct method call uses parentheses and comma-separated tasks [OK]

Hint: Use parentheses and commas for Task.WhenAny arguments [OK]

Common Mistakes:

• Using square brackets instead of parentheses
• Using curly braces instead of parentheses
• Omitting parentheses around arguments

3. What will be the output of this code snippet?

var task1 = Task.Delay(3000).ContinueWith(_ => "Task1 done");
var task2 = Task.Delay(1000).ContinueWith(_ => "Task2 done");
var first = await Task.WhenAny(task1, task2);
Console.WriteLine(await first);

medium

A. Task2 done

B. No output, program hangs

C. Task1 done\nTask2 done

D. Task1 done

Solution

1. Step 1: Analyze task delays

   task1 completes after 3000ms, task2 after 1000ms, so task2 finishes first.

2. Step 2: Task.WhenAny returns first completed task

   first will be task2, so awaiting it prints "Task2 done".

3. Final Answer:

   Task2 done -> Option A

4. Quick Check:

   First completed task result = Task2 done [OK]

Hint: The shortest delay task finishes first [OK]

Common Mistakes:

• Assuming task1 finishes first because it is listed first
• Expecting both tasks to print
• Thinking program hangs waiting for all tasks

4. Identify the error in this code using Task.WhenAny:

var task1 = Task.Delay(2000);
var task2 = Task.Delay(1000);
var first = Task.WhenAny(task1, task2);
Console.WriteLine(await first.Result);

medium

A. Using await on first.Result causes a compile error.

B. Task.WhenAny should be awaited before accessing Result.

C. Task.Delay cannot be used with Task.WhenAny.

D. Console.WriteLine cannot print task results.

Solution

1. Step 1: Check how Task.WhenAny is awaited

   Task.WhenAny returns a Task<Task>, so it must be awaited to get the completed task.

2. Step 2: Identify misuse of Result property

   Accessing first.Result without awaiting first causes incorrect behavior or deadlock.

3. Final Answer:

   Task.WhenAny should be awaited before accessing Result. -> Option B

4. Quick Check:

   Await Task.WhenAny before accessing completed task [OK]

Hint: Always await Task.WhenAny before using its result [OK]

Common Mistakes:

• Accessing Result property without await
• Confusing Task<Task> with Task
• Ignoring async/await pattern

5. You have three tasks: taskA (2s delay), taskB (1s delay), and taskC (3s delay). You want to print the result of the first completed task and then cancel the other two tasks. Which code snippet correctly achieves this?

hard

A. var first = await Task.WhenAny(taskA, taskB, taskC);
cts.Cancel();
Console.WriteLine(await first);

B. var first = await Task.WhenAny(taskA, taskB, taskC);
Console.WriteLine(await first);
// No cancellation code

C. var cts = new CancellationTokenSource();
var taskA = Task.Delay(2000, cts.Token);
var taskB = Task.Delay(1000, cts.Token);
var taskC = Task.Delay(3000, cts.Token);
var first = await Task.WhenAny(taskA, taskB, taskC);
cts.Cancel();
Console.WriteLine(await first);

D. var first = Task.WhenAny(taskA, taskB, taskC).Result;
cts.Cancel();
Console.WriteLine(first.Result);

Solution

1. Step 1: Use CancellationTokenSource to cancel tasks

   Create a CancellationTokenSource and pass its token to all tasks so they can be cancelled.

2. Step 2: Await Task.WhenAny and cancel remaining tasks

   Await Task.WhenAny to get first completed task, then call cts.Cancel() to stop others, finally print the result.

3. Final Answer:

   Use CancellationTokenSource, await Task.WhenAny, then cancel and print. -> Option C

4. Quick Check:

   Cancel tasks after first completion using CancellationTokenSource [OK]

Hint: Pass cancellation token to tasks and cancel after first finishes [OK]

Common Mistakes:

• Not passing cancellation token to tasks
• Calling Cancel before awaiting Task.WhenAny
• Using .Result instead of await causing deadlocks