Résoudre les erreurs et les avertissements liés aux membres qui implémentent une interface

Cet article traite des erreurs suivantes du compilateur :

• CS0071 : une implémentation d’interface explicite d’un événement doit utiliser la syntaxe de l’accesseur d’événements.
• CS0106 : Le modificateur n’est pas valide pour cet élément.
• CS0277 : Le membre n’implémente pas le membre d’interface, car il n’est pas public.
• CS0425 : Les contraintes pour le paramètre de type de méthode doivent correspondre aux contraintes pour le paramètre de type de la méthode d’interface. Envisagez plutôt d’utiliser une implémentation d’interface explicite.
• CS0460 : Les contraintes pour les méthodes de remplacement et d’implémentation d’interface explicite sont héritées de la méthode de base, de sorte qu’elles ne peuvent pas être spécifiées directement, à l’exception d’une contrainte « class » ou d’une contrainte « struct ».
• CS0470 : La méthode ne peut pas implémenter l’accesseur d’interface pour le type. Utilisez une implémentation d’interface explicite.
• CS0473 : L’implémentation d’interface explicite « nom de méthode » correspond à plusieurs membres d’interface. Quel membre d’interface est réellement choisi dépend de l’implémentation. Envisagez plutôt d’utiliser une implémentation non explicite.
• CS0531 : Les membres de l’interface ne peuvent pas avoir de définition.
• CS0535 : Le membre n’implémente pas le membre d’interface.
• CS0538 : Le membre dans la déclaration d'interface explicite n'est pas d'une interface.
• CS0539 : Le membre dans la déclaration d’interface explicite est introuvable parmi les membres de l’interface qui peuvent être implémentés.
• CS0540 : Le type conteneur n’implémente pas le membre de l’interface.
• CS0541 : La déclaration d’interface explicite ne peut être déclarée que dans une classe, un enregistrement, un struct ou une interface.
• CS0550 : le membre ajoute un accesseur introuvable dans le membre de l’interface.
• CS0551 : L’implémentation d’interface explicite ne dispose pas d’un accesseur.
• CS0630 : Le membre ne peut pas implémenter le membre de l’interface, car il a un paramètre __arglist.
• CS0686 : Accessor ne peut pas implémenter le membre de l’interface. Utilisez une implémentation d’interface explicite.
• CS0736 : Le membre n’implémente pas le membre de l’interface d’instance. Il ne peut pas implémenter le membre de l’interface, car il est statique.
• CS0737 : Le membre n’implémente pas le membre d’interface. Il ne peut pas implémenter un membre d’interface, car il n’est pas public.
• CS0738 : Le membre n’implémente pas le membre d’interface. Il ne peut le faire car il n’a pas le type de retour correspondant.
• CS8705 : le membre de l’interface n’a pas d’implémentation la plus spécifique. Aucun membre n’est plus spécifique.
• CS8854 : Le membre n’implémente pas un membre de l’interface.
• CS9333 : Le type de paramètre doit correspondre au membre implémenté.
• CS9334 : le type de retour doit correspondre au membre implémenté.

Déclaration et syntaxe de l’interface

Les erreurs suivantes concernent la syntaxe et la structure appropriées lors de la déclaration d’implémentations d’interface explicites :

• CS0071 : une implémentation d’interface explicite d’un événement doit utiliser la syntaxe de l’accesseur d’événements.
• CS0106 : Le modificateur n’est pas valide pour cet élément.
• CS0531 : Les membres de l’interface ne peuvent pas avoir de définition.
• CS0538 : Un membre dans la déclaration explicite d’interface n’est pas une interface.
• CS0541 : La déclaration d’interface explicite ne peut être déclarée que dans une classe, un enregistrement, un struct ou une interface.

Vous pouvez corriger ces erreurs à l’aide des techniques suivantes :

