blocks|key|930109|text|你确认正则表达式太昂贵了吗？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|930110|正则表达式的成本被大大夸大了。对于这样一个简单的模式，性能会相当好，实际上可能只比直接搜索和替换稍差一点。另外，在构造正则表达式时，您是否尝试过使用Compiled标志？|offset|length|style|CODE|930111|也就是说，你不能使用最简单的方式吗，比如Replace|930112|string+varname+=+"name";
string+pattern+=+"{"+%2B+varname+%2B+"}";
Console.WriteLine("Hi+{name}".Replace(pattern,+"Mike"));|code-block|syntax|javascript|930113|entityMap^0|0|22|8|0|K|7|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@$D|S|E|T|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|U|8|@$D|V|E|W|F|G]]|9|@]|A|$]]|$1|J|3|K|5|L|7|X|8|@]|9|@]|A|$M|N]]|$1|O|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|P|$]]

Have you confirmed that regular expressions are too expensive?

The cost of regular expressions is greatly exaggerated. For such a simple pattern performance will be quite good, probably only slightly less good than direct search-and-replace, in fact. Also, have you experimented with the <code>Compiled</code> flag when constructing the regular expression?

That said, can't you just use the simplest way, i.e. <code>Replace</code>?

<pre><code>string varname = "name";
string pattern = "{" + varname + "}";
Console.WriteLine("Hi {name}".Replace(pattern, "Mike"));
</code></pre>

blocks|key|934979|text|编译后的正则表达式可能会做到这一点，特别是当有许多令牌需要替换时。如果它们只有几个，而且性能是关键，我会简单地通过索引找到令牌，并使用字符串函数替换。信不信由你，这将比正则表达式更快。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|934980|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

A compiled regex might do the trick , especially if there are many tokens to be replaced. If there are just a handful of them and performance is key, I would simply find the token by index and replace using string functions. Believe it or not this will be faster than a regex.

blocks|key|3353681|text|正则表达式当然是一个可行的选择，特别是对于MatchEvaluator|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3353682|++++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];
++++});|code-block|syntax|javascript|3353683|entityMap^0|L|E|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Regex is certainly a viable option, especially with a <code>MatchEvaluator</code>:

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

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

 Dictionary&lt;string, string&gt; vals = new Dictionary&lt;string, string&gt;();
 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];
 });
</code></pre>

blocks|key|4199429|text|现在，如果您在字典中有替换项，如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4199430|++++var++replacements+=+new+Dictionary<string,+string>();
++++replacements["name"]+=+"Mike";
++++replacements["age"]=+"20";|code-block|syntax|javascript|4199431|那么正则表达式就变得非常简单了：|4199432|Regex+regex+=+new+Regex(@"\{(?<key>\w%2B)\}");
++++string+formattext+=+"{name}+is+{age}+years+old";
++++string+newStr+=+regex.Replace(formattext,+
++++++++++++match=>replacements[match.Groups[1].Captures[0].Value]);|4199433|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Now if you have you replacements in a dictionary, like this:

<pre><code> var replacements = new Dictionary&lt;string, string&gt;();
 replacements["name"] = "Mike";
 replacements["age"]= "20";
</code></pre>

then the Regex becomes quite simple:

<pre><code>Regex regex = new Regex(@"\{(?&lt;key&gt;\w+)\}");
 string formattext = "{name} is {age} years old";
 string newStr = regex.Replace(formattext, 
 match=&gt;replacements[match.Groups[1].Captures[0].Value]);
</code></pre>

blocks|key|136010|text|尝试使用StringTemplate。它比这强大得多，但它做的工作无懈可击。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|136011|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Try using StringTemplate. It's much more powerful than that, but it does the job flawless.

blocks|key|930208|text|怎么样|type|unstyled|depth|inlineStyleRanges|entityRanges|data|930209|stringVar+=+"Hello,+{0}.+How+are+you+doing?";
arg1+=+"John";++++//+or+args[0]
String.Format(stringVar,+arg1)|code-block|syntax|javascript|930210|您甚至可以有多个参数，只需递增{x}并向Format()方法添加另一个参数。不确定不同，但是"string“和"String”都有这个方法。|930211|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

How about

<pre><code>stringVar = "Hello, {0}. How are you doing?";
arg1 = "John"; // or args[0]
String.Format(stringVar, arg1)
</code></pre>

You can even have multiple args, just increment the {x} and add another parameter to the Format() method. Not sure the different but both "string" and "String" have this method.

