C#使用Task實現非同步方法

2023-04-08 06:00:33

一、async和await特性的結構

1. 非同步和同步

同步方法：如果一個方法被呼叫了，等待其執行所有處理後呼叫方法才繼續執行的方法。

非同步方法：非同步方法能在處理完成之前就回到呼叫方法。

2.async和await

呼叫方法：該方法呼叫非同步方法，然後在非同步方法（可能在相同的執行緒，也可能在不同的執行緒）執行其任務時繼續執行。

非同步（async）方法：該方法非同步執行其工作，被呼叫時立即回到呼叫方法。

await表示式：用於非同步方法內部，指明需要非同步執行的任務。一個非同步方法需要至少包含一個await表示式。

二、什麼是非同步方法

1.非同步方法的結構

非同步方法在完成其工作之前即返回到呼叫方法，然後在呼叫方法繼續執行的時候完成其工作。

方法頭包含async方法修飾符，該修飾符僅標識此方法是一個非同步方法。
包含至少一個await表示式，表示可以非同步完成的任務。
必須具備以下三種返回型別中的一種：void、Task、Task<T>。
非同步方法的引數可以是任意型別，但不能為ref或out。
按照約定，非同步方法的名稱應該為Async為字尾。
除了方法以外，Lambda表示式和匿名方法也可以作為非同步物件。

2.非同步方法三種返回型別理解

1. Task<T> ：如果呼叫方法要從呼叫中獲取一個T型別的值，非同步方法的返回型別就必須是Task<T>。呼叫方法通過讀取Task的Result屬性來獲取這個T型別的值。

    // 使用返回Task<int>物件的非同步方法程式碼範例：    
    static class DoAsyncStuff 
    {
        public static async Task<int> CalculateSumAsync(int i1, int i2) 
        {
            int sum = await Task.Run(() => GetSum(i1, i2));
            return sum;//注意返回的是一個int型別
        }
 
        private static int GetSum(int i1, int i2) { return i1 + i2; }
    
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            Task<int> task = DoAsyncStuff.CalculateSumAsync(1, 2);
            //處理其他事情...
            Console.WriteLine("Value:{0}",task.Result);//呼叫方法通過Result獲取這個int型別的值
 
        }
    }

2.Task ：如果呼叫方法不需要從非同步方法中返回某個值，但需要檢查非同步方法的狀態，那麼非同步方法可以返回一個Task型別的物件，這時即使非同步方法中出現了return語句，也不會返回任何東西。

    //使用Task不返回型別的非同步方法程式碼範例：
    static class DoAsyncStuff
    {
        public static async Task CalculateSumAsync(int i1, int i2)
        {
            int sum = await Task.Run(() => GetSum(i1, i2));
            Console.WriteLine("Value:{0}",sum);
        }
 
        private static int GetSum(int i1, int i2) { return i1 + i2; }
 
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            Task task = DoAsyncStuff.CalculateSumAsync(1, 2);
            //處理其他事情...
            task.Wait();
            Console.WriteLine("非同步方法結束");
        }
    }

3. void ：如果呼叫方法僅僅想執行非同步方法，而不需要與它進行進一步互動時【稱為“呼叫並忘記”】，非同步方法可以返回void型別。

    //使用「呼叫並忘記」的非同步方法的程式碼範例：
    static class DoAsyncStuff
    {
        public static async void CalculateSumAsync(int i1, int i2)
        {
            int sum = await Task.Run(() => GetSum(i1, i2));
            Console.WriteLine("Value:{0}",sum);
        }
 
        private static int GetSum(int i1, int i2) { return i1 + i2; }
 
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            DoAsyncStuff.CalculateSumAsync(1, 2);
            //處理其他事情...
            Thread.Sleep(200);
            Console.WriteLine("Program Exiting");
        }
    }

3.非同步方法的控制流

1. 非同步方法的結構包含三個不同的區域：

控制流闡述：

