Résoudre les erreurs et les avertissements dans les méthodes asynchrones qui utilisent l’opérateur Await

Cet article traite des erreurs suivantes du compilateur :

• CS1983 : Étant donné qu’il s’agit d’une méthode asynchrone, l’expression de retour doit être de type «T » plutôt que «Task<T> ».
• CS1985 : Impossible d'utiliser 'await' dans un bloc catch.
• CS1986 : 'await' exige que le type ait une méthode 'GetAwaiter' appropriée.
• CS1989 : Les expressions lambda asynchrones ne peuvent pas être converties en arborescences d’expressions.
• CS1991 : « Type » ne peut pas implémenter « événement », car il s’agit d’un événement Windows Runtime et « événement » est un événement .NET standard.
• CS1992 : L’opérateur 'await' ne peut être utilisé que lorsqu’il est contenu dans une méthode ou une expression lambda marquée avec le modificateur 'async'.
• CS1994 : Le modificateur 'async' ne peut être utilisé que dans les méthodes qui ont un corps.
• CS1995 : L’opérateur 'await' peut uniquement être utilisé dans une expression de requête dans la première expression de collection de la clause 'from' initiale ou dans l’expression de collection d’une clause 'join' .
• CS1996 : Impossible d’attendre dans le corps d’une instruction de verrouillage.
• CS1997 : Étant donné que la fonction est une méthode asynchrone qui retourne une valeur, un mot clé de retour ne doit pas être suivi d’une expression d’objet.
• CS1998 : cette méthode asynchrone n’a pas d’opérateurs «await » et s’exécute de manière synchrone. Envisagez d’utiliser l’opérateur «await » pour attendre des appels d’API non bloquants, ou «await Task.Run(...) pour effectuer un travail lié au processeur sur un thread d’arrière-plan.
• CS4001 : Impossible d’attendre l’expression.
• CS4003 : 'await' ne peut pas être utilisé comme identificateur dans une méthode asynchrone ou une expression lambda.
• CS4005 : Les méthodes asynchrones ne peuvent pas avoir de paramètres de type pointeur.
• CS4006 : __arglist n’est pas autorisé dans la liste de paramètres des méthodes asynchrones.
• CS4007 : L’instance de type ne peut pas être conservée sur la limite «await » ou «yield ».
• CS4008 : Impossible d’attendre 'void'.
• CS4009 : un point d’entrée vide ou int ne peut pas être asynchrone.
• CS4010 : Impossible de convertir l’expression asynchrone en type délégué. Une expression asynchrone peut retourner void, Task ou Task<T>, dont aucune n’est convertible en type.
• CS4011 : 'await' exige que le type de retour '{1}. GetAwaiter()' dispose de membres « IsCompleted », « OnCompleted » et « GetResult » appropriés, et implémentez « INotifyCompletion » ou « ICriticalNotifyCompletion ».
• CS4012 : Les paramètres de type ne peuvent pas être déclarés dans des méthodes asynchrones ou des expressions lambda asynchrones.
• CS4014 : Étant donné que cet appel n’est pas attendu, l’exécution de la méthode actuelle se poursuit avant la fin de l’appel. Envisagez d’appliquer l’opérateur await au résultat de l’appel.
• CS4015 : « MethodImplOptions.Synchronized » ne peut pas être appliqué à une méthode asynchrone.
• CS4016 : Étant donné qu’il s’agit d’une méthode asynchrone, l’expression de retour doit être d’un type qui ressemble à une tâche (task-like type) plutôt qu’au type déclaré.
• CS4027 : Le type d’expression n’implémente pas le membre requis.
• CS4028 : 'await' exige que le type dispose d’une méthode « GetAwaiter » appropriée. Vous ne disposez pas d’une directive d’utilisation pour « System » ?
• CS4029 : Impossible de retourner une expression de type 'void'.
• CS4030 : L’attribut de sécurité ne peut pas être appliqué à une méthode Async.
• CS4031 : Les méthodes asynchrones ne sont pas autorisées dans une interface, une classe ou une structure qui a l’attribut « SecurityCritical » ou « SecuritySafeCritical ».
• CS4032 : L’opérateur 'await ne peut être utilisé que dans une méthode asynchrone. Envisagez de marquer cette méthode avec le modificateur « async » et de remplacer son type de retour par «Task<T> ».
• CS4033 : L’opérateur 'await ne peut être utilisé que dans une méthode asynchrone. Envisagez de marquer cette méthode avec le modificateur «async » et de remplacer son type de retour par «Task ».
• CS4034 : L’opérateur 'await ne peut être utilisé que dans une méthode asynchrone. Envisagez de marquer cette méthode avec le modificateur « async ».
• CS8031 : L’expression lambda asynchrone convertie en délégué retournant une tâche ne peut pas retourner une valeur.
• CS8100 : L’opérateur 'await' ne peut pas être utilisé dans un initialiseur de variable de script statique.
• CS8177 : Les méthodes asynchrones ne peuvent pas avoir de variables locales par référence.
• CS8178 : Une référence retournée par un appel à la méthode ne peut pas être conservée sur la limite «await » ou «yield ».
• CS8204 : Pour que le type soit utilisé comme AsyncMethodBuilder pour la cible de type, sa propriété Task doit retourner le type cible au lieu du type déclaré.
• CS8403 : La méthode avec un bloc itérateur doit être «async » pour retourner IAsyncEnumerable<T>.
• CS8411 : L’instruction foreach asynchrone ne peut pas fonctionner sur des variables de type, car le type ne contient pas de définition d’instance publique ou d’extension appropriée pour le membre requis.
• CS8892 : La méthode n’est pas utilisée comme point d’entrée, car un point d’entrée synchrone a été trouvé.
• CS8935 : L’attribut AsyncMethodBuilder n’est pas autorisé sur les méthodes anonymes sans type de retour explicite.
• CS8940 : Un type de retour générique de type tâche était attendu, mais le type trouvé dans l’attribut « AsyncMethodBuilder » n’était pas approprié. Il doit s’agir d’un type générique indépendant d’arité, et son type contenant (le cas échéant) doit être non générique.
• CS9123 : L’opérateur '&' ne doit pas être utilisé sur les paramètres ou les variables locales dans les méthodes asynchrones.
• CS9330 : 'MethodImplAttribute.Async' ne peut pas être appliqué manuellement aux méthodes. Marquez la méthode « async ».

