Interpolation de chaînes et String.Format en C# : spécificateurs de format, alignement, culture

L'interpolation de chaînes construit une chaîne à partir de texte littéral et d'expressions. Préfixez le littéral par $, placez n'importe quelle expression C# entre accolades, et sa valeur est convertie en texte puis insérée :

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

Sortie :

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

L'interpolation est arrivée avec C# 6. Le compilateur la transforme en appel à string.Format ou string.Concat (ou, depuis C# 10, en code de handler plus efficace), elle n'est donc pas plus lente que la construction manuelle de la chaîne.

L'expression conditionnelle de la dernière ligne a besoin de parenthèses. Dans un emplacement d'interpolation, les deux-points commencent un spécificateur de format, donc {x > 10 ? "yes" : "no"} sans parenthèses est une erreur de compilation.

Spécificateurs de format

Après l'expression, deux-points suivis d'une chaîne de format déterminent la façon dont la valeur est écrite. Les mêmes chaînes de format fonctionnent avec ToString("...") et 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
    }
}

Sortie :

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

Les codes standard, chacun éventuellement suivi d'un nombre de précision :

Les modèles personnalisés construisent un format à partir d'espaces réservés : 0 est un chiffre toujours affiché, # un chiffre affiché seulement s'il est significatif, . le séparateur décimal, , dans le nombre active les séparateurs de groupes, et % multiplie par 100. "0.##" affiche jusqu'à deux décimales et supprime les zéros de fin ; "#,##0.00" est le format comptable classique.

Tout formatage numérique arrondit la valeur affichée ; la variable elle-même reste inchangée. Quand une valeur tombe exactement à mi-chemin (2,25 affiché avec une décimale), les runtimes et les types peuvent arrondir l'égalité différemment ; si la règle compte, arrondissez d'abord explicitement avec Math.Round(value, 1, MidpointRounding.AwayFromZero), puis formatez.

Les dates dans l'interpolation

Les valeurs DateTime acceptent de la même façon des chaînes de format de 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");
    }
}

Sortie :

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

Un format personnalisé de TimeSpan exige que les caractères littéraux soient échappés par une barre oblique inverse, ce qui s'écrit \\: dans un littéral de chaîne ordinaire. La liste complète des codes de date (yyyy, MM, HH, tt...) et les erreurs qu'on commet avec eux (mm désigne les minutes, MM les mois) se trouvent sur format DateTime.

Alignement et remplissage

Une virgule après l'expression définit une largeur minimale de champ. Un nombre positif aligne à droite, un nombre négatif à gauche. Combiné à un format, cela aligne des tableaux en texte brut :

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

Sortie :

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

La syntaxe est {expression,alignment:format} : l'alignement d'abord, puis le format. Une valeur plus longue que la largeur n'est pas tronquée ; elle décale le reste de la ligne. PadLeft et PadRight font le même remplissage hors interpolation.

Échapper les accolades

Pour afficher une accolade littérale, doublez-la : {{ et }}. Cela arrive quand la sortie est du JSON, du CSS ou du 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
    }
}

Sortie :

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

Construire du JSON à la main de cette façon convient pour une ligne de log rapide ; pour du vrai JSON, utilisez un sérialiseur, qui gère correctement les guillemets et les caractères spéciaux dans name.

string.Format et le formatage composite

Avant C# 6, on formatait avec string.Format, qui prend des espaces réservés numérotés et une liste d'arguments. La même syntaxe de format composite est acceptée par Console.WriteLine, StringBuilder.AppendFormat et 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));
    }
}

Sortie :

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

Préférez l'interpolation dans le code : les valeurs se trouvent là où elles apparaissent, donc un espace réservé ne peut pas pointer vers le mauvais argument. string.Format reste le bon outil quand le modèle est une donnée, comme un message traduit chargé depuis un fichier de ressources. Un index d'espace réservé sans argument correspondant ({2} avec deux arguments) lève une FormatException à l'exécution.

La culture : contrôler les séparateurs et la devise

L'interpolation, ToString et string.Format utilisent tous par défaut la culture courante du thread. Sur une machine réglée en allemand, {1234.5:N2} produit 1.234,50 ; aux États-Unis, 1,234.50. Le format monétaire C utilise le symbole de la culture. Pour choisir la culture explicitement, capturez la chaîne interpolée comme un FormattableString et formatez-la avec un fournisseur :

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

Sortie :

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

Utilisez la culture de l'utilisateur pour le texte que lisent les personnes, et CultureInfo.InvariantCulture pour tout ce qu'un autre programme lit. Un CSV écrit avec la culture courante sur une machine allemande contient des virgules dans les nombres et devient illisible ailleurs. Depuis .NET 6, string.Create(CultureInfo.InvariantCulture, $"...") fait la même chose que FormattableString.Invariant sans l'objet intermédiaire.

Chaînes interpolées verbatim et brutes

$ se combine avec @ pour une chaîne interpolée verbatim : les barres obliques inverses sont littérales et la chaîne peut s'étendre sur plusieurs lignes. C# 8 et plus acceptent les deux ordres ($@ ou @$) ; C# 6 et 7 exigent $@ :

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

Sortie :

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

C# 11 a ajouté les chaînes interpolées brutes. Avec un seul $, les accolades marquent les expressions comme d'habitude. Avec $$, une accolade simple est littérale et les expressions demandent deux accolades, ce qui rend lisibles les modèles JSON et de code :

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

C# 11 autorise aussi les sauts de ligne dans un emplacement d'interpolation, si bien qu'une longue expression ou une expression switch peut être répartie sur plusieurs lignes.

Erreurs courantes

• Oublier le $. "Total: {total}" affiche les accolades telles quelles. Le compilateur ne prévient pas.
• Un ternaire sans parenthèses entre les accolades : les deux-points sont lus comme un séparateur de format.
• Formater une sortie lue par des machines avec la culture courante. Les virgules décimales cassent le CSV, le JSON et le SQL. Utilisez la culture invariante.
• Utiliser ToString() sans format pour de l'argent. 2.5m s'affiche 2.5, pas 2.50. Utilisez F2, N2 ou C.
• Construire de grandes chaînes avec l'interpolation dans une boucle. Chaque itération crée une nouvelle chaîne ; utilisez StringBuilder ou string.Join.