blocks|key|4568057|text|使用字典：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4568058|myFunction(new+Dictionary<string,+object>(){
++{"Key",+value},+
++{"Key2",+value}});|code-block|syntax|javascript|4568059|简单地说，您只需要一个new+Dictionary<K,+V>，而不是每个参数。获取键和值很简单。|offset|length|style|CODE|4568060|或使用匿名类型：|4568061|myFunction(new+{
++Key+=+value,+
++Key2+=+value});|4568062|在函数内部使用它不是很好，你需要反射。这看起来像这样：|4568063|foreach+(PropertyInfo+property+in+arg.GetType().GetProperties())
{
++key+=+property.Name;
++value+=+property.GetValue(arg,+null);
}|4568064|(直截了当地说，可能有一些错误……)|4568065|entityMap^0|0|0|B|K|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@$I|11|J|12|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|13|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|14|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|15|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|16|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|17|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|X|$]]

Using a dictionary:

<pre><code>myFunction(new Dictionary&lt;string, object&gt;(){
 {"Key", value}, 
 {"Key2", value}});
</code></pre>

Which is straight forward, you need only one <code>new Dictionary&lt;K, V&gt;</code>, not for each argument. It's trivial to get the keys and values.

Or with an anonymous type:

<pre><code>myFunction(new {
 Key = value, 
 Key2 = value});
</code></pre>

Which is not very nice to use inside the function, you'll need reflection. This would look something like this:

<pre><code>foreach (PropertyInfo property in arg.GetType().GetProperties())
{
 key = property.Name;
 value = property.GetValue(arg, null);
}
</code></pre>

(Staight from my head, probably some errors...)

blocks|key|1541060|text|使用Dictionary+...|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1541061|void+Main()
{
++++var+dic+=+new+Dictionary<string,+object>();
++++dic.Add(+"Key1",+1+);
++++dic.Add(+"Key2",+2+);+++

++++MyFunction(+dic+).Dump();
}

public+static+object+MyFunction(+IDictionary+dic+)
{
+++return+dic["Key1"];
}|code-block|syntax|javascript|1541062|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/xfhwa508.aspx^0|2|A|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Use a <a href="http://msdn.microsoft.com/en-us/library/xfhwa508.aspx" rel="nofollow noreferrer">Dictionary</a> ...

<pre><code>void Main()
{
 var dic = new Dictionary&lt;string, object&gt;();
 dic.Add( "Key1", 1 );
 dic.Add( "Key2", 2 ); 

 MyFunction( dic ).Dump();
}

public static object MyFunction( IDictionary dic )
{
 return dic["Key1"];
}
</code></pre>

blocks|key|4568096|text|以下是更多相同的内容：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4568097|static+void+Main(string[]+args)
{
++++//+http://msdn.microsoft.com/en-us/library/bb531208.aspx
++++MyMethod(new+Dictionary<string,string>()
++++{
++++++++{"key1","value1"},
++++++++{"key2","value2"}
++++});
}

static+void+MyMethod(Dictionary<string,+string>+dictionary)
{
++++foreach+(string+key+in+dictionary.Keys)
++++{
++++++++Console.WriteLine("{0}+-+{1}",+key,+dictionary[key]);
++++}
}|code-block|syntax|javascript|4568098|有关初始化字典的一些细节可以在here中找到。|offset|length|4568099|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/bb531208.aspx^0|0|0|F|4|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

Here's more of the same:

<pre><code>static void Main(string[] args)
{
 // http://msdn.microsoft.com/en-us/library/bb531208.aspx
 MyMethod(new Dictionary&lt;string,string&gt;()
 {
 {"key1","value1"},
 {"key2","value2"}
 });
}

static void MyMethod(Dictionary&lt;string, string&gt; dictionary)
{
 foreach (string key in dictionary.Keys)
 {
 Console.WriteLine("{0} - {1}", key, dictionary[key]);
 }
}
</code></pre>

