C # six major threading operations

C # Threading Operations common six ways to operate 2009-08-28 15:25 Nokiaguy Blog Parkfont Size:T | T

What is the specific way to do C # threading? What are the characteristics and main applications of the C # threading method? So this article will introduce you to this aspect of the content.

AD:2014WOT Global Software Technology Summit Beijing Station course video release

What are common ways to do C # threading operations? What is the implementation of the C # threading method? So let's take a look at what the six methods of specific C # threading operations are, and what are their characteristics?

C # thread operations one, BeginInvoke and EndInvoke methods with delegates (Delegate) to manipulate threads

There are many ways to use threading in C #, and the BeginInvoke and EndInvoke methods of using delegates are one of them. The BeginInvoke method can use threads to asynchronously execute the method that the delegate points to. The return value of the method is then obtained by the EndInvoke method (the return value of the EndInvoke method is the return value of the called method), or the method has been successfully called. There are four ways to get the return value from the EndInvoke method.

C # Thread Operations Ii. Use the EndInvoke method directly to get the return value

When using BeginInvoke to invoke a method asynchronously, the EndInvoke method will block until the method is executed if the method is not finished. As shown in the following code:

2. Using System;
4. Using System.Collections.Generic;
6. Using System.Linq;
8. Using System.Text;
10. Using System.Threading;
14. Namespace MyThread
16. {
18. Class Program
20. {
22. Private static int NewTask (int ms)
24. {
26. Console.WriteLine ("task Start");
28. Thread.Sleep (MS);
30. Random random = new Random ();
32. int n = random. Next (10000);
34. Console.WriteLine ("Mission Accomplished");
36. return n;
38. }
42. Private Delegate int newtaskdelegate (int ms);
48. static void Main (string[] args)
50. {
52. Newtaskdelegate task = NewTask;
54. IAsyncResult AsyncResult = task.  BeginInvoke (+, null, null);
58. EndInvoke method will be blocked for 2 seconds
60. int result = task. EndInvoke (AsyncResult);
62. Console.WriteLine (result);
64. }
66. }
68. }

After running the above program, the program does not output the final result (a random integer) until 2 seconds since the NewTask method is delayed by sleep by 2 seconds. If you do not call the EndInvoke method, the program exits immediately, because the thread created with BeginInvoke is a background thread, and once all of the foreground threads have exited (where the main thread is a foreground thread), the thread will end regardless of whether the background thread finishes executing. and exit the program. Detailed information about the foreground and background threads will be explained in a later section.

Readers can use the above procedure to do the following experiments. First, add the following code to the beginning of the Main method:

1. Thread.Sleep (10000);

To delay the main method for 10 seconds, execute the following code, then press CTRL+F5 to run the program, open Enterprise Manager, observe the number of threads in the current program, assume that the number of threads is 4, and after 10 seconds, the number of threads increases to 5. This is because when the BeginInvoke method is called, a thread is created to execute the NewTask method asynchronously, so the threads increase by one.

C # Threading Operations third, use the IAsyncResult AsyncResult property to determine whether an asynchronous call is complete

Although the method above can implement asynchronous invocation well, when calling the EndInvoke method to get the result of the call, the whole program is just as dead, so the user doesn't feel too good, so we can use asyncresult to determine whether the asynchronous call is complete and display some hints. Doing so can increase the user experience. The code is as follows:

2. static void Main (string[] args)
4. {
6. Newtaskdelegate task = NewTask;
8. IAsyncResult AsyncResult =
10. Task.  BeginInvoke (+, null, null);
14. while (!asyncresult.iscompleted)
16. {
18. Console.Write ("*");
20. Thread.Sleep (100);
22. }
24. Because the asynchronous call is complete, EndInvoke returns the result immediately
26. int result = task. EndInvoke (AsyncResult);
28. Console.WriteLine (result);
30. }

The result of the above code is as shown.

Because it is asynchronous, "*" may be output before "task start", as shown in.

C # Threading Operations Iv. using the WaitOne method to wait for asynchronous method execution to complete

Using the WaitOne method is another way to determine whether an asynchronous call is complete. The code is as follows:

1. static void main (string[] args)  
2. { 
3. newtaskdelegate task = newtask;  
4. iasyncresult asyncresult = task. BeginInvoke (2000, null, null);  
Li class= "alt" > 
5. while  (!asyncresult.asyncwaithandle.waitone (100,  false))  
6. { 
7.  console.write (
8.  
9.  
10. int& Nbsp;result = task. EndInvoke (AsyncResult);  
11. Console.WriteLine (result);  
12. }  

The first parameter of WaitOne represents the number of milliseconds to wait, and within a specified time, the WaitOne method waits until the asynchronous call is complete and notifies the WaitOne method to return True. When the asynchronous call is still not completed after waiting for the specified time, the WaitOne method returns False if the specified time is 0, indicating that no wait, if 1, means that the asynchronous call is completed forever.

C # Threading Operations v. Returning results using callback methods

The methods described above are actually only equivalent to one method. Although these methods can successfully return the results, but also to give the user some hints, but in this process, the whole program is like dead (if the reader in the GUI program is very obvious to use these methods), in order to call the process, the program can still do other work, you must use the way of asynchronous calls. Below we use GUI program to write an example, the code is as follows:

2. Private Delegate int MyMethod ();
4. Private int method ()
6. {
8. Thread.Sleep (10000);
10. return 100;
12. }
14. Private void methodcompleted (IAsyncResult asyncResult)
16. {
18. if (AsyncResult = = null) return;
20. TextBox1.Text = (asyncresult.asyncstate as
22. MyMethod). EndInvoke (AsyncResult). ToString ();
24. }
28. Private void button1_click (object sender, EventArgs e)
30. {
34. MyMethod my = method;
36. IAsyncResult AsyncResult = My. BeginInvoke (methodcompleted, my);
38. }

Note that the last two parameters of the BeginInvoke method are used here (if the called method contains parameters, these parameters will be used as the previous part of the BeginInvoke parameter, and if there are no parameters, the BeginInvoke will have only two parameters). The first parameter is the callback method delegate type, which has only one parameter, which is IAsyncResult, as shown in the Methodcompleted method. The Methodcompleted method is called automatically when the method methods are executed. The second parameter of BeginInvoke needs to pass some values to the Methodcompleted method, which can generally pass the delegate of the called method, such as my in the code above. This value can be obtained using the IAsyncResult.AsyncState property.

Because the above code accesses a textbox on the form asynchronously, you need to press CTRL+F5 to run the program (you cannot run the program directly by pressing F5, otherwise you cannot access the textbox in other threads, for if the GUI component is accessed in another thread, Detailed in the following sections). And put some other visual controls on the form, but after clicking on Button1, the other controls can still be used, as if nothing happened, and after 10 seconds, 100 will be output in TextBox1.

C # Threading Operations Vi. BeginXxx and EndXxx methods for other components

There are also methods like BeginInvoke and EndInvoke in other. Net components, such as the BeginGetResponse and EndGetResponse methods of the System.Net.HttpWebRequest class, and here is an example of using these two methods:

2. Private void requestcompleted (IAsyncResult asyncResult)
4. {
6. if (AsyncResult = = null) return;
8. System.Net.HttpWebRequest HWR =
12. Asyncresult.asyncstate as System.Net.HttpWebRequest;
14. System.Net.HttpWebResponse response =
16. (System.Net.HttpWebResponse) Hwr. EndGetResponse (AsyncResult);
18. System.IO.StreamReader sr = New
20. System.IO.StreamReader (response. GetResponseStream ());
22. TextBox1.Text = Sr. ReadToEnd ();
24. }
26. Private Delegate System.Net.HttpWebResponse Requestdelegate (
30. System.Net.HttpWebRequest request);
34. Private void button1_click (object sender, EventArgs e)
36. {
38. System.Net.HttpWebRequest request =
40. (System.Net.HttpWebRequest)  System.Net.WebRequest.Create ("http://www.cnblogs.com");
42. IAsyncResult AsyncResult =request. BeginGetResponse (requestcompleted, request);

C # six major threading operations