C# String Manipulation: Practical Tips & Common Mistakes for Beginners

Date: Jul 27, 2024
Reading Time: ~7 minutes
Video Tutorial Available on Bilibili

Most developers interact with strings every single day. But do you really understand how strings work, and can you pick the most efficient way to solve real-world problems? In this article, we’ll go over some useful tips and common mistakes when working with C# strings.

C#’s Powerful String-Related Classes

C# offers a variety of classes for string operations:

• string
• StringBuilder
• Encoding
• Regex

They are very powerful, but this can also lead to misunderstandings about their usage. You might be unaware of certain method overloads or performance issues, which can result in inefficient code (often without you even noticing). This post highlights practical tips and pitfalls in C# string manipulation to help you write more efficient and maintainable code.

When You Can Use a char, Don’t Use a string

In C#, there’s a typical distinction in syntax between a char (single quotes) and a string (double quotes). Beyond syntax, they are fundamentally different. A string is a reference type, allocated on the heap, whereas a char is a value type stored on the stack. Because of this, a char is generally more performant than a string.

It’s important not to think of a char simply as a string of length 1. In many C# string methods, there are overloads that accept a char instead of a string. For example:

1
2
3
4
5
6
7

string str = "Hello, World!";

str.StartsWith('H');
str.EndsWith('!');
str.Contains('o');
str.IndexOf('o');
str.Split(',');

These methods accept char parameters, which can help improve performance. Think about how Contains might be implemented under the hood: if you pass a string, even if it’s length 1, the method still treats it as a substring. That involves additional checks and possible overhead for matching a multi-character sequence. Passing a single char avoids that overhead.

Use Overloaded Methods to Reduce Unnecessary Calls

Many string operations have multiple overloads. Using them appropriately can help you reduce extra calls and resource waste. Consider the following examples:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

string str = "  Hello, World,, Good, Morning ";

// We want to split on commas and remove empty entries:
var slices = str.Split(',', StringSplitOptions.RemoveEmptyEntries);

// If you're not aware of this overload, you might do:
var slicesLegacy = str.Split(',')
                      .Where(s => !string.IsNullOrEmpty(s))
                      .ToArray();

// Similarly, if we want to trim each split segment:
var slicesTrimmed = str.Split(',', StringSplitOptions.TrimEntries);

// Without this overload, you might write:
var slicesTrimmedLegacy = str.Split(',')
                             .Select(s => s.Trim())
                             .ToArray();

Each extra call (Where, Select, etc.) can introduce additional overhead.

Another common example: comparing two strings in a case-insensitive manner. A naive approach might be:

1
2
3
4

if (s1.ToLower() == s2.ToLower())
{
    // ...
}

A better way is to use the Equals overload:

1
2
3
4

if (s1.Equals(s2, StringComparison.OrdinalIgnoreCase))
{
    // ...
}

This avoids creating new lowercase strings and does a more efficient comparison.

String Constructors

Most developers create strings by assigning a literal or calling various instance methods, for example:

1
2
3
4
5

string str = "Hello, World!";
string str2 = str.Substring(0, 5);
string str3 = str.Replace(",", " ");

But string also has several constructors that can come in handy. For instance, if you’ve used Python, you might be familiar with ‘=’ * 20 to quickly create a string of repeated characters. In C#, the equivalent is:

1
2

string sep = new string('=', 20);
Console.WriteLine(sep);

You can also create a string from a char array:

1
2
3

char[] chars = str.ToCharArray();
Array.Reverse(chars);
string reversed = new string(chars);

This is often the most efficient way to reverse a string without using Span or unsafe code. Less efficient approaches might look like:

1

string reversed = string.Join("", str.Reverse());

OS-Specific Methods & Considerations

Due to differences between Windows and Unix systems, there are two major pain points: line endings and path separators. 1. Line Endings: • Windows: \r\n (CRLF) • Unix: \n (LF) 2. Path Separators: • Windows:
• Unix: /

Use Path.Combine for Directory Paths

