1async Task SequentialExample()
2{
3    var result1 = await GetDataFromApiAsync("users");     // 2 seconds
4    var result2 = await GetDataFromApiAsync("orders");    // 2 seconds
5    var result3 = await GetDataFromApiAsync("products");  // 2 seconds
6
7    // Total time: ~6 seconds (2 + 2 + 2)
8    Console.WriteLine($"{result1}, {result2}, {result3}");
9}

1async Task ConcurrentExample()
2{
3    var task1 = GetDataFromApiAsync("users");     // Starts immediately
4    var task2 = GetDataFromApiAsync("orders");    // Starts immediately
5    var task3 = GetDataFromApiAsync("products");  // Starts immediately
6
7    await Task.WhenAll(task1, task2, task3);
8    // Total time: ~2 seconds (all run in parallel)
9
10    Console.WriteLine($"{task1.Result}, {task2.Result}, {task3.Result}");
11}

1async Task<string[]> GetAllDataAsync()
2{
3    var tasks = new[]
4    {
5        GetDataFromApiAsync("users"),
6        GetDataFromApiAsync("orders"),
7        GetDataFromApiAsync("products")
8    };
9
10    // WhenAll returns results in the same order as the input tasks
11    string[] results = await Task.WhenAll(tasks);
12    return results;
13}

1void BlockingExample()
2{
3    var task1 = GetDataFromApiAsync("users");
4    var task2 = GetDataFromApiAsync("orders");
5
6    // BLOCKS the current thread — can deadlock in UI/ASP.NET contexts
7    Task.WaitAll(task1, task2);
8
9    Console.WriteLine(task1.Result);
10}

1// Pattern 1: Sequential awaits (~6 seconds)
2var a = await DoWorkAsync(2000);
3var b = await DoWorkAsync(2000);
4var c = await DoWorkAsync(2000);
5
6// Pattern 2: Task.WhenAll (~2 seconds, concurrent, async)
7var taskA = DoWorkAsync(2000);
8var taskB = DoWorkAsync(2000);
9var taskC = DoWorkAsync(2000);
10await Task.WhenAll(taskA, taskB, taskC);
11
12// Pattern 3: Task.WaitAll (~2 seconds, concurrent, BLOCKING)
13var taskX = DoWorkAsync(2000);
14var taskY = DoWorkAsync(2000);
15Task.WaitAll(taskX, taskY);  // Blocks thread — avoid

1// Sequential: first exception stops execution
2try
3{
4    var a = await MayFailAsync("A");  // If this throws, B never runs
5    var b = await MayFailAsync("B");
6}
7catch (Exception ex)
8{
9    Console.WriteLine(ex.Message);
10}
11
12// WhenAll: all tasks run; all exceptions are collected
13try
14{
15    await Task.WhenAll(MayFailAsync("A"), MayFailAsync("B"), MayFailAsync("C"));
16}
17catch (Exception ex)
18{
19    // 'ex' is the first exception, but all are available:
20    // The AggregateException is in the Task.WhenAll task
21}
22
23// Access all exceptions from WhenAll
24var allTasks = Task.WhenAll(MayFailAsync("A"), MayFailAsync("B"));
25try
26{
27    await allTasks;
28}
29catch
30{
31    foreach (var ex in allTasks.Exception.InnerExceptions)
32    {
33        Console.WriteLine($"Error: {ex.Message}");
34    }
35}

1async Task<string> GetFastestResultAsync()
2{
3    var task1 = FetchFromServer1Async();
4    var task2 = FetchFromServer2Async();
5
6    var fastest = await Task.WhenAny(task1, task2);
7    return await fastest;  // Get the result of whichever finished first
8}

1public class DashboardService
2{
3    public async Task<DashboardData> LoadDashboardAsync(int userId)
4    {
5        // These are independent — run concurrently
6        var profileTask = _userService.GetProfileAsync(userId);
7        var ordersTask = _orderService.GetRecentOrdersAsync(userId);
8        var notificationsTask = _notificationService.GetUnreadAsync(userId);
9
10        await Task.WhenAll(profileTask, ordersTask, notificationsTask);
11
12        return new DashboardData
13        {
14            Profile = profileTask.Result,
15            RecentOrders = ordersTask.Result,
16            Notifications = notificationsTask.Result
17        };
18    }
19}