Dela via

Stränginterpolation i C#

  • Artikel

Den här självstudien visar hur du använder stränginterpolation för att formatera och inkludera uttryck resulterar i en resultatsträng. Exemplen förutsätter att du är bekant med grundläggande C#-begrepp och formatering av .NET-typ. Om du är nybörjare på stränginterpolation eller formatering av .NET-typ kan du först läsa självstudiekursen för interaktiv stränginterpolation. Mer information om formateringstyper i .NET finns i Formateringstyper i .NET.

Introduktion

Om du vill identifiera en strängliteral som en interpolerad sträng förbereder du den med symbolen $ . Du kan bädda in valfritt giltigt C#-uttryck som returnerar ett värde i en interpolerad sträng. I följande exempel konverteras resultatet så snart ett uttryck utvärderas till en sträng och ingår i en resultatsträng:

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

Som exemplet visar inkluderar du ett uttryck i en interpolerad sträng genom att omsluta det med klammerparenteser:

{<interpolationExpression>}

Interpolerade strängar stöder alla funktioner i funktionen för sammansatt strängformatering . Det gör dem till ett mer läsbart alternativ till metodens användning String.Format .

Så här anger du en formatsträng för ett interpolationsuttryck

Om du vill ange en formatsträng som stöds av typen av uttrycksresultat följer du interpolationsuttrycket med ett kolon (":") och formatsträngen:

{<interpolationExpression>:<formatString>}

I följande exempel visas hur du anger standard- och anpassade formatsträngar för uttryck som ger datum och tid eller numeriska resultat:

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.

Mer information finns i avsnittet Formatera strängkomponent i artikeln Sammansatt formatering .

Så här styr du fältbredden och justeringen för det formaterade interpoleringsuttrycket

Om du vill ange den minsta fältbredden och justeringen för det formaterade uttrycksresultatet följer du interpoleringsuttrycket med kommatecken (",") och det konstanta uttrycket:

{<interpolationExpression>,<alignment>}

Om justeringsvärdet är positivt är det formaterade uttrycksresultatet högerjusterat. Om det är negativt är det vänsterjusterat.

Om du behöver ange både justering och en formatsträng börjar du med justeringskomponenten:

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

I följande exempel visas hur du anger justering och använder pipe-tecken ("|") för att avgränsa textfält:

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|

Som exemplet visar ignoreras justeringsvärdet om längden på det formaterade uttrycksresultatet överskrider angiven fältbredd.

Mer information finns i avsnittet Justeringskomponent i artikeln Sammansatt formatering .

Använda escape-sekvenser i en interpolerad sträng

Interpolerade strängar stöder alla escape-sekvenser som kan användas i vanliga strängliteraler. Mer information finns i Strängrymningssekvenser.

Om du vill tolka escape-sekvenser bokstavligen använder du en ordagrann strängliteral. En interpolerad ordagrann sträng börjar med både $ och @ tecken. Du kan använda $ och @ i valfri ordning: både $@"..." och @$"..." är giltiga interpolerade ordagranna strängar.

Om du vill inkludera en klammerparentes, "{" eller "}", i en resultatsträng använder du två klammerparenteser, "{{" eller "}}". Mer information finns i avsnittet Escapeing braces (Undantagna klammerparenteser ) i artikeln Sammansatt formatering .

I följande exempel visas hur du inkluderar klammerparenteser i en resultatsträng och konstruerar en ordagrann interpolerad sträng:

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

Från och med C# 11 kan du använda interpolerade råsträngliteraler.

Så här använder du en villkorsoperator ?: för ternary i ett interpoleringsuttryck

Eftersom kolonet (":") har en särskild betydelse i ett objekt med ett interpolationsuttryck, om du vill använda en villkorsoperator i ett uttryck, omsluter det i parenteser, som följande exempel visar:

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

Skapa en kulturspecifik resultatsträng med stränginterpolation

Som standard använder en interpolerad sträng den aktuella kultur som definieras av CultureInfo.CurrentCulture egenskapen för alla formateringsåtgärder.

Från och med .NET 6 kan du använda String.Create(IFormatProvider, DefaultInterpolatedStringHandler) metoden för att matcha en interpolerad sträng till en kulturspecifik resultatsträng, som följande exempel visar:

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

I tidigare versioner av .NET använder du implicit konvertering av en interpolerad sträng till en System.FormattableString instans och anropar dess ToString(IFormatProvider) metod för att skapa en kulturspecifik resultatsträng. I följande exempel visas hur du gör det:

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

Som exemplet visar kan du använda en FormattableString instans för att generera flera resultatsträngar för olika kulturer.

Skapa en resultatsträng med hjälp av den invarianta kulturen

Från och med .NET 6 använder du String.Create(IFormatProvider, DefaultInterpolatedStringHandler) metoden för att matcha en interpolerad sträng med en resultatsträng för InvariantCulture, som följande exempel visar:

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

I tidigare versioner av .NET, tillsammans med FormattableString.ToString(IFormatProvider) metoden, kan du använda den statiska FormattableString.Invariant metoden, som följande exempel visar:

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

Slutsats

I den här självstudien beskrivs vanliga scenarier för användning av stränginterpolering. Mer information om stränginterpolation finns i Stränginterpolation. Mer information om formateringstyper i .NET finns i formateringstyperna i artiklarna .NET och Sammansatt formatering .

Se även