Quelle est la principale différence entre `attendre tâche.run (); return; `et` retour tâche.run () `en programmation asynchrone C #, et comment cela a un impact sur la gestion des exceptions?

Les principales différences entre await Task.Run(); return; et return Task.Run() dans la programmation asynchrone et l'impact sur le traitement anormal

Différences du concept

La principale différence entre les deux fragments de code est une communication anormale. Dans la version "", les anomalies lancées dans la tâche seront capturées et stockées dans l'objet de tâche retourné. En attendant la tâche, des anomalies seront réparties. Au contraire, la version "" n'attend pas la tâche, donc aucune anomalie lancée ne sera capturée, mais la lancera immédiatement sur l'appel.

Génération de code await Task.Run(); return; return Task.Run();

Le code généré par ces deux fragments de code est différent. Dans la version "", le compilateur génère une machine d'état pour emballer les opérations asynchrones, y compris la gestion des conditions anormales. La version "" ne génère pas de machine d'état car elle n'attend aucune opération asynchrone.

Traitement anormal

Considérez l'exemple suivant: await Task.Run(); return; return Task.Run();

Si nous appelons , la version "

" lancera une exception lorsque vous attendez la tâche. Cependant, si nous appelons , l'exception sera lancée immédiatement. (Supposons que la fonction soit correctement gérée anormale).

Méthode vide asynchrone

<code class="language-csharp">static async Task OneTestAsync(int n)
{
    await Task.Delay(n);
}

static Task AnotherTestAsync(int n)
{
    return Task.Delay(n);
}</code>

Pour la méthode vide asynchrone, la logique de la communication anormale est différente. S'il existe, les anomalies lancées dans la méthode du vide asynchrones seront jetées dans le contexte du fil actuel. Sinon, ils seront jetés à travers , et l'appelant ne peut pas les gérer sur les mêmes cadres de pile.

DoTestAsync(OneTestAsync, -2) Simulation Asynchrone Dissémination anormale await DoTestAsync(AnotherTestAsync, -2) DoTestAsync Vous pouvez utiliser une technique pour simuler le comportement de communication anormal des méthodes asynchrones.

Dans cet exemple, des anomalies seront lancées à l'intérieur de la tâche, puis se propagent dans l'objet , similaire à la situation de .

La possibilité de verrous morts ThreadPool.QueueUserWorkItem

La version asynchrone / en attente est plus facile à se produire dans le contexte de synchronisation non-défaut. Par exemple, le code suivant se produira dans les applications WinForms ou WPF:

C'est parce que essayant d'attendre l'achèvement de l'opération asynchrone sur le thread d'interface utilisateur, et l'opération asynchrone elle-même doit également être exécutée sur le thread d'interface utilisateur, ce qui entraîne des serrures mortes.

En bref, await Task.Run(); return; fournit un traitement anormal structuré, et return Task.Run(); jette directement l'anomalie à la fête d'appel, et le parti d'appel doit être géré par eux-mêmes. La méthode à choisir dépend de votre stratégie de traitement anormale et de votre contexte de programme. await La version est plus sûre, mais il est nécessaire de considérer le problème potentiel de verrouillage mort; return Task.Run() plus concis, mais le traitement anormal nécessite plus de soins.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!