Substitua vários elementos de string em C #

Existe um jeito melhor de fazer isso...

MyString.Trim().Replace("&", "and").Replace(",", "").Replace("  ", " ")
         .Replace(" ", "-").Replace("'", "").Replace("/", "").ToLower();

Eu estendi a classe string para mantê-la em um único trabalho, mas existe uma maneira mais rápida?

public static class StringExtension
{
    public static string clean(this string s)
    {
        return s.Replace("&", "and").Replace(",", "").Replace("  ", " ")
                .Replace(" ", "-").Replace("'", "").Replace(".", "")
                .Replace("eacute;", "é").ToLower();
    }
}

Apenas por diversão (e para interromper os argumentos nos comentários), eu apresentei uma ideia básica comparando os vários exemplos abaixo.

https://gist.github.com/ChrisMcKee/5937656

A opção regex pontua terrivelmente; a opção de dicionário surge mais rápido; a versão longa do stringbuilder replace é ligeiramente mais rápida do que a mão curta.

Mais rápido - não. Mais eficaz - sim, se você usar a StringBuilderclasse. Com sua implementação, cada operação gera uma cópia de uma string que, em certas circunstâncias, pode prejudicar o desempenho. Strings são objetos imutáveis , então cada operação retorna apenas uma cópia modificada.

Se você espera que esse método seja ativado ativamente em múltiplos Stringsde comprimento significativo, pode ser melhor "migrar" sua implementação para a StringBuilderclasse. Com ele, qualquer modificação é realizada diretamente nessa instância, evitando operações de cópia desnecessárias.

public static class StringExtention
{
    public static string clean(this string s)
    {
        StringBuilder sb = new StringBuilder (s);

        sb.Replace("&", "and");
        sb.Replace(",", "");
        sb.Replace("  ", " ");
        sb.Replace(" ", "-");
        sb.Replace("'", "");
        sb.Replace(".", "");
        sb.Replace("eacute;", "é");

        return sb.ToString().ToLower();
    }
}

isso será mais eficiente:

public static class StringExtension
{
    public static string clean(this string s)
    {
        return new StringBuilder(s)
              .Replace("&", "and")
              .Replace(",", "")
              .Replace("  ", " ")
              .Replace(" ", "-")
              .Replace("'", "")
              .Replace(".", "")
              .Replace("eacute;", "é")
              .ToString()
              .ToLower();
    }
}

Se você está simplesmente atrás de uma solução bonita e não precisa economizar alguns nanossegundos, que tal um pouco de açúcar LINQ?

var input = "test1test2test3";
var replacements = new Dictionary<string, string> { { "1", "*" }, { "2", "_" }, { "3", "&" } };

var output = replacements.Aggregate(input, (current, replacement) => current.Replace(replacement.Key, replacement.Value));

Talvez um pouco mais legível?

    public static class StringExtension {

        private static Dictionary<string, string> _replacements = new Dictionary<string, string>();

        static StringExtension() {
            _replacements["&"] = "and";
            _replacements[","] = "";
            _replacements["  "] = " ";
            // etc...
        }

        public static string clean(this string s) {
            foreach (string to_replace in _replacements.Keys) {
                s = s.Replace(to_replace, _replacements[to_replace]);
            }
            return s;
        }
    }

Adicione também a sugestão do New In Town sobre StringBuilder ...

Existe uma coisa que pode ser otimizada nas soluções sugeridas. Ter muitas chamadas para Replace()faz com que o código faça várias passagens na mesma string. Com strings muito longas, as soluções podem ser lentas devido à perda de capacidade do cache da CPU. Pode ser que se deva considerar a substituição de várias strings em uma única passagem .

Outra opção usando o linq é

[TestMethod]
public void Test()
{
  var input = "it's worth a lot of money, if you can find a buyer.";
  var expected = "its worth a lot of money if you can find a buyer";
  var removeList = new string[] { ".", ",", "'" };
  var result = input;

  removeList.ToList().ForEach(o => result = result.Replace(o, string.Empty));

  Assert.AreEqual(expected, result);
}

Estou fazendo algo semelhante, mas no meu caso estou fazendo a serialização / desserialização, então preciso poder ir nas duas direções. Eu descobri que usar uma string [] [] funciona quase de forma idêntica ao dicionário, incluindo a inicialização, mas você pode ir na outra direção também, retornando os substitutos aos seus valores originais, algo que o dicionário realmente não está configurado para fazer.

Editar: você pode usar Dictionary<Key,List<Values>>para obter o mesmo resultado que string [] []

string input = "it's worth a lot of money, if you can find a buyer.";
for (dynamic i = 0, repl = new string[,] { { "'", "''" }, { "money", "$" }, { "find", "locate" } }; i < repl.Length / 2; i++) {
    input = input.Replace(repl[i, 0], repl[i, 1]);
}