blocks|key|1517479|text|没有内置的方法来处理这个问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1517480|Here's+one+method|offset|length|1517481|string+myString+=+"{foo}+is+{bar}+and+{yadi}+is+{yada}".Inject(o);|code-block|syntax|javascript|1517482|Here's+another|1517483|Status.Text+=+"{UserName}+last+logged+in+at+{LastLoginDate}".FormatWith(user);|1517484|A+third+improved+method+partially+based+on+the+two+above，来自Phil+Haack|1517485|entityMap|0|LINK|mutability|MUTABLE|url|http://mo.notono.us/2008/07/c-stringinject-format-strings-by-key.html|1|http://james.newtonking.com/archive/2008/03/29/formatwith-2-0-string-formatting-with-named-variables.aspx|2|http://haacked.com/archive/2009/01/04/fun-with-named-formats-string-parsing-and-edge-cases.aspx^0|0|0|H|0|0|0|0|E|1|0|0|0|1K|2|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@]|9|@$D|14|E|15|1|16]]|A|$]]|$1|F|3|G|5|H|7|17|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|18|8|@]|9|@$D|19|E|1A|1|1B]]|A|$]]|$1|M|3|N|5|H|7|1C|8|@]|9|@]|A|$I|J]]|$1|O|3|P|5|6|7|1D|8|@]|9|@$D|1E|E|1F|1|1G]]|A|$]]|$1|Q|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]|Y|$5|T|U|V|A|$W|Z]]|10|$5|T|U|V|A|$W|11]]]]

There is no built-in method for handling this.

<a href="http://mo.notono.us/2008/07/c-stringinject-format-strings-by-key.html" rel="noreferrer">Here's one method</a>

<pre><code>string myString = "{foo} is {bar} and {yadi} is {yada}".Inject(o);
</code></pre>

<a href="http://james.newtonking.com/archive/2008/03/29/formatwith-2-0-string-formatting-with-named-variables.aspx" rel="noreferrer">Here's another</a>

<pre><code>Status.Text = "{UserName} last logged in at {LastLoginDate}".FormatWith(user);
</code></pre>

<a href="http://haacked.com/archive/2009/01/04/fun-with-named-formats-string-parsing-and-edge-cases.aspx" rel="noreferrer">A third improved method partially based on the two above</a>, from Phil Haack

blocks|key|1732615|text|我刚刚在我的博客上发布了一个实现：http://haacked.com/archive/2009/01/04/fun-with-named-formats-string-parsing-and-edge-cases.aspx|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1732616|它解决了这些其他实现在花括号转义方面存在的一些问题。这篇文章有详细的内容。它也做了DataBinder.Eval的事情，但仍然非常快。|1732617|entityMap|0|LINK|mutability|MUTABLE|url|http://haacked.com/archive/2009/01/04/fun-with-named-formats-string-parsing-and-edge-cases.aspx^0|H|2N|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

I have an implementation I just posted to my blog here: <a href="http://haacked.com/archive/2009/01/04/fun-with-named-formats-string-parsing-and-edge-cases.aspx" rel="noreferrer">http://haacked.com/archive/2009/01/04/fun-with-named-formats-string-parsing-and-edge-cases.aspx</a>

It addresses some issues that these other implementations have with brace escaping. The post has details. It does the DataBinder.Eval thing too, but is still very fast.

blocks|key|1732737|text|您还可以使用匿名类型，如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1732738|++++public+string+Format(string+input,+object+p)
++++{
++++++++foreach+(PropertyDescriptor+prop+in+TypeDescriptor.GetProperties(p))
++++++++++++input+=+input.Replace("{"+%2B+prop.Name+%2B+"}",+(prop.GetValue(p)+??+"(null)").ToString());

++++++++return+input;
++++}|code-block|syntax|javascript|1732739|当然，如果您还想解析格式设置，则需要更多代码，但您可以使用以下函数格式化字符串，如：|1732740|Format("test+{first}+and+{another}",+new+{+first+=+"something",+another+=+"something+else"+})|1732741|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|$]]

You can also use anonymous types like this:

<pre><code> public string Format(string input, object p)
 {
 foreach (PropertyDescriptor prop in TypeDescriptor.GetProperties(p))
 input = input.Replace("{" + prop.Name + "}", (prop.GetValue(p) ?? "(null)").ToString());

 return input;
 }
</code></pre>

Of course it would require more code if you also want to parse formatting, but you can format a string using this function like:

<pre><code>Format("test {first} and {another}", new { first = "something", another = "something else" })
</code></pre>

blocks|key|1732657|text|请参阅https://stackoverflow.com/questions/271398?page=2#358259|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1732658|使用链接到的扩展，您可以编写以下代码：|1732659|var+str+=+"{foo}+{bar}+{baz}".Format(foo=>"foo",+bar=>2,+baz=>new+object());|code-block|syntax|javascript|1732660|你会得到"foo+2+System.Object“。|style|CODE|1732661|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/271398?page=2#358259^0|3|1K|0|0|0|0|4|K|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|11|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|12|8|@$A|13|B|14|M|N]]|9|@]|C|$]]|$1|O|3|-4|5|6|7|15|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]]]

See <a href="https://stackoverflow.com/questions/271398?page=2#358259">https://stackoverflow.com/questions/271398?page=2#358259</a>

With the linked-to extension you can write this:

<pre><code>var str = "{foo} {bar} {baz}".Format(foo=&gt;"foo", bar=&gt;2, baz=&gt;new object());
</code></pre>

and you'll get <code>"foo 2 System.Object</code>".

blocks|key|1517220|text|我认为你能得到的最接近的是一个索引格式：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1517221|String.Format("{0}+has+{1}+quote+types.",+"C#",+"1");|code-block|syntax|javascript|1517222|还有String.Replace()，如果你愿意在多个步骤中完成它，并且确信你不会在字符串中的其他地方找到你的‘变量’：|1517223|string+MyString+=+"{language}+has+{n}+quote+types.";
MyString+=+MyString.Replace("{language}",+"C#").Replace("{n}",+"1");|1517224|将其扩展为使用列表：|1517225|List<KeyValuePair<string,+string>>+replacements+=+GetFormatDictionary();++
foreach+(KeyValuePair<string,+string>+item+in+replacements)
{
++++MyString+=+MyString.Replace(item.Key,+item.Value);
}|1517226|您可以使用Dictionary通过迭代它的.Keys集合来做到这一点，但是通过使用List>，我们可以利用List的.ForEach()方法并将其压缩回一行代码：|1517227|replacements.ForEach(delegate(KeyValuePair<string,string>)+item)+{+MyString+=+MyString.Replace(item.Key,+item.Value);});|1517228|lambda会更简单，但我仍然使用.Net+2.0。还要注意，在迭代使用时，.Replace()的性能并不出色，因为.Net中的字符串是不可变的。此外，这要求MyString变量的定义方式使得委托可以访问它，因此它还不够完美。|offset|length|style|CODE|1517229|entityMap^0|0|0|0|0|0|0|0|0|27|8|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|16|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|18|8|@$U|19|V|1A|W|X]]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|Z|$]]

I think the closest you'll get is an indexed format:

<pre><code>String.Format("{0} has {1} quote types.", "C#", "1");
</code></pre>

There's also String.Replace(), if you're willing to do it in multiple steps and take it on faith that you won't find your 'variables' anywhere else in the string:

<pre><code>string MyString = "{language} has {n} quote types.";
MyString = MyString.Replace("{language}", "C#").Replace("{n}", "1");
</code></pre>

Expanding this to use a List:

<pre><code>List&lt;KeyValuePair&lt;string, string&gt;&gt; replacements = GetFormatDictionary(); 
foreach (KeyValuePair&lt;string, string&gt; item in replacements)
{
 MyString = MyString.Replace(item.Key, item.Value);
}
</code></pre>

You could do that with a Dictionary&lt;string, string> too by iterating it's .Keys collections, but by using a List&lt;KeyValuePair&lt;string, string>> we can take advantage of the List's .ForEach() method and condense it back to a one-liner:

