Modo efficiente per rimuovere TUTTI gli spazi bianchi da String?

Sto chiamando un'API REST e sto ricevendo una risposta XML. Restituisce un elenco di nomi di un'area di lavoro e sto scrivendo un IsExistingWorkspace()metodo rapido . Dal momento che tutte le aree di lavoro sono costituite da caratteri contigui senza spazi bianchi, presumo che il modo più semplice per scoprire se un determinato spazio di lavoro sia nell'elenco sia rimuovere tutti gli spazi bianchi (comprese le nuove righe) e farlo (XML è la stringa ricevuta dal web richiesta):

XML.Contains("<name>" + workspaceName + "</name>");

So che fa distinzione tra maiuscole e minuscole e mi affido a questo. Ho solo bisogno di un modo per rimuovere tutti gli spazi bianchi in una stringa in modo efficiente. So che RegEx e LINQ possono farlo, ma sono aperto ad altre idee. Sono principalmente preoccupato solo per la velocità.

Questo è il modo più veloce che conosco, anche se hai detto che non volevi usare le espressioni regolari:

Regex.Replace(XML, @"\s+", "")

Ho un modo alternativo senza regexp e sembra funzionare abbastanza bene. È una continuazione della risposta di Brandon Moretz:

 public static string RemoveWhitespace(this string input)
 {
    return new string(input.ToCharArray()
        .Where(c => !Char.IsWhiteSpace(c))
        .ToArray());
 }

L'ho testato in un semplice test unitario:

[Test]
[TestCase("123 123 1adc \n 222", "1231231adc222")]
public void RemoveWhiteSpace1(string input, string expected)
{
    string s = null;
    for (int i = 0; i < 1000000; i++)
    {
        s = input.RemoveWhitespace();
    }
    Assert.AreEqual(expected, s);
}

[Test]
[TestCase("123 123 1adc \n 222", "1231231adc222")]
public void RemoveWhiteSpace2(string input, string expected)
{
    string s = null;
    for (int i = 0; i < 1000000; i++)
    {
        s = Regex.Replace(input, @"\s+", "");
    }
    Assert.AreEqual(expected, s);
}

Per 1.000.000 di tentativi la prima opzione (senza regexp) viene eseguita in meno di un secondo (700 ms sulla mia macchina) e la seconda richiede 3,5 secondi.

Prova il metodo di sostituzione della stringa in C #.

XML.Replace(" ", string.Empty);

La mia soluzione è usare Split and Join ed è sorprendentemente veloce, in effetti la più veloce delle risposte migliori qui.

str = string.Join("", str.Split(default(string[]), StringSplitOptions.RemoveEmptyEntries));

Tempi per 10.000 cicli su una semplice stringa con spazi bianchi inclusi nuove righe e schede

• split / join = 60 millisecondi
• linq chararray = 94 millisecondi
• regex = 437 millisecondi

Migliora questo avvolgendolo nel metodo per dargli un significato, e anche renderlo un metodo di estensione mentre ci siamo ...

public static string RemoveWhitespace(this string str) {
    return string.Join("", str.Split(default(string[]), StringSplitOptions.RemoveEmptyEntries));
}

Sulla base della risposta di Henks ho creato alcuni metodi di prova con la sua risposta e alcuni metodi aggiunti, più ottimizzati. Ho trovato che i risultati differiscono in base alla dimensione della stringa di input. Pertanto, ho testato con due set di risultati. Nel metodo più veloce, l'origine collegata ha un modo ancora più veloce. Ma, poiché è caratterizzato come non sicuro, l'ho lasciato fuori.

Risultati della stringa di input lunghi:

1. InPlaceCharArray: 2021 ms ( risposta di Sunsetquest ) - ( fonte originale )
2. Divisione stringa quindi join: 4277ms ( risposta di Kernowcode )
3. Lettore di stringhe: 6082 ms
4. LINQ utilizzando char.IsWhitespace nativo: 7357 ms
5. LINQ: 7746 ms ( risposta di Henk )
6. ForLoop: 32320 ms
7. RegexCompiled: 37157 ms
8. Regex: 42940 ms

Risultati di stringhe di input brevi:

1. InPlaceCharArray: 108 ms ( risposta di Sunsetquest ) - ( fonte originale )
2. Divisione stringa quindi join: 294 ms ( risposta di Kernowcode )
3. Lettore di stringhe: 327 ms
4. ForLoop: 343 ms
5. LINQ utilizzando char.IsWhitespace nativo: 624 ms
6. LINQ: 645ms ( risposta di Henk )
7. RegexCompiled: 1671 ms
8. Regex: 2599 ms

Codice :

