Interpolazione di stringhe e String.Format in C#: formati, allineamento, cultura

L'interpolazione di stringhe costruisce una stringa a partire da testo letterale ed espressioni. Metti $ davanti al letterale, scrivi una qualsiasi espressione C# tra graffe, e il suo valore viene convertito in testo e inserito:

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

L'interpolazione è arrivata in C# 6. Il compilatore la trasforma in una chiamata a string.Format o string.Concat (oppure, da C# 10, in codice handler più efficiente), quindi non è più lenta che costruire la stringa a mano.

L'espressione condizionale nell'ultima riga ha bisogno delle parentesi. Dentro uno spazio di interpolazione, i due punti iniziano uno specificatore di formato, quindi {x > 10 ? "yes" : "no"} senza parentesi è un errore di compilazione.

Specificatori di formato

Dopo l'espressione, i due punti e una stringa di formato controllano come viene scritto il valore. Le stesse stringhe di formato funzionano con ToString("...") e 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

I codici standard, ognuno seguito facoltativamente da un numero di precisione:

I formati personalizzati costruiscono un formato a partire da segnaposto: 0 è una cifra sempre mostrata, # è una cifra mostrata solo se significativa, . è il separatore decimale, , dentro il numero attiva i separatori delle migliaia, e % moltiplica per 100. "0.##" mostra fino a due decimali ed elimina gli zeri finali; "#,##0.00" è il classico formato contabile.

Tutta la formattazione numerica arrotonda il valore mostrato; la variabile in sé resta invariata. Quando un valore sta esattamente a metà (2.25 mostrato con un decimale), runtime e tipi diversi possono arrotondare il pareggio in modo diverso, quindi se la regola conta arrotonda prima in modo esplicito con Math.Round(value, 1, MidpointRounding.AwayFromZero) e poi formatta.

Date nell'interpolazione

I valori DateTime accettano allo stesso modo le stringhe di formato per le date:

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

Un formato personalizzato di TimeSpan richiede che i caratteri letterali siano preceduti da un backslash, che in un letterale stringa normale si scrive \\:. L'elenco completo dei codici per le date (yyyy, MM, HH, tt...) e gli errori tipici (mm sono i minuti, MM i mesi) si trovano in formato DateTime.

Allineamento e riempimento

Una virgola dopo l'espressione imposta una larghezza minima del campo. Un numero positivo allinea a destra, un numero negativo allinea a sinistra. Insieme a un formato, permette di incolonnare tabelle in testo semplice:

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

La sintassi è {expression,alignment:format}: prima l'allineamento, poi il formato. Un valore più lungo della larghezza non viene troncato; sposta in avanti il resto della riga. PadLeft e PadRight fanno lo stesso riempimento fuori dall'interpolazione.

Escape delle graffe

Per stampare una graffa letterale, raddoppiala: {{ e }}. Capita quando l'output è JSON, CSS o codice:

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}

Costruire JSON a mano in questo modo va bene per una rapida riga di log; per il JSON vero usa un serializzatore, che gestisce correttamente le virgolette e i caratteri speciali dentro name.

string.Format e formattazione composita

Prima di C# 6 la formattazione si faceva con string.Format, che accetta segnaposto numerati e una lista di argomenti. La stessa sintassi di formattazione composita è accettata da Console.WriteLine, StringBuilder.AppendFormat e 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.

Nel codice preferisci l'interpolazione: i valori stanno dove compaiono, quindi un segnaposto non può puntare all'argomento sbagliato. string.Format resta lo strumento giusto quando il modello è un dato, come un messaggio tradotto caricato da un file di risorse. Un indice di segnaposto senza un argomento corrispondente ({2} con due argomenti) lancia una FormatException in esecuzione.

Cultura: controllare separatori e valuta

Interpolazione, ToString e string.Format usano tutti di default la cultura corrente del thread. Su una macchina impostata in tedesco (o in italiano), {1234.5:N2} produce 1.234,50; negli Stati Uniti produce 1,234.50. Il formato valuta C usa il simbolo della cultura. Per scegliere la cultura in modo esplicito, cattura la stringa interpolata come FormattableString e formattala con un 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

Usa la cultura dell'utente per il testo che leggono le persone, e CultureInfo.InvariantCulture per tutto ciò che legge un altro programma. Un CSV scritto con la cultura corrente su una macchina tedesca ha virgole dentro i numeri ed è illeggibile altrove. Su .NET 6 e successivi, string.Create(CultureInfo.InvariantCulture, $"...") fa lo stesso di FormattableString.Invariant senza l'oggetto intermedio.

Stringhe interpolate verbatim e raw

$ si combina con @ per una stringa interpolata verbatim: i backslash sono letterali e la stringa può estendersi su più righe. C# 8 e successivi accettano entrambi gli ordini ($@ o @$); C# 6 e 7 richiedono $@:

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 ha aggiunto le stringhe interpolate raw. Con un solo $, le graffe indicano le espressioni come al solito. Con $$, una graffa singola è letterale e le espressioni richiedono due graffe, il che rende leggibili i modelli JSON e di codice:

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

C# 11 permette anche di andare a capo dentro uno spazio di interpolazione, così un'espressione lunga o un'espressione switch si può dividere su più righe.

Errori comuni

• Dimenticare il $. "Total: {total}" stampa le graffe letteralmente. Il compilatore non avvisa.
• Un operatore ternario senza parentesi dentro le graffe: i due punti vengono letti come separatore del formato.
• Formattare l'output per le macchine con la cultura corrente. Le virgole decimali rompono CSV, JSON e SQL. Usa la cultura invariante.
• Usare ToString() senza formato per gli importi. 2.5m viene stampato come 2.5, non 2.50. Usa F2, N2 o C.
• Costruire stringhe grandi con l'interpolazione in un ciclo. Ogni iterazione crea una nuova stringa; usa StringBuilder o string.Join.