Нормализовать новые строки в C#

Regex может помочь ... может сделать что-то вроде этого ...

(\ r \ n | \ n \ n | \ n \ r | \ r | \ n) заменить на \ r \ n

Это регулярное выражение произвело эти результаты из опубликованной таблицы (просто тестировало левую часть), поэтому замена должна нормализоваться.

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

Вы слишком сложно думаете. Игнорируйте каждый \ r и превращайте каждый \ n в \ r \ n.

В псевдо-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);
   }
 }

РЕДАКТИРОВАТЬ: \ r сам по себе не является ограничителем строки, поэтому я сомневаюсь, что вы действительно хотите расширить \ r до \ r \ n.

Я считаю, что это сделает то, что вам нужно:

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

Я не уверен на 100% в точном синтаксисе, и у меня нет компилятора .Net, который можно было бы проверить. Я написал его на perl и преобразовал в (надеюсь, правильный) C#. Единственный реальный трюк - сначала сопоставить "\ r \ n" и "\ n \ r".

Чтобы применить его ко всему потоку, просто обработайте фрагменты ввода. (Вы можете сделать это с помощью обертки потока, если хотите.)

Исходный perl:

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

Результаты тестирования:

[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

Обновление: теперь преобразует \ n \ r в \ r \ n, хотя я бы не стал называть это нормализацией.

Я с Джейми Завински на RegEx:

«Некоторые люди, столкнувшись с проблемой, думают:« Я знаю, я буду использовать регулярные выражения ». Теперь у них две проблемы»

Для тех из нас, кто предпочитает удобочитаемость:

• Шаг 1

  Заменить \ r \ n на \ n

  Замените \ n \ r на \ n (если вы действительно этого хотите, некоторые плакаты, кажется, думают, что нет)

  Заменить \ r на \ n

• Шаг 2 Замените \ n на Environment.NewLine или \ r \ n или что-то еще.

Я согласен, что Regex - это ответ, однако все остальные не упоминают разделители строк Unicode. Те (и их варианты с \ n) должны быть включены.

Нормализовать перерывы, чтобы все они соответствовали \r\n.

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

Это ответ на вопрос. Данное решение заменяет строку заданной таблицей перевода. Он не использует дорогостоящую функцию регулярного выражения. Он также не использует несколько функций замены, каждая из которых по отдельности перебирала данные с несколькими проверками и т. д.

Таким образом, поиск выполняется непосредственно в цикле 1 for. Для того, сколько раз емкость результирующего массива должна быть увеличена, цикл также используется в функции Array.Copy. Это все петли. В некоторых случаях больший размер страницы может быть более эффективным.

public static string NormalizeNewLine(this string val)
{
    if (string.IsNullOrEmpty(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);
}

Таблица перевода мне очень нравится, даже если '\ n \ r' на самом деле не используется на базовых платформах. Кто будет использовать два типа переносов строк для обозначения двух переносов строк? Если вы хотите это знать, то вам нужно сначала взглянуть, чтобы узнать, используются ли \ n и \ r по отдельности в одном документе.

Это двухэтапный процесс. Сначала вы конвертируете все комбинации \r и \n в одну, скажем, \r
. Затем вы конвертируете весь \r в ваш целевой \r\n.

normalized = 
    original.Replace("\r\n", "\r").
             Replace("\n\r", "\r").
             Replace("\n", "\r").
             Replace("\r", "\r\n"); // last step