Risolvere gli errori e gli avvisi per le dichiarazioni del costruttore e gli inizializzatori di modulo

Questo articolo illustra gli errori del compilatore seguenti:

• CS0132: 'constructor': un costruttore statico deve essere senza parametri.
• CS0514: Il costruttore statico non può avere una chiamata esplicita al costruttore 'this' o a un 'base'.
• CS0515: i modificatori di accesso non sono consentiti nei costruttori statici.
• CS0516: Il costruttore 'constructor' non può chiamare sé stesso.
• CS0517: 'class' non dispone di una classe base e non può chiamare un costruttore di base.
• CS0522: le strutture non possono chiamare i costruttori della classe base.
• CS0526: le interfacce non possono contenere costruttori di istanza.
• CS0568: gli struct non possono contenere costruttori senza parametri espliciti.
• CS0573: 'dichiarazione di campo': non può avere inizializzatori di campi dell'istanza negli struct.
• CS0710: classi statiche non possono avere costruttori di istanza.
• CS0768: Costruttore non può chiamare se stesso tramite un altro costruttore.
• CS1018: prevista la parola chiave 'this' o 'base'.
• CS8054: Enumerazioni non possono contenere costruttori espliciti senza parametri.
• CS8091: non può essere esterno e avere un inizializzatore del costruttore.
• CS8760: 'event': un evento extern non può avere un inizializzatore.
• CS8358: impossibile usare il costruttore dell'attributo perché contiene parametri 'in' o 'ref readonly'.
• CS8813: un inizializzatore di modulo deve essere un metodo membro ordinario
• CS8814: Il metodo 'method' dell'inizializzatore del modulo deve essere accessibile a livello di modulo
• CS8815: il metodo 'method' dell'inizializzatore del modulo deve essere statico e non virtuale, non deve contenere parametri e deve restituire 'void'
• CS8816: il metodo 'method' dell'inizializzatore del modulo non deve essere generico e non deve essere contenuto in un tipo generico
• CS8861: elenco di argomenti imprevisti.
• CS8862: Un costruttore dichiarato in un tipo con una lista di parametri deve avere l'inizializzatore del costruttore 'this'.
• CS8867: Nessun costruttore di copia accessibile trovato nel tipo di base '{0}'.
• CS8868: Un costruttore di copia in un record deve chiamare un costruttore di copia della base o un costruttore di oggetti senza parametri se il record eredita dall'oggetto .
• CS8878: Un costruttore di copia '{0}' deve essere pubblico o protetto perché il record non è sigillato.
• CS8900: l'inizializzatore di modulo non può essere attribuito con 'UnmanagedCallersOnly'.
• CS8901: Il metodo è contrassegnato con 'UnmanagedCallersOnly' e non può essere chiamato direttamente. Ottieni un puntatore a funzione per questo metodo.
• CS8902: 'method' ha l'attributo 'UnmanagedCallersOnly' e non può essere convertito in un tipo delegato. Ottenere un puntatore di funzione per questo metodo.
• CS8910: Il costruttore primario è in conflitto con il costruttore di copia sintetizzato.
• CS8958: Il costruttore di struct senza parametri deve essere 'public'.
• CS8982: Un costruttore dichiarato in uno 'struct' con elenco di parametri deve avere un inizializzatore 'this' che chiama il costruttore primario o un costruttore dichiarato in modo esplicito.
• CS8983: un 'struct' con inizializzatori di campo deve includere un costruttore dichiarato in modo esplicito.
• CS9105: Impossibile usare il parametro del costruttore primario in questo contesto.
• CS9106: l'identificatore è ambiguo tra il tipo e il parametro in questo contesto.
• CS9108: Non è possibile usare un parametro di tipo simile a ref all'interno di un metodo anonimo, un'espressione lambda, un'espressione di query o una funzione locale.
• CS9109: All'interno di un membro dell'istanza, non si può utilizzare il parametro del costruttore principale ref, out, o in.
• CS9110: Impossibile utilizzare un parametro del costruttore primario di tipo simile a ref all'interno di un membro dell'istanza.
• CS9111: metodi anonimi, espressioni lambda, espressioni di query e funzioni locali all'interno di un membro dell'istanza di uno struct non possono accedere al parametro del costruttore primario.
• CS9112: metodi anonimi, espressioni lambda, espressioni di query e funzioni locali all'interno di uno struct non possono accedere al parametro del costruttore primario usato anche all'interno di un membro dell'istanza.
• CS9114: Un parametro del costruttore primario di un tipo readonly non può essere assegnato (tranne nel setter init-only del tipo o un inizializzatore di variabile).
• CS9115: Un parametro del costruttore primario di un tipo readonly non può essere restituito dal riferimento scrivibile.
• CS9116: In un tipo readonly, un parametro del costruttore primario non può essere utilizzato come valore ref o out, tranne nel setter init-only del tipo o in un inizializzatore di variabile.
• CS9117: Membri del parametro del costruttore primario di un tipo readonly non possono essere modificati (tranne nel setter init-only del tipo o di un inizializzatore di variabile).
• CS9118: Membri del parametro costruttore principale di un tipo a sola lettura non possono essere restituiti tramite un riferimento scrivibile.
• CS9119: I membri del parametro del costruttore primario di un tipo readonly non possono essere utilizzati come valore ref o out (ad eccezione del setter init-only del tipo o di un inizializzatore di variabile).
• CS9120: Impossibile restituire il parametro del costruttore primario come riferimento.
• CS9121: Il parametro di tipo del costruttore primario della struttura provoca un ciclo nel layout della struttura.
• CS9122: lista di parametri inattesa.
• CS9136: Impossibile usare un parametro del costruttore primario di un tipo specifico all'interno di un membro dell'istanza.

