Ersetzen Sie Zeilenumbrüche in einem String C #

Wie kann ich Zeilenumbrüche innerhalb einer Zeichenfolge in C # ersetzen?

Verwenden Sie ersetzen durch Environment.NewLine

myString = myString.Replace(System.Environment.NewLine, "replacement text"); //add a line terminating ;

Wie in anderen Beiträgen erwähnt, müssen Sie, wenn die Zeichenfolge aus einer anderen Umgebung (OS) stammt, die Implementierung neuer Zeilensteuerungszeichen in dieser bestimmten Umgebung ersetzen .

Die bisher veröffentlichten Lösungen ersetzen entweder nur Environment.NewLineoder sie schlagen fehl, wenn die Ersetzungszeichenfolge Zeilenumbrüche enthält, da sie string.Replacemehrmals aufgerufen werden.

Hier ist eine Lösung, die einen regulären Ausdruck verwendet, um alle drei Ersetzungen in nur einem Durchgang über die Zeichenfolge vorzunehmen. Dies bedeutet, dass die Ersatzzeichenfolge sicher Zeilenumbrüche enthalten kann.

string result = Regex.Replace(input, @"\r\n?|\n", replacementString);

Um die Antwort von The.Anyi.9 zu erweitern, sollten Sie auch die verschiedenen Arten von Zeilenumbrüchen im allgemeinen Gebrauch kennen . Abhängig davon, woher Ihre Datei stammt, sollten Sie prüfen, ob Sie alle Alternativen finden ...

string replaceWith = "";
string removedBreaks = Line.Replace("\r\n", replaceWith).Replace("\n", replaceWith).Replace("\r", replaceWith);

sollte dich zum Laufen bringen ...

Ich würde Environment.Newline verwenden, wenn ich eine neue Zeile für eine Zeichenfolge einfügen möchte, aber nicht alle neuen Zeilen aus einer Zeichenfolge entfernen möchte.

Abhängig von Ihrer Plattform können Sie verschiedene Arten von Zeilenumbrüchen verwenden, aber selbst innerhalb derselben Plattform werden häufig unterschiedliche Arten von Zeilenumbrüchen verwendet. Insbesondere beim Umgang mit Dateiformaten und Protokollen.

string ReplaceNewlines(string blockOfText, string replaceWith)
{
    return blockOfText.Replace("\r\n", replaceWith).Replace("\n", replaceWith).Replace("\r", replaceWith);
}

Wenn Ihr Code in verschiedenen Umgebungen ausgeführt werden soll, würde ich die Verwendung der Environment.NewLineKonstante in Betracht ziehen , da diese speziell newlinein der jeweiligen Umgebung verwendet wird.

line = line.Replace(Environment.NewLine, "newLineReplacement");

Wenn Sie jedoch den Text aus einer Datei erhalten, die von einem anderen System stammt, ist dies möglicherweise nicht die richtige Antwort. Sie sollten ihn durch die auf dem anderen System verwendete Zeilenumbruchkonstante ersetzen. Es wird typischerweise \noder sein \r\n.

Vergessen Sie nicht, dass Ersetzen nicht das Ersetzen in der Zeichenfolge durchführt, sondern eine neue Zeichenfolge mit den ersetzten Zeichen zurückgibt. Im Folgenden werden Zeilenumbrüche entfernt (nicht ersetzt). Ich würde die Methode von @Brian R. Bondy verwenden, wenn ich sie durch etwas anderes ersetzen würde, vielleicht als Erweiterungsmethode. Denken Sie daran, zuerst nach Nullwerten zu suchen, bevor Sie Replace oder die bereitgestellten Erweiterungsmethoden aufrufen.

string line = ...

line = line.Replace( "\r", "").Replace( "\n", "" );

Als Erweiterungsmethoden:

public static class StringExtensions
{
   public static string RemoveLineBreaks( this string lines )
   {
      return lines.Replace( "\r", "").Replace( "\n", "" );
   }

   public static string ReplaceLineBreaks( this string lines, string replacement )
   {
      return lines.Replace( "\r\n", replacement )
                  .Replace( "\r", replacement )
                  .Replace( "\n", replacement );
   }
}

Um sicherzustellen, dass alle möglichen Arten von Zeilenumbrüchen (Windows, Mac und Unix) ersetzt werden, sollten Sie Folgendes verwenden:

string.Replace("\r\n", "\n").Replace('\r', '\n').Replace('\n', 'replacement');

und in dieser Reihenfolge, um keine zusätzlichen Zeilenumbrüche zu machen, wenn Sie eine Kombination von Zeichen für das Zeilenende finden.

