Remplacer plusieurs caractères dans une chaîne C#

Question

Existe-t-il une meilleure façon de remplacer les cordes ?

Je suis surpris que Replace ne prenne pas en compte un tableau de caractères ou un tableau de chaînes de caractères. Je suppose que je pourrais écrire ma propre extension mais je suis curieux de savoir s'il existe un meilleur moyen intégré de faire ce qui suit ? Remarquez que le dernier remplacement est une chaîne et non un caractère.

myString.Replace(';', '\n').Replace(',', '\n').Replace('\r', '\n').Replace('\t', '\n').Replace(' ', '\n').Replace("\n\n", "\n");

Answer 1

Vous pouvez utiliser une expression régulière de remplacement.

s/[;,\t\r ]|[\n]{2}/\n/g

• s/ au début signifie une recherche
• Les personnages entre [ et ] sont les caractères à rechercher (dans n'importe quel ordre)
• Le deuxième / délimite le texte à rechercher et le texte à remplacer

En anglais, cela se lit comme suit :

"Recherche de ; ou , ou \t ou \r ou (espace) ou exactement deux \n et le remplacer par \n "

En C#, vous pourriez faire ce qui suit : (après avoir importé System.Text.RegularExpressions )

Regex pattern = new Regex("[;,\t\r ]|[\n]{2}");
pattern.Replace(myString, "\n");

Answer 2

Si vous vous sentez particulièrement intelligent et que vous ne voulez pas utiliser Regex :

char[] separators = new char[]{' ',';',',','\r','\t','\n'};

string s = "this;is,\ra\t\n\n\ntest";
string[] temp = s.Split(separators, StringSplitOptions.RemoveEmptyEntries);
s = String.Join("\n", temp);

Vous pourriez également intégrer cette méthode dans une méthode d'extension sans trop d'efforts.

Edit : Ou alors attendez 2 minutes et je finirai par l'écrire de toute façon :)

public static class ExtensionMethods
{
   public static string Replace(this string s, char[] separators, string newVal)
   {
       string[] temp;

       temp = s.Split(separators, StringSplitOptions.RemoveEmptyEntries);
       return String.Join( newVal, temp );
   }
}

Et voilà...

char[] separators = new char[]{' ',';',',','\r','\t','\n'};
string s = "this;is,\ra\t\n\n\ntest";

s = s.Replace(separators, "\n");

Answer 3

Vous pouvez utiliser la fonction Aggregate de Linq :

string s = "the\nquick\tbrown\rdog,jumped;over the lazy fox.";
char[] chars = new char[] { ' ', ';', ',', '\r', '\t', '\n' };
string snew = chars.Aggregate(s, (c1, c2) => c1.Replace(c2, '\n'));

Voici la méthode d'extension :

public static string ReplaceAll(this string seed, char[] chars, char replacementCharacter)
{
    return chars.Aggregate(seed, (str, cItem) => str.Replace(cItem, replacementCharacter));
}

Exemple d'utilisation de la méthode d'extension :

string snew = s.ReplaceAll(chars, '\n');

Answer 4

C'est le chemin le plus court :

myString = Regex.Replace(myString, @"[;,\t\r ]|[\n]{2}", "\n");

Answer 5

Ohhh, l'horreur des performances ! La réponse est un peu dépassée, mais quand même...

public static class StringUtils
{
    #region Private members

    [ThreadStatic]
    private static StringBuilder m_ReplaceSB;

    private static StringBuilder GetReplaceSB(int capacity)
    {
        var result = m_ReplaceSB;

        if (null == result)
        {
            result = new StringBuilder(capacity);
            m_ReplaceSB = result;
        }
        else
        {
            result.Clear();
            result.EnsureCapacity(capacity);
        }

        return result;
    }

    public static string ReplaceAny(this string s, char replaceWith, params char[] chars)
    {
        if (null == chars)
            return s;

        if (null == s)
            return null;

        StringBuilder sb = null;

        for (int i = 0, count = s.Length; i < count; i++)
        {
            var temp = s[i];
            var replace = false;

            for (int j = 0, cc = chars.Length; j < cc; j++)
                if (temp == chars[j])
                {
                    if (null == sb)
                    {
                        sb = GetReplaceSB(count);
                        if (i > 0)
                            sb.Append(s, 0, i);
                    }

                    replace = true;
                    break;
                }

            if (replace)
                sb.Append(replaceWith);
            else
                if (null != sb)
                    sb.Append(temp);
        }

        return null == sb ? s : sb.ToString();
    }
}