Condividi tramite

È possibile risolvere gli errori e gli avvisi nelle dichiarazioni di matrici e raccolte nonché nelle espressioni di inizializzazione

Questo articolo illustra gli errori del compilatore seguenti:

  • CS0022: numero di indici errato in [], previsto 'number'
  • CS0178: identificatore di classificazione non valido: previsto ',' o ']'
  • CS0248: non è possibile creare una matrice con dimensioni negative
  • CS0270: non è possibile specificare la dimensione della matrice in una dichiarazione di variabile. Provare a inizializzare con un'espressione 'new'
  • CS0611: gli elementi di una matrice non possono essere di tipo type
  • CS0623: gli inizializzatori di matrice possono essere usati solo in un inizializzatore di campo o di variabile. Provare a utilizzare un'espressione nuova.
  • CS0650: dichiaratore di matrice non valido: per dichiarare una matrice gestita, l'identificatore di classificazione precede l'identificatore della variabile. Per dichiarare un campo buffer a dimensione fissa, usare la parola chiave fixed prima del tipo di campo.
  • CS0719: gli elementi matrice non possono essere di tipo statico
  • CS0747: dichiaratore di membro di inizializzatore non valido.
  • CS0820: non è possibile assegnare l'inizializzatore di matrice a una variabile locale tipizzata in modo implicito
  • CS0826: nessun tipo migliore trovato per una matrice tipizzata in modo implicito.
  • CS0846: è previsto un inizializzatore di matrice annidato
  • CS1063: il miglior metodo Add di overload per l'elemento inizializzatore di raccolta è obsoleto.
  • CS1552: identificatore del tipo di matrice, [], deve essere visualizzato prima del nome del parametro
  • CS1586: la creazione della matrice deve avere la dimensione della matrice o l'inizializzatore della matrice
  • CS1920: l'inizializzatore di elemento non può essere vuoto.
  • CS1921: la corrispondenza migliore del metodo di overload ha una firma errata dell'elemento inizializzatore. Il Add inizializzabile deve essere un metodo di istanza accessibile.
  • CS1925: non è possibile inizializzare l'oggetto di tipo 'type' con un inizializzatore di raccolta.
  • CS1950: il miglior metodo Add di overload per l'inizializzatore di raccolta presenta alcuni argomenti non validi.
  • CS1954: non è possibile usare la corrispondenza migliore del metodo di overload per l'elemento dell'inizializzatore di raccolta. I metodi dell'inizializzatore di raccolta 'Add' non possono avere parametri ref o out.
  • CS9174: non è possibile inizializzare il tipo con un valore letterale di raccolta perché il tipo non è constructible.
  • CS9176: non esiste alcun tipo di destinazione per il valore letterale della raccolta.
  • CS9185: il tipo di compilazione CollectionBuilderAttribute deve essere una classe o uno struct non generico.
  • CS9186: il nome del metodo CollectionBuilderAttribute non è valido.
  • CS9187: non è possibile trovare un metodo accessibile con la firma prevista: un metodo statico con un parametro singolo di tipo ReadOnlySpan<T> e il tipo restituito corretto
  • CS9188: Type ha un CollectionBuilderAttribute ma nessun tipo di elemento.
  • CS9203: un'espressione di raccolta di questo tipo non può essere usata in questo contesto perché potrebbe essere esposta all'esterno dell'ambito corrente.
  • CS9210: questa versione di System.Collections.Immutable.ImmutableArray<T>non può essere usata con le espressioni di raccolta.
  • CS9212: l'operatore Spread '..' non può operare sulle variabili di tipo 'type' perché 'type' non contiene un'istanza pubblica o una definizione di estensione per 'member'.
  • CS9213: La destinazione dell'espressione della collezione 'type' non ha un tipo di elemento definito.
  • CS9214: il tipo di espressione di raccolta deve avere un costruttore applicabile che può essere chiamato senza argomenti.
  • CS9215: il tipo di espressione di raccolta 'type' deve avere un'istanza o un metodo di estensione 'Add' che può essere chiamato con un singolo argomento.
  • CS9222: l'inizializzatore di raccolta genera una catena infinita di istanziazioni della raccolta 'tipo'.
  • CS9332: impossibile usare l'operatore spread '..' nell'espressione di filtro di una clausola catch.
  • CS9354: l'elemento 'with(...)' deve essere il primo elemento
  • CS9355: gli elementi 'with(...)' non sono supportati per il tipo 'type'
  • CS9356: gli argomenti degli elementi 'with(...)' non possono essere dinamici
  • CS9357: l'elemento 'with(...)' per un'interfaccia di sola lettura deve essere vuoto se presente
  • CS9358: il tipo di elemento di questa raccolta non deve essere un ref struct o un parametro di tipo che consente ref struct
  • CS9359: nessun overload per il metodo 'method' accetta argomenti di elemento 'number' 'with(...)'

