学懂C#异步编程：深入详解 C# 异步方法中的 Task.WhenAll、Task.WhenAny、await、Wait、WaitAll、WaitAny 等用法及其区别和需要注意的坑

martian665

3376人浏览 · 2024-09-25 16:14:32

martian665 · 2024-09-25 16:14:32 发布

引言

异步编程在现代应用程序中越来越重要，它可以提高程序的响应性和性能。C# 提供了一整套用于异步操作的工具和方法，如 Task.WhenAll、Task.WhenAny、await、Wait、WaitAll、WaitAny 等。本篇技术博客将详细讲解这些方法的基本用法、区别、应用场景，以及在使用时需要注意或避免的坑，帮助你熟练掌握 C# 中的异步编程技术。

1. 异步编程的基本概念

什么是异步编程

异步编程是一种编程范式，通过异步操作可以使程序在等待长时间运行的任务（如 I/O 操作、网络请求等）完成时，继续执行其他任务，而不阻塞主线程。

异步编程的好处

提高程序响应性：避免长时间阻塞，保持用户界面的平滑和响应。
提高并发性能：更好地利用系统资源，处理更多的并发任务。

2. Task 和 Task<T>

Task 的基本概念

Task 类表示一个异步操作，可以使用 Task.Run 方法来启动一个新的任务。

Task task = Task.Run(() => {
    // 执行异步操作
});

Task<T> 的基本概念

Task<T> 类表示一个返回结果的异步操作，T 是返回结果的类型。

Task<int> task = Task.Run(() => {
    // 执行异步操作并返回结果
    return 42;
});

3. await 关键字

基本用法

await 关键字用于等待一个异步任务完成。它只能在返回类型为 async 的方法中使用。

public async Task ExampleAsync() {
    await Task.Delay(1000); // 等待 1 秒钟
}

示例代码与详解

以下是一个完整的示例，展示了如何使用 await 关键字等待异步任务完成：

public async Task ExampleAsync() {
    Console.WriteLine("Start");
    await Task.Delay(1000); // 异步等待 1 秒钟
    Console.WriteLine("End after 1 second");
}

public static async Task MainFun() {
    await ExampleAsync();
}

这个示例展示了如何使用 await 关键字等待一个异步任务完成，并在任务完成后继续执行。

4. Task.WhenAll

基本用法

Task.WhenAll 方法用于等待一组任务全部完成。它返回一个新的任务，该任务在所有提供的任务完成时完成。

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

await Task.WhenAll(task1, task2);

示例代码与详解

以下是一个完整的示例，展示了如何使用 Task.WhenAll 等待一组任务全部完成：

public async Task ExampleWhenAll() {
    Task task1 = Task.Delay(1000); // 异步等待 1 秒钟
    Task task2 = Task.Delay(2000); // 异步等待 2 秒钟

    await Task.WhenAll(task1, task2); // 等待所有任务完成
    Console.WriteLine("All tasks completed");
}

public static async Task Main(string[] args) {
    await new Program().ExampleWhenAll();
}

注意事项和坑
无限等待：如果 Task.WhenAll 中包含的任务有未开始或永远不会完成的任务，调用 WhenAll 会导致无限等待。
解决方案：确保所有任务均已启动，并有一个合理的超时机制。
public async Task ExampleWhenAllWithTimeout() {
    Task task1 = Task.Delay(1000); // 异步等待 1 秒钟
    Task task2 = Task.Delay(2000); // 异步等待 2 秒钟

    Task timeout = Task.Delay(3000); // 超时任务
    Task allTasks = Task.WhenAll(task1, task2);

    if (await Task.WhenAny(allTasks, timeout) == timeout) {
        Console.WriteLine("Operation timed out");
    } else {
        Console.WriteLine("All tasks completed");
    }
}

5. Task.WhenAny

基本用法

Task.WhenAny 方法用于等待一组任务中的任何一个完成。它返回一个新的任务，该任务在任意一个提供的任务完成时完成，并返回第一个完成的任务。

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

Task completedTask = await Task.WhenAny(task1, task2);

示例代码与详解

以下是一个完整的示例，展示了如何使用 Task.WhenAny 等待一组任务中的任意一个完成：

