What is the best algorithm for overriding GetHashCode

Question

In  NET  the GetHashCode method is used in a lot of places throughout the  NET base class libraries  Implementing it properly is especially important to find items quickly in a collection or when determining equality   Is there a standard algorithm or best practice on how to implement GetHashCode for my custom classes so I don t degrade performance

User · Answer

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(); }
    }
}

Usage:

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.

User · Answer

NET Standard 2 1 And Above If you are using  NET Standard 2 1 or above  you can use the System HashCode struct  There are two methods of using it  HashCode Combine The Combine method can be used to create a hash code  given up to eight objects  public override int GetHashCode     gt  HashCode Combine this object1  this object2    HashCode Add The Add method helps you to deal with collections  public override int GetHashCode         var hashCode   new HashCode        hashCode Add this object1       foreach  var item in this collection                hashCode Add item             return hashCode ToHashCode       GetHashCode Made Easy You can read the full blog post  GetHashCode Made Easy  for more details and comments  Usage Example public class SuperHero       public int Age   get  set        public string Name   get  set        public List lt string gt  Powers   get  set         public override int GetHashCode     gt          HashCode Of this Name  And this Age  AndEach this Powers      Implementation public struct HashCode   IEquatable lt HashCode gt        private const int EmptyCollectionPrimeNumber   19      private readonly int value       private HashCode int value    gt  this value   value       public static implicit operator int HashCode hashCode    gt  hashCode value       public static bool operator    HashCode left  HashCode right    gt  left Equals right        public static bool operator    HashCode left  HashCode right    gt    left    right        public static HashCode Of lt T gt  T item    gt  new HashCode GetHashCode item         public static HashCode OfEach lt T gt  IEnumerable lt T gt  items    gt          items    null   new HashCode 0    new HashCode GetHashCode items  0         public HashCode And lt T gt  T item    gt           new HashCode CombineHashCodes this value  GetHashCode item          public HashCode AndEach lt T gt  IEnumerable lt T gt  items                if  items    null                        return new HashCode this value                      return new HashCode GetHashCode items  this value               public bool Equals HashCode other    gt  this value Equals other value        public override bool Equals object obj                if  obj is HashCode                        return this Equals  HashCode obj                      return false             public override int GetHashCode     gt  this value GetHashCode         private static int CombineHashCodes int h1  int h2                unchecked                          Code copied from System Tuple a good way to combine hashes              return   h1  lt  lt  5    h1    h2                       private static int GetHashCode lt T gt  T item    gt  item  GetHashCode      0       private static int GetHashCode lt T gt  IEnumerable lt T gt  items  int startHashCode                var temp   startHashCode           var enumerator   items GetEnumerator            if  enumerator MoveNext                          temp   CombineHashCodes temp  GetHashCode enumerator Current                 while  enumerator MoveNext                                  temp   CombineHashCodes temp  GetHashCode enumerator Current                                    else                       temp   CombineHashCodes temp  EmptyCollectionPrimeNumber                      return temp           What Makes a Good Algorithm  Performance The algorithm that calculates a hash code needs to be fast  A simple algorithm is usually going to be a faster one  One that does not allocate extra memory will also reduce need for garbage collection  which will in turn also improve performance  Deterministic The hashing algorithm needs to be deterministic i e  given the same input it must always produce the same output  Reduce Collisions The algorithm that calculates a hash code needs to keep hash collisions to a minumum  A hash collision is a situation that occurs when two calls to GetHashCode on two different objects produce identical hash codes  Note that collisions are allowed  some have the misconceptions that they are not  but they should be kept to a minimum  A good hash function should map the expected inputs as evenly as possible over its output range  It should have uniformity  Prevent s DoS In  NET Core each time you restart an application you will get different hash codes  This is a security feature to prevent Denial of Service attacks  DoS   For  NET Framework you should enable this feature by adding the following App config file   lt  xml version   quot 1 0 quot   gt     lt configuration gt        lt runtime gt           lt UseRandomizedStringHashAlgorithm enabled  quot 1 quot    gt        lt  runtime gt     lt  configuration gt   Because of this feature  hash codes should never be used outside of the application domain in which they were created  they should never be used as key fields in a collection and they should never be persisted  Read more about this here  Cryptographically Secure  The algorithm does not have to be a Cryptographic hash function  Meaning it does not have to satisfy the following conditions   It is infeasible to generate a message that yields a given hash value It is infeasible to find two different messages with the same hash value A small change to a message should change the hash value so extensively that the new hash value appears uncorrelated with the old hash value  avalanche effect

User · Answer

Here is my simplistic approach  I am using the classic builder pattern for this  It is typesafe  no boxing unboxing  and also compatbile with  NET 2 0  no extension methods etc     It is used like this   public override int GetHashCode         HashBuilder b   new HashBuilder        b AddItems this member1  this member2  this member3       return b Result       And here is the acutal builder class   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 lt T gt  T item                unchecked                       this result   this result   Prime2   item GetHashCode                         public void AddItems lt T1  T2 gt  T1 item1  T2 item2                this AddItem item1           this AddItem item2              public void AddItems lt T1  T2  T3 gt  T1 item1  T2 item2  T3 item3                this AddItem item1           this AddItem item2           this AddItem item3              public void AddItems lt T1  T2  T3  T4 gt  T1 item1  T2 item2  T3 item3           T4 item4                this AddItem item1           this AddItem item2           this AddItem item3           this AddItem item4              public void AddItems lt T1  T2  T3  T4  T5 gt  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 lt T gt  params T   items                foreach  T item in items                        this AddItem item

User · Answer

Here s my helper class using Jon Skeet s implementation   public static class HashCode       public const int Start   17       public static int Hash lt T gt  this int hash  T obj                var h   EqualityComparer lt T gt  Default GetHashCode obj           return unchecked  hash   31    h             Usage   public override int GetHashCode         return HashCode Start          Hash  field1           Hash  field2           Hash  field3       If you want to avoid writing an extension method for System Int32   public readonly struct HashCode       private readonly int  value       public HashCode int value    gt   value   value       public static HashCode Start   get      new HashCode 17        public static implicit operator int HashCode hash    gt  hash  value       public HashCode Hash lt T gt  T obj                var h   EqualityComparer lt T gt  Default GetHashCode obj           return unchecked new HashCode   value   31    h               public override int GetHashCode     gt   value      It still avoids any heap allocation and is used exactly the same way   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       Edit  May 2018   EqualityComparer lt T gt  Default getter is now a JIT intrinsic - the pull request is mentioned by Stephen Toub in this blog post

User · Answer

NET Standard 2 1 And Above If you are using  NET Standard 2 1 or above  you can use the System HashCode struct  There are two methods of using it  HashCode Combine The Combine method can be used to create a hash code  given up to eight objects  public override int GetHashCode     gt  HashCode Combine this object1  this object2    HashCode Add The Add method helps you to deal with collections  public override int GetHashCode         var hashCode   new HashCode        hashCode Add this object1       foreach  var item in this collection                hashCode Add item             return hashCode ToHashCode       GetHashCode Made Easy You can read the full blog post  GetHashCode Made Easy  for more details and comments  Usage Example public class SuperHero       public int Age   get  set        public string Name   get  set        public List lt string gt  Powers   get  set         public override int GetHashCode     gt          HashCode Of this Name  And this Age  AndEach this Powers      Implementation public struct HashCode   IEquatable lt HashCode gt        private const int EmptyCollectionPrimeNumber   19      private readonly int value       private HashCode int value    gt  this value   value       public static implicit operator int HashCode hashCode    gt  hashCode value       public static bool operator    HashCode left  HashCode right    gt  left Equals right        public static bool operator    HashCode left  HashCode right    gt    left    right        public static HashCode Of lt T gt  T item    gt  new HashCode GetHashCode item         public static HashCode OfEach lt T gt  IEnumerable lt T gt  items    gt          items    null   new HashCode 0    new HashCode GetHashCode items  0         public HashCode And lt T gt  T item    gt           new HashCode CombineHashCodes this value  GetHashCode item          public HashCode AndEach lt T gt  IEnumerable lt T gt  items                if  items    null                        return new HashCode this value                      return new HashCode GetHashCode items  this value               public bool Equals HashCode other    gt  this value Equals other value        public override bool Equals object obj                if  obj is HashCode                        return this Equals  HashCode obj                      return false             public override int GetHashCode     gt  this value GetHashCode         private static int CombineHashCodes int h1  int h2                unchecked                          Code copied from System Tuple a good way to combine hashes              return   h1  lt  lt  5    h1    h2                       private static int GetHashCode lt T gt  T item    gt  item  GetHashCode      0       private static int GetHashCode lt T gt  IEnumerable lt T gt  items  int startHashCode                var temp   startHashCode           var enumerator   items GetEnumerator            if  enumerator MoveNext                          temp   CombineHashCodes temp  GetHashCode enumerator Current                 while  enumerator MoveNext                                  temp   CombineHashCodes temp  GetHashCode enumerator Current                                    else                       temp   CombineHashCodes temp  EmptyCollectionPrimeNumber                      return temp           What Makes a Good Algorithm  Performance The algorithm that calculates a hash code needs to be fast  A simple algorithm is usually going to be a faster one  One that does not allocate extra memory will also reduce need for garbage collection  which will in turn also improve performance  Deterministic The hashing algorithm needs to be deterministic i e  given the same input it must always produce the same output  Reduce Collisions The algorithm that calculates a hash code needs to keep hash collisions to a minumum  A hash collision is a situation that occurs when two calls to GetHashCode on two different objects produce identical hash codes  Note that collisions are allowed  some have the misconceptions that they are not  but they should be kept to a minimum  A good hash function should map the expected inputs as evenly as possible over its output range  It should have uniformity  Prevent s DoS In  NET Core each time you restart an application you will get different hash codes  This is a security feature to prevent Denial of Service attacks  DoS   For  NET Framework you should enable this feature by adding the following App config file   lt  xml version   quot 1 0 quot   gt     lt configuration gt        lt runtime gt           lt UseRandomizedStringHashAlgorithm enabled  quot 1 quot    gt        lt  runtime gt     lt  configuration gt   Because of this feature  hash codes should never be used outside of the application domain in which they were created  they should never be used as key fields in a collection and they should never be persisted  Read more about this here  Cryptographically Secure  The algorithm does not have to be a Cryptographic hash function  Meaning it does not have to satisfy the following conditions   It is infeasible to generate a message that yields a given hash value It is infeasible to find two different messages with the same hash value A small change to a message should change the hash value so extensively that the new hash value appears uncorrelated with the old hash value  avalanche effect

