Reemplazar saltos de línea en una cadena C #

¿Cómo puedo reemplazar saltos de línea dentro de una cadena en C #?

Usar reemplazar con Environment.NewLine

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

Como se mencionó en otras publicaciones, si la cadena proviene de otro entorno (SO), entonces deberá reemplazar esa implementación de entornos particulares de nuevos caracteres de control de línea .

Las soluciones publicadas hasta ahora solo reemplazan Environment.NewLine o fallan si la cadena de reemplazo contiene saltos de línea porque llaman string.Replacevarias veces.

Aquí hay una solución que usa una expresión regular para hacer los tres reemplazos en una sola pasada sobre la cadena. Esto significa que la cadena de reemplazo puede contener saltos de línea de forma segura.

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

Para ampliar la respuesta de The.Anyi.9, también debe tener en cuenta los diferentes tipos de salto de línea en el uso general . Dependiendo de dónde se originó su archivo, es posible que desee ver para asegurarse de tomar todas las alternativas ...

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

debería ponerte en marcha ...

Usaría Environment.Newline cuando quisiera insertar una nueva línea para una cadena, pero no eliminar todas las nuevas líneas de una cadena.

Dependiendo de su plataforma, puede tener diferentes tipos de nuevas líneas, pero incluso dentro de la misma plataforma, a menudo se utilizan diferentes tipos de nuevas líneas. En particular cuando se trata de formatos de archivo y protocolos.

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

Si se supone que su código se ejecuta en diferentes entornos, consideraría usar la Environment.NewLineconstante, ya que es específicamente la newlineutilizada en el entorno específico.

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

Sin embargo, si obtiene el texto de un archivo que se origina en otro sistema, esta podría no ser la respuesta correcta, y debe reemplazarla con cualquier constante de nueva línea que se use en el otro sistema. Normalmente será \no \r\n.

No olvide que reemplazar no hace el reemplazo en la cadena, sino que devuelve una nueva cadena con los caracteres reemplazados. Lo siguiente eliminará los saltos de línea (no los reemplazará). Usaría el método de @Brian R. Bondy si los reemplazara con otra cosa, tal vez envuelto como un método de extensión. Recuerde verificar primero los valores nulos antes de llamar a Reemplazar o los métodos de extensión provistos.

string line = ...

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

Como métodos de extensión:

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 asegurarse de que se reemplacen todas las formas posibles de saltos de línea (Windows, Mac y Unix), debe usar:

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

y en este orden, para no hacer saltos de línea adicionales, cuando encuentre alguna combinación de caracteres de final de línea.

si desea "limpiar" las nuevas líneas, el comentario flamebaud usando regex @"[\r\n]+"es la mejor opció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
  }
}

Necesitaba reemplazar el \r\ncon un retorno de carro real y avance de línea y reemplazar \tcon una pestaña real. Entonces se me ocurrió lo siguiente:

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 qué no los dos?

string ReplacementString = "";

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

Nota: Reemplace strincon el nombre de su cadena de entrada.

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

Use el método .Replace ()

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

La mejor manera de reemplazar saltos de línea de forma segura es

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

eso debería producir una cadena con solo \ n (por ejemplo, salto de línea) como saltos de línea. Este código también es útil para corregir saltos de línea mixtos.

Como una nueva línea puede delimitarse por \n, \ry \r\n, primero reemplazaremos \ry \r\npor \n, y solo luego dividiremos la cadena de datos.

Las siguientes líneas deberían ir al 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");

o

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

dependiendo de qué camino quieres ir.

Espera que ayude.

Otra opción es crear un StringReadersobre la cadena en cuestión. En el lector, hazlo .ReadLine()en un bucle. Luego tiene las líneas separadas, sin importar qué separadores (consistentes o inconsistentes) tengan. Con eso, puede proceder como lo desee; una posibilidad es usar un StringBuildery recurrir .AppendLinea él.

La ventaja es que permite que el marco decida qué constituye un "salto de línea".

Si desea reemplazar solo las líneas nuevas:

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

Si desea reemplazar nuevas líneas, pestañas y espacios en blanco:

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