Some details on initialising a dictionary can be found <a href="http://msdn.microsoft.com/en-us/library/bb531208.aspx" rel="nofollow noreferrer">here</a>.

blocks|key|4568157|text|当语法对于其他合适的模式来说不是很好时，改变语法。这样如何：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4568158|public+void+MyFunction(params+KeyValuePair<string,+object>[]+pairs)
{
++++//+...
}

public+static+class+Pairing
{
++++public+static+KeyValuePair<string,+object>+Of(string+key,+object+value)
++++{
++++++++return+new+KeyValuePair<string,+object>(key,+value);
++++}
}|code-block|syntax|javascript|4568159|用法：|4568160|MyFunction(Pairing.Of("Key1",+5),+Pairing.Of("Key2",+someObject));|4568161|更有趣的是向string添加一个扩展方法，使其可配对：|offset|length|style|CODE|4568162|public+static+KeyValuePair<string,+object>+PairedWith(this+string+key,+object+value)
{
++++return+new+KeyValuePair<string,+object>(key,+value);
}|4568163|4568164|MyFunction("Key1".PairedWith(5),+"Key2".PairedWith(someObject));|4568165|编辑：您也可以通过从Dictionary<,>派生来使用不带通用括号的字典语法|BOLD|4568166|public+void+MyFunction(MessageArgs+args)
{
++++//+...
}

public+class+MessageArgs+:+Dictionary<string,+object>
{}|4568167|4568168|MyFunction(new+MessageArgs+{+{+"Key1",+5+},+{+"Key2",+someObject+}+});|4568169|entityMap^0|0|0|0|0|6|6|0|0|0|0|0|2|A|D|0|0|0|0^^$0|@$1|2|3|4|5|6|7|15|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|16|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|17|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|18|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|19|8|@$M|1A|N|1B|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|D|7|1C|8|@]|9|@]|A|$E|F]]|$1|S|3|H|5|6|7|1D|8|@]|9|@]|A|$]]|$1|T|3|U|5|D|7|1E|8|@]|9|@]|A|$E|F]]|$1|V|3|W|5|6|7|1F|8|@$M|1G|N|1H|O|X]|$M|1I|N|1J|O|P]]|9|@]|A|$]]|$1|Y|3|Z|5|D|7|1K|8|@]|9|@]|A|$E|F]]|$1|10|3|H|5|6|7|1L|8|@]|9|@]|A|$]]|$1|11|3|12|5|D|7|1M|8|@]|9|@]|A|$E|F]]|$1|13|3|-4|5|6|7|1N|8|@]|9|@]|A|$]]]|14|$]]

When the syntax is bad for an otherwise decent pattern, change the syntax. How about:

<pre><code>public void MyFunction(params KeyValuePair&lt;string, object&gt;[] pairs)
{
 // ...
}

public static class Pairing
{
 public static KeyValuePair&lt;string, object&gt; Of(string key, object value)
 {
 return new KeyValuePair&lt;string, object&gt;(key, value);
 }
}
</code></pre>

Usage:

<pre><code>MyFunction(Pairing.Of("Key1", 5), Pairing.Of("Key2", someObject));
</code></pre>

Even more interesting would be to add an extension method to <code>string</code> to make it pairable:

<pre><code>public static KeyValuePair&lt;string, object&gt; PairedWith(this string key, object value)
{
 return new KeyValuePair&lt;string, object&gt;(key, value);
}
</code></pre>

Usage:

<pre><code>MyFunction("Key1".PairedWith(5), "Key2".PairedWith(someObject));
</code></pre>

Edit: You can also use the dictionary syntax without the generic brackets by deriving from <code>Dictionary&lt;,&gt;</code>:

<pre><code>public void MyFunction(MessageArgs args)
{
 // ...
}

public class MessageArgs : Dictionary&lt;string, object&gt;
{}
</code></pre>

Usage:

