C# String-Interpolation und String.Format: Formatbezeichner, Ausrichtung, Kultur

String-Interpolation baut einen String aus wörtlichem Text und Ausdrücken. Stelle dem Literal ein $ voran, setze einen beliebigen C#-Ausdruck in geschweifte Klammern, und sein Wert wird in Text umgewandelt und eingefügt:

using System;

class Program
{
    static void Main()
    {
        string customer = "Maya";
        int items = 3;
        decimal price = 4.5m;

        Console.WriteLine($"Hello, {customer}!");
        Console.WriteLine($"{items} items at {price} = {items * price}");
        Console.WriteLine($"Name has {customer.Length} letters, upper: {customer.ToUpper()}");
        Console.WriteLine($"Free shipping: {(items * price > 10 ? "yes" : "no")}");
    }
}

Ausgabe:

Hello, Maya!
3 items at 4.5 = 13.5
Name has 4 letters, upper: MAYA
Free shipping: yes

Interpolation kam mit C# 6. Der Compiler macht daraus einen Aufruf von string.Format oder string.Concat (oder seit C# 10 effizienteren Handler-Code), sie ist also nicht langsamer, als den String von Hand zu bauen.

Der Bedingungsausdruck in der letzten Zeile braucht Klammern. In einem Interpolationsloch leitet ein Doppelpunkt einen Formatbezeichner ein, daher ist {x > 10 ? "yes" : "no"} ohne Klammern ein Kompilierfehler.

Formatbezeichner

Nach dem Ausdruck steuern ein Doppelpunkt und ein Formatstring, wie der Wert geschrieben wird. Dieselben Formatstrings funktionieren mit ToString("...") und string.Format.

using System;

class Program
{
    static void Main()
    {
        decimal total = 1234567.891m;
        int orderId = 42;
        double ratio = 0.8127;

        Console.WriteLine($"{total:F2}");     // fixed-point, 2 decimals
        Console.WriteLine($"{total:N2}");     // with thousands separators
        Console.WriteLine($"{total:N0}");     // no decimals, rounded
        Console.WriteLine($"{orderId:D5}");   // integer padded to 5 digits
        Console.WriteLine($"{255:X}");        // hexadecimal
        Console.WriteLine($"{255:x4}");       // lowercase hex, 4 digits
        Console.WriteLine($"{total:E2}");     // scientific
        Console.WriteLine($"{ratio:F3}");
        Console.WriteLine($"{ratio:0.0%}");   // custom: percent with 1 decimal
        Console.WriteLine($"{total:#,##0.00}"); // custom pattern
        Console.WriteLine($"{7.5:000.0}");    // leading zeros
        Console.WriteLine($"{3.10m:0.##}");   // drop trailing zeros
    }
}

Ausgabe:

1234567.89
1,234,567.89
1,234,568
00042
FF
00ff
1.23E+006
0.813
81.3%
1,234,567.89
007.5
3.1

Die Standardcodes, jeweils optional gefolgt von einer Genauigkeitsangabe:

Benutzerdefinierte Muster bauen ein Format aus Platzhaltern: 0 ist eine Ziffer, die immer angezeigt wird, # eine Ziffer, die nur angezeigt wird, wenn sie signifikant ist, . ist das Dezimaltrennzeichen, , innerhalb der Zahl aktiviert Gruppentrennzeichen, und % multipliziert mit 100. "0.##" zeigt bis zu zwei Nachkommastellen und lässt nachgestellte Nullen weg; "#,##0.00" ist das klassische Buchhaltungsformat.

Jede numerische Formatierung rundet den angezeigten Wert; die Variable selbst bleibt unverändert. Liegt ein Wert genau in der Mitte (2.25 mit einer Nachkommastelle angezeigt), können verschiedene Runtimes und Typen diesen Gleichstand unterschiedlich runden. Wenn die Regel wichtig ist, runde also vorher explizit mit Math.Round(value, 1, MidpointRounding.AwayFromZero) und formatiere dann.

Datumswerte in der Interpolation

DateTime-Werte nehmen auf dieselbe Weise Datumsformatstrings an:

using System;

