Risolvere gli errori e gli avvisi correlati ai parametri di tipo generico e agli argomenti di tipo generico

Questo articolo illustra gli errori del compilatore seguenti:

• CS0080: i vincoli non sono consentiti nelle dichiarazioni non generiche.
• CS0081: la dichiarazione di parametro di tipo deve essere un identificatore non un tipo.
• CS0224: un metodo con vararg non può essere generico, essere in un tipo generico o avere un parametro params.
• CS0304: impossibile creare un'istanza del tipo di variabile perché non ha il new() vincolo .
• CS0305: l'uso del tipo generico richiede argomenti di tipo N.
• CS0306: il tipo non può essere usato come argomento di tipo.
• CS0307: 'identifier' non può essere usato con argomenti di tipo.
• CS0308: Il tipo o metodo non generico non può essere usato con argomenti di tipo.
• CS0310: il tipo deve essere un tipo non astratto con un costruttore pubblico senza parametri per usarlo come parametro nel tipo o nel metodo generico.
• CS0311: il tipo non può essere usato come parametro T di tipo nel tipo o nel metodo generico. Non esiste alcuna conversione implicita dei riferimenti da 'type1' a 'type2'.
• CS0312: il tipo 'type1' non può essere usato come parametro di tipo nel tipo o nel metodo generico. Il tipo nullable 'type1' non soddisfa il vincolo di 'constraint'.
• CS0313: il tipo 'type1' non può essere usato come parametro di tipo nel tipo o nel metodo generico. Il tipo nullable 'type1' non soddisfa il vincolo di 'constraint'. I tipi nullable non possono soddisfare alcun vincolo di interfaccia.
• CS0314: il tipo non può essere usato come parametro di tipo nel tipo o nel metodo generico. Non esiste alcuna conversione boxing o conversione di parametri di tipo da 'type' a 'constraint'.
• CS0315: il tipo non può essere usato come parametro T di tipo nel tipo o nel metodo generico. Non esiste alcuna conversione boxing da 'type' a 'constraint'.
• CS0401: il new() vincolo deve essere l'ultimo vincolo restrittivo specificato.
• CS0403: Impossibile convertire null in un parametro di tipo perché potrebbe essere un tipo di valore non annullabile. Prendere in considerazione invece l'uso di default(T).
• CS0405: vincolo duplicato per il parametro di tipo.
• CS0406: Il vincolo di tipo classe 'constraint' deve precedere qualsiasi altro vincolo.
• CS0409: una clausola di vincolo è già stata specificata per il parametro di tipo 'type parameter'. Tutti i vincoli per un parametro di tipo devono essere specificati in una singola clausola where.
• CS0411: gli argomenti di tipo per il metodo 'method' non possono essere dedotti dall'utilizzo. Provare a specificare gli argomenti di tipo in modo esplicito.
• CS0412: parametro: un parametro, una variabile locale o una funzione locale non può avere lo stesso nome di un parametro di tipo di metodo.
• CS0413: il parametro di tipo non può essere usato con l'operatore as perché non dispone di un vincolo di tipo di classe né di un class vincolo.
• CS0417: Identificatore: non può fornire argomenti durante la creazione di un'istanza di un tipo di variabile.
• CS0449: i classvincoli , structunmanaged, notnull, e default non possono essere combinati o duplicati e devono essere specificati per primi nell'elenco dei vincoli.
• Parametro di tipo: non è possibile specificare sia una classe di vincolo che il vincolo o .
• CS0451: il new() vincolo non può essere usato con il struct vincolo .
• CS0452: il tipo 'type name' deve essere un tipo riferimento per usarlo come parametro 'parameter name' nel tipo generico o nel metodo 'generico'.
• CS0453: Il tipo 'type name' deve essere un tipo di valore non annullabile per utilizzarlo come parametro 'parameter name' nel tipo generico o nel metodo 'generic'.
• CS0454: dipendenza del vincolo circolare che include il parametro di tipo 1 e il parametro di tipo 2.
• CS0455: il parametro di tipo eredita vincoli in conflitto 'constraint1' e 'constraint2'.
• CS0456: il parametro di tipo 'type parameter 1' ha il vincolo 'struct' in modo che 'type parameter 1' non possa essere usato come vincolo per 'type parameter 2'.
• CS0693: il parametro di tipo 'type parameter' ha lo stesso nome del parametro di tipo dal tipo esterno 'type'.
• CS0694: il parametro type ha lo stesso nome del tipo contenitore o del metodo .
• CS0695: 'type' non può implementare sia 'interface1' che 'interface2' perché possono unificare per alcune sostituzioni di parametri di tipo.
• CS0698: un tipo generico non può derivare dal tipo perché è una classe di attributi.
• CS0699: 'generic' non definisce il parametro di tipo 'identifier'.
• CS0701: 'identifier' non è un vincolo valido. Un tipo utilizzato come vincolo deve essere un'interfaccia, una classe non sealed o un parametro di tipo.
• CS0702: Il vincolo non può essere una classe speciale.
• CS0703: accessibilità incoerente: il tipo di vincolo è meno accessibile rispetto alla dichiarazione.
• CS0704: impossibile eseguire ricerche di membri non virtuali in 'type' perché si tratta di un parametro di tipo.
• CS0706: tipo di vincolo non valido. Un tipo utilizzato come vincolo deve essere un'interfaccia, una classe non sealed o un parametro di tipo.
• CS0717: classe statica: le classi statiche non possono essere usate come vincoli.
• CS0718: 'type': i tipi statici non possono essere usati come argomenti di tipo.
• CS1720: l'espressione causerà sempre un'eccezione System.NullReferenceException perché il valore predefinito di "tipo generico" è Null.
• CS1763: 'parameter' è di tipo 'type'. Un valore di parametro predefinito di un tipo riferimento diverso da string può essere inizializzato solo con null.
• CS1948: la variabile di intervallo 'name' non può avere lo stesso nome di un parametro del tipo di metodo.
• CS1960: modificatore di varianza non valido. Solo i parametri di tipo interfaccia e delegato possono essere specificati come variant.
• CS1961: Varianza non valida: il parametro di tipo deve essere valido in covarianza in 'type'. Il parametro di tipo è controvariante.
• CS3024: il tipo di vincolo 'type' non è conforme a CLS.
• CS7002: uso imprevisto di un nome generico.
• CS8322: Impossibile passare un argomento di tipo dinamico a una funzione locale generica con argomenti di tipo dedotti.
• CS8375: il vincolo 'new()' non può essere usato con il vincolo 'non gestito'.
• CS8377: Il tipo 'type' deve essere un tipo valore non nullable, insieme a tutti i campi, a qualsiasi livello di annidamento, per poterlo usare come parametro 'parameter' nel tipo generico o nel metodo 'generic'.
• CS8379: il parametro di tipo 'type parameter 1' ha il vincolo 'unmanaged' in modo che 'type parameter 1' non possa essere usato come vincolo per 'type parameter 2'.
• CS8380: 'type': non può specificare sia una classe di vincolo che il vincolo 'non gestito'.
• CS8387: il parametro di tipo 'type parameter' ha lo stesso nome del parametro di tipo dal metodo esterno 'method'.
• CS8389: l'omissione dell'argomento di tipo non è consentita nel contesto corrente.
• CS8427: le enumerazioni, le classi e le strutture non possono essere dichiarate in un'interfaccia con un parametro di tipo 'in' o 'out'.
• CS8665: Il metodo 'method' specifica un vincolo 'class' per il parametro di tipo 'type parameter', ma il parametro di tipo corrispondente 'type parameter' di metodo sottoposto a override o implementato in modo esplicito 'method' non è un tipo riferimento.
• CS8666: Il metodo 'method' specifica un vincolo 'struct' per il parametro di tipo 'type parameter', ma il parametro di tipo corrispondente 'type parameter' del metodo ridefinito o implementato in modo esplicito 'method' non è un tipo valore non annullabile.
• CS8822: Il metodo 'method' specifica un vincolo 'default' per il parametro di tipo 'type parameter', ma il parametro di tipo corrispondente 'type parameter' di metodo sottoposto a override o implementato in modo esplicito 'method' è vincolato a un tipo riferimento o a un tipo valore.
• CS8823: il vincolo 'default' è valido solo nei metodi di implementazione dell'interfaccia di override ed espliciti.
• CS8893: 'type' non è un tipo di convenzione di chiamata valido per 'UnmanagedCallersOnly'.
• CS8894: impossibile usare 'type' come parametro o tipo restituito in un metodo con attributo 'UnmanagedCallersOnly'.
• CS8895: i metodi attribuiti con 'UnmanagedCallersOnly' non possono avere parametri di tipo generico e non possono essere dichiarati in un tipo generico.
• CS8896: 'UnmanagedCallersOnly' può essere applicato solo a normali metodi statici non astratti, non virtuali o funzioni locali statiche.
• CS9011: La parola chiave delegate non può essere usata come vincolo. Intendevi System.Delegate?
• CS9012: Parola chiave recordinaspettata. Intendevi record struct o record class?
• CS9338: accessibilità incoerente: il tipo è meno accessibile rispetto alla classe.

