Teilen über

Text eines unformatierten Zeichenfolgenliterals: """ in Zeichenfolgenliteralen

Ein unformatiertes Zeichenfolgenliteral beginnt und endet jeweils mit mindestens drei doppelten Anführungszeichen ("):

var singleLine = """This is a "raw string literal". It can contain characters like \, ' and ".""";

Unformatierte Zeichenfolgenliterale können mehrere Zeilen umfassen:

var xml = """
        <element attr="content">
            <body>
            </body>
        </element>
        """;

Die C#-Sprachreferenz dokumentiert die zuletzt veröffentlichte Version der C#-Sprache. Außerdem enthält sie erste Dokumentation für Features in der öffentlichen Vorschau für die kommende Sprachversion.

In der Dokumentation werden alle Features identifiziert, die in den letzten drei Versionen der Sprache oder in der aktuellen öffentlichen Vorschau eingeführt wurden.

Tipp

Informationen dazu, wann ein Feature erstmals in C# eingeführt wurde, finden Sie im Artikel zum Versionsverlauf der C#-Sprache.

Die folgenden Regeln regeln die Interpretation eines mehrteiligen unformatierten Zeichenfolgenliterals:

  • Die ersten Anführungszeichen müssen die letzten Nicht-Leerzeichen in ihrer Zeile sein, und die schließenden Anführungszeichen müssen die ersten Nicht-Leerzeichen in ihrer Zeile sein.
  • Leerzeichen, die sich links von den schließenden Anführungszeichen befinden, werden aus allen Zeilen des unformatierten Zeichenfolgenliterals entfernt.
  • Alle Leerzeichen, die auf die öffnenden Anführungszeichen in derselben Zeile folgen, werden ignoriert.
  • Nur Leerzeichenzeilen nach dem öffnenden Anführungszeichen sind im Zeichenfolgenliteral enthalten.
  • Der Zeilenumbruch vor den schließenden Anführungszeichen ist nicht in der Zeichenfolge enthalten.
  • Wenn leerzeichen vor dem Endtrennzeichen in derselben Zeile stehen, müssen die genaue Anzahl und Art von Leerzeichen (z. B. Leerzeichen und Tabstopps) am Anfang jeder Inhaltszeile vorhanden sein. Insbesondere stimmt ein Leerzeichen nicht mit einer horizontalen Registerkarte überein und umgekehrt.

Die letzte Regel ist einfach, wenn Sie konsistent sind, wie Sie Registerkarten (U+0009) oder Leerzeichen (U+0020) zum Einrücken des Codes verwenden, einschließlich unformatierter Zeichenfolgenliterale. Sie können beide verwenden, aber nicht in demselben mehrteiligen unformatierten Zeichenfolgenliteral mischen. Die folgenden Deklarationen sind z. B. zulässig (Leerzeichen werden wie \b für ein Leerzeichen und \t für ein Tabstoppzeichen gezeichnet:)

// Using `\b` and `\t` to visual the actual whitespace characters
var xml = """
\b\b\b\b<element attr="content">
\b\b\b\b\b\b<body>
\b\b\b\b\b\b</body>
\b\b\b\b</element>
\b\b\b\b""";

// Using `\b` and `\t` to visual the actual whitespace characters
var xmlTabs = """
\t\t\t\t<element attr="content">
\t\t\t\t\t\t<body>
\t\t\t\t\t\t</body>
\t\t\t\t</element>
\t\t\t\t""";

Da die folgende Deklaration jedoch kein konsistentes Format für das Leerzeichen links neben dem Schließen """verwendet, ist die Deklaration ungültig:

// Using `\b` and `\t` to visual the actual whitespace characters
var xml = """
\t\b\b\b<element attr="content">
\b\t\b\b\b\b<body>
\b\b\t\b\b\b</body>
\b\b\b\t</element>
\b\b\b\b""";

Tipp

Visual Studio und das C# Dev Kit bieten einige Überprüfungs- und Syntaxmarkierungen, wenn unformatierte Zeichenfolgenliterale JSON-Daten oder reguläre Ausdrücke enthalten.

Die Tools analysieren den Text. Wenn die Tools vertrauen, dass der Text JSON oder einen regulären Ausdruck darstellt, stellt der Editor Syntaxfarben bereit.

Sie können diese Erfahrung verbessern, indem Sie einen Kommentar oberhalb der Deklaration hinzufügen, der das Format angibt:

  • // lang=json gibt an, dass das unformatierte Zeichenfolgenliteral JSON-Daten darstellt.
  • // lang=regex gibt an, dass das unformatierte Zeichenfolgenliteral einen regulären Ausdruck darstellt.

Wenn ein unformatiertes Zeichenfolgenliteral als Argument verwendet wird, bei dem der Parameter das System.Diagnostics.CodeAnalysis.StringSyntaxAttribute Format angibt, überprüfen diese Tools das unformatierte Zeichenfolgenliteral für einige der Formattypen. Sowohl JSON als auch regex werden unterstützt.

Bei einigen Formaten ermöglicht der Kommentar oder das Attribut Codevorschläge Korrekturen für Zeichenfolgenliterale basierend auf dem Format.

Möglicherweise müssen Sie ein unformatiertes Zeichenfolgenliteral erstellen, das drei oder mehr aufeinander folgende doppelte Anführungszeichen enthält. Unformatierte Zeichenfolgenliterale können mit einer Sequenz von mindestens drei doppelten Anführungszeichen beginnen und enden. Wenn Ihr Zeichenfolgenliteral drei aufeinanderfolgende doppelte Anführungszeichen enthält, beginnen und beenden Sie das unformatierte Zeichenfolgenliteral mit vier doppelten Anführungszeichen:

var moreQuotes = """" As you can see,"""Raw string literals""" can start and end with more than three double-quotes when needed."""";

Wenn Sie ein unformatiertes Zeichenfolgenliteral mit Anführungszeichen beginnen oder beenden müssen, verwenden Sie das mehrteilige Format:

var MultiLineQuotes = """"
               """Raw string literals""" can start and end with more than three double-quotes when needed.
               """";

Rohzeichenfolgenliterale können auch mit interpolierten Zeichenfolgen kombiniert werden, um die Zeichen { und } in die Ausgabezeichenfolge einzubetten. Sie können mehrere $-Zeichen in einem interpolierten unformatierten Zeichenfolgenliteral verwenden, um die Zeichen { und } in die Ausgabezeichenfolge einzubetten, ohne sie mit Escapezeichen zu versehen.

Der Inhalt des unformatierten Zeichenfolgenliterals darf keinen Satz zusammenhängender "-Zeichen enthalten, deren Länge gleich oder größer als die Länge des Trennzeichens des unformatierten Zeichenfolgenliterals ist. Beispielsweise sind die Zeichenfolgen """" """ """" und """"""" """""" """"" """" """ """"""" wohlgeformt. Die Zeichenfolgen """ """ """ sind jedoch """ """" """ nicht wohlgeformt.

Weitere Informationen

  • Last updated on