Résoudre les erreurs et les avertissements dans les expressions de correspondance de modèle

Cet article traite des erreurs et des avertissements suivants du compilateur :

• CS8116 : Il n’est pas légal d’utiliser un type Nullable dans un modèle ; utilisez plutôt le type sous-jacent.
• CS8117 : Opérande non valide pour la correspondance de modèle ; valeur requise, mais expression trouvée.
• CS8119 : L’expression de commutateur doit être une valeur ; expression trouvée.
• CS8120 : La casse de commutateur est inaccessible. Il a déjà été traité par un cas précédent ou il est impossible de faire correspondre.
• CS8121 : Une expression de type source ne peut pas être gérée par un modèle de type cible.
• CS8208 : Il n’est pas légal d’utiliser le type « dynamique » dans un modèle.
• CS8502 : La mise en correspondance du type tuple nécessite des sous-modèles notés, mais des sous-modèles incorrects sont présents.
• CS8503 : un sous-modèle de propriété nécessite une référence à la propriété ou au champ à mettre en correspondance, par exemple « {{ Name : value }} »
• CS8504 : Modèle manquant
• CS8505 : un littéral par défaut « default » n’est pas valide comme modèle. Utilisez un autre littéral (par exemple, « 0 » ou « null ») selon les besoins. Pour correspondre à tout, utilisez un modèle d’abandon '_'.
• CS8506 : Aucun type optimal n’a été trouvé pour l’expression switch.
• CS8508 : La syntaxe « var » d’un modèle n’est pas autorisée à faire référence à un type, mais var le type est dans l’étendue ici.
• CS8509 : l’expression switch ne gère pas toutes les valeurs possibles de son type d’entrée (il n’est pas exhaustif). Par exemple, le modèle '...' n’est pas couvert.
• CS8510 : Le motif est inaccessible. Il a déjà été géré par une branche précédente de l'expression de switch ou il est impossible à correspondre.
• CS8512 : le nom '_' fait référence à la constante, et non au modèle d’abandon. Utilisez « var _ » pour ignorer la valeur, ou « @_ » pour faire référence à une constante par ce nom.
• CS8513 : le nom '_' fait référence au type, et non au modèle _d’abandon. Utilisez « @_ » pour le type ou « var _ » pour ignorer.
• CS8515 : Les parenthèses sont requises autour de l’expression de gouvernance du commutateur.
• CS8516 : Le nom n’identifie pas un élément tuple '{1}'.
• CS8517 : Le nom ne correspond pas au paramètre « Déconstruct » correspondant.
• CS8518 : Une expression de ce type ne peut jamais correspondre au modèle fourni.
• CS8519 : L’expression donnée ne correspond jamais au modèle fourni.
• CS8520 : L’expression donnée correspond toujours à la constante fournie.
• CS8521 : La correspondance des modèles n’est pas autorisée pour les types de pointeur.
• CS8522 : Les noms d’éléments ne sont pas autorisés lors de la correspondance de modèle via « System.Runtime.CompilerServices.ITuple ».
• CS8523 : Le modèle d’abandon n’est pas autorisé en tant qu’étiquette de cas dans une instruction switch. Utilisez `case var _ :` pour un modèle d’abandon, ou `case @_ :` pour une constante nommée '_'.
• CS8524 : L’expression switch ne gère pas certaines valeurs de son type d’entrée (il n’est pas exhaustif) impliquant une valeur d’énumération non nommée.
• CS8525 : un indicateur de variable doit se présenter après un modèle de propriété.
• CS8780 : Une variable peut ne pas être déclarée dans un modèle « non » ou « ou ».
• CS8781 : Les modèles relationnels peuvent ne pas être utilisés pour une valeur de ce type.
• CS8782 : Les modèles relationnels peuvent ne pas être utilisés pour un naN à virgule flottante.
• CS8793 : L’expression donnée correspond toujours au modèle fourni.
• CS8794 : Une expression de type '{0}' correspond toujours au modèle fourni.
• CS8846 : L’expression switch ne gère pas toutes les valeurs possibles de son type d’entrée (il n’est pas exhaustif). Par exemple, ce modèle n’est pas couvert. Toutefois, un modèle avec une clause ' when' peut correspondre à cette valeur.
• CS8918 : Identificateur ou accès à un membre simple attendu.
• CS8978 : '...' ne peut pas être rendu nullable.
• CS8979 : Les modèles de liste ne peuvent pas être utilisés pour une valeur de type '...'.
• CS8980 : Les modèles de tranche ne peuvent être utilisés qu’une seule fois et directement à l’intérieur d’un modèle de liste.
• CS8985 : Les modèles de liste ne peuvent pas être utilisés pour une valeur de type '...'. Aucune propriété 'Length' ou 'Count' appropriée n’a été trouvée.
• CS9013 : Une constante « null » de chaîne n’est pas prise en charge comme modèle pour « ... ». Utilisez plutôt une chaîne vide.
• CS9060 : Impossible d’utiliser une constante numérique ou un modèle relationnel sur '...' car il hérite ou étend « INumberBase<T> ». Envisagez d’utiliser un modèle de type pour affiner un type numérique spécifique.
• CS9134 : Une branche d’expression switch ne commence pas par le mot clé « case ».
• CS9135 : une valeur constante de type est attendue
• CS9336 : Le modèle est redondant.
• CS9337 : Le modèle est trop complexe pour analyser la redondance.
• CS9344 : L’opérateur '==' n’est pas pris en charge dans un modèle.
• CS9345 : L’opérateur '!=' n’est pas pris en charge dans un modèle. Utilisez « not » pour représenter un modèle négatif.

