У .NET GetHashCodeметод використовується у багатьох місцях у бібліотеках базового класу .NET. Правильне його виконання особливо важливо для швидкого пошуку предметів у колекції або при визначенні рівності.

Чи є стандартний алгоритм чи найкраща практика щодо того, як реалізувати GetHashCodeмої власні класи, щоб я не погіршував продуктивність?

Зазвичай я йду з чимось на зразок реалізації, поданої у казковій ефективній Java Джоша Блоха . Це швидко і створює досить хороший хеш, який навряд чи спричинить зіткнення. Виберіть два різних простих числа, наприклад, 17 і 23, і виконайте:

public override int GetHashCode()
{
    unchecked // Overflow is fine, just wrap
    {
        int hash = 17;
        // Suitable nullity checks etc, of course :)
        hash = hash * 23 + field1.GetHashCode();
        hash = hash * 23 + field2.GetHashCode();
        hash = hash * 23 + field3.GetHashCode();
        return hash;
    }
}

Як зазначається в коментарях, ви можете виявити, що краще вибрати велику розмноження, щоб помножити замість цього. Мабуть, 486187739 - це добре ... і хоча більшість прикладів, які я бачив з невеликою кількістю, як правило, використовують праймери, є принаймні подібні алгоритми, де часто використовуються непрості числа. В не quite- FNV приклад пізніше, наприклад, я використав цифри , які , мабуть , добре працюють - але початкове значення не є простим. (Константа множення є простим. Я не знаю, наскільки це важливо.)

Це краще, ніж звичайна практика використання XORхеш-кодів з двох основних причин. Припустимо, у нас є тип з двома intполями:

XorHash(x, x) == XorHash(y, y) == 0 for all x, y
XorHash(x, y) == XorHash(y, x) for all x, y

До речі, попередній алгоритм - це той, який зараз використовується компілятором C # для анонімних типів.

На цій сторінці представлено досить багато варіантів. Я думаю, що в більшості випадків вищесказане є "досить хорошим", і це неймовірно легко запам’ятати і правильно вийти. ФПНА альтернатива є аналогічно простий, але використовує різні константи і XORзамість того , щоб в ADDякості операції комбінування. Він виглядає приблизно так, як наведений нижче код, але звичайний алгоритм FNV працює на окремих байтах, тому це вимагатиме зміни для виконання однієї ітерації за байт, а не для 32-бітного хеш-значення. FNV також розроблений для змінної довжини даних, тоді як спосіб, яким ми їх тут використовуємо, завжди для однакової кількості значень поля. Зауваження до цієї відповіді свідчать про те, що код тут насправді не працює так само (як у випробуваному прикладі), як описано вище.

// 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;
    }
}

Зауважте, що слід пам’ятати про те, що в ідеалі ви повинні запобігти зміні стану, що чутливий до рівності (і, отже, залежно від хеш-коду), після додавання його до колекції, що залежить від хеш-коду.

Відповідно до документації :

Ви можете замінити GetHashCode для незмінних типів посилань. Загалом, для змінних посилальних типів вам слід перекрити GetHashCode, лише якщо:

• Ви можете обчислити хеш-код із полів, які не змінюються; або
• Ви можете переконатися, що хеш-код змінного об'єкта не змінюється, поки об'єкт міститься у колекції, що спирається на його хеш-код.

Анонімний тип

Microsoft вже пропонує хороший загальний генератор HashCode: просто скопіюйте свої властивості / поля в анонімний тип і введіть хеш-код:

new { PropA, PropB, PropC, PropD }.GetHashCode();

Це буде працювати для будь-якої кількості властивостей. Тут не використовується бокс. Він просто використовує алгоритм, вже реалізований в рамках для анонімних типів.

ValueTuple - оновлення для C # 7

Як згадує @cactuaroid у коментарях, може використовуватися кордону значень. Це економить кілька натискань клавіш і, що ще важливіше, виконується чисто на стеку (без сміття):

(PropA, PropB, PropC, PropD).GetHashCode();

(Примітка. Оригінальна техніка, що використовує анонімні типи, здається, створює об’єкт на купі, тобто сміття, оскільки анонімні типи реалізуються як класи, хоча компілятор може це оптимізувати. Це було б цікаво порівняти ці параметри, але варіант кортежу повинен бути вищим.)

Ось мій помічник хеш-коду.
Його перевага полягає в тому, що він використовує загальні аргументи типу і тому не спричиняє боксу:

public static class HashHelper
{
    public static int GetHashCode<T1, T2>(T1 arg1, T2 arg2)
    {
         unchecked
         {
             return 31 * arg1.GetHashCode() + arg2.GetHashCode();
         }
    }

    public static int GetHashCode<T1, T2, T3>(T1 arg1, T2 arg2, T3 arg3)
    {
        unchecked
        {
            int hash = arg1.GetHashCode();
            hash = 31 * hash + arg2.GetHashCode();
            return 31 * hash + arg3.GetHashCode();
        }
    }

    public static int GetHashCode<T1, T2, T3, T4>(T1 arg1, T2 arg2, T3 arg3, 
        T4 arg4)
    {
        unchecked
        {
            int hash = arg1.GetHashCode();
            hash = 31 * hash + arg2.GetHashCode();
            hash = 31 * hash + arg3.GetHashCode();
            return 31 * hash + arg4.GetHashCode();
        }
    }

    public static int GetHashCode<T>(T[] list)
    {
        unchecked
        {
            int hash = 0;
            foreach (var item in list)
            {
                hash = 31 * hash + item.GetHashCode();
            }
            return hash;
        }
    }

    public static int GetHashCode<T>(IEnumerable<T> list)
    {
        unchecked
        {
            int hash = 0;
            foreach (var item in list)
            {
                hash = 31 * hash + item.GetHashCode();
            }
            return hash;
        }
    }

