blocks|key|4189271|text|这是因为框架要求两个相同的对象必须具有相同的哈希码。如果覆盖equals方法来对两个对象进行特殊比较，并且该方法认为这两个对象相同，则这两个对象的散列代码也必须相同。(字典和哈希表依赖于这一原则)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4189272|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|$]]

It is because the framework requires that two objects that are the same must have the same hashcode. If you override the equals method to do a special comparison of two objects and the two objects are considered the same by the method, then the hash code of the two objects must also be the same. (Dictionaries and Hashtables rely on this principle).

blocks|key|925167|text|通过重写Equals，您基本上是在声明您更了解如何比较给定类型的两个实例，因此您很可能是提供最佳散列代码的最佳候选者。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|925168|这是一个ReSharper如何为您编写GetHashCode()函数的示例：|925169|public+override+int+GetHashCode()
{
++++unchecked
++++{
++++++++var+result+=+0;
++++++++result+=+(result+*+397)+%5E+m_someVar1;
++++++++result+=+(result+*+397)+%5E+m_someVar2;
++++++++result+=+(result+*+397)+%5E+m_someVar3;
++++++++result+=+(result+*+397)+%5E+m_someVar4;
++++++++return+result;
++++}
}|code-block|syntax|javascript|925170|正如您所看到的，它只是尝试根据类中的所有字段猜测一个好的哈希码，但是既然您知道对象的域或值范围，您仍然可以提供一个更好的哈希码。|925171|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

By overriding Equals you're basically stating that you are the one who knows better how to compare two instances of a given type, so you're likely to be the best candidate to provide the best hash code.

This is an example of how ReSharper writes a GetHashCode() function for you:

<pre><code>public override int GetHashCode()
{
 unchecked
 {
 var result = 0;
 result = (result * 397) ^ m_someVar1;
 result = (result * 397) ^ m_someVar2;
 result = (result * 397) ^ m_someVar3;
 result = (result * 397) ^ m_someVar4;
 return result;
 }
}
</code></pre>

As you can see it just tries to guess a good hash code based on all the fields in the class, but since you know your object's domain or value ranges you could still provide a better one.

blocks|key|125909|text|是的，如果您的项目将用作字典或HashSet<T>等中的关键字，这一点很重要-因为这是用来(在没有自定义IEqualityComparer<T>的情况下)将项目分组到存储桶中的。如果两个项目的哈希码不匹配，它们可能永远不会被认为相等(Equals将永远不会被调用)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|125910|GetHashCode()方法应该反映Equals逻辑；规则如下：|125911|如果两个事物相等(Equals(...)+==+true)，则它们必须返回相同的值。|125912|是相等的，它们没有必要相同；这是一个冲突，将调用Equals以查看它是否为真正的相等。|unordered-list-item|125913|125914|在本例中，看起来"return+FooId;“是一个合适的GetHashCode()实现。如果您正在测试多个属性，通常使用如下代码组合它们，以减少对角线冲突(即，使new+Foo(3,5)具有与new+Foo(5,3)不同的哈希码)：|125915|unchecked+//+only+needed+if+you're+compiling+with+arithmetic+checks+enabled
{+//+(the+default+compiler+behaviour+is+*disabled*,+so+most+folks+won't+need+this)
++++int+hash+=+13;
++++hash+=+(hash+*+7)+%2B+field1.GetHashCode();
++++hash+=+(hash+*+7)+%2B+field2.GetHashCode();
++++...
++++return+hash;
}|code-block|syntax|javascript|125916|哦-为方便起见，在覆盖Equals和GetHashCode时，您还可以考虑提供==和!=运算符。|125917|125918|here演示了当你弄错的时候会发生什么。|125919|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.microsoft.com/en-us/dotnet/api/system.object.equals?view=netframework-4.8|1|https://docs.microsoft.com/en-us/dotnet/api/system.object.gethashcode?view=netframework-4.8|2|https://stackoverflow.com/questions/638761/c-gethashcode-override-of-object-containing-generic-array/639098#639098^0|F|A|1G|K|39|6|0|0|J|6|0|D|1|0|9|J|0|O|6|0|0|9|D|T|D|2A|C|2P|C|0|0|B|6|I|B|13|2|16|2|0|0|0|4|2|0^^$0|@$1|2|3|4|5|6|7|1B|8|@$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]]|D|@$9|1G|A|1H|1|1I]]|E|$]]|$1|F|3|G|5|6|7|1J|8|@$9|1K|A|1L|B|C]]|D|@$9|1M|A|1N|1|1O]]|E|$]]|$1|H|3|I|5|6|7|1P|8|@$9|1Q|A|1R|B|C]]|D|@]|E|$]]|$1|J|3|K|5|L|7|1S|8|@$9|1T|A|1U|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|1V|8|@]|D|@]|E|$]]|$1|N|3|O|5|6|7|1W|8|@$9|1X|A|1Y|B|C]|$9|1Z|A|20|B|C]|$9|21|A|22|B|C]|$9|23|A|24|B|C]]|D|@]|E|$]]|$1|P|3|Q|5|R|7|25|8|@]|D|@]|E|$S|T]]|$1|U|3|V|5|6|7|26|8|@$9|27|A|28|B|C]|$9|29|A|2A|B|C]|$9|2B|A|2C|B|C]|$9|2D|A|2E|B|C]]|D|@]|E|$]]|$1|W|3|-4|5|6|7|2F|8|@]|D|@]|E|$]]|$1|X|3|Y|5|6|7|2G|8|@]|D|@$9|2H|A|2I|1|2J]]|E|$]]|$1|Z|3|-4|5|6|7|2K|8|@]|D|@]|E|$]]]|10|$11|$5|12|13|14|E|$15|16]]|17|$5|12|13|14|E|$15|18]]|19|$5|12|13|14|E|$15|1A]]]]

