异步方法的定义和调用

大王小生

641人浏览 · 2024-03-15 15:40:21

大王小生 · 2024-03-15 15:40:21 发布

在C#中，异步编程是一种常用的技术，它允许程序在不阻塞主线程的情况下执行耗时的操作，比如网络请求、文件I/O等。自从C# 5.0引入了async和await关键字后，异步编程变得更加简单和直观。

1. 定义异步方法

要定义一个异步方法，使用async关键字，并将方法的返回类型设置为Task或Task<T>（其中T是返回类型）。例如：

public async Task MyAsyncMethod()

{

// 异步操作

await Task.Delay(1000); // 模拟异步操作，比如网络请求

Console.WriteLine("异步操作完成");

}

对于返回结果的异步方法：

public async Task<int> MyAsyncMethodWithResult()

{

// 异步操作

await Task.Delay(1000); // 模拟异步操作

return 42; // 返回结果

}

2. 使用`await`关键字

await关键字用于等待一个异步操作的完成。它只能在标记为async的方法内部使用。例如：

public async Task CallAsyncMethod()

{

Console.WriteLine("调用异步方法前");

await MyAsyncMethod(); // 等待异步方法完成

Console.WriteLine("调用异步方法后");

}

3. 处理异常

在async方法中，你可以使用try-catch块来捕获由await表达式引发的异常。例如：

public async Task HandleExceptions()

{

try

{

await MyAsyncMethod(); // 可能抛出异常的异步操作

}

catch (Exception ex)

{

Console.WriteLine($"发生异常: {ex.Message}");

}

4. 配置和取消异步操作

对于需要取消的异步操作，可以使用CancellationToken。例如：

public async Task MyCancellableAsyncMethod(CancellationToken token)

{

while (!token.IsCancellationRequested)

{

// 执行一些工作，但不阻塞主线程

await Task.Delay(100, token); // 可以响应取消请求

}

var cts = new CancellationTokenSource();

var token = cts.Token;

Task task = MyCancellableAsyncMethod(token); // 启动异步操作

cts.Cancel(); // 请求取消操作

await task; // 等待任务完成（即使被取消）

5. 使用`async/await`的注意事项：

await表达式会导致当前异步方法暂停执行，直到await关键字等待的任务完成，这有助于避免阻塞线程。但，调用方县城并不会阻塞，当调用方线程执行到异步方法的await关键字后，返回调用方线程代码，继续往下执行代码！！！
async/await主要用于IO密集型操作，而不是CPU密集型操作。对于CPU密集型任务，考虑使用Task.Run()来在后台线程上执行。例如：await Task.Run(() => HeavyComputation());。
在UI线程中使用async/await可以避免界面冻结，特别是在Windows Forms、WPF或Xamarin等环境中。
在ASP.NET Core中，使用async/await可以提高应用程序的响应性，因为它允许I/O操作在不影响其他请求处理的情况下进行。

通过合理使用async/await，你可以编写出既高效又响应迅速的异步应用程序。

如下demo1，定义了一个返回值为Task的异步方法，调用该异步方法时，方法前面加上await关键字，新开辟一个线程执行该任务，调用方线程不等待该异步方法的task执行结束，继续执行其代码。

        static async void M()
        {
            await MethodAsync();
        }

        /// <summary>
        /// 异步方法，返回值为Task
        /// </summary>
        /// <returns></returns>
        async static Task MethodAsync()
        {
            Console.WriteLine("Start Running async Method");
            await Task.Delay(5000);//模拟耗时的操作，例如等待外部相应或IO操作
            Console.WriteLine("Stop Running async Method");
        }

        static void Main(string[] args)
        {
            Console.WriteLine("Start Running Main Method entry Point");

            M();

            Console.WriteLine("Stop Running Main Method entry Point");

            Console.ReadKey();
        }

执行结果如下，异步方法不影响调用方线程继续执行，不需要等待异步方法执行结束，提高效率，提高用户体验，奈斯~！

如下demo2伪代码也是演示了异步方法的执行过程，介绍略。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace AsyncMethod
{
    class Program
    {
        static void Main(string[] args)
        {
            //async method keyword: await async
            Console.WriteLine($"Main() start code line:{Thread.CurrentThread.ManagedThreadId}");

            //调用返回值void的异步方法,调用不能用await关键字
            AsyncMethod();
            
            Console.WriteLine($"Main() end code line:{Thread.CurrentThread.ManagedThreadId}");

            Console.ReadKey();
        }

        /// <summary>
        /// 返回值为void的异步方法，如果异步方法内没有await关键字，则这个异步方法的调用与普通的同步方法没有区别
        /// </summary>
        static async void AsyncMethod()
        {
            //调用线程进入异步方法执行代码
            Console.WriteLine($"async method start code line:{Thread.CurrentThread.ManagedThreadId}");

            //调用线程遇到异步方法第一个await，返回调用线程继续执行异步方法下面的代码，task由新的线程执行
            await Task.Run(() => 
            {
                Thread.Sleep(100);
                Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
                Thread.Sleep(1000);
            });

            Console.WriteLine($"code after void async method await:{Thread.CurrentThread.ManagedThreadId}");

            //调用的异步方法AsyncMethodReturnTask，调用前加关键字await
            //在方法内部第一个await关键字时，调用线程终止，await的Task代码及后面的代码，由新分配的线程执行
            await AsyncMethodReturnTask();
            
            //异步方法await后面的语句，等Task代码执行结束后，由新开的task的线程继续执行
            Console.WriteLine($"async method end code line:{Thread.CurrentThread.ManagedThreadId}");
        }

        /// <summary>
        /// 返回值为Task的异步方法
        /// </summary>
        /// <returns></returns>
        static async Task AsyncMethodReturnTask()
        {
            Console.WriteLine($"AsyncMethodReturnTask start:{Thread.CurrentThread.ManagedThreadId}");

            //public static Task<TResult> Run<TResult>(Func<TResult> function);
            int result = await Task.Run(() => 
            {
                Thread.Sleep(2000);
                return 666;
            });

            Console.WriteLine($"AsyncMethodReturnTask end:{Thread.CurrentThread.ManagedThreadId}");
        }
    }
}

代码执行结果如下》》》