    /// <summary>
    /// Gets a hashcode for a collection for that the order of items 
    /// does not matter.
    /// So {1, 2, 3} and {3, 2, 1} will get same hash code.
    /// </summary>
    public static int GetHashCodeForOrderNoMatterCollection<T>(
        IEnumerable<T> list)
    {
        unchecked
        {
            int hash = 0;
            int count = 0;
            foreach (var item in list)
            {
                hash += item.GetHashCode();
                count++;
            }
            return 31 * hash + count.GetHashCode();
        }
    }

    /// <summary>
    /// Alternative way to get a hashcode is to use a fluent 
    /// interface like this:<br />
    /// return 0.CombineHashCode(field1).CombineHashCode(field2).
    ///     CombineHashCode(field3);
    /// </summary>
    public static int CombineHashCode<T>(this int hashCode, T arg)
    {
        unchecked
        {
            return 31 * hashCode + arg.GetHashCode();   
        }
    }

Також у нього є метод розширення для забезпечення вільного інтерфейсу, тому ви можете використовувати його так:

public override int GetHashCode()
{
    return HashHelper.GetHashCode(Manufacturer, PartN, Quantity);
}

або так:

public override int GetHashCode()
{
    return 0.CombineHashCode(Manufacturer)
        .CombineHashCode(PartN)
        .CombineHashCode(Quantity);
}

У бібліотеці Helper у мене є клас хешингу, який я використовую для цього.

/// <summary> 
/// This is a simple hashing function from Robert Sedgwicks Hashing in C book.
/// Also, some simple optimizations to the algorithm in order to speed up
/// its hashing process have been added. from: www.partow.net
/// </summary>
/// <param name="input">array of objects, parameters combination that you need
/// to get a unique hash code for them</param>
/// <returns>Hash code</returns>
public static int RSHash(params object[] input)
{
    const int b = 378551;
    int a = 63689;
    int hash = 0;

    // If it overflows then just wrap around
    unchecked
    {
        for (int i = 0; i < input.Length; i++)
        {
            if (input[i] != null)
            {
                hash = hash * a + input[i].GetHashCode();
                a = a * b;
            }
        }
    }

    return hash;
}

Потім просто ви можете використовувати його як:

public override int GetHashCode()
{
    return Hashing.RSHash(_field1, _field2, _field3);
}

Я не оцінював її ефективність, тому будь-які відгуки вітаються.

Ось мій клас помічників із застосуванням Джон Скіта .

public static class HashCode
{
    public const int Start = 17;

    public static int Hash<T>(this int hash, T obj)
    {
        var h = EqualityComparer<T>.Default.GetHashCode(obj);
        return unchecked((hash * 31) + h);
    }
}

Використання:

public override int GetHashCode()
{
    return HashCode.Start
        .Hash(_field1)
        .Hash(_field2)
        .Hash(_field3);
}

Якщо ви не хочете писати метод розширення для System.Int32:

public readonly struct HashCode
{
    private readonly int _value;

    public HashCode(int value) => _value = value;

    public static HashCode Start { get; } = new HashCode(17);

    public static implicit operator int(HashCode hash) => hash._value;

    public HashCode Hash<T>(T obj)
    {
        var h = EqualityComparer<T>.Default.GetHashCode(obj);
        return unchecked(new HashCode((_value * 31) + h));
    }

    public override int GetHashCode() => _value;
}

Він все одно уникає будь-якого розподілу купи і використовується точно так само:

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 (травень 2018): EqualityComparer<T>.Defaultздобувач тепер JIT внутрішній - запит тягнути згадуються Стівен Toub в цьому блозі .

.NET стандарт 2.1 і вище

Якщо ви використовуєте .NET Standard 2.1 або вище, ви можете використовувати структуру System.HashCode . Існує два способи його використання:

HashCode.Combine

CombineМетод може бути використаний для створення хеш - код, дані до восьми об'єктів.

public override int GetHashCode() => HashCode.Combine(this.object1, this.object2);

HashCode.Add

AddМетод допоможе вам впоратися з колекціями:

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 зроблено легко

Ви можете прочитати повне повідомлення в блозі " GetHashCode Made Easy " для отримання більш детальної інформації та коментарів.

Приклад використання

public class SuperHero
{
    public int Age { get; set; }
    public string Name { get; set; }
    public List<string> Powers { get; set; }

    public override int GetHashCode() =>
        HashCode.Of(this.Name).And(this.Age).AndEach(this.Powers);
}

Впровадження

public struct HashCode : IEquatable<HashCode>
{
    private const int EmptyCollectionPrimeNumber = 19;
    private readonly int value;

    private HashCode(int value) => this.value = value;

    public static implicit operator int(HashCode hashCode) => hashCode.value;

    public static bool operator ==(HashCode left, HashCode right) => left.Equals(right);

    public static bool operator !=(HashCode left, HashCode right) => !(left == right);

    public static HashCode Of<T>(T item) => new HashCode(GetHashCode(item));

    public static HashCode OfEach<T>(IEnumerable<T> items) =>
        items == null ? new HashCode(0) : new HashCode(GetHashCode(items, 0));

    public HashCode And<T>(T item) => 
        new HashCode(CombineHashCodes(this.value, GetHashCode(item)));

    public HashCode AndEach<T>(IEnumerable<T> items)
    {
        if (items == null)
        {
            return new HashCode(this.value);
        }

        return new HashCode(GetHashCode(items, this.value));
    }

    public bool Equals(HashCode other) => 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() => 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 << 5) + h1) ^ h2;
        }
    }

    private static int GetHashCode<T>(T item) => item?.GetHashCode() ?? 0;

    private static int GetHashCode<T>(IEnumerable<T> 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;
    }
}