<pre><code>replacements.ForEach(delegate(KeyValuePair&lt;string,string&gt;) item) { MyString = MyString.Replace(item.Key, item.Value);});
</code></pre>

A lambda would be even simpler, but I'm still on .Net 2.0. Also note that the .Replace() performance isn't stellar when used iteratively, since strings in .Net are immutable. Also, this requires the <code>MyString</code> variable be defined in such a way that it's accessible to the delegate, so it's not perfect yet.

blocks|key|1517872|text|private+static+Regex+s_NamedFormatRegex+=+new+Regex(@"\{(?!\{)(?<key>[\w]%2B)(:(?<fmt>(\{\{%7C\}\}%7C[%5E\{\}])*)?)?\}",+RegexOptions.Compiled);

public+static+StringBuilder+AppendNamedFormat(this+StringBuilder+builder,IFormatProvider+provider,+string+format,+IDictionary<string,+object>+args)
{
++++if+(builder+==+null)+throw+new+ArgumentNullException("builder");
++++var+str+=+s_NamedFormatRegex.Replace(format,+(mt)+=>+{
++++++++string+key+=+mt.Groups["key"].Value;
++++++++string+fmt+=+mt.Groups["fmt"].Value;
++++++++object+value+=+null;
++++++++if+(args.TryGetValue(key,out+value))+{
++++++++++++return+string.Format(provider,+"{0:"+%2B+fmt+%2B+"}",+value);
++++++++}+else+{
++++++++++++return+mt.Value;
++++++++}
++++});
++++builder.Append(str);
++++return+builder;
}

public+static+StringBuilder+AppendNamedFormat(this+StringBuilder+builder,+string+format,+IDictionary<string,+object>+args)
{
++++if+(builder+==+null)+throw+new+ArgumentNullException("builder");
++++return+builder.AppendNamedFormat(null,+format,+args);
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1517873|示例：|unstyled|1517874|var+builder+=+new+StringBuilder();
builder.AppendNamedFormat(
@"你好,{Name},今天是{Date:yyyy/MM/dd},+这是你第{LoginTimes}次登录，积分{Score:{{+0.00+}}}",
new+Dictionary<string,+object>()+{+
++++{+"Name",+"wayjet"+},
++++{+"LoginTimes",18+},
++++{+"Score",+100.4+},
++++{+"Date",DateTime.Now+}
});|1517875|输出:你好，wayjet，今天是2011-05-04，这是你第18次登录，积分{+100.40+}|1517876|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$B|C]]|$1|I|3|J|5|F|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|F|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<pre><code>private static Regex s_NamedFormatRegex = new Regex(@"\{(?!\{)(?&lt;key&gt;[\w]+)(:(?&lt;fmt&gt;(\{\{|\}\}|[^\{\}])*)?)?\}", RegexOptions.Compiled);

public static StringBuilder AppendNamedFormat(this StringBuilder builder,IFormatProvider provider, string format, IDictionary&lt;string, object&gt; args)
{
 if (builder == null) throw new ArgumentNullException("builder");
 var str = s_NamedFormatRegex.Replace(format, (mt) =&gt; {
 string key = mt.Groups["key"].Value;
 string fmt = mt.Groups["fmt"].Value;
 object value = null;
 if (args.TryGetValue(key,out value)) {
 return string.Format(provider, "{0:" + fmt + "}", value);
 } else {
 return mt.Value;
 }
 });
 builder.Append(str);
 return builder;
}

public static StringBuilder AppendNamedFormat(this StringBuilder builder, string format, IDictionary&lt;string, object&gt; args)
{
 if (builder == null) throw new ArgumentNullException("builder");
 return builder.AppendNamedFormat(null, format, args);
}
</code></pre>

Example:

<pre><code>var builder = new StringBuilder();
builder.AppendNamedFormat(
@"你好,{Name},今天是{Date:yyyy/MM/dd}, 这是你第{LoginTimes}次登录，积分{Score:{{ 0.00 }}}",
new Dictionary&lt;string, object&gt;() { 
 { "Name", "wayjet" },
 { "LoginTimes",18 },
 { "Score", 100.4 },
 { "Date",DateTime.Now }
});
</code></pre>

Output:
你好,wayjet,今天是2011-05-04, 这是你第18次登录，积分{ 100.40 }

blocks|key|1517942|text|检查这一条：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1517943|public+static+string+StringFormat(string+format,+object+source)
{
++++var+matches+=+Regex.Matches(format,+@"\{(.%2B?)\}");
++++List<string>+keys+=+(from+Match+matche+in+matches+select+matche.Groups[1].Value).ToList();

++++return+keys.Aggregate(
++++++++format,
++++++++(current,+key)+=>
++++++++{
++++++++++++int+colonIndex+=+key.IndexOf(':');
++++++++++++return+current.Replace(
++++++++++++++++"{"+%2B+key+%2B+"}",
++++++++++++++++colonIndex+>+0
++++++++++++++++++++?+DataBinder.Eval(source,+key.Substring(0,+colonIndex),+"{0:"+%2B+key.Substring(colonIndex+%2B+1)+%2B+"}")
++++++++++++++++++++:+DataBinder.Eval(source,+key).ToString());
++++++++});
}|code-block|syntax|javascript|1517944|示例：|1517945|string+format+=+"{foo}+is+a+{bar}+is+a+{baz}+is+a+{qux:#.#}+is+a+really+big+{fizzle}";
var+o+=+new+{+foo+=+123,+bar+=+true,+baz+=+"this+is+a+test",+qux+=+123.45,+fizzle+=+DateTime.Now+};
Console.WriteLine(StringFormat(format,+o));|1517946|与其他解决方案相比，性能相当不错。|1517947|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Check this one:

<pre><code>public static string StringFormat(string format, object source)
{
 var matches = Regex.Matches(format, @"\{(.+?)\}");
 List&lt;string&gt; keys = (from Match matche in matches select matche.Groups[1].Value).ToList();

 return keys.Aggregate(
 format,
 (current, key) =&gt;
 {
 int colonIndex = key.IndexOf(':');
 return current.Replace(
 "{" + key + "}",
 colonIndex &gt; 0
 ? DataBinder.Eval(source, key.Substring(0, colonIndex), "{0:" + key.Substring(colonIndex + 1) + "}")
 : DataBinder.Eval(source, key).ToString());
 });
}
</code></pre>

Sample:

<pre><code>string format = "{foo} is a {bar} is a {baz} is a {qux:#.#} is a really big {fizzle}";
var o = new { foo = 123, bar = true, baz = "this is a test", qux = 123.45, fizzle = DateTime.Now };
Console.WriteLine(StringFormat(format, o));
</code></pre>

Performance is pretty ok compared to other solutions.

blocks|key|1732353|text|我怀疑这是不可能的。首先想到的是如何访问本地变量名？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1732354|然而，使用LINQ和Lambda表达式可能会有一些聪明的方法来实现这一点。|1732355|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

I doubt this will be possible. The first thing that comes to mind is how are you going to get access to local variable names?

There might be some clever way using LINQ and Lambda expressions to do this however.