Conditions requises pour l’expression Await

• CS1985 : Impossible d'utiliser await dans une instruction catch.
• CS1986 : 'await' exige que le type ait une méthode 'GetAwaiter' appropriée.
• CS1992 : L’opérateur 'await' ne peut être utilisé que lorsqu’il est contenu dans une méthode ou une expression lambda marquée avec le modificateur 'async' .
• CS1995 : L’opérateur 'await' peut uniquement être utilisé dans une expression de requête dans la première expression de collection de la clause 'from' initiale ou dans l’expression de collection d’une clause 'join' .
• CS1996 : Impossible d’attendre dans le corps d’une instruction de verrouillage.
• CS4008 : Impossible d’attendre 'void'.
• CS4032 : L’opérateur 'await ne peut être utilisé que dans une méthode asynchrone. Envisagez de marquer cette méthode avec le modificateur «async » et de remplacer son type de retour par «Task<T> ».
• CS4033 : L’opérateur 'await ne peut être utilisé que dans une méthode asynchrone. Envisagez de marquer cette méthode avec le modificateur «async » et de remplacer son type de retour par «Task ».
• CS4034 : L’opérateur 'await ne peut être utilisé que dans une méthode asynchrone. Envisagez de marquer cette méthode avec le modificateur « async ».
• CS8178 : Une référence retournée par cet appel ne peut pas être conservée sur la limite «await » ou «yield ».
• CS8411 : L’instruction foreach asynchrone ne peut pas fonctionner sur des variables de type, car le type ne contient pas de définition d’instance publique ou d’extension appropriée pour le membre requis.
• CS4001 : Impossible d’attendre l’expression.
• CS4003 : 'await' ne peut pas être utilisé comme identificateur dans une méthode asynchrone ou une expression lambda.
• CS4007 : L’instance de type ne peut pas être conservée sur la limite «await » ou «yield ».
• CS4011 : '' exige que le type de retour de 'GetAwaiter()' possède les membres appropriés 'IsCompleted', 'OnCompleted' et 'GetResult', et implémente 'INotifyCompletion' ou 'ICriticalNotifyCompletion'.
• CS4027 : Le type n’implémente pas le membre requis.
• CS4028 : 'await' exige que le type dispose d’une méthode « GetAwaiter » appropriée. Vous ne disposez pas d’une directive d’utilisation pour « System » ?
• CS8100 : L’opérateur 'await' ne peut pas être utilisé dans un initialiseur de variable de script statique.

