Task.Wait n'attend pas la fin de la méthode asynchrone

N'utilisez pas var task = new Task (...); task.Start (); , utilisez simplement Task.Run à la place.

Dans le premier cas, le constructeur Task (Action action) est utilisé pour que vous n'attendiez pas réellement la méthode async. Si vous inspectez real C # sans sucre de syntaxe asyn-await, vous verrez AsyncVoidMethodBuilder . Dans le cas de Task.Run , vous utilisez Task.Run (Func func) pour recevoir des tâches "réelles".

Donc, si vous voulez utiliser le constructeur, vous devez utiliser l'approche des commentaires: nouvelle tâche .

Une citation de @JonSkeet :

Votre méthode async renvoie simplement void, ce qui signifie qu'il n'y a pas de moyen simple de tout ce qui attend qu'il se termine. (Vous devriez presque toujours évitez d'utiliser les méthodes async void. Ils ne sont vraiment disponibles que pour le pour vous abonner à des événements.)

Alors regardez cette ligne de votre code:

static async Task Main(string[] args)
{
    // best way to do it
    await AsyncTest();


    Console.WriteLine("Main finished");
}

private static async Task AsyncTest()
{
    // Don't use thread sleep, await task delay is fine
    // Thread.Sleep(2000);

    await Task.Delay(2000);
    Console.WriteLine("Method finished");
}

Regardez la signature des constructeurs de Task :

    public Task(Action action);
    public Task(Action action, CancellationToken cancellationToken);       
    public Task(Action action, TaskCreationOptions creationOptions);
    public Task(Action<object> action, object state);
    public Task(Action action, CancellationToken cancellationToken, TaskCreationOptions creationOptions);
    public Task(Action<object> action, object state, CancellationToken cancellationToken);
    public Task(Action<object> action, object state, TaskCreationOptions creationOptions);
    public Task(Action<object> action, object state, CancellationToken cancellationToken, TaskCreationOptions creationOptions);

Toutes sont des Actions et comme vous le savez, Action a un type de retour void . p >

var t = new Task(async () => await AsyncTest());

vérifiez ceci

public static async Task Main(string[] args)
{
    var t = Task.Factory.StartNew(async () => await AsyncTest());
    //t.Start();
    t.Result.Wait();    
    t.Wait();
    Console.WriteLine("Main finished");
}

private static async Task AsyncTest()
{
    //Thread.Sleep(2000);
    await Task.Delay(2000);
    Console.WriteLine("Method finished");
}

et ce lien

Je ne comprends toujours pas pourquoi Task ne fonctionne pas correctement avec async / await inside delegate.

Parce que le constructeur Task n'est utilisé que pour créer Déléguer des tâches - c'est-à-dire des tâches qui représentent du code synchrone à exécuter. Comme le code est synchrone, votre lambda async est traité comme un lambda async void , ce qui signifie que l'instance Task n'attendra pas de manière asynchrone AsyncTest pour terminer.

Plus précisément, le constructeur de Task ne doit jamais, jamais être utilisé dans un code, n'importe où, pour quelque raison que ce soit . Il n'a littéralement aucun cas d'utilisation valide.

Un bon remplacement de Task.Task est Task.Run , ce qui fait comprendre async lambdas.

Dans mon vrai programme, Task a différé son exécution. L'objet de tâche est créé à un endroit, puis plus tard après une condition spécifique exécutée par une autre partie du programme.

Dans ce cas, utilisez un délégué asynchrone . Plus précisément, Func.

static async Task Main(string[] args)
{
    Func<Task> func = AsyncTest;

    // Later, when we're ready to run.
    await func();
    Console.WriteLine("Main finished");
}

private static async Task AsyncTest()
{
    Thread.Sleep(2000);
    await Task.Delay(2000);
    Console.WriteLine("Method finished");
}