In questo articolo, sono inoltre illustrati gli avvisi seguenti:

  • CS1062: il miglior metodo Add di overload per l'elemento inizializzatore di raccolta è obsoleto.
  • CS1064: il miglior metodo Add di overload per l'elemento inizializzatore di raccolta è obsoleto.
  • CS3007: metodo di overload 'method' che differisce solo per i tipi di matrice senza nome non è conforme a CLS
  • CS3016: l'utilizzo di matrici come argomenti di attributi non è conforme a CLS
  • CS0251: indicizzazione di una matrice con un indice negativo (gli indici di matrice iniziano sempre a zero)
  • CS9208: un'espressione di raccolta può comportare allocazioni di heap impreviste. Prendere in considerazione la creazione esplicita di una matrice, quindi la conversione nel tipo finale per rendere esplicita l'allocazione.
  • CS9209: un'espressione di raccolta può comportare allocazioni heap impreviste a causa dell'uso delle espansioni di '..'. Prendere in considerazione la creazione esplicita di una matrice, quindi la conversione nel tipo finale per rendere esplicita l'allocazione.
  • CS9332: impossibile usare l'operatore spread '..' nell'espressione di filtro di una clausola catch.

Accesso all'elemento di matrice non valido

  • CS0022: numero errato degli indici all'interno di [], previsto 'number'
  • CS0251: l'indicizzazione di una matrice con un indice negativo (gli indici di matrice iniziano sempre a zero)

Per accedere correttamente agli elementi della matrice, seguire queste regole di indicizzazione. Per altre informazioni, vedere Matrici.

  • Specificare lo stesso numero di indici come dimensioni dichiarate (CS0022). Una matrice unidimensionale richiede un indice; una matrice tridimensionale richiede tre indici.
  • Usare solo numeri interi non negativi per gli indici di matrice (CS0251). Gli indici di matrice iniziano sempre a zero.