User · Answer

I usually go with something like the implementation given in Josh Bloch s fabulous Effective Java  It s fast and creates a pretty good hash which is unlikely to cause collisions  Pick two different prime numbers  e g  17 and 23  and do  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           As noted in comments  you may find it s better to pick a large prime to multiply by instead  Apparently 486187739 is good    and although most examples I ve seen with small numbers tend to use primes  there are at least similar algorithms where non-prime numbers are often used  In the not-quite-FNV example later  for example  I ve used numbers which apparently work well - but the initial value isn t a prime   The multiplication constant is prime though  I don t know quite how important that is   This is better than the common practice of XORing hashcodes for two main reasons  Suppose we have a type with two int fields  XorHash x  x     XorHash y  y     0 for all x  y XorHash x  y     XorHash y  x  for all x  y  By the way  the earlier algorithm is the one currently used by the C  compiler for anonymous types  This page gives quite a few options  I think for most cases the above is  quot good enough quot  and it s incredibly easy to remember and get right  The FNV alternative is similarly simple  but uses different constants and XOR instead of ADD as a combining operation  It looks something like the code below  but the normal FNV algorithm operates on individual bytes  so this would require modifying to perform one iteration per byte  instead of per 32-bit hash value  FNV is also designed for variable lengths of data  whereas the way we re using it here is always for the same number of field values  Comments on this answer suggest that the code here doesn t actually work as well  in the sample case tested  as the addition approach above     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           Note that one thing to be aware of is that ideally you should prevent your equality-sensitive  and thus hashcode-sensitive  state from changing after adding it to a collection that depends on the hash code  As per the documentation   You can override GetHashCode for immutable reference types  In general  for mutable reference types  you should override GetHashCode only if   You can compute the hash code from fields that are not mutable  or You can ensure that the hash code of a mutable object does not change while the object is contained in a collection that relies on its hash code    The link to the FNV article is broken but here is a copy in the Internet Archive  Eternally Confuzzled - The Art of Hashing

User · Answer

Here is my simplistic approach  I am using the classic builder pattern for this  It is typesafe  no boxing unboxing  and also compatbile with  NET 2 0  no extension methods etc     It is used like this   public override int GetHashCode         HashBuilder b   new HashBuilder        b AddItems this member1  this member2  this member3       return b Result       And here is the acutal builder class   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 lt T gt  T item                unchecked                       this result   this result   Prime2   item GetHashCode                         public void AddItems lt T1  T2 gt  T1 item1  T2 item2                this AddItem item1           this AddItem item2              public void AddItems lt T1  T2  T3 gt  T1 item1  T2 item2  T3 item3                this AddItem item1           this AddItem item2           this AddItem item3              public void AddItems lt T1  T2  T3  T4 gt  T1 item1  T2 item2  T3 item3           T4 item4                this AddItem item1           this AddItem item2           this AddItem item3           this AddItem item4              public void AddItems lt T1  T2  T3  T4  T5 gt  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 lt T gt  params T   items                foreach  T item in items                        this AddItem item

User · Answer

Here s my helper class using Jon Skeet s implementation   public static class HashCode       public const int Start   17       public static int Hash lt T gt  this int hash  T obj                var h   EqualityComparer lt T gt  Default GetHashCode obj           return unchecked  hash   31    h             Usage   public override int GetHashCode         return HashCode Start          Hash  field1           Hash  field2           Hash  field3       If you want to avoid writing an extension method for System Int32   public readonly struct HashCode       private readonly int  value       public HashCode int value    gt   value   value       public static HashCode Start   get      new HashCode 17        public static implicit operator int HashCode hash    gt  hash  value       public HashCode Hash lt T gt  T obj                var h   EqualityComparer lt T gt  Default GetHashCode obj           return unchecked new HashCode   value   31    h               public override int GetHashCode     gt   value      It still avoids any heap allocation and is used exactly the same way   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       Edit  May 2018   EqualityComparer lt T gt  Default getter is now a JIT intrinsic - the pull request is mentioned by Stephen Toub in this blog post

User · Answer

ReSharper users can generate GetHashCode  Equals  and others with ReSharper - gt  Edit - gt  Generate Code - gt  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

User · Answer

In most cases where Equals   compares multiple fields it doesn t really matter if your GetHash   hashes on one field or on many  You just have to make sure that calculating the hash is really cheap  No allocations  please  and fast  No heavy computations and certainly no database connections  and provides a good distribution   The heavy lifting should be part of the Equals   method  the hash should be a very cheap operation to enable calling Equals   on as few items as possible   And one final tip  Don t rely on GetHashCode   being stable over multiple aplication runs  Many  Net types don t guarantee their hash codes to stay the same after a restart  so you should only use the value of GetHashCode   for in memory data structures

User · Answer

I want to add my newest findings to this thread I came back to so often  My current visual studio   project setup provides the functionallity to automatically refactors tuples to structs  This will generate a GetHashCode function like so          public override int GetHashCode                         int hashCode   -2088324004              hashCode   hashCode   -1521134295   AuftragGesperrt GetHashCode                hashCode   hashCode   -1521134295   Auftrag gesperrt von GetHashCode                hashCode   hashCode   -1521134295   Auftrag gesperrt am GetHashCode                return hashCode

User · Answer

