Zamień podziały linii w ciągu C #

Jak mogę zastąpić podziały wiersza w ciągu w C #?

Użyj zamień na Environment.NewLine

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

Jak wspomniano w innych postach, jeśli ciąg pochodzi z innego środowiska (OS), należy zastąpić implementację nowych znaków kontrolnych wiersza w tym środowisku .

Rozwiązania opublikowane do tej pory albo tylko zastępują, Environment.NewLinealbo zawodzą, jeśli ciąg zastępujący zawiera podziały wiersza, ponieważ wywołują string.Replacewiele razy.

Oto rozwiązanie, które wykorzystuje wyrażenie regularne do wykonania wszystkich trzech zamian w jednym przejściu ciągu. Oznacza to, że ciąg zastępujący może bezpiecznie zawierać podziały linii.

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

Aby rozszerzyć odpowiedź The.Anyi.9, powinieneś również zdawać sobie sprawę z różnych typów ogólnego łamania linii . W zależności od tego, skąd pochodzi Twój plik, możesz sprawdzić, czy złapałeś wszystkie alternatywy ...

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

powinienem zacząć ...

Chciałbym użyć Environment.Newline, gdy chciałem wstawić nowy wiersz dla ciągu, ale nie do usunięcia wszystkich nowych wierszy z ciągu.

W zależności od platformy możesz mieć różne typy znaków nowej linii, ale nawet na tej samej platformie często stosuje się różne rodzaje znaków nowej linii. W szczególności w przypadku formatów plików i protokołów.

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

Jeśli twój kod ma działać w różnych środowiskach, rozważyłbym użycie Environment.NewLinestałej, ponieważ jest ona specyficznie newlineużywana w określonym środowisku.

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

Jeśli jednak otrzymujesz tekst z pliku pochodzącego z innego systemu, może to nie być poprawna odpowiedź i powinieneś zastąpić dowolną stałą nowego wiersza używaną w innym systemie. Zazwyczaj będzie to \nlub \r\n.

Nie zapominaj, że replace nie wykonuje zamiany w ciągu, ale zwraca nowy ciąg z zastąpionymi znakami. Poniższe spowoduje usunięcie podziałów linii (nie zastąpi ich). Użyłbym metody @Briana R. Bondy'ego, jeśli zastąpiłbym je czymś innym, być może opakowanym jako metoda rozszerzenia. Pamiętaj, aby najpierw sprawdzić wartości zerowe przed wywołaniem funkcji Replace lub podanych metod rozszerzenia.

string line = ...

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

Jako metody rozszerzenia:

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

Aby upewnić się, że wszystkie możliwe sposoby podziału linii (Windows, Mac i Unix) zostały zastąpione, należy użyć:

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

i w tej kolejności, aby nie robić dodatkowych podziałów linii, gdy znajdziesz jakąś kombinację znaków kończących linię.

jeśli chcesz „wyczyścić” nowe linie, najlepiej jest użyć komentarza Flameba przy użyciu wyrażenia regularnego @"[\r\n]+".

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

Musiałem zastąpić \r\nrzeczywistym znakiem powrotu karetki i przesunięciem wiersza i zastąpić \tfaktyczną tabulatorem. Więc wpadłem na następujące:

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

Dlaczego nie oba?

string ReplacementString = "";

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

Uwaga: Zamień strinna nazwę swojego ciągu wejściowego.

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

Użyj metody .Replace ()

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

Najlepszym sposobem na bezpieczne zastąpienie łamania linii jest

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

które powinny generować ciąg z \ n (np. linefeed) jako podziałami linii. ten kod jest także przydatny do naprawy mieszanych podziałów linii.

Jako nowej linii może być ograniczona \n, \ra \r\nprzede będziemy wymieniać \ri \r\nz \n, a dopiero potem podzielonego ciąg danych.

Do parseCSVmetody powinny przejść następujące wiersze :

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

lub

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

w zależności od tego, którą drogą chcesz iść.

Mam nadzieję, że to pomoże.

Inną opcją jest utworzenie danego StringReaderciągu znaków. Na czytniku rób .ReadLine()w pętli. Następnie rozdzielamy linie, bez względu na to, jakie separatory (spójne lub niespójne) miały. Dzięki temu możesz kontynuować, jak chcesz; jedną z możliwości jest użycie StringBuilderi wywołanie .AppendLinego.

Zaletą jest to, że pozwalasz ramie decydować, co stanowi „podział linii”.

Jeśli chcesz zastąpić tylko nowe linie:

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

Jeśli chcesz zastąpić znaki nowej linii, tabulatory i białe znaki:

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