C#语法——await与async的正确打开方式

C#5.0推出了新语法，await与async，但相信你们仍是不多使用它们。关于await与async有不少文章讲解，但有没有这样一种感受，你看完后，总感受这东西很不错，但用的时候，老是想不起来，或者不知道该怎么用。

为何呢？我以为你们的await与async的打开方式不正确。

 正确的打开方式

 

首先看下使用约束。

一、await 只能在标记了async的函数内使用。

二、await 等待的函数必须标记async。

有没有感受这是个循环？没错，这就是个循环。这也就是为何你们不怎么用他们的缘由。这个循环很讨厌，那么怎么破除这个循环呢？

【很简单，await等待的是线程，不是函数。】

不理解吗？不要紧，接着看下去。

下面从头来说解，首先看这么一组对比

public static int NoAsyncTest()
{
   return 1;
}
public static async Task<int> AsyncTest()
{ 
　 return 1;
}

 async Task<int>等于int

这意味着咱们在正常调用这两个函数时，他们是等效的。那么用async Task<int>来修饰int目的是什么呢？

目的是为了让这个方法这样被调用 await AsyncTest()，但直接这样调用，并不会开启线程，那这样费劲的修饰是否是就没什么意义了呢。

固然不是，那何时会让 await AsyncTest()有意义呢？

咱们接着往下看，修改AsyncTest以下。而后，此时再调用await AsyncTest()，你会神奇的发现，依然没有卵用。。。

Excute方法正常执行，而AsyncTest内运行的线程，本身执行本身的。

public static async void Excute()
 {
       Console.WriteLine(Thread.CurrentThread.GetHashCode() + " 开始 Excute " + DateTime.Now);
       await AsyncTest();
       Console.WriteLine(Thread.CurrentThread.GetHashCode() + " 结束 Excute " + DateTime.Now);
 }

 public static async Task<int> AsyncTest()
 {
        Task.Run(() =>
            {
                Console.WriteLine(Thread.CurrentThread.GetHashCode() + " Run1 " + DateTime.Now);
                Thread.Sleep(1000);
            });
            return 1;
 }

别着急，咱们稍做调整，在线程后面增长.GetAwaiter().GetResult()。这句话是干什么用的呢？是用来获取线程返回值的。

这个逻辑是这样的，若是想要获取线程返回结果，就天然要等待线程结束。

运行一下，咱们将看下面的结果。

public static async Task<int> AsyncTest()
        {
            Task.Run(() =>
            {
                Console.WriteLine(Thread.CurrentThread.GetHashCode() + " Run1 " + DateTime.Now);
                Thread.Sleep(1000);
            }).GetAwaiter().GetResult();
            return 1;
        }

　

可是，好像await AsyncTest();仍是没启做用。没错，事实就是，他真的不会起做用。。。

那么怎么才能让他起做用呢？

首先，咱们定义一个普通函数，他的返回值是一个Task，而后咱们获得Task后，运行它，再用await等待这个Task。

因而咱们就获得这样的结果。

 public static async void Excute()
        {
            Console.WriteLine(Thread.CurrentThread.GetHashCode() + " 开始 Excute " + DateTime.Now);
            var waitTask = AsyncTestRun();
            waitTask.Start();
            int i = await waitTask;
            Console.WriteLine(Thread.CurrentThread.GetHashCode() + " i " + i);
            Console.WriteLine(Thread.CurrentThread.GetHashCode() + " 结束 Excute " + DateTime.Now);
        }
        public static Task<int> AsyncTestRun()
        {
            Task<int> t = new Task<int>(() => {
                Console.WriteLine(Thread.CurrentThread.GetHashCode() + " Run1 " + DateTime.Now);
                Thread.Sleep(1000);
                return 100;
            });
            return t;
        }

　　

如图，这样写await AsyncTest();就起做用了。

因此，仍是那句话，await等待的是线程，不是函数。

但在图里，咱们发现很奇怪的一点，结束Excute也是线程3，而不是线程1。也就是说，Await会对线程进行优化。

下面看下两组代码的对比，让咱们就更清楚的了解下Await。

第一组，使用await等待线程。

public static async void Excute()
{
   Console.WriteLine(Thread.CurrentThread.GetHashCode() + " 开始 Excute " + DateTime.Now);
   await SingleAwait(); 
   Console.WriteLine(Thread.CurrentThread.GetHashCode() + " 结束 Excute " + DateTime.Now);
}
      
public static async Task SingleAwait()
{
     Console.WriteLine(Thread.CurrentThread.GetHashCode() + " AwaitTest开始 " + DateTime.Now);
     await Task.Run(() =>
            {
                Console.WriteLine(Thread.CurrentThread.GetHashCode() + " Run1 " + DateTime.Now);
                Thread.Sleep(1000);
            });
            await Task.Run(() =>
            {
                Console.WriteLine(Thread.CurrentThread.GetHashCode() + " Run2 " + DateTime.Now);
                Thread.Sleep(1000);
            });
            Console.WriteLine(Thread.CurrentThread.GetHashCode() + " AwaitTest结束 " + DateTime.Now);
            return;
}

 

第二组，使用等待线程结果，等待线程。

 public static async void Excute()
{
     Console.WriteLine(Thread.CurrentThread.GetHashCode() + " 开始 Excute " + DateTime.Now);
            await SingleNoAwait(); 
     Console.WriteLine(Thread.CurrentThread.GetHashCode() + " 结束 Excute " + DateTime.Now);
        }
public static async Task SingleNoAwait()
{
      Console.WriteLine(Thread.CurrentThread.GetHashCode() + " SingleNoAwait开始 " + DateTime.Now);
       Task.Run(() =>
        {
                Console.WriteLine(Thread.CurrentThread.GetHashCode() + " Run1 " + DateTime.Now);
                Thread.Sleep(1000);
            }).GetAwaiter().GetResult();
            Task.Run(() =>
            {
                Console.WriteLine(Thread.CurrentThread.GetHashCode() + " Run2 " + DateTime.Now);
                Thread.Sleep(1000);
            }).GetAwaiter().GetResult();
            Console.WriteLine(Thread.CurrentThread.GetHashCode() + " SingleNoAwait结束 " + DateTime.Now);
            return;
}

能够明确的看到，第二组，线程从新回到了主线程1中，而第一组，已经被优化到了线程4中。

 

 结语

await是一种很便捷的语法，他的确会让代码简洁一些，但他主动优化线程的功能，若是不了解就使用，可能会致使一些奇怪的BUG发生。

这也是官方为何只提供了await调用服务的例子，由于，在程序内调用，await仍是要了解后，再使用，才安全。

C#语法——委托，架构的血液

C#语法——元组类型

C#语法——泛型的多种应用

----------------------------------------------------------------------------------------------------

注：此文章为原创，任何形式的转载都请联系做者得到受权并注明出处！
若您以为这篇文章还不错，请点击下方的【推荐】，很是感谢！