This is a static helper class that implements Josh Bloch s implementation  and provides explicit overloads to  prevent  boxing  and also to implement the hash specifically for the long primitives   You can pass a string comparison that matches your equals implementation   Because the Hash output is always an int  you can just chain Hash calls   using System  using System Collections  using System Collections Generic  using System Reflection  using System Runtime CompilerServices    namespace Sc Util System            lt summary gt          Static methods that allow easy implementation of hashCode  Example usage           lt code gt          public override int GetHashCode                 gt  HashCodeHelper Seed                  Hash primitiveField                   Hsh objectField                   Hash iEnumerableField            lt  code gt           lt  summary gt      public static class HashCodeHelper                    lt summary gt              An initial value for a hashCode  to which is added contributions from fields              Using a non-zero value decreases collisions of hashCode values               lt  summary gt          public const int Seed   23           private const int oddPrimeNumber   37                 lt summary gt              Rotates the seed against a prime number               lt  summary gt               lt param name  aSeed  gt The hash s first term  lt  param gt               lt returns gt The new hash code  lt  returns gt           MethodImpl MethodImplOptions AggressiveInlining           private static int rotateFirstTerm int aSeed                        unchecked                   return HashCodeHelper oddPrimeNumber   aSeed                                         lt summary gt              Contributes a boolean to the developing HashCode seed               lt  summary gt               lt param name  aSeed  gt The developing HashCode value or seed  lt  param gt               lt param name  aBoolean  gt The value to contribute  lt  param gt               lt returns gt The new hash code  lt  returns gt           MethodImpl MethodImplOptions AggressiveInlining           public static int Hash this int aSeed  bool aBoolean                        unchecked                   return HashCodeHelper rotateFirstTerm aSeed                             aBoolean                                   1                                   0                                         lt summary gt              Contributes a char to the developing HashCode seed               lt  summary gt               lt param name  aSeed  gt The developing HashCode value or seed  lt  param gt               lt param name  aChar  gt The value to contribute  lt  param gt               lt returns gt The new hash code  lt  returns gt           MethodImpl MethodImplOptions AggressiveInlining           public static int Hash this int aSeed  char aChar                        unchecked                   return HashCodeHelper rotateFirstTerm aSeed                            aChar                                        lt summary gt              Contributes an int to the developing HashCode seed              Note that byte and short are handled by this method  through implicit conversion               lt  summary gt               lt param name  aSeed  gt The developing HashCode value or seed  lt  param gt               lt param name  aInt  gt The value to contribute  lt  param gt               lt returns gt The new hash code  lt  returns gt           MethodImpl MethodImplOptions AggressiveInlining           public static int Hash this int aSeed  int aInt                        unchecked                   return HashCodeHelper rotateFirstTerm aSeed                            aInt                                        lt summary gt              Contributes a long to the developing HashCode seed               lt  summary gt               lt param name  aSeed  gt The developing HashCode value or seed  lt  param gt               lt param name  aLong  gt The value to contribute  lt  param gt               lt returns gt The new hash code  lt  returns gt           MethodImpl MethodImplOptions AggressiveInlining           public static int Hash this int aSeed  long aLong                        unchecked                   return HashCodeHelper rotateFirstTerm aSeed                             int  aLong    aLong  gt  gt  32                                          lt summary gt              Contributes a float to the developing HashCode seed               lt  summary gt               lt param name  aSeed  gt The developing HashCode value or seed  lt  param gt               lt param name  aFloat  gt The value to contribute  lt  param gt               lt returns gt The new hash code  lt  returns gt           MethodImpl MethodImplOptions AggressiveInlining           public static int Hash this int aSeed  float aFloat                        unchecked                   return HashCodeHelper rotateFirstTerm aSeed                            Convert ToInt32 aFloat                                         lt summary gt              Contributes a double to the developing HashCode seed               lt  summary gt               lt param name  aSeed  gt The developing HashCode value or seed  lt  param gt               lt param name  aDouble  gt The value to contribute  lt  param gt               lt returns gt The new hash code  lt  returns gt           MethodImpl MethodImplOptions AggressiveInlining           public static int Hash this int aSeed  double aDouble                gt  aSeed Hash Convert ToInt64 aDouble                  lt summary gt              Contributes a string to the developing HashCode seed               lt  summary gt               lt param name  aSeed  gt The developing HashCode value or seed  lt  param gt               lt param name  aString  gt The value to contribute  lt  param gt               lt param name  stringComparison  gt Optional comparison that creates the hash  lt  param gt               lt returns gt The new hash code  lt  returns gt           MethodImpl MethodImplOptions AggressiveInlining           public static int Hash                  this int aSeed                  string aString                  StringComparison stringComparison   StringComparison Ordinal                        if  aString    null                  return aSeed Hash 0               switch  stringComparison                    case StringComparison CurrentCulture                       return StringComparer CurrentCulture GetHashCode aString                   case StringComparison CurrentCultureIgnoreCase                       return StringComparer CurrentCultureIgnoreCase GetHashCode aString                   case StringComparison InvariantCulture                       return StringComparer InvariantCulture GetHashCode aString                   case StringComparison InvariantCultureIgnoreCase                       return StringComparer InvariantCultureIgnoreCase GetHashCode aString                   case StringComparison OrdinalIgnoreCase                       return StringComparer OrdinalIgnoreCase GetHashCode aString                   default                       return StringComparer Ordinal GetHashCode aString                                         lt summary gt              Contributes a possibly-null array to the developing HashCode seed              Each element may be a primitive  a reference  or a possibly-null array               lt  summary gt               lt param name  aSeed  gt The developing HashCode value or seed  lt  param gt               lt param name  aArray  gt CAN be null  lt  param gt               lt returns gt The new hash code  lt  returns gt           MethodImpl MethodImplOptions AggressiveInlining           public static int Hash this int aSeed  IEnumerable aArray                        if  aArray    null                  return aSeed Hash 0               int countPlusOne   1     So it differs from null             foreach  object item in aArray                      countPlusOne                  if  item is IEnumerable arrayItem                        if   object ReferenceEquals aArray  arrayItem                           aSeed   aSeed Hash arrayItem      recursive call                    else                     aSeed   aSeed Hash item                             return aSeed Hash countPlusOne                           lt summary gt              Contributes a possibly-null array to the developing HashCode seed              You must provide the hash function for each element               lt  summary gt               lt param name  aSeed  gt The developing HashCode value or seed  lt  param gt               lt param name  aArray  gt CAN be null  lt  param gt               lt param name  hashElement  gt Required  yields the hash for each element             in  lt paramref name  aArray   gt   lt  param gt               lt returns gt The new hash code  lt  returns gt           MethodImpl MethodImplOptions AggressiveInlining           public static int Hash lt T gt  this int aSeed  IEnumerable lt T gt  aArray  Func lt T  int gt  hashElement                        if  aArray    null                  return aSeed Hash 0               int countPlusOne   1     So it differs from null             foreach  T item in aArray                      countPlusOne                  aSeed   aSeed Hash hashElement item                              return aSeed Hash countPlusOne                           lt summary gt              Contributes a possibly-null object to the developing HashCode seed               lt  summary gt               lt param name  aSeed  gt The developing HashCode value or seed  lt  param gt               lt param name  aObject  gt CAN be null  lt  param gt               lt returns gt The new hash code  lt  returns gt           MethodImpl MethodImplOptions AggressiveInlining           public static int Hash this int aSeed  object aObject                        switch  aObject                    case null                       return aSeed Hash 0                   case bool b                       return aSeed Hash b                   case char c                       return aSeed Hash c                   case int i                       return aSeed Hash i                   case long l                       return aSeed Hash l                   case float f                       return aSeed Hash f                   case double d                       return aSeed Hash d                   case string s                       return aSeed Hash s                   case IEnumerable iEnumerable                       return aSeed Hash iEnumerable                             return aSeed Hash aObject GetHashCode                              lt summary gt              This utility method uses reflection to iterate all specified properties that are readable             on the given object  excluding any property names given in the params arguments  and             generates a hashcode               lt  summary gt               lt param name  aSeed  gt The developing hash code  or the seed  if you have no seed  use             the  lt see cref  Seed   gt   lt  param gt               lt param name  aObject  gt CAN be null  lt  param gt               lt param name  propertySelector  gt  lt see cref  BindingFlags   gt  to select the properties to hash  lt  param gt               lt param name  ignorePropertyNames  gt Optional  lt  param gt               lt returns gt A hash from the properties contributed to  lt c gt aSeed lt  c gt   lt  returns gt           MethodImpl MethodImplOptions AggressiveInlining           public static int HashAllProperties                  this int aSeed                  object aObject                  BindingFlags propertySelector                           BindingFlags Instance                           BindingFlags Public                           BindingFlags GetProperty                  params string   ignorePropertyNames                        if  aObject    null                  return aSeed Hash 0               if   ignorePropertyNames    null                       amp  amp   ignorePropertyNames Length    0                     foreach  PropertyInfo propertyInfo in aObject GetType                            GetProperties propertySelector                         if   propertyInfo CanRead                                 Array IndexOf ignorePropertyNames  propertyInfo Name   gt   0                           continue                      aSeed   aSeed Hash propertyInfo GetValue aObject                                    else                   foreach  PropertyInfo propertyInfo in aObject GetType                            GetProperties propertySelector                         if  propertyInfo CanRead                          aSeed   aSeed Hash propertyInfo GetValue aObject                                                return aSeed                           lt summary gt              NOTICE  this method is provided to contribute a  lt see cref  KeyValuePair TKey TValue    gt  to             the developing HashCode seed  by hashing the key and the value independently  HOWEVER              this method has a different name since it will not be automatically invoked by              lt see cref  Hash int object    gt    lt see cref  Hash int IEnumerable    gt               or  lt see cref  HashAllProperties   gt  --- you MUST NOT mix this method with those unless             you are sure that no KeyValuePair instances will be passed to those methods  or otherwise             the generated hash code will not be consistent  This method itself ALSO will not invoke             this method on the Key or Value here if that itself is a KeyValuePair               lt  summary gt               lt param name  aSeed  gt The developing HashCode value or seed  lt  param gt               lt param name  keyValuePair  gt The value to contribute  lt  param gt               lt returns gt The new hash code  lt  returns gt           MethodImpl MethodImplOptions AggressiveInlining           public static int HashKeyAndValue lt TKey  TValue gt  this int aSeed  KeyValuePair lt TKey  TValue gt  keyValuePair                gt  aSeed Hash keyValuePair Key                       Hash keyValuePair Value                 lt summary gt              NOTICE  this method is provided to contribute a collection of  lt see cref  KeyValuePair TKey TValue    gt              to the developing HashCode seed  by hashing the key and the value independently  HOWEVER              this method has a different name since it will not be automatically invoked by              lt see cref  Hash int object    gt    lt see cref  Hash int IEnumerable    gt               or  lt see cref  HashAllProperties   gt  --- you MUST NOT mix this method with those unless             you are sure that no KeyValuePair instances will be passed to those methods  or otherwise             the generated hash code will not be consistent  This method itself ALSO will not invoke             this method on a Key or Value here if that itself is a KeyValuePair or an Enumerable of             KeyValuePair               lt  summary gt               lt param name  aSeed  gt The developing HashCode value or seed  lt  param gt               lt param name  keyValuePairs  gt The values to contribute  lt  param gt               lt returns gt The new hash code  lt  returns gt           MethodImpl MethodImplOptions AggressiveInlining           public static int HashKeysAndValues lt TKey  TValue gt                   this int aSeed                  IEnumerable lt KeyValuePair lt TKey  TValue gt  gt  keyValuePairs                        if  keyValuePairs    null                  return aSeed Hash null               foreach  KeyValuePair lt TKey  TValue gt  keyValuePair in keyValuePairs                    aSeed   aSeed HashKeyAndValue keyValuePair                             return aSeed

User · Answer

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

User · Answer

Can try to adopt approach from C   Boost libraries  Something like this  class HashUtil     public static int HashCombine int seed  int other          unchecked             return other   0x9e3779b9    seed  lt  lt  6     seed  gt  gt  2                and then  class MyClass     private string  field1    private int  field2    private AnotherClass  field3    private YetAnotherClass  field4     public override int GetHashCode           int result   HashUtil HashCombine  field1 GetHashCode     field2       result   HashUtil HashCombine result   field3 GetHashCode         return HashUtil HashCombine result   field4 GetHashCode

User · Answer

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(); }
    }
}

Usage:

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.

User · Answer