Erreurs de syntaxe d’expression switch

• CS8119 : L’expression de commutateur doit être une valeur ; expression trouvée.
• CS8504 : Modèle manquant
• CS8505 : un littéral par défaut « default » n’est pas valide comme modèle. Utilisez un autre littéral (par exemple, « 0 » ou « null ») selon les besoins. Pour correspondre à tout, utilisez un modèle d’abandon '_'.
• CS8506 : Aucun type optimal n’a été trouvé pour l’expression switch.
• CS8515 : Les parenthèses sont requises autour de l’expression de gouvernance du commutateur.
• CS8523 : Le modèle d’abandon n’est pas autorisé en tant qu’étiquette de cas dans une instruction switch. Utilisez 'cas var _ :' pour un modèle d’abandon, ou 'cas @_ :' pour une constante nommée '_'.
• CS9134 : un bras d’expression switch ne commence pas par un mot clé « case ».
• CS9135 : une valeur constante de type est attendue
• CS9344 : L’opérateur '==' n’est pas pris en charge dans un modèle.
• CS9345 : L’opérateur ' !=' n’est pas pris en charge dans un modèle. Utilisez « pas » pour représenter un modèle négatif.

Fournissez une valeur en tant qu’expression contrôlante d’une instruction ou d’une switch expression (CS8119). L’expression de gouvernance doit produire une valeur. Les types, espaces de noms, groupes de méthodes et méthodes retournant void ne sont pas valides. Utilisez une expression qui s'évalue à une valeur.

Fournissez un modèle là où un est attendu (CS8504). Un bras de commutateur ou is une expression nécessite un modèle suivant la syntaxe appropriée. Veillez à inclure une expression de modèle valide.

N’utilisez pas le default littéral comme modèle (CS8505). Le default mot clé n’est pas valide dans la correspondance de modèle. Utilisez une valeur littérale spécifique comme 0 ou null à la place, ou utilisez le modèle _ d’abandon pour correspondre à n’importe quelle valeur.

Spécifiez un type explicite pour le résultat de l’expression switch lorsque le compilateur ne peut pas déduire le type optimal des branches (CS8506). Cette erreur se produit lorsque les branches renvoient des résultats de retour de types différents sans type commun que le compilateur puisse déduire automatiquement, comme les groupes de méthodes ou les lambdas. Affectez le résultat à une variable explicitement typée au lieu d’utiliser var.