public async Task ExampleWhenAny() {
    Task task1 = Task.Delay(1000); // 异步等待 1 秒钟
    Task task2 = Task.Delay(2000); // 异步等待 2 秒钟

    Task completedTask = await Task.WhenAny(task1, task2); // 等待任意一个任务完成

    if (completedTask == task1) {
        Console.WriteLine("Task 1 completed first");
    } else if (completedTask == task2) {
        Console.WriteLine("Task 2 completed first");
    }
}

public static async Task Main(string[] args) {
    await new Program().ExampleWhenAny();
}

注意事项和坑

处理未完成任务：Task.WhenAny 只会等待第一个完成的任务，其他未完成的任务仍然会继续执行。

解决方案：显式取消或等待其他任务，以确保它们不会继续运行。

public async Task ExampleWhenAnyWithCancellation() {
    Task task1 = Task.Delay(1000); // 异步等待 1 秒钟
    Task task2 = Task.Delay(2000); // 异步等待 2 秒钟

    Task completedTask = await Task.WhenAny(task1, task2); // 等待任意一个任务完成

    if (completedTask == task1) {
        Console.WriteLine("Task 1 completed first");
    } else if (completedTask == task2) {
        Console.WriteLine("Task 2 completed first");
    }

    // 显式取消其他任务或等待它们完成
    await Task.WhenAll(task1, task2);
}

6. Task.Wait

基本用法

Task.Wait 方法用于同步等待一个任务完成。它会阻塞当前线程，直到任务完成。

Task task = Task.Delay(1000);
task.Wait(); // 同步等待任务完成

示例代码与详解

以下是一个完整的示例，展示了如何使用 Task.Wait 同步等待任务完成：

public void ExampleWait() {
    Task task = Task.Delay(1000); // 异步等待 1 秒钟
    task.Wait(); // 同步等待任务完成
    Console.WriteLine("Task completed");
}

public static void Main(string[] args) {
    new Program().ExampleWait();
}

注意事项和坑
阻塞主线程：Task.Wait 会阻塞当前线程，如果在 UI 线程中使用，可能会导致界面卡顿。
解决方案：尽量在后台线程中使用 Task.Wait，或者使用 await 代替 Task.Wait。
public async Task ExampleWaitInBackground() {
    Task task = Task.Delay(1000); // 异步等待 1 秒钟
    await Task.Run(() => task.Wait()); // 在后台线程中等待任务完成
    Console.WriteLine("Task completed");
}

public static async Task Main(string[] args) {
    await new Program().ExampleWaitInBackground();
}

7. Task.WaitAll

基本用法

Task.WaitAll 方法用于同步等待一组任务全部完成。它会阻塞当前线程，直到所有任务完成。

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

Task.WaitAll(task1, task2); // 同步等待所有任务完成

示例代码与详解

以下是一个完整的示例，展示了如何使用 Task.WaitAll 同步等待一组任务全部完成：

public void ExampleWaitAll() {
    Task task1 = Task.Delay(1000); // 异步等待 1 秒钟
    Task task2 = Task.Delay(2000); // 异步等待 2 秒钟

    Task.WaitAll(task1, task2); // 同步等待所有任务完成
    Console.WriteLine("All tasks completed");
}

public static void Main(string[] args) {
    new Program().ExampleWaitAll();
}

注意事项和坑
无限等待：如果 Task.WaitAll 中包含的任务有未开始或永远不会完成的任务，调用 WaitAll 会导致无限等待。
解决方案：确保所有任务均已启动，并有一个合理的超时机制。
public void ExampleWaitAllWithTimeout() {
    Task task1 = Task.Delay(1000); // 异步等待 1 秒钟
    Task task2 = Task.Delay(2000); // 异步等待 2 秒钟

    if (Task.WaitAll(new Task[] { task1, task2 }, 3000)) { // 使用超时机制
        Console.WriteLine("All tasks completed");
    } else {
        Console.WriteLine("Operation timed out");
    }
}

public static void Main(string[] args) {
    new Program().ExampleWaitAllWithTimeout();
}

8. Task.WaitAny

基本用法

Task.WaitAny 方法用于同步等待一组任务中的任何一个完成。它返回第一个完成的任务的索引。

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

int completedTaskIndex = Task.WaitAny(task1, task2); // 同步等待任意一个任务完成

示例代码与详解

以下是一个完整的示例，展示了如何使用 Task.WaitAny 同步等待一组任务中的任意一个完成：