blocks|key|1732829|text|这是我前段时间做的一个。它使用带有单个参数的Format方法扩展字符串。好的是，如果你提供一个简单的参数，比如整数，它将使用标准的string.Format，但是如果你使用匿名类型，它也可以工作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1732830|示例用法：|1732831|"The+{Name}+family+has+{Children}+children".Format(new+{+Children+=+4,+Name+=+"Smith"+})|code-block|syntax|javascript|1732832|将导致“Smith家族有4个孩子”。|1732833|它不会像数组和索引器那样做疯狂的绑定工作。但它是超级简单和高性能的。|1732834|++++public+static+class+AdvancedFormatString
{

++++///+<summary>
++++///+An+advanced+version+of+string.Format.++If+you+pass+a+primitive+object+(string,+int,+etc),+it+acts+like+the+regular+string.Format.++If+you+pass+an+anonmymous+type,+you+can+name+the+paramters+by+property+name.
++++///+</summary>
++++///+<param+name="formatString"></param>
++++///+<param+name="arg"></param>
++++///+<returns></returns>
++++///+<example>
++++///+"The+{Name}+family+has+{Children}+children".Format(new+{+Children+=+4,+Name+=+"Smith"+})
++++///+
++++///+results+in+
++++///+"This+Smith+family+has+4+children
++++///+</example>
++++public+static+string+Format(this+string+formatString,+object+arg,+IFormatProvider+format+=+null)
++++{
++++++++if+(arg+==+null)
++++++++++++return+formatString;

++++++++var+type+=+arg.GetType();
++++++++if+(Type.GetTypeCode(type)+!=+TypeCode.Object+%7C%7C+type.IsPrimitive)
++++++++++++return+string.Format(format,+formatString,+arg);

++++++++var+properties+=+TypeDescriptor.GetProperties(arg);
++++++++return+formatString.Format((property)+=>
++++++++++++{
++++++++++++++++var+value+=+properties[property].GetValue(arg);
++++++++++++++++return+Convert.ToString(value,+format);
++++++++++++});
++++}


++++public+static+string+Format(this+string+formatString,+Func<string,+string>+formatFragmentHandler)
++++{
++++++++if+(string.IsNullOrEmpty(formatString))
++++++++++++return+formatString;
++++++++Fragment[]+fragments+=+GetParsedFragments(formatString);
++++++++if+(fragments+==+null+%7C%7C+fragments.Length+==+0)
++++++++++++return+formatString;

++++++++return+string.Join(string.Empty,+fragments.Select(fragment+=>
++++++++++++{
++++++++++++++++if+(fragment.Type+==+FragmentType.Literal)
++++++++++++++++++++return+fragment.Value;
++++++++++++++++else
++++++++++++++++++++return+formatFragmentHandler(fragment.Value);
++++++++++++}).ToArray());
++++}


++++private+static+Fragment[]+GetParsedFragments(string+formatString)
++++{
++++++++Fragment[]+fragments;
++++++++if+(+parsedStrings.TryGetValue(formatString,+out+fragments)+)
++++++++{
++++++++++++return+fragments;
++++++++}
++++++++lock+(parsedStringsLock)
++++++++{
++++++++++++if+(+!parsedStrings.TryGetValue(formatString,+out+fragments)+)
++++++++++++{
++++++++++++++++fragments+=+Parse(formatString);
++++++++++++++++parsedStrings.Add(formatString,+fragments);
++++++++++++}
++++++++}
++++++++return+fragments;
++++}

++++private+static+Object+parsedStringsLock+=+new+Object();
++++private+static+Dictionary<string,Fragment[]>+parsedStrings+=+new+Dictionary<string,Fragment[]>(StringComparer.Ordinal);

++++const+char+OpeningDelimiter+=+'{';
++++const+char+ClosingDelimiter+=+'}';

++++///+<summary>
++++///+Parses+the+given+format+string+into+a+list+of+fragments.
++++///+</summary>
++++///+<param+name="format"></param>
++++///+<returns></returns>
++++static+Fragment[]+Parse(string+format)
++++{
++++++++int+lastCharIndex+=+format.Length+-+1;
++++++++int+currFragEndIndex;
++++++++Fragment+currFrag+=+ParseFragment(format,+0,+out+currFragEndIndex);

++++++++if+(currFragEndIndex+==+lastCharIndex)
++++++++{
++++++++++++return+new+Fragment[]+{+currFrag+};
++++++++}

++++++++List<Fragment>+fragments+=+new+List<Fragment>();
++++++++while+(true)
++++++++{
++++++++++++fragments.Add(currFrag);
++++++++++++if+(currFragEndIndex+==+lastCharIndex)
++++++++++++{
++++++++++++++++break;
++++++++++++}
++++++++++++currFrag+=+ParseFragment(format,+currFragEndIndex+%2B+1,+out+currFragEndIndex);
++++++++}
++++++++return+fragments.ToArray();

++++}

++++///+<summary>
++++///+Finds+the+next+delimiter+from+the+starting+index.
++++///+</summary>
++++static+Fragment+ParseFragment(string+format,+int+startIndex,+out+int+fragmentEndIndex)
++++{
++++++++bool+foundEscapedDelimiter+=+false;
++++++++FragmentType+type+=+FragmentType.Literal;

++++++++int+numChars+=+format.Length;
++++++++for+(int+i+=+startIndex;+i+<+numChars;+i%2B%2B)
++++++++{
++++++++++++char+currChar+=+format[i];
++++++++++++bool+isOpenBrace+=+currChar+==+OpeningDelimiter;
++++++++++++bool+isCloseBrace+=+isOpenBrace+?+false+:+currChar+==+ClosingDelimiter;

++++++++++++if+(!isOpenBrace+&&+!isCloseBrace)
++++++++++++{
++++++++++++++++continue;
++++++++++++}
++++++++++++else+if+(i+<+(numChars+-+1)+&&+format[i+%2B+1]+==+currChar)
++++++++++++{//{{+or+}}
++++++++++++++++i%2B%2B;
++++++++++++++++foundEscapedDelimiter+=+true;
++++++++++++}
++++++++++++else+if+(isOpenBrace)
++++++++++++{
++++++++++++++++if+(i+==+startIndex)
++++++++++++++++{
++++++++++++++++++++type+=+FragmentType.FormatItem;
++++++++++++++++}
++++++++++++++++else
++++++++++++++++{

++++++++++++++++++++if+(type+==+FragmentType.FormatItem)
++++++++++++++++++++++++throw+new+FormatException("Two+consequtive+unescaped+{+format+item+openers+were+found.++Either+close+the+first+or+escape+any+literals+with+another+{.");

++++++++++++++++++++//curr+character+is+the+opening+of+a+new+format+item.++so+we+close+this+literal+out
++++++++++++++++++++string+literal+=+format.Substring(startIndex,+i+-+startIndex);
++++++++++++++++++++if+(foundEscapedDelimiter)
++++++++++++++++++++++++literal+=+ReplaceEscapes(literal);

++++++++++++++++++++fragmentEndIndex+=+i+-+1;
++++++++++++++++++++return+new+Fragment(FragmentType.Literal,+literal);
++++++++++++++++}
++++++++++++}
++++++++++++else
++++++++++++{//close+bracket
++++++++++++++++if+(i+==+startIndex+%7C%7C+type+==+FragmentType.Literal)
++++++++++++++++++++throw+new+FormatException("A+}+closing+brace+existed+without+an+opening+{+brace.");

++++++++++++++++string+formatItem+=+format.Substring(startIndex+%2B+1,+i+-+startIndex+-+1);
++++++++++++++++if+(foundEscapedDelimiter)
++++++++++++++++++++formatItem+=+ReplaceEscapes(formatItem);//a+format+item+with+a+{+or+}+in+its+name+is+crazy+but+it+could+be+done
++++++++++++++++fragmentEndIndex+=+i;
++++++++++++++++return+new+Fragment(FragmentType.FormatItem,+formatItem);
++++++++++++}
++++++++}

++++++++if+(type+==+FragmentType.FormatItem)
++++++++++++throw+new+FormatException("A+format+item+was+opened+with+{+but+was+never+closed.");

++++++++fragmentEndIndex+=+numChars+-+1;
++++++++string+literalValue+=+format.Substring(startIndex);
++++++++if+(foundEscapedDelimiter)
++++++++++++literalValue+=+ReplaceEscapes(literalValue);

++++++++return+new+Fragment(FragmentType.Literal,+literalValue);

++++}

++++///+<summary>
++++///+Replaces+escaped+brackets,+turning+'{{'+and+'}}'+into+'{'+and+'}',+respectively.
++++///+</summary>
++++///+<param+name="value"></param>
++++///+<returns></returns>
++++static+string+ReplaceEscapes(string+value)
++++{
++++++++return+value.Replace("{{",+"{").Replace("}}",+"}");
++++}

++++private+enum+FragmentType
++++{
++++++++Literal,
++++++++FormatItem
++++}

++++private+class+Fragment
++++{

++++++++public+Fragment(FragmentType+type,+string+value)
++++++++{
++++++++++++Type+=+type;
++++++++++++Value+=+value;
++++++++}

++++++++public+FragmentType+Type
++++++++{
++++++++++++get;
++++++++++++private+set;
++++++++}

++++++++///+<summary>
++++++++///+The+literal+value,+or+the+name+of+the+fragment,+depending+on+fragment+type.
++++++++///+</summary>
++++++++public+string+Value
++++++++{
++++++++++++get;
++++++++++++private+set;
++++++++}


++++}

}|1732835|entityMap^0|0|0|0|0|0|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|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|V|8|@]|9|@]|A|$G|H]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Here's one I made a while back. It extends String with a Format method taking a single argument. The nice thing is that it'll use the standard string.Format if you provide a simple argument like an int, but if you use something like anonymous type it'll work too.