Placez l’expression conditionnelle d'une instruction switch entre parenthèses et le corps entre accolades (CS8515). L’instruction switch nécessite des parenthèses sur l'expression à évaluer et des accolades autour du bloc de code. Cette erreur se produit lorsque les parenthèses ou les accolades sont manquantes.

Utilisez case var _: au lieu du discard _ nu comme label de cas dans une instruction switch (CS8523). Le modèle d’abandon nu n’est pas autorisé dans les instructions switch en raison d’ambiguïté avec une constante nommée _. Utiliser case var _: pour un abandon ou case @_: pour faire correspondre une constante nommée _.

Supprimez le mot clé case des branches d'expression switch. Les expressions switch utilisent une syntaxe différente de celle des instructions switch (CS9134). Dans les expressions switch, chaque bras se compose d’un modèle suivi du => jeton et d’une expression, sans le case mot clé utilisé dans les instructions switch. Utilisez des valeurs constantes plutôt que des variables dans des modèles. La mise en correspondance des modèles nécessite des constantes au moment de la compilation (CS9135). Les variables ne peuvent pas être utilisées comme modèles. Le compilateur doit connaître les valeurs exactes au moment de la compilation pour générer le code correspondant approprié.

Utilisez des opérateurs de modèle relationnel (<, >, <=, >=) ou le not mot clé au lieu d’opérateurs ==!= dans des modèles (CS9344, CS9345). Les opérateurs d’égalité et d’inégalité ne sont pas pris en charge dans la syntaxe du modèle. Utilisez un modèle constant pour l’égalité et le not mot clé pour l’inégalité.

Pour plus d’informations sur la syntaxe correcte, consultez l’expression Switch.

Complétivité et redondance des modèles

• CS8120 : La casse de commutateur est inaccessible. Il a déjà été traité par un cas précédent ou il est impossible de faire correspondre.
• CS8509 : l’expression switch ne gère pas toutes les valeurs possibles de son type d’entrée (il n’est pas exhaustif). Par exemple, le modèle '...' n’est pas couvert.
• CS8510 : Le modèle est inaccessible. Il a déjà été géré par un bras précédent de l’expression de commutateur ou il est impossible de faire correspondre.
• CS8518 : Une expression de type ne peut jamais correspondre au modèle fourni.
• CS8519 : L’expression donnée ne correspond jamais au modèle fourni.
• CS8520 : L’expression donnée correspond toujours à la constante fournie.
• CS8524 : L’expression switch ne gère pas certaines valeurs de son type d’entrée (il n’est pas exhaustif) impliquant une valeur d’énumération non nommée. Par exemple, le modèle noté n’est pas couvert.
• CS8793 : L’expression donnée correspond toujours au modèle fourni.
• CS8794 : Une expression de type correspond toujours au modèle fourni.
• CS8846 : L’expression switch ne gère pas toutes les valeurs possibles de son type d’entrée (il n’est pas exhaustif). Par exemple, le modèle noté n’est pas couvert. Toutefois, un modèle avec une clause ' when' peut correspondre à cette valeur.
• CS9336 : Le modèle est redondant.
• CS9337 : Le modèle est trop complexe pour analyser la redondance.

Réorganiser ou supprimer les étiquettes de cas inaccessibles dans les instructions switch (CS8120). Une case étiquette est inaccessible lorsqu’un cas précédent gère déjà toutes les valeurs que le cas ultérieur correspondrait. Cela se produit lorsqu’un modèle plus général apparaît avant un modèle plus spécifique ou lorsque le modèle est impossible à faire correspondre pour le type d’entrée.

