Task.WhenAny for first completion in C Sharp (C#) - Mini Project: Build & Apply

Task.WhenAny for first completion

📖 Scenario: You are building a simple program that runs multiple tasks and wants to know which one finishes first.

🎯 Goal: Create three tasks that complete after different delays, then use Task.WhenAny to find and display the first task that finishes.

📋 What You'll Learn

Create three tasks with different delays

Use a variable to hold the first completed task

Use Task.WhenAny to get the first completed task

Print which task finished first

💡 Why This Matters

🌍 Real World

In real apps, you might start multiple operations and want to react as soon as one finishes, like loading data from multiple sources and using the fastest response.

💼 Career

Understanding Task.WhenAny is important for asynchronous programming in C#, which is common in web, desktop, and mobile app development.

1

Create three tasks with different delays

Create three tasks called task1, task2, and task3 that each delay for 3000, 2000, and 1000 milliseconds respectively using Task.Delay.

C Sharp (C#)

# Create three tasks with different delays
// Your code here

Hint

Use Task.Delay(milliseconds) to create tasks that complete after a delay.

2

Create an array of tasks

Create an array called tasks that contains task1, task2, and task3.

C Sharp (C#)

using System.Threading.Tasks;

Task task1 = Task.Delay(3000);
Task task2 = Task.Delay(2000);
Task task3 = Task.Delay(1000);

// Create an array called tasks with task1, task2, and task3
// Your code here

Hint

Use new Task[] { } to create an array of tasks.

3

Use Task.WhenAny to get the first completed task

Create a variable called firstFinished and assign it the result of await Task.WhenAny(tasks) inside an async method.

C Sharp (C#)

using System.Threading.Tasks;
using System;

class Program
{
    static async Task Main()
    {
        Task task1 = Task.Delay(3000);
        Task task2 = Task.Delay(2000);
        Task task3 = Task.Delay(1000);

        Task[] tasks = new Task[] { task1, task2, task3 };

        // Use Task.WhenAny to get the first finished task
        // Your code here
    }
}

Hint

Remember to make the Main method async to use await.

4

Print which task finished first

Print "Task 1 finished first" if firstFinished is task1, "Task 2 finished first" if it is task2, or "Task 3 finished first" if it is task3.

C Sharp (C#)

using System.Threading.Tasks;
using System;

class Program
{
    static async Task Main()
    {
        Task task1 = Task.Delay(3000);
        Task task2 = Task.Delay(2000);
        Task task3 = Task.Delay(1000);

        Task[] tasks = new Task[] { task1, task2, task3 };

        Task firstFinished = await Task.WhenAny(tasks);

        // Print which task finished first
        // Your code here
    }
}

Hint

Compare firstFinished with each task variable and print the matching message.

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