Yes, it is important if your item will be used as a key in a dictionary, or <code>HashSet&lt;T&gt;</code>, etc - since this is used (in the absence of a custom <code>IEqualityComparer&lt;T&gt;</code>) to group items into buckets. If the hash-code for two items does not match, they may never be considered equal (<a href="https://docs.microsoft.com/en-us/dotnet/api/system.object.equals?view=netframework-4.8" rel="noreferrer">Equals</a> will simply never be called).

The <a href="https://docs.microsoft.com/en-us/dotnet/api/system.object.gethashcode?view=netframework-4.8" rel="noreferrer">GetHashCode()</a> method should reflect the <code>Equals</code> logic; the rules are:

<ul>
<li>if two things are equal (<code>Equals(...) == true</code>) then they must return the same value for <code>GetHashCode()</code></li>
<li>if the <code>GetHashCode()</code> is equal, it is not necessary for them to be the same; this is a collision, and <code>Equals</code> will be called to see if it is a real equality or not.</li>
</ul>

In this case, it looks like "<code>return FooId;</code>" is a suitable <code>GetHashCode()</code> implementation. If you are testing multiple properties, it is common to combine them using code like below, to reduce diagonal collisions (i.e. so that <code>new Foo(3,5)</code> has a different hash-code to <code>new Foo(5,3)</code>):

<pre><code>unchecked // only needed if you're compiling with arithmetic checks enabled
{ // (the default compiler behaviour is *disabled*, so most folks won't need this)
 int hash = 13;
 hash = (hash * 7) + field1.GetHashCode();
 hash = (hash * 7) + field2.GetHashCode();
 ...
 return hash;
}
</code></pre>

Oh - for convenience, you might also consider providing <code>==</code> and <code>!=</code> operators when overriding <code>Equals</code> and <code>GetHashCode</code>.

<hr>

A demonstration of what happens when you get this wrong is <a href="https://stackoverflow.com/questions/638761/c-gethashcode-override-of-object-containing-generic-array/639098#639098">here</a>.

blocks|key|929904|text|实际上，正确地实现GetHashCode()是非常困难的，因为除了Marc已经提到的规则之外，散列代码在对象的生命周期内不应该改变。因此，用于计算哈希码的字段必须是不可变的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|929905|当我使用NHibernate时，我终于找到了这个问题的解决方案。我的方法是根据对象的ID计算哈希码。ID只能通过构造函数来设置，所以如果您想要更改ID+(这是非常不可能的)，您必须创建一个具有新ID的新对象，从而创建一个新的哈希码。这种方法最适合GUID，因为您可以提供一个随机生成ID的无参数构造函数。|929906|entityMap^0|9|D|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|N|8|@]|D|@]|E|$]]]|I|$]]

