Der einfachste Weg, eine Zeichenfolge in Zeilenumbrüchen in .NET zu teilen?

Ich muss eine Zeichenfolge in .NET in Zeilenumbrüche aufteilen. Die einzige Möglichkeit, Zeichenfolgen aufzuteilen, ist die Split- Methode. Dadurch kann ich mich jedoch nicht (leicht) in eine neue Zeile aufteilen. Was ist also der beste Weg, dies zu tun?

Um einen String zu teilen, müssen Sie die Überladung verwenden, die ein Array von Strings benötigt:

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

Bearbeiten:
Wenn Sie verschiedene Arten von Zeilenumbrüchen in einem Text verarbeiten möchten, können Sie die Möglichkeit verwenden, mehr als eine Zeichenfolge abzugleichen. Dadurch werden beide Zeilenumbrüche korrekt aufgeteilt und leere Zeilen und Abstände im Text beibehalten:

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

Was ist mit einem StringReader?

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

Sie sollten in der Lage sein, Ihre Saite ziemlich einfach zu teilen, wie folgt:

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

Vermeiden Sie die Verwendung von string.Split für eine allgemeine Lösung, da Sie überall dort, wo Sie die Funktion verwenden, mehr Speicher verwenden - die ursprüngliche Zeichenfolge und die geteilte Kopie, beide im Speicher. Vertrauen Sie mir, dass dies ein verdammt großes Problem sein kann, wenn Sie mit der Skalierung beginnen. Führen Sie eine 32-Bit-Stapelverarbeitungs-App aus, die 100-MB-Dokumente verarbeitet, und Sie werden auf acht gleichzeitige Threads verzichten. Nicht dass ich schon einmal dort gewesen wäre ...

Verwenden Sie stattdessen einen solchen Iterator.

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

Auf diese Weise können Sie eine speichereffizientere Schleife um Ihre Daten durchführen.

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

Wenn Sie alles im Speicher haben möchten, können Sie dies natürlich tun.

var allTheLines = document.SplitToLines.ToArray();

Verwenden Sie basierend auf Guffas Antwort in einer Erweiterungsklasse:

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

Für eine Zeichenfolgenvariable s:

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

Dies verwendet die Definition der Zeilenenden in Ihrer Umgebung. Unter Windows sind die Zeilenenden CR-LF (Wagenrücklauf, Zeilenvorschub) oder die Escapezeichen von C # \r\n.

Dies ist eine zuverlässige Lösung, denn wenn Sie die Zeilen mit neu kombinieren String.Join, entspricht dies Ihrer ursprünglichen Zeichenfolge:

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

Was nicht zu tun ist:

• Verwenden Sie StringSplitOptions.RemoveEmptyEntriesdiese Option , da dadurch Markups wie Markdown unterbrochen werden, bei denen leere Zeilen einen syntaktischen Zweck haben.
• Auf Trennzeichen teilen new char[]{Environment.NewLine}, da unter Windows ein leeres Zeichenfolgenelement für jede neue Zeile erstellt wird.

Regex ist auch eine Option:

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

Ich dachte nur, ich würde meine zwei Bits hinzufügen, weil die anderen Lösungen für diese Frage nicht in die wiederverwendbare Codeklassifizierung fallen und nicht bequem sind.

Der folgende Codeblock erweitert das stringObjekt so, dass es als natürliche Methode beim Arbeiten mit Zeichenfolgen verfügbar ist.

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

Sie können die .Split()Funktion jetzt aus einer beliebigen Zeichenfolge wie folgt verwenden:

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

Um ein Zeilenumbruchzeichen aufzuteilen, übergeben Sie einfach "\n"oder "\r\n"als Begrenzerparameter.

Kommentar: Es wäre schön, wenn Microsoft diese Überlastung implementieren würde.

Ich verwende derzeit diese Funktion (basierend auf anderen Antworten) in VB.NET:

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

Es wird versucht, zuerst die plattformlokale Newline aufzuteilen und dann auf jede mögliche Newline zurückzugreifen.

Ich habe das bisher nur in einer Klasse gebraucht. Wenn sich das ändert, werde ich dies wahrscheinlich machen Publicund es in eine Utility-Klasse verschieben und es vielleicht sogar zu einer Erweiterungsmethode machen.

Hier erfahren Sie, wie Sie die Zeilen wieder zusammenfügen können:

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

Nun, eigentlich sollte Split reichen:

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

Die Option RemoveEmptyStrings stellt sicher, dass Sie keine leeren Einträge haben, da \ n einem \ r folgt

(Bearbeiten, um Kommentare wiederzugeben :) Beachten Sie, dass auch echte Leerzeilen im Text verworfen werden. Dies ist normalerweise das, was ich möchte, aber es ist möglicherweise nicht Ihre Anforderung.

Ich wusste nichts über Environment.Newline, aber ich denke, dies ist eine sehr gute Lösung.

Mein Versuch wäre gewesen:

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

Das zusätzliche .Trim entfernt alle \ r oder \ n, die möglicherweise noch vorhanden sind (z. B. unter Windows, aber Teilen einer Zeichenfolge mit OS x Newline-Zeichen). Wahrscheinlich nicht die schnellste Methode.

BEARBEITEN:

Wie in den Kommentaren richtig hervorgehoben, werden dadurch auch Leerzeichen am Zeilenanfang oder vor dem neuen Zeilenvorschub entfernt. Wenn Sie dieses Leerzeichen beibehalten müssen, verwenden Sie eine der anderen Optionen.

Dumme Antwort: Schreiben Sie in eine temporäre Datei, damit Sie den Ehrwürdigen verwenden können 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);
        }
    }
}

Eigentlich sehr einfach.

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