C# les paramètres Nommés pour une chaîne de remplacer les valeurs de paramètre

Regex est certainement une option viable, surtout avec un MatchEvaluator:

    Regex re = new Regex(@"\{(\w*?)\}", RegexOptions.Compiled); //store this...

    string input = "Hi {name}, do you like {food}?";

    Dictionary<string, string> vals = new Dictionary<string, string>();
    vals.Add("name", "Fred");
    vals.Add("food", "milk");

    string q = re.Replace(input, delegate(Match match)
    {
        string key = match.Groups[1].Value;
        return vals[key];
    });

OriginalL'auteur Marc Gravell

Après réflexion sur ce sujet, j'ai réalisé ce que je souhaite, était de cette Chaîne.Format() prend un IDictionary comme argument, et que les modèles pourraient être écrites à l'aide des noms au lieu de index.

Pour la substitution de chaîne avec beaucoup de possible de clés/valeurs, les numéros d'index de résultat dans illisible chaîne de modèles - et, dans certains cas, vous pouvez même ne pas connaître les éléments qui vont avoir ce numéro, alors je suis venu avec l'extension suivante:

https://gist.github.com/896724

En gros, cela vous permet d'utiliser la chaîne de modèles avec des noms plutôt que des numéros, et un dictionnaire au lieu d'un tableau, et vous permet d'avoir toutes les autres bonnes caractéristiques de Chaîne de caractères.Format(), permettant l'utilisation d'une coutume IFormatProvider, si nécessaire, et en permettant l'utilisation de tous les types de mise en forme de la syntaxe de précision, la longueur, etc.

La exemple fourni dans le matériel de référence pour la Chaîne.Le Format est un excellent exemple de la façon dont les modèles avec de nombreux éléments numérotés devenu complètement illisible - le portage de cet exemple pour utiliser cette nouvelle méthode d'extension, vous obtenez quelque chose comme ceci:

var replacements = new Dictionary<String, object>()
                       {
                           { "date1", new DateTime(2009, 7, 1) },
                           { "hiTime", new TimeSpan(14, 17, 32) },
                           { "hiTemp", 62.1m },
                           { "loTime", new TimeSpan(3, 16, 10) },
                           { "loTemp", 54.8m }
                       };

var template =
    "Temperature on {date1:d}:\n{hiTime,11}: {hiTemp} degrees (hi)\n{loTime,11}: {loTemp} degrees (lo)";

var result = template.Subtitute(replacements);

Comme quelqu'un l'a souligné, si ce que vous écrivez doit être hautement optimisée, ne pas utiliser quelque chose comme ça - si vous avez du format des millions de chaînes de cette façon, dans une boucle, de la mémoire et des performances pourraient être importants.

D'autre part, si vous êtes inquiet au sujet de l'écriture lisible, maintenable code - et si vous êtes en train de faire, de dire, un tas d'opérations de base de données, dans le grand schéma des choses, cette fonction ne sera pas ajouter une surcharge importante.

...

Pour des raisons de commodité, j'ai essayer d'ajouter une méthode qui permettrait d'accepter un objet anonyme au lieu d'un dictionnaire:

public static String Substitute(this String template, object obj)
{
    return Substitute(
        template,
        obj.GetType().GetProperties().ToDictionary(p => p.Name, p => p.GetValue(obj, null))
    );
}

Pour une raison quelconque, cela ne fonctionne pas - le passage d'un objet anonyme comme new { name: "value" } pour cette extension de la méthode donne une erreur de compilation message disant que le meilleur match a été le IDictionary version de cette méthode. Vous ne savez pas comment résoudre ce problème. (quelqu'un?)

OriginalL'auteur mindplay.dk

Constitué à partir des regex pourrait faire l'affaire , surtout si il y a beaucoup de jetons d'être remplacé. Si il y a juste une poignée d'entre eux et de la performance est la clé, je voudrais simplement trouver le jeton à l'index et de le remplacer à l'aide de fonctions de chaînes de caractères. Le croire ou pas ce sera plus rapide que d'une expression régulière.

OriginalL'auteur Andrew Hare

ou essayer avec Linq si vous avez toutes vos remplacer les valeurs stockées dans un Dictionnaire obj.

Par exemple:

Dictionary<string,string> dict = new Dictionary<string,string>();
dict.add("replace1","newVal1");
dict.add("replace2","newVal2");
dict.add("replace3","newVal3");

var newstr = dict.Aggregate(str, (current, value) => current.Replace(value.Key, value.Value));

dict est votre rechercher-remplacer les paires défini dans le Dictionnaire de l'objet.
str est votre chaîne dont vous avez besoin de faire quelques remplacements.

OriginalL'auteur Allen Wang