Beheben von Fehlern und Warnungen für Zeichenfolgenliteraldeklarationen

Der C#-Compiler generiert Fehler und Warnungen, wenn Sie Zeichenfolgenliterale mit einer falschen Syntax deklarieren oder sie in nicht unterstützten Kontexten verwenden. Mithilfe dieser Diagnose können Sie Probleme mit grundlegenden Zeichenfolgenliteralen, Zeichenliteralen, rohen Zeichenfolgenliteralen und UTF-8-Zeichenfolgenliteralen identifizieren.

• CS1009: Unbekannte Escapesequenz.
• CS1010: Neue Zeile in Konstante.
• CS1011: Leeres Zeichenliteral.
• CS1012: Zu viele Zeichen im Zeichenliteral.
• CS1039: Unvollständiges Zeichenfolge.
• CS8996: Rohzeichenfolgenliterale sind in Präprozessordirektiven nicht zulässig.
• CS8997: Nicht abgeschlossenes rohes Zeichenfolgenliteral.
• CS8998: Nicht genügend Anführungszeichen für diesen unformatierten Zeichenfolgeninhalt.
• CS8999: Zeile beginnt nicht mit demselben Leerraum wie die schließende Zeile des rohen Zeichenfolgenliterals.
• CS9000: Literaltrennzeichen für unformatierte Zeichenfolgen muss in einer eigenen Zeile enthalten sein.
• CS9001: Mehrzeilige unformatierte Zeichenfolgenliterale sind nur in wörtlich interpolierten Zeichenfolgen zulässig.
• CS9002: Mehrzeilige rohe Zeichenfolgenliterale müssen mindestens eine Zeile mit Inhalt enthalten.
• CS9003: Zeile enthält unterschiedliche Leerzeichen als erwartet.
• CS9004: Nicht genügend Anführungszeichen für Rohzeichenfolgenliteral.
• CS9005: Nicht genügend schließende Klammern für interpoliertes unformatiertes String-Literal.
• CS9006: Zu viele öffnende Klammern für interpoliertes unformatiertes Zeichenfolgen-Literal.
• CS9007: Zu viele schließende Klammern für ein interpoliertes rohes String-Literal.
• CS9008: Sequenz von '@' Zeichen ist nicht zulässig.
• CS9009: Zeichenfolge muss mit Anführungszeichen beginnen.
• CS9026: Die Eingabezeichenfolge kann nicht in die entsprechende UTF-8-Byte-Darstellung konvertiert werden.
• CS9047: Der Operator kann nicht auf Operanden angewendet werden, die keine UTF-8-Byte-Darstellungen sind.
• CS9274: Dieses Zeichenfolgenliteral kann nicht in den Datenabschnitt eingefügt werden, da es eine XXHash128-Kollision mit einem anderen Zeichenfolgenliteral hat.
• CS9315: Die kombinierte Länge der vom Programm verwendeten Benutzerzeichenfolgen überschreitet den zulässigen Grenzwert. Zum Hinzufügen eines Zeichenfolgenliterals muss die Anwendung neu gestartet werden.

Falsch formatierte Zeichenfolgenliterale

• CS1009 - Unbekannte Escape-Sequenz.
• CS1010 - Neue Zeile in Konstante.
• CS1011 - Leerer Zeichenwert.
• CS1012 - Zu viele Zeichen im Character Literal.
• CS1039 - Unterminiertes Zeichenfolgenliteral.

Um diese Fehler zu beheben, wenden Sie die folgenden Techniken an:

• Verwenden Sie eine der standardmäßigen Escapesequenzen, die in der C#-Sprachspezifikation definiert sind, z. B. \n (Neue Zeile), \t (Tabstopp), \\ (Rückwärtsschrägstrich) oder \" (doppeltes Anführungszeichen) (CS1009). Der Compiler erkennt keine Escapesequenzen, die nicht Teil der Sprachspezifikation sind. Daher verursacht die Verwendung nicht definierter Escapesequenzen diesen Fehler, da der Compiler nicht bestimmen kann, welches Zeichen Sie darstellen möchten.
• Fügen Sie das schließende Anführungszeichen hinzu, um Ihr Zeichenfolgenliteral (CS1039) abzuschließen. Zeichenfolgenliterale müssen sowohl ein öffnendes als auch ein schließendes Trennzeichen haben. Eine unabgeschlossene Zeichenfolge führt dazu, dass der Compiler den nachfolgenden Quellcode als Teil des Zeichenfolgeninhalts behandelt, was zu Analysefehlern führt.
• Fügen Sie genau ein Zeichen zwischen den einzelnen Anführungszeichen in Ihrem Zeichenliteral hinzu (CS1011, CS1012). Zeichenliterale stellen einen einzelnen Zeichenwert dar und müssen genau ein Zeichen oder eine gültige Escapesequenz enthalten, sodass leere Zeichenliterale oder solche, die mehrere Zeichen enthalten, gegen die Sprachregeln für den char Typ verstoßen.
• Teilen Sie Zeichenfolgenliterale, die mehrere Quellzeilen umfassen, indem Sie jede Zeile mit einem schließenden Anführungszeichen beenden und die nächste Zeile mit einem öffnenden Anführungszeichen beginnen, indem Sie sie mithilfe des Operators + verketten (CS1010). Reguläre Zeichenfolgenliterale können keine tatsächlichen Zeilenumbruchzeichen enthalten, da das schließende Anführungszeichen in derselben Zeile wie das öffnende Anführungszeichen angezeigt werden muss, Sie können jedoch mehrzeilige Zeichenfolgen durch Verkettung oder mithilfe von Verbatimzeichenfolgen oder unformatierten Zeichenfolgenliteralen erreichen, die eingebettete Newlines als Teil des Zeichenfolgeninhalts zulassen.

Weitere Informationen finden Sie unter Zeichenfolgen.

Falsch gebildete unformatierte Zeichenfolgenliterale

• CS8996 - Raw-String-Literale sind in Präprozessordirektiven nicht zulässig.
• CS8997 - Nicht abgeschlossenes Rohzeichenfolgenliteral.
• CS8998 - Nicht genügend Anführungszeichen für diesen unformatierten Zeichenfolgeninhalt.
• CS8999 - Die Zeile beginnt nicht mit dem gleichen Leerzeichen wie die abschließende Zeile des Rohzeichenfolgenliterals.
• CS9000 - Das Rohzeichenfolgenliteraltrennzeichen muss seine eigene Zeile haben.
• CS9001 - Mehrzeilige, unformatierte Zeichenfolgenliterale sind nur in wortwörtlich interpolierten Zeichenfolgen zulässig.
• CS9002 - Mehrzeilige, unformatierte Zeichenfolgenliterale müssen mindestens eine Inhaltszeile enthalten.
• CS9003 - Zeile enthält unterschiedliche Leerzeichen als erwartet.
• CS9004 - Nicht genügend Anführungszeichen für ein Rohzeichenfolgenliteral.
• CS9005 - Nicht genügend geschlossene geschweifte Klammern für Interpolationsliteral im Rohtext.
• CS9006 - Zu viele öffnende geschweifte Klammern für interpoliertes Rohzeichenfolgenliteral.
• CS9007 - Zu viele schließende geschweifte Klammern für interpoliertes unformatiertes Zeichenfolgenliteral.
• CS9008 - Die Sequenz von '@' Zeichen ist nicht zulässig.
• CS9009 - Zeichenfolge muss mit Anführungszeichen beginnen.

Um diese Fehler zu beheben, wenden Sie die folgenden Techniken an:

