Risolvere gli errori e gli avvisi per le dichiarazioni di tipo di unione e di gerarchia chiusa

Il compilatore C# genera errori quando si usano in modo improprio tipi di unione o gerarchie di tipi chiusi. Un tipo unione rappresenta un valore che può essere uno di diversi tipi di caso, con conversioni implicite e pattern matching esaustivo. Le gerarchie chiuse limitano i tipi che possono derivare da un tipo di base. Questa diagnostica consente di seguire le regole per dichiarare e usare tipi di unione e gerarchie chiuse.

• CS9370: Una dichiarazione di union deve specificare almeno un tipo di caso.
• CS9371: Impossibile convertire il tipo 'type' in 'object' mediante una conversione implicita di riferimento o una conversione boxing.
• CS9373: I campi di istanza, le proprietà autoimplementate o gli eventi di tipo campo non sono consentiti in una dichiarazione 'union'.
• CS9374: Costruttori pubblici esplicitamente dichiarati con un singolo parametro non sono consentiti in una dichiarazione 'union'.
• CS9375: un costruttore dichiarato in una dichiarazione 'union' deve avere un inizializzatore 'this' che chiama un costruttore sintetizzato o un costruttore dichiarato in modo esplicito.
• CS9380: i tipi e gli alias non possono essere denominati 'closed'.
• CS9381: 'type': un tipo chiuso non può essere sigillato o statico
• CS9382: 'type': non può usare un tipo chiuso 'type' da un altro assembly come tipo di base.
• CS9383: 'type': il parametro di tipo 'parameter' deve essere usato nel tipo di base 'type' perché il tipo di base è chiuso.
• CS9384: 'type': un tipo chiuso non può essere contrassegnato come astrazione perché è sempre astratta in modo implicito.
• CS9385: un tipo di unione deve avere almeno un membro di creazione unione.
• CS9386: un tipo di provider di membri unione deve avere una proprietà 'Value' di tipo 'object?' o 'object'. La proprietà deve avere una funzione di accesso get pubblica.
• CS9387: Una dichiarazione 'union' non può usare un'interfaccia provider dei membri della union.

Requisiti di dichiarazione dell'unione

• CS9370: Una dichiarazione di unione deve specificare almeno un tipo di caso.
• CS9371: impossibile convertire il tipo 'type' in 'object' tramite una conversione implicita di riferimento o boxing.

Una dichiarazione di unione specifica un nome e un elenco di tipi di casi. Questi errori impongono i requisiti strutturali di una dichiarazione corretta di unione. Per le regole complete, vedere la specifica della funzionalità dei tipi di unione.

Per correggere questi errori, applicare le modifiche seguenti alla dichiarazione di unione:

• Aggiungere almeno un tipo di caso all'elenco dei tipi di unione (CS9370). Un'unione deve avere uno o più tipi di caso poiché lo scopo dell'unione è rappresentare un set chiuso di alternative. Una dichiarazione come union Empty() senza tipi di case definiti non è significativa.
• Modificare o rimuovere i tipi di dati che non vengono convertiti in object tramite una conversione implicita di riferimento o boxing (CS9371). I tipi union archiviano i loro contenuti come unico riferimento object?, quindi ogni caso deve essere convertibile in object. I tipi come i puntatori o i tipi ref struct non soddisfano questo requisito. Sostituirli con un tipo wrapper che può essere incapsulato o archiviato come riferimento.

Restrizioni dei membri dell'Unione

• CS9373: I campi di istanza, le proprietà automatiche o gli eventi di tipo campo non sono consentiti in una dichiarazione 'union'.
• CS9374: i costruttori pubblici dichiarati in modo esplicito con un singolo parametro non sono consentiti in una dichiarazione 'union'.
• CS9375: un costruttore dichiarato in una dichiarazione 'union' deve avere un inizializzatore 'this' che chiama un costruttore sintetizzato o un costruttore dichiarato in modo esplicito.

Una dichiarazione di unione può includere un corpo con membri aggiuntivi, ma il compilatore limita ciò che è possibile dichiarare. Queste restrizioni assicurano che i costruttori di conversione generati dal compilatore e il meccanismo di archiviazione funzionino correttamente. Per le regole complete, vedere la specifica della funzionalità dei tipi di unione.

Per correggere questi errori, applicare le modifiche seguenti ai membri dell'unione:

• Rimuovere i campi dell'istanza, le proprietà implementate automaticamente e gli eventi di tipo campo dal corpo dell'unione (CS9373). Un'unione non definisce nuovi membri dati. Compone i tipi esistenti in un set chiuso di alternative. Dichiarare qualsiasi stato aggiuntivo nei tipi di casi stessi o usare membri statici nell'unione.
• Rimuovere o modificare l'accessibilità di qualsiasi costruttore pubblico dichiarato in modo esplicito che accetta un singolo parametro (CS9374). Il compilatore genera un costruttore pubblico a parametro singolo per ogni tipo di case per supportare le conversioni di unione implicite. Il costruttore esplicito con la stessa forma è in conflitto con i costruttori generati. Se è necessario un costruttore a parametro singolo, impostarlo internal o private.
• Aggiungere un this inizializzatore a qualsiasi costruttore dichiarato in modo esplicito in modo che concatena a un costruttore sintetizzato o a un altro costruttore dichiarato in modo esplicito (CS9375). I costruttori generati dal compilatore inizializzano correttamente la memoria interna dell'unione. I costruttori che non fanno riferimento a loro potrebbero lasciare l'unione in uno stato non valido. Usare : this(someValue) per collegare un costruttore di tipo case generato o : this() per collegare un costruttore esplicito senza parametri che dichiari.