呼叫非同步方法後，知道遇到第一個await表示式之前都是同步的。
遇到await表示式之後，非同步方法將控制返回到呼叫方法。如果方法的返回型別為Task或Task<T>型別，將建立一個Task物件，表示需非同步完成的任務和後續，然後將Task返回到呼叫方法。
到目前為止，已經出現兩個控制流，非同步方法內的和呼叫方法內的。非同步方法的程式碼完成以下工作：
- 非同步執行await表示式的空閒任務。
- 當await表示式完成時，執行後續部分。如果後續還有await表示式，將重複此步驟：非同步執行await表示式，然後執行後續部分。
當後續部分遇到return語句或到達方法末尾時：
- 如果方法返回型別為void，控制流將退出。
- 如果方法返回型別為Task，後續部分設定Task的屬性並退出。
- 如果方法返回型別為Task<T>,後續部分還將設定Task的Result屬性。
同時呼叫方法中的程式碼繼續其程序，從非同步方法獲取Task物件。當需要其實際值時，就參照Task物件的Result屬性，屆時，如果非同步方法設定了該屬性，呼叫方法就能呼叫其值並繼續，否則將暫停等待該屬性被設定，然後再繼續執行。

需要注意的是：非同步方法的return語句並沒有真正返回一個值，它只是退出了，非同步方法中的返回型別始終是方法頭中宣告的返回型別。

三、await表示式

await表示式指定了一個非同步執行的任務。這個任務可能是一個Task型別的物件，也可能不是，預設情況下這個任務在當前執行緒非同步執行。

我們可能需要編寫自己的方法作為await表示式的任務。最簡單的方式是在你的方法中使用Task.Run建立一個Task。（關於Task.Run即在不同的執行緒上執行你的方法）Task.Run方法有8個過載，如下圖所示：

以Func<int> 委託作為引數的程式碼範例：

    class MyClass
    {
        public int Get10() 
        {
            return 10;
        }
 
        public async Task DoWorkAsync() 
        {
            //方式1：使用Get10建立名為ten的Func<int>委託，將該委託傳入Task.Run方法
            Func<int> ten = new Func<int>(Get10);
            int a = await Task.Run(ten);
 
            //方式2：直接在Task.Run中建立委託，傳入Get10方法
            int b = await Task.Run(new Func<int>(Get10));
 
            //方式3：使用與Func<T>相容的Lambda表示式，Lambda表示式將隱式轉換為該委託
            int c = await Task.Run(() => { return 10; });
 
            Console.WriteLine("{0},{1},{2}",a,b,c);
        }
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            Task task = new MyClass().DoWorkAsync();
            task.Wait();
        }
    }

從Task.Run的過載中可以發現，可以作為Run中第一個引數的委託有四種：

使用四種委託作為引數的Run方法程式碼範例：

    class MyClass
    {
        public static async Task DoWorkAsync() 
        {
            await Task.Run(() => Console.WriteLine(5.ToString()));//Aciton,無參無返
 
            Console.WriteLine((await Task.Run(() => 6)).ToString());//TResult Func()，無參有返，返回TResult型別物件
 
            await Task.Run(() => Task.Run(() => Console.WriteLine(7.ToString())));//Task Func()，無參有返，返回簡單Task物件
 
            Console.WriteLine((await Task.Run(() => Task.Run(() => 8))).ToString());//Task<TResult> Func()，無參有返，返回Task<T>物件
        }
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            Task task = MyClass.DoWorkAsync();
            task.Wait();
        }
    }

假如我們需要一個接受引數的方法，但是無法匹配上述的四種委託（接受沒有引數的方法的委託），我們可以建立一個Lambda表示式，其唯一行為就是執行我們的接受引數的方法，來滿足Run方法所能接受的委託形式。程式碼範例如下：

    class MyClass
    {
        //需要使用非同步的方法
        public static int GetSum(int a, int b) { return a + b; }
 
        public static async Task DoWorkAsync(int a,int b) 
        {
            int result = await Task.Run(() => GetSum(a, b));//建立一個滿足Func<TResult>委託形式的Lambda表示式
            Console.WriteLine(result);
        }
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            Task task = MyClass.DoWorkAsync(6,7);
            task.Wait();
        }
    }

四、取消一個非同步操作

一些.NET非同步方法允許你請求終止執行，我們可以在自己的非同步方法中加入這個特性。有兩個類：CancellationToken和CancellationTokenSource是專門為了取消非同步操作設計的。