<pre><code>MyFunction(new MessageArgs { { "Key1", 5 }, { "Key2", someObject } });
</code></pre>

blocks|key|1351780|text|这有点麻烦，但您可以让Message类实现IEnumerable接口，并为其提供一个Add方法。然后，您将能够使用集合初始值设定项语法：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1351781|Agent.SendMessage
(
++++new+Message(MessageTypes.SomethingHappened)+{{+"foo",+42+},+{+"bar",+123+}}
);

//+...

public+class+Message+:+IEnumerable
{
++++private+Dictionary<string,+object>+_map+=+new+Dictionary<string,+object>();

++++public+Message(MessageTypes+mt)
++++{
++++++++//+...
++++}

++++public+void+Add(string+key,+object+value)
++++{
++++++++_map.Add(key,+value);
++++}

++++IEnumerator+IEnumerable.GetEnumerator()
++++{
++++++++return+((IEnumerable)_map).GetEnumerator();
++++++++//+or+throw+a+NotImplementedException+if+you+prefer
++++}
}|code-block|syntax|javascript|1351782|entityMap^0|B|7|L|B|16|3|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|U|8|@]|D|@]|E|$]]]|L|$]]

A bit of a hack, but you could have your <code>Message</code> class implement the <code>IEnumerable</code> interface and give it an <code>Add</code> method. You'll then be able to use collection initializer syntax:

<pre><code>Agent.SendMessage
(
 new Message(MessageTypes.SomethingHappened) {{ "foo", 42 }, { "bar", 123 }}
);

// ...

public class Message : IEnumerable
{
 private Dictionary&lt;string, object&gt; _map = new Dictionary&lt;string, object&gt;();

 public Message(MessageTypes mt)
 {
 // ...
 }

 public void Add(string key, object value)
 {
 _map.Add(key, value);
 }

 IEnumerator IEnumerable.GetEnumerator()
 {
 return ((IEnumerable)_map).GetEnumerator();
 // or throw a NotImplementedException if you prefer
 }
}
</code></pre>

blocks|key|4568239|text|有趣的是，我刚刚(几分钟前)创建了一个方法，使用匿名类型和反射来实现这一点：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4568240|MyMethod(new+{+Key1+=+"value1",+Key2+=+"value2"+});


public+void+MyMethod(object+keyValuePairs)
{
++++var+dic+=+DictionaryFromAnonymousObject(keyValuePairs);
++++//+Do+something+with+the+dictionary
}

public+static+IDictionary<string,+string>+DictionaryFromAnonymousObject(object+o)
{
++++IDictionary<string,+string>+dic+=+new+Dictionary<string,+string>();
++++var+properties+=+o.GetType().GetProperties();
++++foreach+(PropertyInfo+prop+in+properties)
++++{
++++++++dic.Add(prop.Name,+prop.GetValue(o,+null)+as+string);
++++}
++++return+dic;
}|code-block|syntax|javascript|4568241|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Funny, I just created (minutes ago) a method that allows to do that, using anonymous types and reflection :

<pre><code>MyMethod(new { Key1 = "value1", Key2 = "value2" });


public void MyMethod(object keyValuePairs)
{
 var dic = DictionaryFromAnonymousObject(keyValuePairs);
 // Do something with the dictionary
}

public static IDictionary&lt;string, string&gt; DictionaryFromAnonymousObject(object o)
{
 IDictionary&lt;string, string&gt; dic = new Dictionary&lt;string, string&gt;();
 var properties = o.GetType().GetProperties();
 foreach (PropertyInfo prop in properties)
 {
 dic.Add(prop.Name, prop.GetValue(o, null) as string);
 }
 return dic;
}
</code></pre>

