委托线程三部曲（引用）

#异步委托(异步方法调用)一:
同步调用 : 程序顺序执行时-->调用很耗时的[方法]-->阻塞当前线程-->[方法]调用完成-->继续执行。
异步调用 : 

--------------------------------------------------------------------------------

委托例子 : 
    自写委托如下 : 
    public delegate String MyDelegate(String name);
    微软会自动提供下面两个方法 : 
    IAsyncResult BeginInvoke(String name, AsyncResult callback, Object o);
    String EndInvoke(IAsyncResult result);

--------------------------------------------------------------------------------

每个委托都有3个方法 : 
    Invoke      : 是委托指定函数的同步调用;
    BeginInvoke : 是异步调用, 调用后立即返回，不等待调用结果
    EndInvoke   : 是异步调用, 用于检索调用结果。调用BeginInvoke后可随时调用, 它将一直阻塞到异步调用完成。

AsyncCallback 委托 : 用于指定在开始操作完成后应被调用的方法。
IAsyncResult 接口  : 用于监视和管理异步操作。

public interface IAsyncResult
{
    Object AsyncState { get; }              // 该属性为BeginInvoke参数中的最后一个参数对象
    WaitHandle AsyncWaitHandle { get; }     // 
    bool CompletedSynchronously { get; }    // 如果开始操作调用已同步完成，则其属性将被设置为 true。
    bool IsCompleted { get; }               // 该属性判断异步调用是否结束
}

--------------------------------------------------------------------------------

例子 : 

1) 定义一个委托 :
    using System.Threading;
    using System.Runtime.Remoting.Messaging;

    public delegate int AddHandler(int a,int b);
    public class 加法类
    {
        public static int Add(int a, int b)
        {
            Console.WriteLine("开始计算：" + a + "+" + b);
            Thread.Sleep(3000); //模拟该方法运行三秒
            Console.WriteLine("计算完成！");
            return a + b;
        }
    }

2) 同步调用 : 委托的Invoke方法用来进行同步调用。同步调用也可以叫阻塞调用，它将阻塞当前线程，然后执行调用，调用完毕后再继续向下进行。
    public class 同步调用
    {
        static void Main()
        {
            Console.WriteLine("===== 同步调用 SyncInvokeTest =====");
            AddHandler handler = new AddHandler(加法类.Add);
            int result = handler.Invoke(1, 2);

            Console.WriteLine("继续做别的事情。。。");

            Console.WriteLine(result);
            Console.ReadKey();
        }

        /*运行结果：
         ===== 同步调用 SyncInvokeTest =====
         开始计算：1+2
         计算完成！
         继续做别的事情。。。
         3       */
    }

3) 异步调用 : 异步调用不阻塞线程，而是把调用塞到线程池中，程序主线程或UI线程可以继续执行。委托的异步调用通过BeginInvoke和EndInvoke来实现。
    public class 异步调用
    {
        static void Main()
        {
            Console.WriteLine("===== 异步调用 AsyncInvokeTest =====");
            AddHandler handler = new AddHandler(加法类.Add);

            //IAsyncResult: 异步操作接口(interface)
            //BeginInvoke: 委托(delegate)的一个异步方法的开始
            IAsyncResult result = handler.BeginInvoke(1, 2, null, null);

            Console.WriteLine("继续做别的事情。。。");

            //异步操作返回
            Console.WriteLine(handler.EndInvoke(result));
            Console.ReadKey();
        }

        /*运行结果：
         ===== 异步调用 AsyncInvokeTest =====
         继续做别的事情。。。
         开始计算：1+2
         计算完成！
         3       */
    }

4) 异步回调 : 用回调函数，当调用结束时会自动调用回调函数，解决了为等待调用结果，而让线程依旧被阻塞的局面。

    public class 异步回调
    {
        static void Main()
        {
            Console.WriteLine("===== 异步回调 AsyncInvokeTest =====");
            AddHandler handler = new AddHandler(加法类.Add);

            //异步操作接口(注意BeginInvoke方法的不同！)
            IAsyncResult result = handler.BeginInvoke(1,2,new AsyncCallback(回调函数),"AsycState:OK");
            
            Console.WriteLine("继续做别的事情。。。");
            Console.ReadKey();
        }

        static void 回调函数(IAsyncResult result)
        {   //result 是“加法类.Add()方法”的返回值

            //AsyncResult 是IAsyncResult接口的一个实现类，空间：System.Runtime.Remoting.Messaging
            //AsyncDelegate 属性可以强制转换为用户定义的委托的实际类。
            AddHandler handler = (AddHandler)((AsyncResult)result).AsyncDelegate;
            Console.WriteLine(handler.EndInvoke(result));
            Console.WriteLine(result.AsyncState);
        }

        /*运行结果：
        ===== 异步回调 AsyncInvokeTest =====
        开始计算：1+2
        继续做别的事情。。。
        计算完成！
        3
        AsycState:OK
                 */
    }

总结 : 
Invoke方法首先检查发出调用的线程(即当前线程)是不是UI线程，如果是，直接执行委托指向的方法，如果不是，它将切换到UI线程，然后执行委托指向的方法。