C# String Interpolation ו-String.Format: מפרטי עיצוב, יישור ותרבות

string interpolation בונה מחרוזת מטקסט מילולי ומביטויים. הוסיפו לליטרל את הקידומת $, שימו כל ביטוי C# בסוגריים מסולסלים, והערך שלו יומר לטקסט ויוכנס:

using System;

class Program
{
    static void Main()
    {
        string customer = "Maya";
        int items = 3;
        decimal price = 4.5m;

        Console.WriteLine($"Hello, {customer}!");
        Console.WriteLine($"{items} items at {price} = {items * price}");
        Console.WriteLine($"Name has {customer.Length} letters, upper: {customer.ToUpper()}");
        Console.WriteLine($"Free shipping: {(items * price > 10 ? "yes" : "no")}");
    }
}

פלט:

Hello, Maya!
3 items at 4.5 = 13.5
Name has 4 letters, upper: MAYA
Free shipping: yes

אינטרפולציה הגיעה ב-C# 6. הקומפיילר הופך אותה לקריאה ל-string.Format או ל-string.Concat (או, מאז C# 10, לקוד handler יעיל יותר), כך שהיא לא איטית יותר מבניית המחרוזת ביד.

הביטוי המותנה בשורה האחרונה צריך סוגריים. בתוך חור אינטרפולציה, נקודתיים מתחילים מפרט עיצוב, ולכן {x > 10 ? "yes" : "no"} בלי סוגריים הוא שגיאת קומפילציה.

מפרטי עיצוב

אחרי הביטוי, נקודתיים ומחרוזת עיצוב קובעים איך הערך ייכתב. אותן מחרוזות עיצוב עובדות עם ToString("...") ועם string.Format.

using System;

class Program
{
    static void Main()
    {
        decimal total = 1234567.891m;
        int orderId = 42;
        double ratio = 0.8127;

        Console.WriteLine($"{total:F2}");     // fixed-point, 2 decimals
        Console.WriteLine($"{total:N2}");     // with thousands separators
        Console.WriteLine($"{total:N0}");     // no decimals, rounded
        Console.WriteLine($"{orderId:D5}");   // integer padded to 5 digits
        Console.WriteLine($"{255:X}");        // hexadecimal
        Console.WriteLine($"{255:x4}");       // lowercase hex, 4 digits
        Console.WriteLine($"{total:E2}");     // scientific
        Console.WriteLine($"{ratio:F3}");
        Console.WriteLine($"{ratio:0.0%}");   // custom: percent with 1 decimal
        Console.WriteLine($"{total:#,##0.00}"); // custom pattern
        Console.WriteLine($"{7.5:000.0}");    // leading zeros
        Console.WriteLine($"{3.10m:0.##}");   // drop trailing zeros
    }
}

פלט:

1234567.89
1,234,567.89
1,234,568
00042
FF
00ff
1.23E+006
0.813
81.3%
1,234,567.89
007.5
3.1

הקודים הסטנדרטיים, שאחרי כל אחד מהם אפשר להוסיף מספר דיוק:

תבניות מותאמות בונות עיצוב ממצייני מקום: 0 היא ספרה שתמיד מוצגת, # היא ספרה שמוצגת רק אם היא משמעותית, . היא הנקודה העשרונית, , בתוך המספר מפעיל מפרידי קבוצות, ו-% מכפיל ב-100. "0.##" מציג עד שתי ספרות אחרי הנקודה ומשמיט אפסים בסוף; "#,##0.00" הוא עיצוב הנהלת החשבונות הקלאסי.

כל עיצוב מספרי מעגל את הערך המוצג; המשתנה עצמו לא משתנה. כשערך נמצא בדיוק באמצע (2.25 שמוצג עם ספרה אחת אחרי הנקודה), סביבות ריצה וטיפוסים שונים יכולים לעגל את המקרה הזה אחרת, אז אם הכלל חשוב, עגלו קודם במפורש עם Math.Round(value, 1, MidpointRounding.AwayFromZero) ורק אז עצבו.

תאריכים באינטרפולציה

ערכי DateTime מקבלים מחרוזות עיצוב של תאריכים באותה דרך:

using System;