Ajoutez des bras de commutateur qui gèrent toutes les valeurs d’entrée possibles pour créer des expressions de commutateur exhaustives (CS8509, CS8524, CS8846). Les expressions switch doivent couvrir toutes les valeurs possibles du type d’entrée. Sinon, le compilateur ne peut pas garantir que l’expression produit un résultat pour toutes les entrées. Le compilateur avertit séparément pour les valeurs d'énumération sans nom (CS8524) et dans les cas où une condition when peut correspondre à une valeur non gérée par ailleurs (CS8846). Utilisez le modèle d’abandon (_) comme un bras de traitement général final pour traiter les valeurs restantes que vous n’avez pas besoin de gérer explicitement.

Réorganiser ou supprimer des bras d’expression switch inaccessibles (CS8510). Comme CS8120 pour switch les instructions, cette erreur indique qu’un bras d’expression switch est inaccessible, car un bras précédent gère déjà toutes les valeurs que le bras ultérieur correspondrait.

Examinez les modèles qui ne peuvent jamais correspondre ou toujours correspondre à l’entrée (CS8518, CS8519, CS8520, CS8793, CS8794). Ces diagnostics indiquent que le compilateur peut déterminer au moment de la compilation si un modèle correspond toujours ou jamais. Un modèle toujours correspondant est redondant et un modèle ne correspondant jamais est un code mort. Les deux peuvent indiquer des erreurs logiques.

Passez en revue les modèles que le compilateur identifie comme redondants. Les modèles redondants peuvent indiquer une erreur logique dans laquelle vous vouliez utiliser not ou différents opérateurs logiques (CS9336). Simplifiez les modèles complexes qui sont trop difficiles pour le compilateur à analyser pour la redondance. Décomposez-les en expressions plus simples et plus faciles à gérer (CS9337).

Pour plus d’informations sur les exigences d’exhaustivité et l’optimisation des modèles, consultez l’expression Switch, l’instruction Switch et les modèles.

Erreurs de modèle de type

• CS8116 : Il n’est pas légal d’utiliser un type Nullable dans un modèle ; utilisez plutôt le type sous-jacent.
• CS8117 : Opérande invalide pour la mise en correspondance de modèle ; une valeur est requise, mais une expression a été trouvée.
• CS8121 : Une expression de type source ne peut pas être gérée par un modèle de type cible.
• CS8208 : Il n’est pas légal d’utiliser le type « dynamique » dans un modèle.
• CS8508 : La syntaxe « var » pour un modèle n’est pas autorisée à faire référence à un type, mais le type est accessible dans ce contexte.
• CS8513 : le nom '_' fait référence au type, et non au modèle _d’abandon. Utilisez « @_ » pour le type ou « var _ » pour ignorer.
• CS8521 : La correspondance des modèles n’est pas autorisée pour les types de pointeur.
• CS8781 : Les modèles relationnels peuvent ne pas être utilisés pour une valeur de type.
• CS8782 : Les modèles relationnels peuvent ne pas être utilisés pour un naN à virgule flottante.
• CS8978 : '...' ne peut pas être rendu nullable.
• CS9060 : Impossible d’utiliser une constante numérique ou un modèle relationnel sur '...' car il hérite ou étend « INumberBase<T> ». Envisagez d’utiliser un modèle de type pour affiner un type numérique spécifique.

Utilisez le type sous-jacent au lieu du type Nullable dans les modèles (CS8116). Vous ne pouvez pas utiliser un type valeur nullable comme int? directement dans un modèle de type. Utilisez plutôt le type sous-jacent (int) et le modèle correspond à la fois à des valeurs nullables et non nullables.

Fournissez une valeur en tant qu’opérande pour une correspondance de modèle (CS8117). Le côté gauche d’une is expression doit être une valeur, et non un type, un espace de noms ou un groupe de méthodes. Affectez d’abord le résultat à une variable ou utilisez une expression différente qui produit une valeur.

Utilisez un type de modèle compatible avec le type d’expression (CS8121). Le compilateur déclenche cette erreur lorsqu’il n’existe aucune conversion possible entre le type d’expression et le type de modèle. Par exemple, vous ne pouvez pas faire correspondre une string expression à un modèle de int type. Remplacez le type de modèle par un type compatible avec l’expression, ou convertissez l’expression en type compatible.

