异步编程 - 《C#编程指南》 - 严富坤的知识库专栏(yanfukun.com)

异步编程的背景与意义
异步编程模型概述
基于任务的异步编程（TAP）
异步编程的应用场景
异步编程中的常见问题
- 死锁
- 取消异步操作
高级异步编程技术
- 异步流
- 异步锁
异步编程的最佳实践
小结

异步编程是现代编程中不可或缺的一部分，尤其是在处理I/O密集型操作和提高应用程序的响应能力时，异步编程显得尤为重要。C#作为一门现代化的编程语言，提供了丰富的异步编程支持，从最初的异步编程模型（APM）到基于任务的异步模式（TAP），再到引入async和await关键字，使异步编程变得更加简洁和直观。本文将深入探讨C#中的异步编程，全面解析其原理和机制，并结合实际案例，帮助读者掌握异步编程的精髓。

异步编程的背景与意义

在传统的同步编程模型中，所有操作都是按顺序执行的。当一个操作阻塞时，整个程序的执行也会被阻塞，这在处理I/O操作（如文件读写、网络请求）时尤为明显。为了提高程序的响应能力和性能，异步编程应运而生。异步编程允许程序在等待I/O操作完成时继续执行其他任务，从而提高资源利用率和程序响应速度。

异步编程模型概述

C#中主要有三种异步编程模型：

异步编程模型（APM，Asynchronous Programming Model）
事件驱动模型（EAP，Event-based Asynchronous Pattern）
任务异步模型（TAP，Task-based Asynchronous Pattern）

异步编程模型（APM）

APM是最早的异步编程模型，通过BeginXXX和EndXXX方法来实现异步操作。APM的缺点是代码复杂且难以维护。

public void BeginReadExample()
{
    FileStream fs = new FileStream("example.txt", FileMode.Open, FileAccess.Read, FileShare.Read, 4096, true);
    byte[] buffer = new byte[1024];
    fs.BeginRead(buffer, 0, buffer.Length, new AsyncCallback(ReadCallback), fs);
}
private void ReadCallback(IAsyncResult ar)
{
    FileStream fs = (FileStream)ar.AsyncState;
    int bytesRead = fs.EndRead(ar);
    // 处理读取的数据
    fs.Close();
}

事件驱动模型（EAP）

EAP通过事件和事件处理程序来实现异步操作，常见于早期的.NET框架组件中。虽然EAP比APM更易于使用，但其复杂性和回调地狱的问题依然存在。

public void DownloadFileAsyncExample()
{
    WebClient client = new WebClient();
    client.DownloadFileCompleted += new AsyncCompletedEventHandler(DownloadFileCallback);
    client.DownloadFileAsync(new Uri("http://example.com/file.txt"), "file.txt");
}
private void DownloadFileCallback(object sender, AsyncCompletedEventArgs e)
{
    if (e.Error == null)
    {
        // 处理下载完成
    }
    else
    {
        // 处理错误
    }
}

任务异步模型（TAP）

TAP是目前C#中最推荐的异步编程模型，通过Task和Task类来实现异步操作。TAP与async和await关键字结合使用，使得异步编程更加直观和简洁。

public async Task DownloadFileAsync()
{
    using (HttpClient client = new HttpClient())
    {
        string content = await client.GetStringAsync("http://example.com/file.txt");
        // 处理下载内容
    }
}

基于任务的异步编程（TAP）

Task类与Task类

Task类表示一个异步操作，而Task类表示一个返回值的异步操作。Task类提供了一系列方法和属性，用于管理和控制异步操作。

public async Task ExampleAsync()
{
    Task<int> task = Task.Run(() => Compute());
    int result = await task;
    Console.WriteLine(result);
}
private int Compute()
{
    // 模拟计算
    Thread.Sleep(1000);
    return 42;
}

async和await关键字

async关键字用于标记一个方法为异步方法，await关键字用于等待一个异步操作的完成。使用async和await关键字可以使异步代码看起来像同步代码，极大地提高了代码的可读性和可维护性。

public async Task<int> ComputeAsync()
{
    await Task.Delay(1000); // 模拟异步操作
    return 42;
}
public async Task MainAsync()
{
    int result = await ComputeAsync();
    Console.WriteLine(result);
}

异步异常处理

在异步方法中，可以使用try-catch语句来处理异常。异步方法中的异常会被包装在一个AggregateException对象中，需要使用await关键字将其展开。

public async Task HandleExceptionAsync()
{
    try
    {
        await Task.Run(() => { throw new InvalidOperationException("发生异常"); });
    }
    catch (InvalidOperationException ex)
    {
        Console.WriteLine($"捕获异常: {ex.Message}");
    }
}

异步编程的应用场景

I/O操作

异步编程最常见的应用场景之一是I/O操作，如文件读写和网络请求。通过异步操作，可以避免阻塞主线程，提高程序的响应能力。

