Partager via

Erreurs et avertissements des membres d'interface statiques abstraits et virtuels

Le compilateur génère les erreurs suivantes pour les déclarations non valides des membres abstraits statiques ou virtuels dans les interfaces :

  • CS8920 : L’interface ne peut pas être utilisée comme argument de type. Le membre statique n’a pas d’implémentation la plus spécifique dans l’interface.
  • CS8921 : Le paramètre d’un opérateur unaire doit être le type conteneur ou son paramètre de type limité à celui-ci.
  • CS8922 : Le type de paramètre pour ++ ou -- l’opérateur doit être le type conteneur, ou son paramètre de type lui est limité.
  • CS8923 : Le type de retour pour l'opérateur ++ ou -- doit soit correspondre au type de paramètre, soit être dérivé du type de paramètre, soit être le paramètre de type du type contenant contraint à ce type, sauf si le type de paramètre est un paramètre de type différent.
  • CS8924 : L’un des paramètres d’un opérateur binaire doit être le type conteneur ou son paramètre de type limité à celui-ci.
  • CS8925 : Le premier opérande d’un opérateur de décalage surchargé doit avoir le même type que le type conteneur ou son paramètre de type limité à celui-ci
  • CS8926 : un membre d’interface virtuelle ou abstraite statique est accessible uniquement sur un paramètre de type.
  • CS8928 : Le type n’implémente pas le membre d’interface statique. La méthode ne peut pas implémenter le membre de l’interface, car elle n’est pas statique.
  • CS8930 : L’implémentation explicite d’un opérateur défini par l’utilisateur doit être déclarée statique
  • CS8931 : Une conversion définie par l'utilisateur dans une interface doit consister en une conversion vers ou à partir d'un paramètre de type sur le type englobant restreint au type englobant
  • CS8932 : La méthode 'UnmanagedCallersOnly' ne peut pas être utilisée pour implémenter un membre d'interface dans ce type
  • CS9044 : Le type n’implémente pas le membre de l’interface. La méthode ne peut pas implémenter implicitement un membre inaccessible.
  • CS9046 : L’un des paramètres d’un opérateur d’égalité ou d’inégalité déclaré dans une interface doit être un paramètre de type limité à l’interface

Ces erreurs se produisent à trois emplacements dans votre code :

Erreurs dans la déclaration d’interface

Vous pouvez rencontrer les erreurs suivantes lorsque vous déclarez une interface avec les membres static abstract ou static virtual :

  • CS8921 : Le paramètre d’un opérateur unaire doit être le type conteneur ou son paramètre de type limité à celui-ci.
  • CS8922 : Le type de paramètre pour ++ ou -- l’opérateur doit être le type conteneur, ou son paramètre de type lui est limité.
  • CS8923 : l'opérateur ++ ou -- doit avoir un type de retour qui correspond au type de paramètre, ou qui soit dérivé du type de paramètre, ou qui soit un paramètre de type du conteneur qui y est contraint, sauf si le type de paramètre est un paramètre de type différent.
  • CS8924 : L’un des paramètres d’un opérateur binaire doit être le type conteneur ou son paramètre de type limité à celui-ci.
  • CS8925 : Le premier opérande d’un opérateur de décalage surchargé doit avoir le même type que le type conteneur ou son paramètre de type limité à celui-ci
  • CS8931 : La conversion définie par l’utilisateur dans une interface doit être convertie en ou à partir d’un paramètre de type sur le type englobant limité au type englobant
  • CS9046 : L’un des paramètres d’un opérateur d’égalité ou d’inégalité déclaré dans l’interface doit être un paramètre de type limité à l’interface

Pour les opérateurs unaires déclarés dans une interface, vérifiez que le paramètre est soit le type d’interface lui-même, soit un paramètre T de type où T il est contraint d’implémenter l’interface (CS8921). Cette contrainte garantit que l’opérateur ne peut être appliqué qu’aux types qui implémentent l’interface, ce qui permet au compilateur de résoudre l’implémentation correcte au moment de la compilation.

Pour les opérateurs incrément (++) et décrément (--), vérifiez que le paramètre suit les mêmes règles que les autres opérateurs unaires (CS8922). En outre, le type de retour doit correspondre au type de paramètre, dériver de celui-ci ou être le paramètre de type de l’interface contraint à l’interface (CS8923). Ces règles garantissent que les opérations d’incrémentation et de décrémentation retournent un type compatible qui peut être affecté à la variable d’origine.

Pour les opérateurs binaires, au moins l’un des deux paramètres doit être le type d’interface conteneur ou un paramètre de type contraint à implémenter l’interface (CS8924). Cette exigence permet à l’autre paramètre d’être n’importe quel type, ce qui permet aux opérateurs comme T operator +(T left, int right) dans les scénarios mathématiques génériques.

Pour les opérateurs de décalage (<< et >>), le premier opérande doit être le type conteneur ou son paramètre de type contraint (CS8925). Le deuxième opérande suit les règles d’opérateur de décalage standard et est généralement int.

Pour les opérateurs de conversion définis par l’utilisateur, la conversion doit impliquer un paramètre de type limité au type d’interface englobant (CS8931). Vous ne pouvez pas définir de conversions entre des types arbitraires dans une interface ; la conversion doit être liée aux types qui implémentent l’interface.

Pour les opérateurs d’égalité (==) et d’inégalité (!=), au moins un paramètre doit être un paramètre de type limité à l’interface, pas seulement le type d’interface lui-même (CS9046). Cette exigence plus stricte pour les opérateurs d’égalité garantit une sécurité de type appropriée lors de la comparaison des instances via l’interface.

Pour plus d’informations sur les règles relatives aux déclarations d’opérateur dans les interfaces, consultez les membres abstraits statiques dans les interfaces. Pour obtenir un guide pratique sur l’implémentation de ces modèles, consultez Explorer les membres de l’interface abstraite statique.

Erreurs dans la déclaration d’interface d’implémentation de type

Vous pouvez rencontrer les erreurs suivantes lorsque vous définissez un type qui implémente une interface avec static abstract ou static virtual des méthodes :

  • CS8928 : Le type n’implémente pas le membre d’interface statique. La méthode ne peut pas implémenter le membre de l’interface, car elle n’est pas statique.
  • CS8930 : L’implémentation explicite d’un opérateur défini par l’utilisateur doit être déclarée statique
  • CS8932 : La méthode 'UnmanagedCallersOnly' ne peut pas implémenter le membre d’interface dans le type
  • CS9044 : Le type n’implémente pas le membre de l’interface. La méthode ne peut pas implémenter implicitement un membre inaccessible.

Lorsque vous implémentez un membre d’interface virtuelle abstraite ou statique statique, déclarez la méthode d’implémentation à l’aide du static modificateur (CS8928). Contrairement aux membres de l’interface d’instance implémentés par les méthodes d’instance, les membres abstraits statiques nécessitent des implémentations statiques, car le runtime les appelle sur le type lui-même, et non sur une instance.

Pour les implémentations explicites d’opérateurs définis par l’utilisateur à partir d’une interface, incluez le static modificateur dans l’implémentation (CS8930). Les implémentations d’interface explicites des opérateurs suivent la même exigence statique que les implémentations implicites.

Supprimez l’attribut System.Runtime.InteropServices.UnmanagedCallersOnlyAttribute de n’importe quelle méthode qui implémente un membre d’interface (CS8932). Les méthodes marquées à l’aide de cet attribut ne peuvent être appelées qu’à partir de code non managé et ne peuvent pas participer à l’implémentation de l’interface, car le runtime doit les appeler via le mécanisme de répartition de l’interface.

Si la méthode d’implémentation a une accessibilité plus restrictive que le membre d’interface (par exemple, une private ou internal une méthode implémentant un membre d’interface public ), utilisez la syntaxe d’implémentation d’interface explicite au lieu de l’implémentation implicite (CS9044). L’implémentation implicite nécessite que le membre d’implémentation soit au moins aussi accessible que le membre d’interface qu’il implémente.

Pour plus d’informations sur l’implémentation de membres d’interface, consultez Interfaces et implémentation explicite de l’interface.

Erreurs d’appel des membres statiques des interfaces abstraites

Il se peut que vous rencontriez les erreurs suivantes lorsque vous tentez d’appeler un membre d’interface défini en tant que static abstract ou static virtual :

  • CS8920 : L’interface ne peut pas être utilisée comme argument de type. Le membre statique n’a pas d’implémentation la plus spécifique dans l’interface.
  • CS8926 : un membre d’interface virtuelle ou abstraite statique est accessible uniquement sur un paramètre de type.

Lorsque vous utilisez une interface avec des membres abstraits statiques comme argument de type, assurez-vous que tous les membres abstraits statiques disposent d’une implémentation la plus spécifique disponible (CS8920). Cette erreur s’affiche lorsque le compilateur ne peut pas déterminer l’implémentation à utiliser, généralement parce que plusieurs hiérarchies d’interface fournissent des implémentations par défaut conflictuelles ou qu’aucune implémentation n’existe.

Accédez aux membres d'interface abstraits statiques ou virtuels statiques par le biais d'un paramètre de type contraint à implémenter l'interface, plutôt que directement via le type d'interface (CS8926). Par exemple, utilisez T.MemberName où T est limité par where T : IMyInterface, plutôt que IMyInterface.MemberName. Le compilateur a besoin d’un type concret pour résoudre l’implémentation à appeler et un paramètre de type contraint fournit ce type concret au moment de la compilation via la spécialisation générique.

Pour plus d'informations sur la façon d'accéder aux membres abstraits statiques, consultez la section sur les membres abstraits statiques dans les interfaces.

  • Last updated on