Dela via

Stränginterpolation med hjälp av $

  • Artikel

Tecknet $ identifierar en strängliteral som en interpolerad sträng. En interpolerad sträng är en strängliteral som kan innehålla interpolationsuttryck. När en interpolerad sträng matchas till en resultatsträng ersätter kompilatorn objekt med interpoleringsuttryck med strängrepresentationerna av uttrycksresultatet.

Stränginterpolation ger en mer läsbar, bekväm syntax för att formatera strängar. Det är lättare att läsa än sammansatt strängformatering. I följande exempel används båda funktionerna för att skapa samma utdata:

var name = "Mark";
var date = DateTime.Now;

// Composite formatting:
Console.WriteLine("Hello, {0}! Today is {1}, it's {2:HH:mm} now.", name, date.DayOfWeek, date);
// String interpolation:
Console.WriteLine($"Hello, {name}! Today is {date.DayOfWeek}, it's {date:HH:mm} now.");
// Both calls produce the same output that is similar to:
// Hello, Mark! Today is Wednesday, it's 19:40 now.

Från och med C# 10 kan du använda en interpolerad sträng för att initiera en konstant sträng. Du kan bara göra det om alla interpolationsuttryck i den interpolerade strängen också är konstanta strängar.

Struktur för en interpolerad sträng

Om du vill identifiera en strängliteral som en interpolerad sträng förbereder du den med symbolen $ . Du kan inte ha något tomt utrymme mellan $ och " som startar en strängliteral.

Strukturen för ett objekt med ett interpolationsuttryck är följande:

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

Element inom hakparenteser är valfria. I följande tabell beskrivs varje element:

Element Description
interpolationExpression Uttrycket som skapar ett resultat som ska formateras. När uttrycket är nullär utdata den tomma strängen (String.Empty).
alignment Det konstanta uttrycket vars värde definierar det minsta antalet tecken i strängrepresentationen av uttrycksresultatet. Om det är positivt är strängrepresentationen högerjusterad. om den är negativ, vänsterjusterad. Mer information finns i avsnittet Justeringskomponent i artikeln Sammansatt formatering .
formatString En formatsträng som stöds av typen av uttrycksresultat. Mer information finns i avsnittet Formatera strängkomponent i artikeln Sammansatt formatering .

I följande exempel används valfria formateringskomponenter som beskrivs i föregående tabell:

Console.WriteLine($"|{"Left",-7}|{"Right",7}|");

const int FieldWidthRightAligned = 20;
Console.WriteLine($"{Math.PI,FieldWidthRightAligned} - default formatting of the pi number");
Console.WriteLine($"{Math.PI,FieldWidthRightAligned:F3} - display only three decimal digits of the pi number");
// Output is:
// |Left   |  Right|
//     3.14159265358979 - default formatting of the pi number
//                3.142 - display only three decimal digits of the pi number

Från och med C# 11 kan du använda nya rader i ett interpolationsuttryck för att göra uttryckets kod mer läsbar. I följande exempel visas hur nya rader kan förbättra läsbarheten för ett uttryck som omfattar mönstermatchning:

string message = $"The usage policy for {safetyScore} is {
    safetyScore switch
    {
        > 90 => "Unlimited usage",
        > 80 => "General usage, with daily safety check",
        > 70 => "Issues must be addressed within 1 week",
        > 50 => "Issues must be addressed within 1 day",
        _ => "Issues must be addressed before continued use",
    }
    }";

Interpolerade råsträngliteraler

Från och med C# 11 kan du använda en interpolerad råsträngliteral, som följande exempel visar:

int X = 2;
int Y = 3;

var pointMessage = $"""The point "{X}, {Y}" is {Math.Sqrt(X * X + Y * Y):F3} from the origin""";

Console.WriteLine(pointMessage);
// Output is:
// The point "2, 3" is 3.606 from the origin

Om du vill bädda in { och } tecken i resultatsträngen startar du en interpolerad råsträngliteral med flera $ tecken. När du gör det bäddas alla sekvenser eller { } tecken som är kortare än antalet $ tecken in i resultatsträngen. Om du vill omsluta ett interpoleringsuttryck i strängen måste du använda samma antal klammerparenteser som antalet $ tecken, som följande exempel visar:

int X = 2;
int Y = 3;

var pointMessage = $$"""{The point {{{X}}, {{Y}}} is {{Math.Sqrt(X * X + Y * Y):F3}} from the origin}""";
Console.WriteLine(pointMessage);
// Output is:
// {The point {2, 3} is 3.606 from the origin}

I föregående exempel börjar en interpolerad råsträngliteral med två $ tecken. Du måste placera varje interpoleringsuttryck mellan dubbla klammerparenteser ({{ och }}). En enda klammerparentes bäddas in i en resultatsträng. Om du behöver bädda in upprepade { tecken eller } tecken i en resultatsträng använder du ett lämpligt större antal $ tecken för att ange en interpolerad råsträngliteral. Om strängliteralen har fler upprepade klammerparenteser än antalet $ tecken { grupperas tecknen och } inifrån och ut. I föregående exempel tolkar {{X}} literalen The point {{{X}}, {{Y}}} och {{Y}} som interpolerade uttryck. Det yttre { och } ingår ordagrant i utdatasträngen.