public class RemoveWhitespace
{
    public static string RemoveStringReader(string input)
    {
        var s = new StringBuilder(input.Length); // (input.Length);
        using (var reader = new StringReader(input))
        {
            int i = 0;
            char c;
            for (; i < input.Length; i++)
            {
                c = (char)reader.Read();
                if (!char.IsWhiteSpace(c))
                {
                    s.Append(c);
                }
            }
        }

        return s.ToString();
    }

    public static string RemoveLinqNativeCharIsWhitespace(string input)
    {
        return new string(input.ToCharArray()
            .Where(c => !char.IsWhiteSpace(c))
            .ToArray());
    }

    public static string RemoveLinq(string input)
    {
        return new string(input.ToCharArray()
            .Where(c => !Char.IsWhiteSpace(c))
            .ToArray());
    }

    public static string RemoveRegex(string input)
    {
        return Regex.Replace(input, @"\s+", "");
    }

    private static Regex compiled = new Regex(@"\s+", RegexOptions.Compiled);
    public static string RemoveRegexCompiled(string input)
    {
        return compiled.Replace(input, "");
    }

    public static string RemoveForLoop(string input)
    {
        for (int i = input.Length - 1; i >= 0; i--)
        {
            if (char.IsWhiteSpace(input[i]))
            {
                input = input.Remove(i, 1);
            }
        }
        return input;
    }

    public static string StringSplitThenJoin(this string str)
    {
        return string.Join("", str.Split(default(string[]), StringSplitOptions.RemoveEmptyEntries));
    }

    public static string RemoveInPlaceCharArray(string input)
    {
        var len = input.Length;
        var src = input.ToCharArray();
        int dstIdx = 0;
        for (int i = 0; i < len; i++)
        {
            var ch = src[i];
            switch (ch)
            {
                case '\u0020':
                case '\u00A0':
                case '\u1680':
                case '\u2000':
                case '\u2001':
                case '\u2002':
                case '\u2003':
                case '\u2004':
                case '\u2005':
                case '\u2006':
                case '\u2007':
                case '\u2008':
                case '\u2009':
                case '\u200A':
                case '\u202F':
                case '\u205F':
                case '\u3000':
                case '\u2028':
                case '\u2029':
                case '\u0009':
                case '\u000A':
                case '\u000B':
                case '\u000C':
                case '\u000D':
                case '\u0085':
                    continue;
                default:
                    src[dstIdx++] = ch;
                    break;
            }
        }
        return new string(src, 0, dstIdx);
    }
}

Test :

[TestFixture]
public class Test
{
    // Short input
    //private const string input = "123 123 \t 1adc \n 222";
    //private const string expected = "1231231adc222";

    // Long input
    private const string input = "123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222";
    private const string expected = "1231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc222";

    private const int iterations = 1000000;

    [Test]
    public void RemoveInPlaceCharArray()
    {
        string s = null;
        var stopwatch = Stopwatch.StartNew();
        for (int i = 0; i < iterations; i++)
        {
            s = RemoveWhitespace.RemoveInPlaceCharArray(input);
        }

        stopwatch.Stop();
        Console.WriteLine("InPlaceCharArray: " + stopwatch.ElapsedMilliseconds + " ms");
        Assert.AreEqual(expected, s);
    }

    [Test]
    public void RemoveStringReader()
    {
        string s = null;
        var stopwatch = Stopwatch.StartNew();
        for (int i = 0; i < iterations; i++)
        {
            s = RemoveWhitespace.RemoveStringReader(input);
        }

        stopwatch.Stop();
        Console.WriteLine("String reader: " + stopwatch.ElapsedMilliseconds + " ms");
        Assert.AreEqual(expected, s);
    }

    [Test]
    public void RemoveLinqNativeCharIsWhitespace()
    {
        string s = null;
        var stopwatch = Stopwatch.StartNew();
        for (int i = 0; i < iterations; i++)
        {
            s = RemoveWhitespace.RemoveLinqNativeCharIsWhitespace(input);
        }

        stopwatch.Stop();
        Console.WriteLine("LINQ using native char.IsWhitespace: " + stopwatch.ElapsedMilliseconds + " ms");
        Assert.AreEqual(expected, s);
    }

    [Test]
    public void RemoveLinq()
    {
        string s = null;
        var stopwatch = Stopwatch.StartNew();
        for (int i = 0; i < iterations; i++)
        {
            s = RemoveWhitespace.RemoveLinq(input);
        }

        stopwatch.Stop();
        Console.WriteLine("LINQ: " + stopwatch.ElapsedMilliseconds + " ms");
        Assert.AreEqual(expected, s);
    }

