פורמט DateTime ב-C#: מחרוזות פורמט סטנדרטיות ומותאמות, תרבות ו-ISO 8601

DateTime.ToString(format) הופך תאריך לטקסט. הפורמט הוא או מחרוזת פורמט סטנדרטית (אות אחת כמו d או o, שהתבנית המדויקת שלה מגיעה מהתרבות) או תבנית מותאמת שבנויה ממגדירים כמו yyyy, MM ו-HH. אותן מחרוזות עובדות באינטרפולציה, $"{date:yyyy-MM-dd}", וב-string.Format.

using System;
using System.Globalization;

class Program
{
    static void Main()
    {
        var shipped = new DateTime(2026, 10, 9, 18, 30, 7, 45);
        var inv = CultureInfo.InvariantCulture;

        Console.WriteLine(shipped.ToString("yyyy-MM-dd", inv));
        Console.WriteLine(shipped.ToString("yyyy-MM-dd HH:mm:ss", inv));
        Console.WriteLine(shipped.ToString("dd/MM/yyyy", inv));
        Console.WriteLine(shipped.ToString("MMM d, yyyy", inv));
        Console.WriteLine(shipped.ToString("dddd, MMMM d", inv));
        Console.WriteLine(shipped.ToString("h:mm tt", inv));
        Console.WriteLine(shipped.ToString("HH:mm:ss.fff", inv));
        Console.WriteLine($"Shipped {shipped:yyyy-MM-dd} at {shipped:HH:mm}");
    }
}

פלט:

2026-10-09
2026-10-09 18:30:07
09/10/2026
Oct 9, 2026
Friday, October 9
6:30 PM
18:30:07.045
Shipped 2026-10-09 at 18:30

הדוגמאות בדף הזה מעבירות CultureInfo.InvariantCulture כדי שהפלט יהיה זהה בכל מחשב; בלעדיו, ToString משתמשת בתרבות הנוכחית, שיכולה לשנות שמות חודשים, מפרידים ואפילו את לוח השנה.

מגדירי פורמט מותאמים

פורמט מותאם הוא תבנית שבה אותיות מסוימות מייצגות חלקים של התאריך. הן רגישות לאותיות גדולות וקטנות: M הוא חודש ו-m הוא דקה, H היא השעה בפורמט 24 שעות ו-h השעה בפורמט 12 שעות.

כל תו אחר מועתק כמו שהוא. זה כולל אותיות שאינן מגדירים, וכך "YYYY-DD" מדפיס בשקט YYYY-DD: אין ב-.NET מגדיר Y או D באות גדולה.

אות אחת לבדה נקראת כפורמט סטנדרטי, לא כמותאם: ToString("d") היא תבנית התאריך הקצר, לא מספר היום. כדי לקבל רק את היום, כתבו ToString("%d") או השתמשו במאפיין Day.

using System;
using System.Globalization;

class Program
{
    static void Main()
    {
        var d = new DateTime(2026, 10, 9, 18, 30, 7);
        var inv = CultureInfo.InvariantCulture;

        Console.WriteLine(d.ToString("d", inv));             // standard short date
        Console.WriteLine(d.ToString("%d", inv));            // custom: day of month
        Console.WriteLine(d.ToString("yyyyMMdd_HHmmss", inv)); // for file names
        Console.WriteLine(d.ToString("'Week of' MMM d", inv));
        Console.WriteLine(d.ToString("HH'h'mm", inv));
        Console.WriteLine(d.ToString("yyyy-MM-ddTHH:mm:ss", inv));
        Console.WriteLine(d.ToString("YYYY-DD", inv));      // not specifiers: copied
    }
}

פלט:

10/09/2026
9
20261009_183007
Week of Oct 9
18h30
2026-10-09T18:30:07
YYYY-DD

מחרוזות פורמט סטנדרטיות

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

using System;
using System.Globalization;

class Program
{
    static void Main()
    {
        var d = new DateTime(2026, 10, 9, 18, 30, 7, DateTimeKind.Utc);
        var inv = CultureInfo.InvariantCulture;

        foreach (string f in new[] { "d", "D", "f", "g", "G", "M", "Y", "t", "T", "o", "s", "u", "r" })
        {
            Console.WriteLine($"{f}  {d.ToString(f, inv)}");
        }

        var us = new CultureInfo("en-US");
        Console.WriteLine($"en-US d: {d.ToString("d", us)}, D: {d.ToString("D", us)}");
    }
}

