什么是重写的System.Object.GetHashCode的最佳algorithm？
在.NET中System.Object.GetHashCode方法被用在很多地方，在整个.NET基类库中。 特别是在快速查找collections中的物品或确定平等时。 是否有一个标准的algorithm/最佳做法如何实现我的自定义类的GetHashCode覆盖，所以我不降低性能？
我通常使用类似于Josh Bloch 神话般的 Effective Java中的实现 。 这很快，并创build一个不太可能造成冲突的相当不错的哈希。 select两个不同的素数，例如17和23，然后：
public override int GetHashCode() { unchecked // Overflow is fine, just wrap { int hash = 17; // Suitable nullity checks etc, of course :) hash = hash * 23 + field1.GetHashCode(); hash = hash * 23 + field2.GetHashCode(); hash = hash * 23 + field3.GetHashCode(); return hash; } }
正如评论中指出的那样，您可能会发现，select一个大的素数来代替乘法会更好。 显然486187739是好的…虽然我看到的小数字的大多数例子倾向于使用素数，但是至less有类似的algorithm，其中经常使用非素数。 例如，在后来的FNV不太完整的例子中，我使用的数字显然效果不错 – 但是初始值并不是主要的。 （乘法常数是主要的，但我不知道这是多么的重要。）
由于两个主要原因，这比通常的XOR更好。 假设我们有一个带有两个int字段的types：
XorHash(x, x) == XorHash(y, y) == 0 for all x, y XorHash(x, y) == XorHash(y, x) for all x, y
顺便说一下，早期的algorithm是C＃编译器当前使用的匿名types的algorithm。
这个页面提供了很多选项。 我认为在大多数情况下，上述内容“足够好”，记住和正确的logging非常容易。 FNV的select同样简单，但使用不同的常量和XOR而不是ADD作为组合操作。 它看起来像下面的代码，但正常的FNValgorithm对单个字节进行操作，所以这需要修改每个字节执行一次迭代，而不是每个32位散列值。 FNV也被devise用于可变长度的数据，而我们在这里使用的方式始终是相同数量的字段值。 对这个答案的评论表明，这里的代码实际上并不如上面的加法方法那样工作（在样本情况下testing）。
// Note: Not quite FNV! public override int GetHashCode() { unchecked // Overflow is fine, just wrap { int hash = (int) 2166136261; // Suitable nullity checks etc, of course :) hash = (hash * 16777619) ^ field1.GetHashCode(); hash = (hash * 16777619) ^ field2.GetHashCode(); hash = (hash * 16777619) ^ field3.GetHashCode(); return hash; } }
请注意，有一点需要注意的是，理想情况下，应该在将其添加到依赖哈希代码的集合中之后，防止对平等敏感（因此对哈希码敏感）状态发生更改。
根据文件 ：
你可以为不可变的引用types覆盖GetHashCode。 通常，对于可变引用types，只有在以下情况下才应该重写GetHashCode：
- 你可以从不可变的字段计算哈希代码; 要么
- 当对象包含在依赖哈希码的集合中时，可以确保可变对象的哈希码不会更改。
微软已经提供了一个很好的通用HashCode生成器：只需将您的属性/字段值复制到一个匿名types并将其哈希：
new { PropA, PropB, PropC, PropD }.GetHashCode();
这将适用于任何数量的属性。 它不使用拳击或额外的资源。 它只是使用匿名types框架中已经实现的algorithm。
这是我的hashcode助手。
它的优点是它使用genericstypes参数，因此不会导致装箱：
public static class HashHelper { public static int GetHashCode<T1, T2>(T1 arg1, T2 arg2) { unchecked { return 31 * arg1.GetHashCode() + arg2.GetHashCode(); } } public static int GetHashCode<T1, T2, T3>(T1 arg1, T2 arg2, T3 arg3) { unchecked { int hash = arg1.GetHashCode(); hash = 31 * hash + arg2.GetHashCode(); return 31 * hash + arg3.GetHashCode(); } } public static int GetHashCode<T1, T2, T3, T4>(T1 arg1, T2 arg2, T3 arg3, T4 arg4) { unchecked { int hash = arg1.GetHashCode(); hash = 31 * hash + arg2.GetHashCode(); hash = 31 * hash + arg3.GetHashCode(); return 31 * hash + arg4.GetHashCode(); } } public static int GetHashCode<T>(T[] list) { unchecked { int hash = 0; foreach (var item in list) { hash = 31 * hash + item.GetHashCode(); } return hash; } } public static int GetHashCode<T>(IEnumerable<T> list) { unchecked { int hash = 0; foreach (var item in list) { hash = 31 * hash + item.GetHashCode(); } return hash; } } /// <summary> /// Gets a hashcode for a collection for that the order of items /// does not matter. /// So {1, 2, 3} and {3, 2, 1} will get same hash code. /// </summary> public static int GetHashCodeForOrderNoMatterCollection<T>( IEnumerable<T> list) { unchecked { int hash = 0; int count = 0; foreach (var item in list) { hash += item.GetHashCode(); count++; } return 31 * hash + count.GetHashCode(); } } /// <summary> /// Alternative way to get a hashcode is to use a fluent /// interface like this:<br /> /// return 0.CombineHashCode(field1).CombineHashCode(field2). /// CombineHashCode(field3); /// </summary> public static int CombineHashCode<T>(this int hashCode, T arg) { unchecked { return 31 * hashCode + arg.GetHashCode(); } }
也有扩展方法提供stream畅的界面，所以你可以这样使用它：
public override int GetHashCode() { return HashHelper.GetHashCode(Manufacturer, PartN, Quantity); }
或者像这样：
public override int GetHashCode() { return 0.CombineHashCode(Manufacturer) .CombineHashCode(PartN) .CombineHashCode(Quantity); }
我在帮助库中有一个哈希类，用于此目的。
/// <summary> /// This is a simple hashing function from Robert Sedgwicks Hashing in C book. /// Also, some simple optimizations to the algorithm in order to speed up /// its hashing process have been added. from: www.partow.net /// </summary> /// <param name="input">array of objects, parameters combination that you need /// to get a unique hash code for them</param> /// <returns>Hash code</returns> public static int RSHash(params object[] input) { const int b = 378551; int a = 63689; int hash = 0; // If it overflows then just wrap around unchecked { for (int i = 0; i < input.Length; i++) { if (input[i] != null) { hash = hash * a + input[i].GetHashCode(); a = a * b; } } } return hash; }
那么，只要你可以使用它：
public override int GetHashCode() { return Hashing.RSHash(_field1, _field2, _field3); }
我没有评估它的performance，所以欢迎任何反馈。
这是我的助手类，它使用Jon Skeet的实现 。
public static class HashCode { public const int Start = 17; public static int Hash<T>(this int hash, T obj) { var h = EqualityComparer<T>.Default.GetHashCode(obj); return unchecked((hash * 31) + h); } }
用法：
public override int GetHashCode() { return HashCode.Start .Hash(field1) .Hash(field2) .Hash(field3); }
如果你想避免写一个System.Int32的扩展方法：
public struct HashCode { private readonly int hashCode; public HashCode(int hashCode) { this.hashCode = hashCode; } public static HashCode Start { get; } = new HashCode(17); public static implicit operator int(HashCode hashCode) => hashCode.GetHashCode(); public HashCode Hash<T>(T obj) { var h = EqualityComparer<T>.Default.GetHashCode(obj); return unchecked(new HashCode((this.hashCode * 31) + h)); } public override int GetHashCode() => this.hashCode; }
它仍然是通用的，它仍然避免了任何堆分配，它的使用方式完全相同：
public override int GetHashCode() { // This time `HashCode.Start` is not an `Int32`, it's a `HashCode` instance. // And the result is implicitly converted to `Int32`. return HashCode.Start .Hash(field1) .Hash(field2) .Hash(field3); }
马丁评论后更新：
obj != null导致拳击，所以我切换到默认比较。
- 看到这个答案关于默认比较器的性能。
- 看到这个问题的空值的哈希代码的讨论。
在Equals（）比较多个字段的大多数情况下，如果GetHash（）在一个字段或多个字段上散列并不重要。 你只需要确保计算哈希值真的很便宜（请不要分配 ），而且速度快（ 没有繁重的计算 ，当然也没有数据库连接），并提供了一个很好的分配。
繁重的工作应该是Equals（）方法的一部分。 哈希应该是一个非常便宜的操作，以尽可能less的项目调用Equals（）。
最后一个提示： 不要依赖GetHashCode（）在多个应用程序运行中保持稳定 。 许多.Nettypes不保证它们的哈希码在重新启动后保持不变，所以您应该只在内存数据结构中使用GetHashCode（）的值。
直到最近，我的答案都非常接近Jon Skeet在这里。 不过，我最近开始了一个项目，它使用了幂级别为2的散列表，即内部表的大小为8,16,32等的散列表。有一个很好的理由来支持素数大小，但是在那里对于两款机型来说也是一些优势。
而且非常吸引人。 所以经过一些实验和研究之后，我开始用以下方式对哈希进行重新哈希处理：
public static int ReHash(int source) { unchecked { ulong c = 0xDEADBEEFDEADBEEF + (ulong)source; ulong d = 0xE2ADBEEFDEADBEEF ^ c; ulong a = d += c = c << 15 | c >> -15; ulong b = a += d = d << 52 | d >> -52; c ^= b += a = a << 26 | a >> -26; d ^= c += b = b << 51 | b >> -51; a ^= d += c = c << 28 | c >> -28; b ^= a += d = d << 9 | d >> -9; c ^= b += a = a << 47 | a >> -47; d ^= c += b << 54 | b >> -54; a ^= d += c << 32 | c >> 32; a += d << 25 | d >> -25; return (int)(a >> 1); } }
然后我的权力的哈希表没有再吸了。
这让我感到不安，因为上述不应该起作用。 或者更确切地说，除非原始的GetHashCode()以非常特殊的方式很差，否则它不应该工作。
重新混合一个哈希码不能改善一个好的哈希码，因为唯一可能的影响就是我们引入了更多的碰撞。
重新混合哈希码不能改善可怕的哈希码，因为唯一可能的影响是我们将例如53值上的大量碰撞改变为大量值183487291。
重新混合一个哈希码只能改善一个哈希码，它至less可以很好地避免整个范围内的绝对冲突（2 32个可能的值），但是在哈希表中实际使用时，避免了冲突的冲突。 虽然更简单的“二的幂次表”模式使这一点变得更加明显，但它也对更常见的素数表产生了负面影响，但这并不明显（重新调整的额外工作将超过收益，但好处仍然在那里）。
编辑：我也使用开放寻址，这也会增加对碰撞的敏感度，可能比它的功率更强。
好吧，这是多lessstring.GetHashCode()可以改进这种方式（按照testing的顺序运行约20-30倍，由于更less的冲突），更扰乱多less我自己的哈希代码可以改善（更多比起那个来说）。
我过去编写的所有GetHashCode（）实现，实际上用作本网站的答案的基础，比我经历的要糟得多 。 大部分时间对于大部分用途来说“足够好”，但是我想要更好的东西。
所以我把这个项目放在一边（反正是一个宠物项目），并开始着眼于如何快速地在.NET中生成一个良好的，散布的散列码。
最后我决定把SpookyHash移植到.NET上。 实际上，上面的代码是使用SpookyHash从32位input产生32位输出的快速path版本。
现在，SpookyHash不是一个很好的快速记住一段代码。 我的端口更是如此，因为我为了更好的速度手工添加了很多内容。 但是这就是代码重用的目的。
然后我把这个项目放在一边，因为正如原来的项目产生了如何产生更好的哈希代码的问题，所以项目产生了如何产生更好的.NET memcpy的问题。
然后我回来了，并产生了很多重载，轻松地将几乎所有的本地types（除了decimal †）都送入哈希码。
Bob Jenkins值得信赖，因为他的原始代码更快，尤其是在64位机器上，这个algorithm是针对‡优化的。
完整的代码可以在https://bitbucket.org/JonHanna/spookilysharp/src看到，但是可以认为上面的代码是它的简化版本。;
但是，由于现在已经写好了，所以可以更容易地使用它：
public override int GetHashCode() { var hash = new SpookyHash(); hash.Update(field1); hash.Update(field2); hash.Update(field3); return hash.Final().GetHashCode(); }
它也需要种子值，所以如果你需要处理不可信的input，并希望防止哈希DoS攻击，你可以设置基于正常运行时间或类似的种子，并使结果不可预知的攻击者：
private static long hashSeed0 = Environment.TickCount; private static long hashSeed1 = DateTime.Now.Ticks; public override int GetHashCode() { //produce different hashes ever time this application is restarted //but remain consistent in each run, so attackers have a harder time //DoSing the hash tables. var hash = new SpookyHash(hashSeed0, hashSeed1); hash.Update(field1); hash.Update(field2); hash.Update(field3); return hash.Final().GetHashCode(); }
*一个很大的惊喜就是手动旋转返回的旋转方法(x << n) | (x >> -n) (x << n) | (x >> -n)改进了一些东西。 我可以肯定的是，抖动会为我说明，但分析表明，否则。
† decimal不是从.NET的angular度来看，尽pipe它来自C＃。 问题在于它自己的GetHashCode()将精度视为重要，而它自己的Equals()则不精确。 两者都是有效的select，但不是那样混合。 在实现你自己的版本时，你需要select做一个，或者其他的，但我不知道你想要的。
‡通过比较。 如果用在一个string上，64位的SpookyHash比32位的string.GetHashCode()要快得多，这比64位的string.GetHashCode()要快一些，这比32位的SpookyHash快得多，但仍然快足以成为一个合理的select。
这是一个很好的：
/// <summary> /// Helper class for generating hash codes suitable /// for use in hashing algorithms and data structures like a hash table. /// </summary> public static class HashCodeHelper { private static int GetHashCodeInternal(int key1, int key2) { unchecked { var num = 0x7e53a269; num = (-1521134295 * num) + key1; num += (num << 10); num ^= (num >> 6); num = ((-1521134295 * num) + key2); num += (num << 10); num ^= (num >> 6); return num; } } /// <summary> /// Returns a hash code for the specified objects /// </summary> /// <param name="arr">An array of objects used for generating the /// hash code.</param> /// <returns> /// A hash code, suitable for use in hashing algorithms and data /// structures like a hash table. /// </returns> public static int GetHashCode(params object[] arr) { int hash = 0; foreach (var item in arr) hash = GetHashCodeInternal(hash, item.GetHashCode()); return hash; } /// <summary> /// Returns a hash code for the specified objects /// </summary> /// <param name="obj1">The first object.</param> /// <param name="obj2">The second object.</param> /// <param name="obj3">The third object.</param> /// <param name="obj4">The fourth object.</param> /// <returns> /// A hash code, suitable for use in hashing algorithms and /// data structures like a hash table. /// </returns> public static int GetHashCode<T1, T2, T3, T4>(T1 obj1, T2 obj2, T3 obj3, T4 obj4) { return GetHashCode(obj1, GetHashCode(obj2, obj3, obj4)); } /// <summary> /// Returns a hash code for the specified objects /// </summary> /// <param name="obj1">The first object.</param> /// <param name="obj2">The second object.</param> /// <param name="obj3">The third object.</param> /// <returns> /// A hash code, suitable for use in hashing algorithms and data /// structures like a hash table. /// </returns> public static int GetHashCode<T1, T2, T3>(T1 obj1, T2 obj2, T3 obj3) { return GetHashCode(obj1, GetHashCode(obj2, obj3)); } /// <summary> /// Returns a hash code for the specified objects /// </summary> /// <param name="obj1">The first object.</param> /// <param name="obj2">The second object.</param> /// <returns> /// A hash code, suitable for use in hashing algorithms and data /// structures like a hash table. /// </returns> public static int GetHashCode<T1, T2>(T1 obj1, T2 obj2) { return GetHashCodeInternal(obj1.GetHashCode(), obj2.GetHashCode()); } }
这里是如何使用它：
private struct Key { private Type _type; private string _field; public Type Type { get { return _type; } } public string Field { get { return _field; } } public Key(Type type, string field) { _type = type; _field = field; } public override int GetHashCode() { return HashCodeHelper.GetHashCode(_field, _type); } public override bool Equals(object obj) { if (!(obj is Key)) return false; var tf = (Key)obj; return tf._field.Equals(_field) && tf._type.Equals(_type); } }
这是我简单化的方法。 我正在使用经典的生成器模式。 这是types安全（没有装箱/拆箱），也与.NET 2.0（没有扩展方法等）compatbile。
它是这样使用的：
public override int GetHashCode() { HashBuilder b = new HashBuilder(); b.AddItems(this.member1, this.member2, this.member3); return b.Result; }
这里是acutalbuild造者类：
internal class HashBuilder { private const int Prime1 = 17; private const int Prime2 = 23; private int result = Prime1; public HashBuilder() { } public HashBuilder(int startHash) { this.result = startHash; } public int Result { get { return this.result; } } public void AddItem<T>(T item) { unchecked { this.result = this.result * Prime2 + item.GetHashCode(); } } public void AddItems<T1, T2>(T1 item1, T2 item2) { this.AddItem(item1); this.AddItem(item2); } public void AddItems<T1, T2, T3>(T1 item1, T2 item2, T3 item3) { this.AddItem(item1); this.AddItem(item2); this.AddItem(item3); } public void AddItems<T1, T2, T3, T4>(T1 item1, T2 item2, T3 item3, T4 item4) { this.AddItem(item1); this.AddItem(item2); this.AddItem(item3); this.AddItem(item4); } public void AddItems<T1, T2, T3, T4, T5>(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5) { this.AddItem(item1); this.AddItem(item2); this.AddItem(item3); this.AddItem(item4); this.AddItem(item5); } public void AddItems<T>(params T[] items) { foreach (T item in items) { this.AddItem(item); } } }
Here is another fluent implementation of the algorithm posted above by Jon Skeet , but which includes no allocations or boxing operations:
public static class Hash { public const int Base = 17; public static int HashObject(this int hash, object obj) { unchecked { return hash * 23 + (obj == null ? 0 : obj.GetHashCode()); } } public static int HashValue<T>(this int hash, T value) where T : struct { unchecked { return hash * 23 + value.GetHashCode(); } } }
用法：
public class MyType<T> { public string Name { get; set; } public string Description { get; set; } public int Value { get; set; } public IEnumerable<T> Children { get; set; } public override int GetHashCode() { return Hash.Base .HashObject(this.Name) .HashObject(this.Description) .HashValue(this.Value) .HashObject(this.Children); } }
The compiler will ensure HashValue is not called with a class due to the generic type constraint. But there is no compiler support for HashObject since adding a generic argument also adds a boxing operation.
Most of my work is done with database connectivity which means that my classes all have a unique identifier from the database. I always use the ID from the database to generate the hashcode.
// Unique ID from database private int _id; ... { return _id.GetHashCode(); }
Pretty much similar to nightcoder's solution except it's easier to raise primes if you want to.
PS: This is one of those times where you puke a little in your mouth, knowing that this could be refactored into one method with 9 default's but it would be slower, so you just close your eyes and try to forget about it.
/// <summary> /// Try not to look at the source code. It works. Just rely on it. /// </summary> public static class HashHelper { private const int PrimeOne = 17; private const int PrimeTwo = 23; public static int GetHashCode<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10) { unchecked { int hash = PrimeOne; hash = hash * PrimeTwo + arg1.GetHashCode(); hash = hash * PrimeTwo + arg2.GetHashCode(); hash = hash * PrimeTwo + arg3.GetHashCode(); hash = hash * PrimeTwo + arg4.GetHashCode(); hash = hash * PrimeTwo + arg5.GetHashCode(); hash = hash * PrimeTwo + arg6.GetHashCode(); hash = hash * PrimeTwo + arg7.GetHashCode(); hash = hash * PrimeTwo + arg8.GetHashCode(); hash = hash * PrimeTwo + arg9.GetHashCode(); hash = hash * PrimeTwo + arg10.GetHashCode(); return hash; } } public static int GetHashCode<T1, T2, T3, T4, T5, T6, T7, T8, T9>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9) { unchecked { int hash = PrimeOne; hash = hash * PrimeTwo + arg1.GetHashCode(); hash = hash * PrimeTwo + arg2.GetHashCode(); hash = hash * PrimeTwo + arg3.GetHashCode(); hash = hash * PrimeTwo + arg4.GetHashCode(); hash = hash * PrimeTwo + arg5.GetHashCode(); hash = hash * PrimeTwo + arg6.GetHashCode(); hash = hash * PrimeTwo + arg7.GetHashCode(); hash = hash * PrimeTwo + arg8.GetHashCode(); hash = hash * PrimeTwo + arg9.GetHashCode(); return hash; } } public static int GetHashCode<T1, T2, T3, T4, T5, T6, T7, T8>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8) { unchecked { int hash = PrimeOne; hash = hash * PrimeTwo + arg1.GetHashCode(); hash = hash * PrimeTwo + arg2.GetHashCode(); hash = hash * PrimeTwo + arg3.GetHashCode(); hash = hash * PrimeTwo + arg4.GetHashCode(); hash = hash * PrimeTwo + arg5.GetHashCode(); hash = hash * PrimeTwo + arg6.GetHashCode(); hash = hash * PrimeTwo + arg7.GetHashCode(); hash = hash * PrimeTwo + arg8.GetHashCode(); return hash; } } public static int GetHashCode<T1, T2, T3, T4, T5, T6, T7>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7) { unchecked { int hash = PrimeOne; hash = hash * PrimeTwo + arg1.GetHashCode(); hash = hash * PrimeTwo + arg2.GetHashCode(); hash = hash * PrimeTwo + arg3.GetHashCode(); hash = hash * PrimeTwo + arg4.GetHashCode(); hash = hash * PrimeTwo + arg5.GetHashCode(); hash = hash * PrimeTwo + arg6.GetHashCode(); hash = hash * PrimeTwo + arg7.GetHashCode(); return hash; } } public static int GetHashCode<T1, T2, T3, T4, T5, T6>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6) { unchecked { int hash = PrimeOne; hash = hash * PrimeTwo + arg1.GetHashCode(); hash = hash * PrimeTwo + arg2.GetHashCode(); hash = hash * PrimeTwo + arg3.GetHashCode(); hash = hash * PrimeTwo + arg4.GetHashCode(); hash = hash * PrimeTwo + arg5.GetHashCode(); hash = hash * PrimeTwo + arg6.GetHashCode(); return hash; } } public static int GetHashCode<T1, T2, T3, T4, T5>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5) { unchecked { int hash = PrimeOne; hash = hash * PrimeTwo + arg1.GetHashCode(); hash = hash * PrimeTwo + arg2.GetHashCode(); hash = hash * PrimeTwo + arg3.GetHashCode(); hash = hash * PrimeTwo + arg4.GetHashCode(); hash = hash * PrimeTwo + arg5.GetHashCode(); return hash; } } public static int GetHashCode<T1, T2, T3, T4>(T1 arg1, T2 arg2, T3 arg3, T4 arg4) { unchecked { int hash = PrimeOne; hash = hash * PrimeTwo + arg1.GetHashCode(); hash = hash * PrimeTwo + arg2.GetHashCode(); hash = hash * PrimeTwo + arg3.GetHashCode(); hash = hash * PrimeTwo + arg4.GetHashCode(); return hash; } } public static int GetHashCode<T1, T2, T3>(T1 arg1, T2 arg2, T3 arg3) { unchecked { int hash = PrimeOne; hash = hash * PrimeTwo + arg1.GetHashCode(); hash = hash * PrimeTwo + arg2.GetHashCode(); hash = hash * PrimeTwo + arg3.GetHashCode(); return hash; } } public static int GetHashCode<T1, T2>(T1 arg1, T2 arg2) { unchecked { int hash = PrimeOne; hash = hash * PrimeTwo + arg1.GetHashCode(); hash = hash * PrimeTwo + arg2.GetHashCode(); return hash; } } }
ReSharper users can generate GetHashCode, Equals, and others with ReSharper -> Edit -> Generate Code -> Equality Members .
// ReSharper's GetHashCode looks like this public override int GetHashCode() { unchecked { int hashCode = Id; hashCode = (hashCode * 397) ^ IntMember; hashCode = (hashCode * 397) ^ OtherIntMember; hashCode = (hashCode * 397) ^ (RefMember != null ? RefMember.GetHashCode() : 0); // ... return hashCode; } }
397 seems to be an ersatz ReSharper "signature", as all methods as of version 2016.2 use it.
Microsoft lead for several way of hashing….
return this.value;// for classes that contain a single int value return x ^ y;//for classes that contain multiple int value return ((int)value ^ (int)(value >> 32));//Forclasses that contain single number bigger than int return obj1.GetHashCode();//for classes that contain class instance field which inherit from object return obj1.GetHashCode() ^ obj2.GetHashCode() ^ obj3.GetHashCode();//for classes that contain multiple class instance field which inherit from object
i can guess that for multiple big int u can use this:
int a=((int)value1 ^ (int)(value1 >> 32)); int b=((int)value2 ^ (int)(value2 >> 32)); int c=((int)value3 ^ (int)(value3 >> 32)); return a ^ b ^ c;
and same for multi-type… all converted first to int using GetHashCode() then the int values will be xor'ed and the result is ur hash…
for those who use hash as ID (i mean a unique value), hash is naturally limit number of digits, i think it was 5 bytes for hashing algorithm, at last MD5…
you may turn multiple value to a hashed value and some of them be same, so don't use it as an identifier… (maybe some day i gonna use your component)
I ran into an issue with floats and decimals using the implementation selected as the answer above.
This test fails (floats; hash is the same even though I switched 2 values to be negative):
var obj1 = new { A = 100m, B = 100m, C = 100m, D = 100m}; var obj2 = new { A = 100m, B = 100m, C = -100m, D = -100m}; var hash1 = ComputeHash(obj1.A, obj1.B, obj1.C, obj1.D); var hash2 = ComputeHash(obj2.A, obj2.B, obj2.C, obj2.D); Assert.IsFalse(hash1 == hash2, string.Format("Hashcode values should be different hash1:{0} hash2:{1}",hash1,hash2));
But this test passes (with ints):
var obj1 = new { A = 100m, B = 100m, C = 100, D = 100}; var obj2 = new { A = 100m, B = 100m, C = -100, D = -100}; var hash1 = ComputeHash(obj1.A, obj1.B, obj1.C, obj1.D); var hash2 = ComputeHash(obj2.A, obj2.B, obj2.C, obj2.D); Assert.IsFalse(hash1 == hash2, string.Format("Hashcode values should be different hash1:{0} hash2:{1}",hash1,hash2));
I changed my implementation to not use GetHashCode for the primitive types and it seems to work better
private static int InternalComputeHash(params object[] obj) { unchecked { var result = (int)SEED_VALUE_PRIME; for (uint i = 0; i < obj.Length; i++) { var currval = result; var nextval = DetermineNextValue(obj[i]); result = (result * MULTIPLIER_VALUE_PRIME) + nextval; } return result; } } private static int DetermineNextValue(object value) { unchecked { int hashCode; if (value is short || value is int || value is byte || value is sbyte || value is uint || value is ushort || value is ulong || value is long || value is float || value is double || value is decimal) { return Convert.ToInt32(value); } else { return value != null ? value.GetHashCode() : 0; } } }
Here is a class that I built with methods to use inside of the overrides of Equals(object obj) and GetHashCode(). I decided to use generics and a hashing algorithm that should be able to cover most objects. Please let me know if you see anything here that doesn't work for some types of object and you have a way to improve it.
public class Equality<T> { public int GetHashCode(T classInstance) { List<FieldInfo> fields = GetFields(); unchecked { int hash = 17; foreach (FieldInfo field in fields) { hash = hash * 397 + field.GetValue(classInstance).GetHashCode(); } return hash; } } public bool Equals(T classInstance, object obj) { if (ReferenceEquals(null, obj)) { return false; } if (ReferenceEquals(this, obj)) { return true; } if (classInstance.GetType() != obj.GetType()) { return false; } return Equals(classInstance, (T)obj); } private bool Equals(T classInstance, T otherInstance) { List<FieldInfo> fields = GetFields(); foreach (var field in fields) { if (!field.GetValue(classInstance).Equals(field.GetValue(otherInstance))) { return false; } } return true; } private List<FieldInfo> GetFields() { Type myType = typeof(T); List<FieldInfo> fields = myType.GetTypeInfo().DeclaredFields.ToList(); return fields; } }
Here is how it's used in a class:
public override bool Equals(object obj) { return new Equality<ClassName>().Equals(this, obj); } public override int GetHashCode() { unchecked { return new Equality<ClassName>().GetHashCode(this); } }
