С# - Разделение на трубу со сбежавшей трубой в данных?

Просто используйте String.IndexOf(), чтобы найти следующую трубу. Если предыдущий символ не является обратной косой чертой, используйте String.Substring() для извлечения слова. В качестве альтернативы вы можете использовать String.IndexOfAny(), чтобы найти следующее вхождение вертикальной черты или обратной косой черты.

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

ИЗМЕНИТЬ

На самом деле, может быть, что-то вроде этого. Было бы интересно посмотреть, как это сравнивается по производительности с решением RegEx.

public List<string> ParseWords(string s)
{
    List<string> words = new List<string>();

    int pos = 0;
    while (pos < s.Length)
    {
        // Get word start
        int start = pos;

        // Get word end
        pos = s.IndexOf('|', pos);
        while (pos > 0 && s[pos - 1] == '\\')
        {
            pos++;
            pos = s.IndexOf('|', pos);
        }

        // Adjust for pipe not found
        if (pos < 0)
            pos = s.Length;

        // Extract this word
        words.Add(s.Substring(start, pos - start));

        // Skip over pipe
        if (pos < s.Length)
            pos++;
    }
    return words;
}

Это должно сделать это:

string test = @"This|is|a|pip\|ed|test (this is a pip|ed test)";
string[] parts = Regex.Split(test, @"(?<!(?<!\\)*\\)\|");

Регулярное выражение в основном говорит: разделить на каналы, которым не предшествует escape-символ. Однако я не должен брать на себя ответственность за это, я просто взломал регулярное выражение из этого поста и упростил его.

ИЗМЕНИТЬ

С точки зрения производительности, по сравнению с методом ручного синтаксического анализа, представленным в этом потоке, я обнаружил, что эта реализация Regex в 3-5 раз медленнее, чем реализация Джонатона Вуда с использованием более длинной тестовой строки, предоставленной OP.

С учетом сказанного, если вы не создадите экземпляр или не добавите слова в List<string> и вместо этого вернете void, метод Джона будет выполняться примерно в 5 раз быстрее, чем метод Regex.Split() (0,01 мс против 0,002 мс) для простого разделения строки. Если вы добавите накладные расходы на управление и возврат List<string>, это будет примерно в 3,6 раза быстрее (0,01 мс против 0,00275 мс), в среднем за несколько наборов из миллиона итераций. Я не использовал статический Regex.Split() для этого теста, вместо этого я создал новый экземпляр Regex с приведенным выше выражением вне моего тестового цикла, а затем вызвал его метод Split.

ОБНОВЛЕНИЕ

Использование статической функции Regex.Split() на самом деле намного быстрее, чем повторное использование экземпляра выражения. В этой реализации использование регулярных выражений всего примерно в 1,6 раза медленнее, чем реализация Джона (0,0043 мс против 0,00275 мс).

Результаты были такими же, используя расширенное регулярное выражение из поста, на который я ссылался.

Я столкнулся с аналогичным сценарием. Для меня было исправлено количество каналов (не каналов с "\|") . Вот как я справился.

string sPipeSplit = "This|is|a|pip\\|ed|test (this is a pip|ed test)";
string sTempString = sPipeSplit.Replace("\\|", "¬"); //replace \| with non printable character
string[] sSplitString = sTempString.Split('|');
//string sFirstString = sSplitString[0].Replace("¬", "\\|"); //If you have fixed number of fields and you are copying to other field use replace while copying to other field.
/* Or you could use a loop to replace everything at once
foreach (string si in sSplitString)
{
    si.Replace("¬", "\\|");
}
*/

Вот еще одно решение.

Одна из самых прекрасных вещей в программировании — это несколько способов решения одной и той же проблемы:

string text = @"This|is|a|pip\|ed|test"; //The original text
string parsed = ""; //Where you will store the parsed string

bool flag = false;
foreach (var x in text.Split('|')) {
    bool endsWithArroba = x.EndsWith(@"\");
    parsed += flag ? "|" + x + " " : endsWithArroba ? x.Substring(0, x.Length-1) : x + " ";
    flag = endsWithArroba;
}

Решение Кори довольно хорошее. Но если вы предпочитаете не работать с регулярными выражениями, тогда вы можете просто выполнить поиск "\|" и замените его каким-либо другим символом, затем выполните разделение, а затем снова замените его на «\|».

Другой вариант — выполнить разбиение, затем просмотреть все строки и, если последним символом является \, соединить его со следующей строкой.

Конечно, все это игнорирует то, что происходит, если вам нужна экранированная обратная косая черта перед каналом... например, "\\|".

В целом, я склоняюсь к регулярному выражению.

Откровенно говоря, я предпочитаю использовать FileHelpers, потому что, хотя это и не разделяется запятой, по сути это одно и то же. И у них есть отличная история о том, почему вам не следует писать этот материал самостоятельно.

Вы можете сделать это с помощью регулярного выражения. Как только вы решите использовать обратную косую черту в качестве escape-символа, вам придется учитывать два случая escape-символа:

• Побег из трубы: \|
• Экранирование обратной косой черты, которую вы хотите интерпретировать буквально.

Оба они могут быть выполнены в одном и том же регулярном выражении. Экранированная обратная косая черта всегда будет состоять из двух символов \ вместе. Последовательные экранированные обратные косые черты всегда будут состоять из \ символов из четного числа. Если вы найдете нечетную последовательность \ перед вертикальной чертой, это означает, что у вас есть несколько скрытых обратных косых черт, за которыми следует экранированная вертикальная черта. Итак, вы хотите использовать что-то вроде этого:

/^(?:((?:[^|\\]|(?:\\{2})|\\\|)+)(?:\||$))*/

Запутанно, возможно, но должно работать. Объяснение:

^              #The start of a line
(?:...
    [^|\\]     #A character other than | or \ OR
    (?:\\{2})* #An even number of \ characters OR
    \\\|       #A literal \ followed by a literal |
...)+          #Repeat the preceding at least once
(?:$|\|)       #Either a literal | or the end of a line