C# String Interpolation and String.Format: Format Specifiers, Alignment, Culture

String interpolation builds a string from literal text and expressions. Prefix the literal with $, put any C# expression in braces, and its value is converted to text and inserted:

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")}");
    }
}

Output:

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

Interpolation arrived in C# 6. The compiler turns it into a string.Format or string.Concat call (or, since C# 10, into more efficient handler code), so it is not slower than building the string by hand.

The conditional expression in the last line needs parentheses. Inside an interpolation hole, a colon starts a format specifier, so {x > 10 ? "yes" : "no"} without parentheses is a compile error.

Format specifiers

After the expression, a colon and a format string control how the value is written. The same format strings work with ToString("...") and 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
    }
}

Output:

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

The standard codes, each optionally followed by a precision number:

Custom patterns build a format from placeholders: 0 is a digit that is always shown, # is a digit shown only if significant, . is the decimal point, , inside the number enables group separators, and % multiplies by 100. "0.##" shows up to two decimals and drops trailing zeros; "#,##0.00" is the classic accounting format.

All numeric formatting rounds the displayed value; the variable itself is unchanged. When a value sits exactly halfway (2.25 shown with one decimal), different runtimes and types can round the tie differently, so if the rule matters, round explicitly first with Math.Round(value, 1, MidpointRounding.AwayFromZero) and then format.

Dates in interpolation

DateTime values take date format strings the same way:

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");
    }
}

Output:

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

A TimeSpan custom format requires literal characters to be escaped with a backslash, which in a regular string literal is written \\:. The full list of date codes (yyyy, MM, HH, tt...) and the mistakes people make with them (mm is minutes, MM is months) are on DateTime format.

Alignment and padding

A comma after the expression sets a minimum field width. A positive number right-aligns, a negative number left-aligns. Combined with a format, it lines up tables in plain text:

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}");
        }
    }
}

Output:

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

The syntax is {expression,alignment:format}: alignment first, then format. A value longer than the width is not truncated; it pushes the rest of the line over. PadLeft and PadRight do the same padding outside interpolation.

Escaping braces

To print a literal brace, double it: {{ and }}. This comes up when the output is JSON, CSS or code:

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
    }
}

Output:

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

Building JSON by hand like this is fine for a quick log line; for real JSON use a serializer, which handles quotes and special characters inside name correctly.

string.Format and composite formatting

Before C# 6, formatting was done with string.Format, which takes numbered placeholders and a list of arguments. The same composite format syntax is accepted by Console.WriteLine, StringBuilder.AppendFormat and 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));
    }
}

Output:

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

Prefer interpolation in code: the values sit where they appear, so a placeholder cannot point at the wrong argument. string.Format remains the right tool when the template is data, such as a translated message loaded from a resource file. A placeholder index with no matching argument ({2} with two arguments) throws a FormatException at run time.

Culture: controlling separators and currency

Interpolation, ToString and string.Format all use the current culture of the thread by default. On a machine set to German, {1234.5:N2} produces 1.234,50; in the US it produces 1,234.50. The currency format C uses the culture's symbol. To choose the culture explicitly, capture the interpolated string as a FormattableString and format it with a 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);
    }
}

Output:

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

Use the user's culture for text people read, and CultureInfo.InvariantCulture for anything another program reads. A CSV written with the current culture on a German machine has commas inside numbers and is unreadable elsewhere. On .NET 6 and later, string.Create(CultureInfo.InvariantCulture, $"...") does the same as FormattableString.Invariant without the intermediate object.

Verbatim and raw interpolated strings

$ combines with @ for a verbatim interpolated string: backslashes are literal and the string may span lines. C# 8 and later accept either order ($@ or @$); C# 6 and 7 require $@:

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}");
    }
}

Output:

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

C# 11 added raw interpolated strings. With one $, braces mark expressions as usual. With $$, a single brace is a literal and expressions need two braces, which makes JSON and code templates readable:

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

C# 11 also allows newlines inside an interpolation hole, so a long expression or a switch expression can be split over several lines.

Common mistakes

• Forgetting the $. "Total: {total}" prints the braces literally. The compiler does not warn.
• A ternary without parentheses inside the braces: the colon is read as a format separator.
• Formatting machine-readable output with the current culture. Decimal commas break CSV, JSON and SQL. Use the invariant culture.
• Using ToString() without a format for money. 2.5m prints as 2.5, not 2.50. Use F2, N2 or C.
• Building large strings with interpolation in a loop. Each iteration creates a new string; use StringBuilder or string.Join.