Inizializzatore di raccolta non valido

  • CS0747: dichiaratore di membro di inizializzatore non valido.
  • CS1920: l'inizializzatore dell'elemento non può essere vuoto.
  • CS1921: La corrispondenza migliore del metodo di overload ha una firma errata per l'elemento inizializzatore. Add inizializzabile deve essere un metodo di istanza accessibile.
  • CS1922: impossibile inizializzare il tipo 'type' con un inizializzatore di raccolta perché 'type' non implementa 'System.Collections.IEnumerable'.
  • CS1925: non è possibile inizializzare l'oggetto di tipo 'type' con un inizializzatore di raccolta.
  • CS1927: Avviso: Ignorare /win32manifest per il modulo perché si applica solo agli assembly
  • CS1950: il miglior metodo Add di overload per l'inizializzatore di raccolta presenta alcuni argomenti non validi.
  • CS1954: non è possibile usare la corrispondenza migliore del metodo di overload per l'elemento dell'inizializzatore di raccolta. I metodi dell'inizializzatore di raccolta 'Add' non possono avere parametri ref o out.
  • CS9174: non è possibile inizializzare il tipo con un valore letterale di raccolta perché il tipo non è constructible.
  • CS9176: non esiste alcun tipo di destinazione per il valore letterale della raccolta.
  • CS9203: un'espressione di raccolta di questo tipo non può essere utilizzata in questo contesto perché potrebbe essere esposta all'esterno dell'ambito corrente.
  • CS9210: Questa versione di System.Collections.Immutable.ImmutableArray<T> non può essere usata con le espressioni di raccolta.
  • CS9212: l'operatore spread '..' non può operare sulle variabili di tipo 'type' perché 'type' non contiene un'istanza pubblica o una definizione di estensione per 'member'.
  • CS9213: la destinazione dell'espressione di raccolta 'type' non ha alcun tipo di elemento.
  • CS9214: il tipo di espressione di raccolta deve avere un costruttore applicabile che può essere chiamato senza argomenti.
  • CS9215: il tipo di espressione di raccolta 'type' deve avere un'istanza o un metodo di estensione 'Add' che può essere chiamato con un singolo argomento.
  • CS9222: l'inizializzatore di raccolta genera una catena infinita di istanze della raccolta 'type'.
  • CS9332: impossibile usare l'operatore spread '..' nell'espressione di filtro di una clausola catch.
  • CS9354: l'elemento 'with(...)' deve essere il primo elemento
  • CS9355: gli elementi 'with(...)' non sono supportati per il tipo 'type'
  • CS9356: gli argomenti degli elementi 'with(...)' non possono essere dinamici
  • CS9357: l'elemento 'with(...)' per un'interfaccia di sola lettura deve essere vuoto se presente
  • CS9358: il tipo di elemento di questa raccolta potrebbe non essere uno struct di riferimento o un parametro di tipo che consente struct di riferimento
  • CS9359: nessun overload per il metodo 'method' accetta argomenti di elemento 'number' 'with(...)'

Il compilatore potrebbe anche generare gli avvisi seguenti:

  • CS1062: il miglior metodo Add di overload per l'elemento inizializzatore di raccolta è obsoleto.
  • CS1063: il miglior metodo Add di overload per l'elemento inizializzatore di raccolta è obsoleto.
  • CS1064: il miglior metodo Add di overload per l'elemento inizializzatore di raccolta è obsoleto.
  • CS9208: un'espressione di raccolta può comportare allocazioni di heap impreviste. Prendere in considerazione la creazione esplicita di una matrice, quindi la conversione nel tipo finale per rendere esplicita l'allocazione.
  • CS9209: un'espressione di raccolta può comportare allocazioni heap impreviste a causa dell'uso di spread di... Prendere in considerazione la creazione esplicita di una matrice, quindi la conversione nel tipo finale per rendere esplicita l'allocazione.

Per creare inizializzatori di raccolta validi, seguire queste regole. Per altre informazioni, vedere Espressioni di raccolta.

  • Non combinare l'inizializzazione delle proprietà con l'aggiunta di elementi nello stesso inizializzatore (CS0747).
  • Includere almeno un elemento negli inizializzatori di raccolta con parentesi graffe (CS1920).
  • Verificare che il tipo di raccolta implementi IEnumerable (CS1922).
  • Usare gli inizializzatori di raccolta solo con tipi di raccolta (CS1925).
  • Verificare che il Add metodo sia accessibile, accetta un parametro corrispondente al tipo di elemento e non usa ref o out modificatori (CS1921, CS1954).
  • Risolvere gli overload di metodi ambigui Add (CS1950).
  • Specificare un tipo di destinazione esplicito per le espressioni di raccolta quando il compilatore non può dedurrlo (CS9176, CS9213).
  • Verificare che il tipo di raccolta sia costruttibile con un costruttore senza parametri (CS9174, CS9214).
  • Non usare tipi di ref struct nelle espressioni di raccolta che potrebbero violare la sicurezza dei riferimenti (CS9203).
  • Aggiornare a una versione compatibile del runtime per le espressioni di raccolta ImmutableArray (CS9210).
  • Implementare modelli di enumerazione (ad esempio GetEnumerator) per il supporto degli operatori spread (CS9212).
  • Evitare dipendenze circolari nell'inizializzazione della raccolta (CS9222).
  • Non usare l'operatore spread nelle espressioni di filtro delle clausole catch (CS9332).
  • Posizionare l'elemento with(...) per primo nelle espressioni di raccolta (CS9354).
  • Usare gli elementi with(...) solo con i tipi che supportano gli argomenti delle espressioni di raccolta (CS9355).
  • Non usare argomenti dinamici negli with(...) elementi (CS9356).
  • Usare vuoto with() per i tipi di interfaccia di sola lettura (CS9357).
  • Non usare i tipi di struct ref come tipi di elemento nelle raccolte che non li supportano (CS9358).
  • Fai corrispondere il numero di with(...) argomenti agli overload del costruttore disponibili (CS9359).

