C#异步编程

时间 2019-11-18

标签 c# 异步编程栏目 C# 繁體版

原文原文链接

什么是异步编程

什么是异步编程呢？举个简单的例子：html

using System.Net.Http;
using System.Threading.Tasks;
using static System.Console;

namespace Core
{
    class Async
    {
        static void Main()
        {
            Start();
            End();
        }

        static void Wait()=>WriteLine("waiting...");
        static void End()=>WriteLine("end...");
        static int Start()
        {
            WriteLine("start...");
            HttpClient client = new HttpClient();
            Waiting();
            var result = client.GetStringAsync("https://www.visualstudio.com/");
            string str = result.Result;
            return str.Length;
        }
    }
}

上面这段代码中，Main方法中的代码是按照自上而下的顺序执行的。网络情况不佳时，Start()方法是比较耗时（注意，这里在Start方法中调用了异步方法GetStringAsync，但该方法在此处是以同步方式执行的，具体缘由下文会进行说明），在Start()方法执行完毕以前，整个程序处于阻塞状态。而异步编程能够很好的解决这个问题，一句简单的话来归纳异步编程就是，程序无须按照代码顺序自上而下的执行。web

async/await

C#5.0新增了async和await关键字，使用这两个关键字能够大大简化异步编程编程

使用 async 关键字可将方法、lambda 表达式或匿名方法标记为异步，即，方法中应该包含一个或多个await表达式，但async关键字自己不会建立异步操做。promise

public async Task Asy()
{
　　//do something...
}

这里须要注意一点，若使用async关键字标记的方法中没有使用await关键字（编译器会给出警告但不报错），那么该方法将会以同步方式执行。网络

定义异步方法的几点要求

定义一个异步方法应知足如下几点：多线程

使用async关键字来修饰方法
在异步方法中使用await关键字（不使用编译器会给出警告但不报错），不然异步方法会以同步方式执行
尽可能不使用void做为返回类型，若但愿异步方法返回void类型，请使用Task
异步方法名称以Async结尾
异步方法中不能声明使用ref或out关键字修饰的变量

下面定义一个异步方法StartAsync()：app

static async Task<int> StartAsync()
{
    HttpClient client = new HttpClient();
    var str = await client.GetStringAsync("https://www.visualstudio.com/");
    return str.Length;
}

异步方法的返回类型

Task<T>
若是在调用匿名方法时使用了await关键字，且匿名方法的返回类型是Task<T>，那么咱们获得的返回类型是T。若未使用await关键字，则返回类型是Task。未使用await，调用GetStringAsync方法时result是Task类型。

从上图咱们能够看到调用GetStringAsync方法时未使用await关键字，result是Task类型，咱们能够经过GetType()方法来获取result的详细类型信息：异步

从上图能够看到result的类型全名是System.Threading.Tasks.Taskasync

从上图咱们能够看到使用await关键字时，result是string类型，而匿名方法GetStringAsync的返回类型是Task<string>ide

Task
若是在调用匿名方法时使用了await关键字，且匿名方法的返回类型是Task，那么咱们获得的返回类型是void。若为使用await关键字，则获得的返回类型是Task。
void
不建议使用void做为异步方法的返回值。
由于使用Task或Task<TResult>任务做为返回值，其属性携带有关其状态和历史记录的信息，如任务是否完成、异步方法是否致使异常或已取消以及最终结果是什么。而await运算符可访问这些属性。

异步方法执行流程

异步程序执行流程

上图是微软官方提供的讲解异步程序执行流程的图示，并附有解释说明：

The numbers in the diagram correspond to the following steps.

An event handler calls and awaits the AccessTheWebAsync async method.

AccessTheWebAsync creates an HttpClient instance and calls the GetStringAsyncasynchronous method to download the contents of a website as a string.

Something happens in GetStringAsync that suspends its progress. Perhaps it must wait for a website to download or some other blocking activity. To avoid blocking resources, GetStringAsync yields control to its caller, AccessTheWebAsync.
GetStringAsync returns a Task<TResult> where TResult is a string, and AccessTheWebAsync assigns the task to thegetStringTask variable. The task represents the ongoing process for the call to GetStringAsync, with a commitment to produce an actual string value when the work is complete.

Because getStringTask hasn't been awaited yet, AccessTheWebAsync can continue with other work that doesn't depend on the final result from GetStringAsync. That work is represented by a call to the synchronous method DoIndependentWork.

DoIndependentWork is a synchronous method that does its work and returns to its caller.

AccessTheWebAsync has run out of work that it can do without a result from getStringTask. AccessTheWebAsync next wants to calculate and return the length of the downloaded string, but the method can't calculate that value until the method has the string.
Therefore, AccessTheWebAsync uses an await operator to suspend its progress and to yield control to the method that called AccessTheWebAsync. AccessTheWebAsync returns a Task<int> to the caller. The task represents a promise to produce an integer result that's the length of the downloaded string.

