Task.WhenAny for first completion in C Sharp (C#) - Time & Space Complexity

Time Complexity: Task.WhenAny for first completion

O(n)

Understanding Time Complexity

We want to understand how the time to get the first finished task grows as we add more tasks.

How does waiting for the first task to complete change when we have more tasks running?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

var tasks = new List<Task>();
for (int i = 0; i < n; i++)
{
    tasks.Add(Task.Run(() => DoWork()));
}
var firstFinished = await Task.WhenAny(tasks);
await firstFinished;
    

This code starts n tasks and waits for the first one to finish.

Identify Repeating Operations

• Primary operation: Starting n tasks in a loop.
• How many times: n times, once per task.
• Waiting operation: Waiting for the first task to complete happens once.

How Execution Grows With Input

Starting tasks grows linearly with n, but waiting for the first to finish depends on the fastest task.

Input Size (n)	Approx. Operations
10	Start 10 tasks, wait for 1 to finish
100	Start 100 tasks, wait for 1 to finish
1000	Start 1000 tasks, wait for 1 to finish

Pattern observation: Starting tasks grows with n, but waiting time depends on the quickest task, not all.

Final Time Complexity

Time Complexity: O(n)

This means the work to start tasks grows with the number of tasks, but waiting stops as soon as the first finishes.

Common Mistake

[X] Wrong: "Waiting for the first task to finish takes as long as waiting for all tasks."

[OK] Correct: We only wait for the fastest task, so the wait time does not add up for all tasks.

Interview Connect

Understanding how waiting for the first task completion scales helps you reason about asynchronous code efficiency in real projects.

Self-Check

"What if we changed Task.WhenAny to Task.WhenAll? How would the time complexity change?"

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