Errori e avvisi correlati alle dichiarazioni di proprietà

È possibile riscontrare gli errori seguenti correlati alle dichiarazioni di proprietà:

• CS0200: la proprietà o l'indicizzatore 'property' non può essere assegnata a - è di sola lettura
• CS0273: Il modificatore di accessibilità dell'accessore 'accessore' deve essere più restrittivo rispetto alla proprietà o all'indicizzatore 'proprietà'
• CS0274: Impossibile specificare modificatori di accessibilità per entrambe le funzioni di accesso della proprietà o dell'indicizzatore 'property'
• CS0275: 'funzione di accesso': i modificatori di accessibilità non possono essere usati nelle funzioni di accesso in un'interfaccia
• CS0276: 'property': i modificatori di accessibilità sugli accessori possono essere usati solo se la proprietà o l'indicizzatore ha sia un metodo get che un metodo set
• CS0442: 'property': le proprietà astratte non possono avere funzioni di accesso private
• CS0544: 'property': impossibile eseguire l'override perché 'member' non è una proprietà
• CS0545: 'function': impossibile eseguire l'override perché 'property' non dispone di un accessor get sottoponibile a override
• CS0546: 'accessorio': impossibile sovrascrivere perché 'property' non dispone di un accessorio set sovrascrivibile
• CS0547: 'property': una proprietà o indicizzatore non può avere tipo void
• CS0548: 'property': la proprietà o l'indicizzatore devono avere almeno una funzione di accesso
• CS0571: 'function': impossibile chiamare in modo esplicito l'operatore o l'accessor
• CS0610: Il campo o la proprietà non può essere di tipo 'type'
• CS0840: 'Nome proprietà' deve dichiarare un corpo perché non è contrassegnato come abstract o extern. Le proprietà implementate automaticamente devono definire le funzioni di accesso get e set.
• CS1014: prevista una funzione di accesso get o set
• CS1043: { o ; previsto
• CS1715: 'tipo': il tipo deve essere 'tipo' per corrispondere al membro sottoposto a override 'member'
• CS8050: solo le proprietà implementate automaticamente o le proprietà che usano la parola chiave 'field' possono avere inizializzatori.
• CS8051: le proprietà implementate automaticamente devono avere funzioni di accesso get.
• CS8053: le proprietà dell'istanza nelle interfacce non possono avere inizializzatori.
• CS8080: le proprietà implementate automaticamente devono eseguire l'override di tutte le funzioni di accesso della proprietà sottoposta a override.
• CS8145: Le proprietà implementate automaticamente non possono restituire per riferimento
• CS8147: Le proprietà restituite dal riferimento non possono avere funzioni di accesso impostate
• CS8341: le proprietà dell'istanza implementate automaticamente negli struct readonly devono essere di sola lettura.
• CS8657: il membro statico 'member' non può essere contrassegnato come 'readonly'.
• CS8658: L'accessorio 'set' implementato automaticamente 'accessor' non può essere contrassegnato come 'readonly'.
• CS8659: la proprietà 'property' implementata automaticamente non può essere contrassegnata come 'readonly' perché dispone di una funzione di accesso 'set'.
• CS8660: non è possibile specificare i modificatori 'readonly' sia sulla proprietà o indicizzatore 'property' che sul suo accessore. Rimuovere uno di essi.
• CS8661: Impossibile specificare modificatori 'readonly' su entrambi gli accessor della proprietà o dell'indicizzatore 'property'. Inserire invece un modificatore 'readonly' direttamente sulla proprietà stessa.
• CS8664: 'property': 'readonly' può essere usato solo nelle funzioni di accesso se la proprietà o l'indicizzatore dispone di una funzione di accesso get e set
• CS8852: La proprietà o l'indicizzatore 'property' solo per l'inizializzazione può essere assegnata solo in un inizializzatore di oggetto, oppure su 'this', 'base' in un costruttore di istanza o in un accessorio 'init'.
• CS8853: 'member' deve corrispondere solo init del membro sottoposto a override 'member'
• CS8855: gli accessori 'accessor' e 'accessor' devono essere entrambi init-only o nessuno
• CS8856: la funzione di accesso 'init' non è valida nei membri statici
• CS8903: le funzioni di accesso 'init' non possono essere contrassegnate come 'readonly'. Contrassegnare 'property' invece in modo di sola lettura.
• CS9029: i tipi e gli alias non possono essere denominati 'required'.
• CS9030: 'member' deve essere necessario perché esegue l'override del membro richiesto 'member'
• CS9031: il membro obbligatorio 'member' non può essere nascosto da 'member'.
• CS9032: il membro obbligatorio non può essere meno visibile o avere un setter meno visibile rispetto al tipo contenitore.
• CS9033: Non usare 'System.Runtime.CompilerServices.RequiredMemberAttribute'. Usare invece la parola chiave 'required' nei campi e nelle proprietà obbligatori.
• CS9034: il membro obbligatorio deve essere impostato.
• CS9035: il membro obbligatorio deve essere impostato nell'inizializzatore di oggetto o nel costruttore dell'attributo.
• CS9036: al membro obbligatorio 'memberName' deve essere assegnato un valore, non può usare un membro annidato o un inizializzatore di raccolta.
• CS9037: l'elenco dei membri necessari per 'type' non è valido e non può essere interpretato.
• CS9038: l'elenco dei membri necessari per il tipo di base 'type' non è valido e non può essere interpretato. Per usare questo costruttore, applicare l'attributo 'SetsRequiredMembers'.
• CS9039: questo costruttore deve aggiungere 'SetsRequiredMembers' perché si concatena a un costruttore con tale attributo.
• CS9040: il tipo non può soddisfare il vincolo 'new()' sul parametro nel tipo o nel metodo generico perché ha membri necessari.
• CS9042: Il membro obbligatorio non deve essere attribuito con 'ObsoleteAttribute' a meno che il tipo che lo contiene non sia obsoleto o che tutti i costruttori siano obsoleti.
• CS9045: i membri obbligatori non sono consentiti al livello superiore di uno script o di un invio.
• CS9258: in questa versione del linguaggio la parola chiave 'field' viene associata a un campo sottostante sintetizzato per la proprietà . Per evitare di generare un campo sottostante sintetizzato e fare riferimento al membro esistente, usare invece 'this.field' o '@field'.
• CS9263: una proprietà parziale non può avere un inizializzatore sia nella definizione che nell'implementazione.

È possibile generare i seguenti avvisi per le proprietà basate su campo:

• CS9264: La proprietà non nullable 'property' deve contenere un valore non nullo all'uscita dal costruttore. È consigliabile aggiungere il modificatore 'required', dichiarare la proprietà come nullable oppure gestire in modo sicuro il caso in cui 'field' è null nell'accessor 'get'.
• CS9266: L'accessor 'accessor' della proprietà 'property' dovrebbe usare 'field' perché l'altro accessor lo usa.
• CS9273: in questa versione del linguaggio 'field' è una parola chiave all'interno di una funzione di accesso alle proprietà. Rinominare la variabile o usare invece l'identificatore '@field'.

Le sezioni seguenti descrivono le cause e le correzioni per questi errori e avvisi.

Accessibilità della funzione di accesso

• CS0273: il modificatore di accessibilità dell'accessorio 'accessorio' deve essere più restrittivo rispetto alla proprietà o all'indicizzatore 'proprietà'
• CS0274: Impossibile specificare modificatori di accessibilità per entrambe le funzioni di accesso della proprietà o dell'indicizzatore 'property'
• CS0275: 'funzione di accesso': i modificatori di accessibilità non possono essere usati nelle funzioni di accesso in un'interfaccia
• CS0276: 'property': i modificatori di accessibilità nelle funzioni di accesso possono essere usati solo se la proprietà o l'indicizzatore dispone di una funzione di accesso get e set
• CS0442: 'property': le proprietà astratte non possono avere funzioni di accesso private

Questi errori applicano le regole per i modificatori di accesso negli accessori delle proprietà e dell'indicizzatore. Per le regole complete, vedere Limitazione dell'accessibilità delle funzioni di accesso e delle funzioni di accesso nella specifica C#. Per correggere questi errori, applicare una delle modifiche seguenti in base alla diagnostica specifica:

• Usare un modificatore di accesso più restrittivo rispetto all'accessibilità dichiarata della proprietà (CS0273). Ad esempio, una internal proprietà può avere una private funzione di accesso impostata, ma non una public . L'accessibilità della funzione di accesso deve essere un sottogruppo appropriato dell'accessibilità della proprietà.
• Applicare un modificatore di accesso a uno solo dei due accessor (CS0274). La dichiarazione di proprietà stabilisce l'accessibilità predefinita per entrambe le funzioni di accesso e una sola funzione di accesso può essere diversa da quella predefinita. Applicare il modificatore di accesso su qualsiasi accedente che necessiti di accesso limitato.
• Rimuovere i modificatori di accesso dagli accessor nelle dichiarazioni di proprietà dell'interfaccia (CS0275). I membri dell'interfaccia definiscono un contratto pubblico e i modificatori di accesso per le singole funzioni di accesso non sono consentiti. Se è necessario limitare l'accesso, applicare invece la restrizione nella classe di implementazione.
• Aggiungere sia un get metodo di accesso che un set metodo di accesso alla proprietà prima di applicare un modificatore di accesso a uno (CS0276). I modificatori di accesso sugli accessor distinguono la visibilità di un accessor dall'altro, il che richiede la presenza di entrambi gli accessor. Se la proprietà dispone di una sola funzione di accesso, rimuovere il modificatore di accesso.
• Modificare il modificatore di accesso degli accessori delle proprietà astratte da private a uno meno restrittivo (CS0442). I membri astratti devono essere accessibili alle classi derivate in modo che tali classi possano fornire implementazioni. Usare protected, internalo protected internal invece di private.

Per altre informazioni, vedere Limitazione dell'accessibilità e delle proprietà della funzione di accesso.

Sintassi della dichiarazione di proprietà

• CS0547: 'proprietà': la proprietà o l'indicizzatore non può avere tipo void
• CS0548: 'property': la proprietà o l'indicizzatore devono avere almeno un metodo di accesso
• CS0571: 'function': impossibile chiamare l'operatore o l'accessore in modo esplicito
• CS0610: Il campo o la proprietà non può essere di tipo 'type'
• CS0840: 'Nome proprietà' deve dichiarare un corpo perché non è contrassegnato come abstract o extern. Le proprietà implementate automaticamente devono definire le funzioni di accesso get e set.
• CS1014: prevista una funzione di accesso get o set
• CS1043: { o ; previsto

Questi errori applicano i requisiti strutturali delle dichiarazioni di proprietà e indicizzatori. Per le regole complete, vedere Proprietà e la sezione Proprietà della specifica C#. Per correggere questi errori, applicare una delle modifiche seguenti in base alla diagnostica specifica:

• Modificare il tipo di proprietà da void a un tipo valido (CS0547). Le proprietà e gli indicizzatori rappresentano espressioni e void non sono un tipo di espressione valido. Scegliere il tipo appropriato per i dati rappresentato dalla proprietà .
• Aggiungere almeno una funzione di accesso (get, seto init) alla dichiarazione di proprietà (CS0548). Una proprietà senza metodi di accesso non consente di leggere o scrivere il relativo valore. Includere un get accessore, un set accessore, un init accessore, o entrambi.
• Accedere alle proprietà usando la sintassi delle proprietà anziché chiamare direttamente i metodi della funzione di accesso (CS0571). Le funzioni di accesso alle proprietà vengono compilate in metodi denominati get_PropertyName e set_PropertyName, ma richiamano questi metodi tramite la sintassi delle proprietà (obj.Property e obj.Property = value). Lo stesso principio si applica agli operatori. Usare la sintassi dell'operatore (++obj) anziché chiamare metodi come op_Increment.
• Modificare il tipo di campo o di proprietà da un tipo con restrizioni a un tipo consentito (CS0610). Alcuni tipi come TypedReference e ArgIterator non possono essere usati come campi o proprietà. Questi tipi possono comunque essere usati come parametri del metodo o variabili locali.
• Per una proprietà di sola lettura, dichiarare una getproprietà implementata automaticamente solo . In caso contrario, aggiungere sia get che set come accessori alle dichiarazioni di proprietà implementate automaticamente o fornire corpi di accessor espliciti (CS0840). Per una proprietà che necessita di logica personalizzata, usare la field parola chiave aggiunta in C# 13 per accedere al campo sottostante sintetizzato dal compilatore nel corpo della funzione di accesso. Per le proprietà abstract o extern, rimuovere i corpi degli accessor perché l'implementazione viene fornita altrove. Per le proprietà partial, suddividere la dichiarazione e l'implementazione tra dichiarazioni di tipo parziale.
• Verificare che il corpo della proprietà contenga solo parole chiave di accesso valide, ovvero get, set o init (CS1014). I corpi delle proprietà non possono contenere istruzioni arbitrarie o dichiarazioni di membri. Spostare campi e metodi all'esterno della proprietà nel corpo della classe o dello struct.
• Usare la sintassi corretta della funzione di accesso alle proprietà con parentesi graffe o corpi di espressione (CS1043). I corpi delle funzioni di accesso devono usare parentesi graffe { }, le funzioni di accesso con corpo di espressione devono usare => la sintassi e le proprietà implementate automaticamente devono terminare con un punto e virgola dopo il token della funzione di accesso.

Per altre informazioni, vedere Proprietà, Proprietà implementate automaticamente e Uso delle proprietà.

Sovrascrittura delle proprietà

• CS0544: 'property': impossibile eseguire l'override perché 'member' non è una proprietà
• CS0545: 'function': impossibile eseguire l'override perché 'property' non dispone di un metodo get sovrascrivibile
• CS0546: 'funzione di accesso': impossibile eseguire l'override perché 'property' non dispone di una funzione di accesso set sostituibile
• CS1715: 'type': il tipo deve essere 'type' per corrispondere al membro sovrascritto 'member'
• CS8080: le proprietà implementate automaticamente devono eseguire l'override di tutte le funzioni di accesso della proprietà sottoposta a override.

Questi errori applicano le regole per l'override delle proprietà nelle classi derivate. Per le regole complete, vedere la sezione Ereditarietà e funzioni di accesso virtuali, sealed, override e astratte della specifica C#. Per correggere questi errori, applicare una delle modifiche seguenti in base alla diagnostica specifica:

• Assicurarsi che il membro di cui si esegue l'override sia una proprietà, non un campo o un metodo (CS0544). La override parola chiave in una proprietà può essere usata solo come destinazione di una virtualproprietà , abstracto override in una classe di base. Per nascondere un membro non di proprietà con una proprietà, usare la new parola chiave anziché override.
• Eseguire l'override solo delle funzioni di accesso presenti nella dichiarazione di proprietà della classe di base (CS0545, CS0546). Non è possibile eseguire l'override di una funzione di accesso alle proprietà che non è presente o accessibile nella classe di base perché non esiste alcun metodo virtuale di cui eseguire l'override. Se la proprietà della classe base ha solo una get funzione di accesso, non è possibile aggiungere una set funzione di accesso tramite un override. Aggiungere la funzione di accesso mancante alla classe base e contrassegnarla virtualoppure usare new per nascondere la proprietà della classe di base con una nuova definizione di proprietà.
• Associa il tipo della proprietà di override con il tipo del membro sottoposto a override (CS1715). Le proprietà di sola lettura (get-only) supportano i tipi restituiti covarianti a partire da C# 9, in modo che l'override possa restituire un tipo più derivato. Tuttavia, le proprietà che hanno un accessor set o init richiedono una corrispondenza esatta del tipo perché il setter accetta i valori del tipo dichiarato. Se è necessario un tipo diverso in una proprietà con un setter, modificare il tipo di proprietà nella classe derivata in modo che corrisponda alla dichiarazione della classe base oppure rimuovere il setter e usare invece un tipo restituito covariante.
• Includere tutte le funzioni di accesso dalla proprietà di base quando si esegue l'override con una proprietà implementata automaticamente (CS8080). Le proprietà implementate automaticamente generano implementazioni di archiviazione e funzioni di accesso, pertanto devono eseguire l'override di tutte le funzioni di accesso presenti nella classe di base. Se la proprietà di base ha sia get che set, anche l'override implementato automaticamente deve avere entrambi. Per eseguire l'override solo di funzioni di accesso specifiche, implementare la proprietà con corpi di accesso espliciti e un campo sottostante esplicito anziché usare l'implementazione automatica.

Per altre informazioni, vedere Ereditarietà, proprietà e utilizzo delle proprietà.

Proprietà supportate dal campo

• CS9258: in questa versione del linguaggio la parola chiave 'field' viene associata a un campo sottostante sintetizzato per la proprietà . Per evitare di generare un campo sottostante sintetizzato e fare riferimento al membro esistente, usare invece 'this.field' o '@field'.
• CS9263: una proprietà parziale non può avere un inizializzatore sia nella definizione che nell'implementazione.
• CS9264: La proprietà 'property' non annullabile deve contenere un valore non nullo quando si esce dal costruttore. È consigliabile aggiungere il modificatore 'required', dichiarare la proprietà come annullabile, oppure gestire in modo sicuro il caso in cui 'field' è nullo nella funzione di accesso 'get'.
• CS9266: L'accessore della proprietà 'property' deve utilizzare 'field' perché l'altro accessore lo sta utilizzando.
• CS9273: in questa versione del linguaggio 'field' è una parola chiave all'interno di una funzione di accesso alle proprietà. Rinominare la variabile o usare invece l'identificatore '@field'.

Per correggere gli errori delle proprietà basate su campi, applicare una delle modifiche seguenti in base alla diagnostica specifica:

• Rinominare qualsiasi variabile denominata field in un identificatore diverso oppure usare la @field sintassi di escape per fare riferimento alla variabile (CS9258, CS9273). Questa correzione è necessaria perché field è una parola chiave contestuale all'interno delle funzioni di accesso alle proprietà in C# 13 e versioni successive, in cui fa riferimento al campo sottostante sintetizzato dal compilatore. Se si desidera accedere a un membro esistente denominato field anziché al campo sottostante sintetizzato, qualificarlo con this.field per evitare ambiguità con il riferimento.
• Rimuovere l'inizializzatore dalla definizione della proprietà parziale o dall'implementazione, mantenendone uno solo (CS9263). Questa correzione è necessaria perché consentire gli inizializzatori in entrambe le posizioni creerebbe ambiguità sul valore da usare e potrebbe causare l'inizializzazione del campo sottostante due volte con valori potenzialmente diversi.
• Aggiungere gli attributi [field: MaybeNull, AllowNull] alla dichiarazione di proprietà per indicare che il campo sottostante deve essere considerato nullable (CS9264). Questa correzione allinea le aspettative di nullità tra il tipo di proprietà e il campo di supporto sintetizzato dal compilatore, risolvendo la mancata corrispondenza in cui la proprietà viene dichiarata come non annullabile, ma l'utilizzo della parola chiave field suggerisce che potrebbe essere null. In alternativa, modificare il tipo di proprietà in nullable, aggiungere il modificatore per garantire l'inizializzazione required o inizializzare la proprietà nel costruttore.
• Usare in modo coerente la parola chiave field in entrambi gli accessori o utilizzare un campo sottostante esplicito in entrambi gli accessori (CS9266). Questa correzione impedisce potenziali bug in cui una funzione di accesso modifica il campo sottostante sintetizzato dal compilatore mentre l'altra funzione di accesso modifica un percorso di archiviazione diverso, causando un comportamento incoerente delle proprietà.

Per altre informazioni, vedere la parola chiave field e le proprietà Partial.

Proprietà di sola lettura

• CS0200: la proprietà o l'indicizzatore 'property' non può essere assegnata a - è di sola lettura
• CS8341: le proprietà dell'istanza implementate automaticamente negli struct readonly devono essere di sola lettura.
• CS8657: il membro statico 'member' non può essere contrassegnato come 'readonly'.
• CS8658: la funzione di accesso 'set' implementata automaticamente 'accessor' non può essere contrassegnata come 'readonly'.
• CS8659: la proprietà 'property' implementata automaticamente non può essere contrassegnata come 'readonly' perché dispone di una funzione di accesso 'set'.
• CS8660: Non è possibile specificare il modificatore 'readonly' sia per la proprietà o indicizzatore 'property', sia per il suo accessor. Rimuovere uno di essi.
• CS8661: impossibile specificare modificatori 'readonly' in entrambe le funzioni di accesso della proprietà o dell'indicizzatore 'property'. Inserire invece un modificatore "readonly" sulla proprietà stessa.
• CS8664: 'property': 'readonly' può essere usato solo nelle funzioni di accesso se la proprietà o l'indicizzatore dispone di una funzione di accesso get e set

Per correggere gli errori di proprietà readonly, applicare una delle modifiche seguenti in base alla diagnostica specifica:

• Aggiungere un set o init accessor alla proprietà per renderla scrivibile (CS0200). Questa correzione è necessaria perché le proprietà senza funzioni di accesso impostate sono di sola lettura e possono essere assegnate solo nell'inizializzatore di campo o costruttore del tipo dichiarante. Se è necessario impostare la proprietà durante l'inizializzazione dell'oggetto ma lasciarla immutabile in un secondo momento, usare un init metodo di accesso anziché un set metodo di accesso. Se la proprietà deve rimanere di sola lettura, spostare l'assegnazione nel costruttore dove è consentita l'inizializzazione o valutare se l'assegnazione è necessaria.
• Contrassegnare le proprietà dell'istanza implementate automaticamente come readonly quando vengono dichiarate all'interno di un readonly struct oggetto (CS8341). Questa correzione applica il contratto di immutabilità della struttura contenitore, assicurando che tutti i membri dell'istanza rispettino la garanzia readonly. Se la proprietà deve essere modificabile, rimuovere il readonly modificatore dalla dichiarazione di struct o implementare la proprietà con un campo sottostante esplicito e corpi di accesso che non modificano lo stato dell'istanza.
• Rimuovere il readonly modificatore dalle dichiarazioni di proprietà o accessor statici (CS8657). Questa correzione è necessaria perché il readonly modificatore si applica solo ai membri dell'istanza di struct per indicare che non modificano lo stato dell'istanza e i membri statici non hanno lo stato dell'istanza da proteggere. Se è necessaria una proprietà statica di sola lettura, è sufficiente omettere la set funzione di accesso anziché usare il readonly modificatore.
• Rimuovere il modificatore readonly dalle funzioni di accesso set implementate automaticamente, o applicare il modificatore solo alla funzione di accesso get (CS8658). Questa correzione è necessaria perché set le funzioni di accesso modificano intrinsecamente lo stato, che contraddice lo scopo del modificatore che non garantisce alcuna modifica dello stato dell'istanza readonly . Se hai bisogno di una proprietà che può essere impostata durante l'inizializzazione, ma successivamente è di sola lettura, usa un init accessor invece di un set accessor.
• Rimuovere il readonly modificatore dalla dichiarazione di proprietà quando la proprietà dispone di una set funzione di accesso (CS8659). Questa correzione è necessaria perché le proprietà con set funzioni di accesso possono modificare lo stato dell'istanza, violando la readonly garanzia. Se è necessaria solo l'impostazione al momento dell'inizializzazione, sostituire l'set accessor con un init accessor o rimuovere completamente l'set accessor per rendere la proprietà veramente di sola lettura.
• Posizionare il readonly modificatore nella dichiarazione di proprietà o nelle singole funzioni di accesso, ma non entrambe (CS8660, CS8661). Questa correzione impedisce dichiarazioni di modificatore ridondanti che potrebbero creare confusione sul modificatore che ha la precedenza. Se si desidera contrassegnare funzioni di accesso specifiche come readonly, rimuovere il modificatore dalla dichiarazione di proprietà e inserirlo solo nelle funzioni di accesso. In alternativa, se tutte le funzioni di accesso devono essere readonly, contrassegnare la proprietà stessa anziché le singole funzioni di accesso.
• Assicurarsi che entrambi i metodi di accesso get e set siano presenti quando si contrassegnano i singoli metodi di accesso come readonly (CS8664). Questa correzione è necessaria perché il readonly modificatore nelle singole funzioni di accesso distingue tra le funzioni di accesso che modificano lo stato e quelle che non lo fanno, il che ha senso solo quando esistono entrambi i tipi di funzione di accesso. Se la proprietà dispone solo di una get funzione di accesso, contrassegnare l'intera proprietà come readonly anziché la singola funzione di accesso.

Per altre informazioni, vedere Membri dell'istanza readonly, parola chiave init e Proprietà.

Proprietà di sola inizializzazione

• CS8852: La proprietà o l'indicizzatore 'property' di tipo init-only può essere assegnata solo in un inizializzatore di oggetto o su 'this' o 'base' in un costruttore di istanza o in un accessor 'init'.
• CS8853: 'member' deve corrispondere solo init del membro sottoposto a override 'member'
• CS8855: Gli accessor 'accessor' e 'accessor' devono essere entrambi init-only oppure nessuno dei due
• CS8856: la funzione di accesso 'init' non è valida nei membri statici
• CS8903: le funzioni di accesso 'init' non possono essere contrassegnate come 'readonly'. Contrassegnare 'property' invece in modo di sola lettura.

Questi errori applicano le regole per l'accessor init, che abilita l'inizializzazione di oggetti non modificabili. Per le regole complete, vedere parola chiave init. Per correggere questi errori, applicare una delle modifiche seguenti in base alla diagnostica specifica:

• Spostare le assegnazioni alle proprietà di sola inizializzazione in un inizializzatore di oggetto, in un costruttore o in un init metodo di accesso (CS8852). Le proprietà di sola inizializzazione non possono essere assegnate dopo il completamento della costruzione dell'oggetto. Assegnare il valore nel corpo del costruttore, un init accessore o un'espressione di inizializzatore di oggetto (new MyType { Property = value }). Se è necessario assegnare la proprietà dopo la costruzione, modificare l'accessor init in un accessor set.
• Abbina il tipo di funzione di accesso init o set quando si esegue l'override di una proprietà (CS8853). Se la proprietà della classe di base utilizza un init accessor, la proprietà di override deve anche utilizzare init. Analogamente, se la base usa set, l'override deve usare set. Questa coerenza garantisce che il contratto di immutabilità stabilito dal tipo di base venga mantenuto nei tipi derivati.
• Usare lo stesso tipo di funzione di accesso (init o set) in entrambe le funzioni di accesso in un'implementazione esplicita dell'interfaccia (CS8855). Quando un tipo implementa in modo esplicito due interfacce che dichiarano la stessa proprietà, entrambe le implementazioni della funzione di accesso devono accettare: entrambi usano init o entrambi usano set.
• Rimuovere la init funzione di accesso dalle dichiarazioni di proprietà statiche o modificarla in una set funzione di accesso (CS8856). L'init accessor è progettato per i modelli di inizializzazione di istanze legati alla costruzione degli oggetti, e i membri statici non partecipano all'inizializzazione degli oggetti. Utilizzare un set accessor per le proprietà statiche mutabili o rimuovere completamente il setter per le proprietà statiche di sola lettura.
• Rimuovere il readonly modificatore dall'init accessore (CS8903). Il readonly modificatore di un membro di struct garantisce che il membro non modifica l'istanza del struct. Poiché un init accessor assegna lo stato dell'istanza, modifica intrinsecamente la struttura e non può essere contrassegnata come readonly. Per rendere l'get accessor readonly, applicare il readonly modificatore solo all'get accessor.

Per altre informazioni, vedere parola chiave init e Inizializzatori di oggetti e raccolte.

Inizializzatori di proprietà

• CS8050: solo le proprietà implementate automaticamente o le proprietà che usano la parola chiave 'field' possono avere inizializzatori.
• CS8051: le proprietà implementate automaticamente devono avere funzioni di accesso get.
• CS8053: le proprietà dell'istanza nelle interfacce non possono avere inizializzatori.

Per correggere gli errori dell'inizializzatore di proprietà, applicare una delle modifiche seguenti in base alla diagnostica specifica:

• Convertire la proprietà in modo da usare la sintassi implementata automaticamente rimuovendo i corpi della funzione di accesso e consentendo al compilatore di generare il campo sottostante (CS8050). Questa correzione è necessaria perché solo le proprietà con l'archiviazione gestita dal compilatore possono avere inizializzatori, assicurandosi che l'inizializzazione venga eseguita prima dell'esecuzione di qualsiasi logica di accesso. In alternativa, modificare le implementazioni della funzione di accesso per usare la field parola chiave per accedere al campo sottostante sintetizzato dal compilatore. Questo approccio abilita l'inizializzatore mantenendo la logica dell'accessorio personalizzato. Se nessuno dei due approcci è adatto, rimuovere l'inizializzatore e assegnare invece il valore in un costruttore, in cui si ha il controllo completo sulla sequenza di inizializzazione.
• Aggiungere una get funzione di accesso alla proprietà implementata automaticamente per abilitare la lettura del valore inizializzato (CS8051). Questa correzione è necessaria perché gli inizializzatori impostano un valore che deve essere recuperabile e una proprietà di sola scrittura viola questa aspettativa fondamentale di inizializzazione della proprietà. Se è effettivamente necessaria una proprietà di sola scrittura, implementare le funzioni di accesso in modo esplicito con un campo sottostante e assegnare il campo direttamente in un costruttore anziché usare un inizializzatore di proprietà.
• Rimuovere l'inizializzatore dalle dichiarazioni di proprietà dell'interfaccia (CS8053). Questa correzione è necessaria perché le interfacce definiscono i contratti per l'implementazione dei tipi anziché fornire implementazioni concrete con valori iniziali. Se è necessario specificare i valori predefiniti, implementare la proprietà in una classe che implementa l'interfaccia o usare metodi di interfaccia predefiniti (disponibili in C# 8.0 e versioni successive) per fornire un'implementazione predefinita.

Per altre informazioni, vedere Proprietà, Proprietà implementate automaticamente e parola chiave di campo.

Membri obbligatori

• CS9029: i tipi e gli alias non possono essere denominati 'required'.
• CS9030: 'member' deve essere necessario perché esegue l'override del membro richiesto 'member'
• CS9031: Il membro obbligatorio 'member' non può essere nascosto da 'member'.
• CS9032: Il membro richiesto non può avere una visibilità inferiore o avere un setter con visibilità inferiore rispetto al tipo che lo contiene.
• CS9033: Non usare 'System.Runtime.CompilerServices.RequiredMemberAttribute'. Usare invece la parola chiave 'required' nei campi e nelle proprietà obbligatori.
• CS9034: il membro obbligatorio deve poter essere impostato.
• CS9035: il membro obbligatorio deve essere impostato nell'inizializzatore di oggetto o nel costruttore dell'attributo.
• CS9036: al membro obbligatorio 'memberName' deve essere assegnato un valore, non può usare un membro annidato o un inizializzatore di raccolta.
• CS9037: l'elenco dei membri necessari per 'type' non è valido e non può essere interpretato.
• CS9038: l'elenco dei membri necessari per il tipo di base 'type' non è valido e non può essere interpretato. Per usare questo costruttore, applicare l'attributo 'SetsRequiredMembers'.
• CS9039: questo costruttore deve aggiungere 'SetsRequiredMembers' perché si concatena a un costruttore con tale attributo.
• CS9040: il tipo non può soddisfare il vincolo 'new()' sul parametro nel tipo o nel metodo generico perché ha membri necessari.
• CS9042: il membro obbligatorio non deve essere attribuito con 'ObsoleteAttribute' a meno che il tipo contenitore non sia obsoleto o che tutti i costruttori siano obsoleti.
• CS9045: i membri obbligatori non sono consentiti al livello superiore di uno script o di un invio.

Per correggere gli errori relativi ai membri richiesti, applicare una delle modifiche seguenti in base alla diagnostica specifica:

• Evitare di usare required come tipo o nome alias (CS9029). Questa correzione è necessaria perché required è una parola chiave contestuale in C# 11 e versioni successive e l'uso come nome di tipo crea ambiguità nel codice in cui potrebbe essere visualizzata la parola chiave.
• Assicurarsi che i membri derivati mantengano il modificatore required quando eseguono l'override dei membri obbligatori (CS9030). Questa correzione applica il contratto stabilito dalla classe base, garantendo che tutti i tipi derivati mantengano gli stessi requisiti di inizializzazione. Evitare di nascondere i membri richiesti con membri non richiesti nelle classi derivate (CS9031), perché questa azione interrompe il contratto di inizializzazione che i consumatori si aspettano dal tipo base.
• Rendere i membri richiesti almeno altrettanto visibili quanto il loro tipo contenitore e assicurarsi che i metodi setter delle proprietà siano sufficientemente visibili (CS9032). Questa correzione impedisce situazioni in cui un tipo è accessibile pubblicamente, ma i relativi membri necessari non possono essere inizializzati da tutti i contesti in cui viene costruito il tipo.
• Usare la required parola chiave anziché applicare RequiredMemberAttribute manualmente (CS9033). Questa correzione garantisce che il compilatore generi i metadati corretti e applichi tutte le regole membro necessarie, che l'applicazione manuale dell'attributo potrebbe non eseguire correttamente.
• Assicurarsi che i membri obbligatori abbiano funzioni di accesso impostate o siano altrimenti impostabili (CS9034). Questa correzione è necessaria perché i membri necessari devono essere inizializzati durante la creazione dell'oggetto, che richiede l'accesso in scrittura. Quando si creano istanze, inizializzare i membri necessari direttamente negli inizializzatori di oggetto (CS9035, CS9036). È necessario assegnare un valore a ogni membro necessario anziché utilizzare inizializzatori di membri annidati o inizializzatori di raccolta, perché il membro necessario deve essere impostato prima di accedere alle relative proprietà.
• Applicare l'attributo SetsRequiredMembers ai costruttori che inizializzano tutti i membri necessari nei rispettivi corpi (CS9038, CS9039). Questa correzione informa il compilatore che il costruttore soddisfa il contratto membro richiesto, consentendo la creazione di oggetti senza inizializzatori di oggetti. Se un costruttore si concatena a un altro costruttore con SetsRequiredMembers, deve avere anche l'attributo .
• Evitare di usare i membri obbligatori nei tipi che devono soddisfare il new() vincolo (CS9040), perché il costruttore senza parametri non può garantire l'inizializzazione dei membri richiesta senza un inizializzatore di oggetto. Non contrassegnare i membri obbligatori come obsoleti a meno che il tipo contenitore o tutti i costruttori siano obsoleti (CS9042), per evitare situazioni in cui i membri sono necessari, ma il loro uso è sconsigliato. I membri obbligatori non sono consentiti nelle istruzioni di primo livello o nei contesti di script (CS9045) perché questi contesti non supportano la sintassi di inizializzazione degli oggetti necessaria per impostare i membri necessari.

Per altre informazioni, vedere l'articolo di riferimento del modificatore richiesto e la guida inizializzatori di oggetti e raccolte .

Proprietà che restituiscono riferimenti

• CS8145: Le proprietà implementate automaticamente non possono restituire per riferimento
• CS8147: Le proprietà restituite dal riferimento non possono avere funzioni di accesso impostate

Per correggere gli errori di proprietà ref-returning, applicare una delle modifiche seguenti in base alla diagnostica specifica:

• Implementare la proprietà in modo esplicito con un campo sottostante e usare la ref parola chiave nell'espressione di restituzione dell'accessor get (CS8145). Questa correzione è necessaria perché le proprietà implementate automaticamente generano un campo sottostante privato gestito dal compilatore internamente. La restituzione di un riferimento a un campo privato espone l'archiviazione interna a cui i chiamanti non devono accedere direttamente. Per creare una proprietà che restituisce un riferimento, dichiarare un campo esplicito e restituirlo utilizzando la sintassi => ref backingField. In alternativa, se non è necessario restituire un riferimento per consentire la modifica diretta dello spazio di archiviazione, rimuovere il ref modificatore dalla dichiarazione di proprietà.
• Rimuovere l'accessor set dalle proprietà che restituiscono riferimenti (CS8147). Questa correzione è necessaria perché una proprietà che restituisce ref fornisce già l'accesso in lettura e scrittura tramite il riferimento restituito stesso. I chiamanti possono modificare direttamente il valore tramite il riferimento senza bisogno di un metodo setter separato. L'inclusione di una set funzione di accesso creerebbe due meccanismi diversi per la modifica della stessa risorsa di archiviazione, ridondante e potrebbe causare confusione sul percorso di modifica da usare.

Per altre informazioni, vedere ref returns e ref locals e Proprietà.