Easiest way to split a string on newlines in .NET?

I need to split a string into newlines in .NET and the only way I know of to split strings is with the Split method. However that will not allow me to (easily) split on a newline, so what is the best way to do it?

10.10.2009 09:25:56
Why would it not? Just split on System.Environment.NewLine
aviraldg 10.10.2009 09:31:06
But you have to wrap it in a string[] and add an extra argument and... it just feels clunky.
RCIX 10.10.2009 09:34:31

To split on a string you need to use the overload that takes an array of strings:

string[] lines = theText.Split(
    new[] { Environment.NewLine },

If you want to handle different types of line breaks in a text, you can use the ability to match more than one string. This will correctly split on either type of line break, and preserve empty lines and spacing in the text:

string[] lines = theText.Split(
    new[] { "\r\n", "\r", "\n" },
16.10.2017 21:25:25
@RCIX: Sending the correct parameters to the method is a bit awkward because you are using it for something that is a lot simpler than what it's capable of. At least it's there, prior to framework 2 you had to use a regular expression or build your own splitting routine to split on a string...
Guffa 10.10.2009 13:32:28
@Leandro: The Environment.NewLine property contains the default newline for the system. For a Windows system for example it will be "\r\n".
Guffa 1.06.2012 16:48:46
@Leandro: One guess would be that the program splits on \n leaving an \r at the end of each line, then outputs the lines with a \r\n between them.
Guffa 1.06.2012 17:11:29
@Samuel: The \r and \n escape sequences (among others) have a special meaning to the C# compiler. VB doesn't have those escape sequences, so there those constants are used instead.
Guffa 25.07.2013 20:22:29
If you want to accept files from lots of various OS's, you might also add "\n\r" to the start and "\r" to the end of the delimiter list. I'm not sure it's worth the performance hit though. (en.wikipedia.org/wiki/Newline)
user420667 26.11.2013 22:39:59

You should be able to split your string pretty easily, like so:

10.10.2009 09:29:44
On a non-*nix system that will split on the separate characters in the Newline string, i.e. the CR and LF characters. That will cause an extra empty string between each line.
Guffa 10.10.2009 09:34:16
Correct me if i'm wrong, but won't that split on the characters \ and n?
RCIX 10.10.2009 09:35:34
@RCIX: No, the \r and \n codes represent single characters. The string "\r\n" is two characters, not four.
Guffa 10.10.2009 09:39:02
if you add the parameter StringSplitOptions.RemoveEmptyEntries, then this will work perfectly.
Ruben 10.10.2009 12:14:00
@Ruben: No, it will not. Serge already suggested that in his answer, and I have aldready explained that it will also remove the empty lines in the original text that should be preserved.
Guffa 10.10.2009 12:40:35

I did not know about Environment.Newline, but I guess this is a very good solution.

My try would have been:

        string str = "Test Me\r\nTest Me\nTest Me";
        var splitted = str.Split('\n').Select(s => s.Trim()).ToArray();

The additional .Trim removes any \r or \n that might be still present (e. g. when on windows but splitting a string with os x newline characters). Probably not the fastest method though.


As the comments correctly pointed out, this also removes any whitespace at the start of the line or before the new line feed. If you need to preserve that whitespace, use one of the other options.

10.10.2009 11:57:44
The Trim will also remove any white space at the beginning and end of lines, for example indentation.
Guffa 10.10.2009 09:45:19
".Trim removes any \r or \n that might be still present" - ouch. Why not write robust code instead?
bzlm 10.10.2009 10:32:52
Maybe I got the question wrong, but it was/is not clear of that whitespace must be preserved. Of course you are right, Trim() also removes whitespace.
Max 10.10.2009 11:59:02
@Max: Wow, wait until I tell my boss that code is allowed to do anything that is not specifically ruled out in the specification... ;)
Guffa 10.10.2009 12:16:37

Well, actually split should do:

//Constructing string...
StringBuilder sb = new StringBuilder();
sb.AppendLine("first line");
sb.AppendLine("second line");
sb.AppendLine("third line");
string s = sb.ToString();

//Splitting multiline string into separate lines
string[] splitted = s.Split(new string[] {System.Environment.NewLine}, StringSplitOptions.RemoveEmptyEntries);

// Output (separate lines)
for( int i = 0; i < splitted.Count(); i++ )
    Console.WriteLine("{0}: {1}", i, splitted[i]);
31.05.2015 17:09:51
The RemoveEmptyEntries option will remove empty lines from the text. That may be desirable in some situations, but a plain split should preserve the empty lines.
Guffa 10.10.2009 10:17:28
yes, you're right, I just made this assumption, that... well, blank lines are not interesting ;)
MaciekTalaska 10.10.2009 10:37:51
string[] lines = text.Split(

The RemoveEmptyStrings option will make sure you don't have empty entries due to \n following a \r

(Edit to reflect comments:) Note that it will also discard genuine empty lines in the text. This is usually what I want but it might not be your requirement.

10.10.2009 10:21:46
The RemoveEmptyStrings options will also remove empty lines, so it doesn't work properly if the text has empty lines in it.
Guffa 10.10.2009 09:43:21
You probably want to preserve genuine empty lines : \r\n\r\n
slim 10.10.2009 09:43:53

Based on Guffa's answer, in an extension class, use:

public static string[] Lines(this string source) {
    return source.Split(new string[] { "\r\n", "\n" }, StringSplitOptions.None);
2.06.2011 15:34:15

For a string variable s:

s.Split(new string[]{Environment.NewLine},StringSplitOptions.None)

This uses your environment's definition of line endings. On Windows, line endings are CR-LF (carriage return, line feed) or in C#'s escape characters \r\n.

This is a reliable solution, because if you recombine the lines with String.Join, this equals your original string:

var lines = s.Split(new string[]{Environment.NewLine},StringSplitOptions.None);
var reconstituted = String.Join(Environment.NewLine,lines);

What not to do:

  • Use StringSplitOptions.RemoveEmptyEntries, because this will break markup such as Markdown where empty lines have syntactic purpose.
  • Split on separator new char[]{Environment.NewLine}, because on Windows this will create one empty string element for each new line.
14.05.2013 19:51:50
Basically the same answer here as the top rated, accepted one, but it does have a nice unit test and caveats.
vapcguy 16.11.2017 23:20:17

Silly answer: write to a temporary file so you can use the venerable File.ReadLines

var s = "Hello\r\nWorld";
var path = Path.GetTempFileName();
using (var writer = new StreamWriter(path))
var lines = File.ReadLines(path);
4.10.2012 16:13:07
Avoid var, as it doesn't define the type of variable, so you may not understand how to use that object, or what that object represents. Plus, this shows writing the lines and doesn't even specify a file name, so I doubt it would work. Then, when reading, the path to the file is again not specified. Assuming that path is C:\Temp\test.txt, you should then have string[] lines = File.ReadLines(path);.
vapcguy 16.11.2017 22:19:41
@vapcguy what did I just read? - I would recommend to re-read the post or debug it in a console program because all you said is plain wrong | path is set on Path.GetTempFileName | var is a common and recommended definition in C# - by the way it does define the type of a variable ...... EDIT: I don't say this is a good solution
koanbock 31.01.2018 15:32:42
@koanbock Ok, so I looked up Path.GetTempFileName msdn.microsoft.com/en-us/library/… and it says it creates a zero-byte file & returns "the full path of that file". I could swear I tried this before and it gave an exception because it didn't find a file, but was returned a folder location, instead. I know the arguments for using var, but I'd say it is NOT recommended because it doesn't show what the variable object is. It obfuscates it.
vapcguy 9.02.2018 18:04:38

What about using a StringReader?

using (System.IO.StringReader reader = new System.IO.StringReader(input)) {
    string line = reader.ReadLine();
30.05.2019 03:21:47
This is my favorite. I wrapped in an extension method and yield return current line: gist.github.com/ronnieoverby/7916886
Ronnie Overby 11.12.2013 19:33:28
This is the only non-regex solution I've found for .netcf 3.5
Carl 20.12.2013 15:00:04
Specially nice when the input is large and copying it all over to an array becomes slow/memory intensive.
Alejandro 2.09.2014 19:59:39
As written, this answer only reads the first line. See Steve Cooper's answer for the while loop that should be added to this answer.
ToolmakerSteve 28.01.2020 20:35:17

Regex is also an option:

    private string[] SplitStringByLineFeed(string inpString)
        string[] locResult = Regex.Split(inpString, "[\r\n]+");
        return locResult;
9.01.2013 22:02:53
If you want to match lines exactly, preserving blank lines, this regex string would be better: "\r?\n".
Rory O'Kane 9.05.2013 16:13:36

I'm currently using this function (based on other answers) in VB.NET:

Private Shared Function SplitLines(text As String) As String()
    Return text.Split({Environment.NewLine, vbCrLf, vbLf}, StringSplitOptions.None)
End Function

It tries to split on the platform-local newline first, and then falls back to each possible newline.

I've only needed this inside one class so far. If that changes, I will probably make this Public and move it to a utility class, and maybe even make it an extension method.

Here's how to join the lines back up, for good measure:

Private Shared Function JoinLines(lines As IEnumerable(Of String)) As String
    Return String.Join(Environment.NewLine, lines)
End Function
14.05.2013 19:35:26
@Samuel - note the quotations. They actually do have that meaning. "\r" = return . "\r\n" = return + new line. ( please review this post and the accepted solution here
Kraang Prime 18.04.2018 01:35:42
@Kraang Hmm.. I haven't worked with .NET in a long time. I would be surprised if that many people up voted a wrong answer. I see that I commented on Guffa's answer too, and got clarification there. I've deleted my comment to this answer. Thanks for the heads up.
Samuel 19.04.2018 14:04:26
using System.IO;

string textToSplit;

if (textToSplit != null)
    List<string> lines = new List<string>();
    using (StringReader reader = new StringReader(textToSplit))
        for (string line = reader.ReadLine(); line != null; line = reader.ReadLine())
26.05.2019 23:55:58

Try to avoid using string.Split for a general solution, because you'll use more memory everywhere you use the function -- the original string, and the split copy, both in memory. Trust me that this can be one hell of a problem when you start to scale -- run a 32-bit batch-processing app processing 100MB documents, and you'll crap out at eight concurrent threads. Not that I've been there before...

Instead, use an iterator like this;

    public static IEnumerable<string> SplitToLines(this string input)
        if (input == null)
            yield break;

        using (System.IO.StringReader reader = new System.IO.StringReader(input))
            string line;
            while( (line = reader.ReadLine()) != null)
                yield return line;

This will allow you to do a more memory efficient loop around your data;

foreach(var line in document.SplitToLines()) 
    // one line at a time...

Of course, if you want it all in memory, you can do this;

var allTheLines = document.SplitToLines.ToArray();
1.05.2014 12:49:39
I have been there... (parsing large HTML files and running out of memory). Yes, avoid string.Split. Using string.Split may result in usage of the Large Object Heap (LOH) - but I am not 100% sure of that.
Peter Mortensen 31.05.2015 17:16:50
If you made SplitToLines a static method(which it seems you dd), then how can you do blah.SplitToLines.. e.g. document.SplitToLines...?
barlop 14.01.2019 17:17:53
ah I see you put this in the formal parameters making it an extension method.
barlop 14.01.2019 18:09:34

I just thought I would add my two-bits, because the other solutions on this question do not fall into the reusable code classification and are not convenient.

The following block of code extends the string object so that it is available as a natural method when working with strings.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Collections;
using System.Collections.ObjectModel;

namespace System
    public static class StringExtensions
        public static string[] Split(this string s, string delimiter, StringSplitOptions options = StringSplitOptions.None)
            return s.Split(new string[] { delimiter }, options);

You can now use the .Split() function from any string as follows:

string[] result;

// Pass a string, and the delimiter
result = string.Split("My simple string", " ");

// Split an existing string by delimiter only
string foo = "my - string - i - want - split";
result = foo.Split("-");

// You can even pass the split options parameter. When omitted it is
// set to StringSplitOptions.None
result = foo.Split("-", StringSplitOptions.RemoveEmptyEntries);

To split on a newline character, simply pass "\n" or "\r\n" as the delimiter parameter.

Comment: It would be nice if Microsoft implemented this overload.

26.05.2019 23:59:29
Environment.Newline is preferred to hard-coding either \n or \r\n.
Michael Blackburn 17.04.2018 14:16:00
@MichaelBlackburn - That is an invalid statement because there is no context. Environment.Newline is for cross platform compatability, not for working with files using different line terminations than the current operating system. See here for more information, so it really depends on what the developer is working with. Use of Environment.Newline ensures there is no consistency in the line return type between OS's, where 'hard-coding' gives the developer full control.
Kraang Prime 19.04.2018 14:17:10
@MichaelBlackburn - There is no need for you to be rude. I was merely providing the information. .Newline isn't magic, under the hood it is just the strings as provided above based on a switch of if it is running on unix, or on windows. The safest bet, is to first do a string replace for all "\r\n" and then split on "\n". Where using .Newline fails, is when you are working with files that are saved by other programs that use a different method for line breaks. It works well if you know every time the file read is always using the line breaks of your current OS.
Kraang Prime 20.04.2018 10:43:53
So what I'm hearing is the most readable way (maybe higher memory use) is foo = foo.Replace("\r\n", "\n"); string[] result = foo.Split('\n');. Am I understanding correctly that this works on all platforms?
John Doe 12.03.2020 19:42:16

Very easy, actually.


Private Function SplitOnNewLine(input as String) As String
    Return input.Split(Environment.NewLine)
End Function


string splitOnNewLine(string input)
    return input.split(environment.newline);
7.07.2017 21:05:37
Totally incorrect and doesn't work. Plus, in C#, it's Environment.NewLine just like in VB.
vapcguy 16.11.2017 22:15:24
See End-of-line identifier in VB.NET? for the different options for new line.
Peter Mortensen 27.05.2019 00:02:51