using System;
using System.Threading;
namespace AsyncTest
{
    public class AsyncDemo
    {
        //方法一
        public string TestMethod(int callDuration, out int threadId)
        {
            Console.WriteLine("Test method begins.");
            Thread.Sleep(callDuration);
            threadId = Thread.CurrentThread.ManagedThreadId;
            return String.Format("My call time was {0}.", callDuration.ToString());
        }
//方法二
public float Addxy(float x, float y)
        {
            return x * y;
        }
    }
    //定義兩個對應(yīng)于方法的委托，參數(shù)同方法一致,委托的聲明寫在調(diào)用類里也是一樣的，不限
    public delegate string AsyncMethodCaller(int callDuration, out int threadId);
    public delegate float AsyncMethodCaller2(float x, float y);
}

using System;
using System.Threading;
namespace AsyncTest
{
    public class AsyncMain
    {
        public static void Main()
        {
            // The asynchronous method puts the thread id here.
            int threadId;
            //實例化.
            AsyncDemo ad = new AsyncDemo();
            // 定義委托
            AsyncMethodCaller caller = new AsyncMethodCaller(ad.TestMethod);

            //通過委托調(diào)用方法，回調(diào)函數(shù)為null
            IAsyncResult result = caller.BeginInvoke(3000,
                out threadId, null, null);

            Thread.Sleep(0);
            Console.WriteLine("Main thread {0} does some work.",
                Thread.CurrentThread.ManagedThreadId);

            // Call EndInvoke to wait for the asynchronous call to complete,會阻塞
            // and to retrieve the results.
            string returnValue = caller.EndInvoke(out threadId, result);

            Console.WriteLine("The call executed on thread {0}, with return value \"{1}\".",
                threadId, returnValue);
        }
    }
}

using System;
using System.Threading;
namespace AsyncTest
{
    public class AsyncMain
    {
        static void Main()
        {
            // The asynchronous method puts the thread id here.
            int threadId;
            //實例化
            AsyncDemo ad = new AsyncDemo();

            //定義委托.
            AsyncMethodCaller caller = new AsyncMethodCaller(ad.TestMethod);

            //調(diào)用
            IAsyncResult result = caller.BeginInvoke(3000,
                out threadId, null, null);

            Thread.Sleep(0);
            Console.WriteLine("Main thread {0} does some work.",
                Thread.CurrentThread.ManagedThreadId);

            // Wait for the WaitHandle to become signaled.
            result.AsyncWaitHandle.WaitOne();

            // Perform additional processing here.
            // Call EndInvoke to retrieve the results.
            string returnValue = caller.EndInvoke(out threadId, result);

            // Close the wait handle.
            result.AsyncWaitHandle.Close();

            Console.WriteLine("The call executed on thread {0}, with return value \"{1}\".",
                threadId, returnValue);
        }
    }
}

using System;
using System.Threading;
namespace AsyncTest
{
    public class AsyncMain
    {
        static void Main() {
            // The asynchronous method puts the thread id here.
            int threadId;

            //實例化.
            AsyncDemo ad = new AsyncDemo();

            //聲明委托
            AsyncMethodCaller caller = new AsyncMethodCaller(ad.TestMethod);

            //調(diào)用.
            IAsyncResult result = caller.BeginInvoke(3000,
                out threadId, null, null);

            //輪詢.
            while(result.IsCompleted == false) {
                Thread.Sleep(250);
                Console.Write(".");
            }
            //取結(jié)果.
            string returnValue = caller.EndInvoke(out threadId, result);

            Console.WriteLine("\nThe call executed on thread {0}, with return value \"{1}\".",
                threadId, returnValue);
        }
    }
}

using System;
using System.Threading;
using System.Runtime.Remoting.Messaging;
namespace AsyncTest
{
    public class AsyncMain
    {
        static void Main()
        {
            //實例化類.
            AsyncDemo ad = new AsyncDemo();

            //實例兩個不同的委托，分別對應(yīng)不同的方法.
            AsyncMethodCaller caller = new AsyncMethodCaller(ad.TestMethod);

AsyncMethodCaller2 caller2 = new AsyncMethodCaller2(ad.Addxy);

            // The threadId parameter of TestMethod is an out parameter, so
            // its input value is never used by TestMethod. Therefore, a dummy
            // variable can be passed to the BeginInvoke call. If the threadId
            // parameter were a ref parameter, it would have to be a class-
            // level field so that it could be passed to both BeginInvoke and
            // EndInvoke.
            int dummy = 0;

            // 調(diào)用時指定回調(diào)方法，在異步執(zhí)行完后會自動調(diào)用該方法，用來取得執(zhí)行的結(jié)果
            IAsyncResult result = caller.BeginInvoke(3000,
                out dummy,
                new AsyncCallback(CallbackMethod),
                "The call executed on thread {0}, with return value \"{1}\".");

caller2.BeginInvoke(2, 3, CallbackMethod2, "this is add");
            Console.WriteLine("The main thread {0} continues to execute...",
                Thread.CurrentThread.ManagedThreadId);
            Thread.Sleep(4000);

            Console.WriteLine("The main thread ends.");
        }

        // The callback method must have the same signature as the
        // AsyncCallback delegate.
        private void CallbackMethod(IAsyncResult ar)
        {
            // Retrieve the delegate.
            AsyncResult result = (AsyncResult) ar;
   //強(qiáng)制轉(zhuǎn)換成對應(yīng)的委托對象
            AsyncMethodCaller caller = (AsyncMethodCaller) result.AsyncDelegate;

            // Retrieve the format string that was passed as state
            // information.
            string formatString = (string) ar.AsyncState;

            // Define a variable to receive the value of the out parameter.
            // If the parameter were ref rather than out then it would have to
            // be a class-level field so it could also be passed to BeginInvoke.
            int threadId = 0;
            // Call EndInvoke to retrieve the results.
            string returnValue = caller.EndInvoke(out threadId, ar);

            // Use the format string to format the output message.
            Console.WriteLine(formatString, threadId, returnValue);
        }
private void CallbackMethod2(IAsyncResult ar)
        {
            // Retrieve the delegate.
            AsyncResult result = (AsyncResult)ar;
//強(qiáng)制轉(zhuǎn)換成對應(yīng)的委托對象
            AsyncMethodCaller2 caller = (AsyncMethodCaller2)result.AsyncDelegate;

            // 取得狀態(tài)
            string formatString = (string)ar.AsyncState;
            //調(diào)用異步完成的方法，取得執(zhí)行結(jié)果
            string returnValue = caller.EndInvoke(ar).ToString();

//此種方式是在windows應(yīng)用程序給控件賦值時用，因為在非創(chuàng)建線程不能操作控件
            this.Invoke(new Action<string>((u) => tb_datainfo.Text += u), returnValue);
            //tb_datainfo.Text = caller.EndInvoke(out threadId, ar);

            // Use the format string to format the output message.
            //Console.WriteLine(formatString, threadId, returnValue);
        }
    }
    }
}