la façon la plus rapide de chaîne de remplacement dans un modèle

J'ai quelques modèles de chaîne

c'est mon {0} modèle {1} string

qui j'ai l'intention de mettre les valeurs de l'utilisateur à l'aide de String.Format().

La chaîne est en fait plus tellement pour des raisons de lisibilité j'utilise:

c'est mon {goodName1} modèle {goodName2} string

Et puis String.Replace chaque paramètre et sa valeur.

Comment puis-je obtenir les meilleures performances et la lisibilité?

Peut-être que je ne devrais pas avoir ce modèle dans un fichier (comme maintenant), mais de créer de façon dynamique par concatanating à un générateur de chaîne et en ajoutant les paramètres lorsque nécessaire? Même si c'est moins lisible.

Quels sont mes autres options?

C'est dommage que cette question a tourné dans un débat sur la vitesse. Le repleated String.Replace solution a un problème plus grave. Si le texte de remplacement contient également des sous-chaînes de la forme {goodNameN} alors vont-ils être élargis ou pas? Il s'avère qu'il dépend de l'ordre dans lequel les remplacements sont effectués. C'est le genre de subtils flou que peut reposer à couvert pendant des années et puis morsure des voies mystérieuses de temps après le code est oublié.

OriginalL'auteur Yaron Naveh | 2009-06-06

  1. 15

    De Atwood: C'. Juste. Ne fait pas. De la matière.

    Pas d'accord - peut importe. assurez-vous que, il importe avant l'optimisation, plutôt que de supposer.
    Parfois, il n'a vraiment d'importance... comme dans ce cas où les Remplacer a été accordée à partir de 20 secondes à 0,1... codeproject.com/Articles/298519/...
    Atwood - il n'a pas d'importance, plus de 100 000 cycles. Plus de 200.000.000 de il pourrait.

    OriginalL'auteur AgileJon

  2. 40

    Vous pouvez mettre les paramètres dans un dictionnaire et d'utiliser le Regex.Replace méthode pour remplacer tous les paramètres en un seul remplacement. De cette façon, la méthode des échelles même si le modèle de chaîne est longue, ou le nombre de paramètres augmente.

    Exemple:

    Dictionary<string, string> parameters = new Dictionary<string, string>();
parameters.Add("goodName1", "asdf");
parameters.Add("goodName2", "qwerty");
string text = "this is my {goodName1} template {goodName2} string";
text = Regex.Replace(text, @"\{(.+?)\}", m => parameters[m.Groups[1].Value]);
    Cette solution est la plus performante, vous devez utiliser une méthode d'extension de la sorte, de prendre soin de la non-existant clés lors de la recherche de la dictionnaire.
    Et \{([^}]+)\} est plus rapide que l'utilisation de la non-greedy opérateur.
    Une bonne note pour le point de sortie est m.Value devrait être m.Groups[1].Value. m.Value renvoie la même chose que m.Groups[0].Value qui est l'ensemble de la partie correspondance.
    Oui, vous avez raison. J'ai corrigé le code.
    plus difficile à lire, regex n'a pas de vitesse massif profit et le rend encore plus difficiles à lire le laisser seul script. It just doesn't matter - Je passé trop de temps à l'optimisation et l'obtention de 0,1 ms boost de vitesse. yay - et mon code était pire que le langage assembleur. chaîne de caractères.remplacer fonctionne très bien, est lisible et même les juniors comprendre. Mais elle ne doit jamais être utilisé dans d'énormes boucles

    OriginalL'auteur Guffa

  3. 7

    Comme pour tout, ça dépend. Si le code va être appelé pour des millions de fois chaque jour, alors pensez à la performance. Si c'est plusieurs fois par jour, puis aller pour des raisons de lisibilité.

    J'ai fait une analyse comparative entre l'utilisation normale (immuable) les chaînes de caractères et StringBuilder. Jusqu'à ce que vous commencez à faire une quantité énorme en peu de temps, vous n'avez pas besoin de s'inquiéter trop.

    Je suis d'accord avec Iain. Pour plus d'informations, consultez cet article sur le Code du Projet: codeproject.com/KB/string/string.aspx

    OriginalL'auteur Iain Holder

  4. 7

    Mon spontanée solution devrait ressembler à ceci:

    string data = "This is a {template1} that is {template2}.";