I usually go with something like the implementation given in Josh Bloch s fabulous Effective Java  It s fast and creates a pretty good hash which is unlikely to cause collisions  Pick two different prime numbers  e g  17 and 23  and do  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           As noted in comments  you may find it s better to pick a large prime to multiply by instead  Apparently 486187739 is good    and although most examples I ve seen with small numbers tend to use primes  there are at least similar algorithms where non-prime numbers are often used  In the not-quite-FNV example later  for example  I ve used numbers which apparently work well - but the initial value isn t a prime   The multiplication constant is prime though  I don t know quite how important that is   This is better than the common practice of XORing hashcodes for two main reasons  Suppose we have a type with two int fields  XorHash x  x     XorHash y  y     0 for all x  y XorHash x  y     XorHash y  x  for all x  y  By the way  the earlier algorithm is the one currently used by the C  compiler for anonymous types  This page gives quite a few options  I think for most cases the above is  quot good enough quot  and it s incredibly easy to remember and get right  The FNV alternative is similarly simple  but uses different constants and XOR instead of ADD as a combining operation  It looks something like the code below  but the normal FNV algorithm operates on individual bytes  so this would require modifying to perform one iteration per byte  instead of per 32-bit hash value  FNV is also designed for variable lengths of data  whereas the way we re using it here is always for the same number of field values  Comments on this answer suggest that the code here doesn t actually work as well  in the sample case tested  as the addition approach above     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           Note that one thing to be aware of is that ideally you should prevent your equality-sensitive  and thus hashcode-sensitive  state from changing after adding it to a collection that depends on the hash code  As per the documentation   You can override GetHashCode for immutable reference types  In general  for mutable reference types  you should override GetHashCode only if   You can compute the hash code from fields that are not mutable  or You can ensure that the hash code of a mutable object does not change while the object is contained in a collection that relies on its hash code    The link to the FNV article is broken but here is a copy in the Internet Archive  Eternally Confuzzled - The Art of Hashing

User · Answer

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

User · Answer

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

User · Answer

ValueTuple - Update for C  7 As  cactuaroid mentions in the comments  a value tuple can be used  This saves a few keystrokes and more importantly executes purely on the stack  no Garbage    PropA  PropB  PropC  PropD  GetHashCode      Note  The original technique using anonymous types seems to create an object on the heap  i e  garbage  since anonymous types are implemented as classes  though this might be optimized out by the compiler  It would be interesting to benchmark these options  but the tuple option should be superior   Anonymous Type  Original Answer  Microsoft already provides a good generic HashCode generator  Just copy your property field values to an anonymous type and hash it  new   PropA  PropB  PropC  PropD   GetHashCode     This will work for any number of properties  It does not use boxing  It just uses the algorithm already implemented in the framework for anonymous types

User · Answer

As of https   github com dotnet coreclr pull 14863  there is a new way to generate hash codes that is super simple  Just write  public override int GetHashCode         gt  HashCode Combine field1  field2  field3     This will generate a quality hash code without you having to worry about the implementation details

User · Answer

ReSharper users can generate GetHashCode  Equals  and others with ReSharper - gt  Edit - gt  Generate Code - gt  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

User · Answer

I have a Hashing class in Helper library that I use it for this purpose        lt summary gt       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      lt  summary gt       lt param name  input  gt array of objects  parameters combination that you need     to get a unique hash code for them lt  param gt       lt returns gt Hash code lt  returns gt  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  lt  input Length  i                          if  input i     null                                hash   hash   a   input i  GetHashCode                    a   a   b                                     return hash      Then  simply you can use it as   public override int GetHashCode         return Hashing RSHash  field1   field2   field3       I didn t assess its performance  so any feedback is welcomed

User · Answer

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

User · Answer

Microsoft lead for several way of hashing       for classes that contain a single int value return this value     for classes that contain multiple int value return x   y     for classes that contain single number bigger than int     return   int value    int  value  gt  gt  32        for classes that contain class instance fields which inherit from object return obj1 GetHashCode       for classes that contain multiple class instance fields which inherit from object return obj1 GetHashCode     obj2 GetHashCode     obj3 GetHashCode       I can guess that for multiple big int you can use this   int a   int value1    int  value1  gt  gt  32    int b   int value2    int  value2  gt  gt  32    int c   int value3    int  value3  gt  gt  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 your hash   For those who use hash as ID  I mean an unique value   hash is naturally limited to a number of digits  I think it was 5 bytes for hashing algorithm  at least MD5   You may turn multiple values to a hashed value and some of them be same  so don t use it as an identifier   maybe some day I am going to use your component

User · Answer

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        lt summary gt      Try not to look at the source code  It works  Just rely on it       lt  summary gt  public static class HashHelper       private const int PrimeOne   17      private const int PrimeTwo   23       public static int GetHashCode lt T1  T2  T3  T4  T5  T6  T7  T8  T9  T10 gt  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 lt T1  T2  T3  T4  T5  T6  T7  T8  T9 gt  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 lt T1  T2  T3  T4  T5  T6  T7  T8 gt  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 lt T1  T2  T3  T4  T5  T6  T7 gt  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 lt T1  T2  T3  T4  T5  T6 gt  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 lt T1  T2  T3  T4  T5 gt  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 lt T1  T2  T3  T4 gt  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 lt T1  T2  T3 gt  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 lt T1  T2 gt  T1 arg1  T2 arg2                unchecked                       int hash   PrimeOne              hash   hash   PrimeTwo   arg1 GetHashCode                hash   hash   PrimeTwo   arg2 GetHashCode                 return hash

User · Answer