class Program
{
    static void Main()
    {
        var shipped = new DateTime(2026, 9, 24, 16, 5, 0);

        Console.WriteLine($"{shipped:yyyy-MM-dd}");
        Console.WriteLine($"{shipped:dd/MM/yyyy HH:mm}");
        Console.WriteLine($"{shipped:ddd, MMM d}");
        Console.WriteLine($"Shipped at {shipped:HH:mm} on {shipped:dddd}");

        TimeSpan eta = TimeSpan.FromMinutes(130);
        Console.WriteLine($"ETA {eta:hh\\:mm}");
        Console.WriteLine($"{eta.TotalHours:F1} hours");
    }
}

פלט:

2026-09-24
24/09/2026 16:05
Thu, Sep 24
Shipped at 16:05 on Thursday
ETA 02:10
2.2 hours

עיצוב מותאם של TimeSpan מחייב בריחה של תווים מילוליים עם לוכסן הפוך, שבליטרל מחרוזת רגיל נכתב \\:. הרשימה המלאה של קודי התאריך (yyyy, MM, HH, tt...) והטעויות שאנשים עושים איתם (mm הוא דקות, MM הוא חודשים) נמצאות בדף על עיצוב DateTime.

יישור וריפוד

פסיק אחרי הביטוי קובע רוחב שדה מינימלי. מספר חיובי מיישר לימין, מספר שלילי מיישר לשמאל. בשילוב עם עיצוב, זה מסדר טבלאות בטקסט פשוט:

using System;

class Program
{
    static void Main()
    {
        var names = new[] { "Espresso", "Latte", "Hot chocolate" };
        var prices = new[] { 2.4m, 3.6m, 4.25m };
        var sold = new[] { 118, 64, 9 };

        Console.WriteLine($"{"Item",-14}|{"Price",7}|{"Sold",5}");
        Console.WriteLine(new string('-', 28));
        for (int i = 0; i < names.Length; i++)
        {
            Console.WriteLine($"{names[i],-14}|{prices[i],7:F2}|{sold[i],5}");
        }
    }
}

פלט:

Item          |  Price| Sold
----------------------------
Espresso      |   2.40|  118
Latte         |   3.60|   64
Hot chocolate |   4.25|    9

התחביר הוא {expression,alignment:format}: קודם היישור, אחר כך העיצוב. ערך ארוך מהרוחב לא נחתך; הוא דוחף את שאר השורה הלאה. PadLeft ו-PadRight מבצעים את אותו ריפוד מחוץ לאינטרפולציה.

בריחה של סוגריים מסולסלים

כדי להדפיס סוגר מסולסל מילולי, הכפילו אותו: {{ ו-}}. זה עולה כשהפלט הוא JSON, CSS או קוד:

using System;

class Program
{
    static void Main()
    {
        int id = 42;
        string name = "Ana";

        Console.WriteLine($"{{ \"id\": {id}, \"name\": \"{name}\" }}");
        Console.WriteLine($"Set literal: {{1, 2, 3}}");
        Console.WriteLine($"{{{id}}}");   // a value wrapped in braces
    }
}

פלט:

{ "id": 42, "name": "Ana" }
Set literal: {1, 2, 3}
{42}

בניית JSON ביד בצורה כזו מתאימה לשורת לוג מהירה; ל-JSON אמיתי השתמשו בסריאלייזר, שמטפל נכון במירכאות ובתווים מיוחדים בתוך name.

string.Format ועיצוב מורכב

לפני C# 6, עיצוב נעשה עם string.Format, שמקבלת מצייני מקום ממוספרים ורשימת ארגומנטים. אותו תחביר של עיצוב מורכב מתקבל על ידי Console.WriteLine, StringBuilder.AppendFormat ו-TextWriter.Write:

using System;

class Program
{
    static void Main()
    {
        string item = "Notebook";
        decimal price = 3.5m;
        int qty = 4;

        string line = string.Format("{0} x{1}: {2:F2}", item, qty, price * qty);
        Console.WriteLine(line);

        Console.WriteLine("{0,-10}|{1,6:F2}", item, price);   // alignment and format
        Console.WriteLine("{0} {0} {1}", "echo", "!");        // an index can repeat

        string template = "Dear {0}, your order #{1:D6} has shipped.";
        Console.WriteLine(string.Format(template, "Leo", 731));
    }
}

פלט:

Notebook x4: 14.00
Notebook  |  3.50
echo echo !
Dear Leo, your order #000731 has shipped.

