C# Control的Invoke和BeginInvoke

C# Control的Invoke和BeginInvoke及其实现机制

与C++不同，C#语言禁止在创建某个控件的线程外对控件进行访问，否则会引起访问违规的异常。但有些时候，我们的确需要从其他线程对控件，此时就需要借助于Invoke和BeginInvoke之手了。我们先来对Invoke进行介绍。

Invoke是控件Control的成员方法，函数有两个重载版本：

Invoke(Delegate) 在拥有此控件的基础窗口句柄的线程上执行指定的委托。
Invoke(Delegate, object[]) 在拥有控件的基础窗口句柄的线程上，用指定的参数列表执行指定委托。

第一个版本用于Invoke不带参数的委托，第二个版本用于Invoke带参数的委托，没有实质的区别。

Invoke 的作用MSDN上描述得有些晦涩，我会尝试用简单点的语言来进行表述。Invoke的作用是，将一个Delegate代表的函数（Delegate可以理解为函数指针）移交到控件所在线程中执行，且这个操作是同步操作，在Delegate代表的函数执行完毕后，Invoke函数才会返回。


当我们需要在其他线程总对一个控件进行操作时，可以如下操作

C# code

delegate void Delegate0();  

// 假设form是 FuncOnControl函数要使用到的form  

C# code

public this Form1 form;  

private void FuncOnControl()  

{  

      Control ctrl  = (Control)this.form;  

      if (ctrl.InvokeRequired)  

      {  

            Delegate0 d = new Delegate0(FuncOnControl);  

            ctrl.Invoke(d);  

            return;  

      }  
      // 真正的 FuncOnControl 应当进行的操作  

} 

上面代码中用到 Control.InvokeRequired这个属性，这个属性表示如果要对Control进行操作，是否需要使用到Invoke来进行线程切换。这个属性的判断依据即当前线程和创建Control的线程是否是同一个线程。

在执行了Invoke以后，不要忘记了return，因为整个函数将会在另外一个线程中被运行，如果没有return，则函数的本次调用会继续下去，导致函数被运行两次，且仍然在当前线程中访问Control。

Invoke 是如何将函数送到其他线程去执行的呢？这里我首先想到的是消息循环，向创建Control的线程发送一个消息，在消息处理函数中调用Delegate代表的函数，这样是肯定可以实现线程切换的。

我们可以编写一个程序来验证Invoke是否真的是使用消息循环机制实现，这个程序将分析控件所在线程收到的消息，验证在Invoke调用的时候，该线程是否收到了可疑的消息。

首先创建一个C#的windows application。

我需要一个跟消息循环相关的类，以发送，接收消息，于是我创建一个类，名为WinApi.cs，其源码如下：

C# code

using System;  

using System.Collections.Generic;  

using System.Text;  

using System.Runtime.InteropServices;  

   

namespace Test  

{  

    [StructLayout(LayoutKind.Sequential)]  

    public struct POINT  

    {  

        public int x;  

        public int y;  

    }  

   

    [StructLayout(LayoutKind.Sequential)]  

    public struct MSG  

    {  

        public IntPtr hwnd;  

        public uint message;  

        public uint wParam;  

        public uint lParam;  

        public uint time;  

        public POINT pt;  

    }  

   

    public class WinApi  

    {  

        [DllImport("user32.dll")]  

        public static extern void PostMessage(IntPtr hWnd, int msg, IntPtr wParam, IntPtr lParam);  

   

        [DllImport("user32.dll")]  

        public static extern bool GetMessage(ref MSG msg, IntPtr hWnd, int min, int max);  

   

        [DllImport("user32.dll")]  

        public static extern void TranslateMessage(ref MSG msg);  

   

        [DllImport("user32.dll")]  

        public static extern void DispatchMessage(ref MSG msg);  

    }  

} 

上面几个函数的功能我在 Windows消息机制里都已经讲过了，在这里我只做简要说明，如果有什么疑问，请参考那一篇文章。

MSG 是Windows消息机制中最重要的一个结构体，表示一个消息。
PostMessage 函数向某一个窗口发送一个指定的消息。
GetMessage 从消息队列中获取消息，其参数hWnd表示要获取发送给哪一个窗口的消息，如果为NULL，则表示所有消息。
TranslateMessage 将消息进行翻译，主要是处理键盘输入相关的东西。
DispatchMessage 对消息进行分发，根据消息的hWnd调用不同的窗口过程。

