Risolvere gli errori e gli avvisi per le dichiarazioni di valori letterali di stringa

Il compilatore C# genera errori e avvisi quando si dichiarano valori letterali stringa con sintassi non corretta o li si usano in contesti non supportati. Questa diagnostica aiuta a identificare i problemi relativi a stringhe letterali di base, caratteri letterali, stringhe letterali non elaborate e stringhe letterali UTF-8.

• CS1009: sequenza di escape non riconosciuta.
• CS1010: nuova riga in costante.
• CS1011: letterale di carattere vuoto.
• CS1012: Troppi caratteri nel valore letterale carattere.
• CS1039: stringa letterale non terminata.
• CS8996: I letterali di stringa grezzi non sono consentiti nelle direttive del preprocessore.
• CS8997: Valore letterale stringa non terminata.
• CS8998: Non ci sono abbastanza virgolette di apertura per questo contenuto di stringa grezza.
• CS8999: La riga non inizia con lo stesso spazio bianco della riga di chiusura del letterale di stringa grezza.
• CS9000: il delimitatore di stringa letterale non elaborata deve essere posto su una propria riga.
• CS9001: i valori letterali stringa non elaborati su più righe sono consentiti solo nelle stringhe interpolate verbatim.
• CS9002: I letterali di stringa raw su più righe devono contenere almeno una riga di contenuto.
• CS9003: la riga contiene spazi vuoti diversi rispetto al previsto.
• CS9004: Numero di virgolette insufficiente per la stringa letterale grezza.
• CS9005: Non ci sono abbastanza parentesi graffe di chiusura per il valore letterale di stringa grezza interpolata.
• CS9006: Troppi parentesi graffe aperti per una stringa letterale non elaborata interpolata.
• CS9007: Troppe parentesi graffe di chiusura per una stringa letterale grezza interpolata.
• CS9008: sequenza di caratteri '@' non consentita.
• CS9009: Stringa deve iniziare con una virgolette.
• CS9026: la stringa di input non può essere convertita nella rappresentazione di byte UTF-8 equivalente.
• CS9047: l'operatore non può essere applicato agli operandi che non sono rappresentazioni di byte UTF-8.
• CS9274: Impossibile emettere questa stringa letterale nella sezione dei dati perché ha una collisione XXHash128 con un'altra stringa letterale.
• CS9315: la lunghezza combinata delle stringhe utente usate dal programma supera il limite consentito. L'aggiunta di un valore letterale stringa richiede il riavvio dell'applicazione.

Stringhe letterali formate in modo non corretto

• CS1009 - Sequenza di escape non riconosciuta.
• CS1010 - Nuova riga in costante.
• CS1011 - Valore letterale di carattere vuoto.
• CS1012 - Troppi caratteri nel valore letterale carattere.
• CS1039 - Letterale di stringa non terminata.

Per correggere questi errori, applicare le tecniche seguenti:

• Usare una delle sequenze di escape standard definite nella specifica del linguaggio C#, ad esempio \n (nuova riga), (tabulazione), \t\\ (barra rovesciata) o \" (virgolette doppie) (CS1009). Il compilatore non riconosce le sequenze di escape che non fanno parte della specifica del linguaggio, quindi l'uso di sequenze di escape non predefinite causa questo errore perché il compilatore non riesce a determinare il carattere che si intende rappresentare.
• Aggiungi il carattere di virgoletta di chiusura per completare la stringa letterale (CS1039). I letterali di stringa devono avere sia un delimitatore di apertura che di chiusura, pertanto, una stringa non terminata fa in modo che il compilatore consideri il codice sorgente successivo come parte del contenuto della stringa, che porta a errori di analisi.
• Aggiungere esattamente un carattere tra virgolette singole nel valore letterale carattere (CS1011, CS1012). I valori letterali carattere rappresentano un singolo valore di carattere e devono contenere esattamente un carattere o una sequenza di escape valida, quindi i valori letterali carattere vuoti o quelli contenenti più caratteri violano le regole della lingua per il char tipo.
• Suddividere i valori letterali stringa che si estendono su più righe di origine terminando ogni riga con virgolette di chiusura e avviando la riga successiva con una virgoletta di apertura, usando l'operatore + per concatenarle (CS1010). I valori letterali stringa regolari non possono contenere caratteri di nuova riga effettivi perché le virgolette di chiusura devono essere visualizzate nella stessa riga delle virgolette di apertura, ma è possibile ottenere stringhe su più righe tramite concatenazione o usando stringhe verbatim o valori letterali stringa non elaborati, che consentono nuove righe incorporate come parte del contenuto della stringa.