Classificazione della matrice non valida

  • CS0178: identificatore di classificazione non valido: previsto ',' o ']'
  • CS0650: dichiaratore di matrice non valido: per dichiarare una matrice gestita, l'identificatore di classificazione deve precedere l'identificatore della variabile. Per dichiarare un campo buffer a dimensione fissa, usare la parola chiave fixed prima del tipo di campo.
  • CS1552: identificatore del tipo di matrice, [], deve essere visualizzato prima del nome del parametro

Per dichiarare correttamente le matrici, seguire l'ordine di sintassi appropriato. Per ulteriori informazioni, vedere Arrays e la C# Language Specification (Specifiche del linguaggio C#) sugli inizializzatori di array.

Una dichiarazione di matrice è costituita da questi token in ordine:

  1. Tipo di elementi della matrice (ad esempio, int, stringo SomeClassType).
  2. Le parentesi quadre dell'array, incluse facoltativamente le virgole per più dimensioni.
  3. Nome della variabile.

Quando si specificano le dimensioni della matrice, è possibile usare:

  • Numero di elementi tra parentesi graffe ({ e })
  • Parentesi quadre vuote
  • Una o più virgole racchiuse tra parentesi quadre

Gli esempi seguenti mostrano dichiarazioni di matrice valide:

int[] anArrayOfIntegers;
string[,,] threeDimensionalStringArray;

Lunghezza della matrice non valida

  • CS0248: non è possibile creare una matrice con dimensioni negative
  • CS0270: le dimensioni della matrice non possono essere specificate in una dichiarazione di variabile (provare a inizializzare con un'espressione 'new')
  • CS1586: la creazione di matrice deve avere dimensioni della matrice o inizializzatore di matrice

Per creare matrici con lunghezze valide, specificare le dimensioni durante l'inizializzazione, non la dichiarazione. Per altre informazioni, vedere Matrici.

  • Specificare la lunghezza della matrice come parte dell'inizializzazione, non come dichiarazione (CS0270).
  • Usare solo numeri interi positivi per le dimensioni della matrice (CS0248).
  • Specificare una dimensione in un'espressione new o in un inizializzatore di matrice (CS1586).

L'esempio seguente illustra entrambi i meccanismi:

int[] fiveIntegers = new int[5];
string[] weekDays = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };

Tipo di elemento non valido

  • CS0611: gli elementi matrice non possono essere di tipo 'type'
  • CS0719: gli elementi matrice non possono essere di tipo statico
  • CS0820: non è possibile assegnare l'inizializzatore di matrice a un locale tipizzato in modo implicito
  • CS0826: nessun tipo migliore trovato per una matrice tipizzata in modo implicito

Per usare matrici con tipi di elemento corretti, seguire queste restrizioni di tipo. Per altre informazioni, vedere Variabili locali tipizzate in modo implicito e tipo comune migliore.

  • Non usare tipi con restrizioni come System.TypedReference e System.ArgIterator come tipi di elemento di matrice (CS0611).
  • Non usare static le classi come tipi di elementi di matrice perché non è possibile creare istanze (CS0719).
  • Inizializzare matrici tipizzate in modo implicito con un'espressione new (CS0820).
  • Verificare che tutti gli elementi in un inizializzatore di matrice tipizzato in modo implicito abbiano un tipo comune migliore (CS0826).

Gli esempi seguenti illustrano come dichiarare matrici tipizzate in modo implicito:

var implicitType = new[] { 1, 2, 3 };
        