Les éléments suivants expliquent comment corriger chaque erreur. Pour plus d’informations sur l’opérateur await et le modèle awaiter, consultez Programmation asynchrone avec async et await.

• Ajoutez le async modificateur à la méthode ou à l’expression lambda qui contient l’expression await (CS1992, CS4032, CS4033, CS4034). Le compilateur requiert le async modificateur afin qu’il puisse générer l’ordinateur d’état qui gère la suspension et la reprise asynchrones. Les trois variantes de cette erreur fournissent des suggestions spécifiques au contexte pour le type de retour correct.
• Déplacez les expressions hors des blocs await lorsque vous ciblez C# 5 ou une version antérieure catch (CS1985). À partir de C# 6, le compilateur prend en charge await dans les blocs catch et finally. Cette erreur n’est plus produite en C# 6 et versions ultérieures.
• Déplacer des await expressions hors des blocs de déclarationslock (CS1996). La suspension de manière asynchrone pendant le maintien d'un verrou entraîne un risque d'interblocages. Le verrou est conservé entre les commutateurs de thread où d’autres codes peuvent attendre le même verrou.
• Restructurez les expressions de requête afin qu’elles await apparaissent uniquement dans la première expression de collection de la clause initiale from ou dans l’expression de collection d’une join clause (CS1995). D’autres clauses de requête se traduisent en expressions lambda qui ne prennent pas en charge la suspension asynchrone.
• Modifiez le type de l’expression attendue afin qu’elle expose une méthode accessible GetAwaiter() qui suit le modèle awaiter (CS1986, CS4028). Le type peut implémenter le modèle directement ou via une méthode d’extension. Si la méthode GetAwaiter existe, mais que vous n'avez pas de directive using pour System, le compilateur produit le message plus spécifique CS4028 au lieu de CS1986.
• Vérifiez que le type awaiter retourné par GetAwaiter() a IsCompleted, OnCompleted, et GetResult membres et implémente INotifyCompletion ou ICriticalNotifyCompletion (CS4011, CS4027). L’expressionawait dépend de ces membres pour vérifier l’état d’achèvement, inscrire des continuations et récupérer les résultats.
• Modifiez le type void de retour de la méthode appelée vers Task ou Task<TResult> pour que le résultat puisse être attendu (CS4008). Vous ne pouvez pas attendre l'exécution d'une méthode void qui renvoie une valeur, car il n'existe pas de tâche pour suivre l'achèvement ou propager des exceptions.
• Remplacez l’expression attendue par un type qui prend en charge le modèle awaiter (CS4001). Les types tels que int, stringet d’autres types intégrés n’ont pas de GetAwaiter méthode et ne peuvent pas être attendus directement.
• Stockez le résultat d’un appel de méthode de retour ref dans une variable locale avant d’utiliser await (CS8178). Une référence retournée par une méthode ne peut pas être conservée sur une await limite, car l’ordinateur d’état asynchrone peut suspendre et reprendre sur un autre thread ou contexte, invalidant la référence.
• Implémentez IAsyncEnumerable<T> sur le type de collection ou ajoutez une méthode accessible GetAsyncEnumerator qui retourne un type avec des Current et des MoveNextAsync membres (CS8411). L’instructionawait foreach nécessite que le type de collection suive le modèle énumérable asynchrone.
• Renommez une variable ou un paramètre local nommé await à l’intérieur d’une méthode ou d’une async expression lambda (CS4003). Dans les contextes asynchrones, await il s’agit d’un mot clé contextuel qui ne peut pas être utilisé comme identificateur.
• Déplacez l’expression await hors de l’initialiseur de variable de script statique et dans un corps de méthode (CS8100). Les initialiseurs statiques s’exécutent en dehors d’un contexte asynchrone. await Il n’est donc pas disponible à cet emplacement.
• Restructurez le code de sorte que les instances de ref struct n'aient pas besoin d'être préservées à travers une limite await ou yield (CS4007). La machine à état asynchrone stocke les variables locales sur le tas et ref struct les types sont conçus pour être liés à la pile. Ils ne peuvent pas être déplacés en toute sécurité vers le stockage sur tas à travers les points de suspension.