blocks|key|1538926|text|在C#+4.0中使用动态类型：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1538927|public+class+MyClass
{
++++//+Could+use+another+generic+type+if+preferred
++++private+readonly+Dictionary<string,+dynamic>+_dictionary+=+new+Dictionary<string,+dynamic>();

++++public+void+MyFunction(params+dynamic[]+kvps)
++++{
++++++++foreach+(dynamic+kvp+in+kvps)
++++++++++++_dictionary.Add(kvp.Key,+kvp.Value);
++++}
}|code-block|syntax|javascript|1538928|使用以下方式调用：|1538929|MyFunction(new+{Key+=+"Key1",+Value+=+"Value1"},+new+{Key+=+"Key2",+Value+=+"Value2"});|1538930|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|$]]

With dynamic type in C# 4.0:

<pre><code>public class MyClass
{
 // Could use another generic type if preferred
 private readonly Dictionary&lt;string, dynamic&gt; _dictionary = new Dictionary&lt;string, dynamic&gt;();

 public void MyFunction(params dynamic[] kvps)
 {
 foreach (dynamic kvp in kvps)
 _dictionary.Add(kvp.Key, kvp.Value);
 }
}
</code></pre>

Call using:

<pre><code>MyFunction(new {Key = "Key1", Value = "Value1"}, new {Key = "Key2", Value = "Value2"});
</code></pre>

blocks|key|239285|text|您可以使用元组来实现类似于@Bryan+Watts的Pairing.Of的东西，而不需要额外的类：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|239286|public+static+void+MyFunction(params+Tuple<string,+int>[]+pairs)
{
}

MyFunction(Tuple.Create("foo",+1),+Tuple.Create("bar",+2));|code-block|syntax|javascript|239287|entityMap^0|Q|A|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|$]]

You could use Tuples to achieve something similar to @Bryan Watts's <code>Pairing.Of</code> without the extra class:

<pre><code>public static void MyFunction(params Tuple&lt;string, int&gt;[] pairs)
{
}

MyFunction(Tuple.Create("foo", 1), Tuple.Create("bar", 2));
</code></pre>

blocks|key|1538965|text|您还可以引用nugetpackage+"valuetuple"，它允许您执行以下操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1538966|public+static+void+MyFunction(params+ValueTuple<string,+object>[]+pairs)
{
++++var+pair+=+pairs[1];
++++var+stringValue+=+pair.item1;
++++var+objectValue+=+pair.item2;
}|code-block|syntax|javascript|1538967|然后，可以像这样调用该方法：|1538968|MyFunction(("string",object),("string",+object));|1538969|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 could also reference the nugetpackage "valuetuple", which allows you to do the following:

<pre><code>public static void MyFunction(params ValueTuple&lt;string, object&gt;[] pairs)
{
 var pair = pairs[1];
 var stringValue = pair.item1;
 var objectValue = pair.item2;
}
</code></pre>

You can then call the method like this:

<pre><code>MyFunction(("string",object),("string", object));
</code></pre>

