Invoke and BeginInvoke BeginInvoke和EndInvoke方法 (转)

时间:2021-11-24 04:12:41

标题: Invoke and BeginInvoke BeginInvokeEndInvoke方法 (转)
-脚印 2009-12-16 17:30阅读:161
- 评论:0 |添加评论 |返回

三篇文章分别转自:

http://www.cnblogs.com/renhaojie/archive/2009/09/10/1564052.html

http://www.cnblogs.com/worldreason/archive/2008/06/09/1216127.html

http://www.cnblogs.com/c2303191/articles/826571.html

看完三篇文章,受益匪浅, 

 

 

BeginInvokeEndInvoke方法

开发语言:C#3.0

IDEVisual Studio 2008

本系列教程主要包括如下内容:

1. BeginInvoke
EndInvoke方法

2. Thread

3. 线程池

4. 线程同步基础

5. 死锁

6. 线程同步的7种方法

7. 如何在线程中访问GUI组件

一、线程概述

在操作系统中一个进程至少要包含一个线程,然后,在某些时候需要在同一个进程中同时执行多项任务,或是为了提供程序的性能,将要执行的任务分解成多个子任务执行。这就需要在同一个进程中开启多个线程。我们使用C#编写一个应用程序(控制台或桌面程序都可以),然后运行这个程序,并打开windows任务管理器,这时我们就会看到这个应用程序中所含有的线程数,如下图所示。

如果任务管理器没有线程数列,可以【查看】>【选择列】来显示线程计数列。从上图可以看出,几乎所有的进程都拥有两个以上的线程。从而可以看出,线程是提供应用程序性能的重要手段之一,尤其在多核CPU的机器上尤为明显。

二、用委托(Delegate)BeginInvokeEndInvoke方法操作线程

C#中使用线程的方法很多,使用委托的BeginInvokeEndInvoke方法就是其中之一。BeginInvoke方法可以使用线程异步地执行委托所指向的方法。然后通过EndInvoke方法获得方法的返回值(EndInvoke方法的返回值就是被调用方法的返回值),或是确定方法已经被成功调用。我们可以通过四种方法从EndInvoke方法来获得返回值。