This is a static helper class that implements Josh Bloch s implementation  and provides explicit overloads to  prevent  boxing  and also to implement the hash specifically for the long primitives   You can pass a string comparison that matches your equals implementation   Because the Hash output is always an int  you can just chain Hash calls   using System  using System Collections  using System Collections Generic  using System Reflection  using System Runtime CompilerServices    namespace Sc Util System            lt summary gt          Static methods that allow easy implementation of hashCode  Example usage           lt code gt          public override int GetHashCode                 gt  HashCodeHelper Seed                  Hash primitiveField                   Hsh objectField                   Hash iEnumerableField            lt  code gt           lt  summary gt      public static class HashCodeHelper                    lt summary gt              An initial value for a hashCode  to which is added contributions from fields              Using a non-zero value decreases collisions of hashCode values               lt  summary gt          public const int Seed   23           private const int oddPrimeNumber   37                 lt summary gt              Rotates the seed against a prime number               lt  summary gt               lt param name  aSeed  gt The hash s first term  lt  param gt               lt returns gt The new hash code  lt  returns gt           MethodImpl MethodImplOptions AggressiveInlining           private static int rotateFirstTerm int aSeed                        unchecked                   return HashCodeHelper oddPrimeNumber   aSeed                                         lt summary gt              Contributes a boolean to the developing HashCode seed               lt  summary gt               lt param name  aSeed  gt The developing HashCode value or seed  lt  param gt               lt param name  aBoolean  gt The value to contribute  lt  param gt               lt returns gt The new hash code  lt  returns gt           MethodImpl MethodImplOptions AggressiveInlining           public static int Hash this int aSeed  bool aBoolean                        unchecked                   return HashCodeHelper rotateFirstTerm aSeed                             aBoolean                                   1                                   0                                         lt summary gt              Contributes a char to the developing HashCode seed               lt  summary gt               lt param name  aSeed  gt The developing HashCode value or seed  lt  param gt               lt param name  aChar  gt The value to contribute  lt  param gt               lt returns gt The new hash code  lt  returns gt           MethodImpl MethodImplOptions AggressiveInlining           public static int Hash this int aSeed  char aChar                        unchecked                   return HashCodeHelper rotateFirstTerm aSeed                            aChar                                        lt summary gt              Contributes an int to the developing HashCode seed              Note that byte and short are handled by this method  through implicit conversion               lt  summary gt               lt param name  aSeed  gt The developing HashCode value or seed  lt  param gt               lt param name  aInt  gt The value to contribute  lt  param gt               lt returns gt The new hash code  lt  returns gt           MethodImpl MethodImplOptions AggressiveInlining           public static int Hash this int aSeed  int aInt                        unchecked                   return HashCodeHelper rotateFirstTerm aSeed                            aInt                                        lt summary gt              Contributes a long to the developing HashCode seed               lt  summary gt               lt param name  aSeed  gt The developing HashCode value or seed  lt  param gt               lt param name  aLong  gt The value to contribute  lt  param gt               lt returns gt The new hash code  lt  returns gt           MethodImpl MethodImplOptions AggressiveInlining           public static int Hash this int aSeed  long aLong                        unchecked                   return HashCodeHelper rotateFirstTerm aSeed                             int  aLong    aLong  gt  gt  32                                          lt summary gt              Contributes a float to the developing HashCode seed               lt  summary gt               lt param name  aSeed  gt The developing HashCode value or seed  lt  param gt               lt param name  aFloat  gt The value to contribute  lt  param gt               lt returns gt The new hash code  lt  returns gt           MethodImpl MethodImplOptions AggressiveInlining           public static int Hash this int aSeed  float aFloat                        unchecked                   return HashCodeHelper rotateFirstTerm aSeed                            Convert ToInt32 aFloat                                         lt summary gt              Contributes a double to the developing HashCode seed               lt  summary gt               lt param name  aSeed  gt The developing HashCode value or seed  lt  param gt               lt param name  aDouble  gt The value to contribute  lt  param gt               lt returns gt The new hash code  lt  returns gt           MethodImpl MethodImplOptions AggressiveInlining           public static int Hash this int aSeed  double aDouble                gt  aSeed Hash Convert ToInt64 aDouble                  lt summary gt              Contributes a string to the developing HashCode seed               lt  summary gt               lt param name  aSeed  gt The developing HashCode value or seed  lt  param gt               lt param name  aString  gt The value to contribute  lt  param gt               lt param name  stringComparison  gt Optional comparison that creates the hash  lt  param gt               lt returns gt The new hash code  lt  returns gt           MethodImpl MethodImplOptions AggressiveInlining           public static int Hash                  this int aSeed                  string aString                  StringComparison stringComparison   StringComparison Ordinal                        if  aString    null                  return aSeed Hash 0               switch  stringComparison                    case StringComparison CurrentCulture                       return StringComparer CurrentCulture GetHashCode aString                   case StringComparison CurrentCultureIgnoreCase                       return StringComparer CurrentCultureIgnoreCase GetHashCode aString                   case StringComparison InvariantCulture                       return StringComparer InvariantCulture GetHashCode aString                   case StringComparison InvariantCultureIgnoreCase                       return StringComparer InvariantCultureIgnoreCase GetHashCode aString                   case StringComparison OrdinalIgnoreCase                       return StringComparer OrdinalIgnoreCase GetHashCode aString                   default                       return StringComparer Ordinal GetHashCode aString                                         lt summary gt              Contributes a possibly-null array to the developing HashCode seed              Each element may be a primitive  a reference  or a possibly-null array               lt  summary gt               lt param name  aSeed  gt The developing HashCode value or seed  lt  param gt               lt param name  aArray  gt CAN be null  lt  param gt               lt returns gt The new hash code  lt  returns gt           MethodImpl MethodImplOptions AggressiveInlining           public static int Hash this int aSeed  IEnumerable aArray                        if  aArray    null                  return aSeed Hash 0               int countPlusOne   1     So it differs from null             foreach  object item in aArray                      countPlusOne                  if  item is IEnumerable arrayItem                        if   object ReferenceEquals aArray  arrayItem                           aSeed   aSeed Hash arrayItem      recursive call                    else                     aSeed   aSeed Hash item                             return aSeed Hash countPlusOne                           lt summary gt              Contributes a possibly-null array to the developing HashCode seed              You must provide the hash function for each element               lt  summary gt               lt param name  aSeed  gt The developing HashCode value or seed  lt  param gt               lt param name  aArray  gt CAN be null  lt  param gt               lt param name  hashElement  gt Required  yields the hash for each element             in  lt paramref name  aArray   gt   lt  param gt               lt returns gt The new hash code  lt  returns gt           MethodImpl MethodImplOptions AggressiveInlining           public static int Hash lt T gt  this int aSeed  IEnumerable lt T gt  aArray  Func lt T  int gt  hashElement                        if  aArray    null                  return aSeed Hash 0               int countPlusOne   1     So it differs from null             foreach  T item in aArray                      countPlusOne                  aSeed   aSeed Hash hashElement item                              return aSeed Hash countPlusOne                           lt summary gt              Contributes a possibly-null object to the developing HashCode seed               lt  summary gt               lt param name  aSeed  gt The developing HashCode value or seed  lt  param gt               lt param name  aObject  gt CAN be null  lt  param gt               lt returns gt The new hash code  lt  returns gt           MethodImpl MethodImplOptions AggressiveInlining           public static int Hash this int aSeed  object aObject                        switch  aObject                    case null                       return aSeed Hash 0                   case bool b                       return aSeed Hash b                   case char c                       return aSeed Hash c                   case int i                       return aSeed Hash i                   case long l                       return aSeed Hash l                   case float f                       return aSeed Hash f                   case double d                       return aSeed Hash d                   case string s                       return aSeed Hash s                   case IEnumerable iEnumerable                       return aSeed Hash iEnumerable                             return aSeed Hash aObject GetHashCode                              lt summary gt              This utility method uses reflection to iterate all specified properties that are readable             on the given object  excluding any property names given in the params arguments  and             generates a hashcode               lt  summary gt               lt param name  aSeed  gt The developing hash code  or the seed  if you have no seed  use             the  lt see cref  Seed   gt   lt  param gt               lt param name  aObject  gt CAN be null  lt  param gt               lt param name  propertySelector  gt  lt see cref  BindingFlags   gt  to select the properties to hash  lt  param gt               lt param name  ignorePropertyNames  gt Optional  lt  param gt               lt returns gt A hash from the properties contributed to  lt c gt aSeed lt  c gt   lt  returns gt           MethodImpl MethodImplOptions AggressiveInlining           public static int HashAllProperties                  this int aSeed                  object aObject                  BindingFlags propertySelector                           BindingFlags Instance                           BindingFlags Public                           BindingFlags GetProperty                  params string   ignorePropertyNames                        if  aObject    null                  return aSeed Hash 0               if   ignorePropertyNames    null                       amp  amp   ignorePropertyNames Length    0                     foreach  PropertyInfo propertyInfo in aObject GetType                            GetProperties propertySelector                         if   propertyInfo CanRead                                 Array IndexOf ignorePropertyNames  propertyInfo Name   gt   0                           continue                      aSeed   aSeed Hash propertyInfo GetValue aObject                                    else                   foreach  PropertyInfo propertyInfo in aObject GetType                            GetProperties propertySelector                         if  propertyInfo CanRead                          aSeed   aSeed Hash propertyInfo GetValue aObject                                                return aSeed                           lt summary gt              NOTICE  this method is provided to contribute a  lt see cref  KeyValuePair TKey TValue    gt  to             the developing HashCode seed  by hashing the key and the value independently  HOWEVER              this method has a different name since it will not be automatically invoked by              lt see cref  Hash int object    gt    lt see cref  Hash int IEnumerable    gt               or  lt see cref  HashAllProperties   gt  --- you MUST NOT mix this method with those unless             you are sure that no KeyValuePair instances will be passed to those methods  or otherwise             the generated hash code will not be consistent  This method itself ALSO will not invoke             this method on the Key or Value here if that itself is a KeyValuePair               lt  summary gt               lt param name  aSeed  gt The developing HashCode value or seed  lt  param gt               lt param name  keyValuePair  gt The value to contribute  lt  param gt               lt returns gt The new hash code  lt  returns gt           MethodImpl MethodImplOptions AggressiveInlining           public static int HashKeyAndValue lt TKey  TValue gt  this int aSeed  KeyValuePair lt TKey  TValue gt  keyValuePair                gt  aSeed Hash keyValuePair Key                       Hash keyValuePair Value                 lt summary gt              NOTICE  this method is provided to contribute a collection of  lt see cref  KeyValuePair TKey TValue    gt              to the developing HashCode seed  by hashing the key and the value independently  HOWEVER              this method has a different name since it will not be automatically invoked by              lt see cref  Hash int object    gt    lt see cref  Hash int IEnumerable    gt               or  lt see cref  HashAllProperties   gt  --- you MUST NOT mix this method with those unless             you are sure that no KeyValuePair instances will be passed to those methods  or otherwise             the generated hash code will not be consistent  This method itself ALSO will not invoke             this method on a Key or Value here if that itself is a KeyValuePair or an Enumerable of             KeyValuePair               lt  summary gt               lt param name  aSeed  gt The developing HashCode value or seed  lt  param gt               lt param name  keyValuePairs  gt The values to contribute  lt  param gt               lt returns gt The new hash code  lt  returns gt           MethodImpl MethodImplOptions AggressiveInlining           public static int HashKeysAndValues lt TKey  TValue gt                   this int aSeed                  IEnumerable lt KeyValuePair lt TKey  TValue gt  gt  keyValuePairs                        if  keyValuePairs    null                  return aSeed Hash null               foreach  KeyValuePair lt TKey  TValue gt  keyValuePair in keyValuePairs                    aSeed   aSeed HashKeyAndValue keyValuePair                             return aSeed

User · Answer

Here is my hashcode helper  It s advantage is that it uses generic type arguments and therefore will not cause boxing   public static class HashHelper       public static int GetHashCode lt T1  T2 gt  T1 arg1  T2 arg2                 unchecked                         return 31   arg1 GetHashCode     arg2 GetHashCode                          public static int GetHashCode lt T1  T2  T3 gt  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 lt T1  T2  T3  T4 gt  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 lt T gt  T   list                unchecked                       int hash   0              foreach  var item in list                                hash   31   hash   item GetHashCode                              return hash                       public static int GetHashCode lt T gt  IEnumerable lt T gt  list                unchecked                       int hash   0              foreach  var item in list                                hash   31   hash   item GetHashCode                              return hash                            lt summary gt          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           lt  summary gt      public static int GetHashCodeForOrderNoMatterCollection lt T gt           IEnumerable lt T gt  list                unchecked                       int hash   0              int count   0              foreach  var item in list                                hash    item GetHashCode                    count                              return 31   hash   count GetHashCode                              lt summary gt          Alternative way to get a hashcode is to use a fluent          interface like this  lt br   gt          return 0 CombineHashCode field1  CombineHashCode field2               CombineHashCode field3            lt  summary gt      public static int CombineHashCode lt T gt  this int hashCode  T arg                unchecked                       return 31   hashCode   arg GetHashCode                         Also it has extension method to provide a fluent interface  so you can use it like this   public override int GetHashCode         return HashHelper GetHashCode Manufacturer  PartN  Quantity       or like this     public override int GetHashCode         return 0 CombineHashCode Manufacturer           CombineHashCode PartN           CombineHashCode Quantity

User · Answer

As of https   github com dotnet coreclr pull 14863  there is a new way to generate hash codes that is super simple  Just write  public override int GetHashCode         gt  HashCode Combine field1  field2  field3     This will generate a quality hash code without you having to worry about the implementation details

