C#使用async和await實現非同步程式設計

2022-07-12 22:06:02

最近在寫程式的時候，經常遇到大量需要非同步存取的情況，但是對於async和await到底怎麼寫，還不是非常明確。

1.普通的程式怎麼寫？

class Program
{
    static void Main(string[] args)
    {
        MyDownLoadString ds = new MyDownLoadString();
        ds.DoRun();
        Console.ReadKey();
    }
 
    class MyDownLoadString
    {
        Stopwatch sw = new Stopwatch();
        public void DoRun()
        {
            const int LargeNumber = 6000000;
            sw.Start();
 
            int t1 = CountCharacters(1, "http://www.microsoft.com");
            int t2 = CountCharacters(2, "http://www.illustratedcsharp.com");
 
            CountToALargeNumber(1, LargeNumber);
            CountToALargeNumber(2, LargeNumber);
            CountToALargeNumber(3, LargeNumber);
            CountToALargeNumber(4, LargeNumber);
           
            Console.WriteLine("Chars in Call1:{0}",t1);
            Console.WriteLine("Chars in Call1:{0}",t2);
        }
 
        private int CountCharacters(int id, string uriString)
        {
            WebClient wc1 = new WebClient();
            Console.WriteLine("Call {0} start: {1:N0}ms ", id, sw.Elapsed.TotalMilliseconds);
            string result = wc1.DownloadString(new Uri(uriString));
            Console.WriteLine("Call {0} completed: {1:N0}ms", id, sw.Elapsed.TotalMilliseconds);
            return result.Length;
        }
 
        private void CountToALargeNumber(int id, int value)
        {
            for (long i = 0; i < value; i++) ;
            Console.WriteLine("End CountToALargeNumber {0} : {1:N0}ms", id, sw.Elapsed.TotalMilliseconds);
        }
    }
}

結果：

Call 1 start: 1ms
Call 1 completed: 903ms
Call 2 start: 903ms
Call 2 completed: 1,355ms
End CountToALargeNumber 1 : 1,375ms
End CountToALargeNumber 2 : 1,399ms
End CountToALargeNumber 3 : 1,417ms
End CountToALargeNumber 4 : 1,435ms
Chars in Call1:161702
Chars in Call1:5164

從執行結果可以看到，同步執行的時間主要花在了兩次請求外部地址上，計算長度並不費時，用圖來表示就像下面

2.使用async和await怎麼寫？

修改上面程式碼，如下

class MyDownLoadString
{
    Stopwatch sw = new Stopwatch();
    public void DoRun()
    {
        const int LargeNumber = 6000000;
        sw.Start();
         // Task<int> 儲存結果物件，後面t1.Result則是獲取結果
         Task<int> t1 = CountCharactersAsync(1, "http://www.microsoft.com");
        Task<int> t2 = CountCharactersAsync(2, "http://www.illustratedcsharp.com");
       
        //無需等待CountCharactersAsync執行完成
        CountToALargeNumber(1, LargeNumber);
        CountToALargeNumber(2, LargeNumber);
        CountToALargeNumber(3, LargeNumber);
        CountToALargeNumber(4, LargeNumber);
         
        //t1.Result獲取結果
        Console.WriteLine("Chars in Call1:{0}",t1.Result);
        Console.WriteLine("Chars in Call1:{0}",t2.Result);
    }
 
    private async Task<int> CountCharactersAsync(int id, string uriString)
    {
        WebClient wc = new WebClient();
        Console.WriteLine("Call {0} start: {1:N0}ms ", id, sw.Elapsed.TotalMilliseconds);
        string result = await wc.DownloadStringTaskAsync(new Uri(uriString));
        Trace.TraceInformation("Taceing Async Call {0} @time:{1:N0}ms", id, sw.Elapsed.TotalMilliseconds);
        Console.WriteLine("Call {0} completed: {1:N0}ms", id, sw.Elapsed.TotalMilliseconds);
        return result.Length;
    }
 
    private void CountToALargeNumber(int id, int value)
    {
        for (long i = 0; i < value; i++) ;
        Console.WriteLine("End CountToALargeNumber {0}: {1:N0}ms", id, sw.Elapsed.TotalMilliseconds);
    }
}

執行結果：

Call 1 start: 2ms
Call 2 start: 253ms
End CountToALargeNumber 1: 288ms
End CountToALargeNumber 2: 359ms
End CountToALargeNumber 3: 560ms
Call 1 completed: 770ms
End CountToALargeNumber 4: 844ms
Call 2 completed: 887ms
Chars in Call1:162262
Chars in Call2:5164

修改如上面的程式碼之後，我們就可以無需等待兩次CountCharactersAsync返回結果，而是直接呼叫了下面的CountToALargeNumber，在CountCharactersAsync請求返回的時候再獲取結果。

3.async和await的細節

async和await可以建立和使用非同步方法，這個特性的由三個部分組成：

