Substituir quebras de linha em uma string C #

Como substituir quebras de linha em uma seqüência de caracteres em c #?

Use substituir por Environment.NewLine

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

Conforme mencionado em outras postagens, se a string vier de outro ambiente (SO), você precisará substituir a implementação desses ambientes em particular de novos caracteres de controle de linha .

As soluções postadas até agora apenas substituem Environment.NewLineou falham se a sequência de substituição contiver quebras de linha porque são chamadas string.Replacevárias vezes.

Aqui está uma solução que usa uma expressão regular para fazer todas as três substituições em apenas uma passagem pela string. Isso significa que a cadeia de substituição pode conter com segurança quebras de linha.

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

Para estender a resposta do The.Anyi.9, você também deve estar ciente dos diferentes tipos de quebra de linha em uso geral . Dependendo de onde o arquivo foi originado, convém verificar todas as alternativas ...

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

deve fazer você ir ...

Eu usaria Environment.Newline quando desejava inserir uma nova linha para uma string, mas não para remover todas as novas linhas de uma string.

Dependendo da sua plataforma, você pode ter diferentes tipos de novas linhas, mas mesmo dentro da mesma plataforma geralmente são usados ​​diferentes tipos de novas linhas. Em particular ao lidar com formatos e protocolos de arquivos.

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

Se seu código deve ser executado em ambientes diferentes, eu consideraria usar a Environment.NewLineconstante, pois é especificamente a newlineusada no ambiente específico.

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

No entanto, se você obtiver o texto de um arquivo originário de outro sistema, talvez essa não seja a resposta correta e substitua-a por qualquer constante de nova linha usada no outro sistema. Normalmente será \nou \r\n.

Não esqueça que substituir não faz a substituição na sequência, mas retorna uma nova sequência com os caracteres substituídos. A seguir, serão removidas as quebras de linha (não as substituídas). Eu usaria o método @Brian R. Bondy se os substituísse por outra coisa, talvez envolvida como um método de extensão. Lembre-se de verificar os valores nulos antes de chamar Substituir ou os métodos de extensão fornecidos.

string line = ...

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

Como métodos de extensão:

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

Para garantir que todas as formas possíveis de quebra de linha (Windows, Mac e Unix) sejam substituídas, você deve usar:

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

e nessa ordem, para não fazer quebras de linha extras, quando você encontrar uma combinação de caracteres de final de linha.

se você quiser "limpar" as novas linhas, o comentário flamebaud usando regex @"[\r\n]+"é a melhor opção.

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

Eu precisava substituir o \r\ncom retorno de carro real e avanço de linha e substituir \tpor uma guia real. Então, eu vim com o seguinte:

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

Por que não ambos?

string ReplacementString = "";

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

Nota: Substitua strinpelo nome da sua sequência de entrada.

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

Use o método .Replace ()

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

A melhor maneira de substituir com segurança as quebras de linha é

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

que deve produzir uma string com apenas \ n (por exemplo, avanço de linha) como quebras de linha. esse código também é útil para corrigir quebras de linha mistas.

Como a nova linha pode ser delimitada por \n, \re \r\n, primeiro, substituiremos \re \r\npor\n , e somente então dividiremos a sequência de dados.

As seguintes linhas devem ir para o parseCSVmétodo:

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

ou

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

dependendo do caminho que você deseja seguir.

Espero que ajude.

Outra opção é criar uma StringReadersobreposição em questão. No leitor, faça .ReadLine()em um loop. Então você tem as linhas separadas, independentemente dos separadores (consistentes ou inconsistentes) que eles tinham. Com isso, você pode proceder como desejar; uma possibilidade é usar um StringBuildere chamar.AppendLine -lo.

A vantagem é que você deixa a estrutura decidir o que constitui uma "quebra de linha".

Se você deseja substituir apenas as novas linhas:

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

Se você deseja substituir novas linhas, guias e espaços em branco:

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