C# - Common String Methods - Part 2

Common String Methods Part 2 in C# 

Introduction

In the first part of this series, we explored many foundational string methods such as Substring, IndexOf, Replace, and others. This second part dives deeper into more advanced and less commonly discussed methods of the System.String class, as well as important related functionality in string manipulation. Mastery of these methods will enhance your ability to handle complex text processing tasks efficiently in C#.

Overview of Topics Covered in Part 2

• Compare() and CompareTo()
• Equals() Method
• IsNullOrEmpty() and IsNullOrWhiteSpace()
• PadLeft() and PadRight()
• Remove() Method
• Insert() Method
• Normalize() Method
• ToCharArray() Method
• String interpolation and formatting methods
• Performance considerations

Compare() and CompareTo() Methods

Compare()

The static String.Compare() method compares two strings and returns an integer indicating their relative position in the sort order.

Return values:

• < 0: strA is less than strB
• 0: strings are equal
• > 0: strA is greater than strB

Example:

int result = String.Compare("apple", "banana");  // result < 0 since "apple" < "banana"
int resultIgnoreCase = String.Compare("apple", "APPLE", StringComparison.OrdinalIgnoreCase);  // 0 (equal ignoring case)
  

StringComparison enumeration allows fine control of comparison rules, such as culture-aware or ordinal comparisons.

CompareTo()

Instance method CompareTo() compares the current string to another string, returning the same type of integer result as Compare().

string a = "cat";
string b = "dog";
int compare = a.CompareTo(b);  // < 0 because "cat" < "dog"
  

Equals() Method

The Equals() method compares two strings for equality. It has several overloads, allowing you to specify case sensitivity and culture rules.

Example:

string s1 = "Hello";
string s2 = "hello";

bool equal1 = s1.Equals(s2);  // false (case sensitive)
bool equal2 = s1.Equals(s2, StringComparison.OrdinalIgnoreCase);  // true
  

Unlike the == operator, Equals() provides more overloads and control over comparison options.

IsNullOrEmpty() and IsNullOrWhiteSpace()

IsNullOrEmpty()

This static method checks if a string is either null or empty ("").

string s1 = null;
string s2 = "";
string s3 = " ";

bool check1 = String.IsNullOrEmpty(s1);  // true
bool check2 = String.IsNullOrEmpty(s2);  // true
bool check3 = String.IsNullOrEmpty(s3);  // false, because s3 contains a space
  

IsNullOrWhiteSpace()

This method extends IsNullOrEmpty() by returning true if the string is null, empty, or consists only of whitespace characters.

string s4 = "   ";

bool check4 = String.IsNullOrWhiteSpace(s4);  // true
  

These methods are invaluable for input validation and cleaning user inputs.

PadLeft() and PadRight() Methods

These methods add padding characters to the left or right of a string until it reaches a specified total length.

Usage:

string str = "123";
string paddedLeft = str.PadLeft(5, '0');   // "00123"
string paddedRight = str.PadRight(5, '*'); // "123**"
  

If the original string is already longer than the specified length, it is returned unchanged.

Remove() Method

Removes characters from a string starting at a specified index, optionally for a specified count.

Overloads:

• Remove(int startIndex): removes from startIndex to the end.
• Remove(int startIndex, int count): removes count characters starting from startIndex.

Example:

string original = "Hello World!";
string removed1 = original.Remove(5);       // "Hello"
string removed2 = original.Remove(5, 6);    // "Hello!"
  

Insert() Method

Inserts a string at a specified index into the current string.

Example:

string baseStr = "Hello!";
string inserted = baseStr.Insert(5, " World");   // "Hello World!"
  

The index must be between 0 and the length of the string (inclusive), otherwise an ArgumentOutOfRangeException is thrown.

Normalize() Method

The Normalize() method converts a string to a specified Unicode normalization form, which is essential when comparing strings containing accented characters or composed/uncomposed characters.

Normalization Forms:

• FormC: Canonical Composition
• FormD: Canonical Decomposition
• FormKC: Compatibility Composition
• FormKD: Compatibility Decomposition

Example:

string accented = "e\u0301";    // 'e' + combining acute accent
string normalized = accented.Normalize(NormalizationForm.FormC);
bool areEqual = normalized == "\u00E9";  // true, 'é' as single character
  

ToCharArray() Method

Converts the string into an array of characters, enabling iteration or manipulation of individual characters.

Example:

string greeting = "Hi!";
char[] chars = greeting.ToCharArray();

foreach(char c in chars) {
    Console.WriteLine(c);
}
// Output:
// H
// i
// !
  

String Interpolation and Formatting

Although not a method of String itself, string interpolation and formatting are essential for dynamic string creation.

String Interpolation

Introduced in C# 6.0, string interpolation provides an easy-to-read syntax to embed expressions inside string literals.

string name = "Alice";
int age = 30;
string greeting = $"Hello, {name}. You are {age} years old.";
// Output: "Hello, Alice. You are 30 years old."
  

String.Format()

The static method String.Format() formats strings using placeholders.

string formatted = String.Format("Hello, {0}. Today is {1:D}.", name, DateTime.Now);
// Output example: "Hello, Alice. Today is Sunday, May 24, 2025."
  

Performance Considerations

Since strings are immutable, every operation that changes a string produces a new string object, which can impact memory and CPU performance when done excessively inside loops or large-scale text processing.

To optimize, use StringBuilder when performing many concatenations or manipulations, and prefer methods that avoid unnecessary string copies. Always be mindful of the trade-offs between readability, maintainability, and performance.

Summary Table of Part 2 Methods