Note
If GetStringAsync (and therefore getStringTask) is complete before AccessTheWebAsync awaits it, control remains inAccessTheWebAsync. The expense of suspending and then returning to AccessTheWebAsync would be wasted if the called asynchronous process (getStringTask) has already completed and AccessTheWebSync doesn't have to wait for the final result.
Inside the caller (the event handler in this example), the processing pattern continues. The caller might do other work that doesn't depend on the result from AccessTheWebAsync before awaiting that result, or the caller might await immediately. The event handler is waiting for AccessTheWebAsync, and AccessTheWebAsync is waiting for GetStringAsync.

GetStringAsync completes and produces a string result. The string result isn't returned by the call to GetStringAsync in the way that you might expect. (Remember that the method already returned a task in step Instead, the string result is stored in the task that represents the completion of the method, getStringTask. The await operator retrieves the result from getStringTask. The assignment statement assigns the retrieved result to urlContents.

When AccessTheWebAsync has the string result, the method can calculate the length of the string. Then the work ofAccessTheWebAsync is also complete, and the waiting event handler can resume. In the full example at the end of the topic, you can confirm that the event handler retrieves and prints the value of the length result.
If you are new to asynchronous programming, take a minute to consider the difference between synchronous and asynchronous behavior. A synchronous method returns when its work is complete (step 5), but an async method returns a task value when its work is suspended (steps 3 and 6). When the async method eventually completes its work, the task is marked as completed and the result, if any, is stored in the task.

解释虽是英文，但并无太难的单词，是能够看懂其意思的。经过上面的说明，咱们能够知道：
在遇到awiat关键字以前，程序是按照代码顺序自上而下以同步方式执行的。
在遇到await关键字以后，系统作了如下工做：

异步方法将被挂起
将控制权返回给调用者
使用线程池中的线程（而非额外建立新的线程）来计算await表达式的结果，因此await不会形成程序的阻塞
完成对await表达式的计算以后，若await表达式后面还有代码则由执行await表达式的线程（不是调用方所在的线程）继续执行这些代码

使用一段代码来进行验证：

static void Main()
{
    Task<int> task = StartAsync();
    Thread.Sleep(5000);
    End();
}

static async Task<int> StartAsync()
{
    WriteLine("start...");
    HttpClient client = new HttpClient();
    var result = client.GetStringAsync("https://www.visualstudio.com/");
    string str = await result;
    return str.Length;
}

执行代码

从上图左侧的调用栈中能够看到，在遇到await关键字以前，异步方法StartAsync自上而下同步执行。注意，这里异步方法GetStringAsync方法是被挂起的，不会形成程序的阻塞，控制权回到调用者StartAsync中，仔细看英文解释中的第3步。
而后在Debug Console中输入System.Threading.Thread.Current查看当前工做线程信息，以及System.Threading.Thread.CurrentThread.IsThreadPoolThread查看当前线程是否在线程池中。

从上图咱们看到，当前线程Id是1，不在线程池中。继续执行程序：

遇到await关键字后，异步方法StartAsync被挂起，控制权也回到了调用者Main方法中。

从上图咱们能够看到异步方法StartAsync中的result变量的Status属性值是WaitingForActivation，Result属性值是Not yet computed。

代码继续执行，将Main方法所在线程接挂起5秒，系统使用线程池中的线程计算await表达式的值：

从上图咱们能够看到，程序已经成功计算出await表达式的值，变量result的Status属性值变成了RanToCompletion。完成对await表达式的计算以后，程序继续执行后面的代码(return str.Length)。

再看此时的工做线程信息：

咱们看到，当前线程Id是5且存在于线程池中。

从这里咱们能够得知异步是借助于多线程来实现的。

Task

Task类拥有执行异步方法的两个方法：Task.Run(),Task.Run<T>，Task.Run以及Task.Run<T>使用线程池中的线程来执行代码，它和使用await关键字的区别是：Task.Run直接使用线程池中的线程，而使用await的异步方法是在遇到await关键字后才使用多线程。

Thread

线程是前面所说的异步（async/await）和任务（Task）的基础。和线程紧密相关的另一个概念是进程，这里很少赘述。

ThreadPool

线程也是对象，频繁的建立和销毁线程比较影响性能，.NET提供线程池使得咱们可以复用线程对象从而避免频繁建立和销毁线程。

结语

本身建立线程比较麻烦但可以更好的控制程序的运行，使用async/await关键字来编码显得较为简洁，但对程序的控制力度会有所下降。

参考文章：

Asynchronous Programming with async and await (C#)
async
await
走进异步编程的世界 - 开始接触 async/await
C#执行异步操做的几种方式比较和总结
 thread task parallel plinq async await多线程任务及异步编程
 走进异步编程的世界 - 在 GUI 中执行异步操做

Async/Await - Best Practices in Asynchronous Programming