In questo articolo sono inoltre illustrati gli avvisi seguenti:

• CS0824: Costruttore 'name' è contrassegnato come esterno.
• CS9107: Il parametro è acquisito nello stato del tipo circostante e lo stesso valore viene passato anche al costruttore di base. Il valore potrebbe essere acquisito anche dalla classe di base.
• CS9113: parametro non letto.
• CS9124: Il parametro viene catturato nello stato del tipo circostante e il relativo valore viene usato per inizializzare un campo, una proprietà o un evento.
• CS9179: il parametro del costruttore primario è ombreggiato da un membro della base
• CS9018: la proprietà implementata automaticamente viene letta prima di essere assegnata in modo esplicito, causando un'assegnazione implicita precedente di 'default'.
• CS9019: il campo viene letto prima di essere assegnato in modo esplicito, causando un'assegnazione implicita precedente di 'default'.
• CS9020: l'oggetto 'this' viene letto prima dell'assegnazione di tutti i relativi campi, causando le assegnazioni implicite precedenti di 'default' ai campi assegnati in modo non esplicito.
• CS9021: il controllo viene restituito al chiamante prima che venga assegnata in modo esplicito la proprietà implementata automaticamente, causando un'assegnazione implicita precedente di 'default'.
• CS9022: il controllo viene restituito al chiamante prima che il campo venga assegnato in modo esplicito, causando un'assegnazione implicita precedente di 'default'.

Costruttori statici

• CS0132: 'constructor': un costruttore statico deve essere senza parametri.
• CS0514: Un costruttore statico non può avere una chiamata esplicita al costruttore 'this' o 'base'.
• CS0515: i modificatori di accesso non sono consentiti nei costruttori statici.

I costruttori statici inizializzano i dati statici per un tipo. Per altre informazioni, vedere Costruttori statici.

Per correggere questi errori, verificare che la dichiarazione del costruttore statico segua queste regole:

• Rimuovere tutti i parametri dalla dichiarazione del costruttore statico, perché un costruttore statico deve essere senza parametri (CS0132). Se è necessario passare i valori di inizializzazione, è consigliabile usare campi statici o proprietà impostati prima dell'esecuzione del costruttore statico.
• Rimuovere tutti i modificatori di accesso, come public, protected, private o internal, dal costruttore statico, perché è il runtime a controllare quando il costruttore statico viene eseguito e i modificatori di accesso non sono rilevanti (CS0515).
• Rimuovere qualsiasi chiamata di inizializzatore di costruttore : base() o : this() dal costruttore statico, perché i costruttori statici non possono collegarsi ad altri costruttori (CS0514). Il runtime richiama automaticamente il costruttore statico della classe base, se presente.

Dichiarazione del costruttore