Що робить хороший алгоритм?

Швидкість

Алгоритм, який обчислює хеш-код, повинен бути швидким. Простий алгоритм, як правило, буде більш швидким.

Детермінований

Алгоритм хешування повинен бути детермінованим, тобто з одиничним входом він завжди повинен отримувати однаковий вихід.

Зменшити зіткнення

Алгоритм, який обчислює хеш-код, повинен підтримувати хеш-колізії до мінімуму. Хеш-зіткнення - це ситуація, яка виникає, коли два дзвінки GetHashCodeна два різних об'єкти створюють однакові хеш-коди. Зауважте, що колізії дозволені (деякі мають помилкові уявлення, що їх немає), але їх слід звести до мінімуму.

Хороша хеш-функція повинна максимально рівномірно відображати очікувані входи в межах її вихідного діапазону. Він повинен мати рівномірність.

Профілактика DoS

У .NET Core кожен раз при перезапуску програми ви отримуватимете різні хеш-коди. Це функція безпеки для запобігання атакам відмови в сервісі (DoS). Для .NET Framework слід активувати цю функцію, додавши наступний файл App.config:

<?xml version ="1.0"?>  
<configuration>  
   <runtime>  
      <UseRandomizedStringHashAlgorithm enabled="1" />  
   </runtime>  
</configuration>

Через цю особливість хеш-коди ніколи не повинні використовуватися за межами домену додатка, в якому вони створені, вони ніколи не повинні використовуватися як ключові поля в колекції, і вони ніколи не повинні зберігатися.

Детальніше про це читайте тут .

Криптографічно безпечний?

Алгоритм не повинен бути криптографічним хеш-функцією . Це означає, що він не повинен відповідати наступним умовам:

• Генерувати повідомлення, яке дає задане хеш-значення, неможливо
• Неможливо знайти два різних повідомлення з однаковим хеш-значенням
• Невелика зміна повідомлення повинна настільки сильно змінити хеш-значення, що нове хеш-значення виявиться некоррельованим зі старим хеш-значенням (ефект лавини).

У більшості випадків, коли Equals () порівнює кілька полів, це насправді не має значення, якщо ваш GetHash () хешируется на одному полі чи на багатьох. Вам просто потрібно переконатися, що обчислення хеса є дуже дешевим ( без розподілу , будь ласка) та швидким ( Без великих обчислень і, звичайно, немає підключень до бази даних) та забезпечує хороший розподіл.

Важкий підйом повинен бути частиною методу рівних (); хеш повинен бути дуже дешевою операцією, щоб дозволити виклику рівнянь () якомога менше елементів.

І ще одна остання порада: не сподівайтеся на те, що GetHashCode () стабільний протягом кількох запусків заявок . Багато типів .et не гарантують, що їх хеш-коди залишаться однаковими після перезавантаження, тому вам слід використовувати лише значення GetHashCode () для структури даних пам'яті.

Донедавна моя відповідь була б дуже близькою до Джона Скіта. Однак я нещодавно розпочав проект, в якому використовували хеш-таблиці потужності з двох потужностей, тобто хеш-таблиці, де розмір внутрішньої таблиці становить 8, 16, 32 і т.д. є деякі переваги і до потужності двох розмірів.

І це в значній мірі смоктало. Тому після невеликих експериментів та досліджень я почав повторно перебирати хеші з наступним:

public static int ReHash(int source)
{
  unchecked
  {
    ulong c = 0xDEADBEEFDEADBEEF + (ulong)source;
    ulong d = 0xE2ADBEEFDEADBEEF ^ c;
    ulong a = d += c = c << 15 | c >> -15;
    ulong b = a += d = d << 52 | d >> -52;
    c ^= b += a = a << 26 | a >> -26;
    d ^= c += b = b << 51 | b >> -51;
    a ^= d += c = c << 28 | c >> -28;
    b ^= a += d = d << 9 | d >> -9;
    c ^= b += a = a << 47 | a >> -47;
    d ^= c += b << 54 | b >> -54;
    a ^= d += c << 32 | c >> 32;
    a += d << 25 | d >> -25;
    return (int)(a >> 1);
  }
}

І тоді моя хеш-таблиця з потужністю більше не смоктала.

Це мене, однак, турбувало, тому що вищезгадане не повинно працювати. Або точніше, він не повинен працювати, якщо оригінал не GetHashCode()був дуже конкретним чином.

Повторне змішування хеш-коду не може поліпшити чудовий хеш-код, оскільки єдиний можливий ефект полягає в тому, що ми вводимо ще кілька зіткнень.

Повторне змішування хеш-коду не може поліпшити жахливий хеш-код, оскільки єдиний можливий ефект полягає в тому, що ми змінюємо, наприклад, велику кількість зіткнень зі значенням 53 на велику кількість значення 18,3487,291.

Повторне змішування хеш-коду може лише покращити хеш-код, який принаймні досить вдало уникнув абсолютних зіткнень у всьому його діапазоні (2 ³² можливі значення), але погано уникнути зіткнень, коли модуль знизився для фактичного використання в хеш-таблиці. Хоча простіший модуль таблиці потужності два зробив це більш очевидним, він також мав негативний ефект у порівнянні з більш поширеними таблицями простих чисел, що це було не так очевидно (додаткова робота з переосмислення перевищила б користь , але користь все одно буде).

Редагувати: Я також використовував відкриту адресацію, що також підвищило б чутливість до зіткнення, можливо, тим більше, ніж факт, що це потужність двох.

І добре, це турбує, наскільки string.GetHashCode()реалізації в .NET (або тут можна вивчити ) можна поліпшити таким чином (на порядок тестів, які працюють приблизно в 20-30 разів швидше через меншу кількість зіткнень) і більше заважає, наскільки мої власні хеш-коди можна було б покращити (набагато більше, ніж це).

