Risolvere gli errori e gli avvisi nelle dichiarazioni del costruttore

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: Costruttore 'constructor' non può chiamare se 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.
• 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.
• CS8861: elenco di argomenti imprevisti.
• CS8862: Un costruttore dichiarato in un tipo con una lista di parametri deve avere l'inizializzatore del costruttore 'this'.
• CS8358: Impossibile usare il costruttore dell'attributo perché contiene parametri 'in'.
• 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.
• 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 che tutti i relativi campi siano stati assegnati, causando le assegnazioni implicite precedenti di 'default' a campi non assegnati in modo 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.
• 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é include parametri 'in'.
• CS8091: Un costruttore non può essere extern e avere un inizializzatore del costruttore.

È 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 i parametri in parametri pass-by-value nei costruttori di attributi, perché i costruttori di attributi non supportano in i modificatori di parametri (CS8358). Il runtime crea un'istanza degli attributi usando la reflection, che non supporta il modificatore in.

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.

È 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: 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).

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(...). Aggiungere un : this(...) inizializzatore che passa gli argomenti appropriati 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. La sintassi class Derived : Base(args) è valida solo quando Base ha un costruttore primario (CS8861). Analogamente, 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 CS9105, spostare l'utilizzo del parametro nella clausola di base della dichiarazione di tipo anziché usarlo in una chiamata del : base() costruttore dichiarata in modo esplicito.

Se un tipo e un parametro del costruttore primario condividono lo stesso nome, il riferimento diventa ambiguo. Per correggere CS9106, rinominare il tipo o il parametro .

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).