Normalizar nuevas líneas en C#

Question

Tengo una secuencia de datos que puede contener \ r, \ n, \ r \ n, \ n \ r o cualquier combinación de ellas. ¿Existe una forma simple de normalizar los datos para hacer que todos ellos simplemente se conviertan en \ r \ n pares para hacer que la visualización sea más consistente?

Así que algo que produciría este tipo de tabla de traducción:

\r  --> \r\n 
\n  --> \r\n 
\n\n --> \r\n\r\n 
\n\r --> \r\n 
\r\n --> \r\n 
\r\n\n --> \r\n\r\n 

Answer 1

creo que esto va a hacer lo que necesita:

using System.Text.RegularExpressions; 
// ... 
string normalized = Regex.Replace(originalString, @"\r\n|\n\r|\n|\r", "\r\n"); 

no estoy 100% seguro de la sintaxis exacta, y no tengo un compilador .Net práctico para comprobar. Lo escribí en perl, y lo convertí en (con suerte correcto) C#. El único truco real es hacer coincidir "\ r \ n" y "\ n \ r" primero.

Para aplicarlo a una secuencia completa, simplemente ejecute en trozos de entrada. (Se puede hacer esto con una envoltura de secuencia si lo desea.)

---

El Perl originales:

$str =~ s/\r\n|\n\r|\n|\r/\r\n/g; 

Los resultados de las pruebas:

[bash$] ./test.pl 
\r -> \r\n 
\n -> \r\n 
\n\n -> \r\n\r\n 
\n\r -> \r\n 
\r\n -> \r\n 
\r\n\n -> \r\n\r\n 

---

Actualización: ahora convierte \ n \ r to \ r \ n, aunque no llamaría a eso normalización.

Answer 2

una expresión regular ayudaría .. podría hacer algo más o menos así ..

(\ r \ n | \ n \ n | \ n \ r | \ r | \ n) reemplazar con \ r \ n

Esta expresión regular produjo estos resultados de la tabla publicada (solo prueba del lado izquierdo) por lo que una sustitución debería normalizarse.

\r => \r 
\n => \n 
\n\n => \n\n 
\n\r => \n\r 
\r\n => \r\n 
\r\n => \r\n 
\n => \n 

Answer 3

Estás pensando demasiado complicado. Ignora cada \ r y convierte cada \ n en un \ r \ n.

En Pseudo-C#:

char[] chunk = new char[X]; 
StringBuffer output = new StringBuffer(); 

buffer.Read(chunk); 
foreach (char c in chunk) 
{ 
    switch (c) 
    { 
     case '\r' : break; // ignore 
     case '\n' : output.Append("\r\n"); 
     default : output.Append(c); 
    } 
} 

EDITAR: solo \ r hay una línea terminador lo que duda de que realmente desea ampliar \ r \ r \ n.

Answer 4

estoy con Jamie Zawinski en RegEx:

"Algunas personas, cuando se enfrentan a un problema, piensan" Yo sé, voy a usar expresiones regulares."Ahora tienen dos problemas"

Para aquellos de nosotros que prefieren la legibilidad:

• Paso 1

  Reemplazar \ r \ n de \ n

  Reemplazar \ n \ r por \ n (si realmente quieres esto, algunos carteles no parecen pensar)

  Reemplazar \ r por \ n

• Paso 2 Sustituir \ n por Environment.NewLine o \ r \ n o lo que sea.

Answer 5

Acepto que Regex es la respuesta, sin embargo, todos los demás no mencionan los separadores de línea Unicode. Esos (y sus variaciones con \ n) deberían incluirse.

Answer 6

normalizar las roturas, por lo que todos ellos son \r\n

var normalisedString = 
      sourceString 
      .Replace("\r\n", "\n") 
      .Replace("\n\r", "\n") 
      .Replace("\r", "\n") 
      .Replace("\n", "\r\n"); 

Answer 7

Esta es la respuesta a la pregunta. La solución dada reemplaza una cadena por la tabla de traducción dada. No usa una función de expresión regular costosa. Tampoco utiliza funciones de reemplazo múltiples que cada uno individualmente recorrió los datos con varias comprobaciones, etc.

Por lo tanto, la búsqueda se realiza directamente en 1 para el ciclo. Para el número de veces que se debe aumentar la capacidad de la matriz de resultados, también se utiliza un bucle dentro de la función Array.Copy. Eso son todos los bucles. En algunos casos, un tamaño de página mayor puede ser más eficiente.

public static string NormalizeNewLine(this string val) 
{ 
    if (string.IsNullOrWhiteSpace(val)) 
     return val; 

    const int page = 6; 
    int a = page; 
    int j = 0; 
    int len = val.Length; 
    char[] res = new char[len]; 

    for (int i = 0; i < len; i++) 
    { 
     char ch = val[i]; 

     if (ch == '\r') 
     { 
      int ni = i + 1; 
      if (ni < len && val[ni] == '\n') 
      { 
       res[j++] = '\r'; 
       res[j++] = '\n'; 
       i++; 
      } 
      else 
      { 
       if (a == page) //ensure capacity 
       { 
        char[] nres = new char[res.Length + page]; 
        Array.Copy(res, 0, nres, 0, res.Length); 
        res = nres; 
        a = 0; 
       } 

       res[j++] = '\r'; 
       res[j++] = '\n'; 
       a++; 
      } 
     } 
     else if (ch == '\n') 
     { 
      int ni = i + 1; 
      if (ni < len && val[ni] == '\r') 
      { 
       res[j++] = '\r'; 
       res[j++] = '\n'; 
       i++; 
      } 
      else 
      { 
       if (a == page) //ensure capacity 
       { 
        char[] nres = new char[res.Length + page]; 
        Array.Copy(res, 0, nres, 0, res.Length); 
        res = nres; 
        a = 0; 
       } 

       res[j++] = '\r'; 
       res[j++] = '\n'; 
       a++; 
      } 
     } 
     else 
     { 
      res[j++] = ch; 
     } 
    } 

    return new string(res, 0, j); 
} 

La tabla de traducción realmente me atrae aunque '\ n' no se use realmente en las plataformas básicas. ¿Quién usaría dos tipos de saltos de línea en sucesión para indicar 2 saltos de línea? Si quiere saber eso, entonces debe echar un vistazo antes para saber si \ ny \ r Ambos se usan por separado en el mismo documento.