Interpolierte Zeichenfolgen (C#-Referenz)

Zum Erstellen von Zeichenfolgen verwendet. Eine interpolierte Zeichenfolge sieht wie eine Vorlagenzeichenfolge aus, die interpolierte Ausdrücke enthält. Eine interpolierte Zeichenfolge gibt eine Zeichenfolge zurück, die die interpolierten Ausdrücke, die sie enthält, durch deren Zeichenfolgenrepräsentation ersetzt.

Die Argumente einer interpolierten Zeichenfolge sind leichter zu verstehen als eine Zusammengesetzte Formatzeichenfolge. Die interpolierte Zeichenfolge

Console.WriteLine($"Name = {name}, hours = {hours:hh}"); 

enthält z.B. zwei interpolierte Ausdrücke: „{name}“ und „{hours:hh}“. Die entsprechende zusammengesetzte Zeichenfolge lautet:

Console.WriteLine("Name = {0}, hours = {1:hh}", name, hours);  

Die Struktur einer interpolierten Zeichenfolge lautet:

$"<text> {<interpolated-expression> [,<field-width>] [:<format-string>] } <text> ..."  

Dabei gilt:

  • field-width ist eine Ganzzahl mit Vorzeichen, die die Anzahl von Zeichen in einem Feld angibt. Wenn sie positiv ist, ist das Feld rechtsbündig; wenn sie negativ ist, ist es linksbündig.

  • format-string ist eine Formatzeichenfolge, die zu dem Objekttyp passt, der formatiert wird. Für den Wert @System.DateTime wäre es beispielsweise eine Standardzeichenfolge für Datum und Zeit wie etwa „D“ und „d“.

Eine interpolierte Zeichenfolge können Sie überall dort verwenden, wo Sie ein Zeichenfolgenliteral verwenden. Die interpolierte Zeichenfolge wird immer nach ausgewertet, wenn der Code mit der interpolierten Zeichenfolge ausgeführt wird. So können Sie die Definition und die Auswertung einer interpolierten Zeichenfolge voneinander trennen.

Um eine geschweifte Klammer („{“ oder „}“) in eine interpolierte Zeichenfolge einzuschließen, verwenden Sie zwei geschweifte Klammern („{{“ oder „}}“). Ausführliche Informationen finden Sie im Abschnitt „Implizite Konvertierungen“.

Wenn die interpolierte Zeichenfolge andere Zeichen mit besonderen Bedeutungen für eine interpolierte Zeichenfolge enthält, wie z.B. Anführungszeichen („), Doppelpunkte (:) oder Kommas (,), sollten diese mit Escapezeichen verwendet werden, wenn sie in Literaltext vorkommen, oder sie sollten in einen Ausdruck eingefügt werden, der durch Klammern getrennt wird, wenn sie Sprachelemente sind, die in einem interpolierten Ausdruck vorkommen. In folgendem Beispiel werden Anführungszeichen mit Escapezeichen verwendet, um diese in der Ergebniszeichenfolge zu beinhalten; Klammern werden zur Trennung des Ausdrucks (age == 1 ? "" : "s") verwendet, damit der Doppelpunkt nicht als Beginn einer Formatzeichenfolge gewertet wird.

using System;

public class Example
{
   public static void Main()
   {
      var name = "Horace";
      var age = 34;
      var s1 = $"He asked, \"Is your name {name}?\", but didn't wait for a reply.";
      Console.WriteLine(s1);
      
      var s2 = $"{name} is {age:D3} year{(age == 1 ? "" : "s")} old.";
      Console.WriteLine(s2); 
   }
}
// The example displays the following output:
//       He asked, "Is your name Horace?", but didn't wait for a reply.
//       Horace is 034 years old.

Implizite Konvertierungen

Es gibt drei implizite Typkonvertierungen aus einer interpolierten Zeichenfolge:

  1. Die Konvertierung einer interpolierten Zeichenfolge in @System.String. In folgendem Beispiel wird eine Zeichenfolge zurückgegeben, deren interpolierte Zeichenfolgenausdrücke durch deren Zeichenfolgenrepräsentationen ersetzt wurden. Zum Beispiel:

    using System;
    
    public class Example
    {
       public static void Main()
       {
          var name = "Bartholomew";
          var s1 = $"Hello, {name}!";  
          Console.WriteLine(s1);
       }
    }
    // The example displays the following output:
    //      Hello, Bartholomew!
    

    Das ist das endgültige Ergebnis einer Zeichenfolgeninterpretation. Alle Vorkommen von doppelten geschweiften Klammern („{{“ oder „}}“) werden in einzelne geschweifte Klammern konvertiert.

  2. Die Konvertierung einer interpolierten Zeichenfolge in eine <xref:System.IFormattable>-Variable, die es Ihnen ermöglicht, mehrere Ergebniszeichenfolgen mit kulturspezifischem Inhalt aus einer einzelnen <xref:System.IFormattable>-Instanz zu erstellen. Dies ist nützlich, wenn sie z.B. die richtigen numerischen und Datumsformate für eine einzelne Kultur einfügen möchten. Alle Vorkommen von doppelten geschweiften Klammern („{{“ oder „}}“) bleiben bestehen, bis Sie die Zeichenfolge formatieren, indem sie die Methode @System.Object.ToString implizit oder explizit aufrufen. Alle enthaltenen Interpolationsausdrücke werden in {0}, {1} usw. konvertiert.

    Im folgendem Beispiel wird die Reflektion verwendet, um die Member sowie die Felder- und Eigenschaftwerte der <xref:System.IFormattable>-Variablen anzuzeigen, die aus einer interpolierten Zeichenfolge erstellt wird. Außerdem wird die @System.Console-Variable an die <xref:System.IFormattable>(System-String)-Methode übergeben.

    using System;
    using System.Globalization;
    using System.Reflection;
    
    public class Example
    {
       public static void Main()
       {
          var price = 1000;
          IFormattable s2 = $"The cost of this item is {price:C}.";  
          ShowInfo(s2);
          CultureInfo.CurrentCulture = new CultureInfo("en-US");
          Console.WriteLine(s2);
          CultureInfo.CurrentCulture = new CultureInfo("fr-FR");
          Console.WriteLine(s2);      
       }
    
       private static void ShowInfo(object obj)
       {
          Console.WriteLine("Displaying member information:\n");
          var t = obj.GetType();
          var flags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic;
          foreach (var m in t.GetMembers(flags)) {
             Console.WriteLine($"{m.Name}: {m.MemberType}");   
             if (m.MemberType == MemberTypes.Property) {
                var p = t.GetProperty(m.Name, flags);
                Console.WriteLine($"   Value: {p.GetValue(obj)}");         
             }
             if (m.MemberType == MemberTypes.Field) {
                var f = t.GetField(m.Name, flags);
                Console.WriteLine($"   Value: {f.GetValue(obj)}");
             }
          }
          Console.WriteLine("-------\n");
       }
    }
    // The example displays the following output:
    //       Displaying member information:
    //       
    //       get_Format: Method
    //       GetArguments: Method
    //       get_ArgumentCount: Method
    //       GetArgument: Method
    //       ToString: Method
    //       System.IFormattable.ToString: Method
    //       ToString: Method
    //       Equals: Method
    //       GetHashCode: Method
    //       GetType: Method
    //       Finalize: Method
    //       MemberwiseClone: Method
    //       .ctor: Constructor
    //       Format: Property
    //          Value: The cost of this item is {0:C}.
    //       ArgumentCount: Property
    //          Value: 1
    //       _format: Field
    //          Value: The cost of this item is {0:C}.
    //       _arguments: Field
    //          Value: System.Object[]
    //       -------
    //       
    //       The cost of this item is $1,000.00.
    //       The cost of this item is 1 000,00 €.
    

    Beachten Sie, dass die interpolierte Zeichenfolge nur mithilfe von Reflektion überprüft werden kann. Wenn sie an eine Methode zum Formatieren von Zeichenfolgen übergeben wird, wie z.B. @System.Console.WriteLine(System.String), werden ihre Formatelemente aufgelöst und die Ergebniszeichenfolge zurückgegeben.

  3. Die Konvertierung einer interpolierten Zeichenfolge in eine <xref:System.FormattableString>-Variable, die eine zusammengesetzte Formatzeichenfolge repräsentiert. Das Überprüfen der zusammengesetzten Zeichenfolge und wie diese als Ergebniszeichenfolge rendert, hilft Ihnen z.B möglicherweise dabei, sich gegen einen Einschleusungsangriff zu schützen, während Sie eine Abfrage erstellen. <xref:System.FormattableString> enthält auch <xref:System.FormattableString.ToString>-Überladungen, mit denen Sie Ergebniszeichenfolgen für die Objekte @System.Globalization.InvariantCulture und @System.Globalization.CurrentCulture erzeugen können. Alle Vorkommen von doppelten geschweiften Klammern („{{“ oder „}}“) bleiben bestehen, bis Sie die Zeichenfolge formatieren. Alle enthaltenen Interpolationsausdrücke werden in {0}, {1} usw. konvertiert.

    using System;
    using System.Globalization;
    
    public class Example
    {
       public static void Main()
       {
          var name = "Bartholomew";
          FormattableString s3 = $"Hello, {name}!";  
          Console.WriteLine($"String: {s3.Format}");
          Console.WriteLine($"Arguments: {s3.ArgumentCount}");
          Console.WriteLine($"Result string: {s3}");
       }
    }
    // The example displays the following output:
    //       String: Hello, {0}!
    //       Arguments: 1
    //       Result string: Hello, Bartholomew!
    

Sprachspezifikation

Weitere Informationen erhalten Sie unter C#-Sprachspezifikation. Die Sprachspezifikation ist die verbindliche Quelle für die Syntax und Verwendung von C#.

Siehe auch

<xref:System.IFormattable?displayProperty=fullName>
<xref:System.FormattableString?displayProperty=fullName>
C#-Referenz
C#-Programmierhandbuch