Résoudre les erreurs et les avertissements dans les déclarations de constructeur

Cet article décrit les erreurs de compilateur suivantes :

• CS0132 : 'constructeur' : un constructeur statique doit être sans paramètre.
• CS0514 : un constructeur statique ne peut pas avoir un appel explicite au constructeur 'this' ou 'base'.
• CS0515: les modificateurs d’accès ne sont pas autorisés sur les constructeurs statiques.
• CS0516 : Le constructeur 'constructor' ne peut pas s'appeler lui-même.
• CS0517: 'class' n’a pas de classe de base et ne peut pas appeler un constructeur de base.
• CS0522: les structs ne peuvent pas appeler des constructeurs de classe de base.
• CS0526 : Les interfaces ne peuvent pas contenir de constructeurs.
• CS0568 : Les structures ne peuvent pas contenir de constructeurs explicites sans paramètre.
• CS0573 : « déclaration de champ » : ne peut pas avoir d’initialiseurs de champ d’instance dans des structs.
• CS0710: classes statiques ne peuvent pas avoir de constructeurs d’instances.
• CS0768 : Un constructeur ne peut pas s'appeler lui-même par l'intermédiaire d'un autre constructeur.
• CS1018 : Mot clé 'this' ou 'base' attendu.
• CS8054 : Les enums ne peuvent pas contenir de constructeurs explicites sans paramètre.
• CS8091: ne peut pas être externe et avoir une initialisation de constructeur.
• CS8861 : liste d’arguments inattendue.
• CS8862 :Un constructeur déclaré dans un type avec une liste de paramètres doit avoir l'initialisateur de constructeur « this ».
• CS8358: Impossible d’utiliser le constructeur d’attribut, car il a des paramètres « in ».
• CS8867: Aucun constructeur de copie accessible n'a été trouvé dans le type de base «{0}».
• CS8868: Un constructeur de copie dans un enregistrement doit appeler un constructeur de copie de la base, ou un constructeur d’objet sans paramètre si l’enregistrement hérite de l’objet.
• CS8878: Un constructeur de copie '{0}' doit être public ou protégé, car l’enregistrement n’est pas scellé.
• CS8910: Le constructeur principal est en conflit avec le constructeur de copie synthétisé.
• CS8958: le constructeur de struct sans paramètre doit être « public ».
• CS8982: Un constructeur déclaré dans un « struct » avec la liste de paramètres doit avoir un initialiseur « this » qui appelle le constructeur principal ou un constructeur déclaré explicitement.
• CS8983 : Une 'struct' avec des initialisateurs de champs doit inclure un constructeur explicitement déclaré.
• CS9105: Impossible d’utiliser le paramètre de constructeur principal dans ce contexte.
• CS9106 : l’identificateur est ambigu entre le type et le paramètre dans ce contexte.
• CS9108: Impossible d’utiliser un paramètre de type ref à l’intérieur d’une méthode anonyme, d’une expression lambda, d’une expression de requête ou d’une fonction locale.
• CS9109 : Impossible d’utiliser ref, outou in paramètre de constructeur principal à l’intérieur d’un membre d’instance.
• CS9110: Impossible d’utiliser le paramètre de constructeur principal qui a un type de type ref-like à l’intérieur d’un membre d’instance.
• CS9111: méthodes anonymes, expressions lambda, expressions de requête et fonctions locales à l’intérieur d’un membre d’instance d’une structure ne peuvent pas accéder au paramètre du constructeur principal.
• CS9112: Les méthodes anonymes, les expressions lambda, les expressions de requête et les fonctions locales à l’intérieur d’une structure ne peuvent pas accéder au paramètre de constructeur principal également utilisé dans un membre d'instance.
• CS9114 : Un paramètre de constructeur primaire d'un type en lecture seule ne peut pas être assigné (sauf dans le setter init-only du type ou dans un initialisateur de variable).
• CS9115 : Un paramètre de constructeur primaire d'un type en lecture seule ne peut pas être retourné par une référence inscriptible.
• CS9116 : Un paramètre de constructeur primaire d'un type en lecture seule ne peut pas être utilisé comme valeur ref ou out (sauf dans le setter init-only du type ou dans un initialisateur de variable).
• CS9117 : Les membres d'un paramètre de constructeur primaire d'un type en lecture seule ne peuvent pas être modifiés (sauf dans le setter init-only du type ou dans un initialisateur de variable).
• CS9118 : Les membres d'un paramètre de constructeur primaire d'un type en lecture seule ne peuvent pas être retournés par une référence inscriptible.
• CS9119: Les membres d’un paramètre de constructeur principal d’un type en lecture seule ne peuvent pas être utilisés comme valeur ref ou out (sauf dans un setter défini uniquement lors de l'initialisation du type ou dans un initialiseur de variable).
• CS9120: Impossible de renvoyer un paramètre du constructeur principal par référence.
• CS9121 : Le paramètre primaire du constructeur d'une structure de type provoque un cycle dans la disposition de la structure.
• CS9122: liste de paramètres inattendue.
• CS9136 : Impossible d'utiliser un paramètre de constructeur primaire de type à l'intérieur d'un membre d'instance.

En outre, les avertissements suivants sont abordés dans cet article :

• CS0824 : Le constructeur 'name' est marqué comme externe.
• CS9107 : Le paramètre est capturé dans l'état du type englobant et sa valeur est également passée au constructeur de base. La valeur peut également être capturée par la classe de base.
• CS9113: Paramètre n’est pas lus.
• CS9124: Paramètre est capturé dans l’état du type englobant et sa valeur est également utilisée pour initialiser un champ, une propriété ou un événement.
• CS9179 : Le paramètre du constructeur primaire est caché par un membre de la base.
• CS9018 : La propriété implémentée automatiquement est lue avant d’être attribuée explicitement, ce qui provoque une affectation implicite précédente de « default ».
• CS9019 : Le champ est lu avant d’être attribué explicitement, ce qui provoque une affectation implicite précédente de « default ».
• CS9020 : L’objet « this » est lu avant que tous ses champs aient été affectés, ce qui entraîne l’affectation implicite précédente de « default » à des champs non attribués explicitement.
• CS9021 : Le contrôle est retourné à l’appelant avant l’affectation explicite de la propriété implémentée automatiquement, ce qui provoque une affectation implicite précédente de « default ».
• CS9022 : Le contrôle est retourné à l’appelant avant que le champ soit explicitement affecté, ce qui provoque une affectation implicite précédente de « default ».

Constructeurs statiques

• CS0132 : 'constructeur' : un constructeur statique doit être sans paramètre.
• CS0514 :Un constructeur statique ne peut pas avoir un appel explicite au constructeur 'this' ou 'base'.
• CS0515 : Les modificateurs d'accès ne sont pas autorisés sur les constructeurs statiques.

Les constructeurs statiques initialisent des données statiques pour un type. Pour plus d’informations, consultez constructeurs statiques.

Pour corriger ces erreurs, vérifiez que votre déclaration de constructeur statique suit les règles suivantes :

• Supprimez tous les paramètres de la déclaration du constructeur statique, car un constructeur statique doit être sans paramètre (CS0132). Si vous devez passer des valeurs d’initialisation, envisagez d’utiliser des champs statiques ou des propriétés que vous avez définis avant l’exécution du constructeur statique.
• Supprimez les modificateurs d’accès tels que public, protected, private ou internal du constructeur statique, car le moment d'exécution du constructeur statique est contrôlé par le runtime et les modificateurs d’accès ne sont pas pertinents (CS0515).
• Supprimez les appels d’initialiseur : base() ou : this() de constructeur du constructeur statique, car les constructeurs statiques ne peuvent pas être chaînés à d'autres constructeurs (CS0514). Le runtime appelle automatiquement le constructeur statique de classe de base s’il en existe un.

Déclaration du constructeur

• CS0526 : Les interfaces ne peuvent pas contenir de constructeurs.
• CS0710 : classes statiques ne peuvent pas avoir de constructeurs d’instances.
• CS8054 : Les énumérations ne peuvent pas contenir de constructeurs explicites sans paramètres.
• CS8358: Impossible d’utiliser le constructeur d’attribut, car il a des paramètres « in ».
• CS8091 : Un constructeur ne peut pas être extern et avoir un initialisateur de constructeur.

Vous pouvez déclarer des constructeurs uniquement dans les types class et struct, y compris dans les types record class et record struct. Pour plus d’informations, consultez constructeurs d’instance.

Pour corriger ces erreurs, essayez les suggestions suivantes :

Déplacez le constructeur vers un type class ou struct, car vous ne pouvez pas déclarer de constructeurs dans les types interface ou enum (CS0526, CS8054). Les interfaces définissent des contrats, mais ne fournissent pas de logique d’initialisation, et les types d’énumération ont leurs valeurs définies au moment de la compilation.

Supprimez les constructeurs d’instances des classes statiques, car les classes statiques ne peuvent pas être instanciées et ne peuvent donc pas avoir de constructeurs d’instances (CS0710). Si vous avez besoin d’une logique d’initialisation, utilisez plutôt un constructeur statique.

Modifiez in les paramètres en paramètres pass-by-value dans les constructeurs d’attributs, car les constructeurs d’attributs ne prennent pas en charge in les modificateurs de paramètres (CS8358). Le runtime utilise la réflexion pour instancier les attributs, ce qui ne prend pas en charge le modificateur in.

Supprimez l'initialiseur : base() ou : this() d’un constructeur extern, car les constructeurs externes ne peuvent pas être chaînés à d’autres constructeurs (CS8091). L’implémentation d’un constructeur extern est fournie en externe. Le chaînage du constructeur n’est donc pas possible.

L’avertissement suivant peut être généré pour les déclarations de constructeur :

• CS0824: Le constructeur est marqué comme externe.

Lorsqu’un constructeur est marqué extern, le compilateur ne peut pas vérifier qu’une implémentation existe. Pour supprimer cet avertissement, fournissez une implémentation non externe ou vérifiez que l’implémentation externe est correctement liée.

Constructeurs dans les types struct

• CS0568 : les structures ne peuvent pas contenir de constructeurs explicites n’acceptant aucun paramètre.
• CS0573 : « déclaration de champ » : ne peut pas avoir d’initialiseurs de champ d’instance dans des structs.
• CS8958 : Le constructeur d'une structure sans paramètre doit être « public ».
• CS8982: Constructeur déclaré dans un « struct » avec la liste de paramètres doit avoir un initialiseur « this » qui appelle le constructeur principal ou un constructeur déclaré explicitement.
• CS8983 : Une « struct » avec des initialisateurs de champs doit inclure un constructeur explicitement déclaré.

Les types de struct ont des règles spécifiques pour les constructeurs et l'initialisation des champs. Pour plus d’informations, consultez la section Struct initialisation et valeurs par défaut de l’article Types de structure .

Pour corriger ces erreurs, essayez les suggestions suivantes :

• Effectuez une mise à niveau vers C# 10 ou version ultérieure si vous rencontrez CS0568 ou CS0573, car ces erreurs se produisent uniquement dans les versions antérieures de C#. C# moderne permet des constructeurs sans paramètre explicites et des initialiseurs de champs dans des structs.
• Ajoutez le public modificateur d’accès à n’importe quel constructeur de struct sans paramètre, car les constructeurs de struct sans paramètre doivent être publics pour garantir que l’allocation default d’expression et de tableau peut initialiser correctement les instances de struct (CS8958).
• Ajoutez un : this(...) initialiseur à des constructeurs explicitement déclarés dans un struct qui a un constructeur principal, car tous les constructeurs sans paramètre doivent être chaînés au constructeur principal ou à un autre constructeur déclaré explicitement pour garantir l’initialisation cohérente (CS8982).
• Déclarez un constructeur explicite lorsque votre struct utilise des initialiseurs de champs, car le compilateur requiert un constructeur explicite pour s’assurer que les initialiseurs de champs sont appelés (CS8983). Ce constructeur peut être un constructeur sans paramètre avec un corps vide.

Les avertissements suivants indiquent qu’un champ ou une propriété n’est pas explicitement affecté avant d’être lu ou avant le retour du contrôle à l’appelant :

• CS9018 : La propriété implémentée automatiquement est lue avant d’être attribuée explicitement, ce qui provoque une affectation implicite précédente de « default ».
• CS9019 : Le champ est lu avant d’être attribué explicitement, ce qui provoque une affectation implicite précédente de « default ».
• CS9020 : L’objet « this » est lu avant l’affectation de tous ses champs, ce qui entraîne l’affectation implicite précédente de champs « default » à des champs non attribués explicitement.
• CS9021 : Le contrôle est retourné à l’appelant avant l’affectation explicite de la propriété implémentée automatiquement, ce qui provoque une affectation implicite précédente de « default ».
• CS9022 : Le contrôle est retourné à l’appelant avant que le champ soit explicitement affecté, ce qui provoque une affectation implicite précédente de « default ».

Pour réduire ces avertissements en silence, affectez explicitement tous les champs et propriétés implémentées automatiquement avant de les lire ou avant le retour du contrôle du constructeur (CS9018, CS9019, CS9020, CS9021, CS9022). Lorsque des membres non attribués sont lus, le compilateur leur assigne implicitement default, ce qui peut ne pas être le comportement prévu.

Appels de constructeurs avec base et this

• CS0516: Le constructeur ne peut pas s'appeler lui-même.
• CS0517 : 'class' n’a pas de classe de base et ne peut pas appeler un constructeur de base.
• CS0522: Les structures ne peuvent pas appeler les constructeurs de la classe de base.
• CS0768: Un constructeur ne peut pas s'appeler lui-même par l'intermédiaire d'un autre constructeur.
• CS1018 : Mot clé 'this' ou 'base' attendu.

En utilisant des initialiseurs de constructeur, un constructeur peut appeler un autre constructeur à l’aide : this() ou : base(). Pour plus d’informations, consultez Utilisation des constructeurs.

Pour corriger ces erreurs, essayez les suggestions suivantes :

• Arrêtez les chaînes d’appels de constructeur circulaires, car un constructeur ne peut pas s’appeler directement ou indirectement via un autre constructeur (CS0516, CS0768). Assurez-vous que le chaînage du constructeur se termine par un constructeur qui ne fait pas appel à un autre constructeur de même type.
• Supprimez l'initialiseur : base() à partir des constructeurs dans les types de struct ou à partir des constructeurs dans System.Object, car ces types n'ont pas de constructeur de classe de base à appeler (CS0517, CS0522). Les types de struct héritent implicitement de System.ValueType, mais vous ne pouvez pas appeler explicitement son constructeur.
• Terminez l’initialiseur du constructeur ou supprimez le signe deux-points (:) de la déclaration du constructeur, car lorsqu’un signe deux-points suit une signature de constructeur, le compilateur attend this() ou base() (CS1018). Ajoutez l’appel du constructeur approprié ou supprimez entièrement le signe deux-points si aucun chaînage n'est souhaité.

Enregistrements et constructeurs de copie

• CS8867: Aucun constructeur de copie accessible n'a été trouvé dans le type de base.
• CS8868: un constructeur de copie dans un enregistrement doit appeler un constructeur de copie de la base, ou un constructeur d’objet sans paramètre si l’enregistrement hérite de l’objet.
• CS8878: Un constructeur de copie doit être public ou protégé, car l’enregistrement n’est pas scellé.
• CS8910: Le constructeur primaire entre en conflit avec le constructeur de copie synthétisé.

Dans un type d’enregistrement dérivé, votre constructeur de copie explicite doit appeler le constructeur de copie du type de base à l’aide de l’initialiseur : this() . Si l’enregistrement hérite directement de System.Object, il peut appeler le constructeur d’objet sans paramètre à la place (CS8868).

Les enregistrements incluent un constructeur de copie synthétisé par le compilateur. Vous pouvez écrire un constructeur de copie explicite, mais il doit répondre à des exigences spécifiques. Le compilateur génère des erreurs lorsque les constructeurs de copie d’enregistrement ne respectent pas ces exigences :

• Le type de base doit avoir un constructeur de copie accessible. Tous les record types ont un constructeur de copie. Assurez-vous que le type de base est un record, ou ajoutez-y un constructeur de copie accessible (CS8867).
• Dans un type d’enregistrement dérivé, votre constructeur de copie explicite doit appeler le constructeur de copie du type de base à l’aide de l’initialiseur : base() . Si l’enregistrement hérite directement de System.Object, il peut appeler le constructeur d’objet sans paramètre à la place (CS8868).
• Les constructeurs de copie doivent être public ou protected sauf si le type d’enregistrement est sealed. Ajoutez le modificateur d’accès approprié au constructeur de copie (CS8878).
• Si votre constructeur de copie explicite a la même signature que le constructeur de copie synthétisé, les définitions sont en conflit. Supprimez votre constructeur de copie explicite ou modifiez sa signature (CS8910).

Déclaration du constructeur principal

Les constructeurs principaux déclarent des paramètres directement dans la déclaration de type. Le compilateur synthétise un champ pour stocker un paramètre de constructeur principal lorsque vous l’utilisez dans des initialiseurs de membres ou de champs.

Chaînage du constructeur

• CS8861 : liste d’arguments inattendue .
• CS8862: Un constructeur déclaré dans un type avec une liste de paramètres doit avoir l'initialisateur de constructeur « this ».
• CS9122: liste de paramètres inattendue.

Lorsqu’un type a un constructeur principal, tous les autres constructeurs déclarés explicitement doivent y être chaînés à l’aide de : this(...). Ajoutez un : this(...) initialiseur qui transmet les arguments appropriés au constructeur principal (CS8862).

Supprimez une liste de paramètres de la référence de type de base lorsque le type de base n’a pas de constructeur principal. La syntaxe class Derived : Base(args) est valide uniquement quand Base un constructeur principal (CS8861). De même, supprimez une liste de paramètres de constructeur principal d’une interface déclaration, car les interfaces ne peuvent pas avoir de constructeurs principaux (CS9122).

Utilisation des paramètres dans les appels de constructeur de base

• CS9105: Impossible d’utiliser le paramètre de constructeur principal dans ce contexte.
• CS9106: Identificateur est ambigu entre le type et le paramètre dans ce contexte.

Vous ne pouvez utiliser les paramètres de constructeur principal que dans l’appel du constructeur de base si vous les transmettez dans le cadre de la déclaration du constructeur principal. Pour corriger CS9105, déplacez l’utilisation des paramètres vers la clause de base de la déclaration de type au lieu de l’utiliser dans l’appel : base() du constructeur explicitement déclaré.

Si un type et un paramètre de constructeur principal partagent le même nom, la référence devient ambiguë. Pour corriger CS9106, renommez le type ou le paramètre.

Paramètres de type semblable à ref

• CS9108: Impossible d’utiliser un paramètre qui a un type de type de type ref à l’intérieur d’une méthode anonyme, d’une expression lambda, d’une expression de requête ou d’une fonction locale.
• CS9109 : Impossible d’utiliser ref, outou in paramètre de constructeur principal à l’intérieur d’un membre d’instance.
• CS9110: Impossible d’utiliser le paramètre du constructeur principal qui a un type ressemblant à ref à l’intérieur d’un membre d’instance.
• CS9136: Impossible d'utiliser un paramètre de constructeur primaire de type à l'intérieur d'un membre d'instance.

Pour résoudre ces erreurs :

• Les paramètres de constructeur principal de ref struct type ont des restrictions sur l’emplacement où vous pouvez les utiliser. Déplacez l’accès au paramètre hors des expressions lambda, des expressions de requête ou des fonctions locales (CS9108). Dans les types qui ne sont pas ref struct, accédez aux paramètres ref struct uniquement dans les initialiseurs de champ ou le corps du constructeur, pas dans les membres d’instance (CS9110, CS9136).
• Pour les types ref struct, vous ne pouvez pas utiliser de paramètres de constructeur principal avec des modificateurs in, ref ou out dans les méthodes d'instance ou les accesseurs de propriété. Copiez la valeur du paramètre dans un champ dans le constructeur et utilisez ce champ dans les membres d’instance à la place (CS9109).

Restrictions de type de struct

• CS9111: Les méthodes anonymes, les expressions lambda, les expressions de requête et les fonctions locales à l’intérieur d’un membre d’instance d’une structure ne peuvent pas accéder au paramètre du constructeur principal.
• CS9112: les méthodes anonymes, les expressions lambda, les expressions de requête et les fonctions locales à l'intérieur d'une structure ne peuvent pas accéder au paramètre de constructeur principal également utilisé à l'intérieur d'un membre d'instance.
• CS9120 : Il est impossible de retourner par référence le paramètre du constructeur principal.
• CS9121: Le paramètre de type du constructeur primaire de la structure provoque un cycle dans l'agencement de la structure.

Pour résoudre ces erreurs :

• Dans les types de struct, vous ne pouvez pas capturer les paramètres du constructeur principal dans les expressions lambda, les expressions de requête ou les fonctions locales à l’intérieur des membres d’instance. Copiez le paramètre dans une variable ou un champ local avant de l’utiliser dans ces contextes (CS9111, CS9112).
• Vous ne pouvez pas retourner par référence les paramètres du constructeur principal dans les types de structure. Stockez la valeur dans un champ et retournez ce champ par référence si nécessaire (CS9120).
• Vérifiez que le type d’un paramètre de constructeur principal ne crée pas de cycle dans la disposition du struct. Un struct ne peut pas contenir de champ de son propre type directement ou indirectement (CS9121).

Restrictions de structure en lecture seule

• CS9114: Un paramètre de constructeur primaire d'un type en lecture seule ne peut pas être assigné (sauf dans le setter init-only du type ou dans un initialisateur de variable).
• CS9115: Un paramètre de constructeur primaire d'un type en lecture seule ne peut pas être renvoyé par une référence inscriptible.
• CS9116: Un paramètre de constructeur principal d’un type en lecture seule ne peut pas être utilisé comme valeur ref ou out (sauf dans un setter uniquement pour l'initialisation du type ou dans l'initialisation d'une variable).
• CS9117: Les membres du paramètre primaire du constructeur d'un type en lecture seule ne peuvent pas être modifiés (sauf dans le setter init-only du type ou dans un initialisateur de variable).
• CS9118: Les membres d'un paramètre de constructeur primaire d'un type en lecture seule ne peuvent pas être retournés par une référence inscriptible.
• CS9119: Les membres du paramètre de constructeur principal d’un type en lecture seule ne peuvent pas être utilisés comme valeurs ref ou out (sauf dans un setter d'initialisation uniquement du type ou d’un initialiseur de variable).

Pour résoudre ces erreurs :

• Dans les types readonly struct, vous ne pouvez pas modifier les paramètres du constructeur principal et leurs membres en dehors des setters réservés à l'initialisation ou des initialiseurs de variables. Déplacez les affectations vers des initialiseurs de champs ou des setters de propriétés init uniquement (CS9114, CS9117).
• Vous ne pouvez pas retourner les paramètres du constructeur principal et leurs membres par référence modifiable dans les types readonly struct. Retournez par readonly ref ou par valeur à la place (CS9115, CS9118).
• Vous ne pouvez pas passer les paramètres du constructeur principal et leurs membres comme arguments ref ou out dans les types readonly struct. Passez-les par valeur ou en tant qu’arguments in à la place (CS9116, CS9119).

Avertissements pour les paramètres capturés et ombrés

• CS9107 : Le paramètre est capturé dans l’état du type englobant et sa valeur est également passée au constructeur de base. La valeur peut également être capturée par la classe de base.
• CS9113 : Le paramètre n’est pas lus.
• CS9124: Paramètre est capturé dans l’état du type englobant et sa valeur est également utilisée pour initialiser un champ, une propriété ou un événement.
• CS9179 : le paramètre du constructeur principal est ombré par un membre de base.

Les avertissements suivants indiquent des problèmes potentiels liés à la façon dont vous stockez ou accédez aux paramètres du constructeur principal :

• Vous pouvez stocker un paramètre deux fois si vous le transmettez tous deux au constructeur de base et que vous y accédez dans le type dérivé. Vous pouvez avoir une copie dans la classe de base et une autre dans la classe dérivée. Déterminez si vous avez besoin des deux copies ou restructurez votre code pour éviter la duplication (CS9107).
• Vous n’avez pas besoin d’un paramètre de constructeur principal si vous ne l’avez jamais lu. Supprimez les paramètres inutilisés de la déclaration du constructeur principal (CS9113).
• Vous pouvez stocker un paramètre deux fois si vous le capturez tous les deux dans le type englobant et l’utilisez pour initialiser un champ, une propriété ou un événement. Envisagez d’utiliser le paramètre capturé directement au lieu d’initialiser un membre distinct (CS9124).
• Un membre de type de base ombre un paramètre de constructeur principal lorsque les deux ont le même nom. Renommez le paramètre pour éviter toute confusion (CS9179).