פלט:

d  10/09/2026
D  Friday, 09 October 2026
f  Friday, 09 October 2026 18:30
g  10/09/2026 18:30
G  10/09/2026 18:30:07
M  October 09
Y  2026 October
t  18:30
T  18:30:07
o  2026-10-09T18:30:07.0000000Z
s  2026-10-09T18:30:07
u  2026-10-09 18:30:07Z
r  Fri, 09 Oct 2026 18:30:07 GMT
en-US d: 10/9/2026, D: Friday, October 9, 2026

o, s, u ו-r מפיקים את אותו טקסט בכל תרבות, ולכן הם בטוחים ללוגים, לשמות קבצים ולהעברת נתונים. שימו לב שעל DateTime, u ו-r לא ממירים את הערך ל-UTC; הם מדפיסים אותו כמו שהוא ומתייגים אותו כ-UTC, אז קראו קודם ל-ToUniversalTime() (או השתמשו ב-DateTime.UtcNow) אם הערך מקומי. (על DateTimeOffset הם כן ממירים.)

התרבות משנה את הפלט

הפורמטים הסטנדרטיים, שמות החודשים והימים, והמפרידים / ו-: מגיעים כולם מהתרבות. העבירו תרבות כארגומנט השני ל-ToString:

using System;
using System.Globalization;

class Program
{
    static void Main()
    {
        var d = new DateTime(2026, 10, 9, 18, 30, 0);
        string[] cultures = { "en-US", "en-GB", "de-DE", "fr-FR", "ja-JP" };

        foreach (string name in cultures)
        {
            var c = new CultureInfo(name);
            Console.WriteLine($"{name}  {d.ToString("d", c)}");
        }

        var de = new CultureInfo("de-DE");
        Console.WriteLine(d.ToString("D", de));
        Console.WriteLine(d.ToString("D", new CultureInfo("fr-FR")));
        Console.WriteLine(d.ToString("dd/MM/yyyy", de));      // "/" becomes "."
        Console.WriteLine(d.ToString("dd'/'MM'/'yyyy", de));  // quoted: a real slash
    }
}

פלט:

en-US  10/9/2026
en-GB  09/10/2026
de-DE  09.10.2026
fr-FR  09/10/2026
ja-JP  2026/10/09
Freitag, 9. Oktober 2026
vendredi 9 octobre 2026
09.10.2026
09/10/2026

נתוני התרבות אינם קפואים. .NET על Linux ועל macOS קוראת אותם מספריית ICU שמותקנת במערכת, ומאז .NET 5 גם .NET על Windows 10 ואילך (.NET Framework משתמשת בנתוני ה-NLS של Windows עצמה), כך שתבנית יכולה להשתנות מעט בין גרסאות ופלטפורמות: גרסאות ICU עדכניות, למשל, שמות רווח צר בלתי שביר במקום רווח רגיל לפני "PM" בפורמט השעה הקצר של ארה"ב, וחלקן נותנות תאריכים קצרים בספרדית בלי האפס המוביל. זו עוד סיבה אף פעם לא לפענח טקסט שעוצב לתצוגה.

נובעים מזה שני כללים. לטקסט שאדם קורא, עצבו עם התרבות שלו (בשרת, זו שמגיעה מהבקשה, לא זו של השרת) והעדיפו פורמטים סטנדרטיים, כך שקורא גרמני יראה 09.10.2026 וקורא אמריקאי 10/9/2026. לטקסט שתוכנית קוראת, השתמשו ב-CultureInfo.InvariantCulture ובתבנית חד-משמעית כמו yyyy-MM-dd או o. תאריך שנכתב עם התרבות הנוכחית ופוענח במחשב אחר הוא מקור קלאסי לימים וחודשים שהתחלפו.

ISO 8601 ו-round-trip עם "o"

פורמט ה-round-trip "o" כותב כל tick ובנוסף את המידע על אזור הזמן, כך שפענוח הטקסט מחזיר בדיוק את אותו DateTime, כולל ה-Kind שלו:

using System;
using System.Globalization;