• Verwenden Sie reguläre Zeichenfolgenliterale oder Verbatim-Zeichenfolgenliterale anstelle von unformatierten Zeichenfolgenliteralen in Präprozessordirektiven wie #if, #defineoder #pragma (CS8996). Präprozessordirektiven werden während der Vorverarbeitungsphase ausgewertet, bevor die lexikalische Analyse erfolgt, sodass der Compiler in diesen Kontexten keine unformatierte Zeichenfolgenliteralsyntax erkennen kann, da rohe Zeichenfolgen während der späteren lexikalischen Analysephase identifiziert werden.
• Fügen Sie ein schließendes Trennzeichen hinzu, das dem öffnenden Trennzeichen entspricht, um das Rohzeichenfolgenliteral (CS8997, CS9004) abzuschließen. Für die Syntax des unformatierten Zeichenfolgenliterals muss das öffnende und schließende Trennzeichen dieselbe Anzahl aufeinander folgender doppelter Anführungszeichen (mindestens drei) enthalten, sodass ein fehlendes oder nicht übereinstimmendes schließendes Trennzeichen verhindert, dass der Compiler bestimmt, wo der Zeichenfolgeninhalt endet.
• Platzieren Sie die öffnenden und schließenden Trennzeichen von mehrzeiligen, unformatierten Zeichenfolgenliteralen in ihren eigenen Zeilen, ohne dass andere Inhalte in diesen Zeilen (CS9000) enthalten sind. Die mehrzeiligen Rohdatenstring-Formatregeln erfordern, dass Trennzeichen auf separaten Zeilen stehen, um klare Abgrenzungen für den Zeichenfolgeninhalt zu schaffen und das Verhalten zu ermöglichen, das gemeinsame führende Leerzeichen aus allen Inhaltszeilen entfernt.
• Fügen Sie mindestens eine Zeile Inhalt zwischen die öffnenden und schließenden Begrenzungen Ihres mehrzeiligen Raw-String-Literals (CS9002) ein. Für die Sprachspezifikation sind mehrzeilige rohe Zeichenfolgen erforderlich, um tatsächlichen Inhalt zu enthalten, da leere mehrzeilige rohe Zeichenfolgen keinen Zweck erfüllen und wahrscheinlich unvollständigen Code angeben, während einzeilige rohe Zeichenfolgen (mit Trennzeichen in derselben Zeile) leer sein können und die entsprechende Syntax für leere Zeichenfolgenwerte sind.
• Passen Sie den Einzug der unformatierten Zeichenfolgeninhaltszeilen an, um den Einzug der schließenden Trennzeichenzeile (CS8999, CS9003) abzugleichen oder zu überschreiten. Die Regeln für die Leerzeichenbehandlung bei Rohzeichenfolgenliteralen verwenden den führenden Leerraum des abschließenden Begrenzers als Basis, um den gemeinsamen Einzug aller Inhaltszeilen zu kürzen. Inhaltszeilen, die weniger Einzug als der abschließende Begrenzer haben, verstoßen gegen diesen Abgleichsalgorithmus und weisen auf eine ungeeignete Formatierung hin.
• Erhöhen Sie die Anzahl der Anführungszeichen in Ihren rohen Zeichenfolgenbegrenzern, um jeden aufeinanderfolgenden Lauf von Anführungszeichen im Inhalt (CS8998) zu überschreiten. Das Trennzeichen muss mehr aufeinander folgende Anführungszeichen enthalten als jede Sequenz innerhalb des Zeichenfolgeninhalts, sodass der Compiler eindeutig zwischen Anführungszeichen unterscheiden kann, die Teil des Inhalts sind, und der Trennzeichensequenz, die das Ende der Zeichenfolge kennzeichnet.
• Stellen Sie bei interpolierten unformatierten Zeichenfolgenliteralen sicher, dass die Anzahl der Dollarzeichen ($) am Anfang mit der Anzahl aufeinander folgender öffnender oder schließender geschweifter Klammern übereinstimmt, die Sie als Literalinhalt benötigen (CS9005, CS9006, CS9007). Die Interpolierte Raw-String-Syntax verwendet die Anzahl der Dollarzeichen, um die Länge der Klammern-Escape-Sequenz zu bestimmen. Sie nutzt $$""" für Interpolationsstellen und erlaubt einzelne { Zeichen als Inhalt, während nicht übereinstimmende Klammernsequenzen entweder eine falsche Interpolationssyntax anzeigen oder auf Inhalte hinweisen, die eine andere Anzahl von Dollarzeichen erfordern.
• Entfernen Sie das @ Präfix aus Ihrem unformatierten Zeichenfolgenliteral und verwenden Sie nur das Anführungszeichentrennzeichen (CS9008, CS9009). Unformatierte Zeichenfolgenliterale sind eine unterschiedliche Syntax, die in C# 11 eingeführt wird, die das Präfix für @ verbatim Zeichenfolgen nicht verwendet, und die Sprachspezifikation lässt die Kombination der @ Verbatimsyntax mit unformatierten Zeichenfolgentrennzeichen nicht zu, da rohe Zeichenfolgen bereits mehrzeilige Inhalte unterstützen und keine Escapesequenzen erfordern.

Hinweis

CS9001 wird in den aktuellen Versionen von C# nicht mehr produziert. Mehrzeilige, unformatierte Zeichenfolgenliterale unterstützen jetzt die Interpolation, ohne dass ein Verbatim-Format erforderlich ist.

Weitere Informationen finden Sie unter Rohzeichenfolgenliteralen.

UTF-8-Zeichenfolgenliterale

• CS9026 - Die Eingabezeichenfolge kann nicht in die entsprechende UTF-8-Bytedarstellung konvertiert werden.
• CS9047 - Der Operator kann nicht auf Operanden angewendet werden, die keine UTF-8-Byte-Darstellungen sind.

Um diese Fehler zu beheben, wenden Sie die folgenden Techniken an:

• Entfernen Sie Zeichen oder Escapesequenzen, die nicht in UTF-8 codiert werden können, aus dem u8 Zeichenfolgenliteral (CS9026). Die UTF-8-Codierungsspezifikation unterstützt den vollständigen Unicode-Zeichensatz, erfordert aber gültige Unicode-Skalarwerte. Daher können surrogate Codepunkte (Werte im Bereich U+D800 bis U+DFFF) nicht direkt in UTF-8-Zeichenfolgen angezeigt werden, da sie für UTF-16-Ersatzpaarcodierung reserviert sind, anstatt eigenständige Zeichen darzustellen, und der Versuch, sie als UTF-8 zu codieren, würde eine ungültige Bytesequenz erzeugen.
• Stellen Sie sicher, dass beide Operanden des Additionsoperators UTF-8-Zeichenfolgenliterale (mit dem u8 Suffix gekennzeichnet) sind, wenn UTF-8-Zeichenfolgen (CS9047) verkettet werden. Der Compiler bietet spezielle Unterstützung für das Verketten von UTF-8-Zeichenfolgenliteralen zur Kompilierungszeit, wodurch Werte erzeugt ReadOnlySpan<byte> werden, die verketteten UTF-8-Byte-Sequenzen darstellen, aber das Mischen von UTF-8-Zeichenfolgen mit regulären string Werten oder anderen Typen wird nicht unterstützt, da das Typsystem nicht bestimmen kann, ob eine Bytespanne oder eine Textzeichenfolge erstellt werden soll, und die zugrunde liegenden Darstellungen (UTF-8 Bytes im Vergleich zu UTF-16 Zeichen) sind grundsätzlich inkompatibel.

Weitere Informationen finden Sie unter UTF-8-Zeichenfolgenliterale.

Literale Zeichenfolgen in Datenabschnitten

• CS9274: Dieses Zeichenfolgenliteral kann nicht in den Datenabschnitt emittiert werden, da es eine XXHash128-Kollision mit einem anderen Zeichenfolgenliteral hat.
• CS9315: Die kombinierte Länge der vom Programm verwendeten Benutzerzeichenfolgen überschreitet den zulässigen Grenzwert. Zum Hinzufügen eines Zeichenfolgenliterals muss die Anwendung neu gestartet werden.

Um diese Probleme zu beheben, probieren Sie die folgenden Techniken aus:

• Deaktivieren Sie das Feature für experimentelle String-Literale im Datenabschnitt Ihrer Anwendung, wenn ein Hash-Konflikt (CS9274) auftritt. Dieser Fehler weist darauf hin, dass zwei verschiedene Zeichenfolgenliterale den gleichen XXHash128-Wert erzeugt haben, wodurch die Optimierung nicht ordnungsgemäß funktioniert. Daher sollten Sie das Feature-Flag entfernen, das dieses experimentelle Verhalten ermöglicht.
• Starten Sie die Anwendung neu, nachdem Sie Zeichenfolgenliterale während einer Debugsitzung geändert haben, wenn das Datenabschnittsfeature aktiviert ist (CS9315). Die Hot Reload-Infrastruktur kann Zeichenfolgenliterale, die im Datenabschnitt gespeichert sind, nicht aktualisieren, da sie in ein spezielles Format eingebettet sind, das zur Laufzeit nicht geändert werden kann, sodass eine fortgesetzte Ausführung mit den alten Zeichenfolgenwerten zu einem falschen Verhalten führen würde.