Erreurs et avertissements liés aux déclarations de propriétés

Vous pouvez rencontrer les erreurs suivantes liées aux déclarations de propriétés :

• CS0200 : La propriété ou l'indexeur 'property' ne peut pas être assignée -- il est en lecture seule
• CS0545 : 'fonction' : ne peut être redéfinie, car la 'propriété' n’a pas d’accesseur get redéfinissable
• CS0571 : 'function' : impossible d’appeler explicitement l’opérateur ou l’accesseur
• CS0840 : « Nom de propriété » doit déclarer un corps, car il n’est pas marqué comme abstrait ou extern. Les propriétés implémentées automatiquement doivent définir les accesseurs get et set.
• CS1014 : Un accesseur get ou set attendu
• CS1043 : { ou ; attendu
• CS8050 : Seules les propriétés implémentées automatiquement, ou les propriétés qui utilisent le mot clé « field », peuvent avoir des initialiseurs
• CS8051 : Les propriétés implémentées automatiquement doivent avoir des accesseurs get
• CS8053 : Les propriétés d’instance dans les interfaces ne peuvent pas avoir d’initialiseurs
• CS8145 : Les propriétés implémentées automatiquement ne peuvent pas retourner par référence
• CS8147 : Les propriétés retournées par référence ne peuvent pas avoir d’accesseurs définis
• CS8341 : Les propriétés d’instance implémentées automatiquement dans les structs en lecture seule doivent être en lecture seule
• CS8657 : Le membre statique ne peut pas être marqué « readonly »
• CS8658 : l’accesseur « set » implémenté automatiquement ne peut pas être marqué « readonly »
• CS8659 : La propriété implémentée automatiquement ne peut pas être marquée « readonly » car elle a un accesseur « set »
• CS8660 : Impossible de spécifier des modificateurs « readonly » sur la propriété et son accesseur
• CS8661 : Impossible de spécifier des modificateurs « readonly » sur les deux accesseurs de propriété
• CS8664 : « readonly » ne peut être utilisé que sur les accesseurs si la propriété a à la fois un accesseur get et un accesseur set
• CS9029 : Les types et alias ne peuvent pas être nommés « obligatoires ».
• CS9030 : Le membre doit être requis, car il remplace le membre requis.
• CS9031 : Le membre requis ne peut pas être masqué par un membre dérivé.
• CS9032 : Le membre obligatoire ne peut pas être moins visible ou avoir un setter moins visible que le type conteneur.
• CS9033 : N’utilisez pas «System.Runtime.CompilerServices.RequiredMemberAttribute' . Utilisez plutôt le mot clé « required » sur les champs et propriétés obligatoires.
• CS9034 : Le membre requis doit être modifiable.
• CS9035 : Le membre obligatoire doit être défini dans le constructeur d’initialiseur ou d’attribut d’objet.
• CS9036 : Le membre obligatoire 'memberName' doit être affecté à une valeur, il ne peut pas utiliser un initialiseur de membre ou de collection imbriqué.
• CS9037 : La liste des membres obligatoires est incorrecte et ne peut pas être interprétée.
• CS9038 : La liste des membres requis pour le type de base est incorrecte et ne peut pas être interprétée. Pour utiliser ce constructeur, appliquez l’attribut 'SetsRequiredMembers .
• CS9039 : ce constructeur doit ajouter «SetsRequiredMembers », car il est lié à un constructeur qui a cet attribut.
• CS9040 : Le type ne peut pas satisfaire la contrainte «new() » sur le paramètre dans le type ou la méthode générique, car il a des membres requis.
• CS9042 : Le membre requis ne doit pas être annoté avec «ObsoleteAttribute », sauf si le type conteneur est obsolète ou si tous les constructeurs sont obsolètes.
• CS9045 : Les membres requis ne sont pas autorisés au niveau supérieur d’un script ou d’une soumission.
• CS9258 : Dans cette version de langage, le mot clé «field » est lié à un champ de stockage synthétisé pour la propriété. Pour éviter de générer un champ de stockage synthétisé et de faire référence au membre existant, utilisez «this.field » ou «@field » à la place.
• CS9263 : Une propriété partielle ne peut pas avoir d’initialiseur sur la définition et l’implémentation.

Les avertissements suivants peuvent être générés pour les propriétés sauvegardées par champ :

• CS9264: La propriété non nullable doit contenir une valeur non null lors de la sortie du constructeur. Envisagez d’ajouter le modificateur « required », de déclarer la propriété comme nullable, ou ajouter l'attribut «[field: MaybeNull, AllowNull]».
• CS9266 : Un accesseur de propriété doit utiliser «field », car l’autre accesseur l’utilise.
• CS9273 : Dans cette version de langage, 'field' est un mot clé dans un accesseur de propriété. Renommez la variable ou utilisez plutôt l’identificateur «@field ».

Les sections suivantes expliquent la cause et les correctifs pour ces erreurs et avertissements.

Syntaxe de l’accesseur de propriété

• CS0545 : 'function' : impossible de remplacer, car 'property' n’a pas d’accesseur get substituable
• CS0571 : 'function' : il est impossible d’appeler explicitement l’opérateur ou l’accesseur
• CS1043 : { ou ; attendu

Pour corriger les erreurs de syntaxe des accesseurs de propriétés, appliquez l'une des modifications suivantes en fonction du diagnostic spécifique :

Remplacez uniquement les accesseurs qui existent dans la déclaration de propriété de classe de base (CS0545). Vous ne pouvez pas remplacer un accesseur de propriété qui n’est pas présent ou accessible dans la classe de base, car il n’existe aucune méthode virtuelle à remplacer dans l’il compilé. Si la propriété de la classe de base n’a qu’un get accesseur, supprimez l’accesseur set de votre redéfinition ou ajoutez l’accesseur manquant à la classe de base et marquez-le virtual. Vous pouvez également utiliser le mot clé new au lieu de override pour masquer la propriété de la classe de base avec une définition de propriété entièrement nouvelle qui comporte des accesseurs différents.

Accédez aux propriétés en utilisant la syntaxe de propriété, plutôt que d’appeler directement des méthodes d’accesseur (CS0571). Les accesseurs de propriété se compilent en méthodes spéciales avec des noms tels que get_PropertyName et set_PropertyName, mais vous devez appeler ces méthodes via la syntaxe de propriété obj.Property et obj.Property = value. Cette approche gère la sémantique appropriée et permet au compilateur d’effectuer des vérifications nécessaires. Le même principe s’applique aux opérateurs, qui compilent à des méthodes comme op_Increment mais doivent être appelées à l’aide de la syntaxe d’opérateur (++obj) plutôt que des appels de méthode.

Utilisez une syntaxe d’accesseur de propriété appropriée avec des accolades ou des corps d’expression (CS1043). Les accesseurs de propriété doivent suivre les règles de syntaxe C# : les corps des accesseurs doivent être placés entre accolades { }, les accesseurs à expression doivent utiliser la syntaxe =>, et les propriétés auto-implémentées doivent se terminer par un point-virgule après la liste des accesseurs. Le compilateur attend une implémentation d’accesseur complète ou le point-virgule qui indique un accesseur implémenté automatiquement.

Pour plus d’informations, consultez Propriétés, Héritage et Utilisation des propriétés.

Propriétés implémentées automatiquement

• CS0840 : « Nom de propriété » doit déclarer un corps, car il n’est pas marqué comme abstrait ou extern. Les propriétés implémentées automatiquement doivent définir les accesseurs get et set.
• CS1014 : Un accesseur set ou get est attendu

Pour corriger les erreurs de propriété implémentées automatiquement, appliquez l’une des modifications suivantes en fonction du diagnostic spécifique :

Ajoutez à la fois get et set comme accesseurs à la déclaration de propriété (CS0840). Les propriétés implémentées automatiquement nécessitent que le compilateur génère un champ de stockage, et le compilateur ne peut le faire que lorsque les deux accesseurs sont présents pour garantir que le stockage peut être lu et écrit. Si vous avez besoin d'une propriété automatiquement implémentée en lecture seule, incluez un accesseur set et utilisez private pour restreindre l'accès en écriture tout en permettant au compilateur de générer le champ de stockage. Alternativement, si la propriété est déclarée en tant que abstract ou extern, supprimez entièrement les corps des accesseurs, car ces modificateurs indiquent que l’implémentation est fournie ailleurs. Pour partial les propriétés, vous pouvez fractionner la déclaration et l’implémentation entre les déclarations de type partiel.

Assurez-vous que la déclaration de propriété contient uniquement les mots clés valides get et set d’accesseur (CS1014). La syntaxe de propriété n'autorise que les déclarations d’accesseur, et non les déclarations arbitraires ni les déclarations de membre dans le corps de la propriété elle-même. Si vous avez besoin d’une logique supplémentaire, implémentez la propriété avec des corps d’accesseur explicites qui contiennent votre code. Si vous tentez de déclarer des champs ou des méthodes, déplacez ces déclarations en dehors de la propriété vers la classe ou le corps de la structure où les déclarations de membre sont autorisées.

Pour plus d’informations, consultez Propriétés et propriétés implémentées automatiquement.

Propriétés basées sur un champ

• CS9258 : Dans cette version de langage, le mot clé «field » est lié à un champ de stockage synthétisé pour la propriété. Pour éviter de générer un champ de stockage synthétisé et de faire référence au membre existant, utilisez «this.field » ou «@field » à la place.
• CS9263 : Une propriété partielle ne peut pas avoir d’initialiseur sur la définition et l’implémentation.
• CS9264 : La propriété non annulable doit contenir une valeur non nulle lors de la sortie du constructeur. Considérez l'ajout du modificateur « required », déclarez la propriété comme annulable, ou ajoutez des attributs «[field: MaybeNull, AllowNull] ».
• CS9266 : Un accesseur de propriété doit utiliser «field », car l’autre accesseur l’utilise.
• CS9273 : Dans cette version de langage, 'field' est un mot clé dans un accesseur de propriété. Renommez la variable ou utilisez plutôt l’identificateur «@field ».

Pour corriger les erreurs de propriété basées sur des champs, appliquez l’une des modifications suivantes en fonction du diagnostic spécifique :

Renommez une variable nommée field en un autre identificateur ou utilisez la @field syntaxe d’échappement pour faire référence à votre variable (CS9258, CS9273). Cette correction est nécessaire, car field il s’agit d’un mot clé contextuel dans les accesseurs de propriétés en C# 13 et versions ultérieures, où il fait référence au champ de stockage synthétisé par le compilateur. Si vous souhaitez accéder à un membre existant nommé field au lieu du champ de stockage synthétisé, qualifiez-le avec this.field pour lever l’ambiguïté de la référence.

Supprimez l’initialiseur de la définition de propriété partielle ou de l’implémentation, en conservant une seule (CS9263). Cette correction est requise, car l'autorisation des initialiseurs dans les deux emplacements créerait une ambiguïté quant à la valeur à utiliser et pourrait entraîner l’initialisation du champ de stockage deux fois avec des valeurs potentiellement différentes.

Ajoutez les [field: MaybeNull, AllowNull] attributs à la déclaration de propriété pour indiquer que le champ de stockage doit être traité comme nullable (CS9264). Cette correction aligne les attentes en matière de nullabilité entre le type de propriété et le champ de stockage synthétisé par le compilateur, en résolvant l’incompatibilité où la propriété est déclarée non nullable, mais l’utilisation field du mot clé suggère qu’elle pourrait être null. Vous pouvez également remplacer le type de propriété par Nullable, ajouter le required modificateur pour garantir l’initialisation ou initialiser la propriété dans le constructeur.

Utilisez systématiquement soit le mot-clé field dans les deux accesseurs, soit un champ de stockage explicite dans les deux accesseurs (CS9266). Cette correction empêche les bogues potentiels dans lesquels un accesseur modifie le champ de stockage synthétisé par le compilateur tandis que l’autre accesseur modifie un autre emplacement de stockage, ce qui entraîne un comportement de propriété incohérent.

Pour plus d’informations, consultez le mot clé de champ et les propriétés partielles.

Propriétés en lecture seule

• CS0200 : La propriété ou l’indexeur 'property' ne peut pas être affecté à -- il est en lecture seule
• CS8341 : Les propriétés d’instance implémentées automatiquement dans les structs en lecture seule doivent être en lecture seule
• CS8657 : Le membre statique ne peut pas être marqué « readonly »
• CS8658 : l’accesseur « set » implémenté automatiquement ne peut pas être marqué « readonly »
• CS8659 : La propriété implémentée automatiquement ne peut pas être marquée « readonly » car elle a un accesseur « set »
• CS8660 : Impossible de spécifier des modificateurs « readonly » sur la propriété et son accesseur
• CS8661 : Il est impossible de spécifier des modificateurs « readonly » sur les deux accesseurs d'une propriété
• CS8664 : « readonly » ne peut être utilisé que sur les accessoires de propriété si la propriété a à la fois un getter et un setter

Pour corriger les erreurs de propriété en lecture seule, appliquez l’une des modifications suivantes en fonction du diagnostic spécifique :

Ajoutez un accesseur set ou init à la propriété pour la rendre modifiable (CS0200). Cette correction est nécessaire, car les propriétés sans accesseurs définis sont en lecture seule et peuvent uniquement être affectées dans le constructeur ou l’initialiseur de champ du type déclarant. Si vous avez besoin que la propriété soit définie lors de l’initialisation de l’objet mais immuable par la suite, utilisez un init accesseur au lieu d’un set accesseur. Si la propriété doit rester en lecture seule, déplacez l’affectation dans le constructeur où l’initialisation est autorisée, ou reconsidérez si l’affectation est vraiment nécessaire.

Marquez les propriétés d’instance implémentées automatiquement comme readonly lorsque vous les déclarez dans un readonly struct (CS8341). Cette correction applique le contrat d'immuabilité de la structure conteneur, garantissant que tous les membres de l'instance respectent la garantie readonly. Si la propriété doit être mutable, supprimez le modificateur readonly de la déclaration de structure ou implémentez la propriété avec un champ de stockage explicite et des corps d’accesseur qui ne modifient pas l’état de l’instance.

Retirez le readonly modificateur dans les déclarations de propriété statique ou d’accesseur (CS8657). Cette correction est requise, car le readonly modificateur s’applique uniquement aux membres d’instance des structs pour indiquer qu’ils ne modifient pas l’état de l’instance et que les membres statiques n’ont pas d’état d’instance à protéger. Si vous avez besoin d’une propriété statique en lecture seule, omettez simplement l’accesseur set plutôt que d’utiliser le readonly modificateur.

Supprimez le readonly modificateur des accesseurs automatiquement implémentés set ou appliquez-le uniquement à l’accesseur get (CS8658). Cette correction est nécessaire, car set les accesseurs modifient intrinsèquement l’état, ce qui contredit l’objectif du modificateur qui garantit aucune modification de l’état de readonly l’instance. Si vous avez besoin d’une propriété qui peut être définie pendant l’initialisation, mais qu’elle est en lecture seule par la suite, utilisez un init accesseur au lieu d’un set accesseur.

Supprimez le readonly modificateur de la déclaration de propriété lorsque la propriété a un set accesseur (CS8659). Cette correction est requise, car les propriétés avec set des accesseurs peuvent modifier l’état de l’instance, ce qui enfreint la readonly garantie. Si vous avez besoin de configurer uniquement lors de l'initialisation, remplacez l'accesseur set par un autre init, ou supprimez entièrement l'accesseur set afin que la propriété soit vraiment en lecture seule.

Placez le readonly modificateur sur la déclaration de propriété ou sur des accesseurs individuels, mais pas les deux (CS8660, CS8661). Cette correction empêche les déclarations de modificateur redondantes susceptibles de créer une confusion quant aux modificateurs qui sont prioritaires. Si vous souhaitez désigner des accesseurs spécifiques avec readonly, retirez le modificateur de la déclaration de la propriété et placez-le uniquement sur les accesseurs. Sinon, si tous les accesseurs doivent être readonly, marquez la propriété elle-même plutôt que les accesseurs individuels.

Assurez-vous que les accesseurs get et set sont présents lors du marquage des accesseurs individuels en tant que readonly (CS8664). Cette correction est nécessaire, car le readonly modificateur sur les accesseurs individuels fait la distinction entre les accesseurs qui modifient l’état et ceux qui ne le font pas, ce qui n’est logique que lorsque les deux types d’accesseur existent. Si la propriété n’a qu’un get accesseur, marquez l'intégralité de la propriété comme readonly au lieu de l’accesseur individuel.

Pour plus d’informations, consultez les membres de l’instance en lecture seule, le mot-clé ‹init› et les propriétés.

Initialiseurs de propriétés

• CS8050 : Seules les propriétés implémentées automatiquement, ou les propriétés qui utilisent le mot clé « field », peuvent avoir des initialiseurs
• CS8051 : Les propriétés implémentées automatiquement doivent avoir des accesseurs get
• CS8053 : Les propriétés d’instance dans les interfaces ne peuvent pas avoir d’initialiseurs

Pour corriger les erreurs d’initialiseur de propriété, appliquez l’une des modifications suivantes en fonction du diagnostic spécifique :

Convertissez la propriété pour utiliser la syntaxe implémentée automatiquement en supprimant les corps d’accesseur et en laissant le compilateur générer le champ de stockage (CS8050). Cette correction est nécessaire, car seules les propriétés avec le stockage géré par le compilateur peuvent avoir des initialiseurs, ce qui garantit que l’initialisation se produit avant l’exécution d’une logique d’accesseur. Vous pouvez également modifier les implémentations d’accesseur pour utiliser le mot clé field pour accéder au champ d'assistance synthétisé par le compilateur. Cette approche active l'initialiseur tout en conservant la logique personnalisée des accesseurs. Si aucune approche n’est appropriée, supprimez l’initialiseur et affectez la valeur dans un constructeur à la place, où vous avez un contrôle total sur la séquence d’initialisation.

Ajoutez un get accesseur à la propriété implémentée automatiquement pour permettre la lecture de la valeur initialisée (CS8051). Cette correction est requise, car les initialiseurs définissent une valeur qui doit être récupérable, et une propriété en écriture seule enfreint cette attente fondamentale d’initialisation des propriétés. Si vous avez vraiment besoin d'une propriété à écriture seule, implémentez explicitement les accesseurs avec un champ de stockage et définissez le champ directement dans un constructeur plutôt que d'utiliser un initialiseur de propriété.

Supprimez l’initialiseur des déclarations de propriétés d’interface (CS8053). Cette correction est nécessaire, car les interfaces définissent des contrats pour l’implémentation de types plutôt que de fournir des implémentations concrètes avec des valeurs initiales. Si vous devez fournir des valeurs par défaut, implémentez la propriété dans une classe qui implémente l’interface ou utilisez les méthodes d’interface par défaut (disponibles en C# 8.0 et versions ultérieures) pour fournir une implémentation par défaut.

Pour plus d’informations, consultez Propriétés, Propriétés implémentées automatiquement et mot clé de champ.

Membres nécessaires

• CS9029 : Les types et alias ne peuvent pas être nommés « obligatoires ».
• CS9030 : Le membre doit être défini comme requis, puisqu'il remplace un membre requis.
• CS9031 : Le membre requis ne peut pas être masqué par un membre dérivé.
• CS9032 : Un membre requis ne peut pas être moins visible ni avoir un setter moins visible que le type conteneur.
• CS9033 : N’utilisez pas «System.Runtime.CompilerServices.RequiredMemberAttribute' . Utilisez plutôt le mot clé « required » sur les champs et propriétés obligatoires.
• CS9034 : Le membre requis doit être modifiable.
• CS9035 : Le membre obligatoire doit être défini dans le constructeur d’initialiseur ou d’attribut d’objet.
• CS9036 : Le membre obligatoire 'memberName' doit être affecté à une valeur, il ne peut pas utiliser un initialiseur de membre ou de collection imbriqué.
• CS9037 : La liste des membres obligatoires est incorrecte et ne peut pas être interprétée.
• CS9038 : La liste des membres requis pour le type de base est incorrecte et ne peut pas être interprétée. Pour utiliser ce constructeur, appliquez l’attribut 'SetsRequiredMembers .
• CS9039 : ce constructeur doit ajouter «SetsRequiredMembers », car il est lié à un constructeur qui a cet attribut.
• CS9040 : Le type ne peut pas satisfaire la contrainte «new() » sur le paramètre dans le type ou la méthode générique, car il a des membres requis.
• CS9042 : Le membre obligatoire ne doit pas être attribué avec «ObsoleteAttribute », sauf si le type conteneur est obsolète ou que tous les constructeurs sont obsolètes.
• CS9045 : Les membres requis ne sont pas autorisés au niveau supérieur d’un script ou d’une soumission.

Pour corriger les erreurs liées aux membres requis, appliquez l’une des modifications suivantes en fonction du diagnostic spécifique :

Évitez d’utiliser required comme type ou nom d’alias (CS9029). Cette correction est nécessaire, car required il s’agit d’un mot clé contextuel en C# 11 et ultérieur, et son utilisation en tant que nom de type crée une ambiguïté dans le code où le mot clé peut apparaître.

Assurez-vous que les membres dérivés conservent le modificateur required lors de la redéfinition des membres requis (CS9030). Cette correction applique le contrat établi par la classe de base, garantissant que tous les types dérivés conservent les mêmes exigences d’initialisation. Évitez de masquer les membres requis avec des membres non requis dans les classes dérivées (CS9031), car cette action interrompt le contrat d’initialisation attendu par les consommateurs du type de base.

Rendez les membres obligatoires au moins aussi visibles que leur type contenant et assurez-vous que les setters de propriétés sont également suffisamment visibles (CS9032). Cette correction empêche les situations où un type est accessible publiquement, mais ses membres requis ne peuvent pas être initialisés à partir de tous les contextes où le type est construit.

Utilisez le required mot clé au lieu d’appliquer RequiredMemberAttribute manuellement (CS9033). Cette correction garantit que le compilateur génère les métadonnées correctes et applique toutes les règles de membre requises, que l’application d’attribut manuel risque de ne pas faire correctement.

Vérifiez que les membres requis ont des accesseurs définis ou sont définissables (CS9034). Cette correction est nécessaire, car les membres requis doivent être initialisés lors de la création d’objets, ce qui nécessite un accès en écriture. Lors de la création d’instances, initialisez les membres requis directement dans les initialiseurs d’objet (CS9035, CS9036). Vous devez affecter une valeur à chaque membre requis au lieu d’utiliser des initialiseurs de membres imbriqués ou des initialiseurs de collection, car le membre requis lui-même doit être défini avant d’accéder à ses propriétés.

Appliquez l’attribut SetsRequiredMembers aux constructeurs qui initialisent tous les membres requis dans leur corps (CS9038, CS9039). Cette correction informe le compilateur que le constructeur remplit le contrat membre requis, ce qui autorise la création d’objets sans initialiseurs d’objet. Si un constructeur est lié à un autre constructeur avec SetsRequiredMembers, il doit également avoir l’attribut.

Évitez d’utiliser les membres requis dans les types qui doivent satisfaire la new() contrainte (CS9040), car le constructeur sans paramètre ne peut pas garantir l’initialisation de membre requise sans initialiseur d’objet. Ne marquez pas les membres requis comme obsolètes, sauf si le type conteneur ou tous les constructeurs sont obsolètes (CS9042), pour empêcher les situations où les membres sont requis, mais leur utilisation est déconseillée. Les membres obligatoires ne sont pas autorisés dans les instructions de niveau supérieur ou les contextes de script (CS9045), car ces contextes ne prennent pas en charge la syntaxe d’initialisation d’objet nécessaire pour définir les membres requis.

Pour plus d’informations, consultez l’article de référence sur les modificateurs requis et le guide des initialiseurs d’objets et de collection .

Propriétés retournant des références

• CS8145 : Les propriétés implémentées automatiquement ne peuvent pas retourner par référence
• CS8147 : Les propriétés retournées par référence ne peuvent pas avoir d’accesseurs définis

Pour corriger les erreurs de propriété de retour de référence, appliquez l’une des modifications suivantes en fonction du diagnostic spécifique :

Implémentez explicitement la propriété avec un champ de stockage et utilisez le mot-clé ref dans l’expression de retour de l'accesseur get (CS8145). Cette correction est nécessaire, car les propriétés implémentées automatiquement génèrent un champ de stockage privé que le compilateur gère en interne. Le renvoi d’une référence à un champ privé expose le stockage interne auquel les appelants ne doivent pas accéder directement. Pour créer une propriété retournant une référence, déclarez un champ de type explicite et retournez-le avec la syntaxe => ref backingField. Sinon, si vous n'avez pas besoin de retourner une référence permettant la modification directe du stockage concerné, supprimez l'attribut ref de la déclaration de propriété.

Supprimez l’accesseur set des propriétés de retour de référence (CS8147). Cette correction est requise, car une propriété de retour de référence fournit déjà un accès en lecture et en écriture via la référence retournée elle-même. Les appelants peuvent modifier directement la valeur via la référence sans avoir besoin d’une méthode setter distincte. L’inclusion d’un set accesseur créerait deux mécanismes différents pour modifier le même stockage, ce qui est redondant et pourrait entraîner une confusion quant au chemin de modification à utiliser.

Pour plus d’informations, consultez les retours ref et locaux ref et les propriétés.