Dichiarazione e denominazione dei parametri di tipo

• CS0080: i vincoli non sono consentiti nelle dichiarazioni non generiche.
• CS0081: la dichiarazione di parametro di tipo deve essere un identificatore non un tipo.
• CS0412: parametro: un parametro, una variabile locale o una funzione locale non può avere lo stesso nome di un parametro di tipo di metodo.
• CS0693: il parametro di tipo 'type parameter' ha lo stesso nome del parametro di tipo dal tipo esterno 'type'.
• CS0694: il parametro type ha lo stesso nome del tipo contenitore o del metodo .
• CS0699: 'generic' non definisce il parametro di tipo 'identifier'.
• CS1948: la variabile di intervallo 'name' non può avere lo stesso nome di un parametro del tipo di metodo.
• CS8387: il parametro di tipo 'type parameter' ha lo stesso nome del parametro di tipo dal metodo esterno 'method'.
• CS9012: parola chiave recordimprevista. Intendevi record struct o record class?

Questi errori si riferiscono a come dichiarare e denominare i parametri dei tipi e dei metodi generici. I nomi dei parametri di tipo devono essere identificatori validi, non devono essere in conflitto con altri identificatori nell'ambito e devono essere visualizzati nell'elenco dei parametri di tipo della dichiarazione.