①呼叫方法(calling method)：該方法呼叫非同步方法，然後在非同步方法（可能使用同一個執行緒也可能不在一個執行緒）執行其任務的時候繼續執行
②非同步方法（async）: 該方法非同步執行其工作，然後立即方法到呼叫方法
③await表示式：用於非同步方法內部，指明需要非同步執行的惹怒我。一個非同步方法可以包含任意多個await表示式，如果一個都不包含編譯器會發出警告

舉例說明一個async/await方法：

//1.呼叫方法
static void Main(string[] args)
{
    Task<int> t = DoSumAsync(1, 2);
    Console.WriteLine("結果:{0}", t.Result);
    Console.ReadKey();
}
 
//2.非同步方法
public static async Task<int> DoSumAsync(int a, int b)
{
    //3.await 表示式
    int sum = await Task.Run(() => { return a + b; });
    return sum;
}

4.什麼是非同步方法？

上面簡單舉例了什麼是非同步方法，下面就詳細學習一下：

非同步方法在完成其工作之前返回到呼叫方法，並在呼叫方法繼續執行的時候完成其工作。語法上有如下特徵：

① 方法使用async作為修飾符
② 方法內部包含一個或者多個await表示式，表示可以非同步完成的任務
③ 必須具備以下三種返回型別 void 、Task 、Task<T> ,其中後兩種的返回物件標識講座未來完成的工作，呼叫方法和非同步方法可以繼續執行。
④非同步方法的引數可以任意型別，但是不能為out和ref引數
⑤約定俗成，一般非同步方法都是以 Async作為字尾的。
⑥ 除了方法之外，Lambda表示式和匿名函數也可以作為非同步物件。

像程式碼：

private async Task<int> CountCharactersAsync(int id, string uriString)
{
    WebClient wc = new WebClient();
    Console.WriteLine("Call {0} start: {1:N0}ms ", id, sw.Elapsed.TotalMilliseconds);
    string result = await wc.DownloadStringTaskAsync(new Uri(uriString));
    Trace.TraceInformation("Taceing Async Call {0} @time:{1:N0}ms", id, sw.Elapsed.TotalMilliseconds);
    Console.WriteLine("Call {0} completed: {1:N0}ms", id, sw.Elapsed.TotalMilliseconds);
    return result.Length;
}

詳細說明：

①async關鍵字是一個上下文關鍵字，也就是說除了做為方法（lambda和匿名函數）的修飾符之外，還可以做識別符號。

②返回型別

Task型別：如果呼叫方法不需要從非同步方法中返回某個值，但需要檢查非同步方法的狀態，可以返回一個Task，此時就算非同步方法中出現了return語句，也不會返回任何東西。
Task<T>型別，除了上面Task的功能，還可以通過 Return屬性來獲取返回的T型別的值。
void型別：如果僅僅是執行非同步方法，而不需要與它做任何進一步的互動（“呼叫並忘記”），此時可以用void，和Task一樣，就算有return語句，也得不到任何東西。

5.非同步方法的控制流

首先要明確“非同步方法”的三個部分，如下圖所示：

①首先是第一個await之前的部分，這部分應該是少量且無需長時間等待的程式碼。
②await表示式，表示需要被非同步執行的任務，這裡有兩個await表示式，第二個await和之前的同步部分和第一個await以及之前的部分是一樣的。
③後續部分：在await表示式之後出現的方法中的其餘程式碼。

執行過程，可以參考下面的圖

有幾個注意的地方：

① await之前的部分是同步執行的
② 當達到awati的時候，會將非同步方法的控制返回給呼叫方法。如果方法返回的型別是Task或者Task<T>，將建立一個Task物件，表示需非同步完成的任務和後續，然後將該Task返回到呼叫方法。這裡的返回值並不是await表示式的返回值，而是非同步方法中宣告的返回值型別。
③ 非同步方法內部需要完成以下工作：

　　- 非同步執行await表達是的空閒任務

- 當await表示式執行完成之後，執行後續部分。後續本身也可能是await表示式，處理過程和上一個一致。

　　- 後續部分如果遇到 return 或者方法達到末尾，將做如下的事情：

　　　　l 如果返回的型別是void,控制流就退出了

　　　　l 如果返回的型別是Task，後續部分設定Task物件的屬性並退出。

　　　　l 如果返回的型別是Task<T>，不僅要設定Task物件屬性，還要設定Task物件的Return屬性。

　　這個點要注意下：並不是遇到return或者達到方法末尾，就能獲取到返回值，它只是退出了。

④ 呼叫方法繼續執行，會從非同步方法獲取Task物件。當需要其實際值的時候，就參照Task物件中的Result屬性。屆時，如果非同步方法設定了該屬性，呼叫方法獲取其值並繼續。否則就等待該屬性被設定，然後再繼續執行。

6. await表示式

