Meilleure pratique pour appeler ConfigureAwait pour tout le code côté serveur

Lorsque vous avez du code côté serveur (c'est-à-dire certains ApiController) et que vos fonctions sont asynchrones - donc elles reviennent Task<SomeObject>- est-il considéré comme une meilleure pratique que chaque fois que vous attendez des fonctions que vous appelez ConfigureAwait(false)?

J'avais lu qu'il est plus performant car il n'a pas à basculer les contextes de thread vers le contexte de thread d'origine. Cependant, avec ASP.NET Web Api, si votre demande arrive sur un thread et que vous attendez une fonction et un appel ConfigureAwait(false)qui pourraient potentiellement vous mettre sur un thread différent lorsque vous renvoyez le résultat final de votre ApiControllerfonction.

J'ai tapé un exemple de ce dont je parle ci-dessous:

public class CustomerController : ApiController
{
    public async Task<Customer> Get(int id)
    {
        // you are on a particular thread here
        var customer = await SomeAsyncFunctionThatGetsCustomer(id).ConfigureAwait(false);

        // now you are on a different thread!  will that cause problems?
        return customer;
    }
}

Mise à jour: ASP.NET Core n'a pas deSynchronizationContext . Si vous êtes sur ASP.NET Core, peu importe que vous l'utilisiez ConfigureAwait(false)ou non.

Pour ASP.NET "Full" ou "Classic" ou autre, le reste de cette réponse s'applique toujours.

Message d'origine (pour ASP.NET non-Core):

Cette vidéo de l'équipe ASP.NET contient les meilleures informations sur l'utilisation asyncsur ASP.NET.

J'avais lu qu'il est plus performant car il n'a pas à basculer les contextes de thread vers le contexte de thread d'origine.

Cela est vrai avec les applications d'interface utilisateur, où il n'y a qu'un seul thread d'interface utilisateur sur lequel vous devez "synchroniser".

Dans ASP.NET, la situation est un peu plus complexe. Lorsqu'une asyncméthode reprend l'exécution, elle récupère un thread du pool de threads ASP.NET. Si vous désactivez la capture de contexte à l'aide ConfigureAwait(false), le thread continue simplement d'exécuter la méthode directement. Si vous ne désactivez pas la capture de contexte, le thread ré-entrera dans le contexte de la demande et continuera ensuite à exécuter la méthode.

Donc, ConfigureAwait(false)ne vous enregistre pas un saut de fil dans ASP.NET; cela vous évite de rentrer dans le contexte de la demande, mais cela est normalement très rapide. ConfigureAwait(false) pourrait être utile si vous essayez de faire une petite quantité de traitement parallèle d'une demande, mais en réalité, TPL est mieux adapté à la plupart de ces scénarios.

Cependant, avec ASP.NET Web Api, si votre demande arrive sur un thread et que vous attendez une fonction et appelez ConfigureAwait (false) qui pourrait potentiellement vous mettre sur un autre thread lorsque vous renvoyez le résultat final de votre fonction ApiController .

En fait, juste faire un awaitpeut le faire. Une fois que votre asyncméthode atteint un await, la méthode est bloquée mais le thread retourne au pool de threads. Lorsque la méthode est prête à continuer, tout thread est extrait du pool de threads et utilisé pour reprendre la méthode.

La seule différence ConfigureAwaitdans ASP.NET est de savoir si ce thread entre dans le contexte de la demande lors de la reprise de la méthode.

J'ai plus d'informations de fond dans mon article MSDN surSynchronizationContext et mon asyncblog d'introduction .

Réponse brève à votre question: Non. Vous ne devriez pas appeler ConfigureAwait(false)au niveau de l'application comme ça.

Version TL; DR de la réponse longue: Si vous écrivez une bibliothèque où vous ne connaissez pas votre consommateur et n'avez pas besoin d'un contexte de synchronisation (ce que vous ne devriez pas dans une bibliothèque, je crois), vous devez toujours utiliser ConfigureAwait(false). Sinon, les consommateurs de votre bibliothèque peuvent faire face à des blocages en consommant vos méthodes asynchrones de manière bloquante. Cela dépend de la situation.

Voici une explication un peu plus détaillée sur l'importance de la ConfigureAwaitméthode (une citation de mon article de blog):

Lorsque vous attendez une méthode avec le mot-clé wait, le compilateur génère un tas de code en votre nom. L'un des objectifs de cette action est de gérer la synchronisation avec le thread d'interface utilisateur (ou principal). Le composant clé de cette fonctionnalité est celui SynchronizationContext.Currentqui obtient le contexte de synchronisation pour le thread actuel. SynchronizationContext.Currentest rempli en fonction de l'environnement dans lequel vous vous trouvez. La GetAwaiterméthode de tâche recherche SynchronizationContext.Current. Si le contexte de synchronisation actuel n'est pas nul, la continuation qui est transmise à ce serveur sera renvoyée dans ce contexte de synchronisation.

Lorsque vous consommez une méthode, qui utilise les nouvelles fonctionnalités du langage asynchrone, de manière bloquante, vous vous retrouverez avec un blocage si vous avez un SynchronizationContext disponible. Lorsque vous consommez de telles méthodes de manière bloquante (en attente de la méthode Task with Wait ou en prenant le résultat directement à partir de la propriété Result de la tâche), vous bloquerez le thread principal en même temps. Lorsque finalement la tâche se termine à l'intérieur de cette méthode dans le pool de threads, elle va invoquer la continuation pour publier sur le thread principal car elle SynchronizationContext.Currentest disponible et capturée. Mais il y a un problème ici: le thread de l'interface utilisateur est bloqué et vous avez un blocage!

En outre, voici deux excellents articles pour vous qui sont exactement pour votre question:

• La recette parfaite pour se tirer une balle dans le pied - se retrouver avec un blocage à l'aide des fonctionnalités du langage asynchrone C # 5.0
• Bibliothèques de clients .NET asynchrones pour votre API HTTP et sensibilisation aux mauvais effets de async / attendent

Enfin, il y a une excellente courte vidéo de Lucian Wischik sur ce sujet: les méthodes de bibliothèque asynchrone devraient envisager d'utiliser Task.ConfigureAwait (false) .

J'espère que cela t'aides.

Le plus grand inconvénient que j'ai trouvé avec l'utilisation de ConfigureAwait (false) est que la culture de thread est rétablie par défaut. Si vous avez configuré une culture, par exemple ...

<system.web>
    <globalization culture="en-AU" uiCulture="en-AU" />    
    ...

et que vous hébergez sur un serveur dont la culture est définie sur en-US, vous trouverez avant que ConfigureAwait (false) ne s'appelle CultureInfo.CurrentCulture renverra en-AU et après que vous obtiendrez en-US. c'est à dire

// CultureInfo.CurrentCulture ~ {en-AU}
await xxxx.ConfigureAwait(false);
// CultureInfo.CurrentCulture ~ {en-US}

Si votre application fait quelque chose qui nécessite un formatage de données spécifique à la culture, vous devrez en être conscient lors de l'utilisation de ConfigureAwait (false).

J'ai quelques réflexions générales sur la mise en œuvre de Task:

1. La tâche est jetable mais nous ne sommes pas censés l' utiliser using.
2. ConfigureAwaita été introduit en 4.5. Taska été introduit en 4.0.
3. Les threads .NET sont toujours utilisés pour faire circuler le contexte (voir C # via le livre CLR), mais dans l'implémentation par défaut, Task.ContinueWithils ne sont pas b / c, il a été réalisé que le changement de contexte est coûteux et il est désactivé par défaut.
4. Le problème est qu'un développeur de bibliothèque ne devrait pas se soucier de savoir si ses clients ont besoin d'un flux de contexte ou non, il ne doit donc pas décider si le flux doit être déplacé ou non.
5. [Ajouté plus tard] Le fait qu'il n'y ait pas de réponse faisant autorité et de référence appropriée et que nous continuons à nous battre sur cela signifie que quelqu'un n'a pas fait son travail correctement.

J'ai quelques articles sur le sujet, mais mon point de vue - en plus de la belle réponse de Tugberk - est que vous devez activer toutes les API asynchrones et idéalement gérer le contexte. Puisque vous effectuez une async, vous pouvez simplement utiliser des continuations au lieu d'attendre, donc aucun blocage ne sera causé car aucune attente n'est effectuée dans la bibliothèque et vous gardez le flux afin que le contexte soit préservé (tel que HttpContext).

Le problème est lorsqu'une bibliothèque expose une API synchrone mais utilise une autre API asynchrone - vous devez donc utiliser Wait()/ Resultdans votre code.