Dela via

Stränginterpolation i C#

Den här självstudien visar hur du använder stränginterpolation för att formatera uttrycksresultat och inkludera dem i en resultatsträng. Exemplen förutsätter att du är bekant med grundläggande C#-begrepp och formatering av .NET-typ. Mer information om formateringstyper i .NET finns i Formateringstyper i .NET.

Inledning

Om du vill identifiera en strängliteral som en interpolerad sträng lägger du till symbolen $ framför. 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 . Varje interpolerad sträng måste ha:

  • En strängliteral som börjar med tecknet $ före sina inledande citattecken. Det får inte finnas några blanksteg mellan symbolen $ och citattecknet.
  • Ett eller flera interpolationsuttryck. Du anger ett interpolationsuttryck med en inledande och avslutande klammerparentes ({ och }). Du kan placera valfritt C#-uttryck som returnerar ett värde (inklusive null) i klammerparenteserna.

C# utvärderar uttrycket mellan { tecknen och } med följande regler:

  • Om interpoleringsuttrycket utvärderas till nullanvänds en tom sträng ("" eller String.Empty) .
  • Om interpolationsuttrycket inte utvärderas till nullanropas vanligtvis ToString metoden för resultattypen.

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>,<width>}

Följande kodexempel använder den minsta fältbredden för att skapa tabellutdata:

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 |

Om breddvärdet är positivt är det formaterade uttrycksresultatet rättjusterat. Om den är negativ är den vänsterjusterad. - Ta bort tecknen före breddspecificeraren och kör exemplet igen för att se resultatet.

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

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

I följande exempel visas hur du anger bredd och 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 breddvärdet om längden på det formaterade uttrycksresultatet överskrider angiven fältbredd.

Mer information finns i avsnittet Breddkomponent i artikeln Sammansatt formatering .

Hur man använder 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 verbatimsträng. En interpolerad ordagrann sträng börjar med både tecknen $ och @. Du kan använda $ och @ i valfri ordning: både $@"..." och @$"..." är giltiga interpolerade bokstavliga strängar.

Om du vill inkludera en klammerparentes, "{" eller "}", i en resultatsträng använder du två klammerparenteser, "{{" eller "}}". För mer information, se avsnittet Escaping braces (Flyktiga 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 ternär villkorsoperator ?: 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 handledningen 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