1.3 Async Task

1. Basics

In C#, async tasks are a way to perform asynchronous operations, allowing your code to run tasks that might take some time (like I/O operations, network requests, or database queries) without blocking the main thread. This leads to more responsive applications, particularly in scenarios where you’re performing operations that would otherwise make the application appear unresponsive.

1.1 Key Concepts

1. async Keyword:

The async keyword is used to mark a method as asynchronous. It allows the use of the await keyword inside the method, enabling asynchronous operations.
An async method usually returns a Task or Task<T>, where T is the type of the result. If the method doesn’t return a value, it can return Task.

2. await Keyword:

The await keyword is used to asynchronously wait for a Task to complete. It pauses the execution of the method until the awaited task is done, but it doesn’t block the thread. Instead, it allows the thread to continue with other work, and the execution of the async method resumes once the awaited task is completed.

3. Task and Task<T>:

A Task represents an asynchronous operation. Task<T> represents an asynchronous operation that returns a value of type T.
Task.Run can be used to run code in the background, off the main thread.

1.2 Why Use Async Tasks?

1. Improved Responsiveness:

In UI applications, using async tasks can prevent the UI from freezing while waiting for long-running operations like file I/O or network requests.

2. Scalability:

In server applications, async tasks allow the server to handle more requests by not blocking threads while waiting for I/O operations to complete.

3. Non-blocking Operations:

Asynchronous programming allows the CPU to perform other tasks while waiting for long-running operations to finish, improving overall efficiency.

In summary, async tasks in C# are a powerful tool for writing responsive, non-blocking code, particularly in scenarios involving I/O-bound or CPU-bound operations that take time to complete.

1.3 Example: Performing Multiple Asynchronous Operations

Let’s simulate downloading data from multiple sources asynchronously.

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        Console.WriteLine("Starting downloads...");

        // Start multiple asynchronous tasks
        Task<string> downloadTask1 = DownloadDataAsync("Source 1");
        Task<string> downloadTask2 = DownloadDataAsync("Source 2");
        Task<string> downloadTask3 = DownloadDataAsync("Source 3");

        // Wait for all tasks to complete
        string[] results = await Task.WhenAll(downloadTask1, downloadTask2, downloadTask3);

        // Display the results
        foreach (var result in results)
        {
            Console.WriteLine(result);
        }

        Console.WriteLine("All downloads complete.");
    }

    // Simulate an asynchronous operation (e.g., downloading data)
    static async Task<string> DownloadDataAsync(string source)
    {
        // Simulate a delay (e.g., downloading data from a source)
        await Task.Delay(new Random().Next(1000, 3000));

        // Return the downloaded data
        return $"{source} download complete!";
    }
}

1. Main Method:

Multiple asynchronous tasks are started simultaneously: DownloadDataAsync("Source 1"), DownloadDataAsync("Source 2"), and DownloadDataAsync("Source 3").
These tasks run concurrently, so they don’t block each other.
await Task.WhenAll(downloadTask1, downloadTask2, downloadTask3); waits for all the download tasks to complete before proceeding.

2. DownloadDataAsync Method:

This method simulates downloading data from a source by introducing a random delay using Task.Delay(new Random().Next(1000, 3000));.
After the delay, it returns a string indicating that the download from the specific source is complete.

3. Output:

The program will print “Starting downloads…” immediately.
After all downloads are complete, it will print the completion messages for each source in the order they finished.
Finally, it will print “All downloads complete.”

This example shows how to execute multiple tasks concurrently and wait for all of them to finish, which is a common scenario when working with asynchronous code.

2. Task.Any(…)

Task.WhenAny is a method in C# that takes in a collection of tasks and returns a task that completes when any of the provided tasks completes. This is useful when you want to perform some action as soon as the first task finishes, rather than waiting for all tasks to complete.

2.1 Basic Usage of `Task.WhenAny`

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        Console.WriteLine("Starting tasks...");

        // Start multiple tasks
        Task<string> task1 = Task1();
        Task<string> task2 = Task2();
        Task<string> task3 = Task3();

        // Wait for any of the tasks to complete
        Task<string> completedTask = await Task.WhenAny(task1, task2, task3);

        // Get the result of the first completed task
        string result = await completedTask;


        //

        Console.WriteLine($"First task completed with result: {result}");
    }

    static async Task<string> Task1()
    {
        await Task.Delay(3000); // Simulate a 3-second task
        return "Task 1 complete";
    }

    static async Task<string> Task2()
    {
        await Task.Delay(2000); // Simulate a 2-second task
        return "Task 2 complete";
    }

    static async Task<string> Task3()
    {
        await Task.Delay(1000); // Simulate a 1-second task
        return "Task 3 complete";
    }
}

1 Multiple Tasks:

Three tasks (Task1, Task2, and Task3) are started simultaneously, each with different delays simulating different completion times.

2 Task.WhenAny:

Task.WhenAny(task1, task2, task3) returns a task that completes when the first of the provided tasks completes. This task contains a reference to the first completed task.

3 Getting the Result:

After the first task completes, await completedTask is used to get the result of that task. The program then prints which task completed first.

4 Output:

Since Task3 has the shortest delay (1 second), it completes first, and the output will be:
```
Starting tasks...
First task completed with result: Task 3 complete
```

2.2 Use Cases for `Task.WhenAny`:

1 Fastest Response:

In scenarios where you have multiple ways to achieve the same result (e.g., querying multiple servers for data), you might want to proceed with the result of the first server that responds.

2 Timeouts:

You can use Task.WhenAny to implement timeouts. For example, you could create a delay task (Task.Delay) alongside your main task and proceed with whichever completes first.