Усі реалізації GetHashCode (), які я кодував у минулому, і які фактично використовувались як основа відповідей на цьому сайті, були набагато гіршими, ніж я хотіла . Значну частину часу це було «досить добре» для більшості застосувань, але я хотів чогось кращого.

Тому я поставив цей проект на одну сторону (це все одно був проект для домашніх тварин) і почав дивитися на те, як швидко створити хороший, добре розподілений хеш-код у .NET.

Врешті-решт я вирішив перенести SpookyHash на .NET. Дійсно, наведений вище код є швидкою версією використання SpookyHash для отримання 32-бітного виходу з 32-бітного входу.

Тепер, SpookyHash - це не приємно швидко запам'ятати фрагмент коду. Мій порт його навіть менший, тому що я вручив багато його для кращої швидкості *. Але саме для цього використовується повторне використання коду.

Потім я поставив цей проект на одну сторону, тому що так само, як і в початковому проекті було поставлено питання про те, як створити кращий хеш-код, таким чином проект створив питання про те, як створити кращу метчі .NET.

Потім я повернувся і створив безліч перевантажень, щоб легко вводити майже decimalхеш-код майже всіх рідних типів (крім †).

Це швидко, для чого Боб Дженкінс заслуговує більшої частини заслуг, оскільки його оригінальний код, з якого я перенісся, все ще швидший, особливо на 64-бітних машинах, алгоритм яких оптимізований для ‡.

Повний код можна побачити на https://bitbucket.org/JonHanna/spookilysharp/src, але врахуйте, що наведений вище код є спрощеною його версією.

Однак, оскільки це вже написано, можна скористатися ним простіше:

public override int GetHashCode()
{
  var hash = new SpookyHash();
  hash.Update(field1);
  hash.Update(field2);
  hash.Update(field3);
  return hash.Final().GetHashCode();
}

Він також приймає насінні значення, тому якщо вам потрібно мати справу з ненадійним входом і хочете захиститись від Hash DoS-атак, ви можете встановити насіння на основі тривалості роботи або подібного, і зробити результати зловмисниками непередбачуваними:

private static long hashSeed0 = Environment.TickCount;
private static long hashSeed1 = DateTime.Now.Ticks;
public override int GetHashCode()
{
  //produce different hashes ever time this application is restarted
  //but remain consistent in each run, so attackers have a harder time
  //DoSing the hash tables.
  var hash = new SpookyHash(hashSeed0, hashSeed1);
  hash.Update(field1);
  hash.Update(field2);
  hash.Update(field3);
  return hash.Final().GetHashCode();
}

* Великою несподіванкою в цьому є те, що вручну вбудований метод обертання, який повертає (x << n) | (x >> -n)покращені речі. Я був би впевнений, що тремтіння підкреслило б це для мене, але профілювання показало інше.

† decimalне є рідною з точки зору .NET, хоча це з C #. Проблема з цим полягає в тому, що її власні GetHashCode()розцінюють точність як важливу, а її Equals()- ні. Обидва є правильним вибором, але не змішуються так. Реалізуючи свою власну версію, вам потрібно вибрати одну чи іншу, але я не можу знати, що ви хочете.

‡ За допомогою порівняння. Якщо використовується на рядку, SpookyHash на 64 бітах значно швидший, ніж string.GetHashCode()на 32 бітах, що трохи швидше, ніж string.GetHashCode()на 64 бітах, що значно швидше, ніж SpookyHash на 32 бітах, хоча все ще досить швидкий, щоб бути розумним вибором.

Це добре:

/// <summary>
/// Helper class for generating hash codes suitable 
/// for use in hashing algorithms and data structures like a hash table. 
/// </summary>
public static class HashCodeHelper
{
    private static int GetHashCodeInternal(int key1, int key2)
    {
        unchecked
        {
           var num = 0x7e53a269;
           num = (-1521134295 * num) + key1;
           num += (num << 10);
           num ^= (num >> 6);

           num = ((-1521134295 * num) + key2);
           num += (num << 10);
           num ^= (num >> 6);

           return num;
        }
    }

    /// <summary>
    /// Returns a hash code for the specified objects
    /// </summary>
    /// <param name="arr">An array of objects used for generating the 
    /// hash code.</param>
    /// <returns>
    /// A hash code, suitable for use in hashing algorithms and data 
    /// structures like a hash table. 
    /// </returns>
    public static int GetHashCode(params object[] arr)
    {
        int hash = 0;
        foreach (var item in arr)
            hash = GetHashCodeInternal(hash, item.GetHashCode());
        return hash;
    }

    /// <summary>
    /// Returns a hash code for the specified objects
    /// </summary>
    /// <param name="obj1">The first object.</param>
    /// <param name="obj2">The second object.</param>
    /// <param name="obj3">The third object.</param>
    /// <param name="obj4">The fourth object.</param>
    /// <returns>
    /// A hash code, suitable for use in hashing algorithms and
    /// data structures like a hash table.
    /// </returns>
    public static int GetHashCode<T1, T2, T3, T4>(T1 obj1, T2 obj2, T3 obj3,
        T4 obj4)
    {
        return GetHashCode(obj1, GetHashCode(obj2, obj3, obj4));
    }

    /// <summary>
    /// Returns a hash code for the specified objects
    /// </summary>
    /// <param name="obj1">The first object.</param>
    /// <param name="obj2">The second object.</param>
    /// <param name="obj3">The third object.</param>
    /// <returns>
    /// A hash code, suitable for use in hashing algorithms and data 
    /// structures like a hash table. 
    /// </returns>
    public static int GetHashCode<T1, T2, T3>(T1 obj1, T2 obj2, T3 obj3)
    {
        return GetHashCode(obj1, GetHashCode(obj2, obj3));
    }