char c = 'c';
short s1 = 0;
short s2 = -0;
short s3 = 1;
short s4 = -1;

// common type is "int"
var commonType = new[] { s1, s2, s3, s4, c, 1 };

Per garantire un tipo comune ottimale, usare una di queste tecniche:

  • Assegnare un tipo esplicito alla matrice.
  • Assegnare lo stesso tipo a tutti gli elementi della matrice.
  • Fornire cast espliciti sugli elementi che potrebbero causare il problema.

Inizializzatore di matrice non valido

  • CS0623: gli inizializzatori di matrice possono essere usati solo in un inizializzatore di variabili o campi. Provare a utilizzare un'espressione nuova.
  • CS0846: è previsto un inizializzatore di matrice annidato
  • CS1925: non è possibile inizializzare l'oggetto di tipo 'type' con un inizializzatore di raccolta.

Questi errori indicano una sintassi dell'inizializzatore di matrice non valida. Per altre informazioni, vedere Matrici.

Per creare inizializzatori di matrice validi:

  • Usare gli inizializzatori di matrice solo nelle dichiarazioni di variabili o campi (CS0623). Usare un'espressione new in altri contesti.
  • Bilanciare le parentesi graffe ({ e }) intorno a elementi o matrici figlio (CS0846).
  • Verificare che l'espressione di inizializzazione corrisponda al numero di matrici in un'inizializzazione di matrice irregolare.
  • Usare gli inizializzatori di raccolta solo con tipi di raccolta, non con matrici o altri tipi (CS1925).

Generatore di raccolte non valido

  • CS9175: un albero delle espressioni potrebbe non contenere un'espressione di raccolta.
  • CS9177: il tipo restituito del metodo generatore 'CollectionBuilderAttribute' deve corrispondere al tipo di raccolta usato in 'betterness'.
  • CS9178: Non c'è un tipo di destinazione per il tipo naturale 'type'.
  • CS9179: il tipo di espressione di raccolta deve avere un costruttore applicabile che può essere chiamato senza argomenti.
  • CS9180: il metodo del generatore 'CollectionBuilderAttribute' deve essere un metodo statico.
  • CS9181: il tipo di parametro del metodo del generatore 'CollectionBuilderAttribute' deve corrispondere al parametro 'ReadOnlySpan<{0}>'
  • CS9182: 'CollectionBuilderAttribute' non valido. Nessun metodo '{0}' corrispondente trovato nel tipo di generatore '{1}'.
  • CS9183: il tipo restituito del metodo 'CollectionBuilderAttribute' deve essere un tipo non astratto e non di interfaccia utilizzabile come 'type'
  • CS9185: un tipo statico non può essere usato come argomento di tipo.
  • CS9186: il nome del metodo di CollectionBuilderAttribute non è valido.
  • CS9187: impossibile trovare un metodo 'Create' accessibile con la firma prevista: un metodo statico con un singolo parametro di tipo 'ReadOnlySpan<{0}>' e il tipo restituito '{1}'.
  • CS9188: 'scoped' non può essere utilizzato come modificatore su un parametro di tipo di un'espressione di collezione.
  • CS9190: il metodo 'CollectionBuilderAttribute' 'builderMethod' non è utilizzabile perché è generico.
  • CS9192: le conversioni di matrici inline non possono essere usate con espressioni di raccolta.
  • CS9193: l'argomento 'argument' potrebbe non essere passato con la parola chiave 'ref'.
  • CS9194: L'argomento 'argument' non può essere passato con la keyword 'out'
  • CS9195: L'argomento 'argument' non può essere passato con la parola chiave 'in'
  • CS9196: La caratteristica 'espressione di raccolta' non è disponibile in C# 'versione'. Usare la versione del linguaggio 'requiredVersion' o una versione successiva.
  • CS9197: La funzionalità 'array inline' non è disponibile in C# 'version'. Usare la versione del linguaggio 'requiredVersion' o una versione successiva.
  • CS9198: La funzionalità 'ref e unsafe nei metodi Asincroni e Iteratori' non è disponibile in C# 'version'. Utilizzare la versione del linguaggio 'requiredVersion' o una versione successiva.
  • CS9199: La funzionalità 'espressione di raccolta' non è disponibile in C# 'versione'. Usare la versione del linguaggio 'requiredVersion' o versione successiva.
  • CS9202: la funzionalità 'ref readonly parameters' non è disponibile in C# 'version'. Usare la versione della lingua 'requiredVersion' o versione successiva.
  • CS9208: l'operatore 'nameof' non può essere usato in un accesso a matrice inline.
  • CS9209: non è possibile utilizzare una proprietà 'property' che restituisce ref come argomento valore.
  • CS9211: l'espressione deve essere di tipo 'type' perché è assegnata dal riferimento
  • CS9212: Impossibile usare l'espressione di raccolta come valore in un'istruzione fissa
  • CS9217: un 'ref' locale non può essere mantenuto attraverso il limite 'await' o 'yield'.
  • CS9218: 'paramName' è uno struct di riferimento e non può essere il tipo di un parametro
  • CS9221: il tipo 'type' non può essere una struct ref o un parametro di tipo che permette struct ref da utilizzare come parametro 'parameter' nel tipo o metodo generico 'member'
  • CS9223: uno struct che contiene campi 'ref' non può essere utilizzato in un'espressione di raccolta.
  • CS9228: dichiarazione non variabile di uno struct di riferimento non consentita
  • CS9232: Le dichiarazioni di metodi parziali presentano differenze di firma.
  • CS9233: il modificatore "file" può essere usato solo sui tipi definiti nel livello superiore in un'unità di compilazione

