Problem. You want to split
strings on different characters with single character or string
delimiters. For example, split a string that contains ""r"n" sequences,
which are Windows newlines. Solution. This document contains several tips for the Split method on the string type in the C# programming language.
Input string: One,Two,Three,Four,Five
Delimiter: , (char)
Array: One (string array)
Two
Three
Four
Five
1. Using Split
Here
we see the basic Split method overload. You already know the general
way to do this, but it is good to look at the basic syntax before we
move on. This example splits on a single character.
=== Example program for splitting on spaces ===
using System;
class Program
{
static void Main()
{
string s = "there is a cat";
//
// Split string on spaces.
// This will separate all the words.
//
string[] words = s.Split(' ');
foreach (string word in words)
{
Console.WriteLine(word);
}
}
}
=== Output of the program ===
there
is
a
cat
Description.
The input string, which contains four words, is split on spaces and the
foreach loop then displays each word. The result value from Split is a
string[] array.
2. Multiple characters
Here we use either
the Regex method or the C# new array syntax. Note that a new char array
is created in the following usages. There is an overloaded method with
that signature if you need StringSplitOptions, which is used to remove
empty strings.
=== Program that splits on lines with Regex ===
using System;
using System.Text.RegularExpressions;
class Program
{
static void Main()
{
string value = "cat"r"ndog"r"nanimal"r"nperson";
//
// Split the string on line breaks.
// The return value from Split is a string[] array.
//
string[] lines = Regex.Split(value, ""r"n");
foreach (string line in lines)
{
Console.WriteLine(line);
}
}
}
=== Output of the program ===
cat
dog
animal
person
Description.
The first example uses Regex. Regex contains the Split method, which is
static. It can be used to split strings, although it has different
performance properties. The next two example show how you can specify
an array as the first parameter to string Split.
=== Program that splits on multiple characters ===
using System;
class Program
{
static void Main()
{
//
// This string is also separated by Windows line breaks.
//
string value = "shirt"r"ndress"r"npants"r"njacket";
//
// Use a new char[] array of two characters ("r and "n) to break
// lines from into separate strings. Use "RemoveEmptyEntries"
// to make sure no empty strings get put in the string[] array.
//
char[] delimiters = new char[] { '"r', '"n' };
string[] parts = value.Split(delimiters, StringSplitOptions.RemoveEmptyEntries);
for (int i = 0; i < parts.Length; i++)
{
Console.WriteLine(parts[i]);
}
//
// Same as the previous example, but uses a new string of 2 characters.
//
parts = value.Split(new string[] { ""r"n" }, StringSplitOptions.None);
for (int i = 0; i < parts.Length; i++)
{
Console.WriteLine(parts[i]);
}
}
}
=== Output of the program ===
(Repeated two times)
shirt
dress
pants
jacket
Overview.
One useful overload of Split receives char[] arrays. The string Split
method can receive a character array as the first parameter. Each char
in the array designates a new block.
Using string arrays.
Another overload of Split receives string[] arrays. This means string
array can also be passed to the Split method. The new string[] array is
created inline with the Split call.
Explanation of StringSplitOptions.
The RemoveEmptyEntries enum is specified. When two delimiters are
adjacent, we end up with an empty result. We can use this as the second
parameter to avoid this. [C# StringSplitOptions Enumeration - dotnetperls.com] The following screenshot shows the Visual Studio debugger.
3. Separating words
Here
we see how you can separate words with Split. Usually, the best way to
separate words is to use a Regex that specifies non-word chars. This
example separates words in a string based on non-word characters. It
eliminates punctuation and whitespace from the return array.
=== Program that separates on non-word pattern ===
using System;
using System.Text.RegularExpressions;
class Program
{
static void Main()
{
string[] w = SplitWords("That is a cute cat, man");
foreach (string s in w)
{
Console.WriteLine(s);
}
Console.ReadLine();
}
/// <summary>
/// Take all the words in the input string and separate them.
/// </summary>
static string[] SplitWords(string s)
{
//
// Split on all non-word characters.
// Returns an array of all the words.
//
return Regex.Split(s, @""W+");
// @ special verbatim string syntax
// "W+ one or more non-word characters together
}
}
=== Output of the program ===
That
is
a
cute
cat
man
Word splitting example.
Here you can separate parts of your input string based on any character
set or range with Regex. Overall, this provides more power than the
string Split methods. [C# Regex.Split Method Examples - dotnetperls.com]
4. Splitting text files
Here
you have a text file containing comma-delimited lines of values. This
is called a CSV file, and it is easily dealt with in C#. We use the
File.ReadAllLines method here, but you may want StreamReader instead.
Reading the following code.
The C# code next reads in both of those lines, parses them, and
displays the values of each line after the line number. The final
comment shows how the file was parsed into the strings.
=== Contents of input file (TextFile1.txt) ===
Dog,Cat,Mouse,Fish,Cow,Horse,Hyena
Programmer,Wizard,CEO,Rancher,Clerk,Farmer
=== Program that splits lines in file (C#) ===
using System;
using System.IO;
class Program
{
static void Main()
{
int i = 0;
foreach (string line in File.ReadAllLines("TextFile1.txt"))
{
string[] parts = line.Split(',');
foreach (string part in parts)
{
Console.WriteLine("{0}:{1}",
i,
part);
}
i++; // For demo only
}
}
}
=== Output of the program ===
0:Dog
0:Cat
0:Mouse
0:Fish
0:Cow
0:Horse
0:Hyena
1:Programmer
1:Wizard
1:CEO
1:Rancher
1:Clerk
1:Farmer
5. Splitting directory paths
Here we see how you can Split the segments in a Windows local directory
into separate strings. Note that directory paths are complex and this
may not handle all cases correctly. It is also platform-specific, and
you could use System.IO.Path. DirectorySeparatorChar for more
flexibility. [C# Path Examples - dotnetperls.com]
=== Program that splits Windows directories (C#) ===
using System;
class Program
{
static void Main()
{
// The directory from Windows
const string dir = @"C:"Users"Sam"Documents"Perls"Main";
// Split on directory separator
string[] parts = dir.Split('""');
foreach (string part in parts)
{
Console.WriteLine(part);
}
}
}
=== Output of the program ===
C:
Users
Sam
Documents
Perls
Main
6. Split internal logic
The logic internal to the .NET framework for Split
is implemented in managed code. The methods call into the overload with
three parameters. The parameters are next checked for validity.
Finally, it uses unsafe code to create the separator list, and then a
for loop combined with Substring to return the array.
7. Benchmarks
The author tested a long string and a short string, having 40 and 1200 chars. String splitting speed varies on the type of strings. The length of the blocks, number of delimiters, and total size of the string factor into performance.
Results.
The Regex.Split option generally performed the worst. The author felt
that the second or third methods would be the best, after observing
performance problems with regular expressions in other situations.
=== Strings used in test ===
//
// Build long string.
//
_test = string.Empty;
for (int i = 0; i < 120; i++)
{
_test += "01234567"r"n";
}
//
// Build short string.
//
_test = string.Empty;
for (int i = 0; i < 10; i++)
{
_test += "ab"r"n";
}
=== Example methods tested (100000 iterations) ===
static void Test1()
{
string[] arr = Regex.Split(_test, ""r"n", RegexOptions.Compiled);
}
static void Test2()
{
string[] arr = _test.Split(new char[] { '"r', '"n' }, StringSplitOptions.RemoveEmptyEntries);
}
static void Test3()
{
string[] arr = _test.Split(new string[] { ""r"n" }, StringSplitOptions.None);
}
Longer strings: 1200 chars.
The benchmark for the methods on the long strings is more even. It may
be that for very long strings, such as entire files, the Regex method
is equivalent or even faster. For short strings, Regex is slowest, but for long strings it is very fast.
=== Benchmark of Split on long strings ===
[1] Regex.Split: 3470 ms
[2] char[] Split: 1255 ms [fastest]
[3] string[] Split: 1449 ms
=== Benchmark of Split on short strings ===
[1] Regex.Split: 434 ms
[2] char[] Split: 63 ms [fastest]
[3] string[] Split: 83 ms
Short strings: 40 chars.
This shows the three methods compared to each other on short strings.
Method 1 is the Regex method, and it is by far the slowest on the short
strings. This may be because of the compilation time. Smaller is
better. [This article was last updated for .NET 3.5 SP1.]
Performance recommendation.
For programs that use shorter strings, the methods that split based on
arrays are faster and simpler, and they will avoid Regex compilation.
For somewhat longer strings or files that contain more lines, Regex is
appropriate. I show some Split improvements that can improve your
program. [C# Split Improvement - dotnetperls.com]
8. Escaped characters
You can use Replace
on your string input to substitute special characters in for any
escaped characters. This can solve lots of problems on parsing
computer-generated code or data. [C# Split Method and Escape Characters - dotnetperls.com]
9. Caching delimiters
The
author's further research into Split and its performance shows that it
is worthwhile to declare your char[] array you are splitting on as a
local instance to reduce memory pressure and improve runtime
performance.
=== Slow version - before ===
//
// Split on multiple characters using new char[] inline.
//
string t = "string to split, ok";
for (int i = 0; i < 10000000; i++)
{
string[] s = t.Split(new char[] { ' ', ',' });
}
=== Fast version - after ===
//
// Split on multiple characters using new char[] already created.
//
string t = "string to split, ok";
char[] c = new char[]{ ' ', ',' }; // <-- Cache this
for (int i = 0; i < 10000000; i++)
{
string[] s = t.Split(c);
}
Interpretation of the above table.
We see that storing the array of delimiters separately is good. My
measurements show the above code is less than 10% faster when the array
is stored outside the loop.
10. Rewriting PHP explode
C# has no explode method exactly like PHP
explode, but you can gain the functionality quite easily with Split,
for the most part. You can replace explode with the Split method that
receives a string[] array. [C# PHP explode Function - dotnetperls.com]
11. Summary
Here we saw several examples and two benchmarks of the Split
method in the C# programming language. You can use Split to divide or
separate your strings while keeping your code as simple as possible.
Sometimes, using IndexOf and Substring together to parse your strings
can be more precise and less error-prone. [C# IndexOf String Examples -
dotnetperls.com]