    /// <summary>
    /// Returns a hash code for the specified objects
    /// </summary>
    /// <param name="obj1">The first object.</param>
    /// <param name="obj2">The second object.</param>
    /// <returns>
    /// A hash code, suitable for use in hashing algorithms and data 
    /// structures like a hash table. 
    /// </returns>
    public static int GetHashCode<T1, T2>(T1 obj1, T2 obj2)
    {
        return GetHashCodeInternal(obj1.GetHashCode(), obj2.GetHashCode());
    }
}

А ось як ним користуватися:

private struct Key
{
    private Type _type;
    private string _field;

    public Type Type { get { return _type; } }
    public string Field { get { return _field; } }

    public Key(Type type, string field)
    {
        _type = type;
        _field = field;
    }

    public override int GetHashCode()
    {
        return HashCodeHelper.GetHashCode(_field, _type);
    }

    public override bool Equals(object obj)
    {
        if (!(obj is Key))
            return false;
        var tf = (Key)obj;
        return tf._field.Equals(_field) && tf._type.Equals(_type);
    }
}

Станом на https://github.com/dotnet/coreclr/pull/14863 , існує новий спосіб генерування хеш-кодів, який дуже простий! Просто напишіть

public override int GetHashCode()
    => HashCode.Combine(field1, field2, field3);

Це створить якісний хеш-код, не турбуючись про деталі реалізації.

Ось ще одна вільна реалізація алгоритму, розміщеного вище Джоном Скітом , але який не включає асигнувань або бокс-операцій:

public static class Hash
{
    public const int Base = 17;

    public static int HashObject(this int hash, object obj)
    {
        unchecked { return hash * 23 + (obj == null ? 0 : obj.GetHashCode()); }
    }

    public static int HashValue<T>(this int hash, T value)
        where T : struct
    {
        unchecked { return hash * 23 + value.GetHashCode(); }
    }
}

Використання:

public class MyType<T>
{
    public string Name { get; set; }

    public string Description { get; set; }

    public int Value { get; set; }

    public IEnumerable<T> Children { get; set; }

    public override int GetHashCode()
    {
        return Hash.Base
            .HashObject(this.Name)
            .HashObject(this.Description)
            .HashValue(this.Value)
            .HashObject(this.Children);
    }
}

Компілятор гарантує HashValue, що не викликається класом через обмеження загального типу. Але підтримки для компілятора немає, HashObjectоскільки додавання загального аргументу також додає операцію боксу.

Ось мій спрощений підхід. Для цього я використовую класичний шаблон для будівельників. Це typesafe (без боксу / unboxing), а також сумісний з .NET 2.0 (відсутність методів розширення тощо).

Він використовується так:

public override int GetHashCode()
{
    HashBuilder b = new HashBuilder();
    b.AddItems(this.member1, this.member2, this.member3);
    return b.Result;
} 

А ось клас акутальних будівельників:

internal class HashBuilder
{
    private const int Prime1 = 17;
    private const int Prime2 = 23;
    private int result = Prime1;

    public HashBuilder()
    {
    }

    public HashBuilder(int startHash)
    {
        this.result = startHash;
    }

    public int Result
    {
        get
        {
            return this.result;
        }
    }

    public void AddItem<T>(T item)
    {
        unchecked
        {
            this.result = this.result * Prime2 + item.GetHashCode();
        }
    }

    public void AddItems<T1, T2>(T1 item1, T2 item2)
    {
        this.AddItem(item1);
        this.AddItem(item2);
    }

    public void AddItems<T1, T2, T3>(T1 item1, T2 item2, T3 item3)
    {
        this.AddItem(item1);
        this.AddItem(item2);
        this.AddItem(item3);
    }

    public void AddItems<T1, T2, T3, T4>(T1 item1, T2 item2, T3 item3, 
        T4 item4)
    {
        this.AddItem(item1);
        this.AddItem(item2);
        this.AddItem(item3);
        this.AddItem(item4);
    }

    public void AddItems<T1, T2, T3, T4, T5>(T1 item1, T2 item2, T3 item3, 
        T4 item4, T5 item5)
    {
        this.AddItem(item1);
        this.AddItem(item2);
        this.AddItem(item3);
        this.AddItem(item4);
        this.AddItem(item5);
    }        

    public void AddItems<T>(params T[] items)
    {
        foreach (T item in items)
        {
            this.AddItem(item);
        }
    }
}

Користувачі ReSharper можуть генерувати GetHashCode, Equals та ін ReSharper -> Edit -> Generate Code -> Equality Members.

// ReSharper's GetHashCode looks like this
public override int GetHashCode() {
    unchecked {
        int hashCode = Id;
        hashCode = (hashCode * 397) ^ IntMember;
        hashCode = (hashCode * 397) ^ OtherIntMember;
        hashCode = (hashCode * 397) ^ (RefMember != null ? RefMember.GetHashCode() : 0);
        // ...
        return hashCode;
    }
}

Якщо у нас не більше 8 об'єктів (сподіваємось), ось ще одна альтернатива.

ValueTupleє структурою і, здається, має надійну GetHashCodeреалізацію.

Це означає, що ми могли просто зробити це:

// Yay, no allocations and no custom implementations!
public override int GetHashCode() => (this.PropA, this.PropB).GetHashCode();

Давайте розглянемо поточну реалізацію .NET Core для ValueTuples GetHashCode.

Це від 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);
    }

І це від 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 << 5) | ((uint)h1 >> 27);
            return ((int)rol5 + h1) ^ h2;
        }
    }

Англійською:

• Лівий поворот (круговий зсув) h1 на 5 позицій.
• Додайте результат і h1 разом.
• XOR результат з h2.
• Почніть з виконання зазначеної операції на {статичному випадковому насінні, h1}.
• Для кожного наступного елемента виконайте операцію над попереднім результатом та наступним пунктом (наприклад, h2).