class Program
{
    static void Main()
    {
        var inv = CultureInfo.InvariantCulture;
        var utc = new DateTime(2026, 10, 9, 18, 30, 7, 45, DateTimeKind.Utc);
        var unspecified = new DateTime(2026, 10, 9, 18, 30, 7, 45);
        var offset = new DateTimeOffset(2026, 10, 9, 20, 30, 7, TimeSpan.FromHours(2));

        string stored = utc.ToString("o", inv);
        Console.WriteLine(stored);
        Console.WriteLine(unspecified.ToString("o", inv));
        Console.WriteLine(offset.ToString("o", inv));

        DateTime back = DateTime.Parse(stored, inv, DateTimeStyles.RoundtripKind);
        Console.WriteLine(back == utc);
        Console.WriteLine(back.Kind);

        Console.WriteLine(utc.ToString("yyyy-MM-ddTHH:mm:ssK", inv));    // no fractions
        Console.WriteLine(offset.ToString("yyyy-MM-dd HH:mm zzz", inv));
    }
}

פלט:

2026-10-09T18:30:07.0450000Z
2026-10-09T18:30:07.0450000
2026-10-09T20:30:07.0000000+02:00
True
Utc
2026-10-09T18:30:07Z
2026-10-09 20:30 +02:00

הסיומת Z מסמנת UTC; DateTime עם Kind מסוג Unspecified לא מקבל סיומת; זמן מקומי או DateTimeOffset מקבלים את ההיסט שלהם (+02:00). פענחו עם DateTimeStyles.RoundtripKind כדי שה-Kind ישרוד. serializers של JSON, מסדי נתונים ו-Date של JavaScript קוראים כולם את הפורמט הזה.

עיצוב TimeSpan

ל-TimeSpan יש קבוצה משלו, קטנה יותר, של מגדירים מותאמים: d (ימים), hh, mm, ss, ו-fff. בניגוד ל-DateTime, כל תו מילולי, כולל : ו-., חייב לקבל escape עם לוכסן הפוך או להיות במירכאות:

using System;

class Program
{
    static void Main()
    {
        var elapsed = new TimeSpan(1, 3, 25, 9, 120);   // 1 day 3:25:09.120

        Console.WriteLine(elapsed.ToString());
        Console.WriteLine(elapsed.ToString("c"));
        Console.WriteLine(elapsed.ToString(@"hh\:mm\:ss"));        // hours component only
        Console.WriteLine(elapsed.ToString(@"d\.hh\:mm"));
        Console.WriteLine(elapsed.ToString(@"mm\:ss\.fff"));
        Console.WriteLine($"{(int)elapsed.TotalHours}:{elapsed.Minutes:D2}");  // 27:25
    }
}

פלט:

1.03:25:09.1200000
1.03:25:09.1200000
03:25:09
1.03:25
25:09.120
27:25

hh בפורמט של TimeSpan הוא רכיב השעות (0 עד 23), כך שמשך של 27 שעות מודפס כ-03. לסכומים מעל יום, חשבו מתוך TotalHours כמו בשורה האחרונה. elapsed.ToString("hh:mm") בלי הלוכסן ההפוך זורק FormatException.

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

• mm לחודש. "yyyy-mm-dd" מדפיס דקות באמצע: 2026-30-09. חודש הוא MM.
• hh בלי tt. "hh:mm" הוא שעון 12 שעות בלי AM או PM, כך ש-06:30 דו-משמעי. השתמשו ב-HH לפורמט 24 שעות.
• YYYY ו-DD. הם לא מגדירים ב-.NET; הם מודפסים כמו שהם. השתמשו ב-yyyy וב-dd.
• / בתבנית לנתונים. זה מפריד התאריך של התרבות. שימו אותו במירכאות או השתמשו בתרבות הבלתי תלויה (invariant).
• ToString() ברירת מחדל בלוגים או בקבצים. הפורמט תלוי במחשב. העבירו פורמט ותרבות.
• זמן מקומי שמתויג כ-UTC. "u", "r" ו-'Z' שנכתב ביד לא ממירים; המירו קודם.
• פענוח עם תבנית שונה מזו שבה כתבתם. שמרו מחרוזות פורמט לנתונים בקבוע אחד והשתמשו בו גם עם ToString וגם עם ParseExact.