Exigences de signature de méthode asynchrone

• CS1983 : Étant donné qu’il s’agit d’une méthode asynchrone, l’expression de retour doit être de type « T » plutôt que « ».Task<T>
• CS1994 : Le modificateur 'async' ne peut être utilisé que dans les méthodes qui ont un corps.
• CS4009 : un point d’entrée vide ou int ne peut pas être asynchrone.
• CS8892 : La méthode n’est pas utilisée comme point d’entrée, car un point d’entrée synchrone a été trouvé.
• CS8935 : L’attribut AsyncMethodBuilder n’est pas autorisé sur les méthodes anonymes sans type de retour explicite.
• CS8940 : Un type de retour générique de type tâche était attendu, mais le type trouvé dans l’attribut « AsyncMethodBuilder » n’était pas approprié. Il doit s’agir d’un type générique sans paramètre de type, avec une arité de un, et son type englobant (s’il existe) doit être non générique.
• CS8403 : La méthode avec un bloc itérateur doit être «async » pour retourner «{1} ».
• CS9330 : 'MethodImplAttribute.Async' ne peut pas être appliqué manuellement aux méthodes. Marquez la méthode 'async'.
• CS4005 : Les méthodes asynchrones ne peuvent pas avoir de paramètres de type pointeur.
• CS4006 : __arglist n’est pas autorisé dans la liste de paramètres des méthodes asynchrones.
• CS4010 : Impossible de convertir le lambda asynchrone en type délégué. Un lambda asynchrone peut retourner void, Task ou Task<T>, dont aucun n’est convertible pour le type de retour.
• CS4012 : Les paramètres de type ne peuvent pas être déclarés dans des méthodes asynchrones ou des expressions lambda asynchrones.
• CS4015 : « MethodImplOptions.Synchronized » ne peut pas être appliqué à une méthode asynchrone.
• CS4016 : Étant donné qu’il s’agit d’une méthode asynchrone, l’expression de retour doit être de type de tâche plutôt que de type.
• CS8031 : L’expression lambda asynchrone convertie en délégué retournant une tâche ne peut pas retourner une valeur.
• CS8204 : Pour que le type soit utilisé comme AsyncMethodBuilder pour le type, sa propriété Task doit retourner le type obligatoire au lieu du type déclaré.

Les éléments suivants expliquent comment corriger chaque erreur. Pour plus d’informations sur les déclarations de méthode asynchrone, consultez le modificateur et les asynctypes de retour asynchrones.

