Escaping characters in C# strings
Tags: dotnet, csharp, beginners
Published: 2021-04-18 18:44:18

In this article, we look at escaping characters in C# strings.
But what is escaping, you may wonder?
That's how we write special characters or characters that would otherwise be impossible to include in a string, like `"`.

This article is part of a **learn programming** series where you need **no prior knowledge of programming**.
If you want to **learn how to program** and want to learn it **using .NET/C#**, this is the right place.
I suggest reading the whole series in order, starting with [Creating your first .NET/C# program](https://dev.to/carlhugom/creating-your-first-net-c-program-1poj), but that's not mandatory.

> This article is part of a sub-series, starting with [Introduction to string concatenation](https://www.forevolve.com/en/articles/2021/03/21/learn-coding-with-dot-net-core-part-6/).
> It is not mandatory to read all articles in order, but I strongly recommend it, especially if you are a beginner.
> If you are already reading the whole series in order, please discard this word of advice.

## Escaping characters

As mentioned in the introduction, the action of escaping characters means you write an "escape sequence" to represent specific characters.
An escape sequence starts with a `\`. It is followed by a character or a series of numbers representing the Unicode character code.

Here are a few examples:

```csharp
using System;

var quotes = "Wrap \"a few words\" with quotes.";
var newLine = "Add a\nnew line.";
var tab = "\tAdd a tab at the begining of the string.";
var e = "This is the letter e: \u0065";

Console.WriteLine(quotes);
Console.WriteLine(newLine);
Console.WriteLine(tab);
Console.WriteLine(e);
```

When we run the previous code, we obtain the following result:

![Code sample's console output](//cdn.forevolve.com/blog/images/2021/2021-04-output-escaped-characters.png)

If we take a closer look:

-   We can write `\"` to insert a `"` character inside a string, which would be impossible otherwise.
-   We can use the special `\n` to insert a new line (see below for more special characters).
-   We can use the special `\t` to insert a horizontal tab (see below for more special characters).
-   We can use the Unicode representation of a character, prefixed by `\u`, to insert that character into a string (UTF-16 or UTF-32).

In my opinion, the most helpful special characters are:

| Escape sequence | Character name                                        | Example                                                                            |
| --------------- | ----------------------------------------------------- | ---------------------------------------------------------------------------------- |
| `\'`            | Single quote                                          | Not related to `string` but to `char`, like <br>`var q = '\'';` (not covered yet). |
| `\"`            | Double quote                                          | See preceding example.                                                             |
| `\\`            | Backslash                                             | `var s = "c:\\folder\\some-file.ext";`                                             |
| `\n`            | New line                                              | See preceding example.                                                             |
| `\r`            | Carriage return                                       | Read the OS specific line break section                                            |
| `\t`            | Horizontal tab                                        | See preceding example.                                                             |
| `\u0000`        | Unicode escape sequence (UTF-16)                      | To write the character `e`: `\u0065`                                               |
| `\U00000000`    | Unicode escape sequence (UTF-32)                      | To write the character `e`: `\U00000065`                                           |
| `\x0[0][0][0]`  | Unicode escape sequence (UTF-16) with variable length | To write the character `e`: `\x65`                                                 |

> See [String Escape Sequences](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/strings/#string-escape-sequences) for some more characters.

Next, we explore line break.

## Platforms-specific line break

In case you did not know, Windows line breaks are different from Unix-based platforms.
Windows uses a sequence of both _carriage return_ and _new line_ (`\r\n`) while Unix uses only a _new line_ (`\n`).
Windows is pretty forgiving and will most likely understand `\n`.
Nevertheless, in a cross-platform app targeting both Windows and Unix (e.g., Linux and Mac), do you really want to leave line breaks to chance?
To save the day, we can use the `Environment.NewLine` property instead, which adapts to the current OS.

Here is an example (same output as the `newLine` variable of the preceding example):

```csharp
using System;
Console.WriteLine($"Add a{Environment.NewLine}new line."); // We leveraged interpolation here
```

If we have many line breaks, this can become tedious.
Hopefully, we can simplify this by leveraging the `string.Format` method we cover next.

## string.Format

We can use the `string.Format` method to format a string.
It is similar to interpolation, but instead of inserting the variables directly, we need to define numerical tokens, like `{0}`, `{1}`, `{2}`, and so forth.
Then, we pass arguments that match those tokens in the correct order to get the final result.

Many other .NET methods allow such a construct, including `Console.WriteLine`.
Here is an example of both `string.Format` and `Console.WriteLine`:

```csharp
using System;
var newLine = string.Format("Add a{0}new line.", Environment.NewLine);
Console.WriteLine(newLine);
Console.WriteLine("Add a{0}new line.", Environment.NewLine);
```

When running the code, both `Console.WriteLine` output the same result.
The advantage here is writing `{0}` every time we need a line break.
Of course, we could use interpolation with `{Environment.NewLine}` directly, but it makes the string longer.
Even worst, we could use concatenation like `"Add a" + Environment.NewLine + "new line."`; I find this to be the hardest code to read, making the string even longer.

**But how does that work?**
In the background, the framework replaces the numerical tokens with the specified arguments.

There are more to `string.Format`, including the possibility to format your values, but that's getting more and more out of the scope of our main subject.
Next, we look at escaping characters in interpolated strings.

## Interpolation-specific escaping

In an interpolated string, we use the characters `{` and `}` to wrap the element to insert, like a variable.
What if we want to write those characters?
It is as easy as doubling them.
For `{`, we write `{{`.
For `}`, we write `}}`.

Here is an example:

```csharp
var name = "Darth Vader";
var greetings = $"{{Hello {name}}}";
Console.WriteLine(greetings);
```

As simple as that, the preceding code will output `{Hello Darth Vader}`.
Next, let's have a look at the verbatim identifier (a.k.a. multiline strings).

## The verbatim identifier

The verbatim identifier (`@`) allows us to write multiline strings, but it's not all.
It also disables the escaping of characters, which can be very handy when writing file paths (amongst other things).
In other words, a backslash is just a backslash, not a special character that starts an escape sequence.
For example, it is more convenient to write `var path = @"c:\folder\some-file.ext";` than `var path = "c:\\folder\\some-file.ext";` (simple vs double backslash).

**Since `\[character]` does not work, how can we escape `"`?**
Like with interpolation, we only have to double it, like `var v = @"Some ""quoted words"" here.";`

The verbatim identifier can also be used to escape reserved keywords, like `if`, `for`, `public`, etc.
For example, if you'd like to create a variable named `public`, you can't write `var public = "some value";` because this won't compile.
However, you could prefix your variable name with `@` to make it work, like this: `var @public = "some value";`.
Using this makes your code a little harder to read, but that's a trick that can come in very handy sometimes.

> **More info:** one place where it was handy was to create `class` attributes in an old ASP.NET MVC version because `class` is a reserved keyword: we had to escape it using the verbatim identifier.

> **Reference:** if you want to know more about reserved keywords, please visit the [C# Keywords](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/) page in the official documentation.

Next, it's your turn to try it out.

## Exercise

In this exercise, you will write a program that writes code.

Unfortunately, I was not able to recreate the exercise on this platform, so please look at the exercise on the original post [on my blog](https://www.forevolve.com/en/articles/2021/04/18/learn-coding-with-dot-net-core-part-8/#exercise). I'm sorry for the inconvenience.

## Conclusion

In this article, we explored the string type a little more.
We discovered that the backslash character (`\`) is used to escape characters or to create special characters like tabs (`\t`) and line breaks (`\r` and `\n`).
We then learned about the `Environment.NewLine` property that gives us the correct platforms-specific line break.
We also peaked at `string.Format` to format strings using numerical tokens instead of interpolation.

Afterward, we explored some edge cases to escape `{` and `}` in interpolated strings and `"` in multiline strings.
The solution was to double the characters; a.k.a. write `""` to obtain `"`.
We saw that in `@"..."` strings, the escape character (`\`) does not work, which is an advantage that can become a disadvantage.
We finally learned to use the verbatim identifier (`@`) to bypass the reserved keywords limitation and use it as an escape character for identifiers.

All in all, that's a lot of new content that concludes our introduction to strings mini-sub-series.

## Next step

It is now time to move to the next article: **Introduction to boolean algebra** which is coming soon. Stay tuned by following me on dev.to, [Twitter](https://twitter.com/CarlHugoM), or other places you can find me.
You can look at [my blog contact page](https://www.forevolve.com/contact/) for more info.