C#异步：等待

合集 - C#8.0核心技术指南[学习笔记](21)

1.C#集合：枚举IEnumerable2022-06-292.C#集合：ICollection和IList接口2022-08-263.C#集合：字典2022-08-304.C#集合：List、Queue、Stack和Set2022-08-295.C#集合：Array类2022-08-266.C#线程2022-09-137.C#线程：任务Task2022-09-138.C#线程：本地存储2022-09-06

9.C#异步：等待2022-06-25

10.C#异步：编写异步函数2022-06-2611.C#异步：Task.WhenAny和Task.WhenAll2022-06-2812.C#异步：异步流2022-06-2813.C#线程：排它锁2022-08-3014.C#线程：非排他锁2022-08-3115.C#并行编程：简要2022-09-0116.C#并行编程：PLINQ2022-09-0217.C#.Net 定时器2022-09-0118.C#线程：使用事件等待句柄发送信号2022-09-0119.C#并行编程：并发集合2022-09-0820.C#并行编程：任务并行2022-09-0721.C#并行编程：Parallel类2022-09-05

收起

await关键字可以简便地附加延续。

static void Main(string[] args)
{
    DisplayPrimesCount();
}
 
static async void DisplayPrimesCount()
{
    int result = await GetPrimesCountAsync(2, 1000000);
    Console.WriteLine(result);
}
 
/// <summary>
/// 获得素数个数
/// </summary>
/// <param name="start">从什么数开始</param>
/// <param name="count">要获取的连续整数的数目</param>
/// <returns></returns>
static Task<int> GetPrimesCountAsync(int start, int count)
{
    return Task.Run(() =>ParallelEnumerable.Range(start, count)
        .Count(n => Enumerable.Range(2, (int)Math.Sqrt(n) - 1).All(i => n % i > 0)));
}

添加了async修饰符的方法称为异步函数。
当遇到await表达式时，通常情况下执行过程会返回到调用者上。运行时再返回之前会在等待的任务上附加一个延续，保证任务结束时执行点会跳回到方法中，并继续剩余的代码。如果顺利结束，则返回值为await表达式赋值。
可以以下例子展开形式印证：

static void DisplayPrimesCount()
{
    var awaiter = GetPrimesCountAsync(2, 1000000).GetAwaiter() ;
    awaiter.OnCompleted(()=>
    {
        int result = awaiter.GetResult();
        Console.WriteLine(result);
    });
}

await等待的表达式通常情况下是一个任务。但实际上，只要该对象拥有GetAwaiter方法，且该方法的返回值为等待器，则编译器都可以接受。

await表达式的最大优势在于它几乎可以出现在任何异步函数的表达式中，但不能出现在lock或unsafe上下文中。
以下示例中，await出现在循环结构中：

static async void DisplayPrimesCounts()
{
    for (int i = 0; i < 10; i++)
    {
        Console.WriteLine(await GetPrimesCountAsync(i * 1000000 + 2, 1000000));
    }
}

在第一次执行GetPrimesCountAsync方法时，由于出现了await表达式，因此执行点返回给调用者。当方法完成时，执行点会从停止之处恢复执行，同时保留局部变量和循环计数器的值。

UI上的等待处理

现在将编写一个UI程序，并且使该程序在调用计算密集的方法时仍然保持UI的响应性。
首先示例同步实现：

public partial class TestUI : Window
{
    Button _button = new Button { Content = "Go" };
    TextBlock _results = new TextBlock();
    public TestUI()
    {
        InitializeComponent();
 
        var panel = new StackPanel();
        panel.Children.Add(_button);
        panel.Children.Add(_results);
        Content = panel;
        _button.Click += (sender, args) => Go();
    }
 
    void Go()
    {
        for (int i = 1; i < 5; i++)
        {
            _results.Text += GetPrimesCount(i * 1000000, 1000000) +
               " primes between " + (i * 1000000) + " and " + ((i + 1) * 1000000 - 1) +
               Environment.NewLine;
        }
 
    }
 
    int GetPrimesCount(int start, int count)
    {
        return ParallelEnumerable.Range(start, count)
            .Count(n =>Enumerable.Range(2, (int)Math.Sqrt(n) - 1).All(i => n % i > 0));
    }
}

当点击按钮时，由于执行计算密集代码时间长，程序会陷入无响应状态。
我们可以分两步实现相应的异步方法。
第一步：异步的GetPrimesCount方法

Task<int> GetPrimesCountAsync (int start, int count)
{
	return Task.Run (() =>
		ParallelEnumerable.Range (start, count).Count (n => 
			Enumerable.Range (2, (int) Math.Sqrt(n)-1).All (i => n % i > 0)));
}

第二步：在Go方法中调用

async void Go()
{
	_button.IsEnabled = false;
	
	for (int i = 1; i < 5; i++)
		_results.Text += await GetPrimesCountAsync (i * 1000000, 1000000) +
			" primes between " + (i*1000000) + " and " + ((i+1)*1000000-1) + Environment.NewLine;
 
	_button.IsEnabled = true;
}

由以上代码可见异步函数的简洁性，只需按同步方式书写，并当调用异步函数时进行等待await就可以避免阻塞了。
GetPrimesCountAsync方法会运行在工作线程上，而Go方法则会“租用”UI线程时间，即Go方法在消息循环中是以伪并发的方式执行的。