ASP.Net Core异步编程

什么是异步编程？

异步编程是可以让程序并行运行的一种手段，其可以让程序中的一个工作单元与主应用程序线程分开独立运行，并且在工作单元运行结束后，会通知主应用程序线程它的运行结果或者失败原因。使用异步编程可以提高应用程序的性能和响应能力。[^1]

应当注意的是，所谓的异步编程能提高效率这句话并不严谨，严格的来说它是利用了等待时间以优化整体的时间效率，而对于其中任意一项工作其本来的效率并没提高。

如果你对此概念的理解还是十分抽象，下面我们用一道小学数学题来举例。

小明的妈妈做饭要a分钟，烧水要b分钟，请问小明妈妈烧水并做饭一共要多长时间（a与b均大于0）？我们不妨记最终所用时间为T，则有如下情况：

• 对于传统的同步编程来讲，小明妈妈要先烧水然后做饭或者先做饭然后去烧水，烧水或做饭的时间内是无法做其他事情的，这个等待的过程我们称为阻塞的。这样所用的总时间如下

\[T_1 = a + b
\]

• 然而对于异步编程，就是让小明妈妈将烧水壶通电进行烧水，烧水由烧水壶负责，而小明妈妈可以一边做饭一边等水烧开。简单来讲就是在等待一件事情完成的同时，利用这段空闲时间去做其他事情，这个过程是非阻塞的。所以所用时间如下：

\[T_2 = \max (a,b)
\]

然而由简单的数学知识可知

\[x \le \max (a,b) < a+b,\space x\in \left \{ a,b \right \}
\]

所以问题来了：对于烧水或做饭的效率提高了吗？答案是没有。因为烧水仍然要b分钟，做饭仍然要a分钟。然而对于整体的效率却得到了提升，就如上方公式所表示的那样。

异步方法的定义

在.net中所谓的异步方法，一般是指async关键字修饰的方法。该方法有如下特点：

• 异步方法的返回值一般是Task<T>，T是真正的返回值类型，如Task<int>。即使方法没有返回值，也最好把返回值声明为非泛型的Task。（按钮等控件事件响应方法用void）
• 异步方法名字以Async结尾。
• 调用异步方法时，一般方法前面加上await关键字，这样返回值就是泛型指定的T类型。
• 一个方法中如果有await调用的异步方法，那么该方法也必须是async修饰的异步方法。

下面我们利用C#自带的异步同步方法写入再读取txt文件

同步方法：

//同步
using System;

namespace ConsoleApp1
{
    class Program
    {

        static void Main(string[] args)
        {
            string filename = "test.txt";   //读取/写入文件名
            File.WriteAllText(filename, "hello,world");
            string str = File.ReadAllText(filename);
            Console.WriteLine(str);
        }
    }
}

异步方法：

//异步
using System;

namespace ConsoleApp1
{
    class Program
    {

        static async Task Main(string[] args)   //注意这里Main函数变化
        {
            string filename = "test.txt";   //读取/写入文件名
            //如果此处不写await，此处不会等待就进行读取。当数据多的时候，一边写一边读，由于写入操作占用文件，当执行下方读取语句的时候程序会报错。
            await File.WriteAllTextAsync(filename, "hello");
            /*
             * 对于ReadAllTextAsync返回值是Task<string>，添加await后会自动把string从Task拿出来
             * 否则要这样写
             * Task<string> t = File.ReadAllTextAsync(filename);
             * string str = await t;
             */
            string str = await File.ReadAllTextAsync(filename);
            Console.WriteLine(str);
        }
    }
}

官方给的方法有了，那么接下来我们写一个自己的异步方法来获取百度的html

using System;

namespace ConsoleApp1
{
    class Program
    {

        static async Task Main(string[] args)
        {
            int a = await DownloadHtmlAsync("https://www.baidu.com", @"test.txt");
            Console.WriteLine("写入完毕！字符串长度为{0}",a);
        }

        //获取百度htnl并写入文件中，返回html字符串长度
        static async Task<int> DownloadHtmlAsync(string url, string filename)
        {
            HttpClient client = new HttpClient();   //.net5及以上
            string html = await client.GetStringAsync(url);
            await File.WriteAllTextAsync(filename, html);
            return html.Length;
        }
    }
}