It's actually very hard to implement <code>GetHashCode()</code> correctly because, in addition to the rules Marc already mentioned, the hash code should not change during the lifetime of an object. Therefore the fields which are used to calculate the hash code must be immutable.

I finally found a solution to this problem when I was working with NHibernate.
My approach is to calculate the hash code from the ID of the object. The ID can only be set though the constructor so if you want to change the ID, which is very unlikely, you have to create a new object which has a new ID and therefore a new hash code. This approach works best with GUIDs because you can provide a parameterless constructor which randomly generates an ID.

blocks|key|126093|text|这样如何：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|126094|public+override+int+GetHashCode()
{
++++return+string.Format("{0}_{1}_{2}",+prop1,+prop2,+prop3).GetHashCode();
}|code-block|syntax|javascript|126095|126096|假设性能不是问题:)|blockquote|126097|126098|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|O|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|P|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|Q|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|R|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|M|$]]

How about:

<pre><code>public override int GetHashCode()
{
 return string.Format("{0}_{1}_{2}", prop1, prop2, prop3).GetHashCode();
}
</code></pre>

<blockquote>
 Assuming performance is not an issue :)
</blockquote>

blocks|key|3344034|text|这不一定很重要；它取决于您的集合的大小和性能需求，以及您的类是否将在您可能不知道性能需求的库中使用。我经常知道我的集合大小不是很大，我的时间比通过创建完美的散列代码获得的几微秒的性能更有价值；所以(为了摆脱编译器的恼人警告)我简单地使用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3344035|+++public+override+int+GetHashCode()
+++{
++++++return+base.GetHashCode();
+++}|code-block|syntax|javascript|3344036|(当然，我也可以使用#杂注来关闭警告，但我更喜欢这种方式。)|3344037|当然，当您处于需要性能的位置时，其他人提到的所有问题都适用。最重要的值-否则在从哈希集或字典中检索项时会得到错误的结果：哈希码不能随着对象的生命周期而变化(更准确地说，是在需要哈希码的时候，比如当字典中的键时)：例如，下面的代码是错误的，因为值是公共的，所以在实例的生命周期中可以在类的外部进行更改，所以您不能将其用作哈希码的基础：|offset|length|style|BOLD|3344038|+++class+A
+++{
++++++public+int+Value;

++++++public+override+int+GetHashCode()
++++++{
+++++++++return+Value.GetHashCode();+//WRONG!+Value+is+not+constant+during+the+instance's+life+time
++++++}
+++}++++|3344039|另一方面，如果值不能改变，可以使用：|3344040|+++class+A
+++{
++++++public+readonly+int+Value;

++++++public+override+int+GetHashCode()
++++++{
+++++++++return+Value.GetHashCode();+//OK++Value+is+read-only+and+can't+be+changed+during+the+instance's+life+time
++++++}
+++}|3344041|entityMap^0|0|0|0|U|3S|0|0|0|I|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|Z|8|@$K|10|L|11|M|N]]|9|@]|A|$]]|$1|O|3|P|5|D|7|12|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|13|8|@$K|14|L|15|M|N]]|9|@]|A|$]]|$1|S|3|T|5|D|7|16|8|@]|9|@]|A|$E|F]]|$1|U|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|V|$]]

It's not necessarily important; it depends on the size of your collections and your performance requirements and whether your class will be used in a library where you may not know the performance requirements. I frequently know my collection sizes are not very large and my time is more valuable than a few microseconds of performance gained by creating a perfect hash code; so (to get rid of the annoying warning by the compiler) I simply use:

<pre><code> public override int GetHashCode()
 {
 return base.GetHashCode();
 }
</code></pre>

