C # advantages and methods of asynchronous calls

We need to clarify why asynchronous callback is required? As we all know, normal methods run in a single thread. Large operations (such as reading large files, operating databases in large batches, and network transmission) in the middle will lead to method blocking, as shown on the interface, Program Card or die, the interface element does not move, no response. The asynchronous method solves these problems. When a method is executed asynchronously, the program immediately opens up a new thread to run your method. The main thread, including the interface, will not die. Now we are talking about how to end this asynchronous new thread.
First, the asynchronous new thread must be recycled. It is a shameful waste of resources ,. net is also not allowed, so you do not want to explore the loopholes, as the saying goes, please be easy to god, it is this truth. Next, you can easily think of two types of recovery: active recovery and passive recovery (of course, this is my understanding, but Microsoft does not say so). Active recovery is, you need to monitor the thread and wait. When the Asynchronous Method is complete, the asynchronous thread will be recycled, and the focus will be returned to the main thread. This is actually the first article.ArticleIn C # asynchronous preliminary, endinvoke is followed by begininvoke. If the asynchronous thread does not complete the operation at endinvoke, the entire program, including the main thread, it is blocked again, and the interface will be "dead. To solve this problem, we should adopt the "passive reclaim" method. An important method is "Asynchronous callback ". Core: A, Use the callback function (callbackmethod in this example) ). This callback function is automatically called after the asynchronous process ends. B, In the preceding two examples, endinvoke is called in the main thread. This method calls endinvoke In the callback function. The general process of asynchronous callback is as follows: first, start Asynchronization. Then, the startup parameter is added with the method executed at the end of Asynchronization. Then, this asynchronous thread will be ignored, finally, when the asynchronous thread completes the work, it will automatically execute the method in the startup parameter, which is indeed very worry-free,CodeWriting is complicated. The code for souzang is as follows:

2. // First, prepare the Asynchronous Method (asynchronous, preferably not multithreading)
4. Privatestringmethodname (intnum, outintnum2)
6. {
8. Num2 = num;
10. Return "helloworld ";
12. }
14. // Program endpoint
16. // The method (callback method) to be executed when asynchronous completion is completed. This method can only have one iasyncresult parameter, but this parameter is almost omnipotent and can be passed to the object.
18. Privatevoidcallbackmethod (iasyncresultar)
20. {
22. // Obtain the delegate object from the asynchronous ar. asyncstate.
24. Delegatenamedn = (delegatename) Ar. asyncstate;
26. // Output parameters
28. Inti;
30. // Be sure to use endinvoke. Otherwise, your end will be miserable.
32. Stringr = DN. endinvoke (Outi, AR );
34. MessageBox. Show ("Asynchronous completion! The value of I is "I. tostring ()", and the value of R is "R );
36. }
38. // Define the delegate with the same signature as the method
40. Privatedelegatestringdelegatename (intnum, outintnum2 );
42. // Program entry
44. Privatevoidrun ()
46. {
48. // Instantiate the delegate and assign a value first
50. Delegatenamedn = newdelegatename (methodname );
52. // Output parameters
54. Inti;
56. // Instantiate the callback Method
58. // Consider asynccallback as delegate. In fact, asynccallback is a Special Delegate, just like event.
60. Asynccallbackacb = newasynccallback (callbackmethod );
62. // Asynchronous Start
64. // If the value of ACB is null, no callback method is available.
66. // The last parameter dn can be replaced with any object. This object can be obtained by the callback method from the parameter and written as null. The parameter dn is equivalent to the thread ID. If multiple asynchronous threads exist, they can all be null, but they cannot be the same. They cannot be the same object. Otherwise, an exception occurs.
68. Iasyncresultiar = DN. begininvoke (1, Outi, ACB, DN );
70. // Do other things
72. //............
74. }
76. // The final result should be: I = 1, R = "helloworld"
78. // In addition, if you can, you can choose not to modify too much when defining the delegate:
80. /// <Summary>
82. /// Define the delegate
84. /// </Summary>
86. /// <Returns> </returns>
88. Publicdelegateboolasyncdelegate ();
90. /// <Summary>
92. /// Callbackmethodmusthavethesamesignatureasthe
94. /// Asynccallbackdelegate
96. /// </Summary>
98. /// <Paramname = "Ar"> </param>
100. Privatevoidcallbackmethod (iasyncresultar)
102. {
104. // Retrievethedelegate.
106. Asyncdelegatedlgt = (asyncdelegate) Ar. asyncstate;
108. // Callendinvoketoretrievetheresults.
110. Dlgt. endinvoke (AR );
112. }
114. // Call other methods:
116. // Asynchronous execution
118. // Specify the delegate Method
120. Asyncdelegateisgt = newasyncdelegate (icpinfo. insert );
122. Iasyncresultar = isgt. begininvoke (newasynccallback (callbackmethod), isgt );

 

 

To:Http://www.cnblogs.com/xiaoli0414/archive/2007/11/27/974534.html