When building file paths, use the Path class. It automatically handles path separators based on the current OS:

1
2
3
4
5

var folder = "MyFolder";
var subfolder = "MySubFolder/";
var filename = "MyFile.txt";

var path = Path.Combine(folder, subfolder, filename);

Path.Combine also takes care of normalizing paths (e.g., removing redundant / or \ characters).

Use Environment.NewLine for Line Endings

To handle line endings, you can use Environment.NewLine, which returns the newline sequence for the current OS. For instance:

1
2
3
4
5
6
7

var lines = new string[]
{
    "Hello, World!",
    "Good, Morning!"
};

var text = string.Join(Environment.NewLine, lines);

Tip: You can also rely on built-in .NET methods that handle line endings automatically, such as File.ReadAllLines(), File.WriteAllLines(), Console.WriteLine(), etc.

.NET 6 ReplaceLineEndings

.NET 6 introduced ReplaceLineEndings, which converts all line endings in a string to a specified string (defaulting to the current OS’s newline):

1
2
3
4
5
6
7
8

var text = "Hello, World!\r\nGood morning!\nGood night!";

// Use the OS default line ending
var normalized = text.ReplaceLineEndings();

// Or specify a custom replacement
var unixNormalized = text.ReplaceLineEndings("\n");
var tabNormalized = text.ReplaceLineEndings("\t");

A Few StringBuilder Tricks

StringBuilder is a well-known class for efficient concatenation of large or frequently modified strings, but you may not be aware of all its features. Below are a few highlights:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

var sb = new StringBuilder();

// Add strings
sb.Append("Hello, World!");
sb.AppendLine("Hello, World!");
sb.AppendFormat("Hello, {0}!", "World");
sb.Append('H', 5); // Append 5 'H' characters

sb.Insert(0, "Hello, ");   // Insert at index 0
sb.Replace("Hello", "Good"); // Replace text
sb.Remove(0, 5); // Remove text starting at index 0
sb.Clear(); // Clear the StringBuilder

sb.ToString(); // Convert to a regular string
sb.ToString(0, 5); // Convert a substring to a regular string

Note that ToString(int startIndex, int length) can reduce extra allocations if you only need part of the content.

Embrace Syntax Sugar with String Interpolation

C# 6 introduced string interpolation, a convenient syntax for string concatenation, allowing you to embed expressions directly into string literals:

1
2
3
4
5
6
7

var name = "World";
var age = 18;

var str = $"Hello, {name}! You are {age} years old.";

// Before string interpolation, you might write:
var strOld = string.Format("Hello, {0}! You are {1} years old.", name, age);

String interpolation is also faster than string.Format. Even with StringBuilder, interpolation can be more readable than AppendFormat, but note that calling Append repeatedly might still yield the best performance in tight loops:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

var id = 123;
var name2 = "World";
var age2 = 18;

var sb = new StringBuilder();

// Using AppendFormat
sb.AppendFormat("ID: {0}, Name: {1}, Age: {2}", id, name2, age2);

// Using string interpolation
sb.Append($"ID: {id}, Name: {name2}, Age: {age2}");

// Using consecutive Append calls
sb.Append("ID: ")
.Append(id)
.Append(", Name: ")
.Append(name2)
.Append(", Age: ")
.Append(age2);

conclusion

We’ve covered several practical tips for C# string operations: • Prefer char over string where applicable. • Use method overloads that reduce unnecessary calls (e.g., Split with StringSplitOptions, Equals with StringComparison, etc.). • Take advantage of string constructors, especially for repeating characters or creating strings from character arrays. • Use platform-aware approaches like Path.Combine and Environment.NewLine. • Leverage StringBuilder efficiently, knowing its handy features. • Embrace string interpolation for more readable and often faster string assembly.

There are many other string-related features in C#, such as raw string literals, StringPool and string.Intern, Span, and various encoding classes. But hopefully, this article has given you insight into some of the most common pitfalls and best practices, helping you write more efficient and readable code when working with strings.