C# Verbatim Strings

In C#, there are several ways to represent string data. One particularly useful string format is the verbatim string. As you progress in your C# journey, understanding verbatim strings will help you write cleaner, more readable code—especially when dealing with certain types of text data.

What Are Verbatim Strings?

A verbatim string is a special kind of string literal in C# that is prefixed with the @ symbol. The key feature of verbatim strings is that they take the characters exactly as they are typed, ignoring escape sequences that would normally be processed in regular strings.

This means:

• Backslashes (\) are treated as literal characters, not as the start of an escape sequence
• String content can span multiple lines without requiring special characters
• Tabs and other whitespace are preserved exactly as written

Basic Syntax

Here's the basic syntax for creating a verbatim string:

csharp

@"This is a verbatim string"

Regular Strings vs. Verbatim Strings

Let's compare regular strings with verbatim strings to understand the differences:

csharp

// Regular string - escape sequences are processed
string regularPath = "C:\\Program Files\\MyApp\\Data";

// Verbatim string - backslashes are treated as literal characters
string verbatimPath = @"C:\Program Files\MyApp\Data";

Console.WriteLine(regularPath);  // Output: C:\Program Files\MyApp\Data
Console.WriteLine(verbatimPath); // Output: C:\Program Files\MyApp\Data

As you can see, both approaches result in the same output, but the verbatim string is cleaner and easier to read.

Working with Special Characters

Newlines in Verbatim Strings

One of the most convenient features of verbatim strings is the ability to include newlines directly:

csharp

string regularMultiline = "Line 1\nLine 2\nLine 3";

string verbatimMultiline = @"Line 1
Line 2
Line 3";

Console.WriteLine(regularMultiline);
Console.WriteLine("---");
Console.WriteLine(verbatimMultiline);

Output:

Line 1
Line 2
Line 3
---
Line 1
Line 2
Line 3

Including Quotes in Verbatim Strings

To include double quotes in a verbatim string, you need to double them:

csharp

// Regular string with quotes
string regularQuotes = "He said, \"Hello, world!\"";

// Verbatim string with quotes
string verbatimQuotes = @"He said, ""Hello, world!""";

Console.WriteLine(regularQuotes);  // Output: He said, "Hello, world!"
Console.WriteLine(verbatimQuotes); // Output: He said, "Hello, world!"

Practical Applications

1. File Paths

Verbatim strings are ideal for file paths, especially on Windows where backslashes are used:

csharp

// Without verbatim strings - messy with escape characters
string filePath = "C:\\Users\\Username\\Documents\\Projects\\MyProject\\data.txt";

// With verbatim strings - much cleaner
string verbatimFilePath = @"C:\Users\Username\Documents\Projects\MyProject\data.txt";

// Using the path in code
try 
{
    string content = File.ReadAllText(verbatimFilePath);
    Console.WriteLine($"File content: {content}");
}
catch (Exception ex)
{
    Console.WriteLine($"Error reading file: {ex.Message}");
}

2. Regular Expressions

Regular expressions often contain many backslashes, making verbatim strings particularly useful:

csharp

using System.Text.RegularExpressions;

// Without verbatim strings - hard to read
string emailPattern = "\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}\\b";

// With verbatim strings - much clearer
string verbatimEmailPattern = @"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b";

string text = "Contact us at [email protected] or [email protected].";
Regex regex = new Regex(verbatimEmailPattern);

MatchCollection matches = regex.Matches(text);
Console.WriteLine("Found email addresses:");
foreach (Match match in matches)
{
    Console.WriteLine(match.Value);
}

Output:

Found email addresses:
[email protected]
[email protected]

3. SQL Queries

When embedding SQL queries in your C# code, verbatim strings help maintain readability:

csharp

// Without verbatim strings - awkward line breaks and escaping
string query = "SELECT Products.ProductName, Categories.CategoryName " +
               "FROM Products " +
               "INNER JOIN Categories ON Products.CategoryID = Categories.CategoryID " +
               "WHERE Products.UnitPrice > 50 " +
               "ORDER BY Products.UnitPrice DESC";

// With verbatim strings - preserves formatting and readability
string verbatimQuery = @"
SELECT Products.ProductName, Categories.CategoryName 
FROM Products 
INNER JOIN Categories ON Products.CategoryID = Categories.CategoryID 
WHERE Products.UnitPrice > 50 
ORDER BY Products.UnitPrice DESC";

Console.WriteLine("SQL Query:");
Console.WriteLine(verbatimQuery);

4. JSON or XML Templates

When working with structured data formats like JSON or XML:

csharp

string jsonTemplate = @"{
    ""name"": ""John Doe"",
    ""age"": 30,
    ""isStudent"": false,
    ""courses"": [
        ""C# Programming"",
        ""Web Development"",
        ""Database Design""
    ],
    ""address"": {
        ""street"": ""123 Main St"",
        ""city"": ""Anytown"",
        ""zipCode"": ""12345""
    }
}";

Console.WriteLine("JSON Template:");
Console.WriteLine(jsonTemplate);

Combining Verbatim Strings with String Interpolation

In C# 8.0 and later, you can combine verbatim strings with string interpolation using the $@ or @$ prefix:

csharp

string name = "John";
int age = 30;

// Using string interpolation with verbatim strings
string message = $@"User Profile:
Name: {name}
Age: {age}
Path: C:\Users\{name}\Documents";

Console.WriteLine(message);

Output:

User Profile:
Name: John
Age: 30
Path: C:\Users\John\Documents

Performance Considerations

Verbatim strings and regular strings have identical performance characteristics at runtime. The difference is purely syntactic and affects only how the compiler interprets the string literals. The resulting string objects are identical regardless of how they were created.

Summary

C# verbatim strings, prefixed with the @ symbol, offer a cleaner and more readable way to work with:

• File paths with backslashes
• Multiline strings
• Regular expressions
• SQL queries
• JSON, XML, or other formatted text

They preserve whitespace and newlines exactly as written and treat backslashes as literal characters rather than escape sequence initiators. The only special case is the double quote character, which must be doubled ("") within verbatim strings.

When working with complex strings, especially those containing many backslashes or spanning multiple lines, verbatim strings can make your code significantly more readable and maintainable.

Exercises

1. Create a verbatim string representing a nested directory structure with at least 3 levels.
2. Write a program that uses verbatim strings to create a simple ASCII art drawing that spans multiple lines.
3. Create a verbatim string containing a complex regular expression for validating phone numbers.
4. Write a SQL query using verbatim strings that joins at least three tables.
5. Convert the following regular string to a verbatim string:
   csharp

   string path = "C:\\Users\\Public\\Documents\\Sample\\file.txt";

Additional Resources

• Microsoft Documentation on String Literals
• C# String Interpolation
• Working with Regular Expressions in C#

Happy coding with C# verbatim strings!