Go to: several issues about how threads in C # access the winform Control

Original article: http://blog.csdn.net/cy757/archive/2009/08/22/4473980.aspx

When we use winform applications, we usually encounter the problem of using the control information on the multi-threaded control interface. However, we cannot use traditional methods to solve this problem. I will introduce it in detail below.

First, let's look at the traditional method:

Code snippet

2. Public Partial Class Form1: Form
4. {
6. PublicForm1 ()
8. {
10. Initializecomponent ();
12. }
14. Private VoidForm1_load (ObjectSender, eventargs E)
16. {
18. Thread thread =NewThread (threadfuntion );
20. Thread. isbackground =True;
22. Thread. Start ();
24. }
26. Private VoidThreadfuntion ()
28. {
30. While(True)
32. {
34. This. Textbox1.text = datetime. Now. tostring ();
36. Thread. Sleep (1000 );
38. }
40. }
42. }

Run this sectionCodeThe system throws an exception: Cross-thread operation not valid: Control 'textbox1' accessed from a thread other than the thread it was created on. this is because. NET 2.0 and later enhanced the security mechanism, and does not allow direct cross-thread access to control attributes in winform. So how can we solve this problem? Several solutions are provided below.

In the first solution, we add the following code in the form1_load () method:

Code snippet

1. private void form1_load ( Object sender, eventargs e)
2. {
3. control. checkforillegalcrossthreadcils = false ;
4. thread = New thread (threadfuntion);
5. thread. isbackground = true ;
6. thread. Start ();
7. }

After this code is added, we will find thatProgramIt can run normally. This code means that in this class, we do not check whether cross-thread calls are legal (if this sentence is not added, the operation is not abnormal, it indicates that the system and the default mode are not checked ). However, this method is not advisable. We can view the definition of the checkforillegalcrossthreadcils attribute and find that it is static. That is to say, no matter where the value is modified in the project, it will take effect globally. In addition, we usually check whether cross-thread access is abnormal. If someone else in the project modifies this attribute, our solution fails and we have to adopt another solution.

The second solution is to use delegate and invoke to control information from other threads. Many people write this control method on the Internet. However, I have read many such posts and it seems that there is no problem, but it has not actually solved this problem, first, let's look at the imperfect methods on the network:

Code snippet

2. Public Partial Class Form1: Form
4. {
6. Private Delegate Void Flushclient();// Proxy
8. PublicForm1 ()
10. {
12. Initializecomponent ();
14. }
16. Private VoidForm1_load (ObjectSender, eventargs E)
18. {
20. Thread thread =NewThread (crossthreadflush );
22.  
24. Thread. isbackground =True;
26. Thread. Start ();
28. }
30.  
32. Private VoidCrossthreadflush ()
34. {
36. // Bind the proxy to the Method
38. FlushclientFc =New Flushclient(Threadfuntion );
40. This. Begininvoke (FC );// Call the proxy
42. }
44. Private VoidThreadfuntion ()
46. {
48. While(True)
50. {
52. This. Textbox1.text = datetime. Now. tostring ();
54. Thread. Sleep (1000 );
56. }
58. }
60. }

In this way, we can see that the exception of cross-thread access does not exist. However, a new problem occurs and the interface does not respond. Why does this problem occur? We just need to refresh the new thread infinitely and theoretically it will not affect the main thread. Otherwise, this method is equivalent to "injecting" The New thread into the main control thread, and it achieves the control of the main thread. As long as this thread does not return, the main thread will never respond. Even if the new thread does not use an infinite loop, it can return. The use of multithreading in this way also loses its original meaning.

Now let's take a look at the recommended solution:

Code snippet

