答案是基于async和await的TAP模式是C#推荐的异步编程方式，它通过非阻塞I/O提升响应性和吞吐量，适用于I/O密集型操作，结合Task.Run可处理CPU密集型任务，相比传统多线程更简洁高效，避免回调地狱，需注意async void、ConfigureAwait和异常处理等最佳实践。
C#的异步编程模式，说到底，我们现在最常用也最推荐的，就是基于
async
和
await
关键字的Task-based Asynchronous Pattern (TAP)。它提供了一种非常优雅的方式来编写非阻塞代码，尤其是在处理那些耗时且需要等待结果的操作时，比如网络请求、文件读写或者长时间的计算。核心思想就是，当一个操作需要等待时，程序不会傻傻地卡在那里，而是可以去做其他有意义的事情，等操作完成再回来继续。这大大提升了应用程序的响应性和资源利用率。
解决方案
实现C#的异步编程，核心就是围绕着
async
和
await
这两个关键字，以及
Task
和
Task
类型展开。
首先，你需要将一个方法标记为
async
。这告诉编译器，这个方法里面可能会有
await
表达式。
async
关键字本身并不会让方法异步执行，它只是一个修饰符，允许你在方法体内部使用
await
。
public async Task FetchDataAsync(){ // ...}
接着，在
async
方法内部，当你调用一个同样返回
Task
或
Task
的异步操作时，你可以使用
await
关键字。
await
的作用是暂停当前方法的执行，并将控制权返回给调用者。当被
await
的操作完成时，控制权会回到
await
表达式之后的那一行，继续执行。
举个例子，假设我们想从一个API获取数据：
using System;using System.Net.Http;using System.Threading.Tasks;public class DataService{ private readonly HttpClient _httpClient = new HttpClient(); public async Task GetExternalDataAsync(string url) { Console.WriteLine($"[{DateTime.Now:HH:mm:ss.fff}] 开始请求数据..."); // 当执行到这里时，方法会暂停，并释放当前线程。 // 网络请求在后台进行，线程可以去做其他事情。 string data = await _httpClient.GetStringAsync(url); Console.WriteLine($"[{DateTime.Now:HH:mm:ss.fff}] 数据请求完成。"); return data; } public async Task ProcessDataAsync() { Console.WriteLine($"[{DateTime.Now:HH:mm:ss.fff}] 开始处理流程..."); string result = await GetExternalDataAsync("https://jsonplaceholder.typicode.com/todos/1"); Console.WriteLine($"[{DateTime.Now:HH:mm:ss.fff}] 接收到的数据长度: {result.Length}"); // 这里可以继续处理result Console.WriteLine($"[{DateTime.Now:HH:mm:ss.fff}] 流程处理完毕。"); } // 主调用方，通常是一个UI事件处理程序或控制台应用的Main方法 public static async Task Main(string[] args) { DataService service = new DataService(); // 调用异步方法 await service.ProcessDataAsync(); Console.WriteLine($"[{DateTime.Now:HH:mm:ss.fff}] 主程序继续执行其他操作..."); // 确保异步操作有足够时间完成，对于控制台应用，通常需要保持主线程活跃 // Console.ReadLine(); // 如果没有其他异步操作，可以用这个保持程序运行 }}
在这个例子里，当
GetExternalDataAsync
方法调用
_httpClient.GetStringAsync(url)
并
await
它时，当前线程并没有被阻塞。它会回到调用栈，允许UI线程响应用户输入，或者允许服务器处理其他请求。当网络请求完成后，一个合适的线程（通常是原来的上下文线程，或者线程池中的一个线程）会继续执行
GetStringAsync
之后的代码。这种模式对于I/O密集型操作尤其有效，因为它能极大地提高应用程序的吞吐量和响应速度。
对于CPU密集型操作，如果你想让它不阻塞调用线程，可以结合
Task.Run
来使用：
public async Task CalculateFactorialAsync(int n){ // 将CPU密集型计算放到线程池线程中执行，避免阻塞UI线程或请求处理线程。 long result = await Task.Run(() => { long factorial = 1; for (int i = 1; i <= n; i++) { factorial *= i; } return factorial; }); return result;}
这样，
Task.Run
会将计算任务调度到线程池中的一个线程上，而
await
则等待这个计算完成，同样不会阻塞调用
CalculateFactorialAsync
的线程。
为什么选择
async/await
async/await
而不是传统的线程或回调？
在我看来，
async/await
模式之所以成为C#异步编程的首选，关键在于它极大地简化了异步代码的编写和理解。回想一下以前，我们可能需要使用回调函数（Callback Hell）、事件驱动异步模式（EAP）或者异步编程模型（APM），那些代码写起来复杂，可读性差，错误处理也相当麻烦。当你的逻辑变得稍微复杂一点，多个异步操作需要串联或并行执行时，代码很快就会变得难以维护。
async/await
让异步代码看起来几乎和同步代码一样，它以一种“顺序执行”的错觉，优雅地处理了线程切换、上下文捕获和结果传递等底层细节。这意味着开发者可以把更多精力放在业务逻辑上，而不是陷在复杂的线程管理和同步机制中。对于现代应用程序，尤其是那些需要高响应性（比如桌面应用、移动应用）或者高吞吐量（比如Web服务器）的场景，
async/await
是提升用户体验和系统性能的利器。它能确保你的应用在等待外部资源时依然保持流畅，不会给用户带来卡顿感。
在
async/await
async/await
实践中，有哪些常见的“坑”和最佳实践？
虽然
async/await
用起来很爽，但它也不是没有自己的脾气。有些地方如果处理不好，可能会让你掉进“坑”里。
一个常见的误区是使用
async void
。
async void
方法主要用于事件处理程序，因为它允许事件订阅者异步执行而不需要返回一个
Task
。但除此之外，几乎所有其他场景都应该返回
async Task
或
async Task
。为什么呢？因为
async void
方法无法被
await
，这意味着你无法知道它何时完成，也无法捕获它内部抛出的异常。一旦
async void
方法内部抛出未处理的异常，它会直接回到应用程序的SynchronizationContext，如果没有合适的处理，就可能导致应用程序崩溃。这就像你放了一个风筝，线断了，你却不知道它飞到哪里去了。
// 避免：难以追踪完成和异常public async void BadAsyncVoidMethod(){ await Task.Delay(1000); throw new InvalidOperationException("Oops!"); // 这个异常很难被捕获}// 推荐：返回Task，可以被await，异常可捕获public async Task GoodAsyncTaskMethod(){ await Task.Delay(1000); // throw new InvalidOperationException("Oops!");}
另一个需要注意的点是
ConfigureAwait(false)
。当你
await
一个
Task
时，默认情况下，运行时会尝试捕获当前的“同步上下文”（SynchronizationContext）或“任务调度器”（TaskScheduler）。当异步操作完成后，它会尝试回到这个捕获的上下文继续执行
await
之后的代码。这对于UI应用非常有用，因为UI元素只能在UI线程上更新。但对于库代码或Web API的后端代码，这种上下文切换通常是不必要的，甚至会带来性能开销，或者在某些情况下导致死锁（特别是当你在同步代码中混合使用
await
和
.Result
或
.Wait()
时）。
所以，在库代码或不需要特定上下文的后端服务中，我通常会建议在
await
调用后加上
.ConfigureAwait(false)
。
// 库方法或后端服务中，通常不需要回到原始上下文public async Task FetchAndProcessDataAsync(string url){ // 不回到原始上下文，提高性能，避免死锁 string data = await _httpClient.GetStringAsync(url).ConfigureAwait(false); // 这里可以继续处理data return data.ToUpperInvariant();}
这样告诉运行时，异步操作完成后，不需要强制回到原始上下文，可以在任何可用的线程池线程上继续执行，这有助于减少开销并避免潜在的死锁问题。但请记住，一旦你使用了
ConfigureAwait(false)
，
await
之后你就不能再访问任何依赖于原始上下文的状态了，比如UI控件。
最后，异常处理。异步方法中的异常处理和同步方法类似，可以使用
try-catch
块。但要注意，如果一个
Task
被
await
了，它的异常会在
await
点重新抛出。如果
Task
没有被
await
，它的异常会在
Task
被垃圾回收时（或者在
.Result
或
.Wait()
被调用时）抛出，这可能会导致程序崩溃，而且很难调试。所以，确保所有
Task
都被妥善地
await
或处理。
public async Task RobustOperationAsync(){ try { string data = await _httpClient.GetStringAsync("http://invalid.url").ConfigureAwait(false); Console.WriteLine(data); } catch (HttpRequestException ex) { Console.WriteLine($"网络请求失败: {ex.Message}"); } catch (Exception ex) { Console.WriteLine($"发生未知错误: {ex.Message}"); }}
async/await
async/await
与传统多线程编程有何不同？
这是一个经常被问到的问题，也常常被混淆。在我看来，理解
async/await
与传统多线程（比如直接使用
Thread
类或
ThreadPool
）以及并行编程（比如
Parallel.For
或PLINQ）的区别至关重要。
最核心的区别在于：
async/await
主要是关于非阻塞I/O，它关注的是如何让一个操作在等待某个外部资源（如网络响应、磁盘读写）时，不占用或阻塞当前的执行线程，从而提高应用程序的响应性和吞吐量。它本身并不会创建新的线程来并行执行代码。当一个方法
await
一个
Task
时，当前线程会被释放，可以去做其他事情。当被
await
的
Task
完成时，
await
之后的代码会在一个可用的线程上（可能是原始线程，也可能是线程池中的一个线程）继续执行。所以，你可以把
async/await
看作是一种“协作式多任务”或者“事件驱动”的编程模型，它更多是关于并发（concurrency）而不是并行（parallelism）。
而传统的多线程编程，比如直接创建
new Thread()
或者使用
ThreadPool.QueueUserWorkItem
，以及并行编程，比如
Task.Run
（不带
await
），
Parallel.For
/
ForEach
，它们的目标是并行执行代码。它们会利用多个CPU核心或多个线程来同时执行不同的计算任务，以减少总的执行时间。这种模式更适合于CPU密集型任务，因为这些任务需要大量的计算资源。
简单来说：
async/await
： 适合I/O密集型操作。它让你的程序在等待外部资源时“空闲”下来，去做其他事情，而不是阻塞等待。它不一定增加CPU的利用率，但能显著提高响应性和吞吐量。它通常使用较少的线程，通过上下文切换来模拟并发。传统多线程/并行编程： 适合CPU密集型操作。它通过分配多个线程或利用多核处理器来同时执行计算任务，以缩短总的计算时间。这会增加CPU的利用率。
当然，两者并非完全独立。在某些情况下，你会希望将一个CPU密集型任务转换为异步操作，以便不阻塞调用线程。这时，你就可以结合使用
Task.Run
和
await
：
// CPU密集型任务，但希望通过async/await使其不阻塞调用线程public async Task PerformCpuIntensiveWorkAsync(){ // Task.Run 将计算任务调度到线程池，await 等待结果 int result = await Task.Run(() => { // 模拟一个耗时的CPU计算 int sum = 0; for (int i = 0; i < 1_000_000_000; i++) { sum += i; } return sum; }); return result;}
这里，
Task.Run
负责将CPU密集型计算放到一个单独的线程池线程上执行，而
await
则让
PerformCpuIntensiveWorkAsync
方法在等待计算完成时是非阻塞的。这是一种将并行计算融入异步流程的常见模式。理解这些差异，能够帮助我们根据具体的场景，选择最合适的编程模型。
以上就是C#的异步编程模式是什么？如何实现？的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1439365.html
微信扫一扫 
支付宝扫一扫 
