在多線程編程中，我們經常要在工作線程中去更新界面顯示，而在多線程中直接調用界面控件的方法 是錯誤的做法，Invoke 和 BeginInvoke 就是為了解決這個問題而出現的，使你在多線程中安全的更新界面顯示。

正確的做法是將工作線程中涉及更新界面的代碼封裝為一個方法，通過 Invoke 或者 BeginInvoke 去調用，兩者的區別就是一個導致工作線程等待，而另外一個則不會。

而所謂的“一面響應操作，一面添加節點”永遠只能是相對的，使 UI 線程的負擔不至于太大而已，因為界面的正確更新始終要通過 UI 線程去做，我們要做的事情是在工作線程中包攬大部分的運算，而將對純粹的界面更新放到 UI 線程中去做，這樣也就達到了減輕 UI 線程負擔的目的了。

舉個簡單例子說明下使用方法,比如你在啟動一個線程,在線程的方法中想更新窗體中的一個TextBox..?

using System.Threading;?

//啟動一個線程?
Thread thread=new Thread(new ThreadStart(DoWork));?
thread.Start();?

//線程方法?
private void DoWork()?
{?
this.TextBox1.Text="我是一個文本框";?
}?

如果你像上面操作,在VS2005或2008里是會有異常的...?

正確的做法是用Invoke\BeginInvoke

using System.Threading;
namespace test
{
public partial class Form1 : Form
{
public delegate void MyInvoke(string str1,string str2);
public Form1()
{
InitializeComponent();


}
public void DoWork()
{
MyInvoke mi = new MyInvoke(UpdateForm);
this.BeginInvoke(mi, new Object[] {"我是文本框","haha"});
}
public void UpdateForm(string param1,string parm2)
{
this.textBox1.Text = param1+parm2;
}
private void button1_Click(object sender, EventArgs e)
{
Thread thread = new Thread(new ThreadStart(DoWork));
thread.Start();
}
}
}

注意代理的使用！

//

c# Invoke和BeginInvoke 區別

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

Control.Invoke 方法 (Delegate)?:在擁有此控件的基礎窗口句柄的線程上執行指定的委托。

Control.BeginInvoke 方法 (Delegate)?:在創建控件的基礎句柄所在線程上異步執行指定委托。

(一）Control的Invoke和BeginInvoke
我們要基于以下認識：
（1）Control的Invoke和BeginInvoke與Delegate的Invoke和BeginInvoke是不同的。
（2）Control的Invoke和BeginInvoke的參數為delegate，委托的方法是在Control的線程上執行的，也就是我們平時所說的UI線程。

我們以代碼(一)來看(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方法執行完后，代碼段C才在UI線程上繼續執行。

看看代碼(二)，Control的BeginInvoke
private delegate void BeginInvokeDelegate();
private void BeginInvokeMethod(){
???//C代碼段
}
private void butBeginInvoke_Click(object sender, EventArgs e) {
???//A代碼段.......
???this.BeginInvoke(new BeginInvokeDelegate(BeginInvokeMethod));
???//B代碼段......
}
你覺得代碼的執行順序是什么呢?記好Control的Invoke和BeginInvoke都執行在主線程即UI線程上
A----------->B--------------->C慎重，這個只做參考。。。。。，我也不肯定執行順序，如果有哪位達人知道的話請告知。
解釋：：(1)A在UI線程上執行完后，開始BeginInvoke，BeginInvoke是異步
(2)InvokeMethod方法，即代碼段C不會執行，而是立即在UI線程上執行代碼段B。
(3)代碼段B執行完后(就是說butBeginInvoke_Click方法執行完后)，InvokeMethod方法，即代碼段C才在UI線程上繼續執行。

由此，我們知道：
Control的Invoke和BeginInvoke的委托方法是在主線程，即UI線程上執行的。也就是說如果你的委托方法用來取花費時間長的數據，然后更新界面什么的，千萬別在UI線程上調用Control.Invoke和Control.BeginInvoke，因為這些是依然阻塞UI線程的，造成界面的假死。

那么，這個異步到底是什么意思呢?

異步是指相對于調用BeginInvoke的線程異步，而不是相對于UI線程異步，你在UI線程上調用BeginInvoke ，當然不行了。－－－－摘自"Invoke和BeginInvoke的真正涵義"一文中的評論。
BeginInvoke的原理是將調用的方法Marshal成消息，然后調用Win32 API中的RegisterWindowMessage()向UI窗口發送消息。－－－－摘自"Invoke和BeginInvoke的真正涵義"一文中的評論。

(二)我們用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，處理往后UI線程切換到invokeThread線程。
這個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
有點疑問：如果UI先執行完畢，是不是有可能過了段時間beginInvokeThread才把消息封送給UI，然后UI才繼續執行封送的消息E。如圖淺綠的部分。


Control的BeginInvoke是相對于調用它的線程，即beginInvokeThread相對是異步的。
因此，我們可以想到。如果要異步取耗費長時間的數據，比如從數據庫中讀大量數據，我們應該這么做。
(1)如果你想阻止調用線程，那么調用代碼(三)，代碼段D刪掉，C改為耗費長時間的操作，因為這個操作是在另外一個線程中做的。代碼段E改為更新界面的方法。
(2)如果你不想阻止調用線程，那么調用代碼(四)，代碼段D刪掉，C改為耗費長時間的操作，因為這個操作是在另外一個線程中做的。代碼段E改為更新界面的方法。