2. Public Partial Class Form1: Form
4. {
6. Private Delegate Void Flushclient();// Proxy
8. PublicForm1 ()
10. {
12. Initializecomponent ();
14. }
16. Private VoidForm1_load (ObjectSender, eventargs E)
18. {
20. Thread thread =NewThread (crossthreadflush );
22. Thread. isbackground =True;
24. Thread. Start ();
26. }
28.  
30. Private VoidCrossthreadflush ()
32. {
34. While(True)
36. {
38. // Place sleep and infinite loop outside of waiting for Asynchronization
40. Thread. Sleep (1000 );
42. Threadfunction ();
44. }
46. }
48. Private VoidThreadfunction ()
50. {
52. If(This. Textbox1.invokerequired)// Wait for Asynchronization
54. {
56. FlushclientFc =New Flushclient(Threadfunction );
58. This. Invoke (FC );// Call the refresh method through proxy
60. }
62. Else
64. {
66. This. Textbox1.text = datetime. Now. tostring ();
68. }
70. }
72. }

 

After running the above code, we can see that the problem has been solved. By waiting for Asynchronization, we will not always hold the control of the main thread, in this way, you can control winform multi-threaded controls without cross-thread call exceptions.

What should I do if the function called in the thread has parameters? I will give another example.

Code snippet

2. Public Delegate Void Myinvoke(StringStr );
4.  
6. Private VoidButton9_click (ObjectSender, eventargs E)
8. {
10. // _ Myinvoke = new myinvoke (settext );
12. // Checkforillegalcrossthreadcils = false;
14. Thread t =NewThread (NewThreadstart (fun ));
16. T. Start ();
18. }
20.  
22. Private VoidFun ()
24. {
26. // _ Myinvoke ("dddd ");
28. Settext ("DDD");
30. }
32. Private VoidSettext (StringS)
34. {
36. If(Textbox6.invokerequired)
38. {
40. Myinvoke_ Myinvoke =New Myinvoke(Settext );
42. This. Invoke (_ myinvoke,New Object[] {S });
44. }
46. Else
48. {
50. This. Textbox6.text = s;
52. }
54. }

There is also a way to do http://www.cnblogs.com/wangqiideal/archive/2008/06/07/1106136.html

Cross-thread control access solution in C # In vs2005

Recently I am working on a project and have encountered cross-thread access to page controls. however, an error is always prompted. You cannot modify the value of the control in the thread where the control is created in other threads. Later, the anonymous proxy is used, and the result is easily solved. the solution is as follows:
First, create a ListBox, lable.

Code snippet

2. UsingSystem;
4. UsingSystem. Collections. Generic;
6. UsingSystem. componentmodel;
8. UsingSystem. Data;
10. UsingSystem. drawing;
12. UsingSystem. text;
14. UsingSystem. Windows. forms;
16. UsingSystem. Threading;
18.  
20. NamespaceAccesscontrol
22. {
24. Public Partial Class Form1:Form
26. {
28. PublicForm1 ()
30. {
32. Initializecomponent ();
34. }
36.  
38. Private VoidForm1_load (ObjectSender,EventargsE)
40. {
42. ThreadNewthread =New Thread(New Threadstart(Backgroundprocess ));
44. Newthread. Start ();
46.  
48. }
50.  
52. /// <Summary>
54. ///Define a proxy
56. /// </Summary>
58. Private Delegate Void Crossthreadoperationcontrol();
60.  
62. Private VoidBackgroundprocess ()
64. {
66. // Instantiate the proxy as an anonymous proxy
68. CrossthreadoperationcontrolCrossdelete =Delegate()
70. {
72. IntI = 1;
74. While(I <5)
76. {
78. // Add a project to the list box
80. Listbox1.items. Add ("Item"+ I. tostring ());
82. I ++;
84. }
86. Label1.text ="I access this lable in the new thread! ";
88. Listbox1.items. Add (label1.text );
90. };
92. Listbox1.invoke (crossdelete );
94. }
96.  
98. }
100. }

I hope this tips will be helpful for your learning and work. If you have a better solution to cross-thread access control problems, I would like to share it with you.