blocks|key|326526|text|考虑到性能上的大多数相似之处，请使用对您正在使用的代码片段来说更正确和更易读的代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|326527|我觉得一个描述加法的操作，因为键的存在已经是一个非常罕见的异常，所以最好用add来表示。从语义上讲，它更有意义。|326528|dict[key]+=+value代表了更好的替代方案。如果我看到这些代码，我会半心半意地认为关键字已经在字典中了。|offset|length|style|CODE|326529|entityMap^0|0|0|0|H|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@$F|O|G|P|H|I]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

Given the, most than probable similarities in performance, use whatever feel more correct and readable to the piece of code you're using.

I feel an operation that describes an addition, being the presence of the key already a really rare exception is best represented with the add. Semantically it makes more sense.

The <code>dict[key] = value</code> represents better a substitution. If I see that code I half expect the key to already be in the dictionary anyway.

blocks|key|323658|text|第一个版本将向字典中添加一个新的密钥，如果字典中已经存在KeyValuePair，则抛出。第二种方法使用索引器，如果键不存在，将添加一个新的键对，但如果键已经存在于字典中，则覆盖键的值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|323659|IDictionary<string,+string>+strings+=+new+Dictionary<string,+string>();

strings["foo"]+=+"bar";++++++++++//strings["foo"]+==+"bar"
strings["foo"]+=+string.Empty;+++//strings["foo"]+==+string.empty
strings.Add("foo",+"bar");+++++++//throws+++++|code-block|syntax|javascript|323660|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|$]]

The first version will add a new KeyValuePair to the dictionary, throwing if key is already in the dictionary. The second, using the indexer, will add a new pair if the key doesn't exist, but overwrite the value of the key if it already exists in the dictionary.

<pre><code>IDictionary&lt;string, string&gt; strings = new Dictionary&lt;string, string&gt;();

strings["foo"] = "bar"; //strings["foo"] == "bar"
strings["foo"] = string.Empty; //strings["foo"] == string.empty
strings.Add("foo", "bar"); //throws 
</code></pre>

blocks|key|3075875|text|是的，这就是区别，如果键已经存在，Add方法就会抛出一个异常。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3075876|使用Add方法的原因正是如此。如果字典不应该已经包含键，那么通常需要异常，以便让您意识到问题。|3075877|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|$]]

Yes, that is the difference, the Add method throws an exception if the key already exists.

The reason to use the Add method is exactly this. If the dictionary is not supposed to contain the key already, you usually want the exception so that you are made aware of the problem.

blocks|key|3289302|text|Dictionary.Add(key,+value)和Dictionary[key]+=+value有不同的用途：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3289303|3289304|使用Add方法添加新的键/值对，现有键不会被替换(抛出ArgumentException+)。|unordered-list-item|3289305|如果不关心键是否已存在于字典中，则使用索引器。换句话说:如果键不在字典中，则添加键/值对；如果键已在字典中，则替换指定键的值。|3289306|3289307|entityMap^0|0|Q|R|N|0|0|2|3|R|H|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|T|8|@]|D|@]|E|$]]|$1|G|3|H|5|I|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|J|3|K|5|I|7|Z|8|@]|D|@]|E|$]]|$1|L|3|-4|5|6|7|10|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|N|$]]

<code>Dictionary.Add(key, value)</code> and <code>Dictionary[key] = value</code> have different purposes:

<ul>
<li>Use the <code>Add</code> method to add new key/value pair, existing keys will not be replaced (an <code>ArgumentException</code> is thrown).</li>
<li>Use the indexer if you don't care whether the key already exists in the dictionary, in other words: add the key/value pair if the the key is not in the dictionary or replace the value for the specified key if the key is already in the dictionary.</li>
</ul>