N’utilisez dynamic pas comme type dans un modèle (CS8208). Le dynamic type n’est pas pris en charge dans la correspondance de modèle. Utilisez object à la place, ou convertissez la valeur en un type spécifique avant de l'apparier.

Renommez le type var ou utilisez un type explicite dans le modèle (CS8508). Lorsqu’un type nommé var est dans le contexte, la syntaxe du pattern var est ambiguë. Le compilateur ne peut pas déterminer si vous envisagez d’utiliser le var modèle ou de référencer le type. Utilisez le nom de type complet ou renommez le type pour éviter le conflit.

Utilisez @_ pour référencer un type nommé _ ou utilisez var _ pour le modèle d’abandon (CS8513). Lorsque qu'un type nommé _ est dans la portée, le compilateur ne peut pas déterminer si _ dans un modèle se réfère au type ou au modèle d'abandon.

N’utilisez pas de correspondance de modèle avec les types de pointeur (CS8521). Les types de pointeur ne sont pas pris en charge dans les expressions de correspondance de modèle. Utilisez plutôt des comparaisons ou des casts explicites.

Utilisez un type pris en charge avec des modèles relationnels (CS8781, CS8782). Les modèles relationnels (<, , >, <=>=) fonctionnent uniquement avec des types numériques qui prennent en charge la comparaison. Ils ne peuvent pas être utilisés avec des valeurs NaN, car les comparaisons NaN retournent toujours false.

Utilisez le type sous-jacent directement dans les modèles lors de l’utilisation de types qui ne peuvent pas être rendus nullables (CS8978). Les types tels que System.Nullable<T>, les types de pointeur et les types de struct ref ne peuvent pas être rendus nullables. Vous devez utiliser le type de base dans votre logique de correspondance de modèle.

Utilisez des modèles de type pour affiner les types numériques génériques à des types numériques spécifiques avant d’appliquer des constantes numériques ou des modèles relationnels (CS9060). Vous ne pouvez pas correspondre aux types numériques génériques qui implémentent INumberBase<T> directement à l’aide de constantes numériques ou de modèles relationnels. Le compilateur ne peut pas déterminer quel type numérique spécifique est mis en correspondance. Vous devez d’abord limiter la valeur à un type numérique concret tel que int, doubleou decimal.

Pour plus d’informations sur les modèles de type, consultez Les types de valeurs Nullable, Les modèles et Les mathématiques génériques.

Répertorier les erreurs de modèle

• CS8979 : Les modèles de liste ne peuvent pas être utilisés pour une valeur de type '...'.
• CS8980 : Les modèles de tranche ne peuvent être utilisés qu’une seule fois et directement à l’intérieur d’un modèle de liste.
• CS8985 : Les modèles de liste ne peuvent pas être utilisés pour une valeur de type '...'. Aucune propriété 'Length' ou 'Count' appropriée n’a été trouvée.
• CS9013 : Une constante « null » de chaîne n’est pas prise en charge comme modèle pour « ... ». Utilisez plutôt une chaîne vide.

Vérifiez que le type prend en charge les opérations requises pour les modèles de liste. Les modèles de liste nécessitent des types qui sont countables et indexables (CS8979, CS8985). Le type doit avoir une propriété Length ou Count accessible et prendre en charge l’indexation. Les types d’exécution qui prennent en charge les modèles de liste incluent des tableaux, List<T>, Span<T>et d’autres types de collection avec des membres appropriés.

Placez des modèles de tranche (..) directement à l’intérieur d’un modèle de liste. Utilisez-les une seule fois par modèle de liste, car ils ne peuvent pas apparaître dans des modèles imbriqués ou en dehors des modèles de liste (CS8980).

Lorsqu'on traite les types Span<char> ou ReadOnlySpan<char>, utilisez une chaîne "" vide au lieu d'une constante de chaîne null. Le littéral null n’est pas pris en charge comme modèle pour les types de span (CS9013).

