【C# 基础精讲】Task和Task＜T＞的应用

当涉及异步编程时，Task 和 Task 是C#中的重要概念。它们不仅是处理异步操作的关键类型，还提供了一些强大的功能和方法，使异步编程更加高效和灵活。在本文中，我们将深入探讨 Task 和 Task 的应用，从创建、执行、等待到取消和异常处理等方面进行详细讨论，帮助您更好地理解如何在C#中应用这些类型。

1. Task 和 Task 的创建

1.1 创建 Task

Task 表示一个异步操作，可以通过多种方式创建。

使用 Task 的构造函数

Task task = new Task(() =>
{
    // 异步操作的代码
});
1
2
3
4

使用 Task.Run

Task task = Task.Run(() =>
{
    // 异步操作的代码
});
1
2
3
4

1.2 创建 Task

Task 表示一个异步操作，它会返回一个类型为 T 的结果。

使用 Task 的构造函数

Task<int> task = new Task<int>(() =>
{
    // 异步操作的代码，返回 int 类型结果
    return 42;
});
1
2
3
4
5

使用 Task.Run

Task<int> task = Task.Run(() =>
{
    // 异步操作的代码，返回 int 类型结果
    return 42;
});
1
2
3
4
5

2. 启动和等待 Task 和 Task

2.1 启动 Task

要启动一个 Task，可以调用其 Start 方法。

task.Start();
1

2.2 使用 await 等待 Task 和 Task

在异步方法中，通过使用 await 关键字来等待 Task 和 Task 的完成。

await task; // 等待 Task 完成
int result = await task; // 等待 Task 完成，并获取结果
1
2

2.3 使用 Wait 阻塞等待

虽然使用 await 可以异步等待任务的完成，但有时可能需要在同步代码中等待任务完成。这时可以使用 Wait 方法，但应谨慎使用，以免造成死锁。

task.Wait(); // 阻塞当前线程，等待任务完成
int result = task.Result; // 阻塞当前线程，等待任务完成，并获取结果
1
2

3. 异步任务的状态和异常处理

3.1 异步任务的状态

异步任务有几个重要的状态：

• TaskStatus.Created：任务已创建，但尚未启动。
• TaskStatus.WaitingForActivation：任务正在等待激活。
• TaskStatus.WaitingToRun：任务正在等待执行。
• TaskStatus.Running：任务正在执行。
• TaskStatus.RanToCompletion：任务已成功完成。
• TaskStatus.Canceled：任务已被取消。
• TaskStatus.Faulted：任务由于异常而失败。

3.2 异常处理

在异步任务中捕获和处理异常与同步代码类似。可以使用 try-catch 块来捕获任务中的异常。

try
{
    await Task.Run(() =>
    {
        // 异步操作的代码
    });
}
catch (Exception ex)
{
    Console.WriteLine($"发生异常：{ex.Message}");
}
1
2
3
4
5
6
7
8
9
10
11

4. 并行执行多个任务

4.1 Task.WhenAll

Task.WhenAll 方法接受一个 Task 数组，当数组中的所有任务都完成时，返回一个新的任务。

Task[] tasks = new Task[]
{
    Task.Run(() => DoTask1()),
    Task.Run(() => DoTask2()),
    Task.Run(() => DoTask3())
};

await Task.WhenAll(tasks); // 等待所有任务完成
1
2
3
4
5
6
7
8

4.2 Task.WhenAny

Task.WhenAny 方法接受一个 Task 数组，返回一个 Task，该任务在数组中的任何一个任务完成时就会完成。

Task<string>[] tasks = new Task<string>[]
{
    Task.Run(() => DoTask1()),
    Task.Run(() => DoTask2()),
    Task.Run(() => DoTask3())
};

Task<string> completedTask = await Task.WhenAny(tasks); // 等待任何一个任务完成
string result = completedTask.Result; // 获取完成的任务的结果
1
2
3
4
5
6
7
8
9

5. 取消任务

5.1 使用 CancellationToken

CancellationToken 是一个用于传递取消请求的标记。可以在任务的异步操作中检查 CancellationToken 是否已被触发，如果是则取消任务。

CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
CancellationToken cancellationToken = cancellationTokenSource.Token;

Task task = Task.Run(() =>
{
    while (!cancellationToken.IsCancellationRequested)
    {
        // 异步操作的代码
    }
}, cancellationToken);
1
2
3
4
5
6
7
8
9
10

5.2 取消已开始的任务

cancellationTokenSource.Cancel(); // 取消任务
1

6. 使用 Task 返回异步操作的结果

6.1 返回结果的异步操作

Task<int> CalculateAsync()
{
    return Task.Run(() =>
    {
        int result = 0;
        // 计算操作的代码
        return result;
    });
}
1
2
3
4
5
6
7
8
9

6.2 使用 await 获取异步操作的结果

int result = await CalculateAsync(); // 等待操作完成，并获取结果
1

7. 异步任务的嵌套

7.1 嵌套异步方法的调用

在异步方法中调用另一个异步方法是很常见的，但不会导致阻塞。调用链中的每个异步方法都会按照异步的方式执行。

public async Task OuterMethodAsync()
{
    Console.WriteLine("开始外部方法");
    await InnerMethodAsync();
    Console.WriteLine("结束外部方法");
}

public async Task InnerMethodAsync()
{
    Console.WriteLine("开始内部方法");
    await Task.Delay(1000); // 模拟异步操作
    Console.WriteLine("结束内部方法");
}
1
2
3
4
5
6
7
8
9
10
11
12
13

7.2 避免异步嵌套过深

尽管异步方法可以嵌套调用，但要注意避免异步嵌套过深，以保持代码的可读性和维护性。

8. 使用 Task 和 Task 的最佳实践

8.1 避免阻塞

在异步编程中，避免使用 Wait、Result 等方法来阻塞线程。使用 await 来异步等待任务的完成。

8.2 使用适当的异常处理

在异步编程中，异常的处理方式与同步代码类似。使用 try-catch 块来捕获和处理异常，确保程序的稳定性。

8.3 关闭取消标记

在使用 CancellationTokenSource 创建取消标记时，要确保在不再需要时关闭取消标记，以防止资源泄漏。

cancellationTokenSource.Dispose(); // 关闭取消标记
1

8.4 合理使用 Task.Run

尽管 Task.Run 可以将同步代码转换为异步代码，但不应在所有地方都使用它。考虑到异步操作的开销，只有耗时的操作才适合使用。

9. 总结

Task 和 Task 是C#中异步编程的关键概念，它们为处理异步操作提供了强大的工具。通过合理使用 Task 和 Task，我们可以更高效地创建、启动、等待和管理异步任务，从而提高程序的性能、并发性和响应性。了解如何创建、执行、等待和取消任务，以及如何处理异常，可以帮助我们更好地编写可靠和高效的异步代码。无论是GUI应用程序还是服务器端开发，Task 和 Task 都是实现高效异步编程的重要工具。