• Rimuovere la clausola di vincolo dalle dichiarazioni non generice (CS0080). La where clausola può essere usata solo su tipi e metodi generici che dichiarano parametri di tipo. Se è necessario applicare vincoli, aggiungere prima i parametri di tipo alla dichiarazione di tipo o metodo.
• Sostituire i nomi dei tipi effettivi con gli identificatori nelle dichiarazioni dei parametri di tipo (CS0081). È necessario dichiarare parametri di tipo usando identificatori (ad esempio T, TKeyo TValue) anziché tipi concreti (ad esempio int o string). Lo scopo di un parametro di tipo è quello di fungere da segnaposto che il compilatore sostituisce con i tipi effettivi quando viene usato il tipo o il metodo generico.
• Rinominare parametri di tipo, variabili locali, parametri o variabili di intervallo per evitare conflitti di denominazione (CS0412, CS0694, CS1948). I nomi dei parametri di tipo non possono nascondere gli identificatori nello stesso ambito e non possono corrispondere al nome del tipo o del metodo contenitore. Anche le variabili di intervallo LINQ non possono riutilizzare il nome del parametro di tipo di un metodo. Tali conflitti creano ambiguità sull'identificatore a cui viene fatto riferimento.
• Usare un nome diverso per i parametri di tipo interni che nascondono quelli esterni (CS0693, CS8387). Quando un membro generico , ad esempio un metodo o un tipo annidato, si trova all'interno di una classe o di un metodo generico, il parametro di tipo interno non è necessariamente uguale a quello esterno. Assegnando loro lo stesso nome si crea confusione sul parametro di tipo a cui viene fatto riferimento. Usare un nome distinto per il parametro di tipo interno.
• Verificare che tutti i parametri di tipo nelle clausole di vincolo siano dichiarati nell'elenco dei parametri di tipo (CS0699). Una where clausola può fare riferimento solo ai parametri di tipo visualizzati nella dichiarazione generica. Se il nome nella where clausola non corrisponde ad alcun parametro di tipo dichiarato, verificare la presenza di errori di digitazione o errori di ortografia.
• Usare la sintassi corretta per la dichiarazione di record (CS9012). Quando si dichiara un tipo di record, è necessario usare record class o record struct (o solo record per un tipo riferimento). La record parola chiave da sola non può essere visualizzata nelle posizioni in cui il compilatore prevede una sintassi di dichiarazione diversa.

Per altre informazioni, vedere Generic Type Parameters and Generics (Parametri di tipo generico e generics).

Dichiarazione e ordinamento dei vincoli

• CS0401: il new() vincolo deve essere l'ultimo vincolo restrittivo specificato.
• CS0406: Il vincolo di tipo classe 'constraint' deve precedere qualsiasi altro vincolo.
• CS0409: una clausola di vincolo è già stata specificata per il parametro di tipo 'type parameter'. Tutti i vincoli per un parametro di tipo devono essere specificati in una singola clausola where.
• CS0449: i classvincoli , structunmanaged, notnull, e default non possono essere combinati o duplicati e devono essere specificati per primi nell'elenco dei vincoli.
• CS0450: Parametro di tipo: non è possibile specificare sia una classe di vincolo che il vincolo class o struct.
• CS0451: il new() vincolo non può essere usato con il struct vincolo .
• CS8375: il vincolo 'new()' non può essere usato con il vincolo 'non gestito'.
• CS8380: 'type': non può specificare sia una classe di vincolo che il vincolo 'non gestito'.
• CS9011: La parola chiave delegate non può essere usata come vincolo. Intendevi System.Delegate?

I vincoli sui parametri di tipo devono seguire un ordine specifico: i vincoli primari (class, struct, unmanagednotnull, o default) vengono prima, quindi un vincolo di tipo di classe, seguito dai vincoli di interfaccia e infine dal vincolo del new() costruttore. Alcuni vincoli si escludono a vicenda e non possono essere combinati. Tutti i vincoli per un singolo parametro di tipo devono essere visualizzati in una singola where clausola.

• Posizionare il new() vincolo alla fine dell'elenco di vincoli (CS0401). Il new() vincolo deve essere visualizzato dopo tutti gli altri vincoli. Puoi ad esempio modificare where T : new(), IDisposable in where T : IDisposable, new().
• Posizionare il vincolo del tipo di classe prima dei vincoli di interfaccia (CS0406). Quando si vincola un parametro di tipo a una classe base specifica insieme alle interfacce, la classe deve essere visualizzata per prima. Puoi ad esempio modificare where T : IDisposable, MyBaseClass in where T : MyBaseClass, IDisposable.
• Combinare tutti i vincoli per un parametro di tipo in una singola where clausola (CS0409). Non è possibile usare più where clausole per lo stesso parametro di tipo. Unirli in una clausola: passare where T : I where T : new() a where T : I, new(). Più where clausole sono valide solo quando sono destinate a parametri di tipo diversi.
• Inserire prima i vincoli primari e non combinare vincoli che si escludono a vicenda (CS0449). È possibile specificare al massimo uno di class, struct, unmanaged, notnullo defaulte deve essere visualizzato per primo nell'elenco dei vincoli. I vincoli class e struct si escludono reciprocamente, così come class e unmanaged.
• Non combinare un vincolo di classe specifico con class, structo unmanaged (CS0450, CS8380). Se un parametro di tipo è vincolato a un tipo di classe specifico, è implicitamente un tipo riferimento, che contraddice il struct vincolo o unmanaged . Rimuovere il vincolo di classe o il vincolo primario.
• Non combinare new() con struct o unmanaged (CS0451, CS8375). Tutti i tipi valore hanno in modo implicito un costruttore pubblico senza parametri, quindi il new() vincolo è ridondante se combinato con struct. Lo stesso vale per unmanaged, che implica struct. Rimuovere il new() vincolo.
• Sostituire delegate con System.Delegate nelle clausole di vincolo (CS9011). La delegate parola chiave viene usata per dichiarare i tipi delegati, non come vincolo. Per vincolare un parametro di tipo ai tipi delegati, usare System.Delegate come tipo di vincolo.