Було б непогано дізнатися більше про властивості цього алгоритму хеш-коду ROL-5.

На жаль, відкладатись на ValueTupleсебе GetHashCodeможе не так швидко, як ми хотіли б і очікуємо. Цей коментар у відповідній дискусії ілюструє, що безпосередньо дзвінок HashHelpers.Combineє більш ефективним. З іншого боку, це є внутрішнім, тому нам доведеться копіювати код, жертвуючи велику частину того, що ми отримали тут. Крім того, ми несемо відповідальність за те, щоб пам'ятати спочатку Combineз випадковим насінням. Я не знаю, які наслідки, якщо ми пропустимо цей крок.

Більшість моєї роботи виконується з підключенням до бази даних, що означає, що всі мої класи мають унікальний ідентифікатор із бази даних. Я завжди використовую ідентифікатор із бази даних, щоб генерувати хеш-код.

// Unique ID from database
private int _id;

...    
{
  return _id.GetHashCode();
}

Дуже схожа на рішення нічного кодера, за винятком того, що легше підняти праймери, якщо ви хочете.

PS: Це один з тих часів, коли ви трохи блукаєте в рот, знаючи, що це може бути перероблене на один метод з 9 за замовчуванням, але це буде повільніше, тому ви просто закриєте очі і намагаєтеся забути про це.

/// <summary>
/// Try not to look at the source code. It works. Just rely on it.
/// </summary>
public static class HashHelper
{
    private const int PrimeOne = 17;
    private const int PrimeTwo = 23;

    public static int GetHashCode<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
    {
        unchecked
        {
            int hash = PrimeOne;
            hash = hash * PrimeTwo + arg1.GetHashCode();
            hash = hash * PrimeTwo + arg2.GetHashCode();
            hash = hash * PrimeTwo + arg3.GetHashCode();
            hash = hash * PrimeTwo + arg4.GetHashCode();
            hash = hash * PrimeTwo + arg5.GetHashCode();
            hash = hash * PrimeTwo + arg6.GetHashCode();
            hash = hash * PrimeTwo + arg7.GetHashCode();
            hash = hash * PrimeTwo + arg8.GetHashCode();
            hash = hash * PrimeTwo + arg9.GetHashCode();
            hash = hash * PrimeTwo + arg10.GetHashCode();

            return hash;
        }
    }

    public static int GetHashCode<T1, T2, T3, T4, T5, T6, T7, T8, T9>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
    {
        unchecked
        {
            int hash = PrimeOne;
            hash = hash * PrimeTwo + arg1.GetHashCode();
            hash = hash * PrimeTwo + arg2.GetHashCode();
            hash = hash * PrimeTwo + arg3.GetHashCode();
            hash = hash * PrimeTwo + arg4.GetHashCode();
            hash = hash * PrimeTwo + arg5.GetHashCode();
            hash = hash * PrimeTwo + arg6.GetHashCode();
            hash = hash * PrimeTwo + arg7.GetHashCode();
            hash = hash * PrimeTwo + arg8.GetHashCode();
            hash = hash * PrimeTwo + arg9.GetHashCode();

            return hash;
        }
    }

    public static int GetHashCode<T1, T2, T3, T4, T5, T6, T7, T8>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
    {
        unchecked
        {
            int hash = PrimeOne;
            hash = hash * PrimeTwo + arg1.GetHashCode();
            hash = hash * PrimeTwo + arg2.GetHashCode();
            hash = hash * PrimeTwo + arg3.GetHashCode();
            hash = hash * PrimeTwo + arg4.GetHashCode();
            hash = hash * PrimeTwo + arg5.GetHashCode();
            hash = hash * PrimeTwo + arg6.GetHashCode();
            hash = hash * PrimeTwo + arg7.GetHashCode();
            hash = hash * PrimeTwo + arg8.GetHashCode();

            return hash;
        }
    }

    public static int GetHashCode<T1, T2, T3, T4, T5, T6, T7>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
    {
        unchecked
        {
            int hash = PrimeOne;
            hash = hash * PrimeTwo + arg1.GetHashCode();
            hash = hash * PrimeTwo + arg2.GetHashCode();
            hash = hash * PrimeTwo + arg3.GetHashCode();
            hash = hash * PrimeTwo + arg4.GetHashCode();
            hash = hash * PrimeTwo + arg5.GetHashCode();
            hash = hash * PrimeTwo + arg6.GetHashCode();
            hash = hash * PrimeTwo + arg7.GetHashCode();

            return hash;
        }
    }

    public static int GetHashCode<T1, T2, T3, T4, T5, T6>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
    {
        unchecked
        {
            int hash = PrimeOne;
            hash = hash * PrimeTwo + arg1.GetHashCode();
            hash = hash * PrimeTwo + arg2.GetHashCode();
            hash = hash * PrimeTwo + arg3.GetHashCode();
            hash = hash * PrimeTwo + arg4.GetHashCode();
            hash = hash * PrimeTwo + arg5.GetHashCode();
            hash = hash * PrimeTwo + arg6.GetHashCode();

            return hash;
        }
    }

    public static int GetHashCode<T1, T2, T3, T4, T5>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
    {
        unchecked
        {
            int hash = PrimeOne;
            hash = hash * PrimeTwo + arg1.GetHashCode();
            hash = hash * PrimeTwo + arg2.GetHashCode();
            hash = hash * PrimeTwo + arg3.GetHashCode();
            hash = hash * PrimeTwo + arg4.GetHashCode();
            hash = hash * PrimeTwo + arg5.GetHashCode();

            return hash;
        }
    }

