Effiziente Weise zu entfernen ALLE Leerzeichen aus String?

Question

Ich rufe eine REST-API auf und erhalte eine XML-Antwort zurück. Sie gibt eine Liste von Arbeitsbereichsnamen zurück, und ich schreibe eine schnelle IsExistingWorkspace() Methode. Da alle Arbeitsbereiche aus zusammenhängenden Zeichen ohne Leerzeichen bestehen, nehme ich an, dass der einfachste Weg, um herauszufinden, ob ein bestimmter Arbeitsbereich in der Liste enthalten ist, darin besteht, alle Leerzeichen (einschließlich Zeilenumbrüche) zu entfernen und dies zu tun (XML ist die Zeichenkette, die von der Webanforderung empfangen wird):

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

Ich weiß, dass zwischen Groß- und Kleinschreibung unterschieden wird, und darauf verlasse ich mich. Ich brauche nur eine Möglichkeit, alle Leerzeichen in einer Zeichenfolge effizient zu entfernen. Ich weiß, RegEx und LINQ kann es tun, aber ich bin offen für andere Ideen. Ich bin vor allem nur über die Geschwindigkeit besorgt.

Answer 1

Nur eine Alternative, weil es ganz nett aussieht :) - HINWEIS: Henks Antwort ist die schnellste von ihnen.

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

Testen von 1.000.000 Schleifen auf "This is a simple Test"

Diese Methode = 1,74 Sekunden
Regex = 2,58 Sekunden
new String (Henks) = 0,82 Sekunden

Answer 2

Ich fand ein schöner Bericht über dieses Thema auf CodeProject von Felipe Machado (mit Hilfe von Richard Robertson )

Er testete zehn verschiedene Methoden. Diese ist die schnellste sicher Version...

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

Und die schnellste unsicher Version... (einige Verbesserungen durch Sunsetquest 26.5.2021 )

public static unsafe void RemoveAllWhitespace(ref 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;
            }
        }

        uint* pi = (uint*)pfixed;
        ulong len = ((ulong)dst - (ulong)pfixed) >> 1;
        pi[-1] = (uint)len;
        pfixed[len] = '\0';
    }
}

Es gibt auch einige schöne unabhängige Benchmarks auf Stack Overflow von Stian Standahl, die auch zeigen, dass Felipes Funktion etwa 300 % schneller ist als die nächstschnellste Funktion. Für die von mir modifizierte Funktion habe ich außerdem ce Trick.

Answer 3

Wenn Sie eine hervorragende Leistung benötigen, sollten Sie LINQ und reguläre Ausdrücke in diesem Fall vermeiden. Ich habe einige Leistungsvergleiche durchgeführt, und es scheint, dass, wenn Sie Leerzeichen am Anfang und Ende der Zeichenfolge entfernen möchten, string.Trim() die ultimative Funktion ist.

Wenn Sie alle Leerzeichen aus einer Zeichenkette entfernen müssen, funktioniert die folgende Methode am schnellsten von allen, die hier veröffentlicht wurden:

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

Answer 4

Regex ist überflüssig; verwenden Sie einfach die Erweiterung auf String (danke Henk). Dies ist trivial und sollte Teil des Frameworks gewesen sein. Wie auch immer, hier ist meine Implementierung:

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

Answer 5

Ich denke, dass viele Menschen hierher kommen, um Räume zu entfernen:

string s = "my string is nice";
s = s.replace(" ", "");