(Of course I could use a #pragma to turn off the warning as well but I prefer this way.)

When you are in the position that you do need the performance than all of the issues mentioned by others here apply, of course. Most important - otherwise you will get wrong results when retrieving items from a hash set or dictionary: the hash code must not vary with the life time of an object (more accurately, during the time whenever the hash code is needed, such as while being a key in a dictionary): for example, the following is wrong as Value is public and so can be changed externally to the class during the life time of the instance, so you must not use it as the basis for the hash code:

<pre><code>
 class A
 {
 public int Value;

 public override int GetHashCode()
 {
 return Value.GetHashCode(); //WRONG! Value is not constant during the instance's life time
 }
 } 
</code></pre>

On the other hand, if Value can't be changed it's ok to use:

<pre><code>
 class A
 {
 public readonly int Value;

 public override int GetHashCode()
 {
 return Value.GetHashCode(); //OK Value is read-only and can't be changed during the instance's life time
 }
 }

</code></pre>

blocks|key|929968|text|当覆盖Equals()时，请不要忘记对照null检查obj参数。同时也比较了不同的类型。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|929969|public+override+bool+Equals(object+obj)
{
++++Foo+fooItem+=+obj+as+Foo;

++++if+(fooItem+==+null)
++++{
+++++++return+false;
++++}

++++return+fooItem.FooId+==+this.FooId;
}|code-block|syntax|javascript|929970|原因是:与null进行比较时，Equals必须返回false。另请参阅http://msdn.microsoft.com/en-us/library/bsc2ak47.aspx|929971|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/bsc2ak47.aspx^0|3|8|K|4|0|0|5|4|F|6|Z|1H|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@$9|15|A|16|1|17]]|E|$]]|$1|M|3|-4|5|6|7|18|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

Please don´t forget to check the obj parameter against <code>null</code> when overriding <code>Equals()</code>.
And also compare the type.

<pre><code>public override bool Equals(object obj)
{
 Foo fooItem = obj as Foo;

 if (fooItem == null)
 {
 return false;
 }

 return fooItem.FooId == this.FooId;
}
</code></pre>

The reason for this is: <code>Equals</code> must return false on comparison to <code>null</code>. See also <a href="http://msdn.microsoft.com/en-us/library/bsc2ak47.aspx" rel="noreferrer">http://msdn.microsoft.com/en-us/library/bsc2ak47.aspx</a>

blocks|key|4189513|text|散列代码用于基于散列的集合，如字典、哈希表、HashSet等。此代码的目的是通过将特定对象放入特定的组(存储桶)来非常快速地对其进行预排序。当您需要从散列集合中检索该对象时，这种预排序非常有助于找到它，因为代码必须只在一个存储桶中搜索您的对象，而不是在它包含的所有对象中搜索。散列码的分布越好(唯一性越好)，检索速度就越快。在理想情况下，每个对象都有一个唯一的哈希码，查找它是一个O(1)操作。在大多数情况下，它接近O(1)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4189514|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|$]]

Hash code is used for hash-based collections like Dictionary, Hashtable, HashSet etc. The purpose of this code is to very quickly pre-sort specific object by putting it into specific group (bucket). This pre-sorting helps tremendously in finding this object when you need to retrieve it back from hash-collection because code has to search for your object in just one bucket instead of in all objects it contains. The better distribution of hash codes (better uniqueness) the faster retrieval. In ideal situation where each object has a unique hash code, finding it is an O(1) operation. In most cases it approaches O(1).

blocks|key|930027|text|我的理解是，原始的GetHashCode()返回对象的内存地址，所以如果您希望比较两个不同的对象，那么覆盖它是很有必要的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|930028|EDITED:这是不正确的，原始的GetHashCode()方法不能保证两个值相等。尽管相等的对象返回相同的哈希码。|930029|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|$]]

It's my understanding that the original GetHashCode() returns the memory address of the object, so it's essential to override it if you wish to compare two different objects. 

EDITED:
That was incorrect, the original GetHashCode() method cannot assure the equality of 2 values. Though objects that are equal return the same hash code.

