Async and await keywords

Async and await are introduced in C #5.0. These two keywords allow you to write asynchronous code in synchronous mode more conveniently. That is to say, more convenient asynchronous programming. The general format is as follows:

 
 

  
  
var result = await expression; 
  
  
statement(s); 
 
 

This statement is equivalent:

 
 

  
  
var awaiter = expression.GetAwaiter(); 
  
  
awaiter.OnCompleted (() => 
  
  
{ 
  
  
var result = awaiter.GetResult(); 
  
  
statement(s); 
  
  
); 
 
 

The expression here is generally a Task or Task <TResult>, but in fact you can define some objects that can use await. However, certain conditions must be met. Let's first look at an example.

 
 

  
  
Static void Main (string [] args)
  
  
{
  
  
DisplayPrimesCount ();
  
  
Thread. Sleep (5000); // wait until asynchronous execution is completed
  
  
}
  
  
Static Task <int> GetPrimesCountAsync (int start, int count)
  
  
{
  
  
Return Task. Run () =>
  
  
ParallelEnumerable. Range (start, count). Count (n =>
  
  
Enumerable. Range (2, (int) Math. Sqrt (n)-1). All (I => n % I> 0 )));
  
  
}
  
  
Static async void DisplayPrimesCount ()
  
  
{
  
  
Int result = await GetPrimesCountAsync (2, 1000000); // Blocking
  
  
Console. WriteLine (result );
  
  
}
 
 

This is a common method.

To asynchronously execute the GetPrimesCountAsync method, first GetPrimesCountAsync must return a "Waiting" object. In the above Code, GetPrimesCountAsync returns the Task <int> type. Then, the async keyword must be added to the await method. And we can see await GetPrimesCountAsync (2, 1000000); this statement returns int instead of Task <int>.

The above code is described in the natural language as follows:

When DisplayPrimesCount is called, DisplayPrimesCount runs a new Task, which calculates the number of prime numbers. After the calculation is completed, the calculated value is returned, and the returned value is placed in the Task object, and returned to the caller. After obtaining the Task value, the caller obtains the result value of the Task.

When the program logic encounters the await GetPrimesCountAsync method, the thread will be suspended until the asynchronous operation is completed. After the result value is obtained, the program will continue to run.

In essence, the emergence of await and async is only a syntactic sugar, but this syntactic sugar can make asynchronous programming more elegant, directly abandoning the original EAP and APM such everywhere BeginXXX, the ugly EndXXX mode increases productivity.

You can use the await method. The returned value must be an awaitable object. It is troublesome to customize an awaitable object. An object must meet the following conditions:

Because Microsoft does not provide an interface that meets the preceding conditions, you can implement this interface by yourself.

 
 

  
  
public interface IAwaitable<out TResult> 
  
  
    { 
  
  
        IAwaiter<TResult> GetAwaiter(); 
  
  
    } 
  
  
    public interface IAwaiter<out TResult> : INotifyCompletion // or ICriticalNotifyCompletion 
  
  
    { 
  
  
        bool IsCompleted { get; } 
  
  
        TResult GetResult(); 
  
  
    } 
 
 

As lambda expressions cannot directly use await, you can program and implement this function skillfully. For example, to implement the extension method on a Func delegate, note:The extension method must be defined in the top-level static class..

 
 

  
  
Public static class FuncExtensions
  
  
{
  
  
Public static IAwaiter <TResult> GetAwaiter <TResult> (this Func <TResult> function)
  
  
{
  
  
Return new FuncAwaiter <TResult> (function );
  
  
}
  
  
}
  
  
Public interface IAwaitable <out TResult>
  
  
{
  
  
IAwaiter <TResult> GetAwaiter ();
  
  
}
  
  
Public interface IAwaiter <out TResult>: INotifyCompletion // or icriticalpolicycompletion
  
  
{
  
  
Bool IsCompleted {get ;}
  
  
TResult GetResult ();
  
  
}
  
  
Internal struct FuncAwaitable <TResult>: IAwaitable <TResult>
  
  
{
  
  
Private readonly Func <TResult> function;
  
  
Public FuncAwaitable (Func <TResult> function)
  
  
{
  
  
This. function = function;
  
  
}
  
  
Public IAwaiter <TResult> GetAwaiter ()
  
  
{
  
  
Return new FuncAwaiter <TResult> (this. function );
  
  
}
  
  
}
  
  
Public struct FuncAwaiter <TResult>: IAwaiter <TResult>
  
  
{
  
  
Private readonly Task <TResult> task;
  
  
Public FuncAwaiter (Func <TResult> function)
  
  
{
  
  
This. task = new Task <TResult> (function );
  
  
This. task. Start ();
  
  
}
  
  
Bool IAwaiter <TResult>. IsCompleted
  
  
{
  
  
Get
  
  
{
  
  
Return this. task. IsCompleted;
  
  
}
  
  
}
  
  
TResult IAwaiter <TResult>. GetResult ()
  
  
{
  
  
Return this. task. Result;
  
  
}
  
  
Void INotifyCompletion. OnCompleted (Action continuation)
  
  
{
  
  
New Task (continuation). Start ();
  
  
}
  
  
}
  
  

  
  
You can write the following in main:
  
  
 
  
  
Static void Main (string [] args)
  
  
{
  
  
Func () => {Console. WriteLine ("await .."); return 0 ;});
  
  
Thread. Sleep (5000); // wait until asynchronous execution is completed
  
  
}
  
  
Static async void Func (Func <int> f)
  
  
{
  
  
Int result = await new Func <int> (f );
  
  
Console. WriteLine (result );
  
  
}
 
 

Where:

The Func method can be executed asynchronously, because Func <int> has implemented the extended method GetAwaiter, And the return value type is the IAwaitable type defined by itself.

Of course, the simpler method is to use the Task object provided by Microsoft so that the lambda expression can return the Task type.

 
 

  
  
Static void Main (string [] args)
  
  
{
  
  
Func () =>
  
  
{
  
  
Return Task <int>. Run <int> () => {return Enumerable. Range (1,100). Sum ();});
  
  
});
  
  
Thread. Sleep (5000); // wait until asynchronous execution is completed
  
  
}
  
  
Static async void Func (Func <Task <int> f)
  
  
{
  
  
Int result = await f ();
  
  
Console. WriteLine (result );
  
  
}
 
 
---------------------------------

References: C #5.0 IN A NUTSHELL

Http://weblogs.asp.net/dixin/archive/2012/11/08/understanding-c-async-await-2-awaitable-awaiter-pattern.aspx