• Vous devez fournir des accesseurs d'événements add et remove manuellement lors de l'implémentation explicite d'un événement d'interface (CS0071). Le compilateur ne génère pas automatiquement ces accesseurs pour les implémentations d’interface explicites. Vous devez donc les définir explicitement pour spécifier la façon dont l’événement est stocké et géré.
• Supprimez le public modificateur des implémentations d’interface explicites (CS0106). Les implémentations d’interface explicites sont implicitement publiques lorsqu’elles sont accessibles via le type d’interface, ce qui rend le public mot clé redondant et non autorisé dans ce contexte.
• Supprimez le abstract modificateur des implémentations d’interface explicites (CS0106). Les implémentations d’interface explicites fournissent l’implémentation réelle et ne peuvent pas être marquées comme abstraites, car elles ne peuvent pas être substituées dans les classes dérivées.
• Supprimez le corps de la méthode des déclarations de membre d’interface ou déplacez l’implémentation vers une classe ou un struct qui implémente l’interface (CS0531). Avant C# 8.0, les membres de l’interface ne peuvent pas contenir d’implémentations ; à partir de C# 8.0, vous pouvez fournir des méthodes d’interface par défaut à l’aide d’une syntaxe spécifique.
• Vérifiez que le type spécifié dans la déclaration d’interface explicite est un type d’interface réel (CS0538). Seuls les types d’interface peuvent être utilisés dans la syntaxe d’implémentation d’interface explicite ; la tentative d’utilisation d’une classe ou d’un autre type non interface enfreint les règles d’implémentation explicites.
• Déplacez des déclarations d’interface explicites dans une classe ou un struct qui déclare l’interface dans sa liste de base (CS0541). Les implémentations d’interface explicites doivent apparaître dans le corps d’une classe ou d’un type de struct et ne peuvent pas être déclarées au niveau de l’espace de noms ou dans d’autres contextes.

Pour plus d’informations, consultez Interfaces, Implémentation d’interface explicite et Guide pratique pour implémenter des événements d’interface.

Types et signatures de retour

Les erreurs suivantes se produisent lorsque la signature de la méthode d’implémentation ne correspond pas à la déclaration de membre de l’interface :

• CS0738 : Le membre n’implémente pas le membre de l’interface. Il n'est pas possible car il n’a pas le type de retour correspondant.
• CS8854 : Le membre n’implémente pas le membre d’interface.
• CS9333 : Le type de paramètre doit correspondre au membre implémenté.
• CS9334 : le type de retour doit correspondre au membre implémenté.

Vous pouvez corriger ces erreurs à l’aide des techniques suivantes :

• Modifiez le type de retour de la méthode d’implémentation pour qu’elle corresponde exactement au type de retour déclaré dans le membre de l’interface (CS0738, CS9334). La signature de l’implémentation doit correspondre précisément à la déclaration d’interface, car la signature de méthode fait partie du contrat qui détermine quel membre de l’interface est implémenté.
• Vérifiez que les types de paramètres de la méthode d’implémentation correspondent exactement aux types de paramètres déclarés dans le membre de l’interface (CS9333). Chaque paramètre doit avoir le même type dans la même position que spécifié dans la déclaration d’interface, car les types de paramètres sont des composants fondamentaux de la signature de méthode utilisée par le compilateur pour faire correspondre les implémentations aux membres de l’interface.
• Ajoutez un init accesseur à la propriété d’implémentation lorsque la propriété d’interface déclare un init setter (CS8854). Le init mot clé autorise l’initialisation des propriétés pendant la construction de l’objet tout en empêchant la modification par la suite, et la propriété d’implémentation doit fournir ce même comportement d’initialisation uniquement pour satisfaire le contrat d’interface.

Pour plus d’informations, consultez interfaces, propriétés et setters init uniquement.

Implémentations manquantes ou incomplètes

Les erreurs suivantes se produisent lorsqu’une classe ne parvient pas à implémenter entièrement une interface ou implémente des membres qui ne correspondent pas au contrat d’interface :