public void ExampleWaitAny() {
    Task task1 = Task.Delay(1000); // 异步等待 1 秒钟
    Task task2 = Task.Delay(2000); // 异步等待 2 秒钟

    int completedTaskIndex = Task.WaitAny(task1, task2); // 同步等待任意一个任务完成

    if (completedTaskIndex == 0) {
        Console.WriteLine("Task 1 completed first");
    } else if (completedTaskIndex == 1) {
        Console.WriteLine("Task 2 completed first");
    }
}

public static void Main(string[] args) {
    new Program().ExampleWaitAny();
}

注意事项和坑

阻塞主线程：Task.WaitAny 会阻塞当前线程，如果在 UI 线程中使用，可能会导致界面卡顿。

解决方案：尽量在后台线程中使用 Task.WaitAny，或者使用 Task.WhenAny 代替 Task.WaitAny。

public async Task ExampleWaitAnyInBackground() {
    Task task1 = Task.Delay(1000); // 异步等待 1 秒钟
    Task task2 = Task.Delay(2000); // 异步等待 2 秒钟

    int completedTaskIndex = await Task.Run(() => Task.WaitAny(task1, task2)); // 在后台线程中等待任意一个任务完成

    if (completedTaskIndex == 0) {
        Console.WriteLine("Task 1 completed first");
    } else if (completedTaskIndex == 1) {
        Console.WriteLine("Task 2 completed first");
    }
}

public static async Task Main(string[] args) {
    await new Program().ExampleWaitAnyInBackground();
}

9. 异步方法的区别与应用场景

Task.WhenAll vs Task.WaitAll

Task.WhenAll
定义：Task.WhenAll 是一个异步方法，它接受一个 Task 数组，并返回一个新的任务，该任务将在所有提供的任务完成时完成。
行为：不阻塞当前线程，异步等待所有任务完成。
返回值：返回一个表示所有任务完成的 Task 对象。如果所有任务完成且没有一个失败，则该任务的结果是一个包含每个任务结果的数组。
错误处理：如果任何一个任务失败，返回的任务将以 AggregateException 形式封装所有单个任务的异常。
var tasks = new Task[] { Task.Delay(1000), Task.Delay(2000) };
await Task.WhenAll(tasks);
Console.WriteLine("All tasks completed asynchronously.");

Task.WaitAll
定义：Task.WaitAll 是一个同步方法，它接受一个 Task 数组，并阻塞调用线程，直到所有提供的任务完成。
行为：阻塞当前线程，等待所有任务完成。
返回值：无返回值，只是阻塞直到所有任务完成。
错误处理：如果任何一个任务失败，WaitAll 方法将抛出 AggregateException，包含所有失败任务的异常。
var tasks = new Task[] { Task.Delay(1000), Task.Delay(2000) };
Task.WaitAll(tasks);
Console.WriteLine("All tasks completed synchronously.");

Task.WhenAll：异步等待一组任务全部完成，不阻塞当前线程。
Task.WaitAll：同步等待一组任务全部完成，阻塞当前线程。

应用场景：

Task.WhenAll 适用于需要同时等待多个异步任务且不希望阻塞当前线程的场景。例如，在一个 Web 应用中，需要并行执行多个 I/O 操作，然后在所有操作完成后继续处理结果。
Task.WaitAll 适用于在后台线程中同时等待多个任务的场景，或需要同步等待的场景。例如，在一个控制台应用程序中，需要在继续执行之前确保所有后台任务都已经完成。

Task.WhenAny vs Task.WaitAny

Task.WhenAny
定义：Task.WhenAny 是一个异步方法，它接受一个 Task 数组，并返回一个新的任务，该任务将在任意一个提供的任务完成时完成。
行为：不阻塞当前线程，异步等待第一个任务完成。
返回值：返回一个表示第一个完成任务的 Task 对象。
错误处理：如果第一个完成的任务失败，返回的任务将反映该失败。如果需要处理错误，可以检查返回的任务的状态。
var tasks = new Task[] { Task.Delay(1000), Task.Delay(2000) };
var completedTask = await Task.WhenAny(tasks);
Console.WriteLine("One of the tasks completed asynchronously.");

Task.WaitAny

