C#非同步呼叫（Asynchronou Delegate）

C#非同步呼叫獲取結果方法：主要有三種，也可以說是四種（官方說四種，電子書說三種），官方在MSDN上已經有詳細的說明： 連結

需要了解到獲取非同步執行的返回值，意味著你需要呼叫Delegate的BeginInvoke方法，而不是Invoke方法。

第一種就是書上沒有說的，但是官方還是給出來的，就是通過呼叫EndInvoke方法來獲取內容，檢視如下程式碼：

    class MyState
    {
        public int ThreadId = 0;
        public int Data = 0;

        public MyState()
        { 
            
        }
    }
    class AsyncInvoke
    {
        private MyState State = null;
        
        public AsyncInvoke()
        {
            State = new MyState();
        }

        private int TakesAWhile(int data, int ms)
        {
            Console.WriteLine("TakesAWhile started");
            Thread.Sleep(ms);
            Console.WriteLine("TakesAWhile completed");
            return ++data;
        }

        public delegate int TakesAWhileDelegate(int data, int ms);

        public void RunEndInvoke()
        {
            TakesAWhileDelegate dl = new TakesAWhileDelegate(TakesAWhile);
            IAsyncResult ar = dl.BeginInvoke(5, 3000, null, null);
            int result = 0;
            result = dl.EndInvoke(ar);
            Console.WriteLine(string.Format("Result: {0}", result));
        }
    } 
 

TakesAWhile started
TakesAWhile completed
Result: 6

通過上面可以知道使用EndInvoke阻塞了主執行緒（RunEndInvoke函式），同時需要使用BeginInvoke的返回值ar作為EndInvoke的入參。

第二種方法Polling（輪詢）BeginInvoke的返回值(IAsyncResult中的屬性IsCompleted)，將RunEndInvoke替換成下面的函式RunPolling：

        public void RunPolling()
        {
            TakesAWhileDelegate dl = new TakesAWhileDelegate(TakesAWhile);
            IAsyncResult ar = dl.BeginInvoke(5, 3000, null, null);

            while (ar.IsCompleted == false)
            {
                Thread.Sleep(500);
            }
            int result = 0;
            result = dl.EndInvoke(ar);
            Console.WriteLine(string.Format("Result: {0}", result));
        }
 

        public void RunInvoke()
        {
            TakesAWhileDelegate dl = new TakesAWhileDelegate(TakesAWhile);
            int result = dl.Invoke(5, 3000);
            Console.WriteLine(string.Format("Result: {0}", result));
        }
 

        public void RunEndInvoke()
        {
            TakesAWhileDelegate dl = new TakesAWhileDelegate(TakesAWhile);
            IAsyncResult ar = dl.BeginInvoke(5, 3000, null, null);
            // Do others in main thread.
            Console.WriteLine("Do others in main thread...");
            //
            int result = 0;
            result = dl.EndInvoke(ar);
            Console.WriteLine(string.Format("Result: {0}", result));
        }

Do others in main thread...
TakesAWhile started
TakesAWhile completed
Result: 6

這樣你可以放別的工作在BeginInvoke的之後，在主執行緒執行，等到執行了，可以使用阻塞主執行緒來等待非同步執行的結果來進行下一步的需要，這樣情況能夠部分提高工作效率，通常用於執行相互獨立的模組，然後再等待兩邊結果（主執行緒以及非同步執行緒的結果）來進行下一步的操作。

好了，講第三種的方法來獲取非同步結果了，就是Wait Handle。 handle是通過BeginInvoke的返回值（ar）中的一個屬性AsyncWaitHandle來獲得的。一開始AsyncWaitHandle是沒有初始化的，但是隻要引用該屬性，作業系統實現它，同時呼叫其waitone函式去等待非同步執行完的訊號。如果使用沒有帶參的waitone函式，則無限期阻塞主執行緒來等待非同步執行，一旦執行完，則返回， 如下程式碼所示：

        public void RunWaitHandle()
        {
            TakesAWhileDelegate dl = new TakesAWhileDelegate(TakesAWhile);
            IAsyncResult ar = dl.BeginInvoke(5, 3000, null, null);
            ar.AsyncWaitHandle.WaitOne();
            Console.WriteLine("Wait for 3 seconds.");
            int result = 0;
            result = dl.EndInvoke(ar);
            ar.AsyncWaitHandle.Close();
            Console.WriteLine(string.Format("Result: {0}", result));
        }

