String manipulation in C# and .NET: The complete guide

Introduction

Strings are one of the most frequently used data types in C#. Whether you’re developing a small utility or a complex enterprise application, string manipulation plays a crucial role.

This article will cover the essential techniques and best practices for working with strings in C#. From basic operations to advanced topics, we’ve got you covered.

Topics covered

String basics in C#
String immutability
String concatenation
String interpolation
String comparison
Substrings and searching
Replacing and removing characters
Splitting and joining Strings
StringBuilder for efficient manipulation
Regular Expressions
Encoding and Decoding Strings
Performance considerations

String basics in C#

Strings in C# are sequences of characters and are represented by the System.String class. Strings are immutable, meaning once created, they cannot be changed.

string greeting = "Hello, World!";<br>Console.WriteLine(greeting); 
// Output: Hello, World!

String immutability

In C#, strings are immutable. Any operation that appears to modify a string actually creates a new string.

string original = "Hello";
string modified = original + ", World!";
Console.WriteLine(original); // Output: Hello
Console.WriteLine(modified); // Output: Hello, World!

String concatenation

You can concatenate strings using the + operator or the String.Concat method.

string firstName = "John";
string lastName = "Doe";
string fullName = firstName + " " + lastName;
Console.WriteLine(fullName); 
// Output: John Doe

// Using String.Concat
string fullNameConcat = string.Concat(firstName, " ", lastName);
Console.WriteLine(fullNameConcat); 
// Output: John Doe

String interpolation

String interpolation is a modern and readable way to build strings.

string name = "Alice";
int age = 30;
string message = $"My name is {name} and I am {age} years old.";

Console.WriteLine(message); 
// Output: My name is Alice and I am 30 years old.

String comparison

C# provides several methods to compare strings, including case-sensitive and case-insensitive comparisons.

string str1 = "hello";
string str2 = "Hello";

// Case-sensitive comparison
bool isEqual = str1 == str2;
Console.WriteLine(isEqual); // Output: False

// Case-insensitive comparison
bool isEqualIgnoreCase = string.Equals(str1, str2, StringComparison.OrdinalIgnoreCase);
Console.WriteLine(isEqualIgnoreCase); 
// Output: True

Substrings and searching

You can extract parts of a string using the Substring method or find substrings using methods like IndexOf and Contains.

string text = "C# is awesome!";

// Extract substring
string substring = text.Substring(3, 2);
Console.WriteLine(substring); // Output: is

// Search for a substring
bool contains = text.Contains("awesome");
Console.WriteLine(contains); // Output: True

int position = text.IndexOf("awesome");
Console.WriteLine(position); // Output: 5

Replacing and removing characters

The Replace and Remove methods are useful for modifying strings.

string sentence = "I love C# programming.";

// Replace
string updated = sentence.Replace("C#", "JavaScript");
Console.WriteLine(updated); 
// Output: I love JavaScript programming.

// Remove
string shortened = sentence.Remove(7, 3);
Console.WriteLine(shortened); 
// Output: I love programming.

Splitting and joining Strings

You can split a string into an array or join an array into a string.

string data = "apple,banana,orange";

// Split
string[] fruits = data.Split(',');
foreach (var fruit in fruits)
{
    Console.WriteLine(fruit);
}

// Join
string joined = string.Join(" | ", fruits);
Console.WriteLine(joined); 
// Output: apple | banana | orange

StringBuilder for efficient manipulation

For heavy string operations, use StringBuilder for better performance.

using System.Text;

StringBuilder sb = new StringBuilder();
sb.Append("Hello");
sb.Append(", ");
sb.Append("World!");
Console.WriteLine(sb.ToString()); 
// Output: Hello, World!

Regular Expressions

Regular expressions are powerful for pattern matching and text extraction.

using System.Text.RegularExpressions;

string input = "Contact: 123-456-7890";
string pattern = "\d{3}-\d{3}-\d{4}";

Match match = Regex.Match(input, pattern);
if (match.Success)
{
    Console.WriteLine(match.Value); // Output: 123-456-7890
}

Encoding and Decoding Strings

You can convert strings to and from byte arrays using encodings.

using System.Text;

string text = "Hello, World!";

// Encode
byte[] bytes = Encoding.UTF8.GetBytes(text);

// Decode
string decoded = Encoding.UTF8.GetString(bytes);
Console.WriteLine(decoded); // Output: Hello, World!

Performance considerations

String operations can impact performance due to immutability. Use StringBuilder for frequent modifications and prefer string.Concat over the + operator in loops.

Conclusion

Mastering string manipulation in C# is essential for writing efficient and maintainable code.

By understanding these techniques, you’ll be better equipped to handle text data in your applications.

Explore these methods and choose the right tools for your use cases!