Example usage:

<pre><code>"The {Name} family has {Children} children".Format(new { Children = 4, Name = "Smith" })
</code></pre>

Would result in "The Smith family has 4 children."

It doesn't do crazy binding stuff like arrays and indexers. But it is super simple and high performance.

<pre><code> public static class AdvancedFormatString
{

 /// &lt;summary&gt;
 /// An advanced version of string.Format. If you pass a primitive object (string, int, etc), it acts like the regular string.Format. If you pass an anonmymous type, you can name the paramters by property name.
 /// &lt;/summary&gt;
 /// &lt;param name="formatString"&gt;&lt;/param&gt;
 /// &lt;param name="arg"&gt;&lt;/param&gt;
 /// &lt;returns&gt;&lt;/returns&gt;
 /// &lt;example&gt;
 /// "The {Name} family has {Children} children".Format(new { Children = 4, Name = "Smith" })
 /// 
 /// results in 
 /// "This Smith family has 4 children
 /// &lt;/example&gt;
 public static string Format(this string formatString, object arg, IFormatProvider format = null)
 {
 if (arg == null)
 return formatString;

 var type = arg.GetType();
 if (Type.GetTypeCode(type) != TypeCode.Object || type.IsPrimitive)
 return string.Format(format, formatString, arg);

 var properties = TypeDescriptor.GetProperties(arg);
 return formatString.Format((property) =&gt;
 {
 var value = properties[property].GetValue(arg);
 return Convert.ToString(value, format);
 });
 }


 public static string Format(this string formatString, Func&lt;string, string&gt; formatFragmentHandler)
 {
 if (string.IsNullOrEmpty(formatString))
 return formatString;
 Fragment[] fragments = GetParsedFragments(formatString);
 if (fragments == null || fragments.Length == 0)
 return formatString;

 return string.Join(string.Empty, fragments.Select(fragment =&gt;
 {
 if (fragment.Type == FragmentType.Literal)
 return fragment.Value;
 else
 return formatFragmentHandler(fragment.Value);
 }).ToArray());
 }


 private static Fragment[] GetParsedFragments(string formatString)
 {
 Fragment[] fragments;
 if ( parsedStrings.TryGetValue(formatString, out fragments) )
 {
 return fragments;
 }
 lock (parsedStringsLock)
 {
 if ( !parsedStrings.TryGetValue(formatString, out fragments) )
 {
 fragments = Parse(formatString);
 parsedStrings.Add(formatString, fragments);
 }
 }
 return fragments;
 }

 private static Object parsedStringsLock = new Object();
 private static Dictionary&lt;string,Fragment[]&gt; parsedStrings = new Dictionary&lt;string,Fragment[]&gt;(StringComparer.Ordinal);

 const char OpeningDelimiter = '{';
 const char ClosingDelimiter = '}';

 /// &lt;summary&gt;
 /// Parses the given format string into a list of fragments.
 /// &lt;/summary&gt;
 /// &lt;param name="format"&gt;&lt;/param&gt;
 /// &lt;returns&gt;&lt;/returns&gt;
 static Fragment[] Parse(string format)
 {
 int lastCharIndex = format.Length - 1;
 int currFragEndIndex;
 Fragment currFrag = ParseFragment(format, 0, out currFragEndIndex);

 if (currFragEndIndex == lastCharIndex)
 {
 return new Fragment[] { currFrag };
 }

 List&lt;Fragment&gt; fragments = new List&lt;Fragment&gt;();
 while (true)
 {
 fragments.Add(currFrag);
 if (currFragEndIndex == lastCharIndex)
 {
 break;
 }
 currFrag = ParseFragment(format, currFragEndIndex + 1, out currFragEndIndex);
 }
 return fragments.ToArray();

 }

 /// &lt;summary&gt;
 /// Finds the next delimiter from the starting index.
 /// &lt;/summary&gt;
 static Fragment ParseFragment(string format, int startIndex, out int fragmentEndIndex)
 {
 bool foundEscapedDelimiter = false;
 FragmentType type = FragmentType.Literal;

 int numChars = format.Length;
 for (int i = startIndex; i &lt; numChars; i++)
 {
 char currChar = format[i];
 bool isOpenBrace = currChar == OpeningDelimiter;
 bool isCloseBrace = isOpenBrace ? false : currChar == ClosingDelimiter;

 if (!isOpenBrace &amp;&amp; !isCloseBrace)
 {
 continue;
 }
 else if (i &lt; (numChars - 1) &amp;&amp; format[i + 1] == currChar)
 {//{{ or }}
 i++;
 foundEscapedDelimiter = true;
 }
 else if (isOpenBrace)
 {
 if (i == startIndex)
 {
 type = FragmentType.FormatItem;
 }
 else
 {

 if (type == FragmentType.FormatItem)
 throw new FormatException("Two consequtive unescaped { format item openers were found. Either close the first or escape any literals with another {.");

 //curr character is the opening of a new format item. so we close this literal out
 string literal = format.Substring(startIndex, i - startIndex);
 if (foundEscapedDelimiter)
 literal = ReplaceEscapes(literal);

 fragmentEndIndex = i - 1;
 return new Fragment(FragmentType.Literal, literal);
 }
 }
 else
 {//close bracket
 if (i == startIndex || type == FragmentType.Literal)
 throw new FormatException("A } closing brace existed without an opening { brace.");

 string formatItem = format.Substring(startIndex + 1, i - startIndex - 1);
 if (foundEscapedDelimiter)
 formatItem = ReplaceEscapes(formatItem);//a format item with a { or } in its name is crazy but it could be done
 fragmentEndIndex = i;
 return new Fragment(FragmentType.FormatItem, formatItem);
 }
 }

 if (type == FragmentType.FormatItem)
 throw new FormatException("A format item was opened with { but was never closed.");

 fragmentEndIndex = numChars - 1;
 string literalValue = format.Substring(startIndex);
 if (foundEscapedDelimiter)
 literalValue = ReplaceEscapes(literalValue);

 return new Fragment(FragmentType.Literal, literalValue);

 }

 /// &lt;summary&gt;
 /// Replaces escaped brackets, turning '{{' and '}}' into '{' and '}', respectively.
 /// &lt;/summary&gt;
 /// &lt;param name="value"&gt;&lt;/param&gt;
 /// &lt;returns&gt;&lt;/returns&gt;
 static string ReplaceEscapes(string value)
 {
 return value.Replace("{{", "{").Replace("}}", "}");
 }

 private enum FragmentType
 {
 Literal,
 FormatItem
 }

 private class Fragment
 {

 public Fragment(FragmentType type, string value)
 {
 Type = type;
 Value = value;
 }

 public FragmentType Type
 {
 get;
 private set;
 }

 /// &lt;summary&gt;
 /// The literal value, or the name of the fragment, depending on fragment type.
 /// &lt;/summary&gt;
 public string Value
 {
 get;
 private set;
 }


 }

}
</code></pre>

blocks|key|1518027|text|下面是一个用于任何对象的简单方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1518028|++++using+System.Text.RegularExpressions;
++++using+System.ComponentModel;