    public static int GetHashCode<T1, T2, T3, T4>(T1 arg1, T2 arg2, T3 arg3, T4 arg4)
    {
        unchecked
        {
            int hash = PrimeOne;
            hash = hash * PrimeTwo + arg1.GetHashCode();
            hash = hash * PrimeTwo + arg2.GetHashCode();
            hash = hash * PrimeTwo + arg3.GetHashCode();
            hash = hash * PrimeTwo + arg4.GetHashCode();

            return hash;
        }
    }

    public static int GetHashCode<T1, T2, T3>(T1 arg1, T2 arg2, T3 arg3)
    {
        unchecked
        {
            int hash = PrimeOne;
            hash = hash * PrimeTwo + arg1.GetHashCode();
            hash = hash * PrimeTwo + arg2.GetHashCode();
            hash = hash * PrimeTwo + arg3.GetHashCode();

            return hash;
        }
    }

    public static int GetHashCode<T1, T2>(T1 arg1, T2 arg2)
    {
        unchecked
        {
            int hash = PrimeOne;
            hash = hash * PrimeTwo + arg1.GetHashCode();
            hash = hash * PrimeTwo + arg2.GetHashCode();

            return hash;
        }
    }
}

Я зіткнувся з проблемою з поплавцями та десятковими знаками, використовуючи реалізацію, обрану як відповідь вище.

Цей тест не вдається (плаває; хеш - те саме, хоча я переключив 2 значення на негативні):

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

Але цей тест проходить (з 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));

Я змінив свою реалізацію, щоб не використовувати GetHashCode для примітивних типів і, здається, працює краще

    private static int InternalComputeHash(params object[] obj)
    {
        unchecked
        {
            var result = (int)SEED_VALUE_PRIME;
            for (uint i = 0; i < obj.Length; i++)
            {
                var currval = result;
                var nextval = DetermineNextValue(obj[i]);
                result = (result * MULTIPLIER_VALUE_PRIME) + nextval;

            }
            return result;
        }
    }



    private static int DetermineNextValue(object value)
    {
        unchecked
        {

                int hashCode;
                if (value is short
                    || value is int
                    || value is byte
                    || value is sbyte
                    || value is uint
                    || value is ushort
                    || value is ulong
                    || value is long
                    || value is float
                    || value is double
                    || value is decimal)
                {
                    return Convert.ToInt32(value);
                }
                else
                {
                    return value != null ? value.GetHashCode() : 0;
                }
        }
    }

Майкрософт веде декілька способів хешування ...

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

Я можу здогадатися, що для кількох великих int ви можете використовувати це:

int a=((int)value1 ^ (int)(value1 >> 32));
int b=((int)value2 ^ (int)(value2 >> 32));
int c=((int)value3 ^ (int)(value3 >> 32));
return a ^ b ^ c;

І те саме для мульти-типів: усі перетворені спочатку в intвикористання, GetHashCode() тоді значення int будуть xor'ed, а результат - ваш хеш.

Для тих, хто використовує хеш як ID (я маю на увазі унікальне значення), хеш, природно, обмежений кількома цифрами, я думаю, це було 5 байтів для алгоритму хешування, принаймні MD5.

Ви можете перетворити кілька значень у хешоване значення, а деякі з них однакові, тому не використовуйте його як ідентифікатор. (можливо, якось я буду використовувати ваш компонент)

Це статичний хелперний клас, який реалізує реалізацію Джоша Блоха; і забезпечує явні перевантаження для "запобігання" боксу, а також для реалізації хешу спеціально для довгих примітивів.

Ви можете пройти порівняння рядків, яке відповідає вашій рівній реалізації.

Оскільки вихід Hash завжди є цілим, ви можете просто ланцюжок Hash-дзвінків.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;
using System.Runtime.CompilerServices;


namespace Sc.Util.System
{
    /// <summary>
    /// Static methods that allow easy implementation of hashCode. Example usage:
    /// <code>
    /// public override int GetHashCode()
    ///     => HashCodeHelper.Seed
    ///         .Hash(primitiveField)
    ///         .Hsh(objectField)
    ///         .Hash(iEnumerableField);
    /// </code>
    /// </summary>
    public static class HashCodeHelper
    {
        /// <summary>
        /// An initial value for a hashCode, to which is added contributions from fields.
        /// Using a non-zero value decreases collisions of hashCode values.
        /// </summary>
        public const int Seed = 23;

        private const int oddPrimeNumber = 37;


        /// <summary>
        /// Rotates the seed against a prime number.
        /// </summary>
        /// <param name="aSeed">The hash's first term.</param>
        /// <returns>The new hash code.</returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private static int rotateFirstTerm(int aSeed)
        {
            unchecked {
                return HashCodeHelper.oddPrimeNumber * aSeed;
            }
        }


        /// <summary>
        /// Contributes a boolean to the developing HashCode seed.
        /// </summary>
        /// <param name="aSeed">The developing HashCode value or seed.</param>
        /// <param name="aBoolean">The value to contribute.</param>
        /// <returns>The new hash code.</returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static int Hash(this int aSeed, bool aBoolean)
        {
            unchecked {
                return HashCodeHelper.rotateFirstTerm(aSeed)
                        + (aBoolean
                                ? 1
                                : 0);
            }
        }

        /// <summary>
        /// Contributes a char to the developing HashCode seed.
        /// </summary>
        /// <param name="aSeed">The developing HashCode value or seed.</param>
        /// <param name="aChar">The value to contribute.</param>
        /// <returns>The new hash code.</returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static int Hash(this int aSeed, char aChar)
        {
            unchecked {
                return HashCodeHelper.rotateFirstTerm(aSeed)
                        + aChar;
            }
        }