blocks|key|930237|text|经过思考，我意识到我真正希望的是String.Format()可以接受IDictionary作为参数，并且可以使用名称而不是索引来编写模板。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|930238|对于具有大量可能键/值的字符串替换，索引号导致字符串模板难以辨认-在某些情况下，您可能甚至不知道哪些项将具有哪些编号，因此我提出了以下扩展：|930239|https://gist.github.com/896724|offset|length|930240|基本上，这允许您使用带名称的字符串模板而不是数字，使用字典而不是数组，并允许您拥有String.Format()的所有其他良好功能，如果需要，允许使用自定义IFormatProvider，并允许使用所有常用的格式化语法-精度、长度等。|930241|String.Format参考资料中提供的example是一个很好的例子，说明了带有许多编号项的模板是如何变得完全难以辨认的-移植这个例子来使用这种新的扩展方法，您会得到如下所示：|930242|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);|code-block|syntax|javascript|930243|正如有人指出的，如果你写的东西需要高度优化，不要使用这样的东西-如果你必须以这种方式格式化数百万个字符串，在一个循环中，内存和性能开销可能会很大。|930244|另一方面，如果你关心编写易读、易维护的代码--如果你正在做，比如说，一堆数据库操作，在大方案中，这个函数不会增加任何显著的开销。|930245|..。|930246|为了方便起见，我确实尝试添加了一个接受匿名对象而不是字典的方法：|930247|public+static+String+Substitute(this+String+template,+object+obj)
{
++++return+Substitute(
++++++++template,
++++++++obj.GetType().GetProperties().ToDictionary(p+=>+p.Name,+p+=>+p.GetValue(obj,+null))
++++);
}|930248|由于某些原因，这种方法不起作用--向该扩展方法传递一个像new+{+name:+"value"+}这样的匿名对象会给出一条编译时错误消息，指出最佳匹配是该方法的IDictionary版本。不知道怎么解决这个问题。(有人吗？)|style|CODE|930249|entityMap|0|LINK|mutability|MUTABLE|url|1|http://msdn.microsoft.com/en-us/library/1ksz8yb7.aspx^0|0|0|0|U|0|0|0|L|7|1|0|0|0|0|0|0|0|S|L|0^^$0|@$1|2|3|4|5|6|7|1D|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1E|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1F|8|@]|9|@$F|1G|G|1H|1|1I]]|A|$]]|$1|H|3|I|5|6|7|1J|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|1K|8|@]|9|@$F|1L|G|1M|1|1N]]|A|$]]|$1|L|3|M|5|N|7|1O|8|@]|9|@]|A|$O|P]]|$1|Q|3|R|5|6|7|1P|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1R|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1S|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|N|7|1T|8|@]|9|@]|A|$O|P]]|$1|10|3|11|5|6|7|1U|8|@$F|1V|G|1W|12|13]]|9|@]|A|$]]|$1|14|3|-4|5|6|7|1X|8|@]|9|@]|A|$]]]|15|$16|$5|17|18|19|A|$1A|E]]|1B|$5|17|18|19|A|$1A|1C]]]]

After thinking about this, I realized what I actually wished for, was that String.Format() would take an IDictionary as argument, and that templates could be written using names instead of indexes.

For string substitutions with lots of possible keys/values, the index numbers result in illegible string templates - and in some cases, you may not even know which items are going to have what number, so I came up with the following extension:

<a href="https://gist.github.com/896724" rel="nofollow">https://gist.github.com/896724</a>

Basically this lets you use string templates with names instead of numbers, and a dictionary instead of an array, and lets you have all the other good features of String.Format(), allowing the use of a custom IFormatProvider, if needed, and allowing the use of all the usual formatting syntax - precision, length, etc.

The <a href="http://msdn.microsoft.com/en-us/library/1ksz8yb7.aspx" rel="nofollow">example</a> provided in the reference material for String.Format is a great example of how templates with many numbered items become completely illegible - porting that example to use this new extension method, you get something like this:

<pre><code>var replacements = new Dictionary&lt;String, object&gt;()
 {
 { "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);
</code></pre>

As someone pointed out, if what you're writing needs to be highly optimized, don't use something like this - if you have to format millions of strings this way, in a loop, the memory and performance overhead could be significant.

On the other hand, if you're concerned about writing legible, maintainable code - and if you're doing, say, a bunch of database operations, in the grand scheme of things, this function will not add any significant overhead.

...

For convenience, I did attempt to add a method that would accept an anonymous object instead of a dictionary:

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

For some reason, this doesn't work - passing an anonymous object like <code>new { name: "value" }</code> to that extension method gives a compile-time error message saying the best match was the IDictionary version of that method. Not sure how to fix that. (anyone?)

blocks|key|3353921|text|或者，如果您将所有的替换值都存储在Dictionary+obj中，请尝试使用Linq执行此操作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3353922|例如：|3353923|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));|code-block|syntax|javascript|3353924|字典是您的搜索-替换对定义的字典对象。字符串是您需要替换的字符串。|offset|length|style|BOLD|3353925|entityMap^0|0|0|0|0|2|J|3|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@$K|U|L|V|M|N]|$K|W|L|X|M|N]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|P|$]]

or try this with Linq if you have all your replace values stored in a Dictionary obj. 

For example:

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

var newstr = dict.Aggregate(str, (current, value) =&gt; current.Replace(value.Key, value.Value));
</code></pre>

dict is your search-replace pairs defined Dictionary object. 
str is your string which you need to do some replacements with.

blocks|key|3353976|text|我会选择mindplay.dk解决方案。工作得很好。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3353977|而且，稍微修改一下，它就支持模板的模板，比如"Hi+{name}，你喜欢{0}吗？“，替换了{name}，但保留了{0}：|3353978|在给定源(https://gist.github.com/896724)中，替换为：|offset|length|3353979|++++++++var+format+=+Pattern.Replace(
++++++++++++template,
++++++++++++match+=>
++++++++++++++++{
++++++++++++++++++++var+name+=+match.Groups[1].Captures[0].Value;

++++++++++++++++++++if+(!int.TryParse(name,+out+parsedInt))
++++++++++++++++++++{
++++++++++++++++++++++++if+(!map.ContainsKey(name))
++++++++++++++++++++++++{
++++++++++++++++++++++++++++map[name]+=+map.Count;
++++++++++++++++++++++++++++list.Add(dictionary.ContainsKey(name)+?+dictionary[name]+:+null);
++++++++++++++++++++++++}

++++++++++++++++++++++++return+"{"+%2B+map[name]+%2B+match.Groups[2].Captures[0].Value+%2B+"}";
++++++++++++++++++++}
++++++++++++++++++++else+return+"{{"+%2B+name+%2B+"}}";
++++++++++++++++}
++++++++++++);|code-block|syntax|javascript|3353980|此外，它还支持长度({name,30})和格式化说明符，或者两者的组合。|3353981|entityMap|0|LINK|mutability|MUTABLE|url|https://gist.github.com/896724^0|0|0|5|U|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@$F|Z|G|10|1|11]]|A|$]]|$1|H|3|I|5|J|7|12|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|13|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

I would go for the mindplay.dk solution... Works quite well. 

And, with a slight modification, it supports templates-of-templates, like
"Hi {name}, do you like {0}?", replacing {name} but retaining {0}:

In the given source (<a href="https://gist.github.com/896724" rel="nofollow">https://gist.github.com/896724</a>), replace as follows:

<pre><code> var format = Pattern.Replace(
 template,
 match =&gt;
 {
 var name = match.Groups[1].Captures[0].Value;

 if (!int.TryParse(name, out parsedInt))
 {
 if (!map.ContainsKey(name))
 {
 map[name] = map.Count;
 list.Add(dictionary.ContainsKey(name) ? dictionary[name] : null);
 }

 return "{" + map[name] + match.Groups[2].Captures[0].Value + "}";
 }
 else return "{{" + name + "}}";
 }
 );
</code></pre>

Furthermore, it supports a length ({name,30}) as well as a formatspecifier, or a combination of both.

I want in a good performance way (I hope) replace a named parameter in my string to a named parameter from code, example, my string:

<pre><code>"Hi {name}, do you like milk?"
</code></pre>

How could I replace the {name} by code, Regular expressions? To expensive? Which way do you recommend?

How do they in example NHibernates HQL to replace :my_param to the user defined value? Or in ASP.NET (MVC) Routing that I like better, "{controller}/{action}", new { controller = "Hello", ... }?

C# Named parameters to a string that replace to the parameter values

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我想以一种性能良好的方式(我希望)将字符串中的命名参数替换为代码中的命名参数，例如，我的字符串："Hi {name}, do you like milk?"如何将{name}替换为代码、正则表达式？太贵了？你推荐哪种方式？他们如何在示例NHibernates HQL中替换:my_param到用户定义的值？或者在我更喜欢...

问将命名参数C#到替换为参数值的字符串
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将命名参数C#到替换为参数值的字符串EN