C # Asynchronous invocation

Let's start with a simple example:

1. Xiao Ming in boiling water, and so on after the boil, will pour water into the thermos, and then began to tidy up the housework
2. Xiaowen in the process of boiling water, cleaning up the housework, and so on after the boil, put down the hands of housework, the boiling water into the thermos, and then continue to tidy up the housework

This is also a common situation in daily life, the efficiency of the small text is significantly higher than xiaoming. From the perspective of C # program execution, Xiaoming uses synchronous processing, and Xiaowen uses asynchronous processing mode.

In synchronous processing, transactions are processed one at a time, while asynchronous means that the child operations are separated from the main operation and the master operation continues, and the child operation notifies the main operation when the processing is complete.

In C #, it is done asynchronously through a delegate. Take a look at the following example:

2. Class Program
4. {
6. static TimeSpan boil ()
8. {
10. Console.WriteLine ("kettle: Start boiling water ...");
12. Thread.Sleep (6000);
14. Console.WriteLine ("Kettle: the water is boiling!"   ");
16. return timespan.minvalue;
18. }
22. delegate TimeSpan Boilingdelegate ();
26. static void Main (string[] args)
28. {
30. Console.WriteLine ("Xiao Wen: Put the kettle on the stove");
32. Boilingdelegate d = new boilingdelegate (boil);
34. IAsyncResult result = D.begininvoke (boilingfinishedcallback, null);
36. Console.WriteLine ("Xiao Wen: Start tidying up the housework ...");
38. For (int i = 0; i <; i++)
40. {
42. Console.WriteLine ("Xiao Wen: finishing the first {0} items housework ...", i + 1);
44. Thread.Sleep (1000);
46. }
48. }
52. static void Boilingfinishedcallback (IAsyncResult result)
54. {
56. AsyncResult AsyncResult = (AsyncResult) result;
58. Boilingdelegate del = (boilingdelegate) asyncresult.asyncdelegate;
60. Del. EndInvoke (result);
62. Console.WriteLine ("Xiao Wen: pouring hot water into a thermos bottle");
64. Console.WriteLine ("Xiao Wen: continue to tidy up the housework");
68. }
70. }

The example above is an example of the simplest asynchronous invocation, without any parameter passing on the asynchronous calling function and a return value check. This example reflects the flow of water boiling water, first xiaowen the kettle on the stove, after the definition of the trust, the use of BeginInvoke method to start an asynchronous call, that is, the kettle began to boil water, so the small article began to tidy up the housework. After the water is fired, the async model of C # triggers the callback function specified by the BeginInvoke method, which is defined by the callback function when the water is fired, and xiaowen the water into the thermos and continues to tidy up the housework.

Thus, implementing an asynchronous call in C # is not complex, first creating an asynchronous handler and defining a delegate for it, and then using the BeginInvoke method of the delegate when calling the function, specifying the callback function when the function is finished (if the completion event does not need to be handled, You can give a null value) and specify the desired parameter (or null if there are no arguments); Finally, the completion event is processed in the callback function.

Note that the EndInvoke call in the previous callback function EndInvoke causes the calling thread to block until the asynchronous function processing is complete. Obviously, the EndInvoke used immediately after BeginInvoke is equivalent to the synchronous call.

The return value of the EndInvoke call is also the return value of the asynchronous handler function. We change the program slightly to change the boil method to the following form:

1. Static TimeSpan Boil ()
2. {
3. DateTime begin = DateTime.Now;
4. Console.WriteLine ("kettle: Start boiling water ...");
5. Thread.Sleep (6000);
6. Console.WriteLine ("Kettle: the water is boiling!"   ");
7. return datetime.now-begin;
8. }

Then change the boilingfinishedcallback to the following form:

1. static void  Boilingfinishedcallback (Iasyncresult result)   
2. {  
3.     asyncresult asyncresult =  (AsyncResult) result;   
4.     BoilingDelegate del =  (boilingdelegate) Asyncresult.asyncdelegate;   
5.     console.writeline (
6.     console.writeline (
7.     console.writeline ( " Xiaowen: Continue to tidy up the housework ");   
8. }   

Then we can get the time value returned by the boil asynchronous handler when EndInvoke. In fact, if the defined Boilingdelegate delegate has a parameter list, we can also pass the required parameters to the asynchronous handler at BeginInvoke. The signature of the Begininvoke/endinvoke function is related to defining their delegate signature.

Note: In the modified Boilingfinishedcallback method, in order to get the delegate instance to get the return value of the asynchronous handler, we used the following transformation:

1. AsyncResult AsyncResult = (AsyncResult) result;
2. Boilingdelegate del = (boilingdelegate) asyncresult.asyncdelegate;

This is to get the entity that invokes the delegate of the asynchronous handler function.

. NET handles asynchronous function calls, which are actually done through threads. This process has the following characteristics:

• The asynchronous function is done by the thread, which is the thread. NET threads in a thread pool
• Typically, the. NET thread pool has 500 threads (of course, this number can be set), and each time the call to BeginInvoke begins asynchronous processing, the asynchronous handler is executed by a thread in the thread pool , and the user cannot control which thread is responsible for executing
• Due to the limited number of threads in the thread pool, the new call request will cause the function to wait for the free thread to occur when the pool is fully occupied. At this point, the efficiency of the program will be affected

To verify these features, see the following procedure:

2. Class Program
4. {
6. delegate void MethodInvoker ();
10. static void Foo ()
12. {
14. int intavailablethreads, intavailableioasynthreds;
18. Threadpool.getavailablethreads (outintavailablethreads,
20. Out intavailableioasynthreds);
24. string strmessage =
26. String.Format (@ is Thread Pool: {0},
28. Thread Id: {1} free Threads {2} ",
30. Thread.CurrentThread.IsThreadPoolThread.ToString (),
32. Thread.CurrentThread.GetHashCode (),
34. Intavailablethreads);
38. Console.WriteLine (strmessage);
42. Thread.Sleep (10000);
46. return;
48. }
52. static void Callfoo ()
54. {
56. MethodInvoker SimpleDelegate =
58. new MethodInvoker (Foo);
62. For (int i = 0; i < i++)
64. {
66. Simpledelegate.begininvoke (null, null);
68. }
70. }
74. static void Main (string[] args)
76. {
78. Threadpool.setmaxthreads (10, 10);
80. Callfoo ();
82. Console.ReadLine ();
84. }
86. }

This program sets the maximum number of threads in the thread pool to 10 at the beginning, and then makes 15 asynchronous calls, with each asynchronous call resting for 10 seconds as the time it takes to process itself. From the execution of the program we can see that after the current 10 asynchronous calls are fully started, a new asynchronous call will wait (note: Not the main thread is waiting) until the thread pool is idle.

C # Asynchronous invocation