העדיפו אינטרפולציה בקוד: הערכים יושבים במקום שבו הם מופיעים, כך שמציין מקום לא יכול להצביע על הארגומנט הלא נכון. string.Format נשארת הכלי הנכון כשהתבנית היא נתונים, כמו הודעה מתורגמת שנטענת מקובץ משאבים. אינדקס של מציין מקום בלי ארגומנט מתאים ({2} עם שני ארגומנטים) זורק FormatException בזמן ריצה.

תרבות: שליטה במפרידים ובמטבע

אינטרפולציה, ToString ו-string.Format משתמשים כולם כברירת מחדל בתרבות הנוכחית של התהליכון. במחשב שמוגדר לגרמנית, {1234.5:N2} מפיק 1.234,50; בארצות הברית הוא מפיק 1,234.50. עיצוב המטבע C משתמש בסמל של התרבות. כדי לבחור את התרבות במפורש, שמרו את מחרוזת האינטרפולציה כ-FormattableString ועצבו אותה עם provider:

using System;
using System.Globalization;

class Program
{
    static void Main()
    {
        decimal amount = 1234.5m;
        var us = new CultureInfo("en-US");
        var de = new CultureInfo("de-DE");

        FormattableString line = $"Total: {amount:N2}";
        Console.WriteLine(line.ToString(us));
        Console.WriteLine(line.ToString(de));

        Console.WriteLine(amount.ToString("C", us));
        Console.WriteLine(string.Format(de, "{0:N2}", amount));

        // For files, logs and URLs: always the invariant culture
        string csv = FormattableString.Invariant($"{amount},{0.75}");
        Console.WriteLine(csv);
    }
}

פלט:

Total: 1,234.50
Total: 1.234,50
$1,234.50
1.234,50
1234.5,0.75

השתמשו בתרבות של המשתמש לטקסט שאנשים קוראים, וב-CultureInfo.InvariantCulture לכל דבר שתוכנית אחרת קוראת. קובץ CSV שנכתב עם התרבות הנוכחית במחשב גרמני מכיל פסיקים בתוך מספרים ובלתי קריא במקומות אחרים. ב-.NET 6 ואילך, string.Create(CultureInfo.InvariantCulture, $"...") עושה את אותו הדבר כמו FormattableString.Invariant בלי אובייקט הביניים.

מחרוזות אינטרפולציה verbatim ו-raw

$ משתלב עם @ למחרוזת אינטרפולציה verbatim: לוכסנים הפוכים הם מילוליים והמחרוזת יכולה להשתרע על פני כמה שורות. C# 8 ואילך מקבלות כל סדר ($@ או @$); C# 6 ו-7 דורשות $@:

using System;

class Program
{
    static void Main()
    {
        string user = "ana";
        int year = 2026;
        Console.WriteLine($@"C:\Users\{user}\Reports\{year}\summary.txt");
        Console.WriteLine($@"Report for {user}
Year: {year}");
    }
}

פלט:

C:\Users\ana\Reports\2026\summary.txt
Report for ana
Year: 2026

C# 11 הוסיפה מחרוזות אינטרפולציה raw. עם $ אחד, סוגריים מסולסלים מסמנים ביטויים כרגיל. עם $$, סוגר מסולסל בודד הוא מילולי וביטויים צריכים שני סוגריים, וזה הופך תבניות JSON וקוד לקריאות:

// C# 11 and later
int id = 42;
string name = "Ana";
string json = $$"""
    {
      "id": {{id}},
      "name": "{{name}}"
    }
    """;

C# 11 מתירה גם שורות חדשות בתוך חור אינטרפולציה, כך שאפשר לפצל ביטוי ארוך או ביטוי switch על פני כמה שורות.

טעויות נפוצות

• שכחה של ה-$. "Total: {total}" מדפיס את הסוגריים המסולסלים כמו שהם. הקומפיילר לא מזהיר.
• אופרטור טרנרי בלי סוגריים בתוך הסוגריים המסולסלים: הנקודתיים נקראים כמפריד עיצוב.
• עיצוב פלט שמכונות קוראות עם התרבות הנוכחית. פסיקים עשרוניים שוברים CSV, JSON ו-SQL. השתמשו בתרבות הבלתי תלויה.
• שימוש ב-ToString() בלי עיצוב לסכומי כסף. 2.5m מודפס כ-2.5, לא 2.50. השתמשו ב-F2, ב-N2 או ב-C.
• בניית מחרוזות גדולות עם אינטרפולציה בתוך לולאה. כל איטרציה יוצרת מחרוזת חדשה; השתמשו ב-StringBuilder או ב-string.Join.