Un moyen efficace de supprimer TOUS les espaces blancs d'une chaîne de caractères ?

Question

J'appelle une API REST et je reçois une réponse XML en retour. Elle renvoie une liste de noms d'espaces de travail, et j'écris un rapide IsExistingWorkspace() méthode. Étant donné que tous les espaces de travail sont constitués de caractères contigus sans espace, je suppose que le moyen le plus simple de savoir si un espace de travail particulier figure dans la liste est de supprimer tous les espaces (y compris les nouvelles lignes) et de faire ceci (XML est la chaîne reçue de la requête Web) :

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

Je sais que c'est sensible à la casse, et je m'y fie. J'ai juste besoin d'un moyen de supprimer efficacement tous les espaces dans une chaîne de caractères. Je sais que RegEx et LINQ peuvent le faire, mais je suis ouvert à d'autres idées. Je suis surtout préoccupé par la vitesse.

Answer 1

C'est le moyen le plus rapide que je connaisse, même si vous avez dit que vous ne vouliez pas utiliser d'expressions régulières :

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

Pour citer @hypehuman dans les commentaires, si vous prévoyez de le faire plus d'une fois, créez et stockez une instance Regex. Cela vous évitera de devoir la construire à chaque fois, ce qui est plus coûteux que vous ne le pensez.

private static readonly Regex sWhitespace = new Regex(@"\s+");
public static string ReplaceWhitespace(string input, string replacement) 
{
    return sWhitespace.Replace(input, replacement);
}

Answer 2

J'ai une méthode alternative sans regexp, et elle semble fonctionner assez bien. C'est une continuation de la réponse de Brandon Moretz :

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

Je l'ai testé dans un simple test unitaire :

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

Pour 1 000 000 d'essais, la première option (sans regexp) s'exécute en moins d'une seconde (700 ms sur ma machine), et la seconde prend 3,5 secondes.

Answer 3

Essayez la méthode de remplacement de la chaîne en C#.

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

Answer 4

C'est juste une alternative parce que ça a l'air plutôt sympa :) - NOTE : Réponse de Henks est le plus rapide d'entre eux.

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

Test de 1.000.000 de boucles sur "This is a simple Test"

Cette méthode = 1,74 seconde
Regex = 2,58 secondes
new String (Henks) = 0,82 seconde

Answer 5

Si vous avez besoin de superbes performances, vous devriez éviter LINQ et les expressions régulières dans ce cas. J'ai effectué une analyse comparative des performances, et il semble que si vous souhaitez supprimer les espaces blancs au début et à la fin d'une chaîne de caractères, string.Trim() est la fonction ultime.

Si vous avez besoin de supprimer tous les espaces blancs d'une chaîne de caractères, la méthode suivante est la plus rapide de toutes celles qui ont été publiées ici :

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