C# - Разделяне на тръба с екранирана тръба в данните?

Просто използвайте 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;
}

% two paths, variable and non-variable
% and a base case to start the count
count([S|L], N) :- var(S), !, count(L, N0),  N is N0+1.
count([S|L], N) :- nonvar(S), !, count(L, N).
count([], 0).

count_alt(L, N) :- findall(S, (member(S, L), var(S)), D), length(D, N).

Това трябва да го направи:

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

Регулярният израз основно казва: разделяне на тръби, които не са предшествани от екраниращ знак. Не трябва да си приписвам заслуги за това обаче, просто отвлякох регулярния израз от тази публикация и го опрости.

РЕДАКТИРАНЕ

По отношение на производителността, в сравнение с метода за ръчно анализиране, предоставен в тази тема, открих, че това внедряване на Regex е 3 до 5 пъти по-бавно от изпълнението на Jonathon Wood, използвайки по-дългия тестов низ, предоставен от OP.

С това казано, ако не създадете или добавите думите към List<string> и вместо това върнете void, методът на Jon идва около 5 пъти по-бърз от метода Regex.Split() (0,01ms срещу 0,002ms) за чисто разделяне на низа. Ако добавите обратно разходите за управление и връщане на List<string>, това беше около 3,6 пъти по-бързо (0,01ms срещу 0,00275ms), осреднено за няколко комплекта от милион итерации. Не използвах статичния Regex.Split() за този тест, вместо това създадох нов екземпляр на Regex с израза по-горе извън моя тестов цикъл и след това извиках неговия метод Split.

АКТУАЛИЗАЦИЯ

Използването на статичната функция Regex.Split() всъщност е много по-бързо от повторното използване на екземпляр на израза. С това внедряване използването на регулярен израз е само около 1,6 пъти по-бавно от изпълнението на Jon (0,0043ms срещу 0,00275ms)

Резултатите бяха същите при използване на разширения регулярен израз от публикацията, към която свързах.

Попаднах на подобен сценарий, за мен броят на тръбите беше фиксиран (не тръби с "\|") . Ето как се справих.

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

Решението на Кори е доста добро. Но ако предпочитате да не работите с Regex, тогава можете просто да направите нещо, търсейки "\|" и го заменете с някакъв друг знак, след това направете вашето разделяне, след което го заменете отново с "\|".

Друг вариант е да направите разделянето, след това да прегледате всички низове и ако последният символ е \, след това да го съедините със следващия низ.

Разбира се, всичко това игнорира какво се случва, ако имате нужда от екранирана обратна наклонена черта преди тръба... като "\\|".

Като цяло обаче клоня към regex.

Честно казано, предпочитам да използвам FileHelpers, защото, въпреки че това не е разделено със запетая, това е основно едно и също нещо. И те имат страхотна история за защо не трябва да пишете тези неща сами.

Можете да направите това с регулярен израз. След като решите да използвате обратна наклонена черта като екраниращ знак, имате два случая на екраниране, които трябва да отчетете:

• Бягство от тръба: \|
• Бягство от обратна наклонена черта, която искате да се тълкува буквално.

И двете могат да бъдат направени в един и същ регулярен израз. Екранираните обратни наклонени черти винаги ще бъдат два \ знака заедно. Последователните, екранирани обратни наклонени черти винаги ще бъдат четни числа от \ знака. Ако намерите нечетна поредица от \ преди тръба, това означава, че имате няколко екранирани обратни наклонени черти, последвани от екранирана тръба. Така че искате да използвате нещо подобно:

/^(?:((?:[^|\\]|(?:\\{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