blocks|key|4189593|text|我们有两个问题要处理。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4189594|4189595|如果对象中的任何字段都可以更改，则无法提供合理的GetHashCode()。此外，对象通常永远不会在依赖于GetHashCode()的集合中使用。因此，实现GetHashCode()的成本通常是不值得的，或者这是不可能的。|ordered-list-item|offset|length|style|CODE|4189596|如果有人将您的对象放在调用GetHashCode()的集合中，而您在没有使GetHashCode()以正确的方式运行的情况下覆盖了Equals()，那么这个人可能要花几天的时间来追踪这个问题。|4189597|4189598|因此，默认情况下，我是这样做的。|4189599|public+class+Foo
{
++++public+int+FooId+{+get;+set;+}
++++public+string+FooName+{+get;+set;+}

++++public+override+bool+Equals(object+obj)
++++{
++++++++Foo+fooItem+=+obj+as+Foo;

++++++++if+(fooItem+==+null)
++++++++{
+++++++++++return+false;
++++++++}

++++++++return+fooItem.FooId+==+this.FooId;
++++}

++++public+override+int+GetHashCode()
++++{
++++++++//+Some+comment+to+explain+if+there+is+a+real+problem+with+providing+GetHashCode()+
++++++++//+or+if+I+just+don't+see+a+need+for+it+for+the+given+class
++++++++throw+new+Exception("Sorry+I+don't+know+what+GetHashCode+should+do+for+this+class");
++++}
}|code-block|syntax|javascript|4189600|entityMap^0|0|0|O|D|1H|D|26|D|0|D|D|11|D|1T|8|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|W|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|X|8|@$F|Y|G|Z|H|I]|$F|10|G|11|H|I]|$F|12|G|13|H|I]]|9|@]|A|$]]|$1|J|3|K|5|E|7|14|8|@$F|15|G|16|H|I]|$F|17|G|18|H|I]|$F|19|G|1A|H|I]]|9|@]|A|$]]|$1|L|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1C|8|@]|9|@]|A|$]]|$1|O|3|P|5|Q|7|1D|8|@]|9|@]|A|$R|S]]|$1|T|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|U|$]]

We have two problems to cope with.

<ol>
<li>You cannot provide a sensible <code>GetHashCode()</code> if any field in the
object can be changed. Also often a object will NEVER be used in a
collection that depends on <code>GetHashCode()</code>. So the cost of
implementing <code>GetHashCode()</code> is often not worth it, or it is not
possible.</li>
<li>If someone puts your object in a collection that calls
<code>GetHashCode()</code> and you have overrided <code>Equals()</code> without also making
<code>GetHashCode()</code> behave in a correct way, that person may spend days
tracking down the problem.</li>
</ol>

Therefore by default I do.

<pre><code>public class Foo
{
 public int FooId { get; set; }
 public string FooName { get; set; }

 public override bool Equals(object obj)
 {
 Foo fooItem = obj as Foo;

 if (fooItem == null)
 {
 return false;
 }

 return fooItem.FooId == this.FooId;
 }

 public override int GetHashCode()
 {
 // Some comment to explain if there is a real problem with providing GetHashCode() 
 // or if I just don't see a need for it for the given class
 throw new Exception("Sorry I don't know what GetHashCode should do for this class");
 }
}
</code></pre>

blocks|key|126303|text|下面，在我看来，考虑到公共属性，使用反射是一个更好的选择，因为有了这个，你就不必担心属性的添加/删除(尽管不是很常见的情况)。我发现这也表现得更好。(使用诊断秒表比较时间)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|126304|++++public+int+getHashCode()
++++{
++++++++PropertyInfo[]+theProperties+=+this.GetType().GetProperties();
++++++++int+hash+=+31;
++++++++foreach+(PropertyInfo+info+in+theProperties)
++++++++{
++++++++++++if+(info+!=+null)
++++++++++++{
++++++++++++++++var+value+=+info.GetValue(this,null);
++++++++++++++++if(value+!=+null)
++++++++++++++++unchecked
++++++++++++++++{
++++++++++++++++++++hash+=+29+*+hash+%5E+value.GetHashCode();
++++++++++++++++}
++++++++++++}
++++++++}
++++++++return+hash;++
++++}|code-block|syntax|javascript|126305|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|$]]

Below using reflection seems to me a better option considering public properties as with this you don't have have to worry about addition / removal of properties (although not so common scenario). This I found to be performing better also.(Compared time using Diagonistics stop watch).

<pre><code> public int getHashCode()
 {
 PropertyInfo[] theProperties = this.GetType().GetProperties();
 int hash = 31;
 foreach (PropertyInfo info in theProperties)
 {
 if (info != null)
 {
 var value = info.GetValue(this,null);
 if(value != null)
 unchecked
 {
 hash = 29 * hash ^ value.GetHashCode();
 }
 }
 }
 return hash; 
 }
</code></pre>