blocks|key|1351983|text|从C#+7.0开始，您可以使用值元组。C#+7.0不仅引入了一种新类型，而且为元组类型和元组值引入了简化的语法。元组类型被简单地写成一个用大括号括起来的类型列表：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1351984|(string,+int,+double)|code-block|syntax|javascript|1351985|相应的元素被命名为Item1、Item2、Item2。您还可以指定可选的别名。这些别名只是语法糖(+C#编译器的一个技巧)；元组仍然基于不变的(但通用的)+System.ValueTuple+struct。|offset|length|style|CODE|1351986|(string+name,+int+count,+double+magnitude)|1351987|元组值具有类似的语法，不同之处在于指定表达式而不是类型|1351988|("test",+7,+x+%2B+5.91)|1351989|或使用别名|1351990|(name:+"test",+count:+7,+magnitude:+x+%2B+5.91)|1351991|params数组示例：|1351992|public+static+void+MyFunction(params+(string+Key,+object+Value)[]+pairs)
{
++++foreach+(var+pair+in+pairs)+{
++++++++Console.WriteLine($"{pair.Key}+=+{pair.Value}");
++++}
}|1351993|也可以像这样解构一个元组|1351994|var+(key,+value)+=+pair;
Console.WriteLine($"{key}+=+{value}");|1351995|这将在两个独立的变量key和value中提取元组中的项。|1351996|现在，您可以轻松地使用不同数量的参数调用MyFunction：|1351997|1351998|+MyFunction(("a",+1),+("b",+2),+("c",+3));|blockquote|1351999|1352000|1352001|它允许我们做像这样的事情|1352002|DrawLine((0,+0),+(10,+0),+(10,+10),+(0,+10),+(0,+0));|1352003|请参阅：New+Features+in+C#+7.0|1352004|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.microsoft.com/en-us/dotnet/api/system.valuetuple?view=netframework-4.8|1|https://blogs.msdn.microsoft.com/dotnet/2017/03/09/new-features-in-c-7-0/^0|0|0|9|5|F|5|L|5|26|H|26|O|0|0|0|0|0|0|0|0|6|0|0|0|0|A|3|E|5|0|K|A|0|0|1|15|0|0|0|0|0|4|M|1|0^^$0|@$1|2|3|4|5|6|7|1U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1W|8|@$I|1X|J|1Y|K|L]|$I|1Z|J|20|K|L]|$I|21|J|22|K|L]|$I|23|J|24|K|L]]|9|@$I|25|J|26|1|27]]|A|$]]|$1|M|3|N|5|D|7|28|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|29|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|2A|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|2B|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|2C|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|2D|8|@$I|2E|J|2F|K|L]]|9|@]|A|$]]|$1|Y|3|Z|5|D|7|2G|8|@]|9|@]|A|$E|F]]|$1|10|3|11|5|6|7|2H|8|@]|9|@]|A|$]]|$1|12|3|13|5|D|7|2I|8|@]|9|@]|A|$E|F]]|$1|14|3|15|5|6|7|2J|8|@$I|2K|J|2L|K|L]|$I|2M|J|2N|K|L]]|9|@]|A|$]]|$1|16|3|17|5|6|7|2O|8|@$I|2P|J|2Q|K|L]]|9|@]|A|$]]|$1|18|3|-4|5|6|7|2R|8|@]|9|@]|A|$]]|$1|19|3|1A|5|1B|7|2S|8|@$I|2T|J|2U|K|L]]|9|@]|A|$]]|$1|1C|3|-4|5|6|7|2V|8|@]|9|@]|A|$]]|$1|1D|3|-4|5|6|7|2W|8|@]|9|@]|A|$]]|$1|1E|3|1F|5|6|7|2X|8|@]|9|@]|A|$]]|$1|1G|3|1H|5|D|7|2Y|8|@]|9|@]|A|$E|F]]|$1|1I|3|1J|5|6|7|2Z|8|@]|9|@$I|30|J|31|1|32]]|A|$]]|$1|1K|3|-4|5|6|7|33|8|@]|9|@]|A|$]]]|1L|$1M|$5|1N|1O|1P|A|$1Q|1R]]|1S|$5|1N|1O|1P|A|$1Q|1T]]]]