三、直接使用EndInvoke方法来获得返回值

    当使用BeginInvoke异步调用方法时,如果方法未执行完,EndInvoke方法就会一直阻塞,直到被调用的方法执行完毕。如下面的代码所示:

 System;
 System.Collections.Generic;
 System.Linq;
 System.Text;
 System.Threading;

 MyThread
{
    
 Program
     {
        
   newTask( ms)
         {
             Console.WriteLine(
<FONT style="FONT-SIZE: 10pt" color="maroon" face=""">"任务开始<FONT style="FONT-SIZE: 10pt" color="maroon" face=""">"newint10000"任务完成<FONT style="FONT-SIZE: 10pt" color="maroon" face=""">"returnprivatedelegateintintstaticvoidstring2000nullnull            // EndInvoke方法将被阻塞
int

 

    在运行上面的程序后,由于newTask方法通过Sleep延迟了2秒,因此,程序直到2秒后才输出最终结果(一个随机整数)。如果不调用EndInvoke方法,程序会立即退出,这是由于使用BeginInvoke创建的线程都是后台线程,这种线程一但所有的前台线程都退出后(其中主线程就是一个前台线程),不管后台线程是否执行完毕,都会结束线程,并退出程序。关于前台和后台线程的详细内容,将在后面的部分讲解。

    读者可以使用上面的程序做以下实验。首先在Main方法的开始部分加入如下代码:

Thread.Sleep(10000);

    以使Main方法延迟10秒钟再执行下面的代码,然后按Ctrl+F5运行程序,并打开企业管理器,观察当前程序的线程数,假设线程数是4,在10秒后,线程数会增至5,这是因为调用BeginInvoke方法时会建立一个线程来异步执行newTask方法,因此,线程会增加一个。

四、使用IAsyncResult asyncResult属性来判断异步调用是否完成

    虽然上面的方法可以很好地实现异步调用,但是当调用EndInvoke方法获得调用结果时,整个程序就象死了一样,这样做用户的感觉并不会太好,因此,我们可以使用asyncResult来判断异步调用是否完成,并显示一些提示信息。这样做可以增加用户体验。代码如下:

  Main([] args)
{
    NewTaskDelegate task = newTask;
     IAsyncResult asyncResult = task.BeginInvoke(
);

    
 (!asyncResult.IsCompleted)
    {
        Console.Write(
);
        Thread.Sleep(
);
    }
    
EndInvoke会立刻返回结果    int


    上面代码的执行结果如下图所示。

    由于是异步,所以“*”可能会在任务开始前输出,如上图所示。


五、使用WaitOne方法等待异步方法执行完成

    使用WaitOne方法是另外一种判断异步调用是否完成的方法。代码如下:

  Main([] args)
{
     NewTaskDelegate task = newTask;
     IAsyncResult asyncResult = task.BeginInvoke(
);

    
 (!asyncResult.AsyncWaitHandle.WaitOne())
     {
          Console.Write(
);              
     }

    
 result = task.EndInvoke(asyncResult);
     Console.WriteLine(result);
}
privatedelegateintprivateint10000return100privatevoidifnullreturnasprivatevoidobject

 

    要注意的是,这里使用了BeginInvoke方法的最后两个参数(如果被调用的方法含有参数的话,这些参数将作为BeginInvoke的前面一部分参数,如果没有参数,BeginInvoke就只有两个参数了)。第一个参数是回调方法委托类型,这个委托只有一个参数,就是IAsyncResult,MethodCompleted方法所示。当method方法执行完后,系统会自动调用MethodCompleted方法。BeginInvoke的第二个参数需要向MethodCompleted方法中传递一些值,一般可以传递被调用方法的委托,如上面代码中的my。这个值可以使用IAsyncResult.AsyncState属性获得。

    由于上面的代码通过异步的方式访问的form上的一个textbox,因此,需要按ctrl+f5运行程序(不能直接按F5运行程序,否则无法在其他线程中访问这个textbox,关于如果在其他线程中访问GUI组件,并在后面的部分详细介绍)。并在form上放一些其他的可视控件,然在点击button1后,其它的控件仍然可以使用,就象什么事都没有发生过一样,在10秒后,在textbox1中将输出100

七、其他组件的BeginXXXEndXXX方法

    在其他的.net组件中也有类似BeginInvokeEndInvoke的方法,如System.Net.HttpWebRequest类的BeginGetResponseEndGetResponse方法,下面是使用这两个方法的一个例子:

 

  requestCompleted(IAsyncResult asyncResult)
{
    
 (asyncResult == ;
     System.Net.HttpWebRequest hwr = asyncResult.AsyncState 
 System.Net.HttpWebRequest;
     System.Net.HttpWebResponse response = 
(System.Net.HttpWebResponse)hwr.EndGetResponse(asyncResult);
     System.IO.StreamReader sr = 
 
System.IO.StreamReader(response.GetResponseStream());
     textBox1.Text = sr.ReadToEnd();
}
  System.Net.HttpWebResponse RequestDelegate(System.Net.HttpWebRequest request);

  button1_Click( sender, EventArgs e)
{
     System.Net.HttpWebRequest request = 
     (System.Net.HttpWebRequest)System.Net.WebRequest.Create(
);
     IAsyncResult asyncResult =request.BeginGetResponse(requestCompleted, request);     
} 

 

 Invoke

and BeginInvoke

转载自: http://www.cnblogs.com/worldreason/archive/2008/06/09/1216127.html

 

一、为什么Control类提供了InvokeBeginInvoke机制?

关于这个问题的最主要的原因已经是dotnet程序员众所周知的,我在此费点笔墨再次记录到自己的日志,以便日后提醒一下自己。

1windows程序消息机制

Windows GUI程序是基于消息机制的,有个主线程维护着一个消息泵。这个消息泵让windows程序生生不息。

                                                  Windows GUI程序的消息循环

 

 

Windows程序有个消息队列,窗体上的所有消息是这个队列里面消息的最主要来源。这里的while循环使用了GetMessage()这个方法,这是个阻塞方法,也就是队列为空时方法就会被阻塞,从而这个while循环停止运动,这避免了一个程序把cpu无缘无故地耗尽,让其它程序难以得到响应。当然在某些需要cpu最大限度运动的程序里面就可以使用另外的方法,例如某些3d游戏或者及时战略游戏中,一般会使用PeekMessage()这个方法,它不会被windows阻塞,从而保证整个游戏的流畅和比较高的帧速。

这个主线程维护着整个窗体以及上面的子控件。当它得到一个消息,就会调用DispatchMessage方法派遣消息,这会引起对窗体上的窗口过程的调用。窗口过程里面当然是程序员提供的窗体数据更新代码和其它代码。

2dotnet里面的消息循环

public static void Main(string[] args)

{

   Form f = new Form();

   Application.Run(f);

}

Dotnet窗体程序封装了上述的while循环,这个循环就是通过Application.Run方法启动的。

3、线程外操作GUI控件的问题

如果从另外一个线程操作windows窗体上的控件,就会和主线程产生竞争,造成不可预料的结果,甚至死锁。因此windows GUI编程有一个规则,就是只能通过创建控件的线程来操作控件的数据,否则就可能产生不可预料的结果。

因此,dotnet里面,为了方便地解决这些问题,Control类实现了ISynchronizeInvoke接口,提供了InvokeBeginInvoke方法来提供让其它线程更新GUI界面控件的机制。

public interface ISynchronizeInvoke

{

        [HostProtection(SecurityAction.LinkDemand, Synchronization=true, ExternalThreading=true)]

        IAsyncResult BeginInvoke(Delegate method, object[] args);

        object EndInvoke(IAsyncResult result);

        object Invoke(Delegate method, object[] args);

        bool InvokeRequired { get; }

}

}

如果从线程外操作windows窗体控件,那么就需要使用Invoke或者BeginInvoke方法,通过一个委托把调用封送到控件所属的线程上执行。

二、消息机制---线程间和进程间通信机制

1window消息发送

Windows消息机制是windows平台上的线程或者进程间通信机制之一。Windows消息值其实就是定义的一个数据结构,最重要的是消息的类型,它就是一个整数;然后就是消息的参数。消息的参数可以表示很多东西。

Windows提供了一些api用来向一个线程的消息队列发送消息。因此,一个线程可以向另一个线程的消息队列发送消息从而告诉对方做什么,这样就完成了线程间的通信。有些api发送消息需要一个窗口句柄,这种函数可以把消息发送到指定窗口的主线程消息队列;而有些则可以直接通过线程句柄,把消息发送到该线程消息队列中。

                                                   

 

用消息机制通信

 

SendMessagewindows api,用来把一个消息发送到一个窗口的消息队列。这个方法是个阻塞方法,也就是操作系统会确保消息的确发送到目的消息队列,并且该消息被处理完毕以后,该函数才返回。返回之前,调用者将会被暂时阻塞。

PostMessage也是一个用来发送消息到窗口消息队列的api函数,但这个方法是非阻塞的。也就是它会马上返回,而不管消息是否真的发送到目的地,也就是调用者不会被阻塞。

2Invoke and BeginInvoke

 

                                                        Invoke or BeginInvoke

 

Invoke或者BeginInvoke方法都需要一个委托对象作为参数。委托类似于回调函数的地址,因此调用者通过这两个方法就可以把需要调用的函数地址封送给界面线程。这些方法里面如果包含了更改控件状态的代码,那么由于最终执行这个方法的是界面线程,从而避免了竞争条件,避免了不可预料的问题。如果其它线程直接操作界面线程所属的控件,那么将会产生竞争条件,造成不可预料的结果。

使用Invoke完成一个委托方法的封送,就类似于使用SendMessage方法来给界面线程发送消息,是一个同步方法。也就是说在Invoke封送的方法被执行完毕前,Invoke方法不会返回,从而调用者线程将被阻塞。

使用BeginInvoke方法封送一个委托方法,类似于使用PostMessage进行通信,这是一个异步方法。也就是该方法封送完毕后马上返回,不会等待委托方法的执行结束,调用者线程将不会被阻塞。但是调用者也可以使用EndInvoke方法或者其它类似WaitHandle机制等待异步操作的完成。

但是在内部实现上,InvokeBeginInvoke都是用了PostMessage方法,从而避免了SendMessage带来的问题。而Invoke方法的同步阻塞是靠WaitHandle机制来完成的。

3、使用场合问题

如果你的后台线程在更新一个UI控件的状态后不需要等待,而是要继续往下处理,那么你就应该使用BeginInvoke来进行异步处理。

如果你的后台线程需要操作UI控件,并且需要等到该操作执行完毕才能继续执行,那么你就应该使用Invoke。否则,在后台线程和主截面线程共享某些状态数据的情况下,如果不同步调用,而是各自继续执行的话,可能会造成执行序列上的问题,虽然不发生死锁,但是会出现不可预料的显示结果或者数据处理错误。

可以看到ISynchronizeInvoke有一个属性,InvokeRequired。这个属性就是用来在编程的时候确定,一个对象访问UI控件的时候是否需要使用Invoke或者BeginInvoke来进行封送。如果不需要那么就可以直接更新。在调用者对象和UI对象同属一个线程的时候这个属性返回false。在后面的代码分析中我们可以看到,Control类对这一属性的实现就是在判断调用者和控件是否属于同一个线程的。

三、Delegate.BeginInvoke

通过一个委托来进行同步方法的异步调用,也是.net提供的异步调用机制之一。但是Delegate.BeginInvoke方法是从ThreadPool取出一个线程来执行这个方法,以获得异步执行效果的。也就是说,如果采用这种方式提交多个异步委托,那么这些调用的顺序无法得到保证。而且由于是使用线程池里面的线程来完成任务,使用频繁,会对系统的性能造成影响。

Delegate.BeginInvoke也是讲一个委托方法封送到其它线程,从而通过异步机制执行一个方法。调用者线程则可以在完成封送以后去继续它的工作。但是这个方法封送到的最终执行线程是运行库从ThreadPool里面选取的一个线程。

这里需要纠正一个误区,那就是Control类上的异步调用BeginInvoke并没有开辟新的线程完成委托任务,而是让界面控件的所属线程完成委托任务的。看来异步操作就是开辟新线程的说法不一定准确。 

四、用Reflector察看一些相关代码

1Control.BeginInvoke and Control.Invoke

publicIAsyncResult BeginInvoke(Delegate method, params object[] args)

{

   using (new MultithreadSafeCallScope())

    {

       return (IAsyncResult) this.FindMarshalingControl().MarshaledInvoke(this, method, args, false);

    }

}

publicobject Invoke(Delegate method, params object[] args)

{

   using (new MultithreadSafeCallScope())

    {

       return this.FindMarshalingControl().MarshaledInvoke(this, method, args, true);

    }

}

这里的FindMarshalingControl方法通过一个循环向上回溯,从当前控件开始回溯父控件,直到找到最*的父控件,用它作为封送对象。例如,我们调用窗体上一个进度条的Invoke方法封送委托,但是实际上会回溯到主窗体,通过这个控件对象来封送委托。因为主窗体是主线程消息队列相关的,发送给主窗体的消息才能发送到界面主线程消息队列。

我们可以看到InvokeBeginInvoke方法使用了同样的实现,只是MarshaledInvoke方法的最后一个参数值不一样。

privateobject MarshaledInvoke(Control caller, Delegate method, object[] args, bool synchronous)

{

   int num;

   if (!this.IsHandleCreated)

    {

       throw new InvalidOperationException(SR.GetString("ErrorNoMarshalingThread"));

    }

   if (((ActiveXImpl) this.Properties.GetObject(PropActiveXImpl)) != null)

    {

       IntSecurity.UnmanagedCode.Demand();

    }

   bool flag = false;

   if ((SafeNativeMethods.GetWindowThreadProcessId(newHandleRef(this, this.Handle), out num) == SafeNativeMethods.GetCurrentThreadId()) && synchronous)

    {

        flag =true;

    }

   ExecutionContext executionContext =null;

   if (!flag)

    {

        executionContext =ExecutionContext.Capture();

    }

   ThreadMethodEntry entry =new ThreadMethodEntry(caller, method, args, synchronous, executionContext);

   lock (this)

    {

       if (this.threadCallbackList == null)

        {

           this.threadCallbackList = new Queue();

        }

    }

   lock (this.threadCallbackList)

    {

        if (threadCallbackMessage == 0)

        {

           threadCallbackMessage = SafeNativeMethods.RegisterWindowMessage(Application.WindowMessagesVersion + "_ThreadCallbackMessage");

        }

       this.threadCallbackList.Enqueue(entry);

    }

   if (flag)

    {

       this.InvokeMarshaledCallbacks();

    }

   else

    {           //终于找到你了,PostMessage

       UnsafeNativeMethods.PostMessage(newHandleRef(this, this.Handle),threadCallbackMessage, IntPtr.Zero,IntPtr.Zero);

    }

   if (!synchronous) //如果是异步,那么马上返回吧

    {

       return entry;

    }

   if (!entry.IsCompleted)//同步调用没结束,阻塞起来等待吧

    {

       this.WaitForWaitHandle(entry.AsyncWaitHandle);

    }

   if (entry.exception != null)

    {

       throw entry.exception;

    }

   return entry.retVal;

}

怎么样,我们终于看到PostMessage了吧?通过windows消息机制实现了封送。而需要封送的委托方法作为消息的参数进行了传递。关于其它的代码这里不作进一步解释。

3InvokeRequired

publicbool InvokeRequired

{

   get

    {

       using (new MultithreadSafeCallScope())

        {

           HandleRef ref2;

           int num;

           if (this.IsHandleCreated)

            {

                ref2 =new HandleRef(this, this.Handle);

            }

           else

            {

               Control wrapper = this.FindMarshalingControl();

               if (!wrapper.IsHandleCreated)

                {

                   return false;

                }

                ref2 =new HandleRef(wrapper, wrapper.Handle);

            }

           int windowThreadProcessId =SafeNativeMethods.GetWindowThreadProcessId(ref2,out num);

           int currentThreadId = SafeNativeMethods.GetCurrentThreadId();

           return (windowThreadProcessId != currentThreadId);

        }

    }

}

终于看到了,这是在判断windows窗体线程和当前的调用者线程是否是同一个,如果是同一个就没有必要封送了,直接访问这个GUI控件吧。否则,就不要那么直接表白了,就需要Invoke或者BeginInvoke做媒了。

 

 

 近日,被ControlInvokeBeginInvoke搞的头大,就查了些相关的资料,整理如下。感谢这篇文章对我的理解InvokeBeginInvoke的真正含义 
(
一)ControlInvokeBeginInvoke
我们要基于以下认识:
1ControlInvokeBeginInvokeDelegateInvokeBeginInvoke是不同的。
2ControlInvokeBeginInvoke的参数为delegate,委托的方法是在Control的线程上执行的,也就是我们平时所说的UI线程。

我们以代码()来看(ControlInvoke)
private delegate void InvokeDelegate();
private void InvokeMethod(){
   //C
代码段
}
private void butInvoke_Click(object sender, EventArgs e) {
   //A
代码段.......
   this.Invoke(new InvokeDelegate(InvokeMethod));
   //B
代码段......
}
你觉得代码的执行顺序是什么呢?记好ControlInvokeBeginInvoke都执行在主线程即UI线程上
A------>C---------------->B
解释:(1)AUI线程上执行完后,开始InvokeInvoke是同步
(2)
代码段B并不执行,而是立即在UI线程上执行InvokeMethod方法,即代码段C
(3)InvokeMethod
方法执行完后,代码段C才在UI线程上继续执行。

看看代码()ControlBeginInvoke
private delegate void BeginInvokeDelegate();
private void BeginInvokeMethod(){
   //C
代码段
}
private void butBeginInvoke_Click(object sender, EventArgs e) {
   //A
代码段.......
   this.BeginInvoke(new BeginInvokeDelegate(BeginInvokeMethod));
   //B
代码段......
}

你觉得代码的执行顺序是什么呢?记好ControlInvokeBeginInvoke都执行在主线程即UI线程上
A----------->B--------------->C
慎重,这个只做参考。。。。。,我也不肯定执行顺序,如果有哪位达人知道的话请告知。
解释::(1)AUI线程上执行完后,开始BeginInvokeBeginInvoke是异步
(2)InvokeMethod
方法,即代码段C不会执行,而是立即在UI线程上执行代码段B
(3)
代码段B执行完后(就是说butBeginInvoke_Click方法执行完后)InvokeMethod方法,即代码段C才在UI线程上继续执行。

由此,我们知道:
Control
InvokeBeginInvoke的委托方法是在主线程,即UI线程上执行的。也就是说如果你的委托方法用来取花费时间长的数据,然后更新界面什么的,千万别在UI线程上调用Control.InvokeControl.BeginInvoke,因为这些是依然阻塞UI线程的,造成界面的假死。

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

异步是指相对于调用BeginInvoke的线程异步,而不是相对于UI线程异步,你在UI线程上调用BeginInvoke,当然不行了。----摘自"InvokeBeginInvoke的真正涵义"一文中的评论。
BeginInvoke
的原理是将调用的方法Marshal成消息,然后调用Win32 API中的RegisterWindowMessage()UI窗口发送消息。----摘自"InvokeBeginInvoke的真正涵义"一文中的评论。

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

代码()  Thread调用ControlInvoke
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
代码段......
}

你觉得代码的执行顺序是什么呢?记好ControlInvokeBeginInvoke都执行在主线程即UI线程上
A------>(Start
一开始BStartMethodC就同时执行)---->(C执行完了,不管B有没有执行完,invokeThread把消息封送(invoke)UI线程,然后自己等待)---->UI线程处理完butInvoke_Click消息后,处理invokeThread封送过来的消息,执行invokeMethod方法,即代码段E,处理往后UI线程切换到invokeThread线程。
这个Control.Invoke是相对于invokeThread线程同步的,阻止了其运行。

解释:
1
UI执行A
2
UI开线程InvokeThreadBC同时执行,B执行在线程UI上,C执行在线程invokeThread上。
3
invokeThread封送消息给UI,然后自己等待,UI处理完消息后,处理invokeThread封送的消息,即代码段E
4
UI执行完E后,转到线程invokeThread上,invokeThread线程执行代码段D

代码()  Thread调用ControlBeginInvoke
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
代码段......
}
你觉得代码的执行顺序是什么呢?记好ControlInvokeBeginInvoke都执行在主线程即UI线程上
A
UI线程上执行----->beginInvokeThread线程开始执行,UI继续执行代码段B,并发地invokeThread执行代码段C-------------->不管UI有没有执行完代码段B,这时beginInvokeThread线程把消息封送给UI,单自己并不等待,继续向下执行-------->UI处理完butBeginInvoke_Click消息后,处理beginInvokeThread线程封送过来的消息。


解释:
1
UI执行A
2
UI开线程beginInvokeThreadBC同时执行,B执行在线程UI上,C执行在线程beginInvokeThread上。
3
beginInvokeThread封送消息给UI,然后自己继续执行代码DUI处理完消息后,处理invokeThread封送的消息,即代码段E
有点疑问:如果UI先执行完毕,是不是有可能过了段时间beginInvokeThread才把消息封送给UI,然后UI才继续执行封送的消息E。如图浅绿的部分。


Control
BeginInvoke是相对于调用它的线程,即beginInvokeThread相对是异步的。
因此,我们可以想到。如果要异步取耗费长时间的数据,比如从数据库中读大量数据,我们应该这么做。
(1)
如果你想阻止调用线程,那么调用代码(),代码段D删掉,C改为耗费长时间的操作,因为这个操作是在另外一个线程中做的。代码段E改为更新界面的方法。
(2)
如果你不想阻止调用线程,那么调用代码(),代码段D删掉,C改为耗费长时间的操作,因为这个操作是在另外一个线程中做的。代码段E改为更新界面的方法。

相关知识:1Invoke BeginInvoke的真正涵义

ControlInvokeBeginInvoke是相对于支线线程(因为一般在支线线程中调用,用来更新主线程uiInvoke立即插入主线程中执行,而BeginInvoke要等主线程结束才执行 

 

 

 


添加评论
返回顶部 |返回首页
上一篇:sql server系统表详细说明(转)
下一篇:event.keycode大全(javascript)
完整模式(
显示图片和代码)
查看原文