blocks|key|930131|text|只是补充一下上面的答案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|930132|如果你不重写Equals，那么默认的行为是比较对象的引用。这同样适用于哈希码-默认实现通常基于引用的存储器地址。因为您确实覆盖了Equals，这意味着正确的行为是比较您在Equals上实现的任何东西，而不是引用，所以您应该对hashcode执行同样的操作。|930133|你的类的客户会期望散列码与equals方法有相似的逻辑，例如，linq方法首先使用IEqualityComparer比较散列码，只有当它们相等时，他们才会比较Equals()方法，这可能是运行成本更高的方法，如果我们没有实现hashcode，equal对象可能会有不同的散列码(因为它们有不同的内存地址)，并会被错误地确定为不相等(Equals()甚至不会命中)。|930134|此外，除了在字典中使用对象可能无法找到它的问题(因为它是由一个哈希码插入的，当您查找它时，默认的哈希码可能会不同，并且再一次不会调用Equals()，就像Marc+Gravell在他的答案中解释的那样，您还引入了对字典或哈希集概念的违反，这不应该允许相同的键-当您重写Equals时，您已经声明了这些对象本质上是相同的，所以您不希望它们在一个数据结构上作为不同的键，该结构应该有一个唯一的键。但是因为它们有不同的哈希码，所以“相同”的关键字将作为不同的关键字插入。|930135|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

Just to add on above answers:

If you don't override Equals then the default behavior is that references of the objects are compared. The same applies to hashcode - the default implmentation is typically based on a memory address of the reference.
Because you did override Equals it means the correct behavior is to compare whatever you implemented on Equals and not the references, so you should do the same for the hashcode. 

Clients of your class will expect the hashcode to have similar logic to the equals method, for example linq methods which use a IEqualityComparer first compare the hashcodes and only if they're equal they'll compare the Equals() method which might be more expensive to run, if we didn't implement hashcode, equal object will probably have different hashcodes (because they have different memory address) and will be determined wrongly as not equal (Equals() won't even hit).