Per ulteriori informazioni, consultare Vincoli sui parametri di tipo.

Tipi di vincolo validi

• CS0405: vincolo duplicato per il parametro di tipo.
• CS0701: 'identifier' non è un vincolo valido. Un tipo utilizzato come vincolo deve essere un'interfaccia, una classe non sealed o un parametro di tipo.
• CS0702: Il vincolo non può essere una classe speciale.
• CS0703: accessibilità incoerente: il tipo di vincolo è meno accessibile rispetto alla dichiarazione.
• CS0706: tipo di vincolo non valido. Un tipo utilizzato come vincolo deve essere un'interfaccia, una classe non sealed o un parametro di tipo.
• CS0717: classe statica: le classi statiche non possono essere usate come vincoli.
• CS3024: il tipo di vincolo 'type' non è conforme a CLS.

Un vincolo deve essere un'interfaccia, una classe non sealed (non sigillata) o un parametro di tipo. Alcuni tipi non sono validi come vincoli a causa del loro significato speciale nel sistema di tipi .NET o perché non possono essere ereditati.

• Rimuovere vincoli duplicati (CS0405). Ogni vincolo può essere visualizzato una sola volta in una clausola di vincolo. Se è presente where T : I, I, rimuovere il duplicato.
• Usare solo tipi non derivabili come vincoli (CS0701). Le classi, gli struct e le enumerazioni sealed non possono essere ereditate, quindi non fungono da vincoli. Usare un'interfaccia che i tipi desiderati implementino, oppure usare una classe base non derivabile.
• Non usare classi speciali come vincoli (CS0702). I tipi Object, Arraye ValueType non possono essere usati come vincoli. Ogni tipo deriva già da Object, quindi vincolare a esso non fornisce alcun valore. Array e ValueType sono tipi di base astratti che non possono essere ereditati direttamente. Se è necessario un comportamento simile a una matrice, usare IList<T> o IEnumerable<T> .
• Assicurarsi che i tipi di vincolo siano accessibili almeno come il tipo generico (CS0703). Un tipo generico pubblico non può avere vincoli usando tipi interni, perché il codice esterno non sarebbe in grado di fornire argomenti di tipo validi. Rendere pubblico il tipo di vincolo o ridurre l'accessibilità del tipo generico.
• Usare solo interfacce, classi non sigillate o parametri di tipo come vincoli (CS0706). Non è possibile usare matrici, classi sigillate, struct, enumerazioni o altri tipi non validi come vincoli. Valutare l'uso di un'interfaccia implementata dai tipi desiderati.
• Non usare classi statiche come vincoli (CS0717). Le classi statiche non possono essere estese perché contengono solo membri statici. Nessun tipo può derivare da una classe statica, rendendolo inutile come vincolo.
• Usare un tipo conforme a CLS per il vincolo di tipo (CS3024). Quando un assembly è contrassegnato con [assembly: CLSCompliant(true)], l'uso di un tipo non conforme a CLS come vincolo di tipo generico potrebbe rendere impossibile il codice scritto in alcuni linguaggi per utilizzare la classe generica.

Per ulteriori informazioni, consultare Vincoli sui parametri di tipo.

Soddisfazione dei vincoli e trasformazioni

• CS0311: il tipo non può essere usato come parametro T di tipo nel tipo o nel metodo generico. Non esiste alcuna conversione implicita dei riferimenti da 'type1' a 'type2'.
• CS0312: il tipo non può essere usato come parametro di tipo nel tipo o nel metodo generico. Il tipo nullable non soddisfa il vincolo 'constraint'.
• CS0313: il tipo non può essere usato come parametro di tipo nel tipo o nel metodo generico. Il tipo nullable non soddisfa il vincolo 'constraint'. I tipi nullable non possono soddisfare alcun vincolo di interfaccia.
• CS0314: Il tipo non può essere usato come parametro di tipo in un tipo o metodo generico. Non esiste alcuna conversione boxing o conversione del parametro di tipo da 'type' a 'constraint'.
• CS0315: il tipo non può essere usato come parametro T di tipo nel tipo o nel metodo generico. Non esiste alcuna conversione boxing da 'type' a 'constraint'.
• CS0452: il tipo 'type name' deve essere un tipo riferimento per usarlo come parametro 'parameter name' nel tipo generico o nel metodo 'generico'.
• CS0453: Il tipo 'type name' deve essere un tipo valore non nullable per poterlo usare come parametro 'parameter name' nel tipo o metodo generico 'generic'.
• CS8377: Il tipo 'type' deve essere un tipo valore che non ammette valori null, così come tutti i campi, a qualsiasi livello di annidamento, per poter essere usato come parametro 'parameter' nel tipo generico o nel metodo 'generic'.

Questi errori si verificano quando un argomento di tipo non soddisfa i vincoli dichiarati in un parametro di tipo generico. L'argomento type deve avere le conversioni corrette, le relazioni di ereditarietà e le proprietà strutturali in modo che corrispondano a tutti i vincoli.

