C#学习第9天：异步编程模型（Async/Await）

最新推荐文章于 2025-04-27 15:07:09 发布

ghost143

最新推荐文章于 2025-04-27 15:07:09 发布

阅读量295

点赞数 5

分类专栏： C#学习30天计划文章标签：学习 c# 开发语言

本文链接：https://blog.csdn.net/ghost143/article/details/146902859

版权

C#学习30天计划专栏收录该内容

26 篇文章

订阅专栏

异步编程允许您在不阻塞主线程的情况下执行耗时操作，从而保持应用程序的响应性。在C#中，async和await关键字是实现异步编程的基础。

基本概念

同步 vs 异步

同步模型

任务是顺序执行的，一个任务完成后才开始下一个任务。这意味着如果有一个耗时的操作，整个流程会被阻塞，直到该操作完成。

Start Task 1
   |
   v
Complete Task 1
   |
   v
Start Task 2
   |
   v
Complete Task 2
   |
   v
... (continue)

特点：

阻塞：当前任务必须等到前一个任务完成。
简单：易于实现和调试。
整体响应性差：如果某个任务很耗时，会导致整体的等待。

异步模型

在异步模型中，任务可以并发执行。一个任务在等待（例如I/O操作）时，其他任务可以继续执行。这提高了程序的效率和响应性。

Start Task 1
   |   
   +---------------------------------+
   |                                 |
   v                                 |
(Wait for I/O)                  Start Task 2
   |                                 |
   v                                 v
(Task 1 Continues)          Complete Task 2
   |
   v
Complete Task 1

特点：

非阻塞：任务可以在等待资源或操作时切换到其他任务。
更复杂：需要考虑回调、状态管理和错误处理。
高响应性：适合I/O密集型应用，如网络请求。

核心关键字

async：标识一个异步方法。
await：暂停异步方法的执行，直到被等待的任务完成。

使用示例

异步方法定义

public async Task<int> FetchDataAsync()
{
    await Task.Delay(1000); // 模拟异步操作
    return 42;
}

使用async修饰符定义异步方法。
返回类型通常为Task或Task<T>。

调用异步方法

using System;
using System.Threading.Tasks;

public class LongRunningTaskExample
{
    // 模拟长时间运行的计算任务
    public static async Task<int> LongRunningCalculationAsync()
    {
        await Task.Delay(2000); // 模拟耗时操作，例如复杂计算
        return 100; // 返回计算结果
    }

    public static async Task Main(string[] args)
    {
        int result = await LongRunningCalculationAsync();
        Console.WriteLine($"Result of long running calculation: {result}");


        //也可以用 try catch
        try
        {
            int result = await LongRunningOperationAsync();
            Console.WriteLine($"Result: {result}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An error occurred: {ex.Message}");
        }
    }
}

异常处理： 异步方法内部抛出的异常可以在await语句中捕获。

使用async void进行延迟操作

假设我们有一个GUI应用程序，需要在用户点击按钮时显示一条消息，并在短暂延迟后自动隐藏这条消息。async void可以用来实现这个需求，因为我们不需要从调用者处等待任务完成。

using System;
using System.Threading.Tasks;

public class DelayedActionExample
{
    // 模拟一个控制台应用中的用户按钮点击事件
    public static void OnButtonClick()
    {
        ShowMessageWithDelay();
    }

    // 使用 async void 来延迟隐藏信息
    private static async void ShowMessageWithDelay()
    {
        Console.WriteLine("Message: Processing your request...");

        // 延迟3秒钟
        await Task.Delay(3000);

        Console.WriteLine("Message: Done");
    }

    public static void Main(string[] args)
    {
        OnButtonClick();

        // 保持控制台打开以观察输出
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}

注意事项

async void方法不能被await，也未能提供一个Task对象来捕获异常，这意味着任何未处理的异常都会终止应用程序。
在大多数情况下，建议使用async Task或async Task<T>，除非是在事件处理器或特殊的延迟功能场合下。

实践习题

1.异步读取和处理大文件

编写一个方法，异步读取一个大型文本文件，并统计每行中单词的数量。然后输出每行的字数统计结果。

using System;
using System.IO;
using System.Threading.Tasks;

public class FileProcessingExample
{
    public static async Task ProcessFileAsync(string filePath)
    {
        using (StreamReader reader = new StreamReader(filePath))
        {
            string line;
            int lineNumber = 0;
            
            while ((line = await reader.ReadLineAsync()) != null)
            {
                lineNumber++;
                int wordCount = line.Split(' ', StringSplitOptions.RemoveEmptyEntries).Length;
                Console.WriteLine($"Line {lineNumber}: {wordCount} words");
            }
        }
    }

    public static async Task Main(string[] args)
    {
        string filePath = "largefile.txt"; // Path to the large text file
        await ProcessFileAsync(filePath);
    }
}

说明：该方法逐行读取文件，使用ReadLineAsync以非阻塞方式获取每一行，从而保持程序响应性。
适用场景：适用于需要对大型文本文件进行分析、日志处理等操作的场合。

2.并发网络请求集合

使用HttpClient发送多个并发的HTTP GET请求至不同的URL，收集每个URL的响应时间，并输出总耗时和每个请求的状态码。

using System;
using System.Diagnostics;
using System.Net.Http;
using System.Threading.Tasks;

public class ConcurrentRequestsExample
{
    private static readonly HttpClient client = new HttpClient();

    public static async Task FetchUrlsAsync(string[] urls)
    {
        var stopwatch = Stopwatch.StartNew();
        var tasks = new Task<HttpResponseMessage>[urls.Length];

        for (int i = 0; i < urls.Length; i++)
        {
            tasks[i] = client.GetAsync(urls[i]);
        }

        HttpResponseMessage[] responses = await Task.WhenAll(tasks);

        stopwatch.Stop();
        
        for (int i = 0; i < responses.Length; i++)
        {
            Console.WriteLine($"URL: {urls[i]}, Status Code: {responses[i].StatusCode}");
        }

        Console.WriteLine($"Total time taken: {stopwatch.ElapsedMilliseconds} ms");
    }

    public static async Task Main(string[] args)
    {
        string[] urls = 
        { 
            "https://www.example.com", 
            "https://www.contoso.com", 
            "https://www.microsoft.com" 
        };
        
        await FetchUrlsAsync(urls);
    }
}