A maneira mais fácil de dividir uma string em novas linhas no .NET?

Eu preciso dividir uma seqüência de caracteres em novas linhas no .NET e a única maneira que eu sei de dividir seqüências é com o método Split . No entanto, isso não me permitirá (facilmente) dividir em uma nova linha; então, qual é a melhor maneira de fazer isso?

Para dividir em uma string, você precisa usar a sobrecarga que requer uma matriz de strings:

string[] lines = theText.Split(
    new[] { Environment.NewLine },
    StringSplitOptions.None
);

Editar:
se você quiser lidar com diferentes tipos de quebras de linha em um texto, poderá usar a capacidade de corresponder a mais de uma sequência. Isso será dividido corretamente em qualquer tipo de quebra de linha e preservará linhas e espaçamento vazios no texto:

string[] lines = theText.Split(
    new[] { "\r\n", "\r", "\n" },
    StringSplitOptions.None
);

Que tal usar um StringReader?

using (System.IO.StringReader reader = new System.IO.StringReader(input)) {
    string line = reader.ReadLine();
}

Você deve poder dividir sua string com muita facilidade, assim:

aString.Split(Environment.NewLine.ToCharArray());

Tente evitar o uso de string.Split para uma solução geral, porque você usará mais memória em todos os lugares em que usar a função - a string original e a cópia dividida, ambas na memória. Confie em mim que isso pode ser um problema enorme quando você começa a escalar - execute um aplicativo de processamento em lote de 32 bits que processa documentos de 100 MB e você terá a mínima ideia de oito threads simultâneos. Não que eu já estive lá antes ...

Em vez disso, use um iterador como este;

    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;
            }
        }
    }

Isso permitirá que você faça um loop mais eficiente de memória em torno de seus dados;

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

Obviamente, se você quiser tudo na memória, poderá fazer isso;

var allTheLines = document.SplitToLines.ToArray();

Com base na resposta de Guffa, em uma classe de extensão, use:

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

Para uma variável de sequência s:

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

Isso usa a definição do seu ambiente de terminações de linha. No Windows, as terminações de linha são CR-LF (retorno de carro, avanço de linha) ou nos caracteres de escape do C # \r\n.

Esta é uma solução confiável, porque se você recombinar as linhas String.Join, isso será igual à sua string original:

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

O que não fazer:

• Use StringSplitOptions.RemoveEmptyEntries, pois isso interromperá a marcação, como Markdown, onde as linhas vazias têm um propósito sintático.
• Dividir no separador new char[]{Environment.NewLine}, porque no Windows isso criará um elemento de sequência vazio para cada nova linha.

Regex também é uma opção:

    private string[] SplitStringByLineFeed(string inpString)
    {
        string[] locResult = Regex.Split(inpString, "[\r\n]+");
        return locResult;
    }

Eu apenas pensei em adicionar meus dois bits, porque as outras soluções nessa questão não se enquadram na classificação de código reutilizável e não são convenientes.

O seguinte bloco de código estende o stringobjeto para que ele esteja disponível como um método natural ao trabalhar com seqüências de caracteres.

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);
        }
    }
}

Agora você pode usar a .Split()função de qualquer sequência da seguinte maneira:

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);

Para dividir um caractere de nova linha, basta passar "\n"ou "\r\n"como o parâmetro delimitador.

Comentário: Seria bom se a Microsoft implementasse essa sobrecarga.

Atualmente, estou usando esta função (com base em outras respostas) no VB.NET:

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

Ele tenta dividir primeiro a nova linha local da plataforma e depois recair em cada nova linha possível.

Eu só precisava disso dentro de uma classe até agora. Se isso mudar, provavelmente vou fazer isso Publice movê-lo para uma classe de utilitário, e talvez até torná-lo um método de extensão.

Veja como juntar as linhas de volta, para uma boa medida:

Private Shared Function JoinLines(lines As IEnumerable(Of String)) As String
    Return String.Join(Environment.NewLine, lines)
End Function

Bem, na verdade, a divisão deve fazer:

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

//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]);
}

string[] lines = text.Split(
  Environment.NewLine.ToCharArray(), 
  StringSplitOptions.RemoveEmptyStrings);

A opção RemoveEmptyStrings garantirá que você não tenha entradas vazias devido a \ n após um \ r

(Edite para refletir os comentários :) Observe que ele também descartará linhas vazias genuínas no texto. Geralmente é isso que eu quero, mas pode não ser sua exigência.

Eu não sabia sobre o Environment.Newline, mas acho que essa é uma solução muito boa.

Minha tentativa teria sido:

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

O .Trim adicional remove qualquer \ r ou \ n que ainda possa estar presente (por exemplo, quando estiver no Windows, mas dividindo uma string com caracteres de nova linha os x). Provavelmente não é o método mais rápido.

EDITAR:

Como os comentários apontaram corretamente, isso também remove qualquer espaço em branco no início da linha ou antes do novo avanço de linha. Se você precisar preservar esse espaço em branco, use uma das outras opções.

Resposta boba: escreva em um arquivo temporário para poder usar o venerável File.ReadLines

var s = "Hello\r\nWorld";
var path = Path.GetTempFileName();
using (var writer = new StreamWriter(path))
{
    writer.Write(s);
}
var lines = File.ReadLines(path);

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())
        {
            lines.Add(line);
        }
    }
}

Muito fácil, na verdade.

VB.NET:

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

C #:

string splitOnNewLine(string input)
{
    return input.split(environment.newline);
}