Metodo di estensione C #: suddivisione delle stringhe che accetta anche un carattere di escape

Question

Vorrei scrivere un metodo di estensione per la classe String .NET. Vorrei che fosse una variante speciale del metodo Split - uno che prende un carattere escape per evitare di dividere la stringa quando viene usato un carattere escape prima del separatore.

Qual è il modo migliore per scrivere questo? Sono curioso di sapere come affrontare al meglio il modo non regex.
Qualcosa con una firma come ...

public static string[] Split(this string input, string separator, char escapeCharacter)
{
   // ...
}

UPDATE: Perché è emerso in uno i commenti, la fuga ...

In C # quando si sfugge a caratteri non speciali si ottiene l'errore - CS1009: sequenza di escape non riconosciuta.

In IE JScript i caratteri di escape vengono eliminati. A meno che non provi \ u poi ottieni una "cifra esadecimale prevista" " errore. Ho testato Firefox e ha lo stesso comportamento.

Vorrei che questo metodo fosse abbastanza indulgente e seguissi il modello JavaScript. Se scappi da un non-separatore, dovresti semplicemente "gentilmente". rimuovi il carattere di escape.

Answer 1

Che ne dici di:

public static IEnumerable<string> Split(this string input, 
                                        string separator,
                                        char escapeCharacter)
{
    int startOfSegment = 0;
    int index = 0;
    while (index < input.Length)
    {
        index = input.IndexOf(separator, index);
        if (index > 0 && input[index-1] == escapeCharacter)
        {
            index += separator.Length;
            continue;
        }
        if (index == -1)
        {
            break;
        }
        yield return input.Substring(startOfSegment, index-startOfSegment);
        index += separator.Length;
        startOfSegment = index;
    }
    yield return input.Substring(startOfSegment);
}

Sembra che funzioni (con alcune stringhe di test veloci), ma non rimuove il carattere di escape - sospetto che dipenderà dalla tua situazione esatta

Answer 2

Questo dovrà essere ripulito un po ', ma essenzialmente è questo ...

List<string> output = new List<string>();
for(int i=0; i<input.length; ++i)
{
    if (input[i] == separator && (i==0 || input[i-1] != escapeChar))
    {
        output.Add(input.substring(j, i-j);
        j=i;
    }
}

return output.ToArray();

Answer 3

La mia prima osservazione è che il separatore dovrebbe essere un carattere, non una stringa, dal momento che fuggire una stringa usando un singolo carattere può essere difficile - quanto della seguente stringa copre il carattere di escape? A parte questo, la risposta di @James Curran è praticamente come la gestirò, anche se, come dice, ha bisogno di un po 'di pulizia. Inizializzazione da j a 0 nell'inizializzatore di loop, ad esempio. Capire come gestire input null, ecc.

Probabilmente desideri supportare anche StringSplitOptions e specificare se restituire una stringa vuota nella raccolta.

Answer 4

Ecco la soluzione se si desidera rimuovere il carattere di escape.

public static IEnumerable<string> Split(this string input, 
                                        string separator, 
                                        char escapeCharacter) {
    string[] splitted = input.Split(new[] { separator });
    StringBuilder sb = null;

    foreach (string subString in splitted) {
        if (subString.EndsWith(escapeCharacter.ToString())) {
            if (sb == null)
                sb = new StringBuilder();
            sb.Append(subString, 0, subString.Length - 1);
        } else {
            if (sb == null)
                yield return subString;
            else {
                sb.Append(subString);
                yield return sb.ToString();
                sb = null;
            }
        }
    }
    if (sb != null)
        yield return sb.ToString();
}

Answer 5

Puoi provare qualcosa del genere. Tuttavia, suggerirei l'implementazione con codice non sicuro per le attività critiche per le prestazioni.

public static class StringExtensions
{
    public static string[] Split(this string text, char escapeChar, params char[] seperator)
    {
        return Split(text, escapeChar, seperator, int.MaxValue, StringSplitOptions.None);
    }

    public static string[] Split(this string text, char escapeChar, char[] seperator, int count)
    {
        return Split(text, escapeChar, seperator, count, StringSplitOptions.None);
    }

    public static string[] Split(this string text, char escapeChar, char[] seperator, StringSplitOptions options)
    {
        return Split(text, escapeChar, seperator, int.MaxValue, options);
    }

    public static string[] Split(this string text, char escapeChar, char[] seperator, int count, StringSplitOptions options)
    {
        if (text == null)
        {
            throw new ArgumentNullException("text");
        }

        if (text.Length == 0)
        {
            return new string[0];
        }

        var segments = new List<string>();

        bool previousCharIsEscape = false;
        var segment = new StringBuilder();

        for (int i = 0; i < text.Length; i++)
        {
            if (previousCharIsEscape)
            {
                previousCharIsEscape = false;

                if (seperator.Contains(text[i]))
                {
                    // Drop the escape character when it escapes a seperator character.
                    segment.Append(text[i]);
                    continue;
                }

                // Retain the escape character when it escapes any other character.
                segment.Append(escapeChar);
                segment.Append(text[i]);
                continue;
            }

            if (text[i] == escapeChar)
            {
                previousCharIsEscape = true;
                continue;
            }

            if (seperator.Contains(text[i]))
            {
                if (options != StringSplitOptions.RemoveEmptyEntries || segment.Length != 0)
                {
                    // Only add empty segments when options allow.
                    segments.Add(segment.ToString());
                }

                segment = new StringBuilder();
                continue;
            }

            segment.Append(text[i]);
        }

        if (options != StringSplitOptions.RemoveEmptyEntries || segment.Length != 0)
        {
            // Only add empty segments when options allow.
            segments.Add(segment.ToString());
        }

        return segments.ToArray();
    }
}

Answer 6

public static string[] Split(this string input, string separator, char escapeCharacter)
{
    Guid g = Guid.NewGuid();
    input = input.Replace(escapeCharacter.ToString() + separator, g.ToString());
    string[] result = input.Split(new string []{separator}, StringSplitOptions.None);
    for (int i = 0; i < result.Length; i++)
    {
        result[i] = result[i].Replace(g.ToString(), escapeCharacter.ToString() + separator);
    }

    return result;
}

Probabilmente non è il modo migliore per farlo, ma è un'altra alternativa. Fondamentalmente, ovunque si trovi la sequenza di escape + separatore, sostituiscila con un GUID (puoi usare qualsiasi altra schifezza casuale qui, non importa). Quindi utilizzare la funzione split integrata. Quindi sostituire il guid in ogni elemento dell'array con escape + seperator.

Answer 7

La firma non è corretta, è necessario restituire un array di stringhe ATTENZIONE NON UTILIZZARE MAI ESTENSIONI, quindi perdonami per alcuni errori;)