• Modifiez l’expression de retour pour qu’elle corresponde au type de résultat sous-jacent de la méthode async (CS1983, CS4016). Lorsqu’une méthode asynchrone retourne Task<T>, l’instruction return doit fournir une valeur de type T, et non Task<T>, car la machine à état générée par le compilateur encapsule automatiquement la valeur dans une tâche. CS1983 s’affiche lorsque la méthode retourne Task<T> et que l’expression est T; CS4016 couvre le cas général où le type d’expression de retour ne correspond pas.
• Supprimez le async modificateur des méthodes qui n’ont pas de corps, comme les méthodes abstraites ou les déclarations de méthode d’interface (CS1994). Le async modificateur nécessite un corps de méthode afin que le compilateur puisse générer l’implémentation de l’ordinateur d’état.
• Modifiez le type de retour d’un point d’entrée asynchrone vers Task ou Task<TResult> (CS4009). À partir de C# 7.1, la Main méthode peut être async, mais elle doit retourner Task ou Task<int> - async void, et async int ne sont pas des signatures de point d’entrée valides.
• Supprimez ou renommez un point d’entrée lorsque le projet contient à la fois une méthode synchrone et asynchrone Main (CS8892). Le compilateur sélectionne le point d’entrée synchrone et émet cet avertissement pour le candidat asynchrone qu’il ignore.
• Ajoutez un type de retour explicite à l’expression lambda avant d’appliquer l’attribut [AsyncMethodBuilder] (CS8935). Le compilateur ne peut pas résoudre le type de générateur pour une méthode anonyme dont le type de retour est déduit, car l’attribut doit être mis en correspondance avec un type de retour spécifique au moment de la compilation.
• Remplacez le type spécifié dans l'attribut [AsyncMethodBuilder] par un type générique non lié d'arité un, tel que MyTaskMethodBuilder<>, plutôt qu'un MyTaskMethodBuilder<T> ou un type non générique (CS8940). Le type contenant le générateur, le cas échéant, doit également être non générique. Le compilateur requiert cette forme afin qu’elle puisse construire le générateur pour n’importe quel type de retour concret de type de tâche.
• Remplacez l’attribut manuel [MethodImpl(MethodImplOptions.Async)] par le async mot clé de la déclaration de méthode (CS9330). L’indicateur MethodImplOptions.Async est réservé à l’utilisation interne du runtime et ne peut pas être appliqué directement dans le code utilisateur.
• Ajoutez le async modificateur aux méthodes qui contiennent des blocs itérateurs et retournent IAsyncEnumerable<T> ou IAsyncEnumerator<T> (CS8403). Sans le async modificateur, le compilateur traite la méthode comme un itérateur synchrone et ne peut pas générer l’ordinateur d’état de flux asynchrone.
• Supprimez les paramètres de type pointeur des méthodes asynchrones (CS4005). Les pointeurs référencent des emplacements de mémoire fixe qui ne peuvent pas être conservés en toute sécurité sur des points de suspension asynchrones où l’exécution peut reprendre sur un autre thread.
• Supprimer __arglist des listes de paramètres de méthode asynchrone (CS4006). Les listes d’arguments de longueur variable dépendent des conventions d’appel basées sur la pile, qui ne sont pas compatibles avec la machine à états asynchrone allouée sur le tas.
• Supprimez les paramètres ref, in ou out, et les paramètres des types ref struct tels que Span<T> ou ReadOnlySpan<T>, des méthodes asynchrones ou des expressions lambda asynchrones (CS4012). Ces types de paramètres sont liés à la pile et ne peuvent pas être capturés en toute sécurité dans la fermeture de la machine à état asynchrone allouée au tas.
• Modifiez le type de délégué de destination pour qu’il corresponde au type de retour de lambda asynchrone (CS4010). Une lambda asynchrone peut retourner void, Taskou , et Task<TResult>le compilateur ne peut pas les convertir en types délégués arbitraires qui attendent différents types de retour.
• Supprimez l'expression return d'une lambda asynchrone affectée à un délégué non générique qui retourne un Task, ou modifiez le type du délégué en Func<Task<T>> afin que la lambda puisse retourner une valeur (CS8031). Un délégué non générique Task-retournant représente une opération asynchrone sans résultat, de sorte que le retour d’une valeur est une incompatibilité de type.
• Supprimez l’attribut [MethodImpl(MethodImplOptions.Synchronized)] des méthodes asynchrones (CS4015). L’option Synchronized acquiert un verrou pour l’exécution de la méthode entière, mais une méthode asynchrone suspend et reprend potentiellement sur différents threads, ce qui rend la sémantique de verrou non définie.
• Corrigez le type personnalisé AsyncMethodBuilder afin que sa Task propriété retourne le même type que le type de retour déclaré de la méthode async (CS8204). Le compilateur utilise la propriété du Task générateur pour obtenir l’objet de tâche final. Par conséquent, une incompatibilité de type empêche l’ordinateur d’état de fonctionner correctement.

Pratiques asynchrones

• CS1989 : Les expressions lambda asynchrones ne peuvent pas être converties en arborescences d’expressions.
• CS1991 : « Type » ne peut pas implémenter « événement », car il s’agit d’un événement Windows Runtime et « événement » est un événement .NET standard.
• CS1997 : Étant donné que la fonction est une méthode asynchrone qui retourne une valeur, un mot clé de retour ne doit pas être suivi d’une expression d’objet.
• CS1998 : cette méthode asynchrone n’a pas d’opérateurs «await » et s’exécute de manière synchrone. Envisagez d’utiliser l’opérateur «await » pour attendre des appels d’API non bloquants, ou «await Task.Run(...) pour effectuer un travail lié au processeur sur un thread d’arrière-plan.
• CS4014 : Étant donné que cet appel n’est pas attendu, l’exécution de la méthode actuelle se poursuit avant la fin de l’appel. Envisagez d’appliquer l’opérateur await au résultat de l’appel.
• CS8177 : Les méthodes asynchrones ne peuvent pas avoir de locals de référence.
• CS9123 : L’opérateur '&' ne doit pas être utilisé sur les paramètres ou les variables locales dans les méthodes asynchrones.
• CS4029 : Impossible de retourner une expression de type 'void'.
• CS4030 : L’attribut de sécurité ne peut pas être appliqué à une méthode Async.
• CS4031 : Les méthodes asynchrones ne sont pas autorisées dans une interface, une classe ou une structure qui a l’attribut « SecurityCritical » ou « SecuritySafeCritical ».