定义：Task.WaitAny 是一个同步方法，它接受一个 Task 数组，并阻塞调用线程，直到任意一个提供的任务完成。
行为：阻塞当前线程，等待第一个任务完成。
返回值：返回第一个完成任务的索引。
错误处理：如果第一个完成的任务失败，WaitAny 方法将反映该失败。如果需要处理错误，可以检查返回的任务的状态。
var tasks = new Task[] { Task.Delay(1000), Task.Delay(2000) };
int completedTaskIndex = Task.WaitAny(tasks);
Console.WriteLine($"Task {completedTaskIndex + 1} completed synchronously.");

Task.WhenAny：异步等待一组任务中的任何一个完成，不阻塞当前线程。
Task.WaitAny：同步等待一组任务中的任何一个完成，阻塞当前线程。

应用场景：

Task.WhenAny 适用于需要异步等待多个任务中的任意一个且不希望阻塞当前线程的场景。例如，在一个 Web 应用中，需要同时发起多个请求，并在第一个响应到达时立即处理。
Task.WaitAny 适用于在后台线程中等待多个任务中的任意一个完成的场景，或需要同步等待的场景。例如，在一个控制台应用程序中，需要在继续执行之前确保至少一个后台任务已经完成。

await vs Task.Wait

await
定义：await 是一个关键字，用于异步等待任务完成。它只能在标记为 async 的方法中使用。
行为：不阻塞当前线程，异步等待任务完成。
返回值：没有明确的返回值，但可以等待返回结果的任务。
错误处理：如果任务失败，await 将抛出该任务的异常，可以在 try-catch 块中处理。
public async Task ExampleAsync() {
    await Task.Delay(1000);
    Console.WriteLine("Task completed asynchronously.");
}

Task.Wait
定义：Task.Wait 是一个同步方法，它阻塞调用线程，直到任务完成。
行为：阻塞当前线程，等待任务完成。
返回值：无返回值，只是阻塞直到任务完成。
错误处理：如果任务失败，Wait 方法将抛出该任务的异常，可以在 try-catch 块中处理。
var task = Task.Delay(1000);
task.Wait();
Console.WriteLine("Task completed synchronously.");

await：异步等待任务完成，不阻塞当前线程。
Task.Wait：同步等待任务完成，阻塞当前线程。

应用场景：

await 适用于需要异步等待任务完成且不希望阻塞当前线程的场景。例如，在一个 GUI 应用中，需要异步执行操作以保持界面响应。
Task.Wait 适用于在后台线程中同步等待任务完成的场景，或需要同步等待的场景。例如，在一个控制台应用程序中，需要在继续执行之前确保某个任务已经完成。

注意事项和使用建议

避免阻塞主线程：在 GUI 或 Web 应用中，使用 Task.Wait 和 Task.WaitAll 会阻塞主线程，导致界面或应用无响应。应尽量使用 await、Task.WhenAll 或 Task.WhenAny。
错误处理：无论使用哪种方法，都需要处理可能的异常。对于 Task.WhenAll 和 await，可以使用 try-catch 块；对于 Task.WaitAll 和 Task.Wait，可以捕获 AggregateException 并处理内部异常。
超时机制：在等待多个任务时，建议添加超时机制，以防止无限等待。例如，可以使用 Task.WhenAny 与一个超时任务结合使用。

10. 综合示例：结合使用多个异步方法的示例

为了更好地展示异步方法的综合应用，我们将创建一个示例，结合使用 await、Task.WhenAll、Task.WhenAny、Task.Wait、Task.WaitAll 和 Task.WaitAny。

综合示例代码

以下是完整的应用程序代码，展示了如何结合使用多个异步方法：

using System;
using System.Threading.Tasks;