User · Answer

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        lt summary gt      Try not to look at the source code  It works  Just rely on it       lt  summary gt  public static class HashHelper       private const int PrimeOne   17      private const int PrimeTwo   23       public static int GetHashCode lt T1  T2  T3  T4  T5  T6  T7  T8  T9  T10 gt  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 lt T1  T2  T3  T4  T5  T6  T7  T8  T9 gt  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 lt T1  T2  T3  T4  T5  T6  T7  T8 gt  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 lt T1  T2  T3  T4  T5  T6  T7 gt  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 lt T1  T2  T3  T4  T5  T6 gt  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 lt T1  T2  T3  T4  T5 gt  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 lt T1  T2  T3  T4 gt  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 lt T1  T2  T3 gt  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 lt T1  T2 gt  T1 arg1  T2 arg2                unchecked                       int hash   PrimeOne              hash   hash   PrimeTwo   arg1 GetHashCode                hash   hash   PrimeTwo   arg2 GetHashCode                 return hash

User · Answer

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  lt  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

User · Answer

I usually go with something like the implementation given in Josh Bloch s fabulous Effective Java  It s fast and creates a pretty good hash which is unlikely to cause collisions  Pick two different prime numbers  e g  17 and 23  and do  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           As noted in comments  you may find it s better to pick a large prime to multiply by instead  Apparently 486187739 is good    and although most examples I ve seen with small numbers tend to use primes  there are at least similar algorithms where non-prime numbers are often used  In the not-quite-FNV example later  for example  I ve used numbers which apparently work well - but the initial value isn t a prime   The multiplication constant is prime though  I don t know quite how important that is   This is better than the common practice of XORing hashcodes for two main reasons  Suppose we have a type with two int fields  XorHash x  x     XorHash y  y     0 for all x  y XorHash x  y     XorHash y  x  for all x  y  By the way  the earlier algorithm is the one currently used by the C  compiler for anonymous types  This page gives quite a few options  I think for most cases the above is  quot good enough quot  and it s incredibly easy to remember and get right  The FNV alternative is similarly simple  but uses different constants and XOR instead of ADD as a combining operation  It looks something like the code below  but the normal FNV algorithm operates on individual bytes  so this would require modifying to perform one iteration per byte  instead of per 32-bit hash value  FNV is also designed for variable lengths of data  whereas the way we re using it here is always for the same number of field values  Comments on this answer suggest that the code here doesn t actually work as well  in the sample case tested  as the addition approach above     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           Note that one thing to be aware of is that ideally you should prevent your equality-sensitive  and thus hashcode-sensitive  state from changing after adding it to a collection that depends on the hash code  As per the documentation   You can override GetHashCode for immutable reference types  In general  for mutable reference types  you should override GetHashCode only if   You can compute the hash code from fields that are not mutable  or You can ensure that the hash code of a mutable object does not change while the object is contained in a collection that relies on its hash code    The link to the FNV article is broken but here is a copy in the Internet Archive  Eternally Confuzzled - The Art of Hashing

User · Answer

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  lt  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

User · Answer

If we have no more than 8 properties  hopefully   here is another alternative   ValueTuple is a struct and appears to have a solid GetHashCode implementation   That means we could simply do this      Yay  no allocations and no custom implementations  public override int GetHashCode     gt   this PropA  this PropB  GetHashCode      Let s take a look at  NET Core s current implementation for ValueTuple s GetHashCode   This is from ValueTuple       internal static int CombineHashCodes int h1  int h2                return HashHelpers Combine HashHelpers Combine HashHelpers RandomSeed  h1   h2              internal static int CombineHashCodes int h1  int h2  int h3                return HashHelpers Combine CombineHashCodes h1  h2   h3           And this is from HashHelper       public static readonly int RandomSeed   Guid NewGuid   GetHashCode         public static int Combine int h1  int h2                unchecked                          RyuJIT optimizes this to use the ROL instruction                Related GitHub pull request  dotnet coreclr 1830             uint rol5     uint h1  lt  lt  5      uint h1  gt  gt  27               return   int rol5   h1    h2                    In English    Left rotate  circular shift  h1 by 5 positions  Add the result and h1 together  XOR the result with h2  Start by performing the above operation on   static random seed  h1    For each further item  perform the operation on the previous result and the next item  e g  h2     It would be nice to know more about the properties of this ROL-5 hash code algorithm   Regrettably  deferring to ValueTuple for our own GetHashCode may not be as fast as we would like and expect  This comment in a related discussion illustrates that directly calling HashHelpers Combine is more performant  On the flip side  that one is internal  so we d have to copy the code  sacrificing much of what we had gained here  Also  we d be responsible for remembering to first Combine with the random seed  I don t know what the consequences are if we skip that step

User · Answer

Up until recently my answer would have been very close to Jon Skeet s here  However  I recently started a project which used power-of-two hash tables  that is hash tables where the size of the internal table is 8  16  32  etc  There s a good reason for favouring prime-number sizes  but there are some advantages to power-of-two sizes too   And it pretty much sucked  So after a bit of experimentation and research I started re-hashing my hashes with the following   public static int ReHash int source      unchecked         ulong c   0xDEADBEEFDEADBEEF    ulong source      ulong d   0xE2ADBEEFDEADBEEF   c      ulong a   d    c   c  lt  lt  15   c  gt  gt  -15      ulong b   a    d   d  lt  lt  52   d  gt  gt  -52      c    b    a   a  lt  lt  26   a  gt  gt  -26      d    c    b   b  lt  lt  51   b  gt  gt  -51      a    d    c   c  lt  lt  28   c  gt  gt  -28      b    a    d   d  lt  lt  9   d  gt  gt  -9      c    b    a   a  lt  lt  47   a  gt  gt  -47      d    c    b  lt  lt  54   b  gt  gt  -54      a    d    c  lt  lt  32   c  gt  gt  32      a    d  lt  lt  25   d  gt  gt  -25      return  int  a  gt  gt  1           And then my power-of-two hash table didn t suck any more   This disturbed me though  because the above shouldn t work  Or more precisely  it shouldn t work unless the original GetHashCode   was poor in a very particular way   Re-mixing a hashcode can t improve a great hashcode  because the only possible effect is that we introduce a few more collisions   Re-mixing a hash code can t improve a terrible hash code  because the only possible effect is we change e g  a large number of collisions on value 53 to a large number of value 18 3487 291   Re-mixing a hash code can only improve a hash code that did at least fairly well in avoiding absolute collisions throughout its range  232 possible values  but badly at avoiding collisions when modulo d down for actual use in a hash table  While the simpler modulo of a power-of-two table made this more apparent  it was also having a negative effect with the more common prime-number tables  that just wasn t as obvious  the extra work in rehashing would outweigh the benefit  but the benefit would still be there    Edit  I was also using open-addressing  which would also have increased the sensitivity to collision  perhaps more so than the fact it was power-of-two   And well  it was disturbing how much the string GetHashCode   implementations in  NET  or study here  could be improved this way  on the order of tests running about 20-30 times faster due to fewer collisions  and more disturbing how much my own hash codes could be improved  much more than that    All the GetHashCode   implementations I d coded in the past  and indeed used as the basis of answers on this site  were much worse than I d throught  Much of the time it was  good enough  for much of the uses  but I wanted something better   So I put that project to one side  it was a pet project anyway  and started looking at how to produce a good  well-distributed hash code in  NET quickly   In the end I settled on porting SpookyHash to  NET  Indeed the code above is a fast-path version of using SpookyHash to produce a 32-bit output from a 32-bit input   Now  SpookyHash is not a nice quick to remember piece of code  My port of it is even less so because I hand-inlined a lot of it for better speed   But that s what code reuse is for   Then I put that project to one side  because just as the original project had produced the question of how to produce a better hash code  so that project produced the question of how to produce a better  NET memcpy   Then I came back  and produced a lot of overloads to easily feed just about all of the native types  except decimal     into a hash code   It s fast  for which Bob Jenkins deserves most of the credit because his original code I ported from is faster still  especially on 64-bit machines which the algorithm is optimised for      The full code can be seen at https   bitbucket org JonHanna spookilysharp src but consider that the code above is a simplified version of it   However  since it s now already written  one can make use of it more easily   public override int GetHashCode       var hash   new SpookyHash      hash Update field1     hash Update field2     hash Update field3     return hash Final   GetHashCode        It also takes seed values  so if you need to deal with untrusted input and want to protect against Hash DoS attacks you can set a seed based on uptime or similar  and make the results unpredictable by attackers   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         A big surprise in this is that hand-inlining a rotation method that returned  x  lt  lt  n     x  gt  gt  -n  improved things  I would have been sure that the jitter would have inlined that for me  but profiling showed otherwise      decimal isn t native from the  NET perspective though it is from the C   The problem with it is that its own GetHashCode   treats precision as significant while its own Equals   does not  Both are valid choices  but not mixed like that  In implementing your own version  you need to choose to do one  or the other  but I can t know which you d want      By way of comparison  If used on a string  the SpookyHash on 64 bits is considerably faster than string GetHashCode   on 32 bits which is slightly faster than string GetHashCode   on 64 bits  which is considerably faster than SpookyHash on 32 bits  though still fast enough to be a reasonable choice

User · Answer

Can try to adopt approach from C   Boost libraries  Something like this  class HashUtil     public static int HashCombine int seed  int other          unchecked             return other   0x9e3779b9    seed  lt  lt  6     seed  gt  gt  2                and then  class MyClass     private string  field1    private int  field2    private AnotherClass  field3    private YetAnotherClass  field4     public override int GetHashCode           int result   HashUtil HashCombine  field1 GetHashCode     field2       result   HashUtil HashCombine result   field3 GetHashCode         return HashUtil HashCombine result   field4 GetHashCode

