通过委托来实现异步 Delegate的BeginInvoke和EndInvoke

什么是.net的异步机制呢？

解释这个话题之前，先让我们来看看同步执行的程序

https://github.com/chucklu/Test/blob/master/DotNet4.5开发指南/并行处理和并发/异步编程模式/APM/SyncProcedure/Program.cs

 static class SyncTest
    {
        public static void Method()
        {

            Console.WriteLine("SyncTest类中的Method()函数的线程ID是{0}", Thread.CurrentThread.ManagedThreadId);//Environment.CurrentManagedThreadId
            if (Thread.CurrentThread.IsThreadPoolThread)//判断当前线程是否托管在线程池上
            {
                Console.WriteLine("SyncTest类中的Method()函数的线程托管于线程池");
            }
            else
            {
                Console.WriteLine("SyncTest类中的Method()函数的线程没有托管在线程池上");
            }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Program类中的Main()函数的线程ID是{0}", Thread.CurrentThread.ManagedThreadId);//Environment.CurrentManagedThreadId
            if (Thread.CurrentThread.IsThreadPoolThread)//判断当前线程是否托管在线程池上
            {
                Console.WriteLine("Program类中的Main()函数的线程托管于线程池");
            }
            else
            {
                Console.WriteLine("Program类中的Main()函数的线程没有托管在线程池上");
            }
            Console.WriteLine();

            SyncTest.Method();//调用静态类的静态方法

            Console.Read();//阻塞，确保能看到上面的打印信息
        }
    }

执行结果如下图所示

从图中可以看出，在主函数中调用另外一个类SyncTest的方法,

进入方法Method的时候，此方法还是和Main函数在同一个线程上执行的

并且该线程不是托管在线程池上的线程

 

 

接下来写一个通过委托，进行异步执行的方法

https://github.com/chucklu/Test/blob/master/DotNet4.5开发指南/并行处理和并发/异步编程模式/APM/AsyncProcedure/Program.cs

不要尝试去查看BeginInvoke和EndInvoke的实现，右键，转到定义，是看不到的。这两个方法是CLR为委托类型添加的

/// <summary>
    /// 声明一个委托 委托的名字是AsyncHandler
    /// </summary>
    /// <param name="name"></param>
    public delegate void AsyncHandler();//委托的声明方式类似于函数，只是比函数多了一个delegate关键字
    
    static class AsyncTest
    {
        public static void Method()
        {
            Console.WriteLine("AsyncTest类中的Method()函数的线程ID是{0}", Thread.CurrentThread.ManagedThreadId);//Environment.CurrentManagedThreadId
            if (Thread.CurrentThread.IsThreadPoolThread)//判断当前线程是否托管在线程池上
            {
                Console.WriteLine("AsyncTest类中的Method()函数的线程托管于线程池");
            }
            else
            {
                Console.WriteLine("AsyncTest类中的Method()函数的线程没有托管在线程池上");
            }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Program类中的Main()函数的线程ID是{0}", Thread.CurrentThread.ManagedThreadId);//Environment.CurrentManagedThreadId
            if (Thread.CurrentThread.IsThreadPoolThread)//判断当前线程是否托管在线程池上
            {
                Console.WriteLine("Program类中的Main()函数的线程托管于线程池");
            }
            else
            {
                Console.WriteLine("Program类中的Main()函数的线程没有托管在线程池上");
            }
            Console.WriteLine();

            //把Method 方法分配给委托对象
            AsyncHandler async = AsyncTest.Method; //

            //发起一个异步调用的方法,返回IAsyncResult 对象
            IAsyncResult result = async.BeginInvoke(null,null);

            //这里会阻碍线程,直到方法执行完毕
            async.EndInvoke(result);

            Console.Read();
        }
    }

运行结果如下图所示

从上图可以看出，委托的BeginInvoke，是新开了一个线程运行方法，并且该线程是托管在线程池上的

 

 

 

 

上面两个代码的示例，区别在于，第二个使用的是委托的BeginInvoke方法

通过反编译工具，我们可以查看委托具体做了什么，一般.net Reflector不错，最近新发现一个叫ILSpy的，开源的反编译工具

https://github.com/icsharpcode/ILSpy   官网的.sln是VS2013的，如果不想自己编译的，也可以去官网下载编译好的exe程序

官网链接是http://ilspy.net/     右上角有一个Download Binaries，点击下载就可以了

接下来上图，反编译的结果

从上图可以发现AsyncHandler委托的结构如下

public extern AsyncHandler(object @object, IntPtr method);
public virtual extern IAsyncResult BeginInvoke(AsyncCallback callback, object @object);
public virtual extern void EndInvoke(IAsyncResult result);
public virtual extern void Invoke();

而且可以发现继承层次，AsyncHandler从MulticastDelegate继承，再上层是Delegate类（注意，大写的Delegate表示的是类，而不是delegate关键字）

 

去msdn上找了相关信息

 

 

 Delegate类

public abstract class Delegate : ICloneable,ISerializable

The Delegate class is the base class for delegate types.
Delegate类是delegate类型的基类

However, only the system and compilers can derive explicitly from the Delegate class or from the MulticastDelegate class. 
然后只有系统和编译器才可以从Delegate类或者MulticastDelegate类进行派生

It is also not permissible to derive a new type from a delegate type. 
从委托类型派生一个新类型也是不允许的

The Delegate class is not considered a delegate type; it is a class used to derive delegate types.
Delegate类并不是委托类型,它只是一个用于派生委托类型的类。

Most languages implement a delegate keyword, and compilers for those languages are able to derive from the MulticastDelegate class; therefore, users should use the delegate keyword provided by the language.
大多数语言实现了delegate关键字，并且这些语言的编译器是能够从MulticastDelegate类进行派生的，所以，开发者们应该使用开发语言所提供的delegate关键字

The common language runtime provides an Invoke method for each delegate type, with the same signature as the delegate.
CLR为每一个委托类型提供了一个Invoke方法，并且该方法和delegate拥有相同的签名

The common language runtime provides each delegate type with BeginInvoke and EndInvoke methods, to enable asynchronous invocation of the delegate.
CLR为每一个委托类型提供了BeginInvoke和EndInvoke方法，来确保委托的异步调用

MulticastDelegate类

public abstract class MulticastDelegate : Delegate

MulticastDelegate is a special class. Compilers and other tools can derive from this class, but you cannot derive from it explicitly. The same is true of the Delegate class.
多播委托是一个特殊的类。编译器或者其他工具，可以从从这个类派生，但是你不能显式地从这个类派生。同样的规则适用于Delegate类。

In addition to the methods that delegate types inherit from MulticastDelegate, the common language runtime provides two special methods: BeginInvoke and EndInvoke.
delegate关键字声明的委托，不但继承了多播委托的方法，并且CLR还提供了两个特殊的方法BeginInvoke和EndInvoke

更多关于BeginInvoke和EndInvoke的信息可以参见此链接[使用异步方式调用同步方法]http://msdn.microsoft.com/en-us/library/2e08f6yc(v=vs.110).aspx

 使用委托进行异步编程http://msdn.microsoft.com/zh-cn/library/22t547yb(v=vs.110).aspx

 

转载自http://www.cnblogs.com/AndyHuang/archive/2008/12/24/1361267.html   (有自己的修改和理解)