public async Task ReadFileAsync(string filePath)
{
    using (FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, true))
    {
        byte[] buffer = new byte[fs.Length];
        await fs.ReadAsync(buffer, 0, buffer.Length);
        string content = Encoding.UTF8.GetString(buffer);
        Console.WriteLine(content);
    }
}
public async Task DownloadFileAsync(string url, string filePath)
{
    using (HttpClient client = new HttpClient())
    {
        byte[] data = await client.GetByteArrayAsync(url);
        await File.WriteAllBytesAsync(filePath, data);
    }
}

GUI编程

在GUI编程中，异步编程可以避免长时间的操作阻塞UI线程，从而保持界面的响应性。

public async void Button_Click(object sender, RoutedEventArgs e)
{
    string result = await LongRunningOperationAsync();
    MessageBox.Show(result);
}
private async Task<string> LongRunningOperationAsync()
{
    await Task.Delay(3000); // 模拟长时间操作
    return "操作完成";
}

并行处理

通过异步编程，可以实现并行处理，提高程序的执行效率。例如，可以同时发送多个网络请求或并行处理多个计算任务。

public async Task<int[]> ComputeMultipleAsync()
{
    Task<int> task1 = Task.Run(() => Compute(1));
    Task<int> task2 = Task.Run(() => Compute(2));
    Task<int> task3 = Task.Run(() => Compute(3));
    int[] results = await Task.WhenAll(task1, task2, task3);
    return results;
}
private int Compute(int id)
{
    Thread.Sleep(1000); // 模拟计算
    return id * 42;
}

异步编程中的常见问题

死锁

在异步编程中，死锁是一个常见的问题。死锁通常发生在同步上下文中，尤其是在GUI应用程序中。为了避免死锁，可以使用ConfigureAwait(false)来避免捕获同步上下文。

public async Task DeadlockExample()
{
    // 错误示例：可能导致死锁
    Task.Run(() => SomeAsyncMethod().Wait()).Wait();
    // 正确示例：使用ConfigureAwait(false)避免死锁
    await SomeAsyncMethod().ConfigureAwait(false);
}
private async Task SomeAsyncMethod()
{
    await Task.Delay(1000);
}

取消异步操作

在某些情况下，需要能够取消异步操作。可以使用CancellationToken来实现取消功能。

public async Task LongRunningOperationAsync(CancellationToken cancellationToken)
{
    for (int i = 0; i < 10; i++)
    {
        cancellationToken.ThrowIfCancellationRequested();
        await Task.Delay(1000, cancellationToken); // 模拟长时间操作
    }
}
public async Task ExampleAsync()
{
    using (CancellationTokenSource cts = new CancellationTokenSource())
    {
        Task task = LongRunningOperationAsync(cts.Token);
        // 模拟用户取消操作
        await Task.Delay(3000);
        cts.Cancel();
        try
        {
            await task;
        }
        catch (OperationCanceledException)
        {
            Console.WriteLine("操作已取消");
        }
    }
}

高级异步编程技术

异步流

C# 8.0引入了异步流（IAsyncEnumerable），允许异步地生成和处理数据流。异步流使得处理大量数据时更加高效。

public async IAsyncEnumerable<int> GenerateSequenceAsync()
{
    for (int i = 0; i < 10; i++)
    {
        await Task
.Delay(500); // 模拟异步操作
        yield return i;
    }
}
public async Task ConsumeSequenceAsync()
{
    await foreach (int value in GenerateSequenceAsync())
    {
        Console.WriteLine(value);
    }
}

异步锁

在异步编程中，传统的锁（lock）不能用于异步方法。可以使用SemaphoreSlim或第三方库（如AsyncEx）提供的异步锁来解决这一问题。

private SemaphoreSlim _lock = new SemaphoreSlim(1, 1);
public async Task SafeMethodAsync()
{
    await _lock.WaitAsync();
    try
    {
        // 安全的异步操作
        await Task.Delay(1000);
    }
    finally
    {
        _lock.Release();
    }
}

异步编程的最佳实践

避免阻塞

在异步方法中，尽量避免使用同步阻塞操作（如Wait、Result），以免导致死锁和性能问题。

public async Task ExampleAsync()
{
    // 错误示例：同步阻塞操作
    Task<int> task = Task.Run(() => 42);
    int result = task.Result;
    // 正确示例：使用await
    result = await task;
}

使用值任务（ValueTask）

在某些高性能场景下，可以使用ValueTask来避免不必要的分配开销。ValueTask是一种更轻量级的异步结果表示形式，但需要谨慎使用。

public async ValueTask<int> ComputeAsync()
{
    return await Task.FromResult(42);
}

正确处理异常

在异步方法中，确保正确处理异常，避免未处理的异常导致程序崩溃。

public async Task HandleExceptionAsync()
{
    try
    {
        await Task.Run(() => { throw new InvalidOperationException("发生异常"); });
    }
    catch (InvalidOperationException ex)
    {
        Console.WriteLine($"捕获异常: {ex.Message}");
    }
}

小结

异步编程是C#中一个强大且灵活的特性，通过异步编程，可以有效提高程序的响应能力和性能。本文深入探讨了C#中的异步编程，介绍了不同的异步编程模型、常见的应用场景以及高级异步编程技术。希望本文能帮助读者更好地理解和掌握C#中的异步编程，在实际开发中充分利用这一强大的编程工具。