Le moyen le plus simple de fractionner une chaîne sur des sauts de ligne dans .NET?

J'ai besoin de diviser une chaîne en sauts de ligne dans .NET et la seule façon que je sache de diviser les chaînes est avec la méthode Split . Cependant, cela ne me permettra pas (facilement) de diviser sur une nouvelle ligne, alors quelle est la meilleure façon de le faire?

Pour diviser sur une chaîne, vous devez utiliser la surcharge qui prend un tableau de chaînes:

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

Modifier:
si vous souhaitez gérer différents types de sauts de ligne dans un texte, vous pouvez utiliser la possibilité de faire correspondre plusieurs chaînes. Cela se divisera correctement sur chaque type de saut de ligne et préservera les lignes vides et l'espacement dans le texte:

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

Et si vous utilisiez un StringReader?

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

Vous devriez pouvoir diviser votre chaîne assez facilement, comme ceci:

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

Essayez d'éviter d'utiliser string.Split pour une solution générale, car vous utiliserez plus de mémoire partout où vous utilisez la fonction - la chaîne d'origine et la copie fractionnée, toutes deux en mémoire. Croyez-moi, cela peut être un sacré problème lorsque vous commencez à évoluer - exécutez une application de traitement par lots 32 bits traitant des documents de 100 Mo, et vous vous retrouverez à huit threads simultanés. Non pas que j'y ai été avant ...

Utilisez plutôt un itérateur comme celui-ci;

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

Cela vous permettra de faire une boucle plus efficace en mémoire autour de vos données;

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

Bien sûr, si vous voulez tout garder en mémoire, vous pouvez le faire;

var allTheLines = document.SplitToLines.ToArray();

Sur la base de la réponse de Guffa, dans une classe d'extension, utilisez:

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

Pour une variable chaîne s:

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

Cela utilise la définition des fins de ligne de votre environnement. Sous Windows, les fins de ligne sont CR-LF (retour chariot, saut de ligne) ou en caractères d'échappement C # \r\n.

C'est une solution fiable, car si vous recombinez les lignes avec String.Join, cela équivaut à votre chaîne d'origine:

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

Ce qu'il ne faut pas faire:

• Utilisez StringSplitOptions.RemoveEmptyEntries, car cela rompra le balisage tel que Markdown où les lignes vides ont un objectif syntaxique.
• Fractionner sur le séparateur new char[]{Environment.NewLine}, car sous Windows, cela créera un élément de chaîne vide pour chaque nouvelle ligne.

Regex est également une option:

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

Je pensais simplement que j'ajouterais mes deux bits, car les autres solutions sur cette question ne tombent pas dans la classification de code réutilisable et ne sont pas pratiques.

Le bloc de code suivant étend l' stringobjet afin qu'il soit disponible comme méthode naturelle lorsque vous travaillez avec des chaînes.

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

Vous pouvez maintenant utiliser la .Split()fonction à partir de n'importe quelle chaîne comme suit:

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

Pour diviser un caractère de nouvelle ligne, passez simplement "\n"ou "\r\n"comme paramètre de délimiteur.

Commentaire: Ce serait bien si Microsoft implémentait cette surcharge.

J'utilise actuellement cette fonction (basée sur d'autres réponses) dans VB.NET:

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

Il essaie d'abord de se diviser sur la nouvelle ligne locale de la plate-forme, puis revient à chaque nouvelle ligne possible.

Pour l'instant, je n'en ai eu besoin que dans une seule classe. Si cela change, je ferai probablement ceciPublic et le déplacer vers une classe utilitaire, et peut-être même en faire une méthode d'extension.

Voici comment joindre les lignes de sauvegarde, pour faire bonne mesure:

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

Eh bien, en fait, le split devrait faire:

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

L' option RemoveEmptyStrings s'assurera que vous n'avez pas d'entrées vides car \ n suit un \ r

(Modifier pour refléter les commentaires :) Notez qu'il supprimera également les véritables lignes vides dans le texte. C'est généralement ce que je veux, mais ce n'est peut-être pas votre exigence.

Je ne connaissais pas Environment.Newline, mais je suppose que c'est une très bonne solution.

Mon essai aurait été:

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

Le .Trim supplémentaire supprime tous les \ r ou \ n qui pourraient être encore présents (par exemple, sur Windows mais en divisant une chaîne avec des caractères de nouvelle ligne os x). Ce n'est probablement pas la méthode la plus rapide.

ÉDITER:

Comme les commentaires l'ont correctement souligné, cela supprime également tout espace au début de la ligne ou avant le nouveau saut de ligne. Si vous devez conserver cet espace, utilisez l'une des autres options.

Réponse idiote: écrivez dans un fichier temporaire pour pouvoir utiliser le vénérable 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);
        }
    }
}

Très facile, en fait.

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