Sostituisci più elementi stringa in C #

C'è un modo migliore per farlo ...

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

Ho esteso la classe delle corde per limitarla a un lavoro, ma esiste un modo più veloce?

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

Solo per divertimento (e per fermare gli argomenti nei commenti) ho spinto un punto su come confrontare i vari esempi di seguito.

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

L'opzione regex ha un punteggio terribile; l'opzione del dizionario è la più rapida; la versione a vento lungo della sostituzione del costruttore di stringhe è leggermente più veloce della mano corta.

Più veloce - no. Più efficace, sì, se utilizzerai la StringBuilderclasse. Con la tua implementazione ogni operazione genera una copia di una stringa che in circostanze potrebbe compromettere le prestazioni. Le stringhe sono oggetti immutabili , quindi ogni operazione restituisce solo una copia modificata.

Se ti aspetti che questo metodo venga chiamato attivamente su multipli Stringsdi lunghezza significativa, potrebbe essere meglio "migrare" la sua implementazione nella StringBuilderclasse. Con esso qualsiasi modifica viene eseguita direttamente su quell'istanza, in modo da risparmiare operazioni di copia non necessarie.

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

Se stai semplicemente cercando una bella soluzione e non hai bisogno di risparmiare qualche nanosecondo, che ne dici di un po 'di zucchero 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));

questo sarà più efficiente:

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

Forse un po 'più leggibile?

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

Aggiungi anche il suggerimento di New In Town su StringBuilder ...

C'è una cosa che può essere ottimizzata nelle soluzioni suggerite. Avere molte chiamate a Replace()fa sì che il codice esegua più passaggi sulla stessa stringa. Con stringhe molto lunghe le soluzioni potrebbero essere lente a causa della mancanza di capacità della cache della CPU. Potrebbe essere necessario considerare la sostituzione di più stringhe in un unico passaggio .

Un'altra opzione che utilizza 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);
}

Sto facendo qualcosa di simile, ma nel mio caso sto facendo la serializzazione / deserializzazione, quindi devo essere in grado di andare in entrambe le direzioni. Trovo che l'uso di una stringa [] [] funzioni in modo quasi identico al dizionario, inclusa l'inizializzazione, ma puoi anche andare nella direzione opposta, riportando i sostituti ai loro valori originali, cosa per cui il dizionario non è davvero impostato.

Modifica: puoi utilizzare Dictionary<Key,List<Values>>per ottenere lo stesso risultato della stringa [] []

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