有了准备工作以后，我需要两个Windows窗口，暂且命名为Form1和Form2。其中Form1为主窗体，Form2为第二个窗体，这个Form2需要在第二个线程中运行，以便我可以点击Form2的按钮，然后调用Form1的Invoke函数，实现线程的切换。看起来有点复杂？ 那就一步一步来做吧。

在创建工程的时候，IDE会自动为我们创建一个Form1，那么我们现在先添加一个From，使用其默认的名称Form2。在Form2里添加一个Form1类型的public成员，如下：

查看源代码打印帮助public Form1 form1 = null; 

我们还需要一个函数，用来Invoke：

C# code

void Func(object sender, EventArgs arg)  

{  

    int id = System.Threading.Thread.CurrentThread.ManagedThreadId;  

    MessageBox.Show("Function Thread:" + id);  

} 

再给Form2添加一个按钮，以执行Invoke操作：

C# code

private void BtnInvoke_Click(object sender, EventArgs e)  

{  

    MessageBox.Show("Invoker Thread:" + System.Threading.Thread.CurrentThread.ManagedThreadId);  

    EventHandler d = new EventHandler(Func);  

   

    Control ctrl = (Control)this.form1;  

    ctrl.Invoke(d);  

} 

Form2已经就绪了，下面给Form1增加一个按钮，以启动Form2，这个按钮的响应代码为：

C# code

private void button1_Click(object sender, EventArgs e)  

{  

    Thread t = new Thread(new ThreadStart(this.ThreadFunc));  

    t.Start();  

} 

当然，不要忘记了 ThreadFunc 的定义，以及在文件头部加上对 System.Thread 名字空间的引入

C# code

private void ThreadFunc()  

{  

    Form2 form2 = new Form2();  

    form2.form1 = this;  

    form2.ShowDialog();  

} 

还记得么？在中提到的， ShowDialog 会让form2正常运行起来。

想想看，Form2有了，可以Invoke了，Form1中也增加了启动Form2的接口了，那么我们下面该验证Invoke是否是向Form1所在线程发了消息了。我们可以直接重载Form1的WndProc以截获消息，但又考虑到消息可能是直接发送到线程中去了，hWnd并不是Form1的句柄，因此我们要做得更绝一点：启动一个新的消息循环！

给Form1添加一个按钮，在其响应代码中输入如下代码：

C# code

private void BtnStartMsgLoop_Click(object sender, EventArgs e)  

{  

    MSG msg = new MSG();  

    while (WinApi.GetMessage(ref msg, IntPtr.Zero, 0, 0))  

    {  

        MessageBox.show("msg recved:" + msg.message);  

   

        WinApi.TranslateMessage(ref msg);  

        WinApi.DispatchMessage(ref msg);  

    }  

} 

我们点击这个按钮以后，消息循环就被我们改变了，是不是很神奇？ 我们可以把所有的消息都用MessageBox弹出来查看，看看Invoke是不是用到了消息。但实际上这段代码一运行，我们就会发现这实在是一个很烂的点子，运行过程中Form1接收到了太多的无关消息了，要是能过滤这些无关消息就好了。可以做到么？ 可以！

给Form1添加一个成员：

C# code

public List<int> MsgList = new List<int>();

 

MsgList将保存所有的与Invoke无关的可能出现的消息，下面我们将需要向MsgList中填入数据。

添加一个按钮，响应代码如下：

C# code

private void BtnInitMsgList_Click(object sender, EventArgs e)  

{  

    MSG msg = new MSG();  

    while (WinApi.GetMessage(ref msg, IntPtr.Zero, 0, 0))  

    {  

        if (MsgList.Contains((int)msg.message) == false)  

        {  

            MsgList.Add((int)msg.message);  

        }  

   

        // exit message loop  

        if (msg.message == 110100)  

        {  

            break;  

        }  

   

        if (msg.hwnd == IntPtr.Zero)  

        {  

             //MessageBox.Show("Msg Recved:" + msg.message);  

             uint message = msg.message;  

              continue;  

        }  

   

                WinApi.TranslateMessage(ref msg);  

                WinApi.DispatchMessage(ref msg);  

    }  

} 

没错，我们又建立了一个消息循环，不过这个消息循环是可以退出的，当接收到的消息为110100时，这个消息循环就会退出，返回到系统的主消息循环中。

好吧，我么又得需要一个按钮了，这个按钮用于退出这个消息循环：

C# code

private void EndInitMsgList_Click(object sender, EventArgs e)  

{  

    WinApi.PostMessage(this.Handle, 110100, IntPtr.Zero, IntPtr.Zero);  

} 