++++public+static+string+StringWithFormat(string+format,+object+args)
++++{
++++++++Regex+r+=+new+Regex(@"\{([A-Za-z0-9_]%2B)\}");

++++++++MatchCollection+m+=+r.Matches(format);

++++++++var+properties+=+TypeDescriptor.GetProperties(args);

++++++++foreach+(Match+item+in+m)
++++++++{
++++++++++++try
++++++++++++{
++++++++++++++++string+propertyName+=+item.Groups[1].Value;
++++++++++++++++format+=+format.Replace(item.Value,+properties[propertyName].GetValue(args).ToString());
++++++++++++}
++++++++++++catch
++++++++++++{
++++++++++++++++throw+new+FormatException("The+format+string+is+not+valid");
++++++++++++}
++++++++}

++++++++return+format;
++++}|code-block|syntax|javascript|1518029|这里是如何使用它的：|1518030|+DateTime+date+=+DateTime.Now;
+string+dateString+=+StringWithFormat("{Month}/{Day}/{Year}",+date);|1518031|输出:+2/27/2012|1518032|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

here is a simple method for any object:

<pre><code> using System.Text.RegularExpressions;
 using System.ComponentModel;

 public static string StringWithFormat(string format, object args)
 {
 Regex r = new Regex(@"\{([A-Za-z0-9_]+)\}");

 MatchCollection m = r.Matches(format);

 var properties = TypeDescriptor.GetProperties(args);

 foreach (Match item in m)
 {
 try
 {
 string propertyName = item.Groups[1].Value;
 format = format.Replace(item.Value, properties[propertyName].GetValue(args).ToString());
 }
 catch
 {
 throw new FormatException("The format string is not valid");
 }
 }

 return format;
 }
</code></pre>

And here how to use it:

<pre><code> DateTime date = DateTime.Now;
 string dateString = StringWithFormat("{Month}/{Day}/{Year}", date);
</code></pre>

output : 2/27/2012

blocks|key|1733070|text|我实现了这是一个简单的类，它复制了String.Format的功能(使用类时除外)。您可以使用字典或类型来定义字段。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1733071|https://github.com/SergueiFedorov/NamedFormatString|offset|length|1733072|C#+6.0将此功能直接添加到语言规范中，因此NamedFormatString是为了向后兼容。|style|CODE|1733073|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|1F|0|0|N|H|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@$D|S|E|T|1|U]]|A|$]]|$1|F|3|G|5|6|7|V|8|@$D|W|E|X|H|I]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|C]]]]

I implemented this is a simple class that duplicates the functionality of String.Format (except for when using classes). You can either use a dictionary or a type to define fields.

<a href="https://github.com/SergueiFedorov/NamedFormatString" rel="nofollow">https://github.com/SergueiFedorov/NamedFormatString</a>

C# 6.0 is adding this functionality right into the language spec, so <code>NamedFormatString</code> is for backwards compatibility.

blocks|key|1733122|text|我以一种与现有解决方案略有不同的方式解决了这个问题。它完成了命名项替换的核心部分(而不是一些人所做的反射部分)。它非常快速和简单……这是我的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1733123|///+<summary>
///+Formats+a+string+with+named+format+items+given+a+template+dictionary+of+the+items+values+to+use.
///+</summary>
public+class+StringTemplateFormatter
{
++++private+readonly+IFormatProvider+_formatProvider;

++++///+<summary>
++++///+Constructs+the+formatter+with+the+specified+<see+cref="IFormatProvider"/>.
++++///+This+is+defaulted+to+<see+cref="CultureInfo.CurrentCulture">CultureInfo.CurrentCulture</see>+if+none+is+provided.
++++///+</summary>
++++///+<param+name="formatProvider"></param>
++++public+StringTemplateFormatter(IFormatProvider+formatProvider+=+null)
++++{
++++++++_formatProvider+=+formatProvider+??+CultureInfo.CurrentCulture;
++++}

++++///+<summary>
++++///+Formats+a+string+with+named+format+items+given+a+template+dictionary+of+the+items+values+to+use.
++++///+</summary>
++++///+<param+name="text">The+text+template</param>
++++///+<param+name="templateValues">The+named+values+to+use+as+replacements+in+the+formatted+string.</param>
++++///+<returns>The+resultant+text+string+with+the+template+values+replaced.</returns>
++++public+string+FormatTemplate(string+text,+Dictionary<string,+object>+templateValues)
++++{
++++++++var+formattableString+=+text;
++++++++var+values+=+new+List<object>();
++++++++foreach+(KeyValuePair<string,+object>+value+in+templateValues)
++++++++{
++++++++++++var+index+=+values.Count;
++++++++++++formattableString+=+ReplaceFormattableItem(formattableString,+value.Key,+index);
++++++++++++values.Add(value.Value);
++++++++}
++++++++return+String.Format(_formatProvider,+formattableString,+values.ToArray());
++++}

++++///+<summary>
++++///+Convert+named+string+template+item+to+numbered+string+template+item+that+can+be+accepted+by+<see+cref="string.Format(string,object[])">String.Format</see>
++++///+</summary>
++++///+<param+name="formattableString">The+string+containing+the+named+format+item</param>
++++///+<param+name="itemName">The+name+of+the+format+item</param>
++++///+<param+name="index">The+index+to+use+for+the+item+value</param>
++++///+<returns>The+formattable+string+with+the+named+item+substituted+with+the+numbered+format+item.</returns>
++++private+static+string+ReplaceFormattableItem(string+formattableString,+string+itemName,+int+index)
++++{
++++++++return+formattableString
++++++++++++.Replace("{"+%2B+itemName+%2B+"}",+"{"+%2B+index+%2B+"}")
++++++++++++.Replace("{"+%2B+itemName+%2B+",",+"{"+%2B+index+%2B+",")
++++++++++++.Replace("{"+%2B+itemName+%2B+":",+"{"+%2B+index+%2B+":");
++++}
}|code-block|syntax|javascript|1733124|它的使用方法如下：|1733125|++++[Test]
++++public+void+FormatTemplate_GivenANamedGuid_FormattedWithB_ShouldFormatCorrectly()
++++{
++++++++//+Arrange
++++++++var+template+=+"My+guid+{MyGuid:B}+is+awesome!";
++++++++var+templateValues+=+new+Dictionary<string,+object>+{+{+"MyGuid",+new+Guid("{A4D2A7F1-421C-4A1D-9CB2-9C2E70B05E19}")+}+};
++++++++var+sut+=+new+StringTemplateFormatter();
++++++++//+Act
++++++++var+result+=+sut.FormatTemplate(template,+templateValues);
++++++++//Assert
++++++++Assert.That(result,+Is.EqualTo("My+guid+{a4d2a7f1-421c-4a1d-9cb2-9c2e70b05e19}+is+awesome!"));
++++}|1733126|希望有人觉得这篇文章有用！|1733127|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I solved this in a slightly different way to the existing solutions.
It does the core of the named item replacement (not the reflection bit that some have done). It is extremely fast and simple...
This is my solution:

<pre><code>/// &lt;summary&gt;
/// Formats a string with named format items given a template dictionary of the items values to use.
/// &lt;/summary&gt;
public class StringTemplateFormatter
{
 private readonly IFormatProvider _formatProvider;

 /// &lt;summary&gt;
 /// Constructs the formatter with the specified &lt;see cref="IFormatProvider"/&gt;.
 /// This is defaulted to &lt;see cref="CultureInfo.CurrentCulture"&gt;CultureInfo.CurrentCulture&lt;/see&gt; if none is provided.
 /// &lt;/summary&gt;
 /// &lt;param name="formatProvider"&gt;&lt;/param&gt;
 public StringTemplateFormatter(IFormatProvider formatProvider = null)
 {
 _formatProvider = formatProvider ?? CultureInfo.CurrentCulture;
 }