await表示式指定了一個非同步執行的任務。語法由 await關鍵字 + 一個空閒物件(稱為任務)組成。這個任務可能是一個Task物件，也可以不是，預設情況下由該執行緒非同步執行。

一個空閒物件指的是一個awaitable型別的範例，awaitable型別是指包含了GetAwaiter方法的型別，方法沒有引數，返回一個稱為awaiter型別的物件。

一個awaiter物件包含了如下成員：

一般情況下我們不需要自己構建一個awaiter物件，使用.net 自己的Task就可以了。最簡單的方法就是使用Task.Run()來返回一個Task物件。關於Task.Run()有一個非常重要的點，他將在不同的執行緒上執行你的方法。

6.例外處理和await表示式

先看下面這個例子，直接在非同步方法內部使用了try..catch。

static void Main(string[] args)
{
 
    Task t = BadAsync();
    t.Wait();
    Console.WriteLine("Task Status:       {0}", t.Status );
    Console.WriteLine("Task IsFaulted:    {0}", t.IsFaulted );
    Console.WriteLine("Please enter a key to exit!");
    Console.ReadKey();
 
}
 
static async Task BadAsync()
{
    try
    {
        await Task.Run(() => { throw new Exception(); });
    }
    catch
    {
        Console.WriteLine("Exception in BadAsync");
    }
}

執行結果：

Exception in BadAsync
Task Status: RanToCompletion
Task IsFaulted: False
Please enter a key to exit!

從結果可以看到，雖然在非同步方法內部進行了try..catch，並且也catch到了異常，但是對於呼叫函數，返回的Task狀態依然為 RanToCompletion 。

為什麼這個亞子？，原因如下：

① Task沒有被取消掉
② 沒有未處理的異常。類似的IsFaulted是false。

7.在呼叫方法中同步的等待任務（WaitAll、WaitAny）

對於單個Task ，可以通過task物件的wait()方法來進行等待。

Task<int> t = CountCharactersAsync("http://www.163.com");
t.Wait();

對於多個Task，可以使用WaitAll()或者waitAny()方法，進行同步。

WaitAll是等待所以的任務完成才繼續操作

Task<int> t1 = CountCharactersAsync(1, "http://www.163.com");
Task<int> t2 = CountCharactersAsync(2, "http://www.microsoft.com");
Task<int>[] tasks = new Task<int>[] { t1, t2 };
Task.WaitAll(tasks);

WaitAny是隻要一個完成就可以繼續操作

Task<int> t1 = CountCharactersAsync(1, "http://www.163.com");
Task<int> t2 = CountCharactersAsync(2, "http://www.microsoft.com");
Task<int>[] tasks = new Task<int>[] { t1, t2 };
Task.WaitAny(tasks);

8.在非同步方法中非同步的等待任務（WhenAll、.WhenAny）

上面說明了如何在“呼叫方法”中，同步等待Task的完成。但是有時候，我們在一個非同步方法中也會存在多個任務，想要讓它們通過await表示式等待。我們可以通過Task.WhenAll() 和 Task.WhenAny() 方法實現。這兩個方法稱為組合子（combinator）。

private async Task<int> CountCharactersAsync(string site1, string site2)
{
    WebClient wc1 = new WebClient();
    WebClient wc2 = new WebClient();
 
    Task<string> t1 = wc1.DownloadStringTaskAsync(new Uri(site1));
    Task<string> t2 = wc2.DownloadStringTaskAsync(new Uri(site2));
 
    List<Task<string>> tasks = new List<Task<string>>();
    tasks.Add(t1);
    tasks.Add(t2);
 
    //組合子
    await Task.WhenAll(tasks);
    //await Task.WhenAny(tasks);
 
    Console.WriteLine("   CCA:  T1 {0} Finished", t1.IsCompleted ? "" : "Not");
    Console.WriteLine("   CCA:  T2 {0} Finished", t2.IsCompleted ? "" : "Not");
 
    return t1.IsCompleted? t1.Result.Length: t2.Result.Length;
}

9.使用Task.Delay 暫停執行緒處理

一般我們都使用Thread.Sleep(xxxx) 進行執行緒的延時，但是 Thread.Sleep會阻塞執行緒。而Task.Delay則不會阻塞執行緒，執行緒可以繼續處理其他的工作。

class Simple
{
    Stopwatch sw = new Stopwatch();
    public void DoRun()
    {
        Console.WriteLine("Caller: Before call");
        ShowDelayAsync();
        Console.WriteLine("Caller: After call");
 
    }
    private async void ShowDelayAsync()
    {
        sw.Start();
        Console.WriteLine("   Before Delay:  {0} ", sw.Elapsed.Milliseconds );
        await Task.Delay(1000);
        Console.WriteLine("   After  Delay:  {0} ", sw.Elapsed.Milliseconds);
    }
}

到此這篇關於C#使用async和await實現非同步程式設計的文章就介紹到這了。希望對大家的學習有所幫助，也希望大家多多支援it145.com。