Requisiti del provider membro dell'unione

• CS9385: un tipo di unione deve avere almeno un membro di creazione unione.
• CS9386: Un tipo di provider di membri di unione deve avere una proprietà di istanza 'Value' di tipo 'object?' o 'object'. La proprietà deve avere un accessor get pubblico.
• CS9387: una dichiarazione 'union' non può usare un'interfaccia del provider di membri unione.

Un provider di tipo union member è un tipo che implementa il pattern union tramite un'interfaccia anziché tramite la parola chiave union. Questi errori impongono i requisiti strutturali per i tipi che partecipano al modello provider dei membri dell'unione. Per le regole complete, vedere la specifica della funzionalità dei tipi di unione.

Per correggere questi errori, applicare le modifiche seguenti al provider dei membri dell'unione:

• Aggiungere almeno un membro di creazione dell'unione al tipo (CS9385). Un tipo di unione deve esporre almeno un membro di creazione ,ad esempio un metodo factory statico o una conversione implicita, in modo che i valori dell'unione possano essere costruiti dai tipi case.
• Aggiungere una proprietà di istanza Value pubblica di tipo object? o object con una funzione di accesso pubblica get al tipo di provider membro (CS9386). La Value proprietà è il modo in cui il runtime recupera il valore archiviato dall'unione. Senza di esso, l'unione non può esporre il relativo contenuto per la corrispondenza dei criteri o l'accesso diretto.
• Rimuovere l'interfaccia del fornitore del membro di unione dalla dichiarazione union (CS9387). Una union dichiarazione sintetizza la propria implementazione del provider membro. Non è possibile specificare un'interfaccia provider per un membro dell'unione per un tipo che usa direttamente la parola chiave union. Usare l'interfaccia del provider membro solo sui tipi che implementano manualmente il modello di unione.

Restrizioni della gerarchia chiusa

• CS9380: i tipi e gli alias non possono essere denominati closed.
• CS9381: 'type': un tipo chiuso non può essere sigillato o statico
• CS9382: 'type': non può usare un tipo chiuso 'type' da un altro assembly come tipo di base.
• CS9383: 'type': il parametro di tipo 'parameter' deve essere fatto riferimento nel tipo di base 'type' perché il tipo di base è chiuso.
• CS9384: 'type': un tipo chiuso non può essere contrassegnato come astrazione perché è sempre astratta in modo implicito.

Una gerarchia di tipi chiusi limita i tipi che possono derivare da un tipo di base. Il compilatore applica queste restrizioni per garantire che il set di tipi derivati sia noto ed esaustivo. Per le regole complete, vedere la specifica della funzionalità delle gerarchie chiuse.

Per correggere questi errori, applicare le modifiche seguenti alla dichiarazione della gerarchia chiusa:

• Rinominare qualsiasi tipo o alias denominato closed, perché closed è una parola chiave riservata in questo contesto (CS9380). Scegliere un nome diverso che non è in conflitto con la parola chiave .
• Rimuovere il sealed modificatore o static da un tipo chiuso (CS9381). Un tipo chiuso è implicitamente astratto (deve essere derivato da), quindi contrassegnarlo sealed (che impedisce la derivazione) o static (che impedisce la creazione di istanze e la derivazione) contraddice il suo scopo.
• Non derivare da un tipo chiuso dichiarato in un altro assembly (CS9382). Le gerarchie chiuse devono avere tutti i relativi sottotipi definiti nello stesso assembly del tipo di base. Questa restrizione consente al compilatore di eseguire una corrispondenza esaustiva dei pattern. Spostare il tipo derivato nello stesso assembly del tipo base chiuso oppure rimuovere la relazione di ereditarietà.
• Assicurarsi che ogni parametro di tipo di un sottotipo generico venga visualizzato nel riferimento al tipo di base quando il tipo di base viene chiuso (CS9383). Poiché una gerarchia chiusa richiede una conoscenza completa di tutti i sottotipi, ogni parametro di tipo in un sottotipo deve essere vincolato tramite il tipo di base. Se non viene fatto riferimento a un parametro di tipo nel tipo di base, il compilatore non può enumerare tutte le possibili istanze.
• Rimuovere il abstract modificatore da una dichiarazione di tipo chiuso (CS9384). Un tipo chiuso è sempre astratto in modo implicito perché funge da base per un set finito di tipi derivati. L'aggiunta abstract in modo esplicito è ridondante e non consentita per evitare confusione sull'eventuale semantica diversa rispetto ad altri tipi chiusi.