logo
搜索
我的图书馆

发文章

发文工具

其他工具

留言交流
搜索
分享

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

 simplelam 2014-11-30

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

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

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

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

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


当我们需要在其他线程总对一个控件进行操作时，可以如下操作
  1. delegate void Delegate0();    
  2. // 假设form是 FuncOnControl函数要使用到的form    

  1. public this Form1 form;    
  2.   
  3. private void FuncOnControl()    
  4.   
  5. {    
  6.       Control ctrl  = (Control)this.form;    
  7.       if (ctrl.InvokeRequired)    
  8.       {    
  9.             Delegate0 d = new Delegate0(FuncOnControl);    
  10.             ctrl.Invoke(d);    
  11.             return;    
  12.       }    
  13.       // 真正的 FuncOnControl 应当进行的操作    
  14. }   


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

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

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

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

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

我需要一个跟消息循环相关的类，以发送，接收消息，于是我创建一个类，名为WinApi.cs，其源码如下：
  1. using System;    
  2. using System.Collections.Generic;    
  3. using System.Text;    
  4. using System.Runtime.InteropServices;    
  1. namespace Test    
  2. {    
  3.     [StructLayout(LayoutKind.Sequential)]    
  4.     public struct POINT    
  5.     {    
  6.         public int x;    
  7.         public int y;    
  8.     }    
  1. [StructLayout(LayoutKind.Sequential)]    
  2. public struct MSG    
  3. {    
  4.     public IntPtr hwnd;    
  5.     public uint message;    
  6.     public uint wParam;    
  7.     public uint lParam;    
  8.     public uint time;    
  9.     public POINT pt;    
  10. }    
  11.   
  12. public class WinApi    
  13. {    
  14.     [DllImport("user32.dll")]    
  15.     public static extern void PostMessage(IntPtr hWnd, int msg, IntPtr wParam, IntPtr lParam);    
  16.   
  17.     [DllImport("user32.dll")]    
  18.     public static extern bool GetMessage(ref MSG msg, IntPtr hWnd, int min, int max);    
  19.   
  20.     [DllImport("user32.dll")]    
  21.     public static extern void TranslateMessage(ref MSG msg);    
  22.   
  23.     [DllImport("user32.dll")]    
  24.     public static extern void DispatchMessage(ref MSG msg);    
  25. }    

上面几个函数的功能我在 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：

  1. void Func(object sender, EventArgs arg)    
  2.   
  3. {    
  4.   
  5.     int id = System.Threading.Thread.CurrentThread.ManagedThreadId;    
  6.     MessageBox.Show("Function Thread:" + id);    
  7.   
  8. }   



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

  1. private void BtnInvoke_Click(object sender, EventArgs e)    
  2.   
  3. {    
  4.   
  5.     MessageBox.Show("Invoker Thread:" + System.Threading.Thread.CurrentThread.ManagedThreadId);    
  6.     EventHandler d = new EventHandler(Func);    
  7.     Control ctrl = (Control)this.form1;    
  8.     ctrl.Invoke(d);    
  9.   
  10. }   


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

  1. private void button1_Click(object sender, EventArgs e)    
  2.   
  3. {    
  4.     Thread t = new Thread(new ThreadStart(this.ThreadFunc));    
  5.     t.Start();    
  6. }   




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

  1. private void ThreadFunc()    
  2. {    
  3.     Form2 form2 = new Form2();    
  4.     form2.form1 = this;    
  5.     form2.ShowDialog();    
  6. }   



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

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

  1. private void BtnStartMsgLoop_Click(object sender, EventArgs e)    
  2.   
  3. {    
  4.     MSG msg = new MSG();    
  5.     while (WinApi.GetMessage(ref msg, IntPtr.Zero, 0, 0))    
  6.     {    
  7.         MessageBox.show("msg recved:" + msg.message);    
  8.         WinApi.TranslateMessage(ref msg);   
  9.         WinApi.DispatchMessage(ref msg);    
  10.     }    
  11. }   


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

给Form1添加一个成员：

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

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

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

  1. private void BtnInitMsgList_Click(object sender, EventArgs e)    
  2.   
  3. {    
  4.   
  5.     MSG msg = new MSG();    
  6.     while (WinApi.GetMessage(ref msg, IntPtr.Zero, 0, 0))    
  7.     {    
  8.         if (MsgList.Contains((int)msg.message) == false)    
  9.         {    
  10.             MsgList.Add((int)msg.message);    
  11.         }  
  1. // exit message loop    
  2. if (msg.message == 110100)    
  3. {    
  4.     break;    
  5. }    
  1. if (msg.hwnd == IntPtr.Zero)    
  2. {    
  3.      //MessageBox.Show("Msg Recved:" + msg.message);    
  4.      uint message = msg.message;    
  5.      continue;    
  6. }    
  1.     WinApi.TranslateMessage(ref msg);    
  2.     WinApi.DispatchMessage(ref msg);    
  3. }    



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

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

  1. private void EndInitMsgList_Click(object sender, EventArgs e)    
  2.   
  3. {    
  4.     WinApi.PostMessage(this.Handle, 110100, IntPtr.Zero, IntPtr.Zero);    
  5. }   




既然有了MsgList，那么BtnStartMsgLoop_Click函数也该做相应修改了：
  1. private void BtnStartMsgLoop_Click(object sender, EventArgs e)    
  2.   
  3. {    
  4.   
  5.     MSG msg = new MSG();    
  6.     while (WinApi.GetMessage(ref msg, IntPtr.Zero, 0, 0))    
  7.     {    
  8.         if (MsgList.Contains((int)msg.message) == false)    
  9.         {    
  10.             uint m = msg.message;    
  11.         }    
  12.         WinApi.TranslateMessage(ref msg);    
  13.         WinApi.DispatchMessage(ref msg);    
  14.     }    
  15.   
  16. }   



我把之前的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的参数，也就是要执行的函数和它的参数，是如何传递的，如果有谁知道的话，
希望能过告诉我，我的联系方式是 wddpxqq@163.com ^_^

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

  1. public IAsyncResult BeginInvoke(Delegate method)   
  1.   
  1. public IAsyncResult BeginInvoke(    
  2.     Delegate method,    
  3.     Object[] args    
  4. )   

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

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

  1. public Object EndInvoke( IAsyncResult asyncResult )   

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

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

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

    本站是提供个人知识管理的网络存储空间，所有内容均由用户发布，不代表本站观点。请注意甄别内容中的联系方式、诱导购买等信息，谨防诈骗。如发现有害或侵权内容，请点击一键举报。
    转藏 分享 献花（0）

    来自： simplelam > 《C#》

    举报/认领

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多