User · Answer

I have a Hashing class in Helper library that I use it for this purpose        lt summary gt       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      lt  summary gt       lt param name  input  gt array of objects  parameters combination that you need     to get a unique hash code for them lt  param gt       lt returns gt Hash code lt  returns gt  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  lt  input Length  i                          if  input i     null                                hash   hash   a   input i  GetHashCode                    a   a   b                                     return hash      Then  simply you can use it as   public override int GetHashCode         return Hashing RSHash  field1   field2   field3       I didn t assess its performance  so any feedback is welcomed

User · Answer

I want to add my newest findings to this thread I came back to so often  My current visual studio   project setup provides the functionallity to automatically refactors tuples to structs  This will generate a GetHashCode function like so          public override int GetHashCode                         int hashCode   -2088324004              hashCode   hashCode   -1521134295   AuftragGesperrt GetHashCode                hashCode   hashCode   -1521134295   Auftrag gesperrt von GetHashCode                hashCode   hashCode   -1521134295   Auftrag gesperrt am GetHashCode                return hashCode

User · Answer

Here is my hashcode helper  It s advantage is that it uses generic type arguments and therefore will not cause boxing   public static class HashHelper       public static int GetHashCode lt T1  T2 gt  T1 arg1  T2 arg2                 unchecked                         return 31   arg1 GetHashCode     arg2 GetHashCode                          public static int GetHashCode lt T1  T2  T3 gt  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 lt T1  T2  T3  T4 gt  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 lt T gt  T   list                unchecked                       int hash   0              foreach  var item in list                                hash   31   hash   item GetHashCode                              return hash                       public static int GetHashCode lt T gt  IEnumerable lt T gt  list                unchecked                       int hash   0              foreach  var item in list                                hash   31   hash   item GetHashCode                              return hash                            lt summary gt          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           lt  summary gt      public static int GetHashCodeForOrderNoMatterCollection lt T gt           IEnumerable lt T gt  list                unchecked                       int hash   0              int count   0              foreach  var item in list                                hash    item GetHashCode                    count                              return 31   hash   count GetHashCode                              lt summary gt          Alternative way to get a hashcode is to use a fluent          interface like this  lt br   gt          return 0 CombineHashCode field1  CombineHashCode field2               CombineHashCode field3            lt  summary gt      public static int CombineHashCode lt T gt  this int hashCode  T arg                unchecked                       return 31   hashCode   arg GetHashCode                         Also it has extension method to provide a fluent interface  so you can use it like this   public override int GetHashCode         return HashHelper GetHashCode Manufacturer  PartN  Quantity       or like this     public override int GetHashCode         return 0 CombineHashCode Manufacturer           CombineHashCode PartN           CombineHashCode Quantity

User · Answer

If we have no more than 8 properties  hopefully   here is another alternative   ValueTuple is a struct and appears to have a solid GetHashCode implementation   That means we could simply do this      Yay  no allocations and no custom implementations  public override int GetHashCode     gt   this PropA  this PropB  GetHashCode      Let s take a look at  NET Core s current implementation for ValueTuple s GetHashCode   This is from ValueTuple       internal static int CombineHashCodes int h1  int h2                return HashHelpers Combine HashHelpers Combine HashHelpers RandomSeed  h1   h2              internal static int CombineHashCodes int h1  int h2  int h3                return HashHelpers Combine CombineHashCodes h1  h2   h3           And this is from HashHelper       public static readonly int RandomSeed   Guid NewGuid   GetHashCode         public static int Combine int h1  int h2                unchecked                          RyuJIT optimizes this to use the ROL instruction                Related GitHub pull request  dotnet coreclr 1830             uint rol5     uint h1  lt  lt  5      uint h1  gt  gt  27               return   int rol5   h1    h2                    In English    Left rotate  circular shift  h1 by 5 positions  Add the result and h1 together  XOR the result with h2  Start by performing the above operation on   static random seed  h1    For each further item  perform the operation on the previous result and the next item  e g  h2     It would be nice to know more about the properties of this ROL-5 hash code algorithm   Regrettably  deferring to ValueTuple for our own GetHashCode may not be as fast as we would like and expect  This comment in a related discussion illustrates that directly calling HashHelpers Combine is more performant  On the flip side  that one is internal  so we d have to copy the code  sacrificing much of what we had gained here  Also  we d be responsible for remembering to first Combine with the random seed  I don t know what the consequences are if we skip that step

User · Answer

ValueTuple - Update for C  7 As  cactuaroid mentions in the comments  a value tuple can be used  This saves a few keystrokes and more importantly executes purely on the stack  no Garbage    PropA  PropB  PropC  PropD  GetHashCode      Note  The original technique using anonymous types seems to create an object on the heap  i e  garbage  since anonymous types are implemented as classes  though this might be optimized out by the compiler  It would be interesting to benchmark these options  but the tuple option should be superior   Anonymous Type  Original Answer  Microsoft already provides a good generic HashCode generator  Just copy your property field values to an anonymous type and hash it  new   PropA  PropB  PropC  PropD   GetHashCode     This will work for any number of properties  It does not use boxing  It just uses the algorithm already implemented in the framework for anonymous types

User · Answer

This is a good one        lt summary gt      Helper class for generating hash codes suitable      for use in hashing algorithms and data structures like a hash table        lt  summary gt  public static class HashCodeHelper       private static int GetHashCodeInternal int key1  int key2                unchecked                      var num   0x7e53a269             num    -1521134295   num    key1             num     num  lt  lt  10              num     num  gt  gt  6               num     -1521134295   num    key2              num     num  lt  lt  10              num     num  gt  gt  6               return num                            lt summary gt          Returns a hash code for the specified objects          lt  summary gt           lt param name  arr  gt An array of objects used for generating the          hash code  lt  param gt           lt returns gt          A hash code  suitable for use in hashing algorithms and data          structures like a hash table            lt  returns gt      public static int GetHashCode params object   arr                int hash   0          foreach  var item in arr              hash   GetHashCodeInternal hash  item GetHashCode             return hash                  lt summary gt          Returns a hash code for the specified objects          lt  summary gt           lt param name  obj1  gt The first object  lt  param gt           lt param name  obj2  gt The second object  lt  param gt           lt param name  obj3  gt The third object  lt  param gt           lt param name  obj4  gt The fourth object  lt  param gt           lt returns gt          A hash code  suitable for use in hashing algorithms and         data structures like a hash table           lt  returns gt      public static int GetHashCode lt T1  T2  T3  T4 gt  T1 obj1  T2 obj2  T3 obj3          T4 obj4                return GetHashCode obj1  GetHashCode obj2  obj3  obj4                    lt summary gt          Returns a hash code for the specified objects          lt  summary gt           lt param name  obj1  gt The first object  lt  param gt           lt param name  obj2  gt The second object  lt  param gt           lt param name  obj3  gt The third object  lt  param gt           lt returns gt          A hash code  suitable for use in hashing algorithms and data          structures like a hash table            lt  returns gt      public static int GetHashCode lt T1  T2  T3 gt  T1 obj1  T2 obj2  T3 obj3                return GetHashCode obj1  GetHashCode obj2  obj3                    lt summary gt          Returns a hash code for the specified objects          lt  summary gt           lt param name  obj1  gt The first object  lt  param gt           lt param name  obj2  gt The second object  lt  param gt           lt returns gt          A hash code  suitable for use in hashing algorithms and data          structures like a hash table            lt  returns gt      public static int GetHashCode lt T1  T2 gt  T1 obj1  T2 obj2                return GetHashCodeInternal obj1 GetHashCode    obj2 GetHashCode               And here is how to use it   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   amp  amp  tf  type Equals  type

User · Answer

This is a good one        lt summary gt      Helper class for generating hash codes suitable      for use in hashing algorithms and data structures like a hash table        lt  summary gt  public static class HashCodeHelper       private static int GetHashCodeInternal int key1  int key2                unchecked                      var num   0x7e53a269             num    -1521134295   num    key1             num     num  lt  lt  10              num     num  gt  gt  6               num     -1521134295   num    key2              num     num  lt  lt  10              num     num  gt  gt  6               return num                            lt summary gt          Returns a hash code for the specified objects          lt  summary gt           lt param name  arr  gt An array of objects used for generating the          hash code  lt  param gt           lt returns gt          A hash code  suitable for use in hashing algorithms and data          structures like a hash table            lt  returns gt      public static int GetHashCode params object   arr                int hash   0          foreach  var item in arr              hash   GetHashCodeInternal hash  item GetHashCode             return hash                  lt summary gt          Returns a hash code for the specified objects          lt  summary gt           lt param name  obj1  gt The first object  lt  param gt           lt param name  obj2  gt The second object  lt  param gt           lt param name  obj3  gt The third object  lt  param gt           lt param name  obj4  gt The fourth object  lt  param gt           lt returns gt          A hash code  suitable for use in hashing algorithms and         data structures like a hash table           lt  returns gt      public static int GetHashCode lt T1  T2  T3  T4 gt  T1 obj1  T2 obj2  T3 obj3          T4 obj4                return GetHashCode obj1  GetHashCode obj2  obj3  obj4                    lt summary gt          Returns a hash code for the specified objects          lt  summary gt           lt param name  obj1  gt The first object  lt  param gt           lt param name  obj2  gt The second object  lt  param gt           lt param name  obj3  gt The third object  lt  param gt           lt returns gt          A hash code  suitable for use in hashing algorithms and data          structures like a hash table            lt  returns gt      public static int GetHashCode lt T1  T2  T3 gt  T1 obj1  T2 obj2  T3 obj3                return GetHashCode obj1  GetHashCode obj2  obj3                    lt summary gt          Returns a hash code for the specified objects          lt  summary gt           lt param name  obj1  gt The first object  lt  param gt           lt param name  obj2  gt The second object  lt  param gt           lt returns gt          A hash code  suitable for use in hashing algorithms and data          structures like a hash table            lt  returns gt      public static int GetHashCode lt T1  T2 gt  T1 obj1  T2 obj2                return GetHashCodeInternal obj1 GetHashCode    obj2 GetHashCode               And here is how to use it   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   amp  amp  tf  type Equals  type