• Modificare l'argomento di tipo in uno che ha una conversione di riferimento implicita verso il tipo di vincolo (CS0311). Quando un parametro di tipo ha un vincolo come where T : BaseType, qualsiasi argomento di tipo deve essere convertibile in BaseType tramite una conversione implicita dei riferimenti o una conversione di identità. Le conversioni numeriche implicite ( ad esempio da short a int) non soddisfano vincoli di parametro di tipo generico.
• Usare tipi valore non nullable o modificare il tipo di vincolo (CS0312, CS0313). I tipi valore nullable (ad esempio int?) sono distinti dai tipi valore sottostanti e non soddisfano gli stessi vincoli. I tipi valore nullable non possono soddisfare vincoli di interfaccia perché il wrapper nullable stesso non implementa l'interfaccia. Usare la forma non annullabile del tipo di valore come argomento di tipo.
• Ripetere i vincoli dei parametri di tipo della classe base in qualsiasi dichiarazione di classe derivata (CS0314). Quando una classe generica derivata eredita da una classe generica di base vincolata, la classe derivata deve dichiarare gli stessi vincoli sui parametri di tipo corrispondenti.
• Verificare che gli argomenti di tipo soddisfino i vincoli di tipo riferimento o di classe (CS0315). Quando un parametro di tipo è vincolato a un tipo di classe, non è possibile usare un tipo valore (struct) come argomento di tipo perché non esiste alcuna conversione boxing che soddisfi la relazione di vincolo. Usare un tipo di riferimento che eredita da o implementa il vincolo.
• Usare un tipo di riferimento come argomento di tipo quando viene specificato il vincolo class (CS0452). Tipi valore come struct o int non possono soddisfare un class vincolo. Modifica l'argomento di tipo in un tipo di riferimento, oppure rimuovi il vincolo class se il tipo generico può funzionare con tipi valore.
• Usare un tipo valore che non ammette valori null per l'argomento di tipo quando viene specificato il vincolo struct (CS0453). I tipi di riferimento, i tipi valore nullable (int?) e altri tipi che non sono tipi valore non possono soddisfare un vincolo struct. Usare un tipo valore concreto non nullable, come int, double o un struct definito dall'utente.
• Utilizzare un tipo i cui campi sono tutti tipi non gestiti quando viene specificato il unmanaged vincolo (CS8377). Il vincolo unmanaged richiede un tipo valore non annullabile in cui ogni campo, a ogni livello di annidamento, sia anch’esso un tipo non gestito. I tipi contenenti campi di tipo riferimento o parametri di tipo generico che non sono noti per essere non gestiti non soddisfano questo vincolo.

Per ulteriori informazioni, consultare Vincoli sui parametri di tipo.

Conflitti di vincoli e dipendenze circolari

• CS0454: dipendenza del vincolo circolare che include il parametro di tipo 1 e il parametro di tipo 2.
• CS0455: il parametro di tipo eredita vincoli in conflitto 'constraint1' e 'constraint2'.
• CS0456: il parametro di tipo 'type parameter 1' ha il vincolo 'struct' in modo che 'type parameter 1' non possa essere usato come vincolo per 'type parameter 2'.
• CS8379: il parametro di tipo 'type parameter 1' ha il vincolo 'unmanaged' in modo che 'type parameter 1' non possa essere usato come vincolo per 'type parameter 2'.

I vincoli non possono creare dipendenze circolari e i parametri di tipo non possono ereditare vincoli in conflitto impossibili da soddisfare contemporaneamente. I vincoli di tipo valore (struct e unmanaged) sono implicitamente sigillati, quindi non possono essere utilizzati come vincoli per altri parametri di tipo.

• Eliminare le dipendenze dei vincoli circolari (CS0454). Un parametro di tipo non può dipendere direttamente o indirettamente da se stesso tramite i relativi vincoli. Ad esempio, where T : U where U : T crea una dipendenza circolare. Interrompere il ciclo rimuovendo uno dei vincoli.
• Rimuovere vincoli ereditati in conflitto (CS0455). Un parametro di tipo non può essere vincolato a più classi non correlate, perché C# non supporta l'ereditarietà di più classi. Analogamente, non può essere vincolato a entrambi struct e a un tipo di classe. Ristrutturare la gerarchia dei tipi o rimuovere uno dei vincoli in conflitto.
• Non usare un structparametro di tipo vincolato o unmanagedvincolato come vincolo per un altro parametro di tipo (CS0456, CS8379). I vincoli di tipo valore vengono bloccati in modo implicito, quindi nessun altro tipo può derivare da essi. Per risolvere questo errore, inserire il tipo di valore o il vincolo non gestito direttamente sul secondo parametro di tipo anziché vincolarlo indirettamente tramite il primo parametro di tipo.

Per ulteriori informazioni, consultare Vincoli sui parametri di tipo.

Regole di sovrascrittura e vincoli di implementazione

• CS8665: Il metodo 'method' specifica un vincolo 'class' per il parametro di tipo 'type parameter', ma il parametro di tipo corrispondente 'type parameter' di metodo sottoposto a override o implementato in modo esplicito 'method' non è un tipo riferimento.
• CS8666: Il metodo 'method' specifica un vincolo 'struct' per il parametro di tipo 'type parameter', ma il parametro di tipo corrispondente 'type parameter' del metodo sottoposto a override o implementato esplicitamente 'method' non è un tipo valore non annullabile.
• CS8822: Il metodo 'method' specifica un vincolo 'default' per il parametro di tipo 'type parameter', ma il parametro di tipo corrispondente 'type parameter' di metodo sottoposto a override o implementato in modo esplicito 'method' è vincolato a un tipo riferimento o a un tipo valore.
• CS8823: il vincolo 'default' è valido solo nei metodi di implementazione dell'interfaccia di override ed espliciti.