Specialtecken

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

Eftersom kolonet (":") har en särskild betydelse i ett interpolationsuttrycksobjekt ska du använda en villkorsoperator i ett interpolationsuttryck. Omslut uttrycket i parenteser.

I följande exempel visas hur du inkluderar en klammerparentes i en resultatsträng. Den visar också hur du använder en villkorsstyrd operator:

string name = "Horace";
int age = 34;
Console.WriteLine($"He asked, \"Is your name {name}?\", but didn't wait for a reply :-{{");
Console.WriteLine($"{name} is {age} year{(age == 1 ? "" : "s")} old.");
// Output is:
// He asked, "Is your name Horace?", but didn't wait for a reply :-{
// Horace is 34 years old.

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 ordagranna strängar. Mer information om ordagranna strängar finns i artiklarna om sträng- och ordagranna identifierare.

Kulturspecifik formatering

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

Om du vill matcha en interpolerad sträng till en kulturspecifik resultatsträng använder du String.Create(IFormatProvider, DefaultInterpolatedStringHandler) metoden, som är tillgänglig från och med .NET 6. I följande exempel visas hur du gör det:

double speedOfLight = 299792.458;

System.Globalization.CultureInfo.CurrentCulture = System.Globalization.CultureInfo.GetCultureInfo("nl-NL");
string messageInCurrentCulture = $"The speed of light is {speedOfLight:N3} km/s.";

var specificCulture = System.Globalization.CultureInfo.GetCultureInfo("en-IN");
string messageInSpecificCulture = string.Create(
    specificCulture, $"The speed of light is {speedOfLight:N3} km/s.");

string messageInInvariantCulture = string.Create(
    System.Globalization.CultureInfo.InvariantCulture, $"The speed of light is {speedOfLight:N3} km/s.");

Console.WriteLine($"{System.Globalization.CultureInfo.CurrentCulture,-10} {messageInCurrentCulture}");
Console.WriteLine($"{specificCulture,-10} {messageInSpecificCulture}");
Console.WriteLine($"{"Invariant",-10} {messageInInvariantCulture}");
// Output is:
// nl-NL      The speed of light is 299.792,458 km/s.
// en-IN      The speed of light is 2,99,792.458 km/s.
// Invariant  The speed of light is 299,792.458 km/s.

I .NET 5 och tidigare versioner av .NET använder du implicit konvertering av en interpolerad sträng till en FormattableString instans. Sedan kan du använda en instansmetod FormattableString.ToString(IFormatProvider) eller en statisk FormattableString.Invariant metod för att skapa en kulturspecifik resultatsträng. I följande exempel visas hur du gör det:

double speedOfLight = 299792.458;
FormattableString message = $"The speed of light is {speedOfLight:N3} km/s.";

var specificCulture = System.Globalization.CultureInfo.GetCultureInfo("en-IN");
string messageInSpecificCulture = message.ToString(specificCulture);
Console.WriteLine(messageInSpecificCulture);
// Output:
// The speed of light is 2,99,792.458 km/s.

string messageInInvariantCulture = FormattableString.Invariant(message);
Console.WriteLine(messageInInvariantCulture);
// Output is:
// The speed of light is 299,792.458 km/s.

Mer information om anpassad formatering finns i avsnittet Anpassad formatering med ICustomFormatter i formateringstyperna i .NET-artikeln .

Andra resurser

Om du inte har använt stränginterpolation tidigare kan du läsa den interaktiva självstudien Stränginterpolation i C# . Du kan också kontrollera en annan stränginterpolation i C#- självstudien. Den här självstudien visar hur du använder interpolerade strängar för att skapa formaterade strängar.

Kompilering av interpolerade strängar

Från och med C# 10 och .NET 6 kontrollerar kompilatorn om en interpolerad sträng tilldelas till en typ som uppfyller det interpolerade stränghanterarmönstret. En interpolerad stränghanterare är en typ som konverterar den interpolerade strängen till en resultatsträng. När en interpolerad sträng har typen stringbearbetas den System.Runtime.CompilerServices.DefaultInterpolatedStringHandlerav . Exempel på en anpassad interpolerad stränghanterare finns i självstudien Skriv en anpassad stränginterpoleringshanterare . Användning av en interpolerad stränghanterare är ett avancerat scenario som vanligtvis krävs av prestandaskäl.

Kommentar

En bieffekt av interpolerade stränghanterare är att en anpassad hanterare, inklusive System.Runtime.CompilerServices.DefaultInterpolatedStringHandler, kanske inte utvärderar alla interpolationsuttryck i den interpolerade strängen under alla förhållanden. Det innebär att biverkningar av dessa uttryck kanske inte inträffar.

Om en interpolerad sträng har typen stringföre C# 10 omvandlas den vanligtvis till ett String.Format metodanrop. Kompilatorn kan ersätta String.Format med String.Concat om det analyserade beteendet skulle motsvara sammanlänkning.

Om en interpolerad sträng har typen IFormattable eller FormattableStringgenererar kompilatorn ett anrop till FormattableStringFactory.Create metoden.

Språkspecifikation för C#

Mer information finns i avsnittet Interpolerade stränguttryck i C#-språkspecifikationen och följande nya funktionsspecifikationer:

Se även