Async and await are introduced in C # 5.0

Async and await are introduced in C # 5.0. These two keywords can make it easier for you to write asynchronous code.

Look at an example:

[CSharp]View Plaincopy

2. Public class MyClass
4. {
6. Public MyClass ()
8. {
10. Displayvalue (); //There is no blocking
12. System.Diagnostics.Debug.WriteLine ("MyClass () End.");
14. }
16. Public task<double> getvalueasync (double num1, double num2)
18. {
20. return Task.run (() =
22. {
24. For (int i = 0; i < 1000000; i++)
26. {
28. NUM1 = num1/num2;
30. }
32. return NUM1;
34. });
36. }
38. Public async void Displayvalue ()
40. {
42. double result = await Getvalueasync (1234.5, 1.01); //This will open a new thread to process the Getvalueasync task, and then return the method immediately
44. All code after this is encapsulated as a delegate, which is called when the Getvalueasync task completes
46. System.Diagnostics.Debug.WriteLine ("Value is:" + result);
48. }
50. }

The ASYNC keyword tag is called asynchronously in the MyClass constructor, Displayvalue (), and the Displayvalue () method executes an await keyword-tagged asynchronous task Getvalueasync (), This asynchronous task must be either a task or a task<tresult> as the return value, and we also see that the actual type returned when the asynchronous task execution completes is void or the Tresult,displayvalue () method await All code after Getvalueasync () will be executed when the asynchronous task is completed.

The code that is actually executed by the Displayvalue () method is as follows:

[CSharp]View Plaincopy

2. Public void Displayvalue ()
4. {
6. system.runtime.compilerservices.taskawaiter<double> awaiter = Getvalueasync (1234.5, 1.01).  Getawaiter ();
8. Awaiter. OnCompleted (() =
10. {
12. double result = Awaiter.  GetResult ();
14. System.Diagnostics.Debug.WriteLine ("Value is:" + result);
16. });
18. }

As you can see, the async and await keywords simply make the above code easier to understand.

The output of the program is as follows:

MyClass () End.

Value is:2.47032822920623e-322

Here is a static Class I wrote that makes it easy to execute an asynchronous invocation of a normal function:

[CSharp]View Plaincopy

2. Public static class Taskasynchelper
4. {
6. // <summary>
8. /// to run a method function asynchronously and execute the callback when execution is complete callback
10. // </summary>
12. /// <param name= "function" > Async method, the method has no arguments, the return type must be void</param>
14. // <param name= "Callback" > The callback method executed when the Async method executes, with no arguments, the return type must be void</param>
16. public static async void RunAsync (action function, action callback)
18. {
20. Func<system.threading.tasks.task> Taskfunc = () =
22. {
24. return System.Threading.Tasks.Task.Run (() =
26. {
28. function ();
30. });
32. };
34. await Taskfunc ();
36. if (callback! = null)
38. Callback ();
40. }
44. // <summary>
46. /// to run a method function asynchronously and execute the callback when execution is complete callback
48. // </summary>
50. // <typeparam name= "TResult" > Return type of async method </typeparam>
52. /// <param name= "function" > Async method, the method has no arguments, the return type must be tresult</param>
54. // <param name= "Callback" > The callback method executed when the Async method executes, the method parameter is TResult, the return type must be void</param>
56. public static async void Runasync<tresult> (func<tresult> function, action<tresult> Callback)
58. {
60. Func<system.threading.tasks.task<tresult>> Taskfunc = () =
62. {
64. return System.Threading.Tasks.Task.Run (() =
66. {
68. return function ();
70. });
72. };
74. TResult RLT = await taskfunc ();
76. if (callback! = null)
78. Callback (RLT);
80. }
82. }

It is easy to use the method name as a parameter, and the most common thing is to pass the time-consuming serialization function in order to avoid blocking the UI process, causing the lag and affecting the user experience.

Async and await are introduced in C # 5.0