输出结果为

写入完毕！字符串长度为9193

打开生成的可执行文件同一目录下的test.txt发现果然获取到了。Html代码太长，此处我就不放出来了。

那么还会有人问，如果某些地方不支持异步方法，那怎么办呢。其实我们只需要在异步方法后面加.Wait()或.Result就可以了（不推荐），代码如下：

//此处为了简洁仅给出了Main函数部分
static void Main(string args[])         //注意此处的Main我们并没用async关键字
{
    File.WriteAllTextAsync("text.txt", "hello,world").Wait();
    string str = File.ReadAllTextAsync(@"test.txt").Result;
    Console.WriteLine(str);
}

尽管这种方式可以达成目的，但是还是不推荐，因为这种方式可能会面临死锁的风险。

死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。[^2]

异步方法的线程委托

在一些情况下我们可能会将异步方法放到线程池来执行。

如果该方法是用正则表达式写的匿名方法的话，则只需要在前面使用async关键字即可。

ThreadPool.QueueUserWorkItem(async (obj) =>{
    while(true)
    {
        await File.WriteAllTextAsync(@"test.txt", "hello,world");
    }
});

async\await原理

我们编译如下代码获取百度Html，并向test.txt写入内容做示范

using System;
using System.Net.Http;

namespace ConsoleApp1
{
    class Program
    {

        static async Task Main(string []args)         //注意此处的Main我们并没用async限定符
        {
            using (HttpClient client = new HttpClient())
            {
                string html = await client.GetStringAsync("https://www.baidu.com");
                Console.WriteLine(html);
            }
            string txt = "hello,world";
            string filename = "test.txt";
            await File.WriteAllTextAsync(filename, txt);
            string str = await File.ReadAllTextAsync(filename);
            Console.WriteLine("文件内容: {0}",str);
        }

    }
}

然后利用ILSpy反编译生成的Dll文件，查看编译器到底给我们做了什么工作来探究async与await背后的原理。

ILSpy可以从GitHub上下载 GitHub - icsharpcode/ILSpy

将ILSpy版本设置成C#4.0

然后发现有两个Main函数

通过查看代码我们便知道，真正的Main实际上是void类型的，这是编译器帮我们搞定的，这个Main中调用了写代码的时候被async修饰返回值为Task的Main函数。

而通过查看<Main>d_0的代码我们可以分析出async与await的底层原理：

• async的方法会被C#编译器编译成一个类，会主要根据await调用切分成多个状态，对async方法的调用会被拆分为MoveNext的调用。
• await看似是等待，实际上编译后没有等待。await调用的等待期间，.net会把当前的线程返回给线程池，等异步方法调用执行完毕后，框架会从线程池再取出来一个线程执行后续代码。此外这里还进行了优化，到要等待的时候如果发现已经执行结束了，那就没必要切换线程了，剩下的代码继续在之前的线程上执行。

我们为了验证上面await的过程可以去尝试打印线程的ID，只要出现线程ID不同即可证明。代码如下：

//利用异步写入一个很大的此字符串增加时间以防止线程ID相同(字符串较小ID可能会相同)
static async Task Main(string []args)
{
    Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
    StringBuilder sb = new StringBuilder();     //StringBuilder需要using System.Text
    for(int i = 0; i < 10000; i++)
    {
        sb.Append("XXXXXX");
    }

    await File.WriteAllTextAsync(@"test.txt", sb.ToString());
    Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
}

在我的PC上运行结果如下，很显然进程ID不一样。

1
10

我们来执行下一段代码

using System;
using System.Text;

namespace ConsoleApp1
{
    class Program
    {

        static async Task Main(string []args)
        {
            Console.WriteLine("之前ID: "+Thread.CurrentThread.ManagedThreadId);
            await CalcAsync(5000);
            Console.WriteLine("之后: "+Thread.CurrentThread.ManagedThreadId);
        }