blocks|key|324291|text|性能几乎是100%25相同的。您可以通过在Reflector.net中打开类来检查这一点|type|unstyled|depth|inlineStyleRanges|entityRanges|data|324292|这是This索引器：|324293|public+TValue+this[TKey+key]
{
++++get
++++{
++++++++int+index+=+this.FindEntry(key);
++++++++if+(index+>=+0)
++++++++{
++++++++++++return+this.entries[index].value;
++++++++}
++++++++ThrowHelper.ThrowKeyNotFoundException();
++++++++return+default(TValue);
++++}
++++set
++++{
++++++++this.Insert(key,+value,+false);
++++}
}|code-block|syntax|javascript|324294|这是Add方法：|324295|public+void+Add(TKey+key,+TValue+value)
{
++++this.Insert(key,+value,+true);
}|324296|我不会张贴整个Insert方法，因为它相当长，但是方法声明如下：|324297|private+void+Insert(TKey+key,+TValue+value,+bool+add)|324298|在函数的下面，会发生这样的事情：|324299|if+((this.entries[i].hashCode+==+num)+&&+this.comparer.Equals(this.entries[i].key,+key))
{
++++if+(add)
++++{
++++++++ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_AddingDuplicate);
++++}|324300|它检查键是否已经存在，如果已经存在并且参数add为true，则抛出异常。|324301|因此，无论出于何种目的和意图，性能都是相同的。|324302|就像其他一些提到的一样，这一切都是关于你是否需要检查，是否尝试添加两次相同的键。|324303|很抱歉发了这么长的帖子，希望没问题。|324304|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|15|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|16|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|17|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|18|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|19|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|1A|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|1B|8|@]|9|@]|A|$]]|$1|S|3|T|5|F|7|1C|8|@]|9|@]|A|$G|H]]|$1|U|3|V|5|6|7|1D|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1E|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1F|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|1G|8|@]|9|@]|A|$]]|$1|12|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|13|$]]

The performance is almost a 100% identical. You can check this out by opening the class in Reflector.net

This is the This indexer:

<pre><code>public TValue this[TKey key]
{
 get
 {
 int index = this.FindEntry(key);
 if (index &gt;= 0)
 {
 return this.entries[index].value;
 }
 ThrowHelper.ThrowKeyNotFoundException();
 return default(TValue);
 }
 set
 {
 this.Insert(key, value, false);
 }
}
</code></pre>

And this is the Add method:

<pre><code>public void Add(TKey key, TValue value)
{
 this.Insert(key, value, true);
}
</code></pre>

I won't post the entire Insert method as it's rather long, however the method declaration is this:

<pre><code>private void Insert(TKey key, TValue value, bool add)
</code></pre>

And further down in the function, this happens:

<pre><code>if ((this.entries[i].hashCode == num) &amp;&amp; this.comparer.Equals(this.entries[i].key, key))
{
 if (add)
 {
 ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_AddingDuplicate);
 }
</code></pre>

Which checks if the key already exists, and if it does and the parameter add is true, it throws the exception.

So for all purposes and intents the performance is the same.

Like a few other mentions, it's all about whether you need the check, for attempts at adding the same key twice.

Sorry for the lengthy post, I hope it's okay.

blocks|key|3075937|text|一种是赋值，另一种是向字典中添加新的键和值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3075938|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|$]]

One is assigning a value while the other is adding to the Dictionary a new Key and Value.

blocks|key|326596|text|要回答这个问题，我们首先需要看一看字典的用途和底层技术。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|326597|Dictionary是KeyValuePair<Tkey,+Tvalue>的列表，其中每个值都由其唯一键表示。假设我们有一份你最喜欢的食物的清单。每个值(食物名称)都由其唯一键(a+position+=您对此食物的喜好程度)表示。|offset|length|style|CODE|326598|示例代码：|326599|Dictionary<int,+string>+myDietFavorites+=+new+Dictionary<int,+string>()
{
++++{+1,+"Burger"},
++++{+2,+"Fries"},
++++{+3,+"Donuts"}
};|code-block|syntax|javascript|326600|假设你想保持健康，你改变了主意，想用沙拉取代你最喜欢的“汉堡”。您的列表仍然是您的收藏夹列表，您不会更改列表的性质。您的收藏夹将保持在列表中的第一位，只是它的值会改变。这就是你调用这个的时候：|326601|/*your+key+stays+1,+you+only+replace+the+value+assigned+to+this+key
++you+alter+existing+record+in+your+dictionary*/
myDietFavorites[1]+=+"Salad";|326602|但是不要忘了你是程序员，从现在开始你的句子的结尾是；你拒绝使用表情符号，因为它们会抛出编译错误，并且所有的收藏列表都是基于0索引的。|326603|你的饮食也变了！所以你再次修改了你的列表：|326604|/*you+don't+want+to+replace+Salad,+you+want+to+add+this+new+fancy+0
++position+to+your+list.+It+wasn't+there+before+so+you+can+either+define+it*/
myDietFavorites[0]+=+"Pizza";