Les éléments suivants expliquent comment corriger chaque erreur. Pour plus d’informations, consultez Programmation asynchrone avec async et await et l’opérateurawait.

• Ajoutez l’opérateur await à chaque appel qui retourne Task ou Task<TResult>, ou ignorez explicitement le résultat avec _ = si le comportement "fire-and-forget" est vraiment prévu (CS4014). Sans await, toute exception levée par l’opération asynchrone est perdue de manière silencieuse, et la méthode appelante continue de s’exécuter avant la fin de l’opération, ce qui peut entraîner des bogues subtils d'ordre et de précision.
• Supprimez l’expression d’une méthode asynchrone dont le return type de retour est Task (non générique) ou modifiez le type Task<T> de retour lorsque la méthode doit retourner une valeur (CS1997). Dans une méthode asynchrone qui retourne Task, le compilateur génère le wrapper de tâche : le renvoi d’une valeur est une incompatibilité de type, car la signature de méthode ne promet aucun résultat.
• Ajoutez au moins une await expression au corps de la méthode, ou supprimez le async modificateur et renvoyez la tâche directement (CS1998). Une async méthode sans aucune expression s’exécute await entièrement de manière synchrone, ce qui ajoute une surcharge inutile de l’ordinateur d’état. Si la méthode encapsule intentionnellement une opération synchrone, la suppression async et le renvoi de la tâche élimine explicitement cette surcharge.
• Réécrire l’expression lambda afin qu’elle n’utilise async pas lorsqu’elle est affectée à un type d’arborescence d’expressions comme Expression<Func<...>> (CS1989). Les arborescences d’expressions représentent du code sous forme de structures de données que le compilateur peut analyser ou traduire, mais la machine d’état complexe qui async produit ne peut pas être capturée dans une arborescence d’expressions.
• Modifiez l’implémentation d’événement afin que la déclaration d’interface et la classe d’implémentation acceptent si l’événement utilise la sémantique Windows Runtime ou la sémantique .NET régulière (CS1991). Cette erreur s’applique aux scénarios d’interopérabilité Windows Runtime où un événement WinRT ne peut pas être implémenté en tant qu’événement .NET normal ou inversement.
• Supprimez l’adresse de l’opérateur (&) des expressions qui référencent des paramètres ou des variables locales à l’intérieur de méthodes asynchrones (CS9123). La machine à états asynchrone peut déplacer des variables capturées vers le tas lors de la suspension, ce qui invaliderait tout pointeur obtenu par adressage.
• Supprimez les variables locales de référence des méthodes asynchrones ou assurez-vous qu’elles ne s’étendent pas sur une await limite (CS8177). La machine à état asynchrone prend en charge les variables locales dans les fermetures allouées au tas, et les références aux emplacements de pile ne peuvent pas être conservées en toute sécurité entre les points de suspension. En C# 13 et versions ultérieures, les variables locales ref sont autorisées dans les méthodes asynchrones tant qu'elles ne franchissent pas une limite de contexte await et que cette erreur n'est pas générée.
• Supprimez l’instruction return qui retourne le résultat d’une voidméthode -return, ou modifiez la méthode appelée pour renvoyer une valeur (CS4029). Vous ne pouvez pas utiliser return SomeVoidMethod(); , car void n’est pas un type qui peut être retourné en tant que valeur. Supprimez le return mot clé et appelez la méthode en tant qu’instruction autonome, ou modifiez la signature de la méthode appelée pour retourner un type concret.
• Supprimez les attributs de sécurité tels [SecurityCritical] ou [SecuritySafeCritical] des méthodes asynchrones (CS4030), ou supprimez le async modificateur des méthodes dans les types marqués avec ces attributs (CS4031). Les annotations de sécurité d’accès au code s’appliquent à la méthode déclarante, mais la machine d’état asynchrone générée par le compilateur s’exécute dans un contexte distinct où ces annotations de sécurité ne peuvent pas être appliquées.