How does string formatting work in .NET? Explain composite formatting, standard and custom format strings for numbers and dates, IFormatProvider and CultureInfo, and when to use the invariant culture.

1. The formatting pipeline

When you call value.ToString("C2", provider) on a primitive:

1. NumberFormatInfo.GetInstance(provider) resolves the provider to a NumberFormatInfo (current culture's if null).
2. The number is converted to its decimal digits (Number.Formatting in the runtime, using exact algorithms such as Ryu/Grisu-like shortest round-trip for floating point since .NET Core 3.0).
3. The format specifier is parsed: one letter plus optional precision = standard format; anything else = custom format.
4. Digits are laid out using the culture's symbols: CurrencySymbol, CurrencyDecimalSeparator, CurrencyGroupSizes, CurrencyNegativePattern, and so on.

ISpanFormattable.TryFormat(Span<char>, out int, ReadOnlySpan<char> format, IFormatProvider?) runs the same pipeline but writes into a caller buffer — used by interpolated string handlers, StringBuilder and UTF-8 formatting (IUtf8SpanFormattable in .NET 8) without allocating.

2. Where culture data comes from

On Windows, .NET 5+ uses ICU by default (previously NLS); on Linux and macOS, it always uses ICU (the libicu package). Culture data therefore can change between OS/ICU versions — for example, a culture's short date pattern, the narrow no-break space (U+202F) before AM/PM in newer CLDR data, or currency symbols. Code and tests that compare formatted output to hard-coded strings can break after an OS or base-image upgrade.

In globalization-invariant mode (InvariantGlobalization=true, common for small containers), every culture behaves like the invariant culture: CultureInfo("en-AU") still exists but formats like invariant (¤ currency symbol). Since .NET 8 you can have PredefinedCulturesOnly=true so creating non-invariant cultures throws instead of silently degrading.

3. The invariant culture

CultureInfo.InvariantCulture is associated with English but not with any country, and its data never changes between .NET versions or machines — that stability is the entire point. Its short date pattern is MM/dd/yyyy, which is why "invariant" date strings look American; for data, prefer ISO 8601 ("O", "yyyy-MM-dd").

4. Parsing mirrors formatting

• decimal.Parse(s, NumberStyles.Number, CultureInfo.InvariantCulture) — specify both the styles allowed and the culture.
• DateTime.ParseExact(s, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None) — never use DateTime.Parse on ambiguous external input.
• TryParse overloads avoid exceptions on bad input.
• DateTimeStyles.AssumeUniversal | AdjustToUniversal control time zone interpretation; DateTimeOffset.Parse with "O" keeps the offset.
• DateOnly and TimeOnly (.NET 6) avoid time-zone confusion for date-only data such as birthdays and due dates.

5. Custom formatters

You can implement IFormatProvider + ICustomFormatter to change how arguments format in string.Format, or implement IFormattable/ISpanFormattable on your own types:

public readonly record struct Abn(string Value) : ISpanFormattable
{
    public string ToString(string? format, IFormatProvider? provider) =>
        format == "S" ? $"{Value[..2]} {Value[2..5]} {Value[5..8]} {Value[8..]}" : Value;

    public bool TryFormat(Span<char> dest, out int written, ReadOnlySpan<char> format, IFormatProvider? provider)
        => dest.TryWrite(provider, $"{ToString(format.ToString(), provider)}", out written);
}

// $"{abn:S}" -> "51 824 753 556"

6. CompositeFormat (.NET 8)

Parsing a composite format string has a cost. For formats used repeatedly (e.g. localised resource strings), parse once:

private static readonly CompositeFormat OrderFmt = CompositeFormat.Parse(Resources.OrderSummary);
string s = string.Format(culture, OrderFmt, id, total);

Analyser CA1863 suggests this for hot paths.

7. Time zones are a separate problem

Formatting does not convert time zones. DateTime.Now.ToString("g") on an Azure App Service in UTC shows UTC time to an Australian user. Convert first with TimeZoneInfo.ConvertTimeBySystemTimeZoneId(utc, "Australia/Sydney") (IANA IDs work on all platforms in .NET 6+), then format with the user's culture, and remember daylight saving changes (AEDT/AEST).

Try it yourself

1. Print 1234.5m.ToString("C") under en-AU, en-US, de-DE, ja-JP and invariant.
2. Format DateTime.Now with "d", "o", "yyyy/MM/dd" under de-DE and notice the separator change.
3. Run a small app with <InvariantGlobalization>true</InvariantGlobalization> and format en-AU currency.
4. Enable CA1305 as a warning and fix the reported calls.

using System.Globalization;

namespace Strings;

public static class Formatting
{
    private static readonly CultureInfo EnAu = CultureInfo.GetCultureInfo("en-AU");
    private static readonly CultureInfo DeDe = CultureInfo.GetCultureInfo("de-DE");

    public static void Main()
    {
        decimal price = 1234.567m;

        // Display formatting in an explicit culture
        Console.WriteLine(price.ToString("C2", EnAu));     // $1,234.57
        Console.WriteLine(price.ToString("N2", DeDe));     // 1.234,57
        Console.WriteLine(string.Format(EnAu, "{0,-8}|{1,12:C2}|{2:P1}", "Widget", price, 0.125));

        // Machine-readable: invariant culture and ISO 8601
        var when = new DateTimeOffset(2026, 10, 23, 14, 5, 0, TimeSpan.FromHours(11));
        string iso = when.ToString("o", CultureInfo.InvariantCulture);
        Console.WriteLine(iso);                            // 2026-10-23T14:05:00.0000000+11:00
        Console.WriteLine(price.ToString(CultureInfo.InvariantCulture)); // 1234.567

        // Parsing with an explicit culture and format
        bool ok = DateOnly.TryParseExact("23/10/2026", "dd/MM/yyyy", CultureInfo.InvariantCulture,
                                         DateTimeStyles.None, out var date);
        Console.WriteLine($"{ok} {date:yyyy-MM-dd}");

        if (decimal.TryParse("1,5", NumberStyles.Number, DeDe, out var german))
            Console.WriteLine(german);                     // 1.5

        // Custom numeric format with sections
        Console.WriteLine((-5).ToString("+0;-0;zero", CultureInfo.InvariantCulture)); // -5

        // Allocation-free formatting into a span
        Span<char> buffer = stackalloc char[16];
        if (price.TryFormat(buffer, out int written, "F2", CultureInfo.InvariantCulture))
            Console.WriteLine(buffer[..written].ToString()); // 1234.57
    }
}