/*or+Add+it*/
myDietFavorites.Add(0,+"Pizza");|326605|定义有两种可能性，你要么想给以前不存在的东西一个新的定义，要么你想改变已经存在的定义。|326606|326607|现在我们来看看引擎盖下的情况。当你创建一个字典时，你的编译器为存储桶(内存中用来存储记录的空间)做了一个预留。存储桶不会以您定义的方式存储键。每个键在进入存储桶(由Microsoft定义)之前都会进行哈希处理，值得一提的是，值部分保持不变。|326608|我将使用CRC32散列算法来简化我的示例。在定义以下内容时：|326609|myDietFavorites[0]+=+"Pizza";|326610|要送到桶里的是db2dc565“披萨”(简化版)。|BOLD|326611|使用更改中的值时：|326612|myDietFavorites[0]+=+"Spaghetti";|326613|如果它在那里，您只需重写分配给键的值。如果它不在那里，你将把你的值放在桶里。|326614|当您在字典上调用Add函数时，如下所示：|326615|myDietFavorite.Add(0,+"Chocolate");|326616|您对0进行散列运算，以将其值与存储桶中的值进行比较。只有当它不在中时，你才可以把它放在中。|326617|它是区分大小写的，因为它经历了哈希。例如"Name“!=+"name”。让我们使用CRC32来描述这一点。|326618|Name“的值是：e04112b1+"name”的值是：1107fb5b|326619|entityMap^0|0|0|A|B|Q|0|0|0|0|0|0|0|0|0|0|0|0|0|7|8|0|0|0|0|0|0|17|2|0|0|1H|0|0|10|0^^$0|@$1|2|3|4|5|6|7|1S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1T|8|@$D|1U|E|1V|F|G]|$D|1W|E|1X|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|1Z|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|20|8|@]|9|@]|A|$]]|$1|Q|3|R|5|L|7|21|8|@]|9|@]|A|$M|N]]|$1|S|3|T|5|6|7|22|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|23|8|@]|9|@]|A|$]]|$1|W|3|X|5|L|7|24|8|@]|9|@]|A|$M|N]]|$1|Y|3|Z|5|6|7|25|8|@]|9|@]|A|$]]|$1|10|3|-4|5|6|7|26|8|@]|9|@]|A|$]]|$1|11|3|12|5|6|7|27|8|@]|9|@]|A|$]]|$1|13|3|14|5|6|7|28|8|@]|9|@]|A|$]]|$1|15|3|16|5|L|7|29|8|@]|9|@]|A|$M|N]]|$1|17|3|18|5|6|7|2A|8|@$D|2B|E|2C|F|19]]|9|@]|A|$]]|$1|1A|3|1B|5|6|7|2D|8|@]|9|@]|A|$]]|$1|1C|3|1D|5|L|7|2E|8|@]|9|@]|A|$M|N]]|$1|1E|3|1F|5|6|7|2F|8|@]|9|@]|A|$]]|$1|1G|3|1H|5|6|7|2G|8|@]|9|@]|A|$]]|$1|1I|3|1J|5|L|7|2H|8|@]|9|@]|A|$M|N]]|$1|1K|3|1L|5|6|7|2I|8|@$D|2J|E|2K|F|19]]|9|@]|A|$]]|$1|1M|3|1N|5|6|7|2L|8|@$D|2M|E|2N|F|19]]|9|@]|A|$]]|$1|1O|3|1P|5|6|7|2O|8|@$D|2P|E|2Q|F|19]]|9|@]|A|$]]|$1|1Q|3|-4|5|6|7|2R|8|@]|9|@]|A|$]]]|1R|$]]

To answer the question first we need to take a look at the purpose of a dictionary and underlying technology. 

<code>Dictionary</code> is the list of <code>KeyValuePair&lt;Tkey, Tvalue&gt;</code> where each value is represented by its unique key. Let's say we have a list of your favorite foods. Each value (food name) is represented by its unique key (a position = how much you like this food).

Example code:

<pre><code>Dictionary&lt;int, string&gt; myDietFavorites = new Dictionary&lt;int, string&gt;()
{
 { 1, "Burger"},
 { 2, "Fries"},
 { 3, "Donuts"}
};
</code></pre>

Let's say you want to stay healthy, you've changed your mind and you want to replace your favorite "Burger" with salad. Your list is still a list of your favorites, you won't change the nature of the list. Your favorite will remain number one on the list, only it's value will change. This is when you call this: 

<pre><code>/*your key stays 1, you only replace the value assigned to this key
 you alter existing record in your dictionary*/
myDietFavorites[1] = "Salad";
</code></pre>

But don't forget you're the programmer, and from now on you finishes your sentences with ; you refuse to use emojis because they would throw compilation error and all list of favorites is 0 index based.

Your diet changed too! So you alter your list again:

<pre><code>/*you don't want to replace Salad, you want to add this new fancy 0
 position to your list. It wasn't there before so you can either define it*/
myDietFavorites[0] = "Pizza";

/*or Add it*/
myDietFavorites.Add(0, "Pizza");
</code></pre>

There are two possibilities with defining, you either want to give a new definition for something not existent before or you want to change definition which already exists. 

Add method allows you to add a record but only under one condition: key for this definition may not exist in your dictionary.

Now we are going to look under the hood. When you are making a dictionary your compiler make a reservation for the bucket (spaces in memory to store your records). Bucket don't store keys in the way you define them. Each key is hashed before going to the bucket (defined by Microsoft), worth mention that value part stays unchanged.

I'll use the CRC32 hashing algorithm to simplify my example. When you defining:

<pre><code>myDietFavorites[0] = "Pizza";
</code></pre>

What is going to the bucket is db2dc565 "Pizza" (simplified).

When you alter the value in with:

<pre><code>myDietFavorites[0] = "Spaghetti";
</code></pre>

You hash your 0 which is again db2dc565 then you look up this value in your bucket to find if it's there. If it's there you simply rewrite the value assigned to the key. If it's not there you'll place your value in the bucket.

When you calling Add function on your dictionary like:

<pre><code>myDietFavorite.Add(0, "Chocolate");
</code></pre>

You hash your 0 to compare it's value to ones in the bucket. You may place it in the bucket only if it's not there.

It's crucial to know how it works especially if you work with dictionaries of string or char type of key. It's case sensitive because of undergoing hashing. So for example "name" != "Name". Let's use our CRC32 to depict this. 

Value for "name" is: e04112b1
Value for "Name" is: 1107fb5b

blocks|key|323748|text|将值插入到字典中的|type|unstyled|depth|inlineStyleRanges|entityRanges|data|323749|+Dictionary<string,+string>+dDS1+=+new+Dictionary<string,+string>();//Declaration
+dDS1.Add("VEqpt",+"aaaa");//adding+key+and+value+into+the+dictionary
+string+Count+=+dDS1["VEqpt"];//assigning+the+value+of+dictionary+key+to+Count+variable
+dDS1["VEqpt"]+=+Count+%2B+"bbbb";//assigning+the+value+to+key|code-block|syntax|javascript|323750|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|$]]

To insert the Value into the Dictionary

<pre><code> Dictionary&lt;string, string&gt; dDS1 = new Dictionary&lt;string, string&gt;();//Declaration
 dDS1.Add("VEqpt", "aaaa");//adding key and value into the dictionary
 string Count = dDS1["VEqpt"];//assigning the value of dictionary key to Count variable
 dDS1["VEqpt"] = Count + "bbbb";//assigning the value to key
</code></pre>

What is the difference in <code>Dictionary.add(key, value)</code> and <code>Dictionary[key] = value</code>?

I've noticed that the last version does not throw an <code>ArgumentException</code> when inserting a duplicate key, but is there any reason to prefer the first version?

Edit: Does anyone have an authoritative source of information about this? I've tried MSDN, but it is as always a wild goose chase :(

Different ways of adding to Dictionary

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

Dictionary.add(key, value)和Dictionary[key] = value有什么不同我注意到最后一个版本在插入重复键时不会抛出ArgumentException，但是有什么理由更喜欢第一个版本吗？编辑：谁有关于这方面的权威信息来源？我试过MSDN，但它总是徒劳无功:(

问添加到字典的不同方法
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问添加到字典的不同方法EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问添加到字典的不同方法
EN