public static List<String> Split(this string input, string separator, char escapeCharacter)
{
    String word = "";
    List<String> result = new List<string>();
    for (int i = 0; i < input.Length; i++)
    {
//can also use switch
        if (input[i] == escapeCharacter)
        {
            break;
        }
        else if (input[i] == separator)
        {
            result.Add(word);
            word = "";
        }
        else
        {
            word += input[i];    
        }
    }
    return result;
}

Answer 8

Personalmente trufferei e darei una sbirciatina alla stringa. Spacco usando il riflettore ... InternalSplitOmitEmptyEntries sembra utile ;-)

Answer 9

Ho avuto anche questo problema e non ho trovato una soluzione. Quindi ho scritto un metodo simile:

    public static IEnumerable<string> Split(
        this string text, 
        char separator, 
        char escapeCharacter)
    {
        var builder = new StringBuilder(text.Length);

        bool escaped = false;
        foreach (var ch in text)
        {
            if (separator == ch && !escaped)
            {
                yield return builder.ToString();
                builder.Clear();
            }
            else
            {
                // separator is removed, escape characters are kept
                builder.Append(ch);
            }
            // set escaped for next cycle, 
            // or reset unless escape character is escaped.
            escaped = escapeCharacter == ch && !escaped;
        }
        yield return builder.ToString();
    }

Va ??in combinazione con Escape e Unescape, che sfugge al separatore e al carattere di escape e rimuove nuovamente i caratteri di escape:

    public static string Escape(this string text, string controlChars, char escapeCharacter)
    {
        var builder = new StringBuilder(text.Length + 3);
        foreach (var ch in text)
        {
            if (controlChars.Contains(ch))
            {
                builder.Append(escapeCharacter);
            }
            builder.Append(ch);
        }
        return builder.ToString();
    }

    public static string Unescape(string text, char escapeCharacter)
    {
        var builder = new StringBuilder(text.Length);
        bool escaped = false;
        foreach (var ch in text)
        {
            escaped = escapeCharacter == ch && !escaped;
            if (!escaped)
            {
                builder.Append(ch);
            }
        }
        return builder.ToString();
    }

Esempi di escape / unescape

separator = ','
escapeCharacter = '\\'
//controlCharacters is always separator + escapeCharacter

@"AB,CD\EF\," <=> @"AB\,CD\\EF\\\,"

Split:

@"AB,CD\,EF\\,GH\\\,IJ" => [@"AB", @"CD\,EF\\", @"GH\\\,IJ"]

Quindi, per usarlo, Escape before Join e Unescape after Split.

Answer 10

public string RemoveMultipleDelimiters(string sSingleLine)
{
    string sMultipleDelimitersLine = "";
    string sMultipleDelimitersLine1 = "";
    int iDelimeterPosition = -1;
    iDelimeterPosition = sSingleLine.IndexOf('>');
    iDelimeterPosition = sSingleLine.IndexOf('>', iDelimeterPosition + 1);
    if (iDelimeterPosition > -1)
    {
        sMultipleDelimitersLine = sSingleLine.Substring(0, iDelimeterPosition - 1);
        sMultipleDelimitersLine1 = sSingleLine.Substring(sSingleLine.IndexOf('>', iDelimeterPosition) - 1);
        sMultipleDelimitersLine1 = sMultipleDelimitersLine1.Replace('>', '*');
        sSingleLine = sMultipleDelimitersLine + sMultipleDelimitersLine1;
    }
    return sSingleLine;
}