Since C# 7.0, you can use value tuples. C# 7.0 not only introduces a new type but a simplified syntax for tuple types and for tuple values. A tuple type is simply written as a list of types surrounded by braces:
<pre><code>(string, int, double)
</code></pre>
The corresponding elements are named <code>Item1</code>, <code>Item2</code>, <code>Item2</code>. You can also specify optional aliases. These aliases are only syntactic sugar (a trick of the C# compiler); the tuples are still based on the invariant (but generic) <a href="https://docs.microsoft.com/en-us/dotnet/api/system.valuetuple?view=netframework-4.8" rel="noreferrer"><code>System.ValueTuple&lt;T1, T2, ...&gt;</code> struct</a>.
<pre><code>(string name, int count, double magnitude)
</code></pre>
Tuple values have a similar syntax, except that you specify expressions instead of types
<pre><code>(&quot;test&quot;, 7, x + 5.91)
</code></pre>
or with the aliases
<pre><code>(name: &quot;test&quot;, count: 7, magnitude: x + 5.91)
</code></pre>
Example with <code>params</code> array:
<pre><code>public static void MyFunction(params (string Key, object Value)[] pairs)
{
 foreach (var pair in pairs) {
 Console.WriteLine($&quot;{pair.Key} = {pair.Value}&quot;);
 }
}
</code></pre>
It is also possible to deconstruct a tuple like this
<pre><code>var (key, value) = pair;
Console.WriteLine($&quot;{key} = {value}&quot;);
</code></pre>
This extracts the items of the tuple in two separate variables <code>key</code> and <code>value</code>.
Now, you can call <code>MyFunction</code> with a varying number of arguments easily:
<blockquote>
<code>MyFunction((&quot;a&quot;, 1), (&quot;b&quot;, 2), (&quot;c&quot;, 3));</code>
</blockquote>
It allows us to do things like
<pre><code>DrawLine((0, 0), (10, 0), (10, 10), (0, 10), (0, 0));
</code></pre>
See: <a href="https://blogs.msdn.microsoft.com/dotnet/2017/03/09/new-features-in-c-7-0/" rel="noreferrer">New Features in C# 7.0</a>

blocks|key|1539057|text|所以我是新手，目前还不能添加注释，但这只是一个建议，通过使@Bryan+Watts成为泛型来改进@Bryan+Watts关于Pairing.of类的想法，允许它很容易被其他类使用。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1539058|public+class+Pairing+
{
++++public+static+KeyValuePair<TKey,+TValue>+of<TKey,+TValue>(TKey+key,+TValue+value)
++++{
++++++++return+new+KeyValuePair<TKey,+TValue>(key,+value);
++++}
}|code-block|syntax|javascript|1539059|entityMap^0|1Q|A|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|$]]

So I'm new and can't currently add comments, but this is just a suggestion to improve @Bryan Watts's idea of the <code>Pairing.of</code> class by making it generic, allowing it to be easily used by other classes.

<pre class="lang-cs prettyprint-override"><code>public class Pairing 
{
 public static KeyValuePair&lt;TKey, TValue&gt; of&lt;TKey, TValue&gt;(TKey key, TValue value)
 {
 return new KeyValuePair&lt;TKey, TValue&gt;(key, value);
 }
}
</code></pre>

I'm looking for a way to have a function such as:

<pre><code>myFunction({"Key", value}, {"Key2", value});
</code></pre>

I'm sure there's something with anonymous types that would be pretty easy, but I'm not seeing it.

The only solution I can think of is to have a <code>params KeyValuePair&lt;String, object&gt;[] pairs</code> parameter, but that ends up being something similar to:

<pre><code>myFunction(new KeyValuePair&lt;String, object&gt;("Key", value),
 new KeyValuePair&lt;String, object&gt;("Key2", value));
</code></pre>

Which is, admittedly, much uglier.

EDIT:

To clarify, I'm writing a <code>Message</code> class to pass between 2 different systems. It contains a <code>ushort</code> specifying the the Message Type, and a dictionary of string to object for "Data" associated with the message. I'd like to be able to pass all this information in the constructor, so I am able to do this:

<pre><code>Agent.SendMessage(new Message(MessageTypes.SomethingHappened, "A", x, "B", y, "C", z));
</code></pre>

or similar syntax.

Key value pairs in C# Params

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我正在寻找一种方法来实现如下功能：myFunction({"Key", value}, {"Key2", value});我相信有一些匿名类型的东西是非常容易的，但我没有看到它。我能想到的唯一解决方案是有一个params KeyValuePair<String, object>[] pairs参数，但最终结果类似于：m...

问C#参数中的键值对
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C#参数中的键值对EN