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(, );

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

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(, val);

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

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:

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 = .Format(, );

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

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.

• 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}.