 /// &lt;summary&gt;
 /// Formats a string with named format items given a template dictionary of the items values to use.
 /// &lt;/summary&gt;
 /// &lt;param name="text"&gt;The text template&lt;/param&gt;
 /// &lt;param name="templateValues"&gt;The named values to use as replacements in the formatted string.&lt;/param&gt;
 /// &lt;returns&gt;The resultant text string with the template values replaced.&lt;/returns&gt;
 public string FormatTemplate(string text, Dictionary&lt;string, object&gt; templateValues)
 {
 var formattableString = text;
 var values = new List&lt;object&gt;();
 foreach (KeyValuePair&lt;string, object&gt; value in templateValues)
 {
 var index = values.Count;
 formattableString = ReplaceFormattableItem(formattableString, value.Key, index);
 values.Add(value.Value);
 }
 return String.Format(_formatProvider, formattableString, values.ToArray());
 }

 /// &lt;summary&gt;
 /// Convert named string template item to numbered string template item that can be accepted by &lt;see cref="string.Format(string,object[])"&gt;String.Format&lt;/see&gt;
 /// &lt;/summary&gt;
 /// &lt;param name="formattableString"&gt;The string containing the named format item&lt;/param&gt;
 /// &lt;param name="itemName"&gt;The name of the format item&lt;/param&gt;
 /// &lt;param name="index"&gt;The index to use for the item value&lt;/param&gt;
 /// &lt;returns&gt;The formattable string with the named item substituted with the numbered format item.&lt;/returns&gt;
 private static string ReplaceFormattableItem(string formattableString, string itemName, int index)
 {
 return formattableString
 .Replace("{" + itemName + "}", "{" + index + "}")
 .Replace("{" + itemName + ",", "{" + index + ",")
 .Replace("{" + itemName + ":", "{" + index + ":");
 }
}
</code></pre>

It is used in the following way:

<pre><code> [Test]
 public void FormatTemplate_GivenANamedGuid_FormattedWithB_ShouldFormatCorrectly()
 {
 // Arrange
 var template = "My guid {MyGuid:B} is awesome!";
 var templateValues = new Dictionary&lt;string, object&gt; { { "MyGuid", new Guid("{A4D2A7F1-421C-4A1D-9CB2-9C2E70B05E19}") } };
 var sut = new StringTemplateFormatter();
 // Act
 var result = sut.FormatTemplate(template, templateValues);
 //Assert
 Assert.That(result, Is.EqualTo("My guid {a4d2a7f1-421c-4a1d-9cb2-9c2e70b05e19} is awesome!"));
 }
</code></pre>

Hope someone finds this useful!