Quando si esegue l'override di un metodo virtuale o si implementa in modo esplicito un metodo di interfaccia, i vincoli sui parametri di tipo del metodo di override devono essere compatibili con i vincoli del metodo di base. Il vincolo default è un modificatore speciale usato solo negli scenari di override e di implementazione esplicita dell'interfaccia per indicare che un parametro di tipo non presenta né il vincolo class né il vincolo struct.

• Assicurarsi che i vincoli del metodo di override corrispondano ai vincoli del metodo di base (CS8665, CS86666). Un override non può aggiungere un class vincolo se il parametro di tipo corrispondente del metodo di base non è vincolato a un tipo riferimento. Analogamente, non può aggiungere un struct vincolo se il parametro di tipo del metodo di base non è vincolato a un tipo valore. La ridefinizione deve essere compatibile con la dichiarazione base.
• Usare il default vincolo solo quando il parametro di tipo del metodo di base non è vincolato (CS8822). Il vincolo default indica che il parametro di tipo non presenta alcun vincolo class o struct. Non è possibile applicare default se il parametro di tipo corrispondente del metodo sottoposto a override ha già un class vincolo o struct .
• Usare il default vincolo solo sui metodi override o di implementazione esplicita dell'interfaccia (CS8823). Il default vincolo non è valido nelle dichiarazioni di metodi regolari. Esiste specificamente per disambiguare quando si ridefinisce un metodo in cui la classe base ha un parametro di tipo non vincolato ed è necessario indicare che anche la ridefinizione lo lascia non vincolato.

Per altre informazioni, vedere Vincoli per i parametri di tipo e il default vincolo.

Vincoli del costruttore

• CS0304: impossibile creare un'istanza del tipo di variabile perché non ha il new() vincolo .
• CS0310: il tipo deve essere un tipo non astratto con un costruttore pubblico senza parametri per usarlo come parametro nel tipo o nel metodo generico.
• CS0417: Identificatore: non può fornire argomenti durante la creazione di un'istanza di un tipo di variabile.

Questi errori riguardano il vincolo new() e l'istanziazione dei parametri di tipo con l'operatore new.

• Aggiungere il vincolo new() ai parametri di tipo che è necessario istanziare (CS0304). Quando si usa new T() all'interno di un tipo o un metodo generico, il compilatore deve garantire che qualsiasi argomento di tipo abbia un costruttore senza parametri. Il new() vincolo fornisce questa garanzia.
• Verificare che gli argomenti di tipo abbiano costruttori pubblici senza parametri (CS0310). Quando un parametro di tipo ha il new() vincolo, qualsiasi tipo concreto usato come argomento di tipo deve essere non astratto e deve fornire un costruttore pubblico senza parametri. I tipi con solo costruttori privati, protetti o con parametri non possono soddisfare il new() vincolo.
• Rimuovere gli argomenti del costruttore quando si crea un'istanza dei parametri di tipo (CS0417). Il new() vincolo garantisce solo un costruttore senza parametri. Non è possibile passare argomenti a new T(arguments). Se è necessario costruire istanze con argomenti specifici, è consigliabile usare un modello factory o un vincolo di interfaccia che definisce il comportamento di costruzione.

Per altre informazioni, vedere Vincoli per i parametri di tipo e il new() vincolo.

Conteggio e utilizzo degli argomenti di tipo

• CS0224: un metodo con vararg non può essere generico, essere in un tipo generico o avere un parametro params.
• CS0305: l'uso del tipo generico richiede argomenti di tipo N.
• CS0306: il tipo non può essere usato come argomento di tipo.
• CS0307: L''identifier'' non può essere usato con argomenti di tipo.
• CS0308: Il tipo o metodo non generico non può essere utilizzato con argomenti di tipo.
• CS7002: uso imprevisto di un nome generico.
• CS8389: l'omissione dell'argomento di tipo non è consentita nel contesto corrente.

Questi errori si riferiscono all'indicazione del numero e del tipo corretti di argomenti per tipi e metodi generici.

• Rimuovere i parametri di tipo generico o contenere dichiarazioni di tipo generico dai metodi che usano __arglist (CS0224). La __arglist parola chiave non è compatibile con i generics perché i meccanismi di runtime per la gestione degli elenchi di argomenti delle variabili sono in conflitto con la sostituzione del tipo necessaria per i parametri di tipo generico.
• Specificare il numero esatto di argomenti di tipo specificati nella dichiarazione generica (CS0305). Ogni parametro di tipo generico nella definizione deve avere un argomento di tipo corrispondente quando viene creata un'istanza del tipo generico.
• Usare solo tipi validi come argomenti di tipo (CS0306). I tipi puntatore (ad esempio int* o char*) non possono essere usati come argomenti di tipo perché i tipi generici richiedono tipi gestiti che il Garbage Collector può tenere traccia.
• Rimuovere la sintassi dell'argomento di tipo dai costrutti non generici (CS0307, CS0308). Gli argomenti di tipo racchiusi tra parentesi angolari possono essere applicati solo a tipi e metodi generici che dichiarano parametri di tipo. Assicurarsi di aver importato lo spazio dei nomi che contiene la versione generica del tipo.
• Rimuovere i parametri di tipo dalle dichiarazioni che non supportano generics (CS7002). Alcuni costrutti, ad esempio enumerazioni, non possono essere generici. Se è necessario un contenitore generico per i valori di enumerazione, è consigliabile usare invece una classe o uno struct generico.
• Specificare tutti gli argomenti di tipo obbligatori in modo esplicito (CS8389). In alcuni contesti, come quando si usa l'operatore typeof o si creano delegati, è necessario specificare tutti gli argomenti di tipo e non è possibile ometterli. Ad esempio, usare typeof(List<int>) anziché tentare di omettere l'argomento di tipo.