Dictionary<string, string> replacements = new Dictionary<string, string>(){
    {"{template1}", "car"},
    {"{template2}", "red"},
};

foreach (string key in replacements.Keys)
{
    data = data.Replace(key, replacements[key]);
}
Console.WriteLine(data); //outputs "This is a car that is red."

    J'ai utilisé ce genre de modèle de remplacement dans plusieurs projets réels et n'ont jamais trouvé que c'était un problème de performance. Car il est facile à utiliser et à comprendre, je n'ai pas vu aucune raison de changer beaucoup.

    OriginalL'auteur Fredrik Mörk

  5. 3

    MÉFIEZ-vous de s'enliser avec ce type de raisonnement.
    À moins que ce code est en cours d'exécution des centaines de fois par minute, et le fichier de modèle est plusieurs K la taille, il est plus important de le faire. Ne perdez pas une minute penser à ce type de problèmes.
    En général, si vous faites beaucoup avec les manipulations de chaînes, puis d'utiliser un générateur de chaîne.
    Il a même un remplacement de la méthode.
    Mais, pourquoi s'embêter. Lorsque vous avez terminé, et SI vous trouvez que vous avez un problème de performance, utilisez l'analyseur de performances et résoudre les VÉRITABLES goulets d'étranglement à l'époque.

    OriginalL'auteur Bobby Ortiz

  6. 2

    La même chose que ci-dessus que Fredrick posté ci-dessus, mais avec linq.

        public static string FindandReplace(this string inputText, Dictionary<string, string> placeHolderValues)
    {
        if (!string.IsNullOrEmpty(inputText))
        {
            return placeHolderValues.Keys.Aggregate(inputText, (current, key) => current.Replace(key, placeHolderValues[key]));
        }
        else return inputText;
    }

    OriginalL'auteur jaxxbo

  7. 0

    Si vous avez besoin d'un bon, rapide, mais le simple moteur de template, vous devriez vérifier StringTemplate. Pour de simples modèles qui ne nécessitent pas de toute logique ou de contrôle de flux dans le modèle lui-même, StringTemplate est GRANDE.

    http://www.stringtemplate.org/download.html

    OriginalL'auteur jrista

  8. 0

    La plus rapide façon de le faire est avec un StringBuilder de l'utilisation des différents appels à StringBuilder.Append(), comme ceci:

    string result = new StringBuilder("this is my ")
                 .Append(UserVar1)
                 .Append(" template ")
                 .Append(UserVar2)
                 .Append(" string")
                 .ToString();

    J'ai soigneusement comparé le cadre du code, et ce sera être plus rapide. Si vous voulez améliorer la lisibilité, vous pouvez garder une chaîne distincte de montrer à l'utilisateur, et de n'utiliser que ce en arrière-plan.

    Vous n'avez pas besoin de le faire. Le compilateur C# compiler ce exactement le même que si vous n'avez tout simplement string result = "this is my " + UserVar1 + " template " + UserVar2 + " string"
    Dans le cas où la performance et la lisibilité qui compte vraiment, c'est très peu probable que le modèle va être codé en dur dans le code. ne vois pas comment cela pourrait aider.

    OriginalL'auteur Joel Coehoorn

  9. 0

    Juste modifié la réponse ci-dessus à la suivante:

        string data = "This is a {template1} that is {template2}.";

    Dictionary<string, string> replacements = new Dictionary<string, string>(){
        {"{template1}", "car"},
        {"{template2}", "red"},
    };

    data.Parse(replacements);

    Méthode d'Extension:

    public static class Parser
{
    public static string Parse(this string template, Dictionary<string, string> replacements)
    {
        if (replacements.Count > 0)
        {
            template = replacements.Keys
                        .Aggregate(template, (current, key) => current.Replace(key, replacements[key]));
        }
        return template;
    }
}

    Espère que cela aide.. 🙂

    OriginalL'auteur Abhilash Shamsunder