Introduction

In .NET format strings, braces are part of the formatting syntax, so you cannot treat them as ordinary text. If you want literal curly braces in the output, the standard rule is to double them: {{ for an opening brace and }} for a closing brace.

That sounds simple, but confusion appears quickly because .NET has several string-formatting styles. Composite formatting, interpolated strings, and logging templates all use brace-like syntax, and they do not always behave the same way.

Composite Formatting Uses Braces for Placeholders

Classic .NET composite formatting treats braces as markers around format items such as 0 or 1.

int count = 42;
string message = string.Format("Count = {0}", count);
Console.WriteLine(message);

Here, {0} means "insert the first argument." Because braces have special meaning, a single literal brace is not allowed in normal text.

If you want the output itself to contain braces, escape them by doubling:

int count = 42;
string message = string.Format("Count = {{ {0} }}", count);
Console.WriteLine(message);

Output:

Count = { 42 }

That is the core rule for string.Format and APIs built on the same composite-formatting system.

Emitting Text That Looks Like a Placeholder

Sometimes you want the output to contain something that resembles a format token, such as {0} literally. Double the braces around the part that should be treated as text:

1string message = string.Format(
2    "Literal token: {{0}}, actual value: {0}",
3    99
4);
5
6Console.WriteLine(message);

Output:

Literal token: {0}, actual value: 99

Without escaping, the runtime would try to interpret both brace pairs as formatting instructions.

Interpolated Strings Use the Same Visual Escape

C# interpolated strings also use braces, so literal braces still need to be doubled.

string name = "Alice";
string message = $"User {{Name: {name}}}";
Console.WriteLine(message);

Output:

User {Name: Alice}

The syntax is a different feature, but the literal-brace rule is visually the same. If the braces are part of the output text rather than interpolation syntax, double them.

Structured Output Is a Common Real-World Case

A lot of developers hit this issue while generating JSON-like or template-like strings:

1int age = 25;
2string json = string.Format(
3    "{{ \"name\": \"Ava\", \"age\": {0} }}",
4    age
5);
6
7Console.WriteLine(json);

This works, but it is worth asking whether string formatting is the right tool. For real JSON output, a serializer is safer because it handles quoting and escaping correctly. Manual formatting is fine for quick examples, logs, or controlled templates, but it becomes brittle as structured text grows more complex.

Do Not Confuse Formatting With Logging Templates

One reason this topic causes confusion is that many logging frameworks also use braces, but not always as composite format placeholders. A logging API may interpret {UserId} as a named message-template field rather than as .NET composite formatting.

That means two strings that look nearly identical can follow different rules depending on the API. If you are not calling string.Format or using an interpolated string directly, check the documentation of the specific library. Do not assume every brace-based string follows the same escaping rules.

A Simple Mental Model

When you are writing a format string, ask a direct question for each brace:

• is this brace part of formatting syntax
• or should it appear in the final text

If it should appear in the final text, double it. That mental model scales from simple one-line messages to more complex templates.

Common Pitfalls

The most common mistake is using a single brace in a composite format string and getting a FormatException. The formatter sees unmatched syntax, not literal text.

Another mistake is hand-building structured formats such as JSON and assuming brace escaping is the only concern. Even if the braces are correct, quotes, backslashes, and special characters can still make the output invalid.

Developers also copy strings between string.Format, interpolated strings, and logging templates as if they were interchangeable. They are similar, but they are not identical systems.

Finally, be careful when reading older examples. Some code uses composite formatting, some uses interpolation, and some uses logging placeholders. The visible braces may look the same while the runtime rules differ.

Summary

• In .NET format strings, use {{ and }} to output literal braces.
• Composite formatting and interpolated strings both require doubled braces for literal text.
• Literal placeholder-like text such as {0} must also be escaped by doubling the braces.
• Manual string formatting works for simple output, but serializers are safer for structured data such as JSON.
• Similar-looking brace syntax in logging frameworks may follow different rules than string.Format.