Per altre informazioni, vedere Generic Type Parameters and Generics (Parametri di tipo generico e generics).

Inferenza degli argomenti di tipo

• CS0411: gli argomenti di tipo per il metodo 'method' non possono essere dedotti dall'utilizzo. Provare a specificare gli argomenti di tipo in modo esplicito.

Questo errore si verifica quando si chiama un metodo generico senza fornire in modo esplicito gli argomenti di tipo e il compilatore non può dedurre gli argomenti di tipo desiderati. Il compilatore deduce gli argomenti di tipo a partire dai tipi degli argomenti del metodo passati al punto di chiamata.

• Specificare gli argomenti di tipo in modo esplicito tra parentesi angolari (CS0411). Se il compilatore non è in grado di determinare gli argomenti di tipo dagli argomenti del metodo, specificarli direttamente. Puoi ad esempio modificare G() in G<int>(). Questo errore si verifica in genere quando un metodo generico non dispone di parametri da cui dedurre il tipo o quando viene passato un null argomento e il compilatore non riesce a determinare il tipo previsto.

Per altre informazioni, vedere Metodi generici.

Varianza dei parametri di tipo

• CS1960: modificatore di varianza non valido. Solo i parametri di tipo interfaccia e delegato possono essere specificati come variant.
• CS1961: Varianza non valida: il parametro di tipo deve essere valido in covarianza in 'type'. Il parametro di tipo è controvariante.
• CS8427: le enumerazioni, le classi e le strutture non possono essere dichiarate in un'interfaccia con un parametro di tipo 'in' o 'out'.

I modificatori di varianza (in per controvarianza, out per la covarianza) controllano come è possibile usare i parametri di tipo nelle dichiarazioni di interfaccia e delegato. Solo le interfacce e i delegati supportano la varianza. Un parametro di tipo covariante (out) può essere visualizzato solo nelle posizioni di output (tipi restituiti), mentre un parametro di tipo controvariante (in) può essere visualizzato solo nelle posizioni di input (tipi di parametro).

• Usare modificatori di varianza solo per i parametri di tipo interfaccia e delegato (CS1960). Le classi, gli struct e altre dichiarazioni di tipo non supportano modificatori di varianza. Solo le dichiarazioni interface e delegate possono usare in o out nei relativi parametri di tipo.
• Usare out (covariante) per i parametri di tipo visualizzati solo nei tipi restituiti e in (controvariante) per i parametri di tipo visualizzati solo nei tipi di parametro (CS1961). Se il parametro di tipo deve essere visualizzato sia nelle posizioni di input che in quella di output, rimuovere il modificatore di varianza.
• Non dichiarare enumerazioni, classi o strutture all'interno di un'interfaccia variante (CS8427). Le dichiarazioni di tipi annidati all'interno di un'interfaccia che dispone di parametri di tipo in o out non sono consentite perché potrebbero violare le regole di sicurezza della varianza. Spostare il tipo annidato all'esterno della dichiarazione di interfaccia.

Per ulteriori informazioni, vedere Covarianza e controvarianza nei Generici.

Restrizioni di utilizzo dei tipi generici

• CS0403: Impossibile convertire null nel parametro di tipo perché potrebbe essere un tipo di valore che non ammette valori null. Si consideri invece l'utilizzo di default(T).
• CS0413: il parametro di tipo non può essere usato con l'operatore as perché non dispone di un vincolo di tipo di classe né di un class vincolo.
• CS0695: 'type' non può implementare sia 'interface1' che 'interface2' perché possono unificare per alcune sostituzioni di parametri di tipo.
• CS0698: un tipo generico non può derivare dal tipo perché è una classe di attributi.
• CS0704: impossibile eseguire ricerche di membri non virtuali in 'type' perché si tratta di un parametro di tipo.
• CS0718: 'type': i tipi statici non possono essere usati come argomenti di tipo.
• CS1720: l'espressione causerà sempre un'eccezione System.NullReferenceException perché il valore predefinito di "tipo generico" è Null.
• CS1763: 'parameter' è di tipo 'type'. Un valore di parametro predefinito di un tipo riferimento diverso da string può essere inizializzato solo con null.
• CS8322: impossibile passare l'argomento con tipo dinamico alla funzione locale generica con argomenti di tipo dedotti.
• CS9338: accessibilità incoerente: il tipo è meno accessibile rispetto alla classe.

Questi errori si riferiscono alle restrizioni relative al modo in cui i tipi generici e i parametri di tipo possono essere usati nelle espressioni, nell'ereditarietà e nell'accesso ai membri.