blocks|key|1733195|text|尽管公认的答案提供了一些很好的示例，但.Inject和一些Haack示例不能处理转义。许多还严重依赖于Regex+(较慢)，或在.NET核心上不可用的DataBinder.Eval，以及在其他一些环境中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1733196|考虑到这一点，我已经编写了一个简单的基于状态机的解析器，它可以逐个字符地流过字符，写入StringBuilder输出。它是作为String扩展方法实现的，可以接受带参数的Dictionary<string,+object>或object作为输入(使用反射)。|offset|length|style|CODE|1733197|它处理无限级别的{{{escaping}}}，并在输入包含不平衡的大括号和/或其他错误时抛出FormatException。|1733198|public+static+class+StringExtension+{
++++///+<summary>
++++///+Extension+method+that+replaces+keys+in+a+string+with+the+values+of+matching+object+properties.
++++///+</summary>
++++///+<param+name="formatString">The+format+string,+containing+keys+like+{foo}+and+{foo:SomeFormat}.</param>
++++///+<param+name="injectionObject">The+object+whose+properties+should+be+injected+in+the+string</param>
++++///+<returns>A+version+of+the+formatString+string+with+keys+replaced+by+(formatted)+key+values.</returns>
++++public+static+string+FormatWith(this+string+formatString,+object+injectionObject)+{
++++++++return+formatString.FormatWith(GetPropertiesDictionary(injectionObject));
++++}

++++///+<summary>
++++///+Extension+method+that+replaces+keys+in+a+string+with+the+values+of+matching+dictionary+entries.
++++///+</summary>
++++///+<param+name="formatString">The+format+string,+containing+keys+like+{foo}+and+{foo:SomeFormat}.</param>
++++///+<param+name="dictionary">An+<see+cref="IDictionary"/>+with+keys+and+values+to+inject+into+the+string</param>
++++///+<returns>A+version+of+the+formatString+string+with+dictionary+keys+replaced+by+(formatted)+key+values.</returns>
++++public+static+string+FormatWith(this+string+formatString,+IDictionary<string,+object>+dictionary)+{
++++++++char+openBraceChar+=+'{';
++++++++char+closeBraceChar+=+'}';

++++++++return+FormatWith(formatString,+dictionary,+openBraceChar,+closeBraceChar);
++++}
++++++++///+<summary>
++++++++///+Extension+method+that+replaces+keys+in+a+string+with+the+values+of+matching+dictionary+entries.
++++++++///+</summary>
++++++++///+<param+name="formatString">The+format+string,+containing+keys+like+{foo}+and+{foo:SomeFormat}.</param>
++++++++///+<param+name="dictionary">An+<see+cref="IDictionary"/>+with+keys+and+values+to+inject+into+the+string</param>
++++++++///+<returns>A+version+of+the+formatString+string+with+dictionary+keys+replaced+by+(formatted)+key+values.</returns>
++++public+static+string+FormatWith(this+string+formatString,+IDictionary<string,+object>+dictionary,+char+openBraceChar,+char+closeBraceChar)+{
++++++++string+result+=+formatString;
++++++++if+(dictionary+==+null+%7C%7C+formatString+==+null)
++++++++++++return+result;

++++++++//+start+the+state+machine!

++++++++//+ballpark+output+string+as+two+times+the+length+of+the+input+string+for+performance+(avoids+reallocating+the+buffer+as+often).
++++++++StringBuilder+outputString+=+new+StringBuilder(formatString.Length+*+2);
++++++++StringBuilder+currentKey+=+new+StringBuilder();

++++++++bool+insideBraces+=+false;

++++++++int+index+=+0;
++++++++while+(index+<+formatString.Length)+{
++++++++++++if+(!insideBraces)+{
++++++++++++++++//+currently+not+inside+a+pair+of+braces+in+the+format+string
++++++++++++++++if+(formatString[index]+==+openBraceChar)+{
++++++++++++++++++++//+check+if+the+brace+is+escaped
++++++++++++++++++++if+(index+<+formatString.Length+-+1+&&+formatString[index+%2B+1]+==+openBraceChar)+{
++++++++++++++++++++++++//+add+a+brace+to+the+output+string
++++++++++++++++++++++++outputString.Append(openBraceChar);
++++++++++++++++++++++++//+skip+over+braces
++++++++++++++++++++++++index+%2B=+2;
++++++++++++++++++++++++continue;
++++++++++++++++++++}
++++++++++++++++++++else+{
++++++++++++++++++++++++//+not+an+escaped+brace,+set+state+to+inside+brace
++++++++++++++++++++++++insideBraces+=+true;
++++++++++++++++++++++++index%2B%2B;
++++++++++++++++++++++++continue;
++++++++++++++++++++}
++++++++++++++++}
++++++++++++++++else+if+(formatString[index]+==+closeBraceChar)+{
++++++++++++++++++++//+handle+case+where+closing+brace+is+encountered+outside+braces
++++++++++++++++++++if+(index+<+formatString.Length+-+1+&&+formatString[index+%2B+1]+==+closeBraceChar)+{
++++++++++++++++++++++++//+this+is+an+escaped+closing+brace,+this+is+okay
++++++++++++++++++++++++//+add+a+closing+brace+to+the+output+string
++++++++++++++++++++++++outputString.Append(closeBraceChar);
++++++++++++++++++++++++//+skip+over+braces
++++++++++++++++++++++++index+%2B=+2;
++++++++++++++++++++++++continue;
++++++++++++++++++++}
++++++++++++++++++++else+{
++++++++++++++++++++++++//+this+is+an+unescaped+closing+brace+outside+of+braces.
++++++++++++++++++++++++//+throw+a+format+exception
++++++++++++++++++++++++throw+new+FormatException($"Unmatched+closing+brace+at+position+{index}");
++++++++++++++++++++}
++++++++++++++++}
++++++++++++++++else+{
++++++++++++++++++++//+the+character+has+no+special+meaning,+add+it+to+the+output+string
++++++++++++++++++++outputString.Append(formatString[index]);
++++++++++++++++++++//+move+onto+next+character
++++++++++++++++++++index%2B%2B;
++++++++++++++++++++continue;
++++++++++++++++}
++++++++++++}
++++++++++++else+{
++++++++++++++++//+currently+inside+a+pair+of+braces+in+the+format+string
++++++++++++++++//+found+an+opening+brace
++++++++++++++++if+(formatString[index]+==+openBraceChar)+{
++++++++++++++++++++//+check+if+the+brace+is+escaped
++++++++++++++++++++if+(index+<+formatString.Length+-+1+&&+formatString[index+%2B+1]+==+openBraceChar)+{
++++++++++++++++++++++++//+there+are+escaped+braces+within+the+key
++++++++++++++++++++++++//+this+is+illegal,+throw+a+format+exception
++++++++++++++++++++++++throw+new+FormatException($"Illegal+escaped+opening+braces+within+a+parameter+-+index:+{index}");
++++++++++++++++++++}
++++++++++++++++++++else+{
++++++++++++++++++++++++//+not+an+escaped+brace,+we+have+an+unexpected+opening+brace+within+a+pair+of+braces
++++++++++++++++++++++++throw+new+FormatException($"Unexpected+opening+brace+inside+a+parameter+-+index:+{index}");
++++++++++++++++++++}
++++++++++++++++}
++++++++++++++++else+if+(formatString[index]+==+closeBraceChar)+{
++++++++++++++++++++//+handle+case+where+closing+brace+is+encountered+inside+braces
++++++++++++++++++++//+don't+attempt+to+check+for+escaped+braces+here+-+always+assume+the+first+brace+closes+the+braces
++++++++++++++++++++//+since+we+cannot+have+escaped+braces+within+parameters.

++++++++++++++++++++//+set+the+state+to+be+outside+of+any+braces
++++++++++++++++++++insideBraces+=+false;

++++++++++++++++++++//+jump+over+brace
++++++++++++++++++++index%2B%2B;

++++++++++++++++++++//+at+this+stage,+a+key+is+stored+in+current+key+that+represents+the+text+between+the+two+braces
++++++++++++++++++++//+do+a+lookup+on+this+key
++++++++++++++++++++string+key+=+currentKey.ToString();
++++++++++++++++++++//+clear+the+stringbuilder+for+the+key
++++++++++++++++++++currentKey.Clear();

++++++++++++++++++++object+outObject;

++++++++++++++++++++if+(!dictionary.TryGetValue(key,+out+outObject))+{
++++++++++++++++++++++++//+the+key+was+not+found+as+a+possible+replacement,+throw+exception
++++++++++++++++++++++++throw+new+FormatException($"The+parameter+\"{key}\"+was+not+present+in+the+lookup+dictionary");
++++++++++++++++++++}

++++++++++++++++++++//+we+now+have+the+replacement+value,+add+the+value+to+the+output+string
++++++++++++++++++++outputString.Append(outObject);

++++++++++++++++++++//+jump+to+next+state
++++++++++++++++++++continue;
++++++++++++++++}+//+if+}
++++++++++++++++else+{
++++++++++++++++++++//+character+has+no+special+meaning,+add+it+to+the+current+key
++++++++++++++++++++currentKey.Append(formatString[index]);
++++++++++++++++++++//+move+onto+next+character
++++++++++++++++++++index%2B%2B;
++++++++++++++++++++continue;
++++++++++++++++}+//+else
++++++++++++}+//+if+inside+brace
++++++++}+//+while

++++++++//+after+the+loop,+if+all+braces+were+balanced,+we+should+be+outside+all+braces
++++++++//+if+we're+not,+the+input+string+was+misformatted.
++++++++if+(insideBraces)+{
++++++++++++throw+new+FormatException("The+format+string+ended+before+the+parameter+was+closed.");
++++++++}

++++++++return+outputString.ToString();
++++}

++++///+<summary>
++++///+Creates+a+Dictionary+from+an+objects+properties,+with+the+Key+being+the+property's
++++///+name+and+the+Value+being+the+properties+value+(of+type+object)
++++///+</summary>
++++///+<param+name="properties">An+object+who's+properties+will+be+used</param>
++++///+<returns>A+<see+cref="Dictionary"/>+of+property+values+</returns>
++++private+static+Dictionary<string,+object>+GetPropertiesDictionary(object+properties)+{
++++++++Dictionary<string,+object>+values+=+null;
++++++++if+(properties+!=+null)+{
++++++++++++values+=+new+Dictionary<string,+object>();
++++++++++++PropertyDescriptorCollection+props+=+TypeDescriptor.GetProperties(properties);
++++++++++++foreach+(PropertyDescriptor+prop+in+props)+{
++++++++++++++++values.Add(prop.Name,+prop.GetValue(properties));
++++++++++++}
++++++++}
++++++++return+values;
++++}
}|code-block|syntax|javascript|1733199|最终，所有的逻辑都归结为10种主要状态--当状态机在括号外，同样在括号内时，下一个字符要么是左括号，要么是转义的左括号，要么是闭括号，要么是转义的闭括号，要么是普通字符。随着循环的进行，将字符添加到输出StringBuffer或键StringBuffer中，从而单独处理其中的每一个条件。当参数关闭时，键StringBuffer的值用于在字典中查找参数的值，然后将该值推送到输出StringBuffer中。最后，返回输出StringBuffer的值。|1733200|entityMap^0|0|17|D|1R|6|2D|Q|34|6|0|8|E|1A|F|0|0|2T|C|37|C|48|C|59|C|5U|C|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@$D|U|E|V|F|G]|$D|W|E|X|F|G]|$D|Y|E|Z|F|G]|$D|10|E|11|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|12|8|@$D|13|E|14|F|G]|$D|15|E|16|F|G]]|9|@]|A|$]]|$1|J|3|K|5|L|7|17|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|18|8|@$D|19|E|1A|F|G]|$D|1B|E|1C|F|G]|$D|1D|E|1E|F|G]|$D|1F|E|1G|F|G]|$D|1H|E|1I|F|G]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]]|R|$]]

Even though the accepted answer gives some good examples, the .Inject as well as some of the Haack examples do not handle escaping. Many also rely heavily on Regex (slower), or DataBinder.Eval which is not available on .NET Core, and in some other environments.

With that in mind, I've written a simple state machine based parser that streams through characters, writing to a <code>StringBuilder</code> output, character by character. It is implemented as <code>String</code> extension method(s) and can take both a <code>Dictionary&lt;string, object&gt;</code> or <code>object</code> with parameters as input (using reflection).

It handles unlimited levels of <code>{{{escaping}}}</code> and throws <code>FormatException</code> when input contains unbalanced braces and/or other errors.

