What are raw string literals in C# 11? Explain the triple-quote syntax, how indentation is removed, including quotes inside the text, interpolated raw strings with multiple dollar signs, UTF-8 raw strings, and where they help in real code such as JSON, SQL and test fixtures.

How I would answer this in an interview

Raw string literals (C# 11) let you write multi-line text containing quotes, backslashes and braces without escaping, delimited by three or more double quotes. They're ideal for JSON, SQL, XML, regex and test fixtures. I'd explain the syntax, indentation removal, quotes inside the text, interpolated raw strings with multiple $, UTF-8 raw strings, and real uses.

1. Syntax

string single = """He said "hello" and left C:\temp""";   // single-line raw string

string json = """
    {
      "orderId": 42,
      "status": "paid",
      "path": "C:\\exports"
    }
    """;

• Start with at least """. Single-line raw strings put content on the same line; multi-line raw strings start content on the next line after the opening delimiter.
• No escape sequences are processed: \n, \\, \" are literal characters. (In the JSON above, C:\\exports stays exactly as written — which is valid JSON escaping, because the string is passed through untouched.)

2. How indentation is removed

In a multi-line raw string, the closing delimiter's column defines the indentation to strip:

        var sql = """
            SELECT Id, Total
            FROM Orders
            WHERE CustomerId = @customerId
            """;

• The whitespace before the closing """ (12 spaces here) is removed from every content line.
• Every content line must start with at least that whitespace (otherwise CS9003).
• The first newline (after the opening delimiter) and the last newline (before the closing delimiter) are not part of the value.
• Mixed tabs/spaces must match exactly.

So you can indent raw strings naturally with your code without the indentation leaking into the value.

3. Quotes inside the text

If the content contains """, use more quotes for the delimiters:

var doc = """"
    A raw string with """ inside it.
    """";

The delimiter must be longer than any run of quotes in the content.

4. Interpolated raw strings with multiple $

The number of $ signs sets how many braces open an interpolation hole, so single braces stay literal — perfect for JSON and C#-like templates:

var payload = $$"""
    {
      "orderId": {{order.Id}},
      "total": {{order.Total.ToString(CultureInfo.InvariantCulture)}},
      "tags": ["priority", "au"]
    }
    """;

• With $$, holes are {{expr}}; a single { or } is literal.
• With $$$, holes are {{{expr}}}, letting {{ appear literally (e.g. Mustache/Handlebars templates).
• Interpolation follows normal rules (current culture, format specifiers like {{total:C}}).

5. UTF-8 raw strings

Append u8 to get a ReadOnlySpan<byte> encoded at compile time:

ReadOnlySpan<byte> body = """
    {"status":"ok"}
    """u8;
await response.Body.WriteAsync(body.ToArray(), ct);   // or write the span directly with PipeWriter

No runtime encoding or allocation for constant payloads. (Interpolation isn't supported with u8.)

6. Real uses

• Test fixtures: JSON request/response bodies, expected API output, snapshot data — readable and copy-pasteable from tools.
• SQL: Dapper queries, FromSql templates (still use parameters, not interpolation of values!), migration scripts in code.
• Regex: patterns with backslashes and quotes without double-escaping (better still with [GeneratedRegex]).
• Code generation: source generators emitting C# with braces ($$""").
• Prompts/templates: LLM prompt templates, email templates with placeholders.
• XML/HTML snippets in tests.

Cautions: don't build SQL/JSON with untrusted values via interpolation — use parameters and serialisers; raw strings make injection easier to write, not safer.

7. A production example

Integration tests for a payments webhook contained JSON with escaped quotes and \ns across 60 lines — nobody could read or update them, and a missing escape made one test silently send invalid JSON. Converting fixtures to raw string literals made them identical to the provider's documentation samples; we used $$""" for the few dynamic fields. Fixture-related test failures disappeared and reviewing payload changes became trivial.