        /// <summary>
        /// Contributes an int to the developing HashCode seed.
        /// Note that byte and short are handled by this method, through implicit conversion.
        /// </summary>
        /// <param name="aSeed">The developing HashCode value or seed.</param>
        /// <param name="aInt">The value to contribute.</param>
        /// <returns>The new hash code.</returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static int Hash(this int aSeed, int aInt)
        {
            unchecked {
                return HashCodeHelper.rotateFirstTerm(aSeed)
                        + aInt;
            }
        }

        /// <summary>
        /// Contributes a long to the developing HashCode seed.
        /// </summary>
        /// <param name="aSeed">The developing HashCode value or seed.</param>
        /// <param name="aLong">The value to contribute.</param>
        /// <returns>The new hash code.</returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static int Hash(this int aSeed, long aLong)
        {
            unchecked {
                return HashCodeHelper.rotateFirstTerm(aSeed)
                        + (int)(aLong ^ (aLong >> 32));
            }
        }

        /// <summary>
        /// Contributes a float to the developing HashCode seed.
        /// </summary>
        /// <param name="aSeed">The developing HashCode value or seed.</param>
        /// <param name="aFloat">The value to contribute.</param>
        /// <returns>The new hash code.</returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static int Hash(this int aSeed, float aFloat)
        {
            unchecked {
                return HashCodeHelper.rotateFirstTerm(aSeed)
                        + Convert.ToInt32(aFloat);
            }
        }

        /// <summary>
        /// Contributes a double to the developing HashCode seed.
        /// </summary>
        /// <param name="aSeed">The developing HashCode value or seed.</param>
        /// <param name="aDouble">The value to contribute.</param>
        /// <returns>The new hash code.</returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static int Hash(this int aSeed, double aDouble)
            => aSeed.Hash(Convert.ToInt64(aDouble));

        /// <summary>
        /// Contributes a string to the developing HashCode seed.
        /// </summary>
        /// <param name="aSeed">The developing HashCode value or seed.</param>
        /// <param name="aString">The value to contribute.</param>
        /// <param name="stringComparison">Optional comparison that creates the hash.</param>
        /// <returns>The new hash code.</returns>
        [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);
            }
        }

        /// <summary>
        /// Contributes a possibly-null array to the developing HashCode seed.
        /// Each element may be a primitive, a reference, or a possibly-null array.
        /// </summary>
        /// <param name="aSeed">The developing HashCode value or seed.</param>
        /// <param name="aArray">CAN be null.</param>
        /// <returns>The new hash code.</returns>
        [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);
        }

        /// <summary>
        /// Contributes a possibly-null array to the developing HashCode seed.
        /// You must provide the hash function for each element.
        /// </summary>
        /// <param name="aSeed">The developing HashCode value or seed.</param>
        /// <param name="aArray">CAN be null.</param>
        /// <param name="hashElement">Required: yields the hash for each element
        /// in <paramref name="aArray"/>.</param>
        /// <returns>The new hash code.</returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static int Hash<T>(this int aSeed, IEnumerable<T> aArray, Func<T, int> 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);
        }

        /// <summary>
        /// Contributes a possibly-null object to the developing HashCode seed.
        /// </summary>
        /// <param name="aSeed">The developing HashCode value or seed.</param>
        /// <param name="aObject">CAN be null.</param>
        /// <returns>The new hash code.</returns>
        [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());
        }


        /// <summary>
        /// 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.
        /// </summary>
        /// <param name="aSeed">The developing hash code, or the seed: if you have no seed, use
        /// the <see cref="Seed"/>.</param>
        /// <param name="aObject">CAN be null.</param>
        /// <param name="propertySelector"><see cref="BindingFlags"/> to select the properties to hash.</param>
        /// <param name="ignorePropertyNames">Optional.</param>
        /// <returns>A hash from the properties contributed to <c>aSeed</c>.</returns>
        [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)
                    && (ignorePropertyNames.Length != 0)) {
                foreach (PropertyInfo propertyInfo in aObject.GetType()
                        .GetProperties(propertySelector)) {
                    if (!propertyInfo.CanRead
                            || (Array.IndexOf(ignorePropertyNames, propertyInfo.Name) >= 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;
        }


        /// <summary>
        /// NOTICE: this method is provided to contribute a <see cref="KeyValuePair{TKey,TValue}"/> 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
        /// <see cref="Hash(int,object)"/>, <see cref="Hash(int,IEnumerable)"/>,
        /// or <see cref="HashAllProperties"/> --- 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.
        /// </summary>
        /// <param name="aSeed">The developing HashCode value or seed.</param>
        /// <param name="keyValuePair">The value to contribute.</param>
        /// <returns>The new hash code.</returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static int HashKeyAndValue<TKey, TValue>(this int aSeed, KeyValuePair<TKey, TValue> keyValuePair)
            => aSeed.Hash(keyValuePair.Key)
                    .Hash(keyValuePair.Value);

        /// <summary>
        /// NOTICE: this method is provided to contribute a collection of <see cref="KeyValuePair{TKey,TValue}"/>
        /// 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
        /// <see cref="Hash(int,object)"/>, <see cref="Hash(int,IEnumerable)"/>,
        /// or <see cref="HashAllProperties"/> --- 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.
        /// </summary>
        /// <param name="aSeed">The developing HashCode value or seed.</param>
        /// <param name="keyValuePairs">The values to contribute.</param>
        /// <returns>The new hash code.</returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static int HashKeysAndValues<TKey, TValue>(
                this int aSeed,
                IEnumerable<KeyValuePair<TKey, TValue>> keyValuePairs)
        {
            if (keyValuePairs == null)
                return aSeed.Hash(null);
            foreach (KeyValuePair<TKey, TValue> keyValuePair in keyValuePairs) {
                aSeed = aSeed.HashKeyAndValue(keyValuePair);
            }
            return aSeed;
        }
    }
}