GetHashCode renvoie la même valeur pour différents objets. Existe-t-il une méthode pour identifier un objet par des propriétés particulières?

GetHashCode renvoie une valeur qui dépend de l'implémentation. Sa conception particulière convient à l'utilisation "standard" et n'a de sens que pendant la durée de vie d'une application. L'algorithme par défaut n'est pas conçu pour éviter les collisions.

La méthode GetHashCode n'est pas conçue pour être unique pour chaque instance.

Votre approche repose sur la composition du hachage de chaque colonne. Un code de hachage doit satisfaire certaines exigences, par exemple la distribution dans le domaine. Cependant, il n'est pas garanti que la composition préserve ces propriétés et exigences: plus vous ajoutez de colonnes, plus les collisions pourraient être "étranges".

De plus, vous invoquez value.GetHashCode () qui empêche une opération de boxe. Comme suggéré par johey, vous devez utiliser la méthode RuntimeHelpers.GetHashCode () car elle interprète l'objet comme une valeur avant de calculer le hachage.

Les structures de données .NET sont conçues pour gérer les collisions en interne, par exemple, IDictionary utilise le hachage pour sélectionner un compartiment, puis analyse séquentiellement le compartiment.

Je veux écrire ici ma solution. Tout ce qui a été dit est vrai mais pas exactement. Je veux collecter le sujet ici.

GetHashCode donne toujours la même valeur pour les objets identiques. Les valeurs de GetHashCode peuvent toujours ne pas appartenir aux différents objets.

Les valeurs de GetHashCode sont donc d'abord comparées pour améliorer les performances, puis passez à l'étape suivante pour comparer des objets s'il y a la même valeur de GetHashCode .

J'ai créé un IEqualityComparer.

private class CustomEqualityComparer<T> : IEqualityComparer<T>
    {

        private readonly List<string> _columns;
        private readonly bool _enableHashCode;
        private readonly ConcurrentDictionary<string, Func<T, object>> _cache;
        public CustomEqualityComparer(List<string> columns, ConcurrentDictionary<string, Func<T, object>> cache, bool enableHashCode = false)
        {
            _columns = columns;
            _enableHashCode = enableHashCode;
            _cache = cache;
        }

        public bool Equals(T x, T y)
        {
            for (var i = 0; i < _columns.Count; i++)
            {
                object value1 = GetValue(x, _columns[i], _cache);
                object value2 = GetValue(y, _columns[i], _cache);
                if (!value1.Equals(value2)) return false;
            }

            return true;
        }

        public int GetHashCode(T obj)
        {
            return _enableHashCode ? GetHashCode(obj, _columns, _cache) : 0;
        }

        private object GetValue(object item, string propertyName, ConcurrentDictionary<string, Func<T, object>> cache)
        {
            if (!cache.TryGetValue(propertyName, out Func<T, object> propertyResolver))
            {
                ParameterExpression arg = Expression.Parameter(item.GetType(), "x");
                Expression expr = Expression.Property(arg, propertyName);
                UnaryExpression unaryExpression = Expression.Convert(expr, typeof(object));
                propertyResolver = Expression.Lambda<Func<T, object>>(unaryExpression, arg).Compile();
                cache.TryAdd(propertyName, propertyResolver);
            }

            return propertyResolver((T)item);
        }

        private int GetHashCode(T obj, List<string> columns, ConcurrentDictionary<string, Func<T, object>> cache)
        {
            unchecked
            {
                var hashCode = 17;

                for (var i = 0; i < columns.Count; i++)
                {
                    object value = GetValue(obj, columns[i], cache);
                    var tempHashCode = value == null ? 0 : value.GetHashCode();
                    hashCode = hashCode * 23 + tempHashCode;
                }

                return hashCode;
            }
        }
    }