既然有了MsgList，那么BtnStartMsgLoop_Click函数也该做相应修改了：

C# code

private void BtnStartMsgLoop_Click(object sender, EventArgs e)  

{  

    MSG msg = new MSG();  

    while (WinApi.GetMessage(ref msg, IntPtr.Zero, 0, 0))  

    {  

        if (MsgList.Contains((int)msg.message) == false)  

        {  

            uint m = msg.message;  

        }  

   

        WinApi.TranslateMessage(ref msg);  

        WinApi.DispatchMessage(ref msg);  

    }  

} 

我把之前的MessageBox.Show替换成了 uint m = msg.message; 这是有原因的，还记得么？ 模态对话框会构建自己的消息循环，我不大想让自己好不容易夺取来的消息循环控制权又转让给了MessageBox，所以我尽量不去使用它，我宁愿在这里加一个断点来进行调试。所以，请本文的读者在 uint m = msg.message 处加设一个断点吧。

是不是有点头晕了？ 下面我来整理下这些Form以及其上的按钮：
Form1:
BtnOpenForm2 : 在一个线程中启动form2
BtnInitMsgList : 启动初始化MsgList的消息循环，将所有出现的消息记录在MsgList中
BtnEndInitMsgList : 给自身发送1101，结束初始化MsgList的过程
BtnStartMsgLoop : 启动消息循环，并对消息进行检测。记住，别忘了在 uint m = msg.message 处加一个断点

Form2:
这个就简单了，只有一个调用Invoke的按键

现在开始测试：
Step 1： 启动调试，会弹出Form1
Step 2： 在Form1 上点击BtnInitMsgList，第大概3秒钟，在这个过程中移动Form1的界面，最大最小化Form1，尽量让消息都被保存到MsgList中。
Step 3： 在Form1 上点击BtnEndInitMsgList，等大概1秒钟
Step 4： 在Form1 上点击BtnOpenForm2，则Form2 启动
Step 5： 在Form1 上点击BtnStartMsgLoop，将消息循环转移到自己的控制下
Step 6： 点击Form2 上的Invoke按钮，调用Form1.Invoke

我们可以很明显地看到，Form2 调用Invoke以后，我们在Form1中设置的断点立马有反应了，跟踪调试，就会发现DispatchMessage的下一行就是Form2中的Func。

在这个程序的基础上，大家可以任意发挥，做自己想做的测试，但我从这个测试里，只得出结论，Invoke实际上是利用消息循环来实现的，但我并不知道Invoke向消息循环中发出了什么参数，实际上 lParam和wParam都是0。如果你得出的lParam和wParam不是0，那么很抱歉，可能那个消息并不是我们需要截获的那一个，你需要MsgList保存更多的无关消息。

我不知道Invoke的参数，也就是要执行的函数和它的参数，是如何传递的，如果有谁知道的话，希望能过告诉我，我的联系方式是 [e-mail] ^_^

到这里，Invoke可以告一段落，下面该是BeginInvoke了。BeginInvoke实现的功能和Invoke一样，都是实现线程切换，只是不同的是，BeginInvoke 抛送消息后，立即返回，而不会阻塞等待执行结束，也就是说，这是一个异步的操作，其原型为：

C# code

public IAsyncResult BeginInvoke(  

    Delegate method  

)  

   

public IAsyncResult BeginInvoke(  

    Delegate method,  

    Object[] args  

) 

一切都跟Invoke的一样，区别就是Invoke返回是object，即Invoke所调用的函数的返回值，而BeginInvoke返回的是 IAsyncResult。

IAsyncResult 实际上相当于一个证明，证明你调用了这个BeginInvoke，你如果想知道调用的结果，就可以调用EndInvoke来获取：

C# code

public Object EndInvoke(  

    IAsyncResult asyncResult  

) 

EndInvoke通常和BeginInvoke配合使用，以获取BeginInvoke调用的函数的返回值，如果调用EndInvoke时，操作尚未完成，则EndInvoke就会一直等待。

这就好比说是你要出门履行，将行礼托运，托运的时候对方会给你开一个托运的单子，等你到了目的地，想取回行李的时候，你就可以拿出这个单子，找托运方换回你的行李，当然，如果行李还在路上，那么不好意思，你得老老实实在那等着了，直到行李来了，你交回单据，才能离开。

BeginInvoke与Invoke相比，更加类似于PostMessage，我们同样可以使用上面的测试方法，来对BeginInvoke的实现原理进行测试，所得出的结论也是一样的： 我们的确收到了消息，但我们却无法分析出更多的实现细节。