<pre><code>public static class StringExtension {
 /// &lt;summary&gt;
 /// Extension method that replaces keys in a string with the values of matching object properties.
 /// &lt;/summary&gt;
 /// &lt;param name="formatString"&gt;The format string, containing keys like {foo} and {foo:SomeFormat}.&lt;/param&gt;
 /// &lt;param name="injectionObject"&gt;The object whose properties should be injected in the string&lt;/param&gt;
 /// &lt;returns&gt;A version of the formatString string with keys replaced by (formatted) key values.&lt;/returns&gt;
 public static string FormatWith(this string formatString, object injectionObject) {
 return formatString.FormatWith(GetPropertiesDictionary(injectionObject));
 }

 /// &lt;summary&gt;
 /// Extension method that replaces keys in a string with the values of matching dictionary entries.
 /// &lt;/summary&gt;
 /// &lt;param name="formatString"&gt;The format string, containing keys like {foo} and {foo:SomeFormat}.&lt;/param&gt;
 /// &lt;param name="dictionary"&gt;An &lt;see cref="IDictionary"/&gt; with keys and values to inject into the string&lt;/param&gt;
 /// &lt;returns&gt;A version of the formatString string with dictionary keys replaced by (formatted) key values.&lt;/returns&gt;
 public static string FormatWith(this string formatString, IDictionary&lt;string, object&gt; dictionary) {
 char openBraceChar = '{';
 char closeBraceChar = '}';

 return FormatWith(formatString, dictionary, openBraceChar, closeBraceChar);
 }
 /// &lt;summary&gt;
 /// Extension method that replaces keys in a string with the values of matching dictionary entries.
 /// &lt;/summary&gt;
 /// &lt;param name="formatString"&gt;The format string, containing keys like {foo} and {foo:SomeFormat}.&lt;/param&gt;
 /// &lt;param name="dictionary"&gt;An &lt;see cref="IDictionary"/&gt; with keys and values to inject into the string&lt;/param&gt;
 /// &lt;returns&gt;A version of the formatString string with dictionary keys replaced by (formatted) key values.&lt;/returns&gt;
 public static string FormatWith(this string formatString, IDictionary&lt;string, object&gt; dictionary, char openBraceChar, char closeBraceChar) {
 string result = formatString;
 if (dictionary == null || formatString == null)
 return result;

 // start the state machine!

 // ballpark output string as two times the length of the input string for performance (avoids reallocating the buffer as often).
 StringBuilder outputString = new StringBuilder(formatString.Length * 2);
 StringBuilder currentKey = new StringBuilder();

 bool insideBraces = false;

 int index = 0;
 while (index &lt; formatString.Length) {
 if (!insideBraces) {
 // currently not inside a pair of braces in the format string
 if (formatString[index] == openBraceChar) {
 // check if the brace is escaped
 if (index &lt; formatString.Length - 1 &amp;&amp; formatString[index + 1] == openBraceChar) {
 // add a brace to the output string
 outputString.Append(openBraceChar);
 // skip over braces
 index += 2;
 continue;
 }
 else {
 // not an escaped brace, set state to inside brace
 insideBraces = true;
 index++;
 continue;
 }
 }
 else if (formatString[index] == closeBraceChar) {
 // handle case where closing brace is encountered outside braces
 if (index &lt; formatString.Length - 1 &amp;&amp; formatString[index + 1] == closeBraceChar) {
 // this is an escaped closing brace, this is okay
 // add a closing brace to the output string
 outputString.Append(closeBraceChar);
 // skip over braces
 index += 2;
 continue;
 }
 else {
 // this is an unescaped closing brace outside of braces.
 // throw a format exception
 throw new FormatException($"Unmatched closing brace at position {index}");
 }
 }
 else {
 // the character has no special meaning, add it to the output string
 outputString.Append(formatString[index]);
 // move onto next character
 index++;
 continue;
 }
 }
 else {
 // currently inside a pair of braces in the format string
 // found an opening brace
 if (formatString[index] == openBraceChar) {
 // check if the brace is escaped
 if (index &lt; formatString.Length - 1 &amp;&amp; formatString[index + 1] == openBraceChar) {
 // there are escaped braces within the key
 // this is illegal, throw a format exception
 throw new FormatException($"Illegal escaped opening braces within a parameter - index: {index}");
 }
 else {
 // not an escaped brace, we have an unexpected opening brace within a pair of braces
 throw new FormatException($"Unexpected opening brace inside a parameter - index: {index}");
 }
 }
 else if (formatString[index] == closeBraceChar) {
 // handle case where closing brace is encountered inside braces
 // don't attempt to check for escaped braces here - always assume the first brace closes the braces
 // since we cannot have escaped braces within parameters.

 // set the state to be outside of any braces
 insideBraces = false;

 // jump over brace
 index++;

 // at this stage, a key is stored in current key that represents the text between the two braces
 // do a lookup on this key
 string key = currentKey.ToString();
 // clear the stringbuilder for the key
 currentKey.Clear();

 object outObject;

 if (!dictionary.TryGetValue(key, out outObject)) {
 // the key was not found as a possible replacement, throw exception
 throw new FormatException($"The parameter \"{key}\" was not present in the lookup dictionary");
 }

 // we now have the replacement value, add the value to the output string
 outputString.Append(outObject);

 // jump to next state
 continue;
 } // if }
 else {
 // character has no special meaning, add it to the current key
 currentKey.Append(formatString[index]);
 // move onto next character
 index++;
 continue;
 } // else
 } // if inside brace
 } // while

 // after the loop, if all braces were balanced, we should be outside all braces
 // if we're not, the input string was misformatted.
 if (insideBraces) {
 throw new FormatException("The format string ended before the parameter was closed.");
 }

 return outputString.ToString();
 }

 /// &lt;summary&gt;
 /// Creates a Dictionary from an objects properties, with the Key being the property's
 /// name and the Value being the properties value (of type object)
 /// &lt;/summary&gt;
 /// &lt;param name="properties"&gt;An object who's properties will be used&lt;/param&gt;
 /// &lt;returns&gt;A &lt;see cref="Dictionary"/&gt; of property values &lt;/returns&gt;
 private static Dictionary&lt;string, object&gt; GetPropertiesDictionary(object properties) {
 Dictionary&lt;string, object&gt; values = null;
 if (properties != null) {
 values = new Dictionary&lt;string, object&gt;();
 PropertyDescriptorCollection props = TypeDescriptor.GetProperties(properties);
 foreach (PropertyDescriptor prop in props) {
 values.Add(prop.Name, prop.GetValue(properties));
 }
 }
 return values;
 }
}
</code></pre>

Ultimately, all the logic boils down into 10 main states - For when the state machine is outside a bracket and likewise inside a bracket, the next character is either an open brace, an escaped open brace, a closed brace, an escaped closed brace, or an ordinary character. Each of these conditions is handled individually as the loop progresses, adding characters to either an output <code>StringBuffer</code> or a key <code>StringBuffer</code>. When a parameter is closed, the value of the key <code>StringBuffer</code> is used to look up the parameter's value in the dictionary, which then gets pushed into the output <code>StringBuffer</code>. At the end, the value of the output <code>StringBuffer</code> is returned.

blocks|key|1517404|text|string+language+=+"Python";
int+numquotes+=+2;
string+output+=+language+%2B+"+has+"%2B+numquotes+%2B+"+language+types.";|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1517405|编辑:我应该说的是，“不，我不相信C#支持你想要做的事情。这是你能得到的最接近的结果。”|unstyled|1517406|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>string language = "Python";
int numquotes = 2;
string output = language + " has "+ numquotes + " language types.";
</code></pre>

Edit:
What I should have said was, "No, I don't believe what you want to do is supported by C#. This is as close as you are going to get."

Is there any way to format a string by name rather than position in C#?

In python, I can do something like this example (shamelessly stolen from <a href="http://docs.python.org/lib/typesseq-strings.html" rel="noreferrer">here</a>):

<pre><code>&gt;&gt;&gt; print '%(language)s has %(#)03d quote types.' % \
 {'language': "Python", "#": 2}
Python has 002 quote types.
</code></pre>

Is there any way to do this in C#? Say for instance:

<pre><code>String.Format("{some_variable}: {some_other_variable}", ...);
</code></pre>

Being able to do this using a variable name would be nice, but a dictionary is acceptable too.

Named string formatting in C#

有没有办法在C#中按名称而不是按位置格式化字符串？在python中，我可以这样做(厚颜无耻地从窃取)：>>> print '%(language)s has %(#)03d quote types.' % \      {'language': "Python", "#": 2}Python has 002 quote types.在C#中有什么方法可以做到这一点吗？举个例子：String.For

问C#中的命名字符串格式
EN

回答 14

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C#中的命名字符串格式EN

回答 14

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C#中的命名字符串格式
EN