        //n个随机数相加
        static async Task<double> CalcAsync(int n)
        {
            Console.WriteLine("CalcAsync: " + Thread.CurrentThread.ManagedThreadId);
            double result = 0;
            Random random = new Random();
            for(var i = 0; i < n; i++)
                result += random.NextDouble();

            return result;
        }

    }
}

查看输出结果中的线程ID发现并没有变。

实际上，异步方法并不会自动在新的线程中执行，除非把代码放到新线程中去。看到这里你可能会问，为什么上文中的线程ID变了呢？

那是因为我们在上文中用当都是内部方法，其实现本就带了Task。

如果我们将上面的CalcAsync方法改成下面的，就能看到进程ID改变了。

static async Task<double> CalcAsync(int n)
{
    return await Task.Run(() =>
    {
        Console.WriteLine("CalcAsync: " + Thread.CurrentThread.ManagedThreadId);
        double result = 0;
        Random random = new Random();
        for (var i = 0; i < n; i++)
            result += random.NextDouble();
        return result;
    });
}

下面来看这两种方法：

static async Task<string> ReadFileAsync(int num)
{
    if (num == 0)
        return await File.ReadAllTextAsync("test1.txt");
    else if (num == 1)
        return await File.ReadAllTextAsync("test2.txt");
    else
        throw new ArgumentException("num invalid");
}


static Task<string> ReadFileAsync(int num)
{
    if (num == 0)
        return File.ReadAllTextAsync("test1.txt");
    else if (num == 1)
        return File.ReadAllTextAsync("test2.txt");
    else
        throw new ArgumentException("num invalid");
}

首先要说明的是，这两种方法都是符合语法规范的并且结果一致。第一种方法，把Task的string拆出来然后返回时又封装了回去，是一个异步方法；而第二种在调用时相当于直接访问的返回的Task，是一个普通的方法，但使用起来是异步的(相当于直接用File.ReadAllTextAsync)。

然而对于异步方法来讲，通过上文中的反编译可知，异步方法会生成一个类，占用更多的线程，运行效率没有普通方法高。第二种方法很好的避免了这个现象，因此必要时我们可以采用第二种方法。

但如果不是简单地将内部的Task返回出来，而是要对值进行某些操作然后再返回的话（比如将string字符串后面再加上一段），那么只能老实地去使用async与await关键字了。

static async Task<string> ReadFileAsync(int num)
{
    if (num == 0)
    {
        string s = await File.ReadAllTextAsync("test1.txt");
        s += "123";
    }
    else if (num == 1)
    {
        string s = await File.ReadAllTextAsync("test2.txt");
        s += "123";
    }
    else
        throw new ArgumentException("num invalid");
}

如果想要在异步方法中暂停一段时间，不要用Sleep方法，因为它会阻塞调用线程，降低并发。

Thread.Sleep(3000);        // 暂停3000ms，会阻塞线程调用

如果要实现类似效果的话，可以用await关键字加Delay方法 ,用法如下

await Task.Delay();        //异步暂停3000ms

在以前版本的.net给出了Thread.Abort()方法，但这种方法是强制结束线程的，可能产生一些问题，尽量不要去使用它。

有时需要提前终止任务，如请求超时，用户取消请求。很多异步方法都有CancellationToken参数用于提请终止执行的信号。

CancellationToken是一个结构体，它有如下几个成员

• None 空
• bool IsCancellationRequested 是否取消
• (*)Register(Action callback)注册取消监听
• ThrowIfCancellationRequested()如果任务被取消执行到这句话就抛出异常

在创建CancellationToken结构体时，一般不是通过new关键字去完成的，而是通过CancellationTokenSource类去创建的。

CancellationTokenSource有几个重要的方法：

• CancelAfter()超时后发出取消信号
• Cancel()发出取消信号

我们利用上面的知识编写一个方法，要求下载一个网页Html n次，但是在一秒钟后会被取消，当然这个过程是异步的。

static async Task Main(string []args)
{
    CancellationTokenSource cts = new CancellationTokenSource();
    cts.CancelAfter(1000);      //1秒后取消操作
    CancellationToken cToken = cts.Token;
    await DownloadHtml("https://www.baidu.com", 100, cToken);
}