Wenn Sie die neuen Zeilen "bereinigen" möchten, ist ein Flammenbaud-Kommentar mit Regex @"[\r\n]+"die beste Wahl.

using System;
using System.Text.RegularExpressions;

class MainClass {
  public static void Main (string[] args) {
    string str = "AAA\r\nBBB\r\n\r\n\r\nCCC\r\r\rDDD\n\n\nEEE";

    Console.WriteLine (str.Replace(System.Environment.NewLine, "-"));
    /* Result:
    AAA
    -BBB
    -
    -
    -CCC


    DDD---EEE
    */
    Console.WriteLine (Regex.Replace(str, @"\r\n?|\n", "-"));
    // Result:
    // AAA-BBB---CCC---DDD---EEE

    Console.WriteLine (Regex.Replace(str, @"[\r\n]+", "-"));
    // Result:
    // AAA-BBB-CCC-DDD-EEE
  }
}

Ich musste das \r\ndurch einen tatsächlichen Wagenrücklauf und Zeilenvorschub ersetzen und durch \teine tatsächliche Lasche ersetzen . Also habe ich mir Folgendes ausgedacht:

public string Transform(string data)
{
    string result = data;
    char cr = (char)13;
    char lf = (char)10;
    char tab = (char)9;

    result = result.Replace("\\r", cr.ToString());
    result = result.Replace("\\n", lf.ToString());
    result = result.Replace("\\t", tab.ToString());

    return result;
}

Warum nicht beide?

string ReplacementString = "";

Regex.Replace(strin.Replace(System.Environment.NewLine, ReplacementString), @"(\r\n?|\n)", ReplacementString);

Hinweis: Ersetzen Sie strindurch den Namen Ihrer Eingabezeichenfolge.

var answer = Regex.Replace(value, "(\n|\r)+", replacementString);

Verwenden Sie die Methode .Replace ()

Line.Replace("\n", "whatever you want to replace with");

Der beste Weg, um Zeilenumbrüche sicher zu ersetzen, ist

yourString.Replace("\r\n","\n") //handling windows linebreaks
.Replace("\r","\n")             //handling mac linebreaks

das sollte einen String mit nur \ n (zB Zeilenvorschub) als Zeilenumbruch erzeugen. Dieser Code ist nützlich, um auch gemischte Zeilenumbrüche zu beheben.

Da eine neue Zeile durch und begrenzt werden \nkann , werden wir zuerst und durch ersetzen und erst dann die Datenzeichenfolge teilen.\r\r\n\r\r\n\n

Die folgenden Zeilen sollten zur parseCSVMethode gehen:

function parseCSV(data) {
    //alert(data);
    //replace UNIX new lines
    data = data.replace(/\r\n/g, "\n");
    //replace MAC new lines
    data = data.replace(/\r/g, "\n");
    //split into rows
    var rows = data.split("\n");
}

string s = Regex.Replace(source_string, "\n", "\r\n");

oder

string s = Regex.Replace(source_string, "\r\n", "\n");

je nachdem welchen Weg du gehen willst.

Hoffe es hilft.

Eine andere Möglichkeit besteht darin, eine StringReaderÜber-String-Zeichenfolge zu erstellen . Führen Sie auf dem Reader .ReadLine()eine Schleife durch. Dann haben Sie die Zeilen getrennt, egal welche (konsistenten oder inkonsistenten) Trennzeichen sie hatten. Damit können Sie fortfahren, wie Sie möchten; Eine Möglichkeit besteht darin, a zu verwenden StringBuilderund es aufzurufen .AppendLine.

Der Vorteil ist, dass Sie das Framework entscheiden lassen, was einen "Zeilenumbruch" ausmacht.

Wenn Sie nur die Zeilenumbrüche ersetzen möchten:

var input = @"sdfhlu \r\n sdkuidfs\r\ndfgdgfd";
var match = @"[\\ ]+";
var replaceWith = " ";
Console.WriteLine("input: " + input);
var x = Regex.Replace(input.Replace(@"\n", replaceWith).Replace(@"\r", replaceWith), match, replaceWith);
Console.WriteLine("output: " + x);

Wenn Sie Zeilenumbrüche, Tabulatoren und Leerzeichen ersetzen möchten:

var input = @"sdfhlusdkuidfs\r\ndfgdgfd";
var match = @"[\\s]+";
var replaceWith = "";
Console.WriteLine("input: " + input);
var x = Regex.Replace(input, match, replaceWith);
Console.WriteLine("output: " + x);