2.3 Example: Task with Timeout

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        // Start a task that takes 5 seconds
        Task<string> longRunningTask = LongRunningOperation();

        // Create a timeout task of 2 seconds
        Task timeoutTask = Task.Delay(2000);

        // Wait for either the long-running task or the timeout
        Task completedTask = await Task.WhenAny(longRunningTask, timeoutTask);

        if (completedTask == timeoutTask)
        {
            Console.WriteLine("Operation timed out.");
        }
        else
        {
            string result = await longRunningTask;
            Console.WriteLine($"Operation completed: {result}");
        }
    }

    static async Task<string> LongRunningOperation()
    {
        await Task.Delay(5000); // Simulate a 5-second task
        return "Operation complete";
    }
}

Timeout Scenario:
- In this example, Task.WhenAny is used to determine if the long-running operation finishes before the timeout. If the timeout task completes first, it prints “Operation timed out.” Otherwise, it proceeds with the result of the long-running operation.
Output:
- Since the timeout task is shorter (2 seconds) than the long-running task (5 seconds), the program will output:
```
Operation timed out.
```

Task.WhenAny is a powerful tool in asynchronous programming, especially when dealing with scenarios where timing and responsiveness are critical.

2.4 Wait for Remaining Tasks

2.4.1 Wait for All Remaining Tasks

Once Task.WhenAny returns the first completed task, you might still need to wait for the other tasks to finish. There are several ways to do this, depending on your specific requirements.

If you want to wait for all other tasks to finish after Task.WhenAny returns, you can use Task.WhenAll to wait for the remaining tasks.

Example:

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        Console.WriteLine("Starting tasks...");

        // Start multiple tasks
        Task<string> task1 = Task1();
        Task<string> task2 = Task2();
        Task<string> task3 = Task3();

        // Wait for any of the tasks to complete
        Task<string> completedTask = await Task.WhenAny(task1, task2, task3);

        // Get the result of the first completed task
        string result = await completedTask;
        Console.WriteLine($"First task completed with result: {result}");

        // Wait for all remaining tasks to complete
        await Task.WhenAll(task1, task2, task3);
        Console.WriteLine("All tasks are now completed.");
    }

    static async Task<string> Task1()
    {
        await Task.Delay(3000); // Simulate a 3-second task
        return "Task 1 complete";
    }

    static async Task<string> Task2()
    {
        await Task.Delay(2000); // Simulate a 2-second task
        return "Task 2 complete";
    }

    static async Task<string> Task3()
    {
        await Task.Delay(1000); // Simulate a 1-second task
        return "Task 3 complete";
    }
}

1 Task.WhenAny:

The program waits for the first task to complete using Task.WhenAny.

2 Wait for All Tasks:

After getting the result from the first completed task, await Task.WhenAll(task1, task2, task3); is used to wait for all tasks to complete. Since the first task has already completed, Task.WhenAll will immediately return for that task and only wait for the other two.

3 Output:

The output will show the result of the first task that completed and then indicate that all tasks have finished:
```
Starting tasks...
First task completed with result: Task 3 complete
All tasks are now completed.
```

2.4.2 Wait for Each Remaining Task Separately

Alternatively, you could wait for each of the remaining tasks individually.

Example:

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        Console.WriteLine("Starting tasks...");

        // Start multiple tasks
        Task<string> task1 = Task1();
        Task<string> task2 = Task2();
        Task<string> task3 = Task3();

        // Wait for any of the tasks to complete
        Task<string> completedTask = await Task.WhenAny(task1, task2, task3);

        // Get the result of the first completed task
        string result = await completedTask;
        Console.WriteLine($"First task completed with result: {result}");

        // Manually wait for the other tasks
        if (completedTask != task1)
        {
            string result1 = await task1;
            Console.WriteLine($"Task 1 completed with result: {result1}");
        }

        if (completedTask != task2)
        {
            string result2 = await task2;
            Console.WriteLine($"Task 2 completed with result: {result2}");
        }

        if (completedTask != task3)
        {
            string result3 = await task3;
            Console.WriteLine($"Task 3 completed with result: {result3}");
        }

        Console.WriteLine("All tasks are now completed.");
    }

    static async Task<string> Task1()
    {
        await Task.Delay(3000); // Simulate a 3-second task
        return "Task 1 complete";
    }

    static async Task<string> Task2()
    {
        await Task.Delay(2000); // Simulate a 2-second task
        return "Task 2 complete";
    }

    static async Task<string> Task3()
    {
        await Task.Delay(1000); // Simulate a 1-second task
        return "Task 3 complete";
    }
}

Manual Waiting:
- After determining which task completed first, the code manually waits for the remaining tasks to complete by checking if each task is not the one that completed first.

Output:

The output will indicate which task completed first and then provide the results of the other tasks as they finish:

Starting tasks...
First task completed with result: Task 3 complete
Task 2 completed with result: Task 2 complete
Task 1 completed with result: Task 1 complete
All tasks are now completed.

Task.WhenAny returns the first task that completes, but the other tasks are still running.
You can wait for the other tasks to finish using Task.WhenAll or by individually awaiting each remaining task.
This pattern is useful in scenarios where you care about the first result but also need to ensure all tasks have completed before proceeding.

Enter Password

1.3 Async Task

1. Basics

1.1 Key Concepts

1.2 Why Use Async Tasks?

1.3 Example: Performing Multiple Asynchronous Operations

2. Task.Any(…)

2.1 Basic Usage of Task.WhenAny

2.2 Use Cases for Task.WhenAny:

2.3 Example: Task with Timeout

2.4 Wait for Remaining Tasks

2.4.1 Wait for All Remaining Tasks

Example:

2.4.2 Wait for Each Remaining Task Separately

Example:

2.1 Basic Usage of `Task.WhenAny`

2.2 Use Cases for `Task.WhenAny`: