Stränginterpolation i C#

Tips/Råd

Den här artikeln är en del av avsnittet Grunderna för utvecklare som redan känner till minst ett programmeringsspråk och lär sig C#. Om du inte har använt programmering tidigare börjar du med självstudierna Komma igång först.

Kommer du från ett annat språk? Stränginterpolering i C# fungerar ungefär som mallliteraler i JavaScript (`${x}`) eller f-strängar i Python (f"{x}"). Uttrycket inuti {} kan vara valfritt giltigt C#-uttryck och du kan lägga till format- och justeringsspecificerare utan att lämna strängen.

Med stränginterpolation kan du bädda in uttryck direkt i en strängliteral genom att prefixera literalen med $:

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

Varje { } är ett interpolationsuttryck. C# utvärderar uttrycket, konverterar resultatet till en sträng genom att anropa dess ToString() metod och ersätter texten i resultatet. Stränginterpolationen för ett null uttryck är den tomma strängen. I de flesta fall ger standardkonverteringen de utdata du vill ha och du behöver inte göra något mer.

Interpolerade strängar är ett mer läsbart alternativ till String.Format, och de stöder den fullständiga funktionsuppsättningen för sammansatt formatering . Allt du kan göra med en klassisk positionsformatsträng – formatspecificerare, justering, kulturmedveten formatering och konstanta strängar – kan du också göra med en interpolerad sträng. Resten av den här artikeln beskriver dessa alternativ. Sträck dig bara efter dem när du behöver finare kontroll över resultatet. annars räcker det med den enkla $"{expression}" formen.

För språkreferensbehandling av syntaxen och de underliggande hanterartyperna, se interpolerad strängreferens . Mer information om prestandafokuserade ämnen som Span<char> interpolering och anpassade interpolerade stränghanterare finns i Strängåtgärder.

Använda en formatsträng

Om du vill styra hur ett uttrycksresultat formateras följer du uttrycket med ett kolon och en standard- eller anpassad formatsträng:

{<expression>:<formatString>}

I följande exempel formateras ett DateTime och ett Double värde:

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.

Ange fältbredd och justering

Om du vill skapa justerade utdata följer du uttrycket med ett kommatecken och en minsta fältbredd. Positiva bredder högerjusterar värdet och negativa bredder vänsterjusterar det:

{<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|

När du behöver både justering och en formatsträng placerar du justeringen först:

{<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|

Om det formaterade värdet är längre än den begärda bredden ignorerar C# bredden och genererar det fullständiga värdet.

Escape klamrar och använd escape-sekvenser

Interpolerade strängar stöder samma escape-sekvenser som vanliga strängliteraler. Om du vill inkludera själva tecknet { eller } i resultatet, dubblerar du det ({{ eller }}).

För sökvägar och andra strängar som innehåller bakstreck bör du föredra en interpolerad rå strängliteral ($"""...""") framför den äldre ordagranna formen ($@"..."). Råsträngslitteraler bearbetar inte escape-sekvenser, så omvända snedstreck visas som de är:

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

Använda ett villkorsuttryck

Kolonet har en särskild innebörd inuti ett interpolationsuttryck, så omge ett villkorsuttryck med parenteser:

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

Låt ett uttryck sträcka sig över flera rader

För bättre läsbarhet kan du bryta långa interpolationsuttryck över flera rader. Flerradsinterpoleringsuttryck är tillgängliga sedan C# 11. I följande exempel läggs nya raderna mellan { tecknen och } till för att avgränsa de interpolerade uttrycken från den literala texten:

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

Skapa konstanta strängar

Du kan skapa konstanta interpolerade strängar när varje interpolerat uttryck är ett konstant värde. Det gör det användbart för attributargument, switch mönster och andra kontexter som kräver kompileringskonstanter:

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

Formatera med en specifik kultur

Som standard formaterar en interpolerad sträng värden med , CultureInfo.CurrentCulturevilket påverkar datum-, tal- och valutarepresentationer. För deterministiska utdata skickar du en explicit kultur till 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

För invarianta utdata (loggar, filformat, maskinläsbara data) skickar du 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

Se även

  • Last updated on