C# String Format – Interpolation, Zahlen, Datum (2026)

Mit C# String Format machst du aus Rohwerten lesbare, lokalisierte Ausgaben. Dieser Beitrag zeigt drei Wege: Verkettung, String.Format und String-Interpolation. Du lernst außerdem, wie du Zahlen, Währungen, DateTimes und eigene Objekte mit CultureInfo formatierst.

Wie formatiert man einen String in C#?

Es gibt viele Situationen, in denen du sauber formatierte Strings brauchst. Stell dir eine Rechnung vor, bei der der Betrag einfach „14“ lautet. Zunächst könnte man fragen: „Vierzehn wovon?“ Und in der Regel möchte man zwei Dezimalstellen sehen. Aber auch das Anzeigen einer Personenliste in einer WPF ListView berührt das Thema String-Formatierung.

Die verschiedenen Ansätze zur String-Formatierung

Wenn es um das Formatieren von Strings in C# geht, gibt es 3 Hauptansätze:

• Strings manuell verketten
• eine Funktion der String-Klasse verwenden
• die neuere String-Interpolation nutzen

Verkettung (Concatenation) bedeutet, mehrere Strings zu einem zusammenzufügen. Das einfachste Beispiel dafür folgt im nächsten Abschnitt: zwei Namensteile zu einem vollständigen Namen zusammensetzen.

Einen String durch manuelle Verkettung formatieren

Schauen wir uns die erste Methode zur String-Formatierung an: die einfache Verkettung. Wie bereits erklärt, entsteht dabei ein komplett neuer String aus mehreren Einzelteilen. Du bist dabei nicht auf eine bestimmte Anzahl von Strings beschränkt.

Betrachten wir nun das erste kleine Beispiel: einen vollständigen Namen aus Namensteilen zusammensetzen. Dazu erstellen wir im ersten Schritt zwei Variablen und kombinieren sie dann.

string firstName = "John";
string lastName = "Doe";

Nach dem Erstellen der Variablen können wir sie zu einem neuen String verketten. Beachte dabei, dass C#-Strings unveränderlich (immutable) sind und die gängigen Operatoren und Funktionen immer einen neuen String erzeugen.

string fullName = firstName + " " + lastName;

Das war die einfachste Art, einen String zu formatieren. Aber was, wenn es etwas komplexer sein muss? Was, wenn der Nutzer sein eigenes Format festlegen können soll?

Einen String in C# „auf die alte Art“ formatieren

Das Beispiel von oben war recht simpel und bietet dem Nutzer keine Anpassungsmöglichkeit. Wenn jemand dein Programm nutzt und die Reihenfolge ändern möchte, müsste er Vor- und Nachname selbst tauschen. Klar, manchmal ist das nicht nötig, aber gut zu wissen!

Schauen wir uns nun eine Hilfsfunktion der String-Klasse des .NET Frameworks an, die einfach „Format“ heißt. Wir verwenden diese Funktion, um den gleichen vollständigen Namen wie oben zu erzeugen.

Dazu schauen wir uns zunächst die Funktionsparameter an. Es gibt verschiedene Überladungen, aber wir konzentrieren uns auf die mit einem String als erstem Parameter und einem Object-Array als zweitem. Der erste Parameter erwartet eine Art Formatierungs-„Formel“. Der zweite erwartet die Objekte, die an den entsprechenden Stellen eingesetzt werden. Das geschieht über geschweifte Klammern mit dem jeweiligen Index des Objekts.

Einen String dynamisch formatieren

Wir können beliebige Objekte (aktuell zwei Strings) kommagetrennt übergeben. Im nächsten Beispiel übergebe ich die beiden Namensteile. Die Variable firstName hat dann den Index 0, lastName den Index 1.

string firstName = "John";
string lastName= "Doe";
string fullName = string.Format("{0} {1}", firstName, lastName);

Jetzt könnte der Nutzer bei Bedarf ein eigenes Format eingeben. Im folgenden Beispiel habe ich die Reihenfolge der Namen getauscht. Das erzeugt einen neuen String mit dem Inhalt „Doe John“ statt „John Doe“.

// z.B. aus einer TextBox übernommen
string userWantedFormat = "{1} {0}";
string firstName = "John";
string lastName= "Doe";
string fullName = string.Format(format, firstName, lastName);

Du könntest die übergebenen Werte natürlich auch dynamisch über eine Liste steuern und Einträge hinzufügen oder weglassen. Die Funktion akzeptiert auch eine Liste beliebiger Objekte als Parameter.

C# String Format mit Interpolation

Ich bevorzuge den modernen Ansatz namens „String-Interpolation“. Damit kannst du die gewünschten Werte direkt an der richtigen Stelle im String platzieren. Bauen wir das obige Beispiel damit nach.

Neben der direkten Positionierung ist es auch viel einfacher zu erkennen, was wo steht. Im vorherigen Beispiel konnten wir nur sagen: „Setze den String mit Index 0 hierhin“, aber was passiert, wenn sich der Index ändert? Weißt du dann noch, welche Position korrekt ist?

Hier das Beispiel von oben, jetzt mit String-Interpolation. Dafür setzen wir ein Dollarzeichen vor den String und geben die Variablennamen in geschweiften Klammern an. Meiner Meinung nach ist das deutlich einfacher und übersichtlicher als alle bisherigen Varianten.

So können wir auch die lästigen Anführungszeichen und „+“-Zeichen vergessen. Weniger Code, bessere Lesbarkeit.

string firstName = "John";
string lastName = "Doe";
string fullName = $"{firstName} {lastName}";

Zahlen und Währungen formatieren

Nachdem wir bisher nur mit dem einfachen Namensbeispiel gearbeitet haben, gehen wir jetzt einen Schritt weiter. Strings zu Strings formatieren ist nicht schwer, aber schauen wir uns an, wie es mit komplexeren Typen aussieht. Der erste etwas komplexere (aber trotzdem einfache) Typ ist eine gewöhnliche Zahl, wie die Rechnungssumme vom Anfang dieses Beitrags (die 14).

In der Regel zeigt man den Gesamtbetrag einer Rechnung mit zwei Dezimalstellen an. Neben den Dezimalstellen verwendet man z. B. auch das Euro-Zeichen. Versuchen wir die einfache Darstellung der Zahl 14 aus dem Bild oben.

Dafür können wir eine der bereits gezeigten Methoden verwenden:

• manuelle Formatierung
• die Format-Methode der String-Klasse
• String-Interpolation

Formatieren mit der „ToString“-Basisfunktion

Zunächst ein Beispiel mit der „manuellen“ Variante über die typische „ToString“-Funktion, die von der Basisklasse Object geerbt wird. Wir verwenden die Überladung, bei der man ein Format als String angeben kann. Das Format „N2“ steht für: Zahl mit zwei Dezimalstellen.

decimal totalNet = 14.95M;
string displayValue = totalNet.ToString("N2");
// Ergebnis: "14.95" bei en-US Systemeinstellung

Mit string.Format oder Interpolation

Das gleiche Ergebnis lässt sich auch mit den anderen beiden Techniken erreichen. Hier beide Varianten:

decimal totalNet = 14.95M;
// mit string.Format
string displayValue = string.Format(totalNet, "{0:N2}");
// mit String-Interpolation
string displayValue = $"{totalNet:N2}";

Eine bestimmte Kultur / Sprache / Locale angeben

Wie im Kommentar zu sehen, erhältst du einen Wert wie „14.95“. Beachte, dass das Ergebnis von der Spracheinstellung abhängt. Du kannst über den Parameter „FormatProvider“ auch z. B. die deutsche Spracheinstellung vorgeben.

// Import nicht vergessen!
// using System.Globalization;
// entweder so
CultureInfo deDeCulture = new CultureInfo("de-DE");
// oder so
CultureInfo enUsCulture = new CultureInfo("en-US");
decimal totalNet = 14.95M;
// als zweiten Parameter übergeben
string displayValue = totalNet.ToString("N2", deDeCulture);
// Ergebnis: en-US = 14.95, de-DE = 14,95

Um String-Interpolation mit einer Kultur zu verwenden, kannst du einen „FormattableString“ erstellen und diesen statt eines normalen Strings verwenden.

decimal totalNet = 14.95M;
// erzeugt automatisch einen FormattableString!
FormattableString displayValue = $"Der Gesamtpreis beträgt {totalNet:N2}.";
CultureInfo enUsCulture = new CultureInfo("en-US");
string message = displayValue.ToString(enUsCulture);
// en-US = 14.95, de-DE = 14,95

Die Kultur global setzen, nicht pro Aufruf

Im nächsten Schritt kannst du es noch einfacher machen, je nach Anwendungsfall, indem du die „CultureInfo“ global setzt. Damit überschreibst du die systemspezifische Standardeinstellung:

// Import nicht vergessen
// using System.Threading;
CultureInfo deDeCulture = new CultureInfo("de-DE");
CultureInfo enUsCulture = new CultureInfo("en-US");
// System-Standard überschreiben
Thread.CurrentThread.CurrentCulture = enUsCulture;

Alle nachfolgenden Aufrufe von Formatierungsfunktionen wie „ToString“ verwenden nun „enUsCulture“ als Standard (anstelle der Systemvorgabe).

Währungsformatierte Strings ausgeben

Nach der normalen Zahlenformatierung können wir nun eine einfache währungsbezogene Zahl anzeigen. Das funktioniert fast identisch, nur mit einem anderen Buchstaben. Statt „N2“ (Zahl mit 2 Dezimalstellen) verwende ich „C2“ (Währung mit 2 Dezimalstellen).

// siehe auch die vorherigen Beispiele mit string.Format und manueller Variante
FormattableString displayValue = $"Der Gesamtpreis beträgt {totalNet:C2}.";
CultureInfo enUsCulture = new CultureInfo("en-US");
string message = displayValue.ToString(enUsCulture);

DateTimes oder komplexere Objekte formatieren

Im nächsten Abschnitt schauen wir uns das Formatieren von komplexeren Objekten an. Zum Beispiel die DateTime-Klasse und eventuell auch eigene Klassen.

Was, wenn du einen Kunden hast, der entweder Privat- oder Geschäftskunde sein kann, und du per C# String Format dessen Anzeige steuern willst? Zeigst du den Firmennamen oder Vor- und Nachname an?

DateTimes formatieren

Beginnen wir mit ein paar Beispielen zur Formatierung einer C# DateTime-Instanz. Ich bleibe bei der String-Interpolation, du kannst aber auch die anderen Techniken von oben verwenden. Nach einem einfachen Datumsstring geht es weiter mit Monats- und Zeitformaten.

// aktuelles Datum und Uhrzeit als Beispiel
DateTime now = DateTime.Now;
// typisch deutsches Datum - z.B. 30.03.2023
string displayValue = $"{now:dd.MM.yyyy}";
// typisch englisches Datum - Backslashes beachten, alternativ
// die doppelten Backslashes weglassen und den @-Prefix nutzen: @$
string displayValue = $"{now:MM\\dd\\yyyy}";
// mit Uhrzeit arbeiten
string displayTimeValue = @$"{now:HH:mm}";

Eigene Objekte wie eine Kunden-Klasse formatieren

In diesem letzten Abschnitt schauen wir uns das Formatieren einer eigenen Kunden-Klasse an. Die Klasse ist bewusst einfach gehalten mit nur wenigen Properties. Wir erstellen zwei „Typen“ von Kunden: Geschäftskunden und Privatkunden. Der Geschäftskunde hat nur seinen Firmennamen, der Privatkunde Vor- und Nachnamen.

public class Customer
{

  public string Company { get; set; }

  public string FirstName { get; set; }

  public string LastName { get; set; }

  public Customer(string company)
  {
    Company = company;
  }

  public Customer(string firstName, string lastName)
  {
    FirstName = firstName;
    LastName = lastName;
  }

}

Dann können wir einen Privat- und einen Geschäftskunden so erstellen:

Customer privateCustomer = new Customer("John", "Doe");
Customer businessCustomer = new Customer("Doe Max Profit ltd.");

Wenn du sie jetzt so formatierst, erhältst du etwas wie „Customer: ProjektName.ClassName“. So sehen Objekte ohne Überschreibung der „ToString“-Funktion aus.

// enthält z.B. Customer: ProjektName.Customer
string text = $"Customer: {privateCustomer}";

Wir müssen also nur die „ToString“-Funktion überschreiben. In diesem Beispiel priorisiere ich den Firmennamen. Ist keiner vorhanden, gebe ich den vollständigen Namen zurück. Wenn du über mehrere Kunden iterieren musst, schau dir C# ForEach an.

public class Customer
{

  // ...
  // restlicher Code von oben
  // ...

  public override ToString()
  {
    if (string.IsNullOrEmpty(Company)) {
      return Company;
    }
    return $"{FirstName} {LastName}";
  }
}

Schau dir nun die Ergebnisse der folgenden Codezeilen an:

Customer privateCustomer = new Customer("John", "Doe");
Customer businessCustomer = new Customer("Doe Max Profit ltd.");
// enthält Customer: John Doe
string text = $"Customer: {privateCustomer}";
// enthält Customer: Doe Max Profit ltd.
string text = $"Customer: {businessCustomer}";

Wie in den Kommentaren zu sehen, erhalten wir nun unterschiedliche und besser lesbare Ergebnisse.

FAQ

Fazit

C# bietet drei Wege zur String-Formatierung: manuelle Verkettung, String.Format und String-Interpolation. Für neuen Code empfehle ich Interpolation, da sie am lesbarsten ist. Verwende CultureInfo, wenn deine Anwendung mehrere Sprachen unterstützen muss. Für ein weiteres praktisches C#-Beispiel schau dir C# LINQ Sum an.