參考以下程式碼：

1. public delegate void treeinvoke();
2. privatevoidUpdateTreeView()
3. {
4.          MessageBox.Show(System.Threading.Thread.CurrentThread.Name);
5. }
6. privatevoid button1_Click(object sender,System.EventArgs e)
7. {
8.           System.Threading.Thread.CurrentThread.Name=“UIThread”;
9.           treeView1.BeginInvoke
   (new treeinvoke(UpdateTreeView));
10. }

看看執行結果，彈出的對話方塊中顯示的是 UIThread，這說明 BeginInvoke 所呼叫的委託根本就是在 UI 執行緒中執行的。

既然是在 UI 執行緒中執行，又何來“非同步執行”一說呢？

我們再看看下面的程式碼：

1. public delegate void treeinvoke();
2. privatevoidUpdateTreeView()
3. {
4. MessageBox.Show(Thread.CurrentThread.Name);
5. }
6. privatevoid button1_Click(object sender
   ,System.EventArgs e)
7. {
8. Thread.CurrentThread.Name=“UIThread”;
9.        Thread th =newThread(newThreadStart(StartThread));
10.        th.Start();
11. }
12. privatevoidStartThread()
13. {
14.           Thread.CurrentThread.Name=“Work Thread”;
15.           treeView1.BeginInvoke(new treeinvoke(UpdateTreeView));
16. }

再看看執行結果，彈出的對話方塊中顯示的還是 UIThread，這說明什麼？這說明 BeginInvoke 方法所呼叫的委託無論如何都是在 UI 執行緒中執行的。

那 BeginInvoke 究竟有什麼用呢？

在多執行緒程式設計中，我們經常要在工作執行緒中去更新介面顯示，而在多執行緒中直接呼叫介面控制元件的方法是錯誤的做法，具體的原因可以在看完我的這篇之後看看這篇：在多執行緒中如何呼叫Winform，如果你是大牛的話就不要看我這篇了，直接看那篇吧，反正那篇文章我沒怎麼看懂。

Invoke 和 BeginInvoke 就是為了解決這個問題而出現的，使你在多執行緒中安全的更新介面顯示。

正確的做法是將工作執行緒中涉及更新介面的程式碼封裝為一個方法，通過 Invoke 或者 BeginInvoke 去呼叫，兩者的區別就是一個導致工作執行緒等待，而另外一個則不會。

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

而在那段更新樹節點的程式碼中，其實唯一起作用的程式碼是：System.Threading.Thread.Sleep(100);，它使 UI 執行緒有了處理介面訊息的機會，其實 數碼幽靈 將問題複雜化了，只要以下的程式碼就可以很好的工作了。

1. privatevoid button1_Click_(object sender,System.EventArgs e)
2. {
3.           TreeNode tn;
4.           for(int i=0;i<100000;i++)
5.           {
6.                    tn=newTreeNode(i.ToString());         
7.                   this.treeView1.Nodes[0].Nodes.Add(tn);
8. if(i%100==0)Application.DoEvents();
9.           }
10. }

近日，被Control的Invoke和BeginInvoke搞的頭大，就查了些相關的資料，整理如下。感謝這篇文章對我的理解Invoke和BeginInvoke的真正含義 。
(一）Control的Invoke和BeginInvoke
我們要基於以下認識：
（1）Control的Invoke和BeginInvoke與Delegate的Invoke和BeginInvoke是不同的。
（2）Control的Invoke和BeginInvoke的引數為delegate，委託的方法是在Control的執行緒上執行的，也就是我們平時所說的UI執行緒。

我們以程式碼(一)來看(Control的Invoke)

1. private delegate voidInvokeDelegate();
2. privatevoidInvokeMethod(){
3. //C程式碼段
4. }
5. privatevoid butInvoke_Click(object sender,EventArgs e){
6. //A程式碼段…….
7. this.Invoke(newInvokeDelegate(InvokeMethod));
8. //B程式碼段……
9. }

你覺得程式碼的執行順序是什麼呢?記好Control的Invoke和BeginInvoke都執行在主執行緒即UI執行緒上
A——>C—————->B
解釋：(1)A在UI執行緒上執行完後，開始Invoke，Invoke是同步
(2)程式碼段B並不執行，而是立即在UI執行緒上執行InvokeMethod方法，即程式碼段C。
(3)InvokeMethod方法執行完後，程式碼段C才在UI執行緒上繼續執行。

看看程式碼(二)，Control的BeginInvoke

1. private delegate voidBeginInvokeDelegate();
2. privatevoidBeginInvokeMethod(){
3. //C程式碼段
4. }
5. privatevoid butBeginInvoke_Click(object sender,EventArgs e){
6. //A程式碼段…….
7. this.BeginInvoke(newBeginInvokeDelegate(BeginInvokeMethod));
8. //B程式碼段……
9. }

你覺得程式碼的執行順序是什麼呢?記好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

1. privateThread invokeThread;
2. private delegate void invokeDelegate();
3. privatevoidStartMethod(){
4. //C程式碼段……
5. Control.Invoke(new invokeDelegate(invokeMethod));
6. //D程式碼段……
7. }
8. privatevoid invokeMethod(){
9. //E程式碼段
10. }
11. privatevoid butInvoke_Click(object sender,EventArgs e){
12. //A程式碼段…….
13. invokeThread =newThread(newThreadStart(StartMethod));
14. invokeThread.Start();
15. //B程式碼段……
16. }

你覺得程式碼的執行順序是什麼呢?記好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

1. privateThread beginInvokeThread;
2. private delegate void beginInvokeDelegate();
3. privatevoidStartMethod(){
4. //C程式碼段……
5. Control.BeginInvoke(new beginInvokeDelegate(beginInvokeMethod));
6. //D程式碼段……
7. }
8. privatevoid beginInvokeMethod(){
9. //E程式碼段
10. }
11. privatevoid butBeginInvoke_Click(object sender,EventArgs e){
12. //A程式碼段…….
13. beginInvokeThread =newThread(newThreadStart(StartMethod));
14. beginInvokeThread .Start();
15. //B程式碼段……
16. }

你覺得程式碼的執行順序是什麼呢?記好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改為更新介面的方法。