• CS0526: le interfacce non possono contenere costruttori di istanza.
• CS0710: classi statiche non possono avere costruttori di istanza.
• CS8054: Enumerazioni non possono contenere costruttori espliciti senza parametri.
• CS8358: impossibile usare il costruttore dell'attributo perché contiene parametri 'in' o 'ref readonly'.
• CS8091: Un costruttore non può essere extern e avere un inizializzatore del costruttore.
• CS8760: 'event': l'evento extern non può avere l'inizializzatore.

È possibile dichiarare costruttori solo nei tipi class e struct, inclusi i tipi record class e record struct. Per altre informazioni, vedere Costruttori di istanze.

Per correggere questi errori, provare i suggerimenti seguenti:

• Spostare il costruttore in un class tipo o struct perché non è possibile dichiarare costruttori in interface o enum tipi (CS0526, CS8054). Le interfacce definiscono i contratti, ma non forniscono la logica di inizializzazione e i tipi enumerazione hanno i valori definiti in fase di compilazione.
• Rimuovere i costruttori di istanza dalle classi statiche, perché non è possibile creare istanze delle classi statiche e pertanto non possono avere costruttori di istanza (CS0710). Se è necessaria la logica di inizializzazione, usare invece un costruttore statico.
• Modificare in o ref readonly i parametri in parametri pass-by-value nei costruttori di attributi, perché i costruttori di attributi non supportano in o ref readonly modificatori di parametri (CS8358). Il runtime istanzia gli attributi usando la reflection, che non supporta il modificatore in o il ref readonly.
• Rimuovere l'inizializzatore : base() o : this() del costruttore da un costruttore extern, perché i costruttori extern non possono concatenarsi ad altri costruttori (CS8091). L'implementazione di un costruttore extern viene fornita esternamente, quindi l'incatenamento dei costruttori non è possibile.
• Rimuovere l'inizializzatore da una dichiarazione di extern evento (CS8760). Gli eventi extern hanno le funzioni di accesso add e remove fornite dal codice esterno, quindi un inizializzatore di campo nell'origine non ha alcun effetto e non è consentito dal compilatore.

È possibile generare l'avviso seguente per le dichiarazioni del costruttore:

• CS0824: Costruttore è contrassegnato come esterno.

Quando un costruttore è contrassegnato come extern, il compilatore non riesce a verificare che esista un'implementazione. Per sopprimere questo avviso, fornire un'implementazione interna oppure assicurarsi che l'implementazione esterna sia collegata correttamente.

Costruttori nei tipi struct

• CS0568: gli struct non possono contenere costruttori espliciti senza parametri.
• CS0573: 'dichiarazione di campo': non può avere inizializzatori di campi dell'istanza negli struct.
• CS8958: Il costruttore di struct senza parametri deve essere 'public'.
• CS8982: Un costruttore dichiarato in un 'struct' con elenco di parametri deve avere un inizializzatore 'this' che chiama il costruttore primario o un costruttore dichiarato in modo esplicito.
• CS8983: uno 'struct' con inizializzatori di campo deve includere un costruttore dichiarato in modo esplicito.

I tipi di struct hanno regole specifiche per costruttori e inizializzazione dei campi. Per altre informazioni, vedere la sezione Inizializzazione Struct e valori predefiniti dell'articolo Tipi di struttura .

Per correggere questi errori, provare i suggerimenti seguenti:

• Eseguire l'aggiornamento a C# 10 o versione successiva se si verifica CS0568 o CS0573, perché questi errori si verificano solo nelle versioni precedenti di C#. C# moderno consente costruttori e inizializzatori di campo espliciti senza parametri negli struct.
• Aggiungere il public modificatore di accesso a qualsiasi costruttore di struct senza parametri, perché i costruttori di struct senza parametri devono essere pubblici per garantire che l'espressione e l'allocazione default di matrici possano inizializzare correttamente le istanze di struct (CS8958).
• Aggiungere un : this(...) inizializzatore ai costruttori dichiarati in modo esplicito in una struttura con un costruttore primario, perché tutti i costruttori non privi di parametri devono concatenarsi al costruttore primario o a un altro costruttore dichiarato in modo esplicito per garantire l'inizializzazione coerente (CS8982).
• Dichiarare un costruttore esplicito quando lo struct usa gli inizializzatori di campo, perché il compilatore richiede un costruttore esplicito per garantire che gli inizializzatori di campo vengano richiamati (CS8983). Questo costruttore può essere un costruttore senza parametri con un corpo vuoto.

