Split a string by another string in C#

How to Split a String by Another String in C#

Learn various methods to split a string using a delimiter string in C#, including String.Split, regular expressions, and custom approaches for advanced scenarios.

Splitting a string by a specific delimiter is a common operation in C# programming. While the String.Split method is powerful, its default behavior often involves splitting by character delimiters. This article explores how to effectively split a string by another string (a sequence of characters) in C#, covering standard library functions and more advanced techniques for complex requirements.

Using String.Split with StringSplitOptions

The most straightforward way to split a string by another string in C# is by using the String.Split method overload that accepts a string[] for delimiters and a StringSplitOptions enumeration. This allows you to specify one or more string delimiters and control how empty entries are handled.

string text = "apple<<>>banana<<>>cherry";
string delimiter = "<<>>";

// Split using a string array for delimiters
string[] parts = text.Split(new string[] { delimiter }, StringSplitOptions.None);

foreach (string part in parts)
{
    Console.WriteLine(part);
}

// Output:
// apple
// banana
// cherry

Splitting a string using a string delimiter and StringSplitOptions.None.

string textWithEmpty = "start<<>>middle<<>><<>>end";
string delimiter = "<<>>";

// Split and remove empty entries
string[] partsWithoutEmpty = textWithEmpty.Split(new string[] { delimiter }, StringSplitOptions.RemoveEmptyEntries);

foreach (string part in partsWithoutEmpty)
{
    Console.WriteLine(part);
}

// Output:
// start
// middle
// end

Using StringSplitOptions.RemoveEmptyEntries to clean up the result.

Splitting with Regular Expressions

For more complex splitting patterns, especially when the delimiter itself might be a pattern rather than a fixed string, regular expressions provide a powerful alternative. The Regex.Split method can handle intricate scenarios that String.Split might not.

flowchart TD
    A[Input String] --> B{"Delimiter Type?"}
    B -- Fixed String --> C[String.Split Method]
    B -- Pattern/Complex --> D[Regex.Split Method]
    C --> E[Resulting String Array]
    D --> E

Decision flow for choosing between String.Split and Regex.Split.

using System.Text.RegularExpressions;

string text = "item1---item2---item3";
string delimiterPattern = "---"; // The delimiter string

// Escape the delimiter if it contains regex special characters
string escapedDelimiter = Regex.Escape(delimiterPattern);

string[] parts = Regex.Split(text, escapedDelimiter);

foreach (string part in parts)
{
    Console.WriteLine(part);
}

// Output:
// item1
// item2
// item3

Splitting a string using Regex.Split with an escaped delimiter.

Performance Considerations

While both String.Split and Regex.Split are effective, their performance characteristics differ. For simple, fixed string delimiters, String.Split is generally faster as it avoids the overhead of regular expression parsing. Regex.Split becomes more efficient when the splitting logic is inherently complex and requires pattern matching.

Performance comparison: String.Split is faster for simple delimiters, Regex.Split for complex patterns.

For extremely performance-critical applications or very large strings, you might consider a manual approach using String.IndexOf and String.Substring in a loop. However, for most common scenarios, the built-in Split methods are sufficient and more readable.