Control的Invoke和BeginInvoke详解

(一）Control的Invoke和BeginInvoke
我们要基于以下认识：
（1）Control的Invoke和BeginInvoke与Delegate的Invoke和BeginInvoke是不同的。
（2）Control的Invoke和BeginInvoke的参数为delegate，委托的方法是在Control的线程上执行的，也就是我们平时所说的UI线程。

先看一下主线程中调用Invoke和BeginInvoke


我们以代码(一)来看(Control的Invoke)：

private delegate void InvokeDelegate();
private void InvokeMethod(){
   //C代码段
}
private void butInvoke_Click(object sender, EventArgs e) {
   //A代码段.......
   this.Invoke(new InvokeDelegate(InvokeMethod));
   //B代码段......
}

你觉得代码的执行顺序是什么呢?记好Control的Invoke和BeginInvoke都执行在主线程即UI线程上
A---------------->C---------------->B

解释：

(1)A在UI线程上执行完后，开始Invoke，Invoke是同步

(2)代码段B并不执行，而是立即在UI线程上执行InvokeMethod方法，即代码段C。

(3)InvokeMethod方法执行完后，代码段B才在UI线程上继续执行。


小结：当在UI线程中执行Invoke时，其实就是函数的直接调用，没什么区别。

private delegate void invokeDelegate();

private void button1_Click(object sender, EventArgs e)
{
    Thread.CurrentThread.Name = "Main";
    listBox1.Items.Add("--begin--");

    Thread.Sleep(5000);
    this.BeginInvoke(new invokeDelegate(invokeMethod));
    listBox1.Items.Add("--end--");
    workOnUIThread();

}
private void workOnUIThread()
{
    listBox1.Items.Add("--UI--");
}

private void invokeMethod()
{
    listBox1.Items.Add("Invoke:" + Thread.CurrentThread.Name );
}

private void button2_Click(object sender, EventArgs e)
{
    listBox1.Items.Add("button2_Click");
}

具体的操作是：我在点击button1后，UI线程sleep5秒钟，在这期间界面会卡死，但是我还是点击两下button2，结果如下：

可以看出执行的顺序是先响应button1的click事件，然后invoke就像函数调用一样，顺序的执行。然后在相应button2的click事件。


看看代码(二)，Control的BeginInvoke：

private delegate void BeginInvokeDelegate();
private void BeginInvokeMethod(){
   //C代码段
}
private void butBeginInvoke_Click(object sender, EventArgs e) {
   //A代码段.......
   this.BeginInvoke(new BeginInvokeDelegate(BeginInvokeMethod));
    //这里让线程暂停一下，它同样不会执行C段代码
   Thread.Sleep(1000);
   //B代码段......
}

你觉得代码的执行顺序是什么呢?记好Control的Invoke和BeginInvoke都执行在主线程即UI线程上。

A----------->B--------------->C

解释：

(1)A在UI线程上执行完后，开始BeginInvoke，BeginInvoke是异步（这个异步在这里没有什么意义，它是相对于支线程异步的，更主线程没什么异步不异步的）
(2)InvokeMethod方法，即代码段C不会执行，而是在UI线程上执行代码段B，即使Sleep一段时间，也不会执行C代码。

(3)代码段B执行完后(就是说butBeginInvoke_Click方法执行完后，并不是什么主线程执行结束后)，InvokeMethod方法，即代码段C才在UI线程上继续执行。


小结：当在UI线程中执行BeginInvoke时，其实是往消息队列发送了一个消息，这个消息告诉UI线程要执行哪个函数。当butBeginInvoke_Click消息处理完成后，OS分配了这个BeginInvoke消息，才去执行相应的函数。

private delegate void invokeDelegate();

private void button1_Click(object sender, EventArgs e)
{
    Thread.CurrentThread.Name = "Main";
    listBox1.Items.Add("--begin--");

    this.BeginInvoke(new invokeDelegate(invokeMethod));
    Thread.Sleep(5000);
    listBox1.Items.Add("--end--");
    workOnUIThread();

}
private void workOnUIThread()
{
    listBox1.Items.Add("--UI--");
}

private void invokeMethod()
{
    listBox1.Items.Add("Invoke:" + Thread.CurrentThread.Name );
}

private void button2_Click(object sender, EventArgs e)
{
    listBox1.Items.Add("button2_Click");
}

具体的操作是：我在点击button1后，UI线程sleep5秒钟，在这期间界面会卡死，但是我还是点击两下了button2，结果如下：

可以看出执行的顺序是先响应button1的click事件，然后BeginInvoke执行，把代理函数封装成一个消息，发送的消息队列，等待OS分发消息然后执行。然后UI线程end和UI这两个输出。之后button1的click事件就响应结束了。然后响应BeginInvoke刚封装的消息，最后在相应button2的click事件。


总结：

1. 当在UI线程中执行Invoke时，其实就是函数的直接调用，没什么区别。

2. 当在UI线程中执行BeginInvoke时，其实是往消息队列发送了一个消息，这个消息告诉UI线程要执行哪个函数。当butBeginInvoke_Click消息处理完成后，OS分配了这个BeginInvoke消息，才去执行相应的函数。

还有一点，我们知道：
Control的Invoke和BeginInvoke的委托方法是在主线程，即UI线程上执行的。也就是说如果你的委托方法用来取花费时间长的数据，然后更新界面什么的，千万别在主线程或者支线程上调用Control.Invoke和Control.BeginInvoke，因为这些是依然阻塞UI线程的，造成界面的假死。

我们来看子线程中调用Invoke和BeginInvoke


那么，这个异步到底是什么意思呢?

异步是指相对于调用BeginInvoke的线程异步（一般是支线程调用），而不是相对于UI线程异步，你在UI线程上调用BeginInvoke ，当然不行了。

－－－－摘自"Invoke和BeginInvoke的真正涵义"一文中的评论。
BeginInvoke的原理是将调用的方法Marshal成消息，然后调用Win32 API中的RegisterWindowMessage()向UI窗口发送消息。
－－－－摘自"Invoke和BeginInvoke的真正涵义"一文中的评论。

立刻总结：上面的这段话是正确的，请相信。那么他的意思就是在支线程中调用Invoke和BeginInvoke，都会把代理函数封装成一个消息，放到消息队列，等待OS分发，然后响应。

(二)我们用Thread来调用BeginInvoke和Invoke
我们开一个线程，让线程执行一些耗费时间的操作，然后再用Control.Invoke和Control.BeginInvoke回到用户UI线程，执行界面更新。

代码(三)  Thread调用Control的Invoke：

private Thread invokeThread;
private delegate void invokeDelegate();
private void StartMethod(){
   //C代码段......
   Control.Invoke(new invokeDelegate(invokeMethod));
  //D代码段......
}
private void invokeMethod(){
  //E代码段
}
private void butInvoke_Click(object sender, EventArgs e) {
   //A代码段.......
   invokeThread = new Thread(new ThreadStart(StartMethod));
   invokeThread.Start();
   //B代码段......
}

你觉得代码的执行顺序是什么呢?记好Control的Invoke和BeginInvoke都执行在主线程即UI线程上
A------>(Start一开始B和StartMethod的C就同时执行)---->(C执行完了，不管B有没有执行完，invokeThread把消息封送(invoke)给UI线程，然后自己等待)---->UI线程处理完butInvoke_Click消息后，处理invokeThread封送过来的消息，执行invokeMethod方法，即代码段E，E段代码返回后支线程继续执行D段代码。

这个Control.Invoke是相对于invokeThread线程同步的，阻止了其运行。

解释：

1. UI执行A

2. UI开线程InvokeThread，B和C同时执行，B执行在线程UI上，C执行在线程invokeThread上。

3. invokeThread封送消息给UI，然后自己等待，UI处理完消息后，处理invokeThread封送的消息，即代码段E

4. UI执行完E后，转到线程invokeThread上，invokeThread线程执行代码段D

代码(四)  Thread调用Control的BeginInvoke

private Thread beginInvokeThread;
private delegate void beginInvokeDelegate();
private void StartMethod(){
   //C代码段......
   Control.BeginInvoke(new beginInvokeDelegate(beginInvokeMethod));
  //D代码段......
}
private void beginInvokeMethod(){
  //E代码段
}
private void butBeginInvoke_Click(object sender, EventArgs e) {
   //A代码段.......
   beginInvokeThread = new Thread(new ThreadStart(StartMethod));
   beginInvokeThread .Start();
   //B代码段......
}

你觉得代码的执行顺序是什么呢?记好Control的Invoke和BeginInvoke都执行在主线程即UI线程上
A在UI线程上执行----->beginInvokeThread线程开始执行，UI继续执行代码段B，并发地invokeThread执行代码段C-------------->不管UI有没有执行完代码段B，这时beginInvokeThread线程把消息封送给UI，但自己并不等待，继续向下执行-------->UI处理完butBeginInvoke_Click消息后，处理beginInvokeThread线程封送过来的消息。

解释：

1. UI执行A

2. UI开线程beginInvokeThread，B和C同时执行，B执行在线程UI上，C执行在线程beginInvokeThread上。

3. beginInvokeThread封送消息给UI，然后自己继续执行代码D，UI处理完消息后，处理invokeThread封送的消息，即代码段E。


小结：在支线程中调用Invoke和BeginInvoke，都会把代理函数封装成一个消息，放到消息队列，等待OS分发，然后响应。

private delegate void invokeDelegate();
 
public Form1()
{
    InitializeComponent();
}
 
private void button1_Click(object sender, EventArgs e)
{
    Thread.CurrentThread.Name = "Main";
    listBox1.Items.Add("--begin--");
 
    Thread threadInvoke = new Thread(ThreadInvoke);
    threadInvoke.Start();
 
    Thread.Sleep(5000);
    listBox1.Items.Add("--end--");
    workOnUIThread();
 
}
private void workOnUIThread()
{
    listBox1.Items.Add("--UI--");
}
 
private void ThreadInvoke()
{
    this.Invoke(new invokeDelegate(invokeMethod));
    //this.BeginInvoke(new invokeDelegate(invokeMethod));
}
 
private void button2_Click(object sender, EventArgs e)
{
    listBox1.Items.Add("button2_Click");
}
 
private void invokeMethod()
{
    listBox1.Items.Add("Invoke:" + Thread.CurrentThread.Name );
}

具体的操作是：我在点击button1后，UI线程sleep5秒钟，在这期间界面会卡死，但是我还是点击两下了button2，结果如下：

可以看出执行的顺序是先响应button1的click事件，然后开启子线程，紧接着UI线程sleep了，子线程继续运行，把代理函数封装成一个消息，挂到UI线程的消息队列中去。等UI线程sleep结束后，继续处理button1的click事件。完了之后，从消息队列中拿到新的消息（就是子线程封装的代理函数），根据消息中指定的代理函数，执行（这些都是UI线程干的活，子线程执行完封装消息就退出了）。处理完这个消息后，再处理button2的click消息。

注意：在子线程中不管调用Invoke或者BeginInvoke，都是封装消息，发送到UI线程的消息队列中去。那么他们的区别是什么？

Invoke会阻塞子线程。

BeginInvoke不会阻塞子线程，它和子线程是异步执行的。

测试代码：

/// <summary>
/// 线程调用Invoke
/// </summary>
private void ThreadInvoke()
{
    listBox1.Items.Add("--begin--");
    new Thread(() =>
    {
        Thread.CurrentThread.Name = "ThreadInvoke";
        string temp = "Before!";
        listBox1.Invoke(new Action(() =>
            {
                Thread.Sleep(10000);
                this.listBox1.Items.Add(temp +="Invoke!" + Thread.CurrentThread.Name);
            }));
        temp += "After!";
    }).Start();
    listBox1.Items.Add("--end--");
}

private void button1_Click(object sender, EventArgs e)
{
    Thread.CurrentThread.Name = "Main";
    ThreadInvoke();
}

private void button2_Click(object sender, EventArgs e)
{
    listBox1.Items.Add("button2_Click");
}

输出：

  • Invoke的委托在主线程中执行
  • Invoke在支线程中调用也会阻塞主线程。（当点击button1后，我试图去点击button2，却发现程序被阻塞了）
  • Invoke还会阻塞支线程。（因为输出结果中没有出现After）
/// <summary>
/// 线程调用BeginInvoke
/// </summary>
private void ThreadBeginInvoke()
{
    listBox1.Items.Add("--begin--");
    new Thread(() =>
    {
        Thread.CurrentThread.Name = "ThreadBeginInvoke";
        string temp = "Before!";
        listBox1.BeginInvoke(new Action(() =>
        {
            Thread.Sleep(10000);
            this.listBox1.Items.Add(temp += "Invoke!" + Thread.CurrentThread.Name);
        }));
        temp += "After!";
    }).Start();
    listBox1.Items.Add("--end--");
}

private void button1_Click(object sender, EventArgs e)
{
    Thread.CurrentThread.Name = "Main";
    ThreadBeginInvoke();
}

private void button2_Click(object sender, EventArgs e)
{
    listBox1.Items.Add("button2_Click");
}

输出：

  • BeginInvoke在主线程中执行。
  • BeginInvoke在支线程中调用也会阻塞主线程。
  • BeginInvoke相对于支线程是异步的。

上面的这种方法，可以很好的实现把子线程中定义的局部变量传递给UI主线程。


这部分就学习到这里，下面总结一下：

1. 在UI线程中调用Invoke，跟普通的函数调用一样一样的；在UI线程中调用BeginInvoke就是封装消息，挂到UI线程的消息队列中去。

2. 在子线程中调用Invoke和BeginInvoke都是封装消息，挂到主线程的消息队列中去。

3. 在子线程中调用Invoke和BeginInvoke的区别是，子线程会等待Invoke返回再往下继续执行，但是BeginInvoke是同子线程异步执行的，子线程不会等BeginInvoke返回。

时间： 2024-08-14 03:20:25

Control的Invoke和BeginInvoke详解的相关文章

C#中Control的Invoke和BeginInvoke是相对于支线线程

近日,被Control的Invoke和BeginInvoke搞的头大,就查了些相关的资料,整理如下. Control的Invoke和BeginInvoke 是相对于支线线程(因为一般在支线线程中调用,用来更新主线程ui)Invoke立即插入主线程中执行,而BeginInvoke 要等主线程结束才执行. (一)Control的Invoke和BeginInvoke我们要基于以下认识:(1)Control的Invoke和BeginInvoke与Delegate的Invoke和BeginInvoke是不

浅谈C#中Control的Invoke与BeginInvoke在主副线程中的执行顺序和区别

今天无意中看到有关Invoke和BeginInvoke的一些资料,不太清楚它们之间的区别.所以花了点时间研究了下. 据msdn中介绍,它们最大的区别就是BeginInvoke属于异步执行的. Control.Invoke 方法 (Delegate) :在拥有此控件的基础窗口句柄的线程上执行指定的委托. Control.BeginInvoke 方法 (Delegate) :在创建控件的基础句柄所在线程上异步执行指定委托. msdn说明: 控件上的大多数方法只能从创建控件的线程调用. 如果已经创建控

【分析】浅谈C#中Control的Invoke与BeginInvoke在主副线程中的执行顺序和区别（SamWang）

今天无意中看到有关Invoke和BeginInvoke的一些资料,不太清楚它们之间的区别.所以花了点时间研究了下. 据msdn中介绍,它们最大的区别就是BeginInvoke属于异步执行的. Control.Invoke 方法 (Delegate) :在拥有此控件的基础窗口句柄的线程上执行指定的委托. Control.BeginInvoke 方法 (Delegate) :在创建控件的基础句柄所在线程上异步执行指定委托. msdn说明: 控件上的大多数方法只能从创建控件的线程调用. 如果已经创建控

[转载]Winform中Control的Invoke与BeginInvoke方法

转自http://www.cppblog.com/baby-fly/archive/2010/04/01/111245.html 一.为什么 Control类提供了 Invoke和 BeginInvoke机制? 关于这个问题的最主要的原因已经是 dotnet程序员众所周知的,我在此费点笔墨再次记录到自己的日志,以便日后提醒一下自己. 1. windows程序消息机制 Windows GUI程序是基于消息机制的,有个主线程维护着一个消息泵.这个消息泵让 windows程序生生不息. Windows

PHP输出缓冲控制 - Output Control 函 应用详解

简介 说到输出缓冲,首先要说的是一个叫做缓冲器(buffer)的东西.举个简单的例子说明他的作用:我们在编辑一篇文档时,在我们没有保存之前,系统是不会向磁盘写入的,而是写到buffer中,当buffer写满或者执行了保存操作,才会将数据写入磁盘.对于PHP来说,每一次像 echo 这样的输出操作,同样是先写入到了 php buffer 里,在脚本执行完毕或者执行了强制输出缓存操作,数据才会在浏览器上显示. 其实对于PHP程序员来说,基本上每个脚本都涉及到了输出缓冲,只是在大多数情况下,我们都不需

进程管理之工作管理详解(job control)

进程管理之工作管理详解(job control) 1 什么是工作管理(job control) 我们知道linux是多任务多终端工作的操作系统.我们可以在多个终端进行工作,也可以在一个终端进行多个任务工作.那在一个终端同时进行多个工作任务,就称为工作管理.比如这种情况,在一个终端,你想要复制文件,同时你还想压缩打包文件,甚至你还想编辑文件,这个时候就要用到工作管理.工作管理的情况,大概是这样的.直接上图. 首先,你要明白前台,后台的概念.前台就是当前我们登陆shell操作的终端,我们与之交互,看

PHP输出缓冲控制- Output Control 函数应用详解

说到输出缓冲,首先要说的是一个叫做缓冲器(buffer)的东西.举个简单的例子说明他的作用:我们在编辑一篇文档时,在我们没有保存之前,系统 是不会向磁盘写入的,而是写到buffer中,当buffer写满或者执行了保存操作,才会将数据写入磁盘.对于PHP来说,每一次像 echo 这样的输出操作,同样是先写入到了 php buffer 里,在脚本执行完毕或者执行了强制输出缓存操作,数据才会在浏览器上显示. 其实对于PHP程序员来说,基本上每个脚本都涉及到了输出缓冲,只是在大多数情况下,我们都不需要对

Oracle ACL (Access Control List)详解

在Oracle11g中,Oracle在安全方面有了很多的改进,而在网络权限控制方面,也有一个新的概念提出来,叫做ACL(Access Control List), 这是一种细粒度的权限控制.在ACL之前,我们对于有一些程序包,例如UTL_MAIL, UTL_SMTP等这些包,你可以利用这些包连接到外部的主机,而默认情况下,这些包都是都是赋予了public角色,所以可能会导致利用这些PL/SQL程序包的恶意工具,所以Oracle提出了一个新的概念来解决这个问题,那就是ACL. 在开始展开ACL之前

C# 中的委托和事件详解

C# 中的委托和事件 文中代码在VS2005下通过,由于VS2003(.Net Framework 1.1)不支持隐式的委托变量,所以如果在一个接受委托类型的位置直接赋予方法名,在VS2003下会报错,解决办法是显式的创建一个委托类型的实例(委托变量).例如:委托类型 委托实例 = new 委托类型(方法名); 引言 委托 和 事件在 .Net Framework中的应用非常广泛,然而,较好地理解委托和事件对很多接触C#时间不长的人来说并不容易.它们就像是一道槛儿,过了这个槛的人,觉得真是太容易