How does string interpolation work in C#? Explain interpolated string handlers, FormattableString, raw interpolated strings, which culture is used, and where interpolation is dangerous (SQL and logging).

1. Lowering in detail

string s = $"Total for {name}: {amount:C2}";

becomes:

var handler = new DefaultInterpolatedStringHandler(literalLength: 12, formattedCount: 2);
handler.AppendLiteral("Total for ");
handler.AppendFormatted(name);
handler.AppendLiteral(": ");
handler.AppendFormatted(amount, "C2");
string s = handler.ToStringAndClear();

• The constructor estimates an initial buffer size from the literal length plus a guess per hole, rents from ArrayPool<char>.Shared (or uses a caller-provided Span<char>).
• AppendFormatted<T>: if T is ISpanFormattable (all primitives, DateTime, Guid, decimal...), calls TryFormat into the remaining buffer; grows by renting a bigger array if needed. Otherwise falls back to IFormattable.ToString or ToString().
• Alignment ({x,10}) and format specifiers are passed through.
• ToStringAndClear creates the final string and returns the rented array to the pool.

If all holes are constant strings, C# 10 makes the whole expression a constant: const string Url = $"{Base}/orders";.

2. Handler argument passing: InterpolatedStringHandlerArgument

A method can pass other parameters into the handler's constructor:

public void Append(IFormatProvider? provider,
    [InterpolatedStringHandlerArgument("", "provider")] ref AppendInterpolatedStringHandler handler);

That is how sb.Append(CultureInfo.InvariantCulture, $"...") formats with a specific culture, and how logging-style handlers receive the logger and level so they can decide shouldAppend = logger.IsEnabled(level) before evaluating any argument expressions.

3. Writing a custom handler (sketch)

[InterpolatedStringHandler]
public ref struct GuardHandler
{
    private DefaultInterpolatedStringHandler _inner;
    public GuardHandler(int literalLength, int formattedCount, bool condition, out bool shouldAppend)
    {
        shouldAppend = !condition;               // only build the message when the check FAILS
        _inner = shouldAppend ? new(literalLength, formattedCount) : default;
    }
    public void AppendLiteral(string s) => _inner.AppendLiteral(s);
    public void AppendFormatted<T>(T value) => _inner.AppendFormatted(value);
    public string ToStringAndClear() => _inner.ToStringAndClear();
}

When shouldAppend is false, the compiler skips all Append* calls — including evaluating expensive argument expressions such as {order.ToJson()}.

4. Culture: CurrentCulture vs CurrentUICulture vs invariant

• CurrentCulture controls formatting and parsing of numbers, dates and currency. Interpolation and ToString() use it.
• CurrentUICulture controls resource lookup (which .resx translation is shown).
• In ASP.NET Core, UseRequestLocalization sets both per request from the query string, cookie or Accept-Language header. Without it, the server's process culture is used.
• Containers based on Alpine or chiseled images may run in globalization-invariant mode (DOTNET_SYSTEM_GLOBALIZATION_INVARIANT=1), where all cultures behave like invariant — en-AU currency formatting silently becomes ¤.

Currency example: $"{19.95m:C}" gives $19.95 for en-AU, 19,95 € for de-DE, and ¤19.95 in invariant culture. Australian apps typically set en-AU explicitly for user-facing formatting and invariant for data.

5. Why logging templates matter

ILogger message templates ("Exported {Count} rows") are parsed once and cached. The provider gets the template and the argument values separately, so:

• Log sinks store Count as a numeric property you can query (Count > 10000).
• Messages with the same template are grouped for alerting and dashboards.
• If the level is disabled, LoggerExtensions still allocates the params object[] — which is why [LoggerMessage] source-generated methods (strongly typed, level-checked, no boxing) are best for hot paths.

Interpolating into the message produces a unique string per call: no grouping, no properties, formatting cost even when disabled, and log volume surprises.

6. How EF Core parameterises FormattableString

FromSql(FormattableString sql) reads sql.Format ("... WHERE Region = {0}") and sql.GetArguments(), replaces each placeholder with a parameter name (@p0), and creates DbParameters with the argument values. Because values never become part of the SQL text, injection is impossible for those holes. Identifiers (table/column names, ORDER BY columns) cannot be parameters — they need allow-listing, not interpolation.

Try it yourself

1. Paste an interpolated string into SharpLab, targeting string and then FormattableString, and compare the lowered code.
2. Set CultureInfo.CurrentCulture = new CultureInfo("de-DE") and print $"{1234.5m}"; then use string.Create(CultureInfo.InvariantCulture, ...).
3. Log with interpolation and with a template into a structured sink (Seq or the console JSON formatter) and compare the output.
4. Run EF Core with LogTo(Console.WriteLine) and compare SQL from FromSqlRaw($"...") vs FromSql($"...").

using System.Globalization;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;

namespace Strings;

public sealed class Order { public int Id { get; set; } public string Region { get; set; } = ""; public decimal Total { get; set; } }

public sealed class ShopContext(DbContextOptions<ShopContext> options) : DbContext(options)
{
    public DbSet<Order> Orders => Set<Order>();
}

public static class Interpolation
{
    public static void Demo()
    {
        int id = 42;
        decimal total = 1234.5m;

        // Alignment and format specifiers
        Console.WriteLine($"|{id,6}|{total,12:C2}|");

        // Culture-safe machine-readable output
        double lat = -33.8688, lon = 151.2093;
        string key = string.Create(CultureInfo.InvariantCulture, $"{lat},{lon}");
        Console.WriteLine(key);                             // -33.8688,151.2093 in any culture

        // Raw interpolated JSON template
        string json = $$"""{ "id": {{id}}, "total": {{total.ToString(CultureInfo.InvariantCulture)}} }""";
        Console.WriteLine(json);

        // Format into a stack buffer: no heap allocation
        Span<char> buffer = stackalloc char[32];
        if (buffer.TryWrite(CultureInfo.InvariantCulture, $"ORD-{id:D6}", out int written))
            Console.WriteLine(buffer[..written].ToString());  // ORD-000042
    }

    // Safe SQL: FromSql turns holes into parameters
    public static Task<List<Order>> ByRegionAsync(ShopContext db, string region, CancellationToken ct)
        => db.Orders.FromSql($"SELECT * FROM Orders WHERE Region = {region}").ToListAsync(ct);

    // Structured logging: template + arguments, not interpolation
    public static void LogShipped(ILogger logger, int orderId)
        => logger.LogInformation("Order {OrderId} shipped", orderId);
}