• CS0535 : Le membre n’implémente pas le membre d’interface.
• CS0550 : Le membre intègre un accesseur qui ne fait pas partie du membre de l’interface.
• CS0551 : L’implémentation d’interface explicite ne dispose pas d’un accesseur.

Vous pouvez corriger ces erreurs à l’aide des techniques suivantes :

• Fournissez une implémentation pour chaque membre déclaré dans l’interface ou déclarez le type en tant que abstract (CS0535). Chaque membre doit être implémenté pour répondre aux exigences de l’interface.
• Supprimez les accesseurs de la propriété d’implémentation qui ne sont pas déclarés dans la propriété d’interface (CS0550). La propriété d’implémentation ne peut inclure que les accesseurs explicitement déclarés dans la définition de l’interface, ce qui garantit que l’implémentation n’ajoute pas de fonctionnalités au-delà de ce que le contrat d’interface spécifie.
• Ajoutez tous les accesseurs requis à l’implémentation d’interface explicite pour qu’ils correspondent à la déclaration d’interface (CS0551). Chaque accesseur déclaré dans l’interface doit avoir un accesseur correspondant dans l’implémentation avec des signatures correspondantes, car l’implémentation doit remplir le contrat d’accesseur complet défini par l’interface.

Pour plus d’informations, consultez Interfaces et propriétés.

Correspondance et résolution des membres

Les erreurs suivantes se produisent lors de la tentative d’implémentation de membres d’interface qui n’existent pas dans l’interface ou lorsque le type conteneur ne déclare pas l’interface :

• CS0539 : Le membre dans la déclaration d’interface explicite est introuvable parmi les membres de l’interface qui peuvent être implémentés.
• CS0540 : Le type conteneur n’implémente pas le membre de l’interface.

Vous pouvez corriger ces erreurs à l’aide des techniques suivantes :

• Vérifiez que le nom et la signature du membre dans l’implémentation d’interface explicite correspondent exactement à un membre déclaré dans l’interface ou supprimez l’implémentation incorrecte (CS0539). Le membre que vous tentez d’implémenter doit réellement exister dans la définition de l’interface avec le nom, le type de retour et les types de paramètres correspondants, car l’implémentation d’interface explicite nécessite une correspondance précise avec le contrat d’interface.
• Ajoutez l’interface à la liste de base de la classe ou du struct, ou supprimez l’implémentation d’interface explicite (CS0540). Un type ne peut implémenter explicitement les membres d’interfaces qu’il déclare dans sa liste d’héritage. Le type d’implémentation doit donc établir la relation d’interface avant de pouvoir fournir des implémentations explicites.

Pour plus d’informations, consultez Interfaces et implémentation d’interface explicite.

Contraintes de type générique

Les erreurs suivantes se produisent lors de l’implémentation de méthodes d’interface génériques avec des contraintes de paramètre de type :

• CS0425 : Les contraintes pour le paramètre de type de méthode doivent correspondre aux contraintes pour le paramètre de type de la méthode d’interface. Envisagez plutôt d’utiliser une implémentation d’interface explicite.
• CS0460 : Les contraintes pour les méthodes de remplacement et d’implémentation d’interface explicite sont héritées de la méthode de base, de sorte qu’elles ne peuvent pas être spécifiées directement, à l’exception d’une contrainte « class » ou d’une contrainte « struct ».

Vous pouvez corriger ces erreurs à l’aide des techniques suivantes :

• Vérifiez que la where clause de la méthode d’implémentation est identique à la déclaration de méthode d’interface ou correspond à la signification sémantique des contraintes (CS0425). Les contraintes de paramètre de type dans l’implémentation doivent correspondre à celles définies dans l’interface ou la méthode de base.
• Retirez les déclarations de contrainte explicites des méthodes de remplacement et d’implémentation d’interface explicites (CS0460). La méthode de substitution hérite automatiquement de ses contraintes de la méthode de base ou d’interface, de sorte que leur déclaration est redondante et n’est pas autorisée à l’exception des cas spécifiques autorisés en C# 8 et versions ultérieures.
• Appliquez la default contrainte pour résoudre les ambiguïtés avec les types de référence nullables dans les implémentations de substitution et d'interface explicite lors de l’utilisation de C# 9 ou versions ultérieures (CS0460). Cette exception à la règle d’héritage de contrainte vous permet de spécifier explicitement la contrainte par défaut pour lever l’ambiguïté des contextes d’annotation nullables.
• Spécifiez explicitement les contraintes where T : class ou where T : struct sur les méthodes redéfinies et les implémentations d'interface explicite lors de l’utilisation de C# 8 ou d'une version ultérieure pour activer les annotations de type référence nullable (CS0460). Ces contraintes spécifiques sont permises pour faciliter l’analyse de types de référence nullable sur les paramètres de type qui sont confinés aux types de référence ou de valeur.

Pour plus d’informations, consultez Contraintes sur les paramètres de type, interfaces et types de référence Nullable.

Visibilité des méthodes et modificateurs

Les erreurs suivantes se produisent lors de l’implémentation de méthodes d’interface avec une accessibilité ou des modificateurs incorrects :

• CS0736 : Le membre n’implémente pas le membre de l’interface d’instance. Il ne peut pas implémenter le membre de l’interface, car il est statique.
• CS0737 : Le membre n’implémente pas le membre d’interface. Il ne peut pas implémenter un membre d’interface, car il n’est pas public.

Vous pouvez corriger ces erreurs à l’aide des techniques suivantes :

• Supprimez le static modificateur de la déclaration de méthode qui implémente le membre d’interface (CS0736). Avant C# 10, les membres de l’interface sont des membres d’instance, et non des membres statiques.
• Ajoutez le public modificateur d’accès à la méthode qui implémente le membre d’interface (CS0737). Tous les membres de l’interface sont implicitement public parce que les interfaces définissent un contrat pour le comportement public, de sorte que la méthode d’implémentation doit également avoir une accessibilité publique accessible via la référence d’interface.

Pour plus d’informations, consultez Interfaces et modificateurs d’accès.

Implémentation et conflits d’accesseur

Les erreurs suivantes se produisent lors de l’implémentation de propriétés d’interface ou d’événements avec des méthodes d’accesseur qui présentent des problèmes de visibilité ou des conflits d’affectation de noms :

• CS0277 : Le membre n’implémente pas le membre de l'interface, car ce dernier n’est pas public.
• CS0470 : La méthode ne peut pas implémenter l’accesseur d’interface pour le type. Utilisez une implémentation d’interface explicite.
• CS0686 : Accessor ne peut pas implémenter le membre de l’interface. Utilisez une implémentation d’interface explicite.

Vous pouvez corriger ces erreurs à l’aide des techniques suivantes :

• Supprimez les modificateurs d’accès des accesseurs de propriété qui limitent la visibilité à moins visible que public, ou ajoutez le public modificateur s’il est manquant (CS0277). Tous les membres de l’interface sont implicitement public, de sorte que l’accesseur d’implémentation doit également disposer d’une accessibilité publique pour satisfaire le contrat d’interface et être accessible via le type d’interface.
• Remplacez les méthodes par des noms de type accesseur (par exemple get_PropertyName) par une syntaxe de propriété appropriée à l’aide de l’implémentation d’interface explicite (CS0470). Le compilateur génère en interne des méthodes d'accesseur pour les propriétés, car créer manuellement des méthodes portant ces noms réservés entre en conflit avec le mécanisme d'implémentation des propriétés.
• Utilisez la syntaxe d’implémentation d’interface explicite pour résoudre les conflits d’affectation de noms lorsque l’interface contient des noms de méthode qui correspondent aux méthodes d’accesseur générées automatiquement (CS0686). Le compilateur génère automatiquement des méthodes comme get_Property et set_Property pour les propriétés, et add_Eventremove_Event pour les événements. Par conséquent, si une interface déclare des méthodes avec ces noms exacts, l’implémentation explicite est nécessaire pour lever l’ambiguïté entre la méthode d’interface et l’accesseur généré par le compilateur.

Pour plus d’informations, consultez Interfaces, Propriétés et Événements.

Implémentations ambiguës et conflictuelles

Les erreurs suivantes se produisent lorsque le compilateur ne peut pas déterminer l’implémentation de l’interface à utiliser :

• CS0473 : L’implémentation d’interface explicite « nom de méthode » correspond à plusieurs membres d’interface. Quel membre d’interface est réellement choisi dépend de l’implémentation. Envisagez plutôt d’utiliser une implémentation non explicite.
• CS8705 : le membre de l’interface 'member' n'a pas d'implémentation jugée la plus spécifique. Aucune n'est considérée comme plus spécifique.

Vous pouvez corriger ces erreurs à l’aide des techniques suivantes :

• Éliminez l’implémentation d’interface explicite et utilisez plutôt une implémentation publique implicite unique pour les deux méthodes d’interface (CS0473). Lorsqu’une méthode générique acquiert la même signature qu’une méthode non générique (par exemple lors de l’implémentation ITest<int> où les deux TestMethod(int) et TestMethod(T) deviennent identiques), le système de métadonnées d’infrastructure de langage commun ne peut pas déterminer sans ambiguïté le membre de l’interface lié à quel emplacement d’implémentation, de sorte que l’utilisation de l’implémentation implicite permet à la méthode unique de répondre aux deux exigences de l’interface.
• Fournissez une implémentation explicite dans la classe ou le struct d’implémentation qui résout l’ambiguïté entre plusieurs implémentations par défaut (CS8705). Cette erreur se produit généralement avec des modèles d’héritage de diamants où une classe implémente plusieurs interfaces qui fournissent chacune des implémentations par défaut pour le même membre. Le compilateur doit spécifier explicitement l’implémentation à utiliser ou fournir votre propre implémentation.
• Restructurez la hiérarchie d’interface pour éviter les conflits d’héritage de diamants où plusieurs interfaces fournissent des implémentations par défaut pour le même membre (CS8705). En redéfinissant les relations d’interface ou en regroupant les implémentations par défaut en une seule interface, vous pouvez éliminer l’ambiguïté qui empêche le compilateur de déterminer l’implémentation la plus spécifique.

Pour plus d’informations, consultez Interfaces et méthodes d’interface par défaut.

Restrictions d’implémentation spéciales

L’erreur suivante se produit lors de l’utilisation de types de paramètres spéciaux qui ne sont pas compatibles avec l’implémentation de l’interface :

• CS0630 : Le membre ne peut pas implémenter le membre de l’interface, car il a un paramètre __arglist.

Vous pouvez corriger cette erreur à l’aide des techniques suivantes :

• Supprimez le __arglist paramètre de la méthode d’implémentation (CS0630). Le __arglist mot clé permet aux méthodes d’accepter un nombre variable d’arguments d’une manière non managée, mais cette fonctionnalité n’est pas compatible avec l’implémentation de l’interface, car les contrats d’interface nécessitent des signatures prévisibles et sécurisées de type qui peuvent être vérifiées au moment de la compilation.
• Remplacez le __arglist paramètre par un params paramètre de tableau pour les listes d’arguments de longueur variable (CS0630). Contrairement à __arglist, le mot clé params fournit un mécanisme sûr pour les types permettant d'accepter des nombres variables d’arguments, entièrement compatibles avec l’implémentation de l’interface, et préserve la sécurité du typage à la compilation nécessaire aux interfaces.

Pour plus d’informations, consultez Interfaces et le mot clé params.