一文带你搞懂C# 异步编程(async/await)底层原理

基于async/await的异步编程

我们先看一下未使用异步时的一段代码，这段代码的作用是从源流拷贝字节到目标流：

如果流里面的数据比较多，未使用异步时，调用线程会被阻塞较长的时间。当调用端是桌面程序时，就会出现我们常见的界面假死情况。

// Synchronously copy all data from source to destination.
public void CopyStreamToStream(Stream source, Stream destination)
{
    var buffer = new byte[0x1000];
    int numRead;
    while ((numRead = source.Read(buffer, 0, buffer.Length)) != 0)
    {
        destination.Write(buffer, 0, numRead);
    }
}

 

然后我们使用async/await关键字，并把方法修改为异步方法版本，此时调用线程就不会被阻塞。

// Asynchronously copy all data from source to destination.
public async Task CopyStreamToStreamAsync(Stream source, Stream destination)
{
    var buffer = new byte[0x1000];
    int numRead;
    while ((numRead = await source.ReadAsync(buffer, 0, buffer.Length)) != 0)
    {
        await destination.WriteAsync(buffer, 0, numRead);
    }
}

 

async/await关键字的内部到底做了什么？让我们接着往下看。

 

我为什么会有这个疑问？

因为平常我会喜欢反编译一些.NET程序集，如果在代码中使用了异步编程，也就是使用了async和await关键字。反编译出来的代码就会显得比较复杂。

所以我就想去详细了解一下基于async/await的异步编程底层原理到底是什么，也就有了这篇文章。

 

我们可以先验证一下这个问题：

创建一个WPF工程

MainWindow.xaml

<Window x:Class="AsyncDemo.MainWindow"
        Title="MainWindow" Height="450" Width="800">
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition/>
            <RowDefinition Height="auto"/>
        </Grid.RowDefinitions>

        <RichTextBox Name="rtbox" VerticalScrollBarVisibility="Auto"></RichTextBox>

        <Button Grid.Row="1" HorizontalAlignment="Center" Width="88" Height="28" VerticalAlignment="Center" Content="Ok" Click="Button_Click" Margin="15"></Button>
    </Grid>
</Window>

 

我们先用同步的方式实现一下：

MainWindow.xaml.cs

 public partial class MainWindow : Window
 {
     public MainWindow()
     {
         InitializeComponent();
     }

     private void Button_Click(object sender, RoutedEventArgs e)
     {
         GetHtmlSource("http://www.baidu.com");
     }

     private void GetHtmlSource(string url)
     {
         WebClient webClient = new WebClient();
         var html = webClient.DownloadString(url);
         this.rtbox.Document = new FlowDocument(new Paragraph(new Run(html)));
     }
 }

 

这个时候我们用反编译工具反编译一下生成的exe，可以看到整体差异不大。

 

然后我们使用Task将同步任务进行包装

   private async void Button_Click(object sender, RoutedEventArgs e)
   {
       //同步
       //GetHtmlSource("http://www.baidu.com");

       //异步
       await Task.Run(() => { GetHtmlSource("http://www.baidu.com"); });
   }

 

此时我们再看一下反编译工具里反编译出来的代码，就会发现有较大的变化 ，编译器生成了一堆奇奇怪怪的代码，如下所示：

public class MainWindow : Window, IComponentConnector
{
    // Fields
    internal RichTextBox rtbox;
    private bool _contentLoaded;

    // Methods
    public MainWindow()
    {
        this.InitializeComponent();
    }

    [AsyncStateMachine(typeof(<Button_Click>d__1)), DebuggerStepThrough]
    private void Button_Click(object sender, RoutedEventArgs e)
    {
        <Button_Click>d__1 stateMachine = new <Button_Click>d__1 {
            <>t__builder = AsyncVoidMethodBuilder.Create(),
            <>4__this = this,
            sender = sender,
            e = e,
            <>1__state = -1
        };
        stateMachine.<>t__builder.Start<<Button_Click>d__1>(ref stateMachine);
    }

    private void GetHtmlSource(string url)
    {
        string html = new WebClient().DownloadString(url);
        if (Application.Current.Dispatcher.CheckAccess())
        {
            this.rtbox.Document = new FlowDocument(new Paragraph(new Run(html)));
        }
        else
        {
            Application.Current.Dispatcher.Invoke(() => this.rtbox.Document = new FlowDocument(new Paragraph(new Run(html))));
        }
    }

    // Nested Types
    [CompilerGenerated]
    private sealed class <Button_Click>d__1 : IAsyncStateMachine
    {
        // Fields
        public int <>1__state;
        public AsyncVoidMethodBuilder <>t__builder;
        public object sender;
        public RoutedEventArgs e;
        public MainWindow <>4__this;
        private TaskAwaiter <>u__1;

        // Methods
        private void MoveNext()
        {
            int num = this.<>1__state;
            try
            {
                TaskAwaiter awaiter;
                if (num != 0)
                {
                    awaiter = Task.Run(new Action(this.<>4__this.<Button_Click>b__1_0)).GetAwaiter();
                    if (!awaiter.IsCompleted)
                    {
                        this.<>1__state = num = 0;
                        this.<>u__1 = awaiter;
                        MainWindow.<Button_Click>d__1 stateMachine = this;
                        this.<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter, MainWindow.<Button_Click>d__1>(ref awaiter, ref stateMachine);
                        return;
                    }
                }
                else
                {
                    awaiter = this.<>u__1;
                    this.<>u__1 = new TaskAwaiter();
                    this.<>1__state = num = -1;
                }
                awaiter.GetResult();
            }
            catch (Exception exception)
            {
                this.<>1__state = -2;
                this.<>t__builder.SetException(exception);
                return;
            }
            this.<>1__state = -2;
            this.<>t__builder.SetResult();
        }

        [DebuggerHidden]
        private void SetStateMachine(IAsyncStateMachine stateMachine)
        {
        }
    }
}

 

 

这些代码都是编译器帮我们生成的。微软简化了异步编程，让开发者使用async/await关键字就可以轻松的实现异步编程，但是实际上它内部是做了很多工作的。

 

下面我们来深入理解一下，基于async/await的异步编程到底是怎么实现的。

 

待更新

 

 

参考资料：

https://devblogs.microsoft.com/dotnet/how-async-await-really-works/