Interpolation de chaîne en C#

Conseil / Astuce

Cet article fait partie de la section Notions de base pour les développeurs qui connaissent déjà au moins un langage de programmation et apprennent C#. Si vous débutez avec la programmation, commencez par commencer par les didacticiels De prise en main .

Venant d’une autre langue ? L’interpolation de chaîne en C# fonctionne beaucoup comme les littéraux de modèle en JavaScript (`${x}`) ou les chaînes f dans Python (f"{x}"). L’expression à l’intérieur {} peut être n’importe quelle expression C# valide, et vous pouvez ajouter des spécificateurs de format et d’alignement sans quitter la chaîne.

L’interpolation de chaîne vous permet d’incorporer des expressions directement dans un littéral de chaîne en préfixant le littéral avec $:

double a = 3;
double b = 4;
Console.WriteLine($"Area of the right triangle with legs of {a} and {b} is {0.5 * a * b}");
Console.WriteLine($"Length of the hypotenuse of the right triangle with legs of {a} and {b} is {CalculateHypotenuse(a, b)}");
double CalculateHypotenuse(double leg1, double leg2) => Math.Sqrt(leg1 * leg1 + leg2 * leg2);
// => Area of the right triangle with legs of 3 and 4 is 6
// => Length of the hypotenuse of the right triangle with legs of 3 and 4 is 5

Chaque { } est une expression d’interpolation. C# évalue l’expression, convertit le résultat en chaîne en appelant sa ToString() méthode et remplace le texte dans le résultat. L’interpolation de chaînes pour une expression null est la chaîne vide. Dans la plupart des cas, la conversion par défaut produit la sortie souhaitée et vous n’avez pas besoin de faire plus.

Les chaînes interpolées sont une alternative plus lisible à String.Format, et prennent en charge l’ensemble de fonctionnalités de mise en forme composite complète. Tout ce que vous pouvez faire avec une chaîne de format positionnel classique ( spécificateurs de format, alignement, mise en forme prenant en compte la culture et chaînes constantes) vous pouvez également le faire avec une chaîne interpolée. Le reste de cet article couvre ces options. Atteignez-les uniquement lorsque vous avez besoin d’un contrôle plus fin sur le résultat ; sinon, la forme simple $"{expression}" est suffisante.

Pour connaître le traitement de référence du langage de la syntaxe et les types de gestionnaires sous-jacents, consultez la référence de chaîne interpolée . Pour connaître les rubriques axées sur les performances, telles que Span<char> l’interpolation et les gestionnaires de chaînes interpolés personnalisés, consultez les opérations de chaîne.

Appliquer une chaîne de format

Pour contrôler la mise en forme d’un résultat d’expression, suivez l’expression avec un signe deux-points et une chaîne de format standard ou personnalisée :

{<expression>:<formatString>}

L’exemple suivant met en forme une valeur DateTime et une valeur Double :

var date = new DateTime(1731, 11, 25);
Console.WriteLine($"On {date:dddd, MMMM dd, yyyy} L. Euler introduced the letter e to denote {Math.E:F5}.");
// => On Sunday, November 25, 1731 L. Euler introduced the letter e to denote 2.71828.

Définir la largeur et l’alignement du champ

Pour produire une sortie alignée, suivez l’expression avec une virgule et une largeur de champ minimale. Les largeurs positives alignent la valeur à droite et les largeurs négatives l’alignent à gauche :

{<expression>,<width>}

var titles = new Dictionary<string, string>()
{
    ["Doyle, Arthur Conan"] = "Hound of the Baskervilles, The",
    ["London, Jack"] = "Call of the Wild, The",
    ["Shakespeare, William"] = "Tempest, The"
};

Console.WriteLine("Author and Title List");
Console.WriteLine();
Console.WriteLine($"|{"Author",-25}|{"Title",30}|");
foreach (var title in titles)
{
    Console.WriteLine($"|{title.Key,-25}|{title.Value,30}|");
}
// => Author and Title List
// =>
// => |Author                   |                         Title|
// => |Doyle, Arthur Conan      |Hound of the Baskervilles, The|
// => |London, Jack             |         Call of the Wild, The|
// => |Shakespeare, William     |                  Tempest, The|

Quand vous avez besoin à la fois d’un alignement et d’une chaîne de format, placez d’abord l’alignement :

{<expression>,<width>:<formatString>}

const int NameAlignment = -9;
const int ValueAlignment = 7;
double a = 3;
double b = 4;
Console.WriteLine($"Three classical Pythagorean means of {a} and {b}:");
Console.WriteLine($"|{"Arithmetic",NameAlignment}|{0.5 * (a + b),ValueAlignment:F3}|");
Console.WriteLine($"|{"Geometric",NameAlignment}|{Math.Sqrt(a * b),ValueAlignment:F3}|");
Console.WriteLine($"|{"Harmonic",NameAlignment}|{2 / (1 / a + 1 / b),ValueAlignment:F3}|");
// => Three classical Pythagorean means of 3 and 4:
// => |Arithmetic|  3.500|
// => |Geometric|  3.464|
// => |Harmonic |  3.429|

Si la valeur mise en forme est supérieure à la largeur demandée, C# ignore la largeur et émet la valeur complète.

Accolades d’échappement et utilisation de séquences d’échappement

Les chaînes interpolées prennent en charge les mêmes séquences d’échappement que les littéraux de chaîne ordinaires. Pour inclure le caractère littéral { ou } dans le résultat, doublez-le ({{ ou }}).

Pour les chemins d’accès et d’autres chaînes qui contiennent des barres obliques inverses, préférez un littéral de chaîne brut interpolé ($"""...""") sur l’ancien formulaire détaillé ($@"..."). Les chaînes littérales brutes ne traitent pas les séquences d’échappement, donc les barres obliques inversées apparaissent telles quelles :

int[] xs = [1, 2, 7, 9];
int[] ys = [7, 9, 12];
Console.WriteLine($"Find the intersection of the {{{string.Join(", ", xs)}}} and {{{string.Join(", ", ys)}}} sets.");
// => Find the intersection of the {1, 2, 7, 9} and {7, 9, 12} sets.

var userName = "Jane";
var stringWithEscapes = $"C:\\Users\\{userName}\\Documents";
var rawInterpolated = $"""C:\Users\{userName}\Documents""";
Console.WriteLine(stringWithEscapes);
Console.WriteLine(rawInterpolated);
// => C:\Users\Jane\Documents
// => C:\Users\Jane\Documents

Utiliser une expression conditionnelle

Le deux-points a une signification particulière à l’intérieur d’une expression d’interpolation, donc mettez une expression conditionnelle entre parenthèses :

var rand = new Random(42);
for (int i = 0; i < 3; i++)
{
    Console.WriteLine($"Coin flip: {(rand.NextDouble() < 0.5 ? "heads" : "tails")}");
}

Étendre une expression sur plusieurs lignes

Pour une meilleure lisibilité, arrêtez les expressions d’interpolation longues sur plusieurs lignes. Les expressions d’interpolation multiligne sont disponibles depuis C# 11. L’exemple suivant ajoute des sauts de ligne entre les caractères { et } afin de séparer les expressions interpolées du texte littéral :

int[] numbers = [3, 1, 4, 1, 5, 9, 2, 6];
Console.WriteLine($"Total: {
        numbers.Sum()
        }, average: {numbers.Average():F2}.");
// => Total: 31, average: 3.88.

Générer des chaînes de constantes

Vous pouvez générer des chaînes interpolées constantes lorsque chaque expression interpolée est une valeur constante. Cela le rend utilisable pour les arguments d’attribut, switch les modèles et d’autres contextes qui nécessitent des constantes au moment de la compilation :

const string Audience = "world";
const string Greeting = $"Hello, {Audience}!";
Console.WriteLine(Greeting);
// => Hello, world!

Format avec une culture spécifique

Par défaut, une chaîne interpolée formate les valeurs à l’aide de CultureInfo.CurrentCulture, ce qui affecte les représentations des dates, des nombres et des devises. Pour une sortie déterministe, passez une culture explicite à String.Create(IFormatProvider, DefaultInterpolatedStringHandler):

CultureInfo[] cultures =
[
    CultureInfo.GetCultureInfo("en-US"),
    CultureInfo.GetCultureInfo("en-GB"),
    CultureInfo.GetCultureInfo("nl-NL"),
    CultureInfo.InvariantCulture
];
var date = new DateTime(2026, 5, 21, 12, 35, 31);
var number = 31_415_926.536;
foreach (var culture in cultures)
{
    var cultureSpecificMessage = string.Create(culture, $"{date,23}{number,20:N3}");
    Console.WriteLine($"{culture.Name,-10}{cultureSpecificMessage}");
}
// Output is similar to:
// => en-US       5/21/2026 12:35:31 PM      31,415,926.536
// => en-GB         21/05/2026 12:35:31      31,415,926.536
// => nl-NL         21-05-2026 12:35:31      31.415.926,536
// =>               05/21/2026 12:35:31      31,415,926.536

Pour une sortie invariante (journaux, formats de fichiers, données lisibles par machine), passez CultureInfo.InvariantCulture :

var timestamp = new DateTime(2026, 5, 21, 15, 46, 24);
string message = string.Create(CultureInfo.InvariantCulture, $"Date and time in invariant culture: {timestamp}");
Console.WriteLine(message);
// => Date and time in invariant culture: 05/21/2026 15:46:24

Voir aussi

  • Last updated on