Per altre informazioni, vedere stringhe.

Letterali di stringa grezza formati in modo errato

• CS8996 - Le stringhe letterali grezze non sono consentite nelle direttive del preprocessore.
• CS8997 - Stringa letterale grezza non terminata.
• CS8998 - Virgolette iniziali non sufficienti per questo contenuto di stringa letterale.
• CS8999 - La riga non inizia con lo stesso spazio bianco della riga di chiusura del letterale di stringa grezza.
• CS9000 - Il delimitatore di stringa letterale non elaborata deve trovarsi su una propria riga.
• CS9001 - I valori letterali stringa non elaborati su più righe sono consentiti solo nelle stringhe interpolate verbatim.
• CS9002 - I valori letterali stringa non elaborati su più righe devono contenere almeno una riga di contenuto.
• CS9003 - La riga contiene spazi vuoti diversi rispetto al previsto.
• CS9004 - Virgolette non sufficienti per il valore letterale stringa non elaborato.
• CS9005 - Parentesi graffe di chiusura non sufficienti per il valore letterale di stringa grezza interpolato.
• CS9006 - Troppe parentesi graffe di apertura per il valore letterale di stringa grezza interpolata.
• CS9007 - Troppe parentesi graffe di chiusura per la stringa letterale non elaborata interpolata.
• CS9008 - Sequenza di caratteri '@' non consentita.
• CS9009 - La stringa deve iniziare con il carattere virgolette.

Per correggere questi errori, applicare le tecniche seguenti:

• Usare letterali di stringa regolari o letterali di stringa verbatim anziché letterali di stringa grezzi nelle direttive del preprocessore come #if, #define, o #pragma (CS8996). Le direttive del preprocessore vengono valutate durante la fase di pre-elaborazione prima dell'esecuzione dell'analisi lessicale, quindi il compilatore non riesce a riconoscere la sintassi letterale stringa non elaborata in questi contesti perché le stringhe non elaborate vengono identificate durante la fase di analisi lessicale successiva.
• Aggiungi un delimitatore di chiusura corrispondente al delimitatore di apertura per completare la stringa letterale non elaborata (CS8997, CS9004). La sintassi dei valori letterali stringa non elaborata richiede che i delimitatori di apertura e chiusura contengano lo stesso numero di caratteri virgolette doppie consecutive (almeno tre), pertanto un delimitatore di chiusura mancante o non corrispondente impedisce al compilatore di determinare dove termina il contenuto della stringa.
• Posizionare i delimitatori di apertura e chiusura di letterali di stringa grezzi su più righe, senza altro contenuto su tali righe (CS9000). Le regole di formato della stringa grezza su più righe richiedono che i delimitatori occupino righe dedicate per stabilire limiti chiari per il contenuto della stringa e per abilitare il comportamento di rimozione degli spazi vuoti che rimuove l'indentazione comune dalle righe di contenuto.
• Aggiungere almeno una riga di contenuto tra i delimitatori di apertura e chiusura della stringa raw multilinea (CS9002). La specifica del linguaggio richiede che le stringhe grezze a più righe contengano effettivamente del contenuto, poiché le stringhe grezze a più righe vuote non hanno uno scopo e indicano probabilmente codice incompleto. Al contrario, le stringhe grezze a riga singola (con delimitatori sulla stessa riga) possono essere vuote e rappresentano la sintassi appropriata per i valori di stringhe vuote.
• Modifica il rientro delle righe di contenuto della stringa grezza in modo che corrisponda o superi il rientro della riga del delimitatore di chiusura (CS8999, CS9003). Le regole di gestione degli spazi vuoti per i valori letterali stringa non elaborati usano lo spazio vuoto iniziale del delimitatore di chiusura come linea di base per tagliare il rientro comune da tutte le righe di contenuto, quindi le righe di contenuto con un rientro minore rispetto al delimitatore di chiusura violano questo algoritmo di taglio e indicano una formattazione errata.
• Aumenta il numero di virgolette doppie nel delimitatore di stringa grezza per superare qualsiasi sequenza consecutiva di virgolette nel contenuto (CS8998). Il delimitatore deve contenere più virgolette consecutive di qualsiasi sequenza all'interno del contenuto stringa, in modo che il compilatore possa distinguere in modo univoco tra virgolette che fanno parte del contenuto e la sequenza delimitatore che contrassegna la fine della stringa.
• Per le stringhe letterali non elaborate interpolate, verificare che il numero di segni di dollaro ($) all'inizio corrisponda al numero di parentesi graffe di apertura o chiusura consecutive da considerare come contenuto letterale (CS9005, CS9006, CS9007). La sintassi della stringa non elaborata interpolata usa il conteggio dei segni del dollaro per determinare la lunghezza della sequenza di escape tra parentesi graffe, quindi $$""" richiede {{ come sequenza per i fori di interpolazione e consente di utilizzare singoli caratteri { come contenuto, mentre sequenze di parentesi graffe non corrispondenti indicano una sintassi di interpolazione non corretta o contenuto che richiede un diverso conteggio dei segni del dollaro.
• Rimuovere il @ prefisso dal valore letterale stringa non elaborato e usare solo il delimitatore di virgolette (CS9008, CS9009). I valori letterali stringa non elaborati sono una sintassi distinta introdotta in C# 11 che non usa il @ prefisso di stringa verbatim e la specifica del linguaggio non consente di combinare la @ sintassi verbatim con delimitatori stringa non elaborati perché le stringhe non elaborate supportano già il contenuto su più righe e non richiedono sequenze di escape.