• Sostituire null le assegnazioni con default(T) o aggiungere un class vincolo (CS0403). Quando si assegna null a un parametro di tipo non vincolato, il compilatore non può garantire che l'argomento di tipo sia un tipo riferimento. Usare default(T), che fornisce il valore predefinito appropriato per qualsiasi tipo o aggiungere un vincolo se è necessaria specificamente la class semantica del tipo di riferimento.
• Aggiungere un vincolo di tipo specifico o un class quando si usa l'operatore as (CS0413). L'operatore as restituisce null se la conversione non riesce, ma i tipi valore non possono essere null. Aggiungere un class vincolo per assicurarsi che il parametro di tipo sia sempre un tipo riferimento.
• Evitare di implementare più volte la stessa interfaccia generica con parametri di tipo che potrebbero unificare (CS0695). Quando una classe implementa più volte un'interfaccia generica con parametri di tipo diversi ,ad esempio class G<T1, T2> : I<T1>, I<T2>, la creazione di un'istanza con lo stesso tipo per entrambi i parametri creerebbe un conflitto. Implementare l'interfaccia una sola volta o ristrutturare per evitare l'unificazione.
• Rimuovere i parametri di tipo generico dalle classi di attributi (CS0698). Questo errore non viene più generato nelle versioni correnti di C#, perché gli attributi generici sono ora supportati.
• Usare il tipo di vincolo concreto anziché il parametro di tipo per l'accesso ai membri annidati (CS0704). Non è possibile accedere ai tipi annidati o ai membri non virtuali tramite un parametro di tipo. Invece di T.InnerType, usare direttamente il tipo di vincolo noto, ad esempio BaseClass.InnerType.
• Non usare tipi statici come argomenti di tipo (CS0718). I tipi statici non possono essere istanziati e non possono essere usati come argomenti generici. Rimuovere il tipo statico dall'argomento generico.
• Evitare di chiamare i membri dell'istanza quando default(T)T è vincolato a un tipo di riferimento (CS1720). Quando T ha un vincolo class, default(T) è null, quindi la chiamata di membri di istanza su di esso solleva sempre un'eccezione NullReferenceException. Aggiungere un controllo Null prima di chiamare i membri o ristrutturare il codice per evitare di usare default(T) direttamente.
• Usare null come valore del parametro predefinito per i parametri facoltativi il cui tipo è un tipo riferimento (CS1763). Se un metodo generico ha un parametro di tipo T ed T è un tipo riferimento, sostituire default(U) con null perché le impostazioni predefinite dei parametri facoltativi devono essere costanti in fase di compilazione e default(T) non corregge tale requisito.
• Specificare in modo esplicito gli argomenti di tipo quando si passano valori dinamici a funzioni locali generiche (CS8322). Quando si passa un dynamic argomento a una funzione locale generica, il compilatore non può dedurre argomenti di tipo. Specificare in modo esplicito l'argomento di tipo o eseguire il cast del valore dinamico.
• Assicurarsi che gli argomenti di tipo utilizzati nelle firme pubbliche o protette abbiano un livello di accessibilità almeno pari a quello del membro (CS9338). Un membro generico pubblico deve usare argomenti di tipo accessibili pubblicamente. Rendere pubblico l'argomento di tipo oppure ridurre l'accessibilità del membro.

Per altre informazioni, vedere Vincoli sui parametri di tipo ed espressioni di valore predefinite.

UnmanagedCallersOnly restrizioni

• CS8893: 'type' non è un tipo di convenzione di chiamata valido per 'UnmanagedCallersOnly'.
• CS8894: impossibile usare 'type' come parametro o tipo restituito in un metodo con attributo 'UnmanagedCallersOnly'.
• CS8895: i metodi attribuiti con 'UnmanagedCallersOnly' non possono avere parametri di tipo generico e non possono essere dichiarati in un tipo generico.
• CS8896: 'UnmanagedCallersOnly' può essere applicato solo a normali metodi statici non astratti, non virtuali o funzioni locali statiche.

L'attributo UnmanagedCallersOnlyAttribute contrassegna i metodi che il codice non gestito può chiamare. Questi metodi hanno requisiti rigorosi perché il runtime deve gestire la transizione tra convenzioni di chiamata gestite e non gestite.

• Usare solo tipi di convenzione di chiamata validi nell'attributo UnmanagedCallersOnly (CS8893). La proprietà CallConvs dell'attributo accetta solo tipi di convenzione di chiamata riconosciuti dello spazio dei nomi System.Runtime.CompilerServices.
• Usare solo tipi blittable come tipi di parametro e di restituzione (CS8894). I metodi contrassegnati con UnmanagedCallersOnly non possono usare tipi gestiti (ad esempio string o object) come parametri o tipi restituiti perché i chiamanti non gestiti non possono gestire i riferimenti di Garbage Collection.
• Rimuovere i parametri di tipo generico dai UnmanagedCallersOnly metodi e non dichiararli nei tipi generici (CS8895). Le convenzioni di chiamata non gestite non supportano generics perché il runtime non è in grado di determinare la convenzione di chiamata corretta per le sostituzioni di tipi generici.
• Si applica UnmanagedCallersOnly solo a normali metodi statici, non astratti, non virtuali o funzioni locali statiche (CS8896). I metodi di istanza, i metodi astratti e i metodi virtuali non possono essere contrassegnati con UnmanagedCallersOnly perché i chiamanti non gestiti non possono eseguire i meccanismi di invio necessari per questi metodi.

Per altre informazioni, vedere UnmanagedCallersOnlyAttribute.