How to Escape Curly Braces in C# and .NET Format Strings

By the end of this page, you will understand how .NET composite formatting works, why curly braces have special meaning in string.Format, and how to output literal { and } characters by escaping them correctly with doubled braces.

In .NET, string.Format uses composite formatting. Inside the format string, curly braces define placeholders where values should be inserted.

A placeholder looks like this:

"{0}"

Here, 0 means: use the first argument passed after the format string.

For example:

string name = "Alice";
string message = string.Format("Hello, {0}", name);
// Hello, Alice

Curly braces are therefore not treated as normal characters. They are part of the formatting syntax.

To include a literal brace in the output, you must escape it by doubling it:

• {{ outputs {
• }} outputs }

Example:

string result = string.Format("Value: {{ {0} }}", 42);
// Value: { 42 }

This matters because many real programs generate text with braces, such as:

• JSON-like snippets
• template output
• log messages
• configuration text
• code generation

If you forget that braces have special meaning in format strings, you may get incorrect output or a FormatException.

Think of a format string as a sentence with instruction markers.

• {0} means: "insert the first value here"
• {1} means: "insert the second value here"
• {{ means: "I really want a literal { character"
• }} means: "I really want a literal } character"

So braces have two possible roles:

1. Formatting commands like {0}
2. Literal characters when escaped as {{ and }}

It is similar to using a reserved symbol in a programming language. Because { and } already mean something special, you must explicitly tell .NET when you want them printed as plain text.

The basic syntax of string.Format is:

string.Format("text {0} more text", value0);

Insert a value

string name = "Sam";
string result = string.Format("Hello, {0}", name);
// Hello, Sam

Output literal braces

string result = string.Format("{{Hello}}") ;
// {Hello}

Output braces around a formatted value

string val = "1,2,3";
string result = string.Format("foo {{{0}}}", val);
// foo {1,2,3}

Why this works

• {{ becomes a literal {
• {0} inserts the first argument, which is val
• }} becomes a literal }

So this format string:

"foo {{{0}}}"

is interpreted as:

• print foo
• print {
• insert argument 0
• print }

Multiple placeholders

string first = "A";
string second = "B";
string result = string.Format("Items: {{ {0}, {1} }}", first, second);
// Items: { A, B }

Using interpolation in modern C#

If you are using string interpolation, braces still need escaping the same way:

string val = "1,2,3";
string result = $"foo {{{val}}}";
// foo {1,2,3}

The rule is the same: doubled braces produce literal braces.

Consider this example:

string val = "1,2,3";
string result = string.Format("foo {{{0}}}", val);

Here is what happens step by step:

1. val is assigned the string "1,2,3".
2. .NET reads the format string: "foo {{{0}}}".
3. It sees foo and copies that directly to the output.
4. It sees {{ and treats it as a literal {.
5. It sees {0} and replaces it with the first argument after the format string, which is val.
6. It sees }} and treats it as a literal }.
7. The final result becomes:

foo {1,2,3}

Now compare that with this code:

string result = string.Format("foo {{0}}", val);

Step by step:

1. foo is copied as normal text.
2. {{ becomes a literal {.
3. 0 is just the character 0 because it is no longer inside a formatting placeholder.
4. }} becomes a literal }.
5. Final output:

foo {0}

That is why your original example prints {0} literally instead of substituting the value.

Escaping braces in format strings is useful whenever you need both:

• formatted values, and
• literal brace characters in the output

Common scenarios

Logging structured-looking messages

string user = "alice";
string log = string.Format("User data: {{ Name: {0} }}", user);
// User data: { Name: alice }

Building JSON-like text manually

string id = "123";
string jsonLike = string.Format("{{ \"id\": \"{0}\" }}", id);
// { "id": "123" }

In real applications, use a JSON serializer instead of manually building JSON when possible.

Generating templates or code snippets

string methodName = "Print";
string code = string.Format("public void {0}() {{ }}", methodName);
// public void Print() { }

Displaying placeholder examples to users

string text = string.Format("Use the token {{username}} to insert the user name.");
// Use the token {username} to insert the user name.

In real codebases, developers often combine formatting with readability and safety.

Common patterns

1. Wrapping values in visible delimiters

string env = "prod";
string message = string.Format("Running in {{ {0} }} environment", env);

This is useful in logs or debugging output.

2. Building messages with named-looking tokens

string tokenHelp = string.Format("Available token: {{orderId}}");

This is common in email templates, configuration systems, or documentation text.

3. Guarding against malformed format strings

