Voulez comprendre async

Voici mon explication

class MainClass
{
    public static async Task<String> AsyncMethod(int delay) {

        await Task.Delay (TimeSpan.FromSeconds(delay));

        return "The method has finished it's execution after waiting for " + delay + " seconds";
    }

    public static async Task Approach1(int delay)
    {
        var response = await AsyncMethod (delay); //await just unwraps Task's result

        Console.WriteLine (response);
    }

    public static Task Approach2(int delay)
    {
        return AsyncMethod(delay).ContinueWith(message => Console.WriteLine(message)); //you could do the same with 
    }

    public static void Main (string[] args)
    {
        var operation1 = Approach1 (3);
        var operation2 = Approach2 (5);

        Task.WaitAll (operation1, operation2);

        Console.WriteLine("All operations are completed")
    }
}

Finalement les deux Approach1 et Approach2 sont identiques morceaux de code.

La async/await est sucre syntaxique autour de la Tâche de l'API. Il prend votre async méthode divise en plusieurs parties avant de await, et après await. Le "avant" la partie est exécutée immédiatement. "L'après" la partie est d'obtenir exécutée lorsque await opération est terminée. Vous êtes capable de suivre la deuxième partie de l'opération via l'API de Tâches puisque vous obtenez une référence à une Tâche.

En général async permet de traiter un appel de méthode comme une sorte de fonctionnement longue durée qui vous permet de référencer via l'API de Tâches et attendre qu'il est fini et continuer avec un autre morceau de code. Soit par l'intermédiaire de ContinueWith appel de via à l'aide de await en général c'est la même chose.

Avant async/await/Task concepts de gens ont été en utilisant des rappels, mais les erreurs de manipulation a été aussi facile que l'enfer, le Task est semblable à un concept de callback sauf qu'il est en mesure de permettre la manipulation des exceptions de plus en plus facilement.

En général tous cette Tâche/async/await mantra est proche de la notion de promises si vous avez travaillé avec jQuery/JavaScript, il y a un concept similaire, voici une belle question en expliquant comment il est fait, il y a "jQuery deferreds et de promesses .alors() vs .done()"

Modifier: je viens de trouvé .NET manque de mise en œuvre de then des fonctionnalités similaires à celle qui se trouve en jQuery/JavaScript.

La différence entre ContinueWith et Then est que Then est capable de composer de la tâche, et à exécuter l'une après l'autre tandis que ContinueWith n'est pas, il est capable seulement de lancer des tâches en parallèle, mais il peut être facilement mis en œuvre par l'attendent de construire. Voici mon code mis à jour contenant tout le toutim:

static class Extensions
{
//Implementation to jQuery-like `then` function in .NET
//According to: http://blogs.msdn.com/b/pfxteam/archive/2012/08/15/implementing-then-with-await.aspx
//Further reading: http://blogs.msdn.com/b/pfxteam/archive/2010/11/21/10094564.aspx
public static async Task Then(this Task task, Func<Task> continuation) 
{ 
await task; 
await continuation(); 
} 
public static async Task<TNewResult> Then<TNewResult>( 
this Task task, Func<Task<TNewResult>> continuation) 
{ 
await task; 
return await continuation(); 
} 
public static async Task Then<TResult>( 
this Task<TResult> task, Func<TResult,Task> continuation) 
{ 
await continuation(await task); 
} 
public static async Task<TNewResult> Then<TResult, TNewResult>( 
this Task<TResult> task, Func<TResult, Task<TNewResult>> continuation) 
{ 
return await continuation(await task); 
}
}
class MainClass
{
public static async Task<String> AsyncMethod1(int delay) {
await Task.Delay (TimeSpan.FromSeconds(delay));
return "The method has finished it's execution after waiting for " + delay + " seconds";
}
public static Task<String> AsyncMethod2(int delay)
{
return Task.Delay (TimeSpan.FromSeconds (delay)).ContinueWith ((x) => "The method has finished it's execution after waiting for " + delay + " seconds");
}
public static async Task<String> Approach1(int delay)
{
var response = await AsyncMethod1 (delay); //await just unwraps Task's result
return "Here is the result of AsyncMethod1 operation: '" + response + "'";
}
public static Task<String> Approach2(int delay)
{
return AsyncMethod2(delay).ContinueWith(message => "Here is the result of AsyncMethod2 operation: '" + message.Result + "'");
}
public static void Main (string[] args)
{
//You have long running operations that doesn't block current thread
var operation1 = Approach1 (3); //So as soon as the code hits "await" the method will exit and you will have a "operation1" assigned with a task that finishes as soon as delay is finished
var operation2 = Approach2 (5); //The same way you initiate the second long-running operation. The method also returns as soon as it hits "await"
//You can create chains of operations:
var operation3 = operation1.ContinueWith(operation1Task=>Console.WriteLine("Operation 3 has received the following input from operation 1: '" + operation1Task.Result + "'"));
var operation4 = operation2.ContinueWith(operation2Task=>Console.WriteLine("Operation 4 has received the following input from operation 2: '" + operation2Task.Result + "'"));
var operation5 = Task.WhenAll (operation3, operation4)
.Then(()=>Task.Delay (TimeSpan.FromSeconds (7)))
.ContinueWith((task)=>Console.WriteLine("After operation3 and 4 have finished, I've waited for additional seven seconds, then retuned this message"));
Task.WaitAll (operation1, operation2); //This call will block current thread;
operation3.Wait (); //This call will block current thread;
operation4.Wait (); //This call will block current thread;
operation5.Wait (); //This call will block current thread;
Console.WriteLine ("All operations are completed");
}
}

OriginalL'auteur Lu4