User · Answer

In case you want to polyfill HashCode from netstandard2 1  public static class HashCode       public static int Combine params object   instances                int hash   17           foreach  var i in instances                        hash   unchecked  hash   31     i  GetHashCode      0                       return hash            Note  If used with struct  it will allocate memory due to boxing

User · Answer

I usually go with something like the implementation given in Josh Bloch s fabulous Effective Java  It s fast and creates a pretty good hash which is unlikely to cause collisions  Pick two different prime numbers  e g  17 and 23  and do  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           As noted in comments  you may find it s better to pick a large prime to multiply by instead  Apparently 486187739 is good    and although most examples I ve seen with small numbers tend to use primes  there are at least similar algorithms where non-prime numbers are often used  In the not-quite-FNV example later  for example  I ve used numbers which apparently work well - but the initial value isn t a prime   The multiplication constant is prime though  I don t know quite how important that is   This is better than the common practice of XORing hashcodes for two main reasons  Suppose we have a type with two int fields  XorHash x  x     XorHash y  y     0 for all x  y XorHash x  y     XorHash y  x  for all x  y  By the way  the earlier algorithm is the one currently used by the C  compiler for anonymous types  This page gives quite a few options  I think for most cases the above is  quot good enough quot  and it s incredibly easy to remember and get right  The FNV alternative is similarly simple  but uses different constants and XOR instead of ADD as a combining operation  It looks something like the code below  but the normal FNV algorithm operates on individual bytes  so this would require modifying to perform one iteration per byte  instead of per 32-bit hash value  FNV is also designed for variable lengths of data  whereas the way we re using it here is always for the same number of field values  Comments on this answer suggest that the code here doesn t actually work as well  in the sample case tested  as the addition approach above     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           Note that one thing to be aware of is that ideally you should prevent your equality-sensitive  and thus hashcode-sensitive  state from changing after adding it to a collection that depends on the hash code  As per the documentation   You can override GetHashCode for immutable reference types  In general  for mutable reference types  you should override GetHashCode only if   You can compute the hash code from fields that are not mutable  or You can ensure that the hash code of a mutable object does not change while the object is contained in a collection that relies on its hash code    The link to the FNV article is broken but here is a copy in the Internet Archive  Eternally Confuzzled - The Art of Hashing

User · Answer

Up until recently my answer would have been very close to Jon Skeet s here  However  I recently started a project which used power-of-two hash tables  that is hash tables where the size of the internal table is 8  16  32  etc  There s a good reason for favouring prime-number sizes  but there are some advantages to power-of-two sizes too   And it pretty much sucked  So after a bit of experimentation and research I started re-hashing my hashes with the following   public static int ReHash int source      unchecked         ulong c   0xDEADBEEFDEADBEEF    ulong source      ulong d   0xE2ADBEEFDEADBEEF   c      ulong a   d    c   c  lt  lt  15   c  gt  gt  -15      ulong b   a    d   d  lt  lt  52   d  gt  gt  -52      c    b    a   a  lt  lt  26   a  gt  gt  -26      d    c    b   b  lt  lt  51   b  gt  gt  -51      a    d    c   c  lt  lt  28   c  gt  gt  -28      b    a    d   d  lt  lt  9   d  gt  gt  -9      c    b    a   a  lt  lt  47   a  gt  gt  -47      d    c    b  lt  lt  54   b  gt  gt  -54      a    d    c  lt  lt  32   c  gt  gt  32      a    d  lt  lt  25   d  gt  gt  -25      return  int  a  gt  gt  1           And then my power-of-two hash table didn t suck any more   This disturbed me though  because the above shouldn t work  Or more precisely  it shouldn t work unless the original GetHashCode   was poor in a very particular way   Re-mixing a hashcode can t improve a great hashcode  because the only possible effect is that we introduce a few more collisions   Re-mixing a hash code can t improve a terrible hash code  because the only possible effect is we change e g  a large number of collisions on value 53 to a large number of value 18 3487 291   Re-mixing a hash code can only improve a hash code that did at least fairly well in avoiding absolute collisions throughout its range  232 possible values  but badly at avoiding collisions when modulo d down for actual use in a hash table  While the simpler modulo of a power-of-two table made this more apparent  it was also having a negative effect with the more common prime-number tables  that just wasn t as obvious  the extra work in rehashing would outweigh the benefit  but the benefit would still be there    Edit  I was also using open-addressing  which would also have increased the sensitivity to collision  perhaps more so than the fact it was power-of-two   And well  it was disturbing how much the string GetHashCode   implementations in  NET  or study here  could be improved this way  on the order of tests running about 20-30 times faster due to fewer collisions  and more disturbing how much my own hash codes could be improved  much more than that    All the GetHashCode   implementations I d coded in the past  and indeed used as the basis of answers on this site  were much worse than I d throught  Much of the time it was  good enough  for much of the uses  but I wanted something better   So I put that project to one side  it was a pet project anyway  and started looking at how to produce a good  well-distributed hash code in  NET quickly   In the end I settled on porting SpookyHash to  NET  Indeed the code above is a fast-path version of using SpookyHash to produce a 32-bit output from a 32-bit input   Now  SpookyHash is not a nice quick to remember piece of code  My port of it is even less so because I hand-inlined a lot of it for better speed   But that s what code reuse is for   Then I put that project to one side  because just as the original project had produced the question of how to produce a better hash code  so that project produced the question of how to produce a better  NET memcpy   Then I came back  and produced a lot of overloads to easily feed just about all of the native types  except decimal     into a hash code   It s fast  for which Bob Jenkins deserves most of the credit because his original code I ported from is faster still  especially on 64-bit machines which the algorithm is optimised for      The full code can be seen at https   bitbucket org JonHanna spookilysharp src but consider that the code above is a simplified version of it   However  since it s now already written  one can make use of it more easily   public override int GetHashCode       var hash   new SpookyHash      hash Update field1     hash Update field2     hash Update field3     return hash Final   GetHashCode        It also takes seed values  so if you need to deal with untrusted input and want to protect against Hash DoS attacks you can set a seed based on uptime or similar  and make the results unpredictable by attackers   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         A big surprise in this is that hand-inlining a rotation method that returned  x  lt  lt  n     x  gt  gt  -n  improved things  I would have been sure that the jitter would have inlined that for me  but profiling showed otherwise      decimal isn t native from the  NET perspective though it is from the C   The problem with it is that its own GetHashCode   treats precision as significant while its own Equals   does not  Both are valid choices  but not mixed like that  In implementing your own version  you need to choose to do one  or the other  but I can t know which you d want      By way of comparison  If used on a string  the SpookyHash on 64 bits is considerably faster than string GetHashCode   on 32 bits which is slightly faster than string GetHashCode   on 64 bits  which is considerably faster than SpookyHash on 32 bits  though still fast enough to be a reasonable choice

User · Answer

Microsoft lead for several way of hashing       for classes that contain a single int value return this value     for classes that contain multiple int value return x   y     for classes that contain single number bigger than int     return   int value    int  value  gt  gt  32        for classes that contain class instance fields which inherit from object return obj1 GetHashCode       for classes that contain multiple class instance fields which inherit from object return obj1 GetHashCode     obj2 GetHashCode     obj3 GetHashCode       I can guess that for multiple big int you can use this   int a   int value1    int  value1  gt  gt  32    int b   int value2    int  value2  gt  gt  32    int c   int value3    int  value3  gt  gt  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 your hash   For those who use hash as ID  I mean an unique value   hash is naturally limited to a number of digits  I think it was 5 bytes for hashing algorithm  at least MD5   You may turn multiple values to a hashed value and some of them be same  so don t use it as an identifier   maybe some day I am going to use your component

User · Answer

In most cases where Equals   compares multiple fields it doesn t really matter if your GetHash   hashes on one field or on many  You just have to make sure that calculating the hash is really cheap  No allocations  please  and fast  No heavy computations and certainly no database connections  and provides a good distribution   The heavy lifting should be part of the Equals   method  the hash should be a very cheap operation to enable calling Equals   on as few items as possible   And one final tip  Don t rely on GetHashCode   being stable over multiple aplication runs  Many  Net types don t guarantee their hash codes to stay the same after a restart  so you should only use the value of GetHashCode   for in memory data structures

User · Answer

In case you want to polyfill HashCode from netstandard2 1  public static class HashCode       public static int Combine params object   instances                int hash   17           foreach  var i in instances                        hash   unchecked  hash   31     i  GetHashCode      0                       return hash            Note  If used with struct  it will allocate memory due to boxing

[.net] What is the best algorithm for overriding GetHashCode?

Examples related to .net

Examples related to algorithm

Examples related to hashcode

Examples related to gethashcode