If the string contains unbalanced braces, .NET can throw FormatException.

try
{
    string message = string.Format("Value: {0", 10);
}
catch (FormatException ex)
{
    Console.WriteLine(ex.Message);
}

4. Preferring interpolation for readability

In modern C#, developers often use string interpolation instead of string.Format for simple cases:

string val = "1,2,3";
string result = $"foo {{{val}}}";

This is easier to read than numbered placeholders.

5. Avoiding manual string construction for structured formats

If you are producing JSON, XML, or SQL, developers usually avoid hand-built strings when tools exist:

• use serializers for JSON/XML
• use parameters for SQL
• use templates for larger text generation

Escaped braces are useful, but they should not replace safer abstractions.

1. Escaping the placeholder itself by accident

Broken code:

string val = "1,2,3";
string result = string.Format("foo {{0}}", val);
// foo {0}

Why it happens:

• {{ and }} escape the braces
• so {0} never becomes a placeholder

Correct code:

string result = string.Format("foo {{{0}}}", val);
// foo {1,2,3}

2. Forgetting to escape literal braces

Broken code:

string result = string.Format("foo { {0} }", 10);

This may throw a FormatException because the braces are not valid formatting syntax.

Correct code:

string result = string.Format("foo {{ {0} }}", 10);
// foo { 10 }

3. Mismatching placeholder indexes

Broken code:

string result = string.Format("{1}", "only one value");

This can throw an exception because argument index 1 does not exist.

Correct code:

string result = string.Format("{0}", "only one value");

4. Using string.Format when no formatting is needed

Unnecessary:

string text = string.Format("{{hello}}");

Simpler:

string text = "{hello}";

If there are no placeholders, plain string literals are often clearer.

5. Confusing string.Format with string interpolation

In interpolation, the syntax changes slightly:

string name = "Sam";
string result = $"Hello, {name}";

But literal braces still require doubling:

string result = $"{{Hello}}";
// {Hello}

string.Format vs interpolation

string name = "Mia";

string a = string.Format("Hello, {0}", name);
string b = $"Hello, {name}";

Both produce the same result.

When to use string.Format

• when working with older code
• when a format string is stored separately
• when using APIs that expect composite formatting

When to use interpolation

• in most new C# code
• when readability matters
• when expressions are simple

Escaped braces in both styles

string name = "Mia";

string a = string.Format("{{{0}}}", name); // {Mia}
string b = $"{{{name}}}";                  // {Mia}

Quick rules

• {0} = insert first argument
• {1} = insert second argument
• {{ = literal {
• }} = literal }

Common examples

string.Format("{0}", 5);           // 5
string.Format("{{0}}");            // {0}
string.Format("{{{0}}}", 5);       // {5}
string.Format("{{ {0} }}", 5);     // { 5 }

Remember

• If you escape the braces around 0, then 0 is treated as plain text.
• To print braces around a formatted value, use:

"{{{0}}}"

Interpolation equivalents

$"{value}"      // inserts value
$"{{value}}"    // prints {value}
$"{{{value}}}"  // prints value inside braces

Edge cases

• Unmatched braces can cause FormatException
• Wrong placeholder indexes can cause FormatException
• If no formatting is needed, use a normal string instead of string.Format

How do I print { and } in string.Format?

Use doubled braces:

"{{" // {
"}}" // }

Why does string.Format("{{0}}", value) print {0}?

Because {{ and }} escape the braces, so 0 is treated as regular text instead of a placeholder.

How do I output {value} with formatting in C#?

Use:

string.Format("{{{0}}}", value)

Does string interpolation use the same brace escaping rule?

Yes. In interpolated strings, literal braces are also escaped with doubled braces.

What exception happens if the format string is invalid?

Usually .NET throws a FormatException if the braces are malformed or placeholder indexes are wrong.

Should I use string.Format or $"..." in modern C#?

For most new code, string interpolation is easier to read. string.Format is still useful in older code and APIs based on composite formatting.

Can I write JSON manually with string.Format?

You can, but in real applications it is better to use a JSON serializer for correctness and safety.

• String interpolation — Modern C# syntax for inserting values into strings.
• Composite formatting — The underlying .NET formatting system used by string.Format.
• FormatException — The exception thrown when a format string is invalid.
• String literals — Useful for understanding when braces need escaping and when they do not.
• Escape sequences — Related idea of representing special characters inside strings.
• Numeric and date formatting — Often used together with placeholders such as {0:N2} or {0:yyyy-MM-dd}.