static async Task DownloadHtml(string url, int n, CancellationToken cancellationToken)
{
    using(HttpClient client = new HttpClient())
    {
        for(var i = 0; i < n; i++)
        {
            string html = await client.GetStringAsync(url);
            Console.WriteLine($"{DateTime.Now}:{html}");
            if (cancellationToken.IsCancellationRequested)
            {
                Console.WriteLine("请求被取消！");
                break;
            }
        }
    }
}

接着我们改变下需求，要求一秒钟后抛出异常，代码可以这样写

static async Task DownloadHtml(string url, int n, CancellationToken cancellationToken)
{
    using(HttpClient client = new HttpClient())
    {
        for(var i = 0; i < n; i++)
        {
            string html = await client.GetStringAsync(url);
            Console.WriteLine($"{DateTime.Now}:{html}");
            cancellationToken.ThrowIfCancellationRequested();
        }
    }
}

当然还有一种方式是利用了GetAsync()方法的

static async Task DownloadHtml(string url, int n, CancellationToken cancellationToken)
{
    using (HttpClient client = new HttpClient())
    {
        for (var i = 0; i < n; i++)
        {
            var resp = await client.GetAsync(url, cancellationToken);
            string html = await resp.Content.ReadAsStringAsync();
            Console.WriteLine($"{DateTime.Now}:{html}");
        }
    }
}

那么这两种方式有什么区别呢？如果网站下载特别慢，对于第一种方式要下载完网页才会执行抛出异常的语句，实际上一秒钟后不一定会抛出异常；而第二种方式，则一秒钟后一定会抛出异常。

Task类的重要方法：

• Task<Task> WhenAny(IEnumerable<Task> tasks)等，任何一个Task完成，Task就完成。
• Task<TResult[]> WhenAll<TResult>(params Task<TResult>[] tasks)等，所有Task完成，Task才完成。用于等待多个任务执行结束但是不在乎它们的执行顺序。
• FromResult()创建普通数值的Task对象

在这里我们主要来看WhenAll的使用

static async Task Main(string[] args)
{
    Task<string> t1 = File.ReadAllTextAsync(@"test1.txt");
    Task<string> t2 = File.ReadAllTextAsync(@"test2.txt");
    Task<string> t3 = File.ReadAllTextAsync(@"test3.txt");

    string[] strs = await Task.WhenAll(t1, t2, t3);
    for (var i = 0; i < 3; i++)
        Console.WriteLine(strs[i]);
}

接口中的异步方法

async是编译器为异步方法中await代码进行分段处理的，而一个异步方法是否修饰了async对于调用者来讲没有区别，因此对于接口中的方法或者抽象方法不能修饰为async。

interface ITest
{
    Task<int> GetCharCount(string file);                //正确
    async Task<int> GetCharCountAsync(string file);     //错误，接口中的方法不能用async修饰
}
class Test : ITest
{
    public async Task<int> GetCharCount(string file)
    {
        string s = await File.ReadAllTextAsync(file);
        return s.Length;
    }
}

异步与yield

yield不仅能简化数据的返回，而且还可以让数据处理“流水线化”提升性能。

关于yield的使用可以参考yield 上下文关键字 - C# 参考 | Microsoft Docs 和 C#中yield用法 - 大西瓜3721 - 博客园

在旧版C#中，async方法中不能用yield。从C#8.0开始，把返回值声明为async IAsyncEnumerable（不要带Task）然后遍历的时候用await foreach()即可。

static async Task Main(string[] args)
{
    await foreach (var s in Test())                //注意await
        Console.WriteLine(s);
}
static async IAsyncEnumerable<string> Test()    //注意没Task
{
    yield return "hello";
    yield return "world";
}

SynchronizationContext问题

在ASP.Net Core和控制台项目中没有SynchronizationContext因此不用去管ConfigureAwait(false)等。

注意事项

在开发时不要把同步方法和异步方法混用。

异步方法的基本内容大概就这些了，本文章可以看作教程同时也是笔者的学习笔记，感谢 杨中科老师提供的.Net Core课程。

[^1]迷彩风情.认识异步编程[Z].知乎,2020-03-28

[^2]死锁[Z].百度百科,2022-08-20