Detailed explanation of the difference between C# Invoke and BeginInvoke

Is the BeginInvoke method really opening a new thread for asynchronous calls?

Refer to the following code:

public delegate void treeinvoke();private void UpdateTreeView()
{
MessageBox.Show(System.Threading.Thread.CurrentThread.Name);
}private void button1_Click(object sender, System.EventArgs e)
{
System.Threading.Thread.CurrentThread.Name = "UIThread";
treeView1.BeginInvoke(new treeinvoke(UpdateTreeView)) ;
}

Look at the running results. The pop-up dialog box shows UIThread, which shows that the delegate called by BeginInvoke is basically executed in the UI thread.

Since it is executed in the UI thread, where is the term "asynchronous execution"?

Let’s take a look at the following code:

public delegate void treeinvoke();private void UpdateTreeView()
{
MessageBox.Show(Thread.CurrentThread.Name);
}private void button1_Click(object sender, System.EventArgs e)
{
Thread.CurrentThread.Name = "UIThread";
Thread th = new Thread(new ThreadStart(StartThread));
th.Start();
}private void StartThread()
{
Thread.CurrentThread.Name = "Work Thread";
treeView1.BeginInvoke(new treeinvoke(UpdateTreeView));
}

Look at the running results again. The pop-up dialog box still displays UIThread. What does this mean? This shows that the delegate called by the BeginInvoke method is executed in the UI thread anyway.

So what is the use of BeginInvoke?

In multi-threaded programming, we often have to update the interface display in the working thread, and it is wrong to directly call the interface control in multi-threads. The specific reasons can be found in my article After the article, read this article: How to call Winform in multi-threads. If you are an expert, don’t read my article. Just read that article. Anyway, I didn’t understand that article very well.

Invoke and BeginInvoke appear to solve this problem, allowing you to safely update the interface display in multi-threads.

The correct approach is to encapsulate the code involved in updating the interface in the worker thread into a method, and call it through Invoke or BeginInvoke. The difference between the two is that one causes the worker thread to wait, while the other does not.

The so-called "while responding to the operation and adding nodes at the same time" can only be relative, so that the burden on the UI thread will not be too great, because the correct update of the interface must always be done through the UI thread. What we have to do is to take over most of the calculations in the worker thread, and put pure interface updates into the UI thread, thus achieving the purpose of reducing the burden on the UI thread.

In the code that updates the tree node, the only code that actually works is: System.Threading.Thread.Sleep(100);, which gives the UI thread an opportunity to process interface messages. In fact, Digital Ghost complicates the problem, as long as the following code will work well.

private void button1_Click_(object sender, System.EventArgs e)
{
TreeNode tn; for(int i=0;i<100000;i++)
{
tn= new TreeNode (i.ToString()); this.treeView1.Nodes[0].Nodes.Add(tn); if (i%100 == 0) Application.DoEvents();
}
}

The above is the detailed content of Detailed explanation of the difference between C# Invoke and BeginInvoke. For more information, please follow other related articles on the PHP Chinese website!