如果使用帶參的，如waitone（1000， false）來判斷當前返回值是true則意味著等待1秒，第二引數來判斷是否退出同步。

從上面三種方法來看，的確是挺好的，但是每次都需要主執行緒去等待，大哥不好當，所以就有了第四種方法，就是使用BegingInvoke的第三個引數，該函式是在BeginInvoke呼叫的函式執行完後自動執行，不然也不叫做callback。
第四個引數通常將非同步函式的delegate傳遞過去，這樣在callback函式中就可以方便的獲取到非同步函式的執行結果或者返回值。

        public void AsyncCompleted(IAsyncResult ar)
        {
            if (ar != null)
            {
				Console.WriteLine("After the async operation.");
                TakesAWhileDelegate dl = ar.AsyncState as TakesAWhileDelegate;
                int result = 0;
                result = dl.EndInvoke(ar);
                Console.WriteLine(string.Format("Result: {0}", result));
            }
        }

        public void RunAsyncCallback()
        {
            TakesAWhileDelegate dl = new TakesAWhileDelegate(TakesAWhile);
            IAsyncResult ar = dl.BeginInvoke(5, 3000, AsyncCompleted, dl);
            Console.WriteLine("Finish RunAsyncCallback.");
        }

        public void RunAsyncCallback2()
        {
            TakesAWhileDelegate dl = new TakesAWhileDelegate(TakesAWhile);
            dl.BeginInvoke(5, 3000, ar => {
                Console.Write("After async operation.");
                int result = 0;
                result = dl.EndInvoke(ar);
                Console.WriteLine(string.Format("Result: {0}", result));
            }, null);
            Console.WriteLine("Finish RunAsyncCallback.");
        }

        private MyState TakesAWhile(int data)
        {
            Console.WriteLine("TakesAWhile started");
            Thread.Sleep(3000);
            Console.WriteLine("TakesAWhile completed");
            return new MyState(){Data=++data, ThreadId=Thread.CurrentThread.ManagedThreadId};
        }

        private delegate MyState TaskAWhileDelegate2(int data);

        public void RunEndInvokeWithStructReturn()
        {
            TaskAWhileDelegate2 dl = new TaskAWhileDelegate2(TakesAWhile);
            IAsyncResult ar = dl.BeginInvoke(5, null, null);
            MyState state = null;
            state = dl.EndInvoke(ar);
         
            Console.WriteLine(string.Format("Data: {0}, ThreadId: {1}", state.Data, state.ThreadId));
        }

        private void TakesAWhile(int data, int ms, ref MyState state)
        {
            Console.WriteLine("TakesAWhile started");
            Thread.Sleep(ms);
            Console.WriteLine("TakesAWhile completed");
            state.Data = ++data;
            state.ThreadId = Thread.CurrentThread.ManagedThreadId;
        }

        private delegate void TakesAWhileDelegate3(int data, int ms, ref MyState state);
       
        public void RunEndInvokeWithRefStruct()
        {
            TakesAWhileDelegate3 dl = new TakesAWhileDelegate3(TakesAWhile);
            IAsyncResult ar = dl.BeginInvoke(5, 3000, ref State, null, null);
            dl.EndInvoke(ref State, ar); // this State could be any other reference to MyState
            Console.WriteLine(string.Format("Data: {0}, ThreadId: {1}", State.Data, State.ThreadId));
        }

上面講述的主要是Thread或者task的非同步呼叫BeginInvoke的結果獲取方法，但是如果該非同步函式中涉及到輸出引數，就如剛才說的複雜物件中的成員是controller的話，就又有一章來講了，對於UI以及後臺執行緒的互動這是一個重要點，如果你不想你的UI經常假死的話，請收看下一回：Controller中BeginInvoke與Invoke的區別以及應用。

AD的優勢是非同步函式的強型別保證，引數的輸入都是規定好的（delegate宣告），如果需要傳遞引數可以在函式中使用ref關鍵字（只針對引用型別，值型別無效果）。由於非同步呼叫時使用task底層實現的，所以他具有了task的優勢，方便使用，但是也有其缺點，不能夠想thread那樣提供豐富的對執行緒設定（後臺，優先順序，不能中斷）。