1. CancellationToken物件包含了一個任務是否應被取消的訊息。擁有CancellationToken物件的任務需要定期檢查其令牌（token）的狀態，如果CancellationToken物件中的IsCancellationRequested屬性為true，任務需停止其操作並返回。CancellationToken是不可逆的，也就是一旦IsCancellationRequested設定為true就不能更改了。

2. CancellationTokenSource物件建立可分配給不同任務的CancellationToken物件。任何持有CancellationTokenSource的物件都可以呼叫其Cancel方法，這會將CancellationToken物件中的IsCancellationRequested設定為true。

3. 使用這兩個取消類的程式碼：

    class MyClass
    {
        public async Task RunAsync(CancellationToken ct) 
        {
            if (ct.IsCancellationRequested)
                return;
            await Task.Run(()=>CycleMethod(ct));
        }
 
        void CycleMethod(CancellationToken ct) 
        {
            Console.WriteLine("開始CycleMethod方法");
 
            const int max = 5;
 
            for (int i = 0; i < max; i++) 
            {
                if (ct.IsCancellationRequested)
                    return;
                Thread.Sleep(1000);
                Console.WriteLine("完成：{0}/{1}",i+1,max);
            }
        }
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            CancellationTokenSource cts = new CancellationTokenSource();
            CancellationToken ct = cts.Token;
 
            MyClass mc = new MyClass();
 
            Task t = mc.RunAsync(ct);
 
            /*
                取消非同步操作的過程是協同的：
                    即呼叫CancellationTokenSource的Cancel時，它本身並不會執行取消操作
                    而是會將CancellationToken的IsCancellationRequested屬性設定為true
                    包含CancellationToken的程式碼負責檢查該屬性，並判斷是否需要停止執行並返回
             */
            //Thread.Sleep(3000);
            //cts.Cancel();//解除註釋將產生取消非同步的操作
 
            t.Wait();
            Console.WriteLine("是否取消了非同步方法：{0}", ct.IsCancellationRequested);
 
        }
    }

五、例外處理的await表示式

就使用try...catch...正常處理異常就行。

    class MyClass
    {
        public static async Task BadAsync() 
        {
            try
            {
                await Task.Run(() => { throw new Exception(); });
            }catch (Exception ex) 
            {
                Console.WriteLine("非同步中丟擲異常...");
            }
        }
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            Task task = MyClass.BadAsync();
            task.Wait();
            Console.WriteLine("Task Status：{0}",task.Status);//Task Status：RanToCompletion，因為Task沒有被取消
            Console.WriteLine("Task IsFaulted：{0}",task.IsFaulted);//Task IsFaulted：False，因為沒有未處理的異常
 
 
        }
    }

六、在呼叫方法中同步地等待任務

1. Wait

Task的Wait方法可以讓呼叫方法等待非同步方法完成，在Wait方法處，流程是阻塞的。

    class MyClass
    {
        public void PrintA()
        {
            const int max = 10;
            for (int i = 0; i < max; i++)
            {
                Thread.Sleep(1000);
                Console.WriteLine("A任務完成：{0}/{1}", i + 1, max);
            }
        }
        public async Task ForWaitAsync() 
        {
            await Task.Run(new Action(PrintA));
        }
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            MyClass mc = new MyClass();
            Task t = mc.ForWaitAsync();
 
            Thread.Sleep(6000);//主執行緒休眠6秒
 
            //等待任務完成,使用此方法可以讓主方法等待非同步方法完成，否則主方法休眠六秒結束時非同步方法也將直接結束
            t.Wait();
        }
    }

2. WaitAll和WaitAny

Wait是等待單一任務完成，我們也可以使用WaitAll和WaitAny等待多個任務。（這兩個方法是同步方法，知道等待條件滿足後再繼續執行，不然流程會阻塞在那裡）

    class MyClass
    {
        public void PrintA()
        {
            const int max = 10;
            for (int i = 0; i < max; i++)
            {
                Thread.Sleep(1000);
                Console.WriteLine("A任務完成：{0}/{1}", i + 1, max);
            }
            Console.WriteLine("A任務全部完成！");
        }
 
        public void PrintB()
        {
            const int max = 5;
            for (int i = 0; i < max; i++)
            {
                Thread.Sleep(1000);
                Console.WriteLine("B任務完成：{0}/{1}", i + 1, max);
            }
            Console.WriteLine("B任務全部完成！");
        }
 
        public async Task AForWaitAsync() 
        {
            await Task.Run(new Action(PrintA));
        }
 
        public async Task BForWaitAsync()
        {
            await Task.Run(new Action(PrintB));
        }
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            MyClass mc = new MyClass();
            Task a = mc.AForWaitAsync();
            Task b = mc.BForWaitAsync();
 
            Task[] task = new Task[] { a, b };//存放Task的陣列
 
            Thread.Sleep(8000);//呼叫方法休眠8秒
 
            //Task.WaitAll(task);//等待所有任務完成
            Task.WaitAny(task);//等待任意一個任務完成後將不再阻塞
 
        }
    }

WaitAll和WaitAny分別還包含四個過載：

七、在非同步方法中非同步地等待任務

有時在非同步方法中，你會希望用await表示式來等待Task。這時非同步方法會返回到呼叫方法，但該非同步方法會等待一個或所有任務完成。可以通過Task.WhenAll或Task.WhenAny方法來實現。這兩個方法稱為組合子。

    class MyClass
    {
        public void PrintA()
        {
            const int max = 10;
            for (int i = 0; i < max; i++)
            {
                Thread.Sleep(1000);
                Console.WriteLine("A任務完成：{0}/{1}", i + 1, max);
            }
        }
 
        public void PrintB()
        {
            const int max = 5;
            for (int i = 0; i < max; i++)
            {
                Thread.Sleep(1000);
                Console.WriteLine("B任務完成：{0}/{1}", i + 1, max);
            }
        }
 
        public async Task AAsync() 
        {
            await Task.Run(new Action(PrintA));
        }
 
        public async Task BAsync()
        {
            await Task.Run(new Action(PrintB));
        }
 
        public async Task ForWhenAsync()
        {
            Task a = AAsync();
            Task b = BAsync();
 
            Task[] tasks = { a, b };//Task陣列
 
            //await Task.WhenAll(tasks);//在非同步中等待所有任務
            await Task.WhenAny(tasks);//在非同步中等待任意一個任務
 
            //此非同步方法中的流程會阻塞在Task.WhenAny(tasks)中，直到某個條件滿足才會到達這裡
            Console.WriteLine("現在任務A是否完成：{0}",a.IsCompleted?"Yes":"No");
            Console.WriteLine("現在任務B是否完成：{0}",b.IsCompleted?"Yes":"No");
        }
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            const int max = 12;
 
            MyClass mc = new MyClass();
            mc.ForWhenAsync();
 
            for (int i = 0;i < max ; i++) 
            {
                Thread.Sleep(1000);
                Console.WriteLine("Main任務完成：{0}/{1}", i + 1, max);
            }
 
        }
    }

八、Task.Delay方法

Task.Delay方法建立一個物件，該物件將暫停其線上程中的處理，並在一定時間之後完成。和Thread.Sleep阻塞執行緒不同的是，Task.Delay方法不會阻塞執行緒，執行緒可以繼續處理其他工作。

    class Simple
    {
        Stopwatch sw = new Stopwatch();
 
        public void DoRun() 
        {
            Console.WriteLine("呼叫之前");
            ShowDelayAsync();
            Console.WriteLine("呼叫之後");
        }
 
        private async void ShowDelayAsync() 
        {
            sw.Start();
            Console.WriteLine("Delay 執行之前：{0}",sw.ElapsedMilliseconds);
            await Task.Delay(1000);//建立了一個Task物件，該物件將暫停其線上程中的處理，所以在列印下一句話之前，控制回到了呼叫方法列印呼叫方法中的"呼叫之後"
            Console.WriteLine("Delay 執行之後：{0}", sw.ElapsedMilliseconds);
        }
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            Simple simple = new Simple();
            simple.DoRun();
            Console.Read();
            
        }
    }

到此這篇關於C#使用Task實現非同步方法的文章就介紹到這了,更多相關C# Task非同步內容請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com！