Task-Based Asynchronous Model (TAP) in C#

The **Task-Based Asynchronous Model (TAP)** is the standard approach for handling **asynchronous programming** in C#. It uses the **Task and Task** types along with **async and await** keywords to enable efficient, non-blocking execution of tasks.

Key Features of Task-Based Asynchronous Model

Uses **Task and Task** for asynchronous operations.
Supports **async/await** for cleaner and more readable code.
Allows **non-blocking execution**, improving responsiveness.
Handles **exceptions using try-catch** in an asynchronous context.

Basic Asynchronous Programming with TAP

The **async/await** pattern simplifies asynchronous programming by enabling **non-blocking execution**.

Example: Basic Asynchronous Method Using async/await

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        Console.WriteLine("Task started...");
        await PerformTaskAsync();
        Console.WriteLine("Task completed.");
    }

    static async Task PerformTaskAsync()
    {
        await Task.Delay(2000); // Simulates an asynchronous delay
        Console.WriteLine("Async Task Finished.");
    }
}

// Output:
// Task started...
// (Waits for 2 seconds)
// Async Task Finished.
// Task completed.

The **await Task.Delay(2000)** simulates an **asynchronous delay** without blocking the main thread.

Returning Data with Task<TResult>

The **Task** type allows returning values asynchronously.

Example: Returning Data from an Asynchronous Method

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        int result = await ComputeSumAsync(10, 20);
        Console.WriteLine($"Computed Sum: {result}");
    }

    static async Task<int> ComputeSumAsync(int a, int b)
    {
        await Task.Delay(1000); // Simulates async work
        return a + b;
    }
}

// Output:
// (Waits for 1 second)
// Computed Sum: 30

The **Task<TResult>** type allows returning values **asynchronously** without blocking execution.

Handling Exceptions in Asynchronous Methods

Use **try-catch** to handle exceptions inside an asynchronous method.

Example: Exception Handling in Async Methods

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        try
        {
            await PerformAsyncTask();
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Exception Caught: {ex.Message}");
        }
    }

    static async Task PerformAsyncTask()
    {
        await Task.Delay(1000);
        throw new InvalidOperationException("Something went wrong!");
    }
}

// Output:
// (Waits for 1 second)
// Exception Caught: Something went wrong!

**Try-catch blocks** allow handling exceptions in **asynchronous methods** effectively.

Running Multiple Asynchronous Tasks in Parallel

The **Task.WhenAll()** method allows running multiple asynchronous tasks concurrently.

Example: Running Multiple Async Methods in Parallel

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        Task task1 = PerformTaskAsync("Task 1");
        Task task2 = PerformTaskAsync("Task 2");

        await Task.WhenAll(task1, task2);

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

    static async Task PerformTaskAsync(string taskName)
    {
        await Task.Delay(2000);
        Console.WriteLine($"{taskName} finished.");
    }
}

// Output:
// (Waits for 2 seconds)
// Task 1 finished.
// Task 2 finished.
// All tasks completed.

The **Task.WhenAll()** method ensures all tasks complete **before proceeding further**.

Best Practices for Using TAP

Use **async/await** for **I/O-bound** operations (e.g., database calls, file I/O).
Avoid using **Task.Result or Task.Wait()**, as they can cause **deadlocks**.
Use **ConfigureAwait(false)** when you don’t need to resume execution on the original thread.
Prefer **Task.WhenAll()** for running multiple asynchronous tasks concurrently.
Always use **try-catch** blocks to handle **exceptions in async methods**.