Annotazioni

CS9001 non viene più prodotto nelle versioni correnti di C#. Ora i valori letterali di stringa grezzi su più righe supportano l'interpolazione senza richiedere il formato verbatim.

Per altre informazioni, vedere Valori letterali stringa non elaborati.

Letterali di stringhe UTF-8

• CS9026 - La stringa di input non può essere convertita nella rappresentazione di byte UTF-8 equivalente.
• CS9047 - L'operatore non può essere applicato agli operandi che non sono rappresentazioni di byte UTF-8.

Per correggere questi errori, applicare le tecniche seguenti:

• Rimuovere caratteri o sequenze di escape che non possono essere codificate in UTF-8 nella letterale di stringa u8 (CS9026). La specifica di codifica UTF-8 supporta il set di caratteri Unicode completo, ma richiede valori scalari Unicode validi, quindi i punti di codice surrogato (valori nell'intervallo da U+D800 a U+DFFF) non possono essere visualizzati direttamente nelle stringhe UTF-8 perché sono riservati per la codifica della coppia di surrogati UTF-16 anziché rappresentare caratteri autonomi e tentando di codificarli come UTF-8 produrrebbe una sequenza di byte non valida.
• Assicurarsi che entrambi gli operandi dell'operatore di addizione siano valori letterali stringa UTF-8 (contrassegnati con il u8 suffisso) quando si concatenano stringhe UTF-8 (CS9047). Il compilatore fornisce un supporto speciale per la concatenazione di valori letterali stringa UTF-8 in fase di compilazione, che produce ReadOnlySpan<byte> valori che rappresentano le sequenze di byte UTF-8 concatenate, ma la combinazione di stringhe UTF-8 con valori regolari string o altri tipi non è supportata perché il sistema di tipi non è in grado di determinare se produrre un intervallo di byte o una stringa di testo e le rappresentazioni sottostanti (byte UTF-8 rispetto a caratteri UTF-16) sono fondamentalmente incompatibili.

Per altre informazioni, vedere stringhe letterali UTF-8.

Stringhe letterali nelle sezioni di dati

• CS9274: Impossibile emettere questo letterale di stringa nella sezione dei dati perché ha una collisione XXHash128 con un altro letterale di stringa.
• CS9315: la lunghezza combinata delle stringhe utente usate dal programma supera il limite consentito. L'aggiunta di un valore letterale stringa richiede il riavvio dell'applicazione.

Per risolvere questi problemi, provare le tecniche seguenti:

• Disabilitare la funzionalità dei valori letterali stringa della sezione dati sperimentali per l'applicazione quando si verifica un conflitto hash (CS9274). Questo errore indica che due letterali di stringa diversi hanno prodotto lo stesso valore XXHash128, il che impedisce il corretto funzionamento dell'ottimizzazione. Pertanto, è necessario rimuovere il flag delle funzionalità che abilita questo comportamento sperimentale.
• Riavviare l'applicazione dopo aver modificato i valori letterali stringa durante una sessione di debug quando la funzionalità della sezione dati è abilitata (CS9315). L'infrastruttura di ricaricamento rapido non può aggiornare i valori letterali stringa archiviati nella sezione dei dati perché sono incorporati in un formato speciale che non può essere modificato in fase di esecuzione, quindi continuare l'esecuzione con i valori stringa precedenti produrrebbe un comportamento errato.