public class Program {
    public async Task ExampleAsync() {
        Console.WriteLine("Start");

        // 使用 await 异步等待任务
        await Task.Delay(1000);
        Console.WriteLine("End after 1 second");

        // 使用 Task.WhenAll 等待多个任务完成
        Task task1 = Task.Delay(1000);
        Task task2 = Task.Delay(2000);
        await Task.WhenAll(task1, task2);
        Console.WriteLine("All tasks completed using WhenAll");

        // 使用 Task.WhenAny 等待任意一个任务完成
        Task completedTask = await Task.WhenAny(task1, task2);
        if (completedTask == task1) {
            Console.WriteLine("Task 1 completed first using WhenAny");
        } else if (completedTask == task2) {
            Console.WriteLine("Task 2 completed first using WhenAny");
        }

        // 使用 Task.Wait 同步等待任务完成
        Task task3 = Task.Delay(1000);
        task3.Wait();
        Console.WriteLine("Task 3 completed using Wait");

        // 使用 Task.WaitAll 同步等待多个任务完成
        Task task4 = Task.Delay(1000);
        Task task5 = Task.Delay(2000);
        Task.WaitAll(task4, task5);
        Console.WriteLine("All tasks completed using WaitAll");

        // 使用 Task.WaitAny 同步等待任意一个任务完成
        Task task6 = Task.Delay(1000);
        Task task7 = Task.Delay(2000);
        int completedTaskIndex = Task.WaitAny(task6, task7);
        if (completedTaskIndex == 0) {
            Console.WriteLine("Task 6 completed first using WaitAny");
        } else if (completedTaskIndex == 1) {
            Console.WriteLine("Task 7 completed first using WaitAny");
        }
    }

    public static async Task Main(string[] args) {
        await new Program().ExampleAsync();
    }
}

代码解析

这个综合示例展示了如何结合使用多个异步方法。以下是对各个部分的详细解析：

使用 await 异步等待任务

await Task.Delay(1000);
Console.WriteLine("End after 1 second");

await：异步等待一个任务完成，在任务完成后继续执行。

使用 Task.WhenAll 等待多个任务完成

Task task1 = Task.Delay(1000);
Task task2 = Task.Delay(2000);
await Task.WhenAll(task1, task2);
Console.WriteLine("All tasks completed using WhenAll");

Task.WhenAll：等待一组任务全部完成，在所有任务完成后继续执行。

使用 Task.WhenAny 等待任意一个任务完成

Task completedTask = await Task.WhenAny(task1, task2);
if (completedTask == task1) {
    Console.WriteLine("Task 1 completed first using WhenAny");
} else if (completedTask == task2) {
    Console.WriteLine("Task 2 completed first using WhenAny");
}

Task.WhenAny：等待一组任务中的任意一个完成，在第一个任务完成后继续执行。这个示例中，completedTask 用于判断哪个任务先完成。

使用 Task.Wait 同步等待任务完成

Task task3 = Task.Delay(1000);
task3.Wait();
Console.WriteLine("Task 3 completed using Wait");

Task.Wait：同步等待一个任务完成，在任务完成后继续执行。这种方式会阻塞当前线程，通常不建议在 UI 线程中使用。

使用 Task.WaitAll 同步等待多个任务完成

Task task4 = Task.Delay(1000);
Task task5 = Task.Delay(2000);
Task.WaitAll(task4, task5);
Console.WriteLine("All tasks completed using WaitAll");

Task.WaitAll：同步等待一组任务全部完成，在所有任务完成后继续执行。这种方式会阻塞当前线程，通常不建议在 UI 线程中使用。

使用 Task.WaitAny 同步等待任意一个任务完成

Task task6 = Task.Delay(1000);
Task task7 = Task.Delay(2000);
int completedTaskIndex = Task.WaitAny(task6, task7);
if (completedTaskIndex == 0) {
    Console.WriteLine("Task 6 completed first using WaitAny");
} else if (completedTaskIndex == 1) {
    Console.WriteLine("Task 7 completed first using WaitAny");
}

Task.WaitAny：同步等待一组任务中的任意一个完成，在第一个任务完成后继续执行。返回的 completedTaskIndex 用于判断哪个任务先完成。

11. 问题扩展

Task.WaitAll 是否等同于 await Task.WhenAll？

Task.WaitAll 和 await Task.WhenAll 也是两种不同的等待多个任务完成的方法，它们之间有着显著的区别，不能互换使用。下面我们将详细解释这两者的行为、应用场景和注意事项。

Task.WaitAll

定义

Task.WaitAll 是一个同步方法，用于阻塞调用线程，直到所有提供的任务完成。

行为

同步：调用 Task.WaitAll 会阻塞当前线程，直到所有任务完成。
线程阻塞：主线程或调用线程会被阻塞，直到所有任务完成。如果在 UI 线程中使用，会导致界面无响应。

