(一）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返回。