Comment faire Tâche awaitable

Plus d'un an plus tard

Après l'utilisation asynchrone attendent depuis plus d'un an maintenant, je sais que certaines choses au sujet de async je l'ai écrit dans ma réponse originale à cette question ne sont pas correctes, bien que le code dans la réponse est encore correct. Hera sont deux liens que m'a aidé énormément à comprendre comment asynchrone attendent oeuvres.

Cette interview Eric Lippert montre une excellente analogie pour async-attendent. De recherche, quelque part dans le milieu pour async-vous attendent.

Dans cet article, le toujours très serviable Eric Lippert montre quelques bonnes pratiques pour async-attendent

Réponse originale à cette question

OK, voici un exemple complet qui m'a aidé pendant le processus d'apprentissage.

Supposons que vous avez une lente calculatrice, et que vous souhaitez utiliser en appuyant sur un bouton. Pendant ce temps vous voulez que votre INTERFACE utilisateur de rester sensible, et peut-être même faire d'autres choses. Lorsque la calculatrice est fini, vous voulez afficher le résultat.

Et de cours: l'utilisation async /await pour cela, et aucune de ces méthodes comme l'événement de drapeaux et d'attente pour ces événements à définir.

Ici est la lenteur de la calculatrice:

private int SlowAdd(int a, int b)
{
    System.Threading.Thread.Sleep(TimeSpan.FromSeconds(5));
    return a+b;
}

Si vous souhaitez utiliser ce mode asynchrone lors de l'utilisation asynchrone attendent que vous avez à utiliser les groupes de travail.Exécuter(...) pour démarrer de manière asynchrone. La valeur de retour de Task.Run est un awaitable Tâche:

• Task si la valeur de retour de la fonction que vous Exécutez est nulle
• Task<TResult> si la valeur de retour de la fonction que vous exécutez est TResult

Vous pouvez commencer la Tâche, faire autre chose, et quand vous avez besoin le résultat de la Tâche que vous tapez vous attendent. Il y a un inconvénient:

Si vous voulez 'attendre' votre fonction doit être asynchrone et retour Task au lieu de void ou Task<TResult> au lieu de TResult.

Voici le code qui s'exécute de la lenteur de la calculatrice.
Il est pratique courante de mettre fin à l'identifiant d'une fonction async avec async.

private async Task<int> SlowAddAsync(int a, int b)
{
    var myTask = Task.Run ( () => SlowAdd(a, b));
    //if desired do other things while the slow calculator is working
    //whenever you have nothing to do anymore and need the answer use await
    int result = await myTask;
    return result;
}

Côté remarque: Certaines personnes préfèrent Tâche.Usine.StartNew au-dessus de Départ.Exécuter. Voir ce MSDN dit à ce sujet:

MSDN: la Tâche.Exécuter par rapport à la Tâche.Usine.StartNew

La SlowAdd est démarré en tant que fonction async, et votre thread continue. Une fois qu'il a besoin de la réponse qu'il attend pour la Tâche. La valeur de retour est la TResult, qui dans ce cas est un int.

Si vous n'avez rien d'utile à faire le code devrait ressembler à ceci:

private async Task`<int`> SlowAddAsync(int a, int b)
{
    return await Task.Run ( () => SlowAdd(a, b));
}

Noter que SlowAddAsync est déclarée une fonction async, donc tout le monde qui utilise cette fonction async devrait également être asynchrone et le retour de la Tâche ou des Tâches<TResult>:

private async Task UpdateForm()
{
     int x = this.textBox1.Text;
     int y = this.textBox2.Text;
     int sum = await this.SlowAddAsync(x, y);
     this.label1.Text = sum.ToString();
}

La bonne chose à propos async /await, c'est que vous n'avez pas à jouer avec ContinueWith attendre jusqu'à ce que la tâche précédente est terminée. Utilisez simplement vous attendent, et vous savez que la tâche est terminée et que vous avez la valeur de retour. De l'instruction après l'attendent est ce que vous auriez normalement faire dans la ContinueWith.

Par ailleurs, votre Tâche.Run n'a pas à appeler une fonction, vous pouvez également mettre un bloc de rapport:

int sum = await Task.Run( () => {
    System.Threading.Thread.Sleep(TimeSpan.FromSeconds(5));
    return a+b});

Cependant, la bonne chose à propos d'une fonction distincte, c'est que vous donner à ceux qui n'ont pas besoin /envie /comprendre asynchrone, la possibilité d'utiliser la fonction sans async /await.

Rappelez-vous:

Chaque fonction qui utilise attendent devrait être async

Chaque async fonction doit retourner une Tâche ou une Tâche<Tresult>

"Mais mon gestionnaire d'événement ne peut pas retourner une Tâche!"

private void OnButton1_Clicked(object sender, ...){...}

Vous avez raison, donc c'est la seule exception:

async des gestionnaires d'événement peut retourner void

Donc en cliquant sur le bouton, la async gestionnaire d'événement conserver l'INTERFACE utilisateur réactive:

private async void OnButton1_Clicked(object sender, ...)
{
    await this.UpdateForm();
}

Cependant, vous avez encore de déclarer le gestionnaire d'événements asynchrones

Beaucoup de .NET fonctions ont async versions de retour d'une Tâche ou d'une Tâche<TResult>.

Il y a async fonctions pour
- L'accès à Internet
- Flux de Lecture et d'Écriture
- Base de données access
- etc.

À utiliser vous n'avez pas à appeler de la Tâche.Terme, ils sont déjà de retour Tâche<TResult> il suffit de les appeler, de continuer à faire vos propres trucs et quand vous avez besoin d'une réponse attendent pour la Tâche et l'utilisation de la TResult.

Lancer plusieurs tâches et d'attendre pour eux de terminer
Si vous commencez à plusieurs tâches et vous voulez attendre pour tous à la fin, utilisez la Tâche.WhenAll(...) PAS la Tâche.Attendre

Tâche.Attendre renvoie un void. De la tâche.WhenAll retourne une Tâche, de sorte que vous pouvez attendre.

Une fois qu'une tâche est terminée, la valeur de retour est déjà le retour de l'attendent, mais si vous y attendent Tâche.WhenAll ( nouvelle Tâche[]{TaskA, TaskB, TaskC});
vous devez utiliser la Tâche<TResult>.Résultat de la propriété de connaître le résultat d'une tâche:

int a = TaskA.Result;

Si l'une des tâches déclenche une exception, il est enveloppé comme InnerExceptions dans un AggregateException. Donc, si vous attendez de la Tâche.WhenAll, être prêt à attraper le AggregateException et vérifier la innerExceptions pour voir toutes les exceptions levées par les tâches que vous avez commencé. Utiliser la fonction AggregateException.Aplatissez-la pour accéder à l'exceptions de plus en plus facilement.

Intéressant de lire à propos de l'annulation:

MSDN à propos de l'Annulation dans la gestion des threads

Enfin: vous utilisez du Fil.Le sommeil(...). La version asynchrone est la Tâche.Delay(Délai):

private async Task`<int`> MySlowAdd(int a, int b)
{
    await Task.Delay(TimeSpan.FromSeconds(5));
    return a+b;
}

Si vous utilisez cette fonction de votre programme de garde adapté.

OriginalL'auteur Harald Coppoolse