Последовательное хеширование структуры до 32 бит

Если у вас было следующее:

struct 
{
    int A;
    int B;
    int C;
}

Предполагая, что A, B, C находятся в диапазоне [1, 1000]. Можно создать «идеальный хэш» (без коллизий), поскольку A, B, C могут иметь каждые 1000 различных возможных значений. Действительно, log2(1000^3) <= 32 (1000^3 — это количество возможных значений структуры, а log2 используется для получения количества битов, необходимых для хранения всех этих значений без коллизий, а 32 — это количество битов целого числа).

int MyHashCode()
{
    return 1000 * (1000 * (A - 1) + (B - 1)) + (C - 1);  // There is no overflow or collision since A, B, C are in the range [1, 1000]
}

Мы можем упростить его, используя более слабое условие: A, B, C находятся в диапазоне [0, 1000]:

int MyHashCode()
{
    return 1001 * (1001 * A + B) + C;  // There is no overflow or collision since A, B, C are in the range [0, 1000]
}

Обновлять

Учитывая, что ваша структура содержит строку внутри нее. То, чего вы хотите достичь, невозможно. Потому что строка может представлять бесконечное количество значений.

Если бы это было возможно, можно было бы создать очень мощный алгоритм сжатия. Это может хранить любой файл в... 32-битном числе! Математически это происходит из-за того, что инъективная функция может отображать только большее пространство.

Анонимные типы имеют автогенерированную разумную GetHashCode() реализацию. Я бы попробовал просто использовать:

struct MyStruct 
{
    int _intField1;
    int _intField2;
    int _intField3;
    string _stringField;

    public long GetHashCode() 
    {
        return new { _intField1, _intField2, _intField3, _stringField }.GetHashCode();
    }
}

Поскольку и int, и string являются неизменяемыми типами, хэш-код должен оставаться одним и тем же между запусками приложения, если базовая версия платформы .NET остается неизменной. (Это может быть или не быть «достаточно стойким».)

Тем не менее, это может измениться, если изменится внутренняя реализация GetHashCode(). В этом случае используйте криптографический хэш. Неважно, что он превышает 32 бита, потому что криптографические хэши предназначены для получения совершенно разных результатов при небольших изменениях ввода. Это означает, что для двух разных входных данных любые заданные 32 бита хеш-кода вряд ли будут равны. Просто используйте BitConverter.ToInt32() для преобразования любой части хэша, которую вы хочу int.

Кроме того, очевидно, что это сделает несколько маловероятным, что две разные структуры будут генерировать разные хеш-коды. (Это можно определить, используя приблизительную формулу парадокса дня рождения, если я правильно читаю вики, это означает, что у вас будет 10% шанс получить дубликаты, когда вы сохраните ~140 000 ~30 000 записей. , Предполагая, что криптографический хеш имеет идеальные свойства. Я не уверен, что вы можете добиться большего успеха без идеального хэша.)

1. Сериализуйте свой тип в байт []
2. Примените общий хеш-алгоритм к байту [], чтобы получить хэш-байт []
3. Вытащите, например, первые 32 бита байта хеша [] и используйте это