示例代码
Task task1 = Task.Delay(1000);
Task task2 = Task.Delay(2000);
Task.WaitAll(task1, task2); // 阻塞当前线程，直到所有任务完成
Console.WriteLine("All tasks completed synchronously.");
应用场景

适用于在后台线程中等待多个任务完成。
控制台应用程序中需要确保所有任务完成后再继续执行其他操作。

注意事项

阻塞：Task.WaitAll 会阻塞当前线程，不适用于需要保持线程响应的场景（如 GUI 应用）。
异常处理：Task.WaitAll 会抛出 AggregateException，包含所有失败任务的异常，需在 try-catch 块中处理。

await Task.WhenAll

定义

Task.WhenAll 是一个异步方法，它接受一个任务数组，并返回一个新的任务，该任务将在所有提供的任务完成时完成。

行为

异步：调用 await Task.WhenAll 不会阻塞当前线程，异步等待所有任务完成。
非阻塞：调用线程可以继续执行其他操作，直到所有任务完成。

示例代码
Task task1 = Task.Delay(1000);
Task task2 = Task.Delay(2000);
await Task.WhenAll(task1, task2); // 异步等待所有任务完成
Console.WriteLine("All tasks completed asynchronously.");
应用场景

适用于需要同时等待多个异步任务且不希望阻塞当前线程的场景。
GUI 应用和 Web 应用中需要并行执行多个异步操作，然后在所有操作完成后继续处理结果。

注意事项

非阻塞：await Task.WhenAll 不会阻塞当前线程，适用于需要保持线程响应的场景。
异常处理：Task.WhenAll 会返回一个包含所有任务结果的任务，如果任何一个任务失败，返回的任务将以 AggregateException 形式封装所有单个任务的异常。

区别总结

行为

Task.WaitAll：同步等待所有任务完成，阻塞当前线程。
await Task.WhenAll：异步等待所有任务完成，不阻塞当前线程。

使用场景

Task.WaitAll：适用于在后台线程中等待多个任务完成，或控制台应用中需要确保所有任务完成后再继续执行。
await Task.WhenAll：适用于需要同时等待多个异步任务且不希望阻塞当前线程的场景，如 GUI 应用和 Web 应用。

异常处理

Task.WaitAll：会抛出 AggregateException，包含所有失败任务的异常，需要在 try-catch 块中处理。
await Task.WhenAll：返回的任务会封装所有任务的异常，需要在 try-catch 块中处理 AggregateException。

示例对比

Task.WaitAll 示例
try {
    Task task1 = Task.Delay(1000);
    Task task2 = Task.Delay(2000);
    Task.WaitAll(task1, task2); // 阻塞当前线程，直到所有任务完成
    Console.WriteLine("All tasks completed synchronously.");
} catch (AggregateException ex) {
    foreach (var innerEx in ex.InnerExceptions) {
        Console.WriteLine($"Exception: {innerEx.Message}");
    }
}
await Task.WhenAll 示例
try {
    Task task1 = Task.Delay(1000);
    Task task2 = Task.Delay(2000);
    await Task.WhenAll(task1, task2); // 异步等待所有任务完成
    Console.WriteLine("All tasks completed asynchronously.");
} catch (AggregateException ex) {
    foreach (var innerEx in ex.InnerExceptions) {
        Console.WriteLine($"Exception: {innerEx.Message}");
    }
}
注意事项和使用建议

避免阻塞主线程：在 GUI 或 Web 应用中，使用 Task.WaitAll 会阻塞主线程，导致界面或应用无响应。应尽量使用 await Task.WhenAll。
错误处理：无论使用哪种方法，都需要处理可能的异常。对于 Task.WaitAll 和 await Task.WhenAll，可以捕获 AggregateException 并处理内部异常。
超时机制：在等待多个任务时，建议添加超时机制，以防止无限等待。例如，可以使用 Task.WhenAny 与一个超时任务结合使用。

通过理解这些异步方法的区别和应用场景，你可以更灵活地选择和使用适合的等待任务完成的方法，从而编写出高效、可靠的异步代码。

12. 总结

本篇技术博客详细介绍了 C# 异步方法中的 Task.WhenAll、Task.WhenAny、await、Wait、WaitAll、WaitAny 的基本概念、用法、区别及注意事项。通过详细解析和完整的示例代码，我们展示了如何使用这些异步方法处理异步操作，并指出了在使用时需要注意的坑及解决方案。