ASP.Net Core异步编程

• 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

异步方法不等于多线程

我们来执行下一段代码

class="language-csharp">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;
	});
}

为什么有的异步方法没标async

下面来看这两种方法：

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

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

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

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

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

CancellationToken参数

在以前版本的.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类与WhenAll

Task类的重要方法：

• Task WhenAny(IEnumerable tasks)等，任何一个Task完成，Task就完成。
• Task WhenAll(params Task[] 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不仅能简化数据的返回，而且还可以让数据处理“流水线化”提升性能。

在旧版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)等。

注意事项

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

结束

异步方法的基本内容大概就这些了，本文章可以看作教程同时也是笔者的学习笔记