    [Test]
    public void RemoveRegex()
    {
        string s = null;
        var stopwatch = Stopwatch.StartNew();
        for (int i = 0; i < iterations; i++)
        {
            s = RemoveWhitespace.RemoveRegex(input);
        }

        stopwatch.Stop();
        Console.WriteLine("Regex: " + stopwatch.ElapsedMilliseconds + " ms");

        Assert.AreEqual(expected, s);
    }

    [Test]
    public void RemoveRegexCompiled()
    {
        string s = null;
        var stopwatch = Stopwatch.StartNew();
        for (int i = 0; i < iterations; i++)
        {
            s = RemoveWhitespace.RemoveRegexCompiled(input);
        }

        stopwatch.Stop();
        Console.WriteLine("RegexCompiled: " + stopwatch.ElapsedMilliseconds + " ms");

        Assert.AreEqual(expected, s);
    }

    [Test]
    public void RemoveForLoop()
    {
        string s = null;
        var stopwatch = Stopwatch.StartNew();
        for (int i = 0; i < iterations; i++)
        {
            s = RemoveWhitespace.RemoveForLoop(input);
        }

        stopwatch.Stop();
        Console.WriteLine("ForLoop: " + stopwatch.ElapsedMilliseconds + " ms");

        Assert.AreEqual(expected, s);
    }

    [TestMethod]
    public void StringSplitThenJoin()
    {
        string s = null;
        var stopwatch = Stopwatch.StartNew();
        for (int i = 0; i < iterations; i++)
        {
            s = RemoveWhitespace.StringSplitThenJoin(input);
        }

        stopwatch.Stop();
        Console.WriteLine("StringSplitThenJoin: " + stopwatch.ElapsedMilliseconds + " ms");

        Assert.AreEqual(expected, s);
    }
}

Modifica : testato un bel rivestimento da Kernowcode.

Solo un'alternativa perché sembra abbastanza carina :) - NOTA: la risposta di Henks è la più veloce di queste.

input.ToCharArray()
 .Where(c => !Char.IsWhiteSpace(c))
 .Select(c => c.ToString())
 .Aggregate((a, b) => a + b);

Test su 1.000.000 di loop attivi "This is a simple Test"

Questo metodo = 1,74 secondi
Regex = 2,58 secondi
new String(Henks) = 0,82