class Program
{
    static void Main()
    {
        var shipped = new DateTime(2026, 9, 24, 16, 5, 0);

        Console.WriteLine($"{shipped:yyyy-MM-dd}");
        Console.WriteLine($"{shipped:dd/MM/yyyy HH:mm}");
        Console.WriteLine($"{shipped:ddd, MMM d}");
        Console.WriteLine($"Shipped at {shipped:HH:mm} on {shipped:dddd}");

        TimeSpan eta = TimeSpan.FromMinutes(130);
        Console.WriteLine($"ETA {eta:hh\\:mm}");
        Console.WriteLine($"{eta.TotalHours:F1} hours");
    }
}

Ausgabe:

2026-09-24
24/09/2026 16:05
Thu, Sep 24
Shipped at 16:05 on Thursday
ETA 02:10
2.2 hours

Ein benutzerdefiniertes Format für TimeSpan verlangt, dass wörtliche Zeichen mit einem Backslash escaped werden, was in einem normalen String-Literal als \\: geschrieben wird. Die vollständige Liste der Datumscodes (yyyy, MM, HH, tt...) und die typischen Fehler damit (mm sind Minuten, MM sind Monate) findest du unter DateTime-Format.

Ausrichtung und Auffüllen

Ein Komma nach dem Ausdruck legt eine Mindestbreite des Felds fest. Eine positive Zahl richtet rechtsbündig aus, eine negative linksbündig. Zusammen mit einem Format richtet das Tabellen in reinem Text aus:

using System;

class Program
{
    static void Main()
    {
        var names = new[] { "Espresso", "Latte", "Hot chocolate" };
        var prices = new[] { 2.4m, 3.6m, 4.25m };
        var sold = new[] { 118, 64, 9 };

        Console.WriteLine($"{"Item",-14}|{"Price",7}|{"Sold",5}");
        Console.WriteLine(new string('-', 28));
        for (int i = 0; i < names.Length; i++)
        {
            Console.WriteLine($"{names[i],-14}|{prices[i],7:F2}|{sold[i],5}");
        }
    }
}

Ausgabe:

Item          |  Price| Sold
----------------------------
Espresso      |   2.40|  118
Latte         |   3.60|   64
Hot chocolate |   4.25|    9

Die Syntax ist {expression,alignment:format}: zuerst die Ausrichtung, dann das Format. Ein Wert, der länger als die Breite ist, wird nicht abgeschnitten; er schiebt den Rest der Zeile weiter. PadLeft und PadRight füllen außerhalb der Interpolation auf dieselbe Weise auf.

Geschweifte Klammern escapen

Um eine wörtliche Klammer auszugeben, verdopple sie: {{ und }}. Das kommt vor, wenn die Ausgabe JSON, CSS oder Code ist:

using System;

class Program
{
    static void Main()
    {
        int id = 42;
        string name = "Ana";

        Console.WriteLine($"{{ \"id\": {id}, \"name\": \"{name}\" }}");
        Console.WriteLine($"Set literal: {{1, 2, 3}}");
        Console.WriteLine($"{{{id}}}");   // a value wrapped in braces
    }
}

Ausgabe:

{ "id": 42, "name": "Ana" }
Set literal: {1, 2, 3}
{42}

JSON so von Hand zu bauen ist für eine schnelle Logzeile in Ordnung; für echtes JSON nimm einen Serializer, der Anführungszeichen und Sonderzeichen in name korrekt behandelt.

string.Format und kombinierte Formatierung

Vor C# 6 wurde mit string.Format formatiert, das nummerierte Platzhalter und eine Liste von Argumenten nimmt. Dieselbe Syntax der kombinierten Formatierung akzeptieren Console.WriteLine, StringBuilder.AppendFormat und TextWriter.Write:

using System;

class Program
{
    static void Main()
    {
        string item = "Notebook";
        decimal price = 3.5m;
        int qty = 4;

        string line = string.Format("{0} x{1}: {2:F2}", item, qty, price * qty);
        Console.WriteLine(line);

        Console.WriteLine("{0,-10}|{1,6:F2}", item, price);   // alignment and format
        Console.WriteLine("{0} {0} {1}", "echo", "!");        // an index can repeat

        string template = "Dear {0}, your order #{1:D6} has shipped.";
        Console.WriteLine(string.Format(template, "Leo", 731));
    }
}

Ausgabe:

Notebook x4: 14.00
Notebook  |  3.50
echo echo !
Dear Leo, your order #000731 has shipped.

Im Code ist Interpolation vorzuziehen: Die Werte stehen dort, wo sie erscheinen, ein Platzhalter kann also nicht auf das falsche Argument zeigen. string.Format bleibt das richtige Werkzeug, wenn die Vorlage Daten ist, etwa eine übersetzte Meldung aus einer Ressourcendatei. Ein Platzhalterindex ohne passendes Argument ({2} bei zwei Argumenten) wirft zur Laufzeit eine FormatException.

Kultur: Trennzeichen und Währung steuern

Interpolation, ToString und string.Format verwenden standardmäßig alle die aktuelle Kultur des Threads. Auf einem auf Deutsch eingestellten Rechner ergibt {1234.5:N2} den Text 1.234,50, in den USA 1,234.50. Das Währungsformat C verwendet das Symbol der Kultur. Um die Kultur explizit zu wählen, fange den interpolierten String als FormattableString ab und formatiere ihn mit einem Provider:

using System;
using System.Globalization;

class Program
{
    static void Main()
    {
        decimal amount = 1234.5m;
        var us = new CultureInfo("en-US");
        var de = new CultureInfo("de-DE");

        FormattableString line = $"Total: {amount:N2}";
        Console.WriteLine(line.ToString(us));
        Console.WriteLine(line.ToString(de));

        Console.WriteLine(amount.ToString("C", us));
        Console.WriteLine(string.Format(de, "{0:N2}", amount));

        // For files, logs and URLs: always the invariant culture
        string csv = FormattableString.Invariant($"{amount},{0.75}");
        Console.WriteLine(csv);
    }
}

Ausgabe:

Total: 1,234.50
Total: 1.234,50
$1,234.50
1.234,50
1234.5,0.75

Nimm die Kultur des Benutzers für Text, den Menschen lesen, und CultureInfo.InvariantCulture für alles, was ein anderes Programm liest. Eine CSV-Datei, die auf einem deutschen Rechner mit der aktuellen Kultur geschrieben wurde, hat Kommas in Zahlen und ist anderswo nicht lesbar. Ab .NET 6 tut string.Create(CultureInfo.InvariantCulture, $"...") dasselbe wie FormattableString.Invariant, ohne das Zwischenobjekt.

Verbatim- und Raw-Interpolation

$ lässt sich mit @ zu einem interpolierten Verbatim-String kombinieren: Backslashes sind wörtlich, und der String darf sich über mehrere Zeilen erstrecken. Ab C# 8 ist jede Reihenfolge erlaubt ($@ oder @$); C# 6 und 7 verlangen $@:

using System;

class Program
{
    static void Main()
    {
        string user = "ana";
        int year = 2026;
        Console.WriteLine($@"C:\Users\{user}\Reports\{year}\summary.txt");
        Console.WriteLine($@"Report for {user}
Year: {year}");
    }
}

Ausgabe:

C:\Users\ana\Reports\2026\summary.txt
Report for ana
Year: 2026

C# 11 hat interpolierte Raw-Strings eingeführt. Mit einem $ markieren Klammern wie gewohnt Ausdrücke. Mit $$ ist eine einzelne Klammer wörtlich, und Ausdrücke brauchen zwei Klammern, was JSON- und Code-Vorlagen lesbar macht:

// C# 11 and later
int id = 42;
string name = "Ana";
string json = $$"""
    {
      "id": {{id}},
      "name": "{{name}}"
    }
    """;

C# 11 erlaubt außerdem Zeilenumbrüche innerhalb eines Interpolationslochs, ein langer Ausdruck oder ein switch-Ausdruck lässt sich also auf mehrere Zeilen verteilen.

Häufige Fehler

• Das $ vergessen. "Total: {total}" gibt die Klammern wörtlich aus. Der Compiler warnt nicht.
• Ein Bedingungsoperator ohne Klammern innerhalb der geschweiften Klammern: Der Doppelpunkt wird als Formattrenner gelesen.
• Maschinenlesbare Ausgabe mit der aktuellen Kultur formatieren. Dezimalkommas zerstören CSV, JSON und SQL. Nimm die invariante Kultur.
• ToString() ohne Format für Geld verwenden. 2.5m wird als 2.5 ausgegeben, nicht als 2.50. Nimm F2, N2 oder C.
• Große Strings in einer Schleife mit Interpolation bauen. Jeder Durchlauf erzeugt einen neuen String; nimm StringBuilder oder string.Join.