Interpolation de chaîne en C#

2025-05-05

Ce tutoriel vous montre comment utiliser l’interpolation de chaîne pour mettre en forme et inclure des résultats d’expression dans une chaîne de résultat. Les exemples supposent que vous connaissez les concepts C# de base et la mise en forme de type .NET. Pour plus d’informations sur la mise en forme des types dans .NET, consultez Types de mise en forme dans .NET.

Présentation

Pour identifier un littéral de chaîne comme chaîne interpolée, préfixez-la du symbole $. Vous pouvez incorporer n’importe quelle expression C# valide qui retourne une valeur dans une chaîne interpolée. Dans l’exemple suivant, dès qu’une expression est évaluée, son résultat est converti en chaîne et inclus dans une chaîne de résultat :

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);
// Output:
// 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

Comme l’illustre l’exemple, vous incluez une expression dans une chaîne interpolée en l'entourant d'accolades :

{<interpolationExpression>}

Les chaînes interpolées prennent en charge toutes les fonctionnalités de la fonctionnalité de mise en forme composite de chaîne . Elles constituent ainsi une alternative plus lisible à l’utilisation de la méthode String.Format. Chaque chaîne interpolée doit avoir :

Littéral de chaîne qui commence par le caractère $ avant son guillemet ouvrant. Il ne peut y avoir aucun espace entre le $ symbole et le guillemet.
Une ou plusieurs expressions d’interpolation. Vous indiquez une expression d’interpolation avec une accolade ouvrante et fermante ({ et }). Vous pouvez placer n’importe quelle expression C# qui retourne une valeur (y compris null) à l’intérieur des accolades.

C# évalue l’expression entre les caractères { et } avec les règles suivantes :

Si l’expression d’interpolation prend la nullvaleur , une chaîne vide (« » ou String.Empty) est utilisée.
Si l’expression d’interpolation n’évalue pas à null, la méthode du type de résultat ToString est généralement appelée.

Comment spécifier une chaîne de format pour une expression d’interpolation

Pour spécifier une chaîne de format prise en charge par le type du résultat de l’expression, suivez l’expression d’interpolation avec un deux-points (« : ») et une chaîne de format.

{<interpolationExpression>:<formatString>}

L’exemple suivant montre comment spécifier des chaînes de format standard et personnalisées pour les expressions qui produisent des résultats de date et d’heure ou numériques :

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}.");
// Output:
// On Sunday, November 25, 1731 L. Euler introduced the letter e to denote 2.71828.

Pour plus d’informations, consultez la section Format du composant chaîne de l’article de mise en forme composite .

Comment contrôler la largeur du champ et l’alignement de l’expression d’interpolation mise en forme

Pour spécifier la largeur minimale du champ et l’alignement du résultat de l’expression mise en forme, suivez l’expression d’interpolation avec une virgule (« , ») et l’expression constante :

{<interpolationExpression>,<width>}

L’exemple de code suivant utilise la largeur minimale du champ pour créer une sortie tabulaire :

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

Si la valeur de largeur est positive, le résultat de l’expression mise en forme est aligné à droite ; s’il est négatif, il est aligné à gauche. Supprimez les - signes avant le spécificateur de largeur et réexécutez l’exemple pour afficher les résultats.

Si vous devez spécifier à la fois la largeur et une chaîne de format, commencez par le composant largeur :

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

L’exemple suivant montre comment spécifier la largeur et l’alignement, et utilise des caractères de canal (« | ») pour délimiter les champs de texte :

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}|");
// Output:
// Three classical Pythagorean means of 3 and 4:
// |Arithmetic|  3.500|
// |Geometric|  3.464|
// |Harmonic |  3.429|

Comme l’illustre l’exemple de sortie, si la longueur du résultat de l’expression mise en forme dépasse la largeur de champ spécifiée, la valeur de largeur est ignorée.

Pour plus d’informations, consultez la section Composant Width de l’article de mise en forme composite .

Comment utiliser des séquences d’échappement dans une chaîne interpolée

Les chaînes interpolées prennent en charge toutes les séquences d’échappement qui peuvent être utilisés dans les littéraux de chaîne ordinaires. Pour plus d’informations, consultez séquences d’échappement de chaîne.

Pour interpréter les séquences d’échappement littéralement, utilisez un littéral de chaîne textuelle. Une chaîne verbatim interpolée commence à la fois par les caractères $ et @. Vous pouvez utiliser $ et @ dans n’importe quel ordre : les deux $@"..." et @$"..." sont des chaînes détaillées interpolées valides.

Pour inclure une accolade, « { » ou « } », dans une chaîne de résultat, utilisez deux accolades, « {{ » ou « }} ». Pour plus d’informations, consultez la section Accolades d’échappement de l’article de mise en forme composite .

L’exemple suivant montre comment inclure des accolades dans une chaîne de résultat et construire une chaîne interpolée détaillée :

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

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

À compter de C# 11, vous pouvez utiliser des littéraux de chaîne brute interpolés.

Comment utiliser un opérateur `?:` conditionnel ternaire dans une expression d’interpolation

Comme le signe deux-points (« : ») a une signification particulière dans un élément avec une expression d’interpolation, afin d’utiliser un opérateur conditionnel dans une expression, placez-le entre parenthèses, comme l’illustre l’exemple suivant :

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

Comment créer une chaîne de résultat spécifique à une culture avec une interpolation de chaîne

Par défaut, une chaîne interpolée utilise la culture actuelle définie par la CultureInfo.CurrentCulture propriété pour toutes les opérations de mise en forme.

À compter de .NET 6, vous pouvez utiliser la String.Create(IFormatProvider, DefaultInterpolatedStringHandler) méthode pour résoudre une chaîne interpolée en chaîne de résultat spécifique à la culture, comme l’illustre l’exemple suivant :

var cultures = new System.Globalization.CultureInfo[]
{
    System.Globalization.CultureInfo.GetCultureInfo("en-US"),
    System.Globalization.CultureInfo.GetCultureInfo("en-GB"),
    System.Globalization.CultureInfo.GetCultureInfo("nl-NL"),
    System.Globalization.CultureInfo.InvariantCulture
};
var date = DateTime.Now;
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       8/27/2023 12:35:31 PM      31,415,926.536
// en-GB         27/08/2023 12:35:31      31,415,926.536
// nl-NL         27-08-2023 12:35:31      31.415.926,536
//               08/27/2023 12:35:31      31,415,926.536

Dans les versions antérieures de .NET, utilisez la conversion implicite d’une chaîne interpolée vers une System.FormattableString instance et appelez sa ToString(IFormatProvider) méthode pour créer une chaîne de résultat spécifique à la culture. L’exemple suivant montre comment effectuer cette opération :

var cultures = new System.Globalization.CultureInfo[]
{
    System.Globalization.CultureInfo.GetCultureInfo("en-US"),
    System.Globalization.CultureInfo.GetCultureInfo("en-GB"),
    System.Globalization.CultureInfo.GetCultureInfo("nl-NL"),
    System.Globalization.CultureInfo.InvariantCulture
};
var date = DateTime.Now;
var number = 31_415_926.536;
FormattableString message = $"{date,23}{number,20:N3}";
foreach (var culture in cultures)
{
    var cultureSpecificMessage = message.ToString(culture);
    Console.WriteLine($"{culture.Name,-10}{cultureSpecificMessage}");
}
// Output is similar to:
// en-US       8/27/2023 12:35:31 PM      31,415,926.536
// en-GB         27/08/2023 12:35:31      31,415,926.536
// nl-NL         27-08-2023 12:35:31      31.415.926,536
//               08/27/2023 12:35:31      31,415,926.536

Comme l’illustre l’exemple, vous pouvez utiliser une FormattableString instance pour générer plusieurs chaînes de résultats pour différentes cultures.

Comment créer une chaîne de résultat à l’aide de la culture invariante

À compter de .NET 6, utilisez la String.Create(IFormatProvider, DefaultInterpolatedStringHandler) méthode pour résoudre une chaîne interpolée en chaîne de résultat pour l’exemple InvariantCulturesuivant :

string message = string.Create(CultureInfo.InvariantCulture, $"Date and time in invariant culture: {DateTime.Now}");
Console.WriteLine(message);
// Output is similar to:
// Date and time in invariant culture: 05/17/2018 15:46:24

Dans les versions antérieures de .NET, ainsi que la FormattableString.ToString(IFormatProvider) méthode, vous pouvez utiliser la méthode statique FormattableString.Invariant , comme l’illustre l’exemple suivant :

string message = FormattableString.Invariant($"Date and time in invariant culture: {DateTime.Now}");
Console.WriteLine(message);
// Output is similar to:
// Date and time in invariant culture: 05/17/2018 15:46:24

Conclusion

Ce tutoriel décrit les scénarios courants d’utilisation de l’interpolation de chaîne. Pour plus d’informations sur l’interpolation de chaîne, consultez Interpolation de chaîne. Pour plus d’informations sur les types de mise en forme dans .NET, consultez les articles Types de mise en forme dans .NET et Mise en forme composite.

Partager via