Per creare espressioni di raccolta con attributi del generatore di raccolte correttamente, seguire questi requisiti. Per altre informazioni, vedere Espressioni di raccolta.

  • Verificare che il tipo di destinazione abbia un tipo di iterazione che supporta foreach (CS9188).
  • Non usare tipi generici come tipi di generatore di raccolte (CS9185).
  • Verificare che il nome del metodo specificato in CollectionBuilderAttribute sia valido (CS9186).
  • Applicare CollectionBuilderAttribute solo con metodi statici che corrispondono alla firma richiesta: restituire il tipo di raccolta e accettare un ReadOnlySpan<T> parametro in cui T corrisponde al tipo di elemento (CS9180, CS9181, CS9182, CS9183, CS9187, CS9190).
  • Verificare che il tipo restituito corrisponda e non sia astratto o un'interfaccia (CS9177, CS9183).
  • Non usare ref struct o tipi con campi ref nelle espressioni di collezione (CS9218, CS9221, CS9223, CS9228).
  • Evitare di usare espressioni di raccolta negli alberi delle espressioni (CS9175).
  • Usare la versione del linguaggio corretta per le espressioni di raccolta e le funzionalità correlate (CS9196, CS9197, CS9198, CS9199, CS9202).

Avvisi relativi alle specifiche del linguaggio comune

  • CS3007: metodo di overload 'method' che differisce solo per i tipi di matrice senza nome non è conforme a CLS
  • CS3016: l'uso di matrici come argomenti di attributo non è conforme a CLS

Per scrivere codice conforme a CLS con matrici, seguire queste linee guida. Per altre informazioni, vedere Indipendenza della lingua.

  • Non creare metodi sovraccaricati che differiscono solo nei tipi di elementi di array (CS3007).
  • Non usare matrici come argomenti di attributo (CS3016).

CS3007 si verifica se si dispone di un metodo di overload che accetta una matrice frastagliata e l'unica differenza tra le firme del metodo è il tipo di elemento della matrice. Per evitare questo errore, è consigliabile usare una matrice rettangolare anziché una matrice irregolare o, se non è necessaria la conformità a CLS, rimuovere l'attributo CLSCompliantAttribute. Per altre informazioni sulla conformità a CLS, vedere Indipendenza del linguaggio e componenti indipendenti dal linguaggio.

CS3016 indica che non è conforme a Common Language Specification (CLS) per passare una matrice a un attributo. Per altre informazioni sulla conformità a CLS, vedere Indipendenza del linguaggio e componenti indipendenti dal linguaggio.

  • Last updated on