In addition, except the problem that you might not be able to find your object if you used it in a dictionary (because it was inserted by one hashcode and when you look for it the default hashcode will probably be different and again the Equals() won't even be called, like Marc Gravell explains in his answer, you also introduce a violation of the dictionary or hashset concept which should not allow identical keys - 
you already declared that those objects are essentially the same when you overrode Equals so you don't want both of them as different keys on a data structure which suppose to have a unique key. But because they have a different hashcode the "same" key will be inserted as different one.

blocks|key|4189818|text|您应该始终保证，如果两个对象相等(由Equals()定义)，则它们应该返回相同的哈希码。正如其他一些评论所述，理论上，如果对象永远不会在HashSet或字典等基于散列的容器中使用，则这在理论上不是强制性的。不过，我建议你始终遵循这条规则。原因很简单，因为人们很容易将集合从一种类型更改为另一种类型，目的是实际提高性能，或者只是以更好的方式传达代码语义。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4189819|例如，假设我们将一些对象保存在一个列表中。过了一段时间，实际上有人意识到HashSet是一个更好的选择，例如，因为它有更好的搜索特性。这就是我们会陷入麻烦的时候。List将在内部为该类型使用默认的相等比较器，在本例中意味着等于，而HashSet则使用GetHashCode()。如果两者的行为不同，那么您的程序也会不同。请记住，这些问题并不是最容易解决的。|4189820|我已经将此行为与blog+post中的其他一些GetHashCode()陷阱进行了总结，您可以在其中找到更多示例和解释。|offset|length|4189821|entityMap|0|LINK|mutability|MUTABLE|url|https://vkontech.com/gethashcode-pitfalls/^0|0|0|8|9|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@$F|S|G|T|1|U]]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

You should always guarantee that if two objects are equal, as defined by Equals(), they should return the same hash code. As some of the other comments state, in theory this is not mandatory if the object will never be used in a hash based container like HashSet or Dictionary. I would advice you to always follow this rule though. The reason is simply because it is way too easy for someone to change a collection from one type to another with the good intention of actually improving the performance or just conveying the code semantics in a better way.

For example, suppose we keep some objects in a List. Sometime later someone actually realizes that a HashSet is a much better alternative because of the better search characteristics for example. This is when we can get into trouble. List would internally use the default equality comparer for the type which means Equals in your case while HashSet makes use of GetHashCode(). If the two behave differently, so will your program. And bear in mind that such issues are not the easiest to troubleshoot.

I've summarized this behavior with some other GetHashCode() pitfalls in a <a href="https://vkontech.com/gethashcode-pitfalls/" rel="nofollow noreferrer">blog post</a> where you can find further examples and explanations.

blocks|key|930176|text|对于.NET+4.7，覆盖GetHashCode()的首选方法如下所示。如果目标是较旧的.NET版本，请包括System.ValueTuple+nuget包。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|930177|//+C#+7.0%2B
public+override+int+GetHashCode()+=>+(FooId,+FooName).GetHashCode();|code-block|syntax|javascript|930178|在性能方面，该方法将优于大多数复合散列代码实现。ValueTuple是一个struct，所以不会有任何垃圾，并且底层算法是最快的。|930179|entityMap|0|LINK|mutability|MUTABLE|url|https://www.nuget.org/packages/System.ValueTuple/|1|https://docs.microsoft.com/en-us/dotnet/api/system.valuetuple?view=netcore-3.1^0|2|8|D|D|1I|N|0|0|0|11|6|O|A|1|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@$9|11|A|12|1|13]]|E|$]]|$1|F|3|G|5|H|7|14|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|15|8|@$9|16|A|17|B|C]]|D|@$9|18|A|19|1|1A]]|E|$]]|$1|M|3|-4|5|6|7|1B|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]|U|$5|P|Q|R|E|$S|V]]]]

As of <code>.NET 4.7</code> the preferred method of overriding <code>GetHashCode()</code> is shown below. If targeting older .NET versions, include the <a href="https://www.nuget.org/packages/System.ValueTuple/" rel="noreferrer">System.ValueTuple nuget</a> package.

<pre class="lang-cs prettyprint-override"><code>// C# 7.0+
public override int GetHashCode() =&gt; (FooId, FooName).GetHashCode();
</code></pre>

In terms of performance, this method will outperform most composite hash code implementations. The <a href="https://docs.microsoft.com/en-us/dotnet/api/system.valuetuple?view=netcore-3.1" rel="noreferrer">ValueTuple</a> is a <code>struct</code> so there won't be any garbage, and the underlying algorithm is as fast as it gets.

blocks|key|126511|text|从C#+9(.net+5或.net+Core3.1)开始，您可能希望像使用Value+Based+Equality一样使用records。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|126512|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-9|1|https://dev.to/wrijugh/c-9-0-value-based-equality-2n8j|2|https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-9#record-types^0|1|4|0|11|K|1|1P|7|2|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]|$A|T|B|U|1|V]|$A|W|B|X|1|Y]]|C|$]]|$1|D|3|-4|5|6|7|Z|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]|N|$5|G|H|I|C|$J|O]]]]

As of <a href="https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-9" rel="nofollow noreferrer">C# 9</a>(.net 5 or .net core 3.1), you may want to use <a href="https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-9#record-types" rel="nofollow noreferrer">records</a> as it does <a href="https://dev.to/wrijugh/c-9-0-value-based-equality-2n8j" rel="nofollow noreferrer">Value Based Equality</a>.

Given the following class

<pre><code>public class Foo
{
 public int FooId { get; set; }
 public string FooName { get; set; }

 public override bool Equals(object obj)
 {
 Foo fooItem = obj as Foo;

 if (fooItem == null) 
 {
 return false;
 }

 return fooItem.FooId == this.FooId;
 }

 public override int GetHashCode()
 {
 // Which is preferred?

 return base.GetHashCode();

 //return this.FooId.GetHashCode();
 }
}
</code></pre>

I have overridden the <code>Equals</code> method because <code>Foo</code> represent a row for the <code>Foo</code>s table. Which is the preferred method for overriding the <code>GetHashCode</code>?

Why is it important to override <code>GetHashCode</code>?

Why is it important to override GetHashCode when Equals method is overridden?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

给定以下类public class Foo{    public int FooId { get; set; }    public string FooName { get; set; }    public override bool Equals(object obj)    {        Foo fooIt...

问当Equals方法被覆盖时，为什么覆盖GetHashCode很重要？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问当Equals方法被覆盖时，为什么覆盖GetHashCode很重要？EN