Ho trovato un bel commento su questo su CodeProject di Felipe Machado (con l'aiuto di Richard Robertson )

Ha testato dieci metodi diversi. Questa è la versione più veloce non sicura ...

public static unsafe string TrimAllWithStringInplace(string str) {
    fixed (char* pfixed = str) {
        char* dst = pfixed;
        for (char* p = pfixed; *p != 0; p++)

            switch (*p) {

                case '\u0020': case '\u00A0': case '\u1680': case '\u2000': case '\u2001':

                case '\u2002': case '\u2003': case '\u2004': case '\u2005': case '\u2006':

                case '\u2007': case '\u2008': case '\u2009': case '\u200A': case '\u202F':

                case '\u205F': case '\u3000': case '\u2028': case '\u2029': case '\u0009':

                case '\u000A': case '\u000B': case '\u000C': case '\u000D': case '\u0085':
                    continue;

                default:
                    *dst++ = *p;
                    break;
            }

        return new string(pfixed, 0, (int)(dst - pfixed));
    }
}

E la versione sicura più veloce ...

public static string TrimAllWithInplaceCharArray(string str) {

    var len = str.Length;
    var src = str.ToCharArray();
    int dstIdx = 0;

    for (int i = 0; i < len; i++) {
        var ch = src[i];

        switch (ch) {

            case '\u0020': case '\u00A0': case '\u1680': case '\u2000': case '\u2001':

            case '\u2002': case '\u2003': case '\u2004': case '\u2005': case '\u2006':

            case '\u2007': case '\u2008': case '\u2009': case '\u200A': case '\u202F':

            case '\u205F': case '\u3000': case '\u2028': case '\u2029': case '\u0009':

            case '\u000A': case '\u000B': case '\u000C': case '\u000D': case '\u0085':
                continue;

            default:
                src[dstIdx++] = ch;
                break;
        }
    }
    return new string(src, 0, dstIdx);
}

Ci sono anche alcuni bei benchmark indipendenti su Stack Overflow di Stian Standahl che mostrano anche come la funzione di Felipe sia circa il 300% più veloce della successiva funzione più veloce.

Se hai bisogno di prestazioni eccezionali, in questo caso dovresti evitare LINQ e le espressioni regolari. Ho eseguito alcuni benchmark delle prestazioni e sembra che se si desidera eliminare gli spazi bianchi dall'inizio e dalla fine della stringa, string.Trim () è la funzione definitiva.

Se devi rimuovere tutti gli spazi bianchi da una stringa, il seguente metodo funziona più velocemente di tutto ciò che è stato pubblicato qui:

    public static string RemoveWhitespace(this string input)
    {
        int j = 0, inputlen = input.Length;
        char[] newarr = new char[inputlen];

        for (int i = 0; i < inputlen; ++i)
        {
            char tmp = input[i];

            if (!char.IsWhiteSpace(tmp))
            {
                newarr[j] = tmp;
                ++j;
            }
        }
        return new String(newarr, 0, j);
    }

Regex è eccessivo; usa l'estensione sulla stringa (grazie Henk). Questo è banale e avrebbe dovuto far parte del framework. Comunque, ecco la mia implementazione:

public static partial class Extension
{
    public static string RemoveWhiteSpace(this string self)
    {
        return new string(self.Where(c => !Char.IsWhiteSpace(c)).ToArray());
    }
}

Ecco una semplice alternativa lineare alla soluzione RegEx. Non sono sicuro di quale sia il più veloce; dovresti confrontarlo.

static string RemoveWhitespace(string input)
{
    StringBuilder output = new StringBuilder(input.Length);

    for (int index = 0; index < input.Length; index++)
    {
        if (!Char.IsWhiteSpace(input, index))
        {
            output.Append(input[index]);
        }
    }
    return output.ToString();
}

Avevo bisogno di sostituire gli spazi bianchi in una stringa con spazi, ma non spazi duplicati. ad esempio, avevo bisogno di convertire qualcosa di simile al seguente:

"a b   c\r\n d\t\t\t e"

per

"a b c d e"

Ho usato il seguente metodo

private static string RemoveWhiteSpace(string value)
{
    if (value == null) { return null; }
    var sb = new StringBuilder();

    var lastCharWs = false;
    foreach (var c in value)
    {
        if (char.IsWhiteSpace(c))
        {
            if (lastCharWs) { continue; }
            sb.Append(' ');
            lastCharWs = true;
        }
        else
        {
            sb.Append(c);
            lastCharWs = false;
        }
    }
    return sb.ToString();
}

Presumo che la tua risposta XML assomigli a questo:

var xml = @"<names>
                <name>
                    foo
                </name>
                <name>
                    bar
                </name>
            </names>";

Il modo migliore per elaborare XML è utilizzare un parser XML, come LINQ to XML :

var doc = XDocument.Parse(xml);

var containsFoo = doc.Root
                     .Elements("name")
                     .Any(e => ((string)e).Trim() == "foo");

Ecco un'altra variante:

public static string RemoveAllWhitespace(string aString)
{
  return String.Join(String.Empty, aString.Where(aChar => aChar !Char.IsWhiteSpace(aChar)));
}

Come con la maggior parte delle altre soluzioni, non ho eseguito test di benchmark esaustivi, ma questo funziona abbastanza bene per i miei scopi.

Possiamo usare:

    public static string RemoveWhitespace(this string input)
    {
        if (input == null)
            return null;
        return new string(input.ToCharArray()
            .Where(c => !Char.IsWhiteSpace(c))
            .ToArray());
    }

Ho trovato diversi risultati per essere vero. Sto cercando di sostituire tutti gli spazi bianchi con un unico spazio e la regex è stata estremamente lenta.

return( Regex::Replace( text, L"\s+", L" " ) );

Ciò che ha funzionato in modo ottimale per me (in C ++ cli) è stato:

String^ ReduceWhitespace( String^ text )
{
  String^ newText;
  bool    inWhitespace = false;
  Int32   posStart = 0;
  Int32   pos      = 0;
  for( pos = 0; pos < text->Length; ++pos )
  {
    wchar_t cc = text[pos];
    if( Char::IsWhiteSpace( cc ) )
    {
      if( !inWhitespace )
      {
        if( pos > posStart ) newText += text->Substring( posStart, pos - posStart );
        inWhitespace = true;
        newText += L' ';
      }
      posStart = pos + 1;
    }
    else
    {
      if( inWhitespace )
      {
        inWhitespace = false;
        posStart = pos;
      }
    }
  }

  if( pos > posStart ) newText += text->Substring( posStart, pos - posStart );

  return( newText );
}

Ho provato prima la routine sopra sostituendo ogni carattere separatamente, ma ho dovuto passare a fare sottostringhe per le sezioni non spaziali. Quando si applica a una stringa di 1.200.000 caratteri:

• la routine di cui sopra viene eseguita in 25 secondi
• la routine sopra + sostituzione del carattere separato in 95 secondi
• la regex si interruppe dopo 15 minuti.