Pour plus d’informations sur les exigences et la syntaxe des modèles de liste, consultez Modèles de liste et modèles.

Erreurs de sous-modèle

• CS8502 : La correspondance du type tuple nécessite des sous-modèles, mais des sous-modèles incorrects sont présents.
• CS8503 : un sous-modèle de propriété nécessite une référence à la propriété ou au champ à mettre en correspondance, par exemple « {{ Name : value }} »
• CS8512 : le nom '_' fait référence à la constante, et non au modèle d’abandon. Utilisez « var _ » pour ignorer la valeur, ou « @_ » pour faire référence à une constante par ce nom.
• CS8516 : Le nom n’identifie pas l’élément de tuple.
• CS8517 : Le nom ne correspond pas au paramètre « Déconstruct » correspondant.
• CS8522 : Les noms d’éléments ne sont pas autorisés lors de la correspondance de modèle via « System.Runtime.CompilerServices.ITuple ».
• CS8525 : un indicateur de variable doit se présenter après un modèle de propriété.
• CS8780 : Une variable peut ne pas être déclarée dans un modèle « non » ou « ou ».
• CS8918 : Identificateur ou accès à un membre simple attendu.

Indiquez le nombre correct de sous-modèles lors de la correspondance d’un type tuple (CS8502). Le nombre de sous-modèles d’un modèle positionnel doit correspondre au nombre d’éléments du type tuple. Ajoutez ou supprimez des sous-modèles pour correspondre à l’arité du tuple.

Incluez la propriété ou le nom du champ dans les sous-modèles de propriété (CS8503). Chaque sous-modèle de propriété doit spécifier la propriété ou le champ à mettre en correspondance. Utilisez la syntaxe { PropertyName: pattern } pour identifier le membre.

Utiliser var _ pour le modèle d’abandon ou @_ pour une constante nommée _ (CS8512). Lorsqu'une constante nommée _ est visible, le terme nu _ dans une étiquette case fait référence à la constante. Pour utiliser le schéma de suppression, écrivez var _ à la place.

Utilisez les noms d’éléments corrects dans les modèles positionnels pour les tuples (CS8516) et les types déconstructés (CS8517). Lorsque vous nommez des sous-modèles dans un modèle positionnel, les noms doivent correspondre aux noms d’éléments tuple ou aux noms de Deconstruct paramètres de méthode.

N’utilisez pas de noms d’éléments dans des modèles positionnels lors de la correspondance via ITuple (CS8522). Lorsqu’un type est mis en correspondance via l’interface ITuple plutôt que par le biais d’une Deconstruct méthode, il n’existe aucun élément nommé. Supprimez les noms d’éléments du modèle.

Placez l’indicateur de variable après le modèle de propriété, et non avant (CS8525). Dans un modèle de propriété avec une désignation de variable, le nom de la variable doit suivre l’accolade fermante du modèle. Par exemple, écrivez { Length: > 0 } s plutôt que s { Length: > 0 }.

Vous ne pouvez pas déclarer de variables dans les combinateurs de motifs not ou or (CS8780). Les déclarations de variables dans les modèles not ne sont pas assignées de manière définitive, et les variables dans les modèles or ne sont attribuées que dans une seule branche. Déplacez la déclaration de variable en dehors du combinateur de modèle.

Utilisez un identificateur ou une expression d’accès de membre simple comme noms de propriétés dans les modèles de propriétés et les sous-modèles positionnels (CS8918). Les expressions complexes, les appels de méthode ou d’autres accès aux membres non simples ne sont pas valides en tant que côté gauche d’un sous-modèle de propriété. Chaque nom de sous-modèle doit être une propriété directe ou un nom de champ, ou un chemin d’accès membre en pointillé comme Property.SubProperty.

Pour plus d’informations sur la syntaxe de sous-modèle, consultez Le modèle de propriété et le modèle positionnel.