首頁 > 軟體

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!


IT145.com E-mail:sddin#qq.com