Résoudre les erreurs et les avertissements pour les déclarations de constructeur et les initialiseurs de module

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 « 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 structs ne peuvent pas appeler des constructeurs de classe de base.
• CS0526 : Les interfaces ne peuvent pas contenir de constructeurs d’instances.
• 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.
• CS8358 : Impossible d’utiliser le constructeur d’attribut, car il a des paramètres « in » ou « ref readonly ».
• CS8760 : 'event' : l’événement extern ne peut pas avoir d’initialiseur.
• CS8813 : un initialiseur de module doit être une méthode membre ordinaire
• CS8814 : La méthode d’initialiseur de module 'method' doit être accessible au niveau du module
• CS8815 : La méthode d’initialiseur de module 'method' doit être statique et non virtuelle, ne doit pas avoir de paramètres et doit retourner 'void'
• CS8816 : La méthode d’initialiseur de module 'method' ne doit pas être générique et ne doit pas être contenue dans un type générique
• 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 ».
• 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é.
• CS8900 : Impossible d’attribuer l’initialiseur de module avec « UnmanagedCallersOnly ».
• CS8901 : 'method' est attribué avec 'UnmanagedCallersOnly' et ne peut pas être appelé directement. Obtenez un pointeur de fonction vers cette méthode.
• CS8902 : 'method' est attribué avec 'UnmanagedCallersOnly' et ne peut pas être converti en type délégué. Obtenez un pointeur de fonction vers cette méthode.
• 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 renvoyé 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 de constructeur primaire 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.
• CS9343 : Impossible de passer des arguments au type de base sans liste de paramètres dans la déclaration de type.

En outre, cet article décrit les avertissements suivants :

• 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 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 ».

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 tout : base() appel d : this() 'initialisation de constructeur du constructeur statique, car les constructeurs statiques ne peuvent pas se chaîner vers 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 d’instances.
• 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 » ou « ref readonly ».
• CS8091 : Un constructeur ne peut pas être extern et avoir un initialisateur de constructeur.
• CS8760 : 'event' : l’événement extern ne peut pas avoir d’initialiseur.

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 les paramètres in ou ref readonly pour qu'ils passent par valeur dans les constructeurs d’attributs, car les constructeurs d’attributs ne prennent pas en charge les modificateurs de paramètres in ou ref readonly (CS8358). Le runtime instancie les attributs en utilisant la réflexion, qui ne prend pas en charge le in modificateur ref readonly or.
• Supprimez l' : base() initialiseur constructeur ou : this() d'un extern constructeur, car les constructeurs externes ne peuvent pas se chaîner vers 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.
• Supprimez l’initialiseur d’une déclaration d’événement extern (CS8760). Les événements extern ont leurs accesseurs d’ajout et de suppression fournis par le code externe. Par conséquent, un initialiseur de champ dans la source n’a aucun effet et n’est pas autorisé par le compilateur.

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 assignés sont lus, le compilateur leur attribue default implicitement, ce qui n’est pas forcément le comportement souhaité.

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 la chaîne de constructeurs se termine finalement à un constructeur qui n'appelle pas un autre constructeur du même type.
• Supprimez l' : base() initialiseur des constructeurs dans les types de struct ou 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). Soit ajouter l’appel constructeur approprié, soit supprimer complètement les deux-points si aucun chaînage n’est prévu.

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éclarations d’initialiseur de module

• CS8813 : un initialiseur de module doit être une méthode membre ordinaire.
• CS8814 : La méthode d’initialiseur de module « method » doit être accessible au niveau du module.
• CS8815 : La méthode d’initialiseur de module 'method' doit être statique et non virtuelle, ne doit pas avoir de paramètres et doit retourner 'void'.
• CS8816 : La méthode d’initialiseur de module 'method' ne doit pas être générique et ne doit pas être contenue dans un type générique.
• CS8900 : Impossible d’attribuer l’initialiseur de module avec « UnmanagedCallersOnly ».
• CS8901 : 'method' est attribué avec 'UnmanagedCallersOnly' et ne peut pas être appelé directement. Obtenez un pointeur de fonction vers cette méthode.
• CS8902 : 'method' est attribué avec 'UnmanagedCallersOnly' et ne peut pas être converti en type délégué. Obtenez un pointeur de fonction vers cette méthode.

Ces erreurs appliquent les conditions requises pour les méthodes marquées avec ModuleInitializerAttribute. Les initialiseurs de module s’exécutent automatiquement lorsqu’un assembly est chargé avant l’exécution d’un autre code dans le module. Pour connaître les règles complètes, consultez les initialiseurs de module.

Pour corriger ces erreurs, appliquez l’une des modifications suivantes en fonction du diagnostic spécifique :

• Vérifiez que la méthode marquée avec [ModuleInitializer] est une méthode ordinaire, et non un accesseur de propriété, un accesseur d’événements, une fonction locale, une fonction lambda, un constructeur, un destructeur ou un opérateur (CS8813). Le compilateur ne peut traiter qu’une déclaration de méthode ordinaire comme une cible valide pour l’infrastructure d’initialiseur de module.
• Rendez la méthode d'initialiseur de module et tous ses types qui les contiennent internal ou public afin que la méthode soit accessible en dehors du type de niveau supérieur (CS8814). Le runtime doit appeler la méthode à partir du code au niveau du module généré, ce qui nécessite l’accessibilité au niveau du module.
• Déclarez la méthode d’initialiseur de module en tant que static, non virtuel, sans paramètres et avec un void type de retour (CS8815). Le runtime appelle des initialiseurs de module sans arguments et ignore le résultat. La signature de méthode doit donc correspondre exactement à ces contraintes.
• Supprimez les paramètres de type générique de la méthode d’initialiseur de module et déplacez la méthode hors de tout type générique contenant (CS8816). Le runtime ne peut pas déterminer quels arguments de type fournir lors de l’appel de l’initialiseur, de sorte que les méthodes et méthodes génériques dans les types génériques ne sont pas autorisées.
• Retirez le UnmanagedCallersOnlyAttribute de la méthode d’initialiseur du module (CS8900). Les initialiseurs de module sont appelés par l’infrastructure d’exécution managée. Ils ne peuvent donc pas être limités aux appelants non gérés uniquement.
• Obtenez un pointeur de fonction plutôt que d’appeler directement une méthode marquée [UnmanagedCallersOnly] (CS8901). Les méthodes attribuées avec UnmanagedCallersOnlyAttribute ne peuvent pas être appelées à partir du code managé. Utilisez l’opérateur & pour obtenir un pointeur de fonction (delegate* unmanaged<...>) dans un unsafe contexte et passer le pointeur au code non managé. Si votre projet n’autorise pas déjà le code non sécurisé, activez AllowUnsafeBlocks.
• Obtenez un pointeur de fonction au lieu de convertir une méthode marquée avec [UnmanagedCallersOnly] en un type délégué (CS8902). Les méthodes attribuées à UnmanagedCallersOnlyAttribute ne peuvent pas être représentées comme des délégués gérés car la convention d'appel est incompatible. Utilisez plutôt des pointeurs de fonction (delegate* unmanaged<...>) dans un unsafe contexte. Si votre projet n’autorise pas déjà le code non sécurisé, activez AllowUnsafeBlocks.

Pour plus d’informations, consultez ModuleInitializerAttribute et UnmanagedCallersOnlyAttribute.

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.
• CS9343 : Impossible de passer des arguments au type de base sans liste de paramètres dans la déclaration de type.

Lorsqu’un type possède un constructeur primaire, tous les autres constructeurs explicitement déclarés doivent s’y enchaîner en utilisant : this(...).

Pour corriger ces erreurs, essayez les suggestions suivantes :

• Ajoutez un : this(...) initialiseur qui transmet les arguments appropriés au constructeur principal, car tous les constructeurs déclarés explicitement doivent être chaînés au constructeur principal (CS8862).
• Supprimez une liste d’arguments d’une interface implémentée ou de la liste de type base d’un struct ou d’une interface. Seule une déclaration de classe avec une liste de paramètres peut passer des arguments à une classe de base dans la liste de type base (CS8861).
• Ajoutez une liste de paramètres à la déclaration de type dérivée avant de passer des arguments à la classe de base, par exemple class Derived(int value) : Base(value) { } (CS9343). La classe de base doit avoir un constructeur correspondant, mais elle n’a pas besoin d’un constructeur principal.
• 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 ces erreurs, essayez les suggestions suivantes :

• 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é, car les paramètres du constructeur principal ne peuvent apparaître que dans la clause de base de la déclaration de type (CS9105).
• Renommez le type ou le paramètre lorsqu’un type et un paramètre de constructeur principal partagent le même nom, car la référence devient ambiguë (CS9106).

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 constructeur primaire d'une structure de type provoque un cycle dans la disposition 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 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 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 principaux du constructeur et leurs membres par référence écrivable dans readonly struct types. 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).