Gli avvisi seguenti indicano che un campo o una proprietà non viene assegnato in modo esplicito prima di essere letto o prima che il controllo torni al chiamante:

• CS9018: la proprietà implementata automaticamente viene letta prima di essere assegnata in modo esplicito, causando un'assegnazione implicita precedente di 'default'.
• CS9019: il campo viene letto prima di essere assegnato in modo esplicito, causando un'assegnazione implicita precedente di 'default'.
• CS9020: l'oggetto 'this' viene letto prima dell'assegnazione di tutti i relativi campi, causando le assegnazioni implicite precedenti di 'default' ai campi assegnati in modo non esplicito.
• CS9021: il controllo viene restituito al chiamante prima che venga assegnata in modo esplicito la proprietà implementata automaticamente, causando un'assegnazione implicita precedente di 'default'.
• CS9022: il controllo viene restituito al chiamante prima che il campo venga assegnato in modo esplicito, causando un'assegnazione implicita precedente di 'default'.

Per disattivare questi avvisi, assegnare in modo esplicito tutti i campi e le proprietà implementate automaticamente prima di leggerli o prima che il controllo restituisca dal costruttore (CS9018, CS9019, CS9020, CS9021, CS9022). Quando i membri non assegnati vengono letti, il compilatore assegna default in modo implicito a tali membri, che potrebbe non essere il comportamento previsto.

Chiamate del costruttore con base e this

• CS0516: il costruttore non può chiamare se stesso.
• CS0517: 'class' non ha una classe di base e non può chiamare un costruttore di base.
• CS0522: gli struct non possono chiamare costruttori di classi di base.
• CS0768: Costruttore non può chiamare se stesso tramite un altro costruttore.
• CS1018: È prevista la parola chiave 'this' o 'base'.

Usando gli inizializzatori del costruttore, un costruttore può chiamare un altro costruttore usando : this() o : base(). Per altre informazioni, vedere Uso di costruttori.

Per correggere questi errori, provare i suggerimenti seguenti:

• Interrompere le catene di chiamate circolari del costruttore, perché un costruttore non può chiamare se stesso direttamente o indirettamente tramite un altro costruttore (CS0516, CS0768). Assicurarsi che il concatenamento del costruttore termini infine in un costruttore che non chiama un altro costruttore nello stesso tipo.
• Rimuovere l'inizializzatore : base() dai costruttori nei tipi di struct o dai costruttori in System.Objectperché questi tipi non hanno un costruttore di classe base da chiamare (CS0517, CS0522). I tipi di struct ereditano in modo implicito da System.ValueType, ma non è possibile chiamare in modo esplicito il relativo costruttore.
• Completare l'inizializzatore del costruttore o rimuovere i due punti (:) dalla dichiarazione del costruttore, perché quando un punto segue una firma del costruttore, il compilatore si aspetta this() o base() (CS1018). Aggiungere la chiamata al costruttore appropriata o rimuovere completamente i due punti se non è previsto alcun concatenamento.

Record e costruttori di copia

• CS8867: Nessun costruttore di copia accessibile trovato nel tipo di base.
• CS8868: Un costruttore di copia in un record deve chiamare un costruttore di copia della base o un costruttore di oggetti senza parametri se il record eredita dall'oggetto .
• CS8878: Un costruttore di copia deve essere pubblico o protetto perché il record non è sigillato.
• CS8910: Il costruttore primario è in conflitto con il costruttore di copia sintetizzato.

In un tipo di record derivato, il costruttore di copia esplicito deve chiamare il costruttore di copia del tipo di base usando l'inizializzatore : this() . Se il record eredita direttamente da System.Object, può chiamare invece il costruttore di oggetti senza parametri (CS8868).

I record includono un costruttore di copia sintetizzato dal compilatore. È possibile scrivere un costruttore di copia esplicito, ma deve soddisfare requisiti specifici. Il compilatore genera errori quando i costruttori di copia dei record violano questi requisiti:

• Il tipo base deve avere un costruttore di copia accessibile. Tutti i record tipi hanno un costruttore di copia. Verificare che il tipo di base sia un recordoggetto o aggiungervi un costruttore di copia accessibile (CS8867).
• In un tipo di record derivato, il costruttore di copia esplicito deve chiamare il costruttore di copia del tipo di base usando l'inizializzatore : base() . Se il record eredita direttamente da System.Object, può chiamare invece il costruttore di oggetti senza parametri (CS8868).
• I costruttori di copia devono essere public o protected , a meno che il tipo di record non sia sealed. Aggiungere il modificatore di accesso appropriato al costruttore di copia (CS8878).
• Se il costruttore di copia esplicita ha la stessa firma del costruttore di copia sintetizzato, le definizioni sono in conflitto. Rimuovere il costruttore di copia esplicito o modificarne la firma (CS8910).

Dichiarazioni di inizializzatore di modulo

• CS8813: un inizializzatore di modulo deve essere un metodo membro ordinario.
• CS8814: il metodo 'method' dell'inizializzatore del modulo deve essere accessibile a livello di modulo.
• CS8815: il metodo 'method' dell'inizializzatore del modulo deve essere statico e non virtuale, non deve avere parametri e deve restituire 'void'.
• CS8816: il metodo 'method' dell'inizializzatore del modulo non deve essere generico e non deve essere contenuto in un tipo generico.
• CS8900: l'inizializzatore di modulo non può essere attribuito con 'UnmanagedCallersOnly'.
• CS8901: Il 'method' è contrassegnato da 'UnmanagedCallersOnly' e non può essere chiamato direttamente. Ottenere un puntatore di funzione per questo metodo.
• CS8902: 'method' è attribuito dell'attributo 'UnmanagedCallersOnly' e non può essere convertito in un tipo delegato. Ottieni un puntatore di funzione a questo metodo.

Questi errori applicano i requisiti per i metodi contrassegnati con ModuleInitializerAttribute. Gli inizializzatori di modulo vengono eseguiti automaticamente quando un assembly viene caricato per la prima volta, prima dell'esecuzione di qualsiasi altro codice nel modulo. Per le regole complete, vedere Inizializzatori di moduli.

Per correggere questi errori, applicare una delle modifiche seguenti in base alla diagnostica specifica:

• Verificare che il metodo contrassegnato con [ModuleInitializer] sia un metodo ordinario, non una funzione di accesso alle proprietà, una funzione di accesso agli eventi, una funzione locale, un'espressione lambda, un costruttore, un distruttore o un operatore (CS8813). Il compilatore può considerare solo una dichiarazione di metodo normale come destinazione valida per l'infrastruttura dell'inizializzatore del modulo.
• Rendere il metodo inizializzatore del modulo e tutti i tipi che lo contengono internal o public in modo che il metodo sia accessibile dall'esterno del tipo di primo livello (CS8814). Il runtime deve chiamare il metodo dal codice a livello di modulo generato, che richiede l'accessibilità a livello di modulo.
• Dichiarare il metodo di inizializzatore del modulo come static, non virtuale, senza parametri e con un void tipo restituito (CS8815). Il runtime chiama gli inizializzatori di modulo senza argomenti e rimuove il risultato, quindi la firma del metodo deve corrispondere esattamente a questi vincoli.
• Rimuovere i parametri di tipo generico dal metodo dell'inizializzatore del modulo e spostare il metodo da qualsiasi tipo generico che lo contiene (CS8816). Il runtime non è in grado di determinare quali argomenti di tipo specificare quando si richiama l'inizializzatore, quindi i metodi generici e i metodi nei tipi generici non sono consentiti.
• Rimuovere il UnmanagedCallersOnlyAttribute dal metodo inizializzatore del modulo (CS8900). Gli inizializzatori di modulo vengono chiamati dall'infrastruttura di runtime gestita, quindi non possono essere limitati solo ai chiamanti non gestiti.
• Ottenere un puntatore di funzione anziché chiamare direttamente un metodo contrassegnato con [UnmanagedCallersOnly] (CS8901). I metodi con attributi con UnmanagedCallersOnlyAttribute non possono essere chiamati dal codice gestito. Usare l'operatore & per ottenere in un contesto delegate* unmanaged<...> un puntatore a funzione (unsafe) e passare il puntatore al codice non gestito. Se il progetto non consente già il codice unsafe, abilitare AllowUnsafeBlocks.
• Ottenere un puntatore a funzione anziché convertire un metodo contrassegnato con [UnmanagedCallersOnly] in un tipo delegato (CS8902). I metodi con attributi con UnmanagedCallersOnlyAttribute non possono essere rappresentati come delegati gestiti perché la convenzione di chiamata non è compatibile. Utilizza invece i puntatori a funzione (delegate* unmanaged<...>) in un contesto unsafe. Se il progetto non consente già il codice unsafe, abilitare AllowUnsafeBlocks.

Per altre informazioni, vedere ModuleInitializerAttribute e UnmanagedCallersOnlyAttribute.

Dichiarazione del costruttore primario

I costruttori primari dichiarano i parametri direttamente nella dichiarazione di tipo. Il compilatore sintetizza un campo per archiviare un parametro del costruttore primario quando viene usato nei membri o negli inizializzatori di campo.

Concatenamento dei costruttori

• CS8861: elenco di argomenti imprevisti.
• CS8862: Un costruttore definito in un tipo che contiene un elenco di parametri deve avere l'inizializzatore del costruttore 'this'.
• CS9122: elenco di parametri imprevisti.

Quando un tipo ha un costruttore primario, tutti gli altri costruttori dichiarati in modo esplicito devono concatenarlo tramite : this(...).

Per correggere questi errori, provare i suggerimenti seguenti:

• Aggiungere un : this(...) inizializzatore che passa gli argomenti appropriati al costruttore primario, perché tutti i costruttori dichiarati in modo esplicito devono essere concatenati al costruttore primario (CS8862).
• Rimuovere un elenco di parametri dal riferimento al tipo di base quando il tipo di base non ha un costruttore primario, perché la sintassi class Derived : Base(args) è valida solo quando Base ha un costruttore primario (CS8861).
• Rimuovere un elenco di parametri del costruttore primario da una interface dichiarazione, perché le interfacce non possono avere costruttori primari (CS9122).

Utilizzo dei parametri nelle chiamate al costruttore di base

• CS9105: Impossibile usare il parametro del costruttore primario in questo contesto.
• CS9106: l'identificatore è ambiguo tra il tipo e il parametro in questo contesto.

È possibile usare i parametri del costruttore primario nella chiamata al costruttore di base solo se vengono passati come parte della dichiarazione del costruttore primario.

Per correggere questi errori, provare i suggerimenti seguenti:

• Spostare l'utilizzo del parametro nella clausola base della dichiarazione di tipo anziché usarlo nella chiamata di : base() un costruttore dichiarato in modo esplicito, perché i parametri del costruttore primario possono essere visualizzati solo nella clausola base della dichiarazione di tipo (CS9105).
• Rinominare il tipo o il parametro quando un tipo e un parametro del costruttore primario condividono lo stesso nome, perché il riferimento diventa ambiguo (CS9106).

Parametri di tipo ref-like

• CS9108: Impossibile utilizzare un parametro che ha un tipo simile a ref all'interno di un metodo anonimo, un'espressione lambda, un'espressione di query o una funzione locale.
• CS9109: Non è possibile usare ref, outo in parametro del costruttore primario all'interno di un membro dell'istanza.
• CS9110: Non è possibile usare il parametro del costruttore primario con tipo simile-ref all'interno di un membro di istanza.
• CS9136: Impossibile usare il parametro del costruttore primario di tipo all'interno di un membro dell'istanza.

Per risolvere questi errori:

• I parametri del costruttore primario di ref struct tipo hanno restrizioni sulla posizione in cui è possibile usarli. Spostare l'accesso al parametro fuori dalle espressioni lambda, espressioni di query o funzioni locali (CS9108). Nei tipi che non sono ref struct, accedere ai ref struct parametri solo negli inizializzatori di campo o nel corpo del costruttore, e non nei membri dell'istanza (CS9110, CS9136).
• Per i tipi ref struct, non è possibile usare i parametri del costruttore primario con i modificatori in, ref o out nei metodi di istanza o nelle funzioni di accesso alle proprietà. Copiare il valore del parametro in un campo nel costruttore e usare tale campo nei membri dell'istanza (CS9109).

Restrizioni relative ai tipi di struct

• CS9111: I metodi anonimi, le espressioni lambda, le espressioni di query e le funzioni locali all'interno di un membro istanza di una struttura non possono accedere al parametro del costruttore primario.
• CS9112: metodi anonimi, espressioni lambda, espressioni di query e funzioni locali all'interno di uno struct non possono accedere al parametro del costruttore primario usato anche all'interno di un membro dell'istanza.
• CS9120: Non è possibile restituire un parametro del costruttore principale per riferimento.
• CS9121: Il parametro di tipo del costruttore primario Struct causa un ciclo nel layout dello struct.

Per risolvere questi errori:

• Nei tipi di struct non è possibile acquisire i parametri del costruttore primario nelle espressioni lambda, nelle espressioni di query o nelle funzioni locali all'interno dei membri dell'istanza. Copiare il parametro in una variabile o un campo locale prima di usarlo in questi contesti (CS9111, CS9112).
• Non è possibile restituire i parametri del costruttore primario per riferimento nei tipi di struct. Archiviare il valore in un campo e restituire tale campo per riferimento, se necessario (CS9120).
• Assicurarsi che il tipo di un parametro del costruttore primario non crei un ciclo nel layout dello struct. Uno struct non può contenere un campo del proprio tipo direttamente o indirettamente (CS9121).

Restrizioni dello struct readonly

• CS9114: Un parametro del costruttore primario di un tipo readonly non può essere assegnato a (tranne che nel setter accessibile solo durante l'inizializzazione del tipo o in un inizializzatore di variabile).
• CS9115: Un parametro del costruttore primario di un tipo readonly non può essere restituito tramite un riferimento scrivibile.
• CS9116: Parametro del costruttore primario di un tipo readonly non può essere usato come valore ref o out (ad eccezione del setter init-only del tipo o di un inizializzatore di variabile).
• CS9117: Membri del parametro del costruttore primario di un tipo readonly non possono essere modificati (tranne nel setter init-only del tipo o di un inizializzatore di variabile).
• CS9118: Membri del parametro del costruttore primario di un tipo readonly non possono essere restituiti da riferimenti scrivibili.
• CS9119: Membri del parametro del costruttore primario di un tipo readonly non possono essere usati come valore ref o out (ad eccezione del setter init-only del tipo o di un inizializzatore variabile).

Per risolvere questi errori:

• Nei tipi readonly struct, non è possibile modificare i parametri del costruttore primario e i relativi membri al di fuori dei setter solo di inizializzazione o degli inizializzatori di variabili. Spostare le assegnazioni in inizializzatori di campo o setter di proprietà con accesso solo in fase di inizializzazione (CS9114, CS9117).
• Non è possibile restituire i parametri del costruttore primario e i relativi membri tramite riferimento scrivibile nei tipi readonly struct. Restituire per valore o tramite readonly ref invece (CS9115, CS9118).
• Non è possibile passare i parametri del costruttore primario e i relativi membri come argomenti ref o out in tipi readonly struct. Passarli per valore o in forma di in argomenti (CS9116, CS9119).

Avvisi per i parametri acquisiti e nascosti

• CS9107: il parametro viene acquisito nello stato del tipo di inclusione e il relativo valore viene passato anche al costruttore di base. Il valore potrebbe essere acquisito anche dalla classe di base.
• CS9113: Parametro non letto.
• CS9124: Parametro viene acquisito nello stato del tipo di inclusione e il relativo valore viene usato anche per inizializzare un campo, una proprietà o un evento.
• CS9179: il parametro del costruttore primario è ombreggiato da un membro della base.

Gli avvisi seguenti indicano potenziali problemi relativi all'archiviazione o all'accesso ai parametri del costruttore primario:

• È possibile archiviare un parametro due volte se viene passato al costruttore di base e accedervi nel tipo derivato. È possibile che sia presente una copia nella classe di base e un'altra nella classe derivata. Valutare se sono necessarie entrambe le copie o ristrutturare il codice per evitare la duplicazione (CS9107).
• Se non lo si legge mai, non è necessario un parametro del costruttore primario. Rimuovere i parametri inutilizzati dalla dichiarazione del costruttore primario (CS9113).
• È possibile archiviare un parametro due volte se entrambi lo si acquisiscono nel tipo di inclusione e lo si usa per inizializzare un campo, una proprietà o un evento. È consigliabile usare direttamente il parametro acquisito anziché inizializzare un membro separato (CS9124).
• Un membro di un tipo base oscura un parametro del costruttore primario quando entrambi hanno lo stesso nome. Rinominare il parametro per evitare confusione (CS9179).