GetHashCode ręczne obiektu zawierający ogólne tablicy

Question

I klasy, który zawiera dwie następujące właściwości:

public int Id  { get; private set; } 
public T[] Values { get; private set; } 

dokonaniu to IEquatable<T> i nadpisane object.Equals tak:

public override bool Equals(object obj) 
{ 
    return Equals(obj as SimpleTableRow<T>); 
} 

public bool Equals(SimpleTableRow<T> other) 
{ 
    // Check for null 
    if(ReferenceEquals(other, null)) 
     return false; 

    // Check for same reference 
    if(ReferenceEquals(this, other)) 
     return true; 

    // Check for same Id and same Values 
    return Id == other.Id && Values.SequenceEqual(other.Values); 
} 

Kiedy o obejście object.Equals Oczywiście muszę również zastąpić GetHashCode. Ale jaki kod powinienem zaimplementować? Jak utworzyć hashcode z ogólnej tablicy? I jak połączyć go z liczbą całkowitą Id?

public override int GetHashCode() 
{ 
    return // What? 
} 

Answer 1

powodu problemów poruszonych w tym wątku, jestem delegowania kolejną odpowiedź pokazując, co się stanie, jeśli źle zrobisz ... głównie, że nie możesz użyć tablicy GetHashCode(); prawidłowe zachowanie polega na tym, że żadne ostrzeżenia nie są drukowane po uruchomieniu ...przełączyć komentarze to naprawić:

using System; 
using System.Collections.Generic; 
using System.Linq; 
static class Program 
{ 
    static void Main() 
    { 
     // first and second are logically equivalent 
     SimpleTableRow<int> first = new SimpleTableRow<int>(1, 2, 3, 4, 5, 6), 
      second = new SimpleTableRow<int>(1, 2, 3, 4, 5, 6); 

     if (first.Equals(second) && first.GetHashCode() != second.GetHashCode()) 
     { // proven Equals, but GetHashCode() disagrees 
      Console.WriteLine("We have a problem"); 
     } 
     HashSet<SimpleTableRow<int>> set = new HashSet<SimpleTableRow<int>>(); 
     set.Add(first); 
     set.Add(second); 
     // which confuses anything that uses hash algorithms 
     if (set.Count != 1) Console.WriteLine("Yup, very bad indeed"); 
    } 
} 
class SimpleTableRow<T> : IEquatable<SimpleTableRow<T>> 
{ 

    public SimpleTableRow(int id, params T[] values) { 
     this.Id = id; 
     this.Values = values; 
    } 
    public int Id { get; private set; } 
    public T[] Values { get; private set; } 

    public override int GetHashCode() // wrong 
    { 
     return Id.GetHashCode()^Values.GetHashCode(); 
    } 
    /* 
    public override int GetHashCode() // right 
    { 
     int hash = Id; 
     if (Values != null) 
     { 
      hash = (hash * 17) + Values.Length; 
      foreach (T t in Values) 
      { 
       hash *= 17; 
       if (t != null) hash = hash + t.GetHashCode(); 
      } 
     } 
     return hash; 
    } 
    */ 
    public override bool Equals(object obj) 
    { 
     return Equals(obj as SimpleTableRow<T>); 
    } 
    public bool Equals(SimpleTableRow<T> other) 
    { 
     // Check for null 
     if (ReferenceEquals(other, null)) 
      return false; 

     // Check for same reference 
     if (ReferenceEquals(this, other)) 
      return true; 

     // Check for same Id and same Values 
     return Id == other.Id && Values.SequenceEqual(other.Values); 
    } 
} 

Answer 2

public override int GetHashCode() { 
    return Id.GetHashCode()^Values.GetHashCode(); 
} 

---

Istnieje kilka dobrych punktów w komentarzach i innych odpowiedzi. PO powinien rozważyć, czy wartości będą używane jako część "klucza", jeśli obiekt był używany jako klucz w słowniku. Jeśli tak, to powinny być częścią kodu skrótu, w przeciwnym razie nie.

Z drugiej strony, nie jestem pewien, dlaczego metoda GetHashCode powinna odzwierciedlać SequenceEqual. Ma na celu obliczenie indeksu w tabeli mieszania, a nie całkowite wyznaczenie równości. Jeśli istnieje wiele kolizji tabel mieszania przy użyciu powyższego algorytmu i jeśli różnią się one sekwencją wartości, należy wybrać algorytm uwzględniający sekwencję. Jeśli kolejność nie ma znaczenia, oszczędzaj czas i nie bierz tego pod uwagę.

Answer 3

chciałbym zrobić to w ten sposób:

long result = Id.GetHashCode(); 
foreach(T val in Values) 
    result ^= val.GetHashCode(); 
return result; 

Answer 4

dostarczonego że Id i wartości nigdy nie zmieni, a wartości nie jest zerowa ...

public override int GetHashCode() 
{ 
    return Id^Values.GetHashCode(); 
} 

pamiętać, że klasa nie jest niezmienna, ponieważ każdy może modyfikować zawartość wartości, ponieważ jest to tablica. Biorąc to pod uwagę, nie starałbym się generować kodu hashcode za pomocą jego zawartości.

Answer 5

Jak o czymś takim:

public override int GetHashCode() 
    { 
     int hash = Id; 
     if (Values != null) 
     { 
      hash = (hash * 17) + Values.Length; 
      foreach (T t in Values) 
      { 
       hash *= 17; 
       if (t != null) hash = hash + t.GetHashCode(); 
      } 
     } 
     return hash; 
    } 

ten powinien być zgodny z SequenceEqual, zamiast robić porównania odniesienia na tablicy.

Answer 6

FWIW, bardzo niebezpieczne jest używanie zawartości wartości w haszowaniu. Powinieneś to zrobić tylko wtedy, gdy możesz zagwarantować, że nigdy się nie zmieni. Jednakże, ponieważ jest narażony, nie sądzę, że zagwarantowanie tego jest możliwe. Kod skrótu obiektu nigdy nie powinien się zmieniać. W przeciwnym razie traci swoją wartość jako klucz w Hashtable lub Dictionary. Weź pod uwagę trudny do znalezienia błąd użycia obiektu jako klucza w HashTable, jego zmiany hashcode ze względu na wpływ zewnętrzny i nie możesz go już znaleźć w HashTable!

Answer 7

Ponieważ hashCode jest trochę kluczem do przechowywania przedmiotów (lllike w hashtable), chciałbym użyć tylko Id.GetHashCode()

Answer 8

Znam ten wątek jest dość stary, ale napisałem tę metodę, aby umożliwić mi obliczyć hashcodes z wielu obiektów. To bardzo pomocne w tym przypadku. Nie jest doskonały, ale spełnia moje potrzeby i najprawdopodobniej również twoje.

Nie mogę tego naprawdę wziąć za zasługę. Dostałem tę koncepcję z niektórych implementacji .net gethashcode. Używam 419 (ostatecznie, to mój ulubiony duży prime), ale możesz wybrać prawie każdą rozsądną liczbę pierwszą (nie za małą ... nie za dużą).

Więc, oto jak dostanę moje hashcodes:

using System.Collections.Generic; 
using System.Linq; 

public static class HashCodeCalculator 
{ 
    public static int CalculateHashCode(params object[] args) 
    { 
     return args.CalculateHashCode(); 
    } 

    public static int CalculateHashCode(this IEnumerable<object> args) 
    { 
     if (args == null) 
      return new object().GetHashCode(); 

     unchecked 
     { 
      return args.Aggregate(0, (current, next) => (current*419)^(next ?? new object()).GetHashCode()); 
     } 
    } 
} 

Answer 9

po prostu musiałem dodać kolejną odpowiedź, ponieważ jeden z bardziej oczywiste (i najłatwiejszym do wdrożenia) rozwiązania nie zostały wymienione - nie licząc zbiorów w twojej GetHashCode obliczenie!

Najważniejszą rzeczą, o której zapomniałem, jest to, że niepowtarzalność wyniku GetHashCode nie jest wymagana (lub w wielu przypadkach nawet jest to możliwe). Nierówne obiekty nie muszą zwracać nierównych kodów skrótu, jedynym wymaganiem jest to, że równe obiekty zwracają równe kody skrótu. Więc o tej definicji, co następuje realizacja GetHashCode jest poprawna dla wszystkich obiektów (zakładając, że jest to poprawne Equals realizacja):

public override int GetHashCode() 
{ 
    return 42; 
} 

Oczywiście byłoby to wydajność najgorszą możliwą wydajność w hashtable odnośnika, O (n) zamiast O (1), ale nadal jest funkcjonalnie poprawny. Z tego względu moją ogólną rekomendacją podczas implementacji GetHashCode dla obiektu, który ma kolekcję dowolnego typu jako jednego lub więcej jej członków, jest po prostu zignorowanie ich i obliczenie wartości GetHashCode wyłącznie na podstawie pozostałych elementów skalarnych. To mogłoby działać całkiem dobrze, z wyjątkiem sytuacji, gdy wstawisz do tabeli mieszania ogromną liczbę obiektów, w których wszystkie ich elementy skalarne mają identyczne wartości, co daje identyczne kody skrótu.

Ignorowanie elementów kolekcji podczas obliczania kodu skrótu może również poprawić wydajność, pomimo zmniejszenia rozkładu wartości kodu skrótu. Pamiętaj, że użycie kodu skrótu ma poprawić wydajność w tabeli mieszania, nie wymagając połączenia z numerem Equals N, a zamiast tego będzie wymagać tylko raz wywołania GetHashCode i szybkiego sprawdzania tablicy hash. Jeśli każdy obiekt ma wewnętrzną tablicę zawierającą 10 000 elementów, które wszystkie uczestniczą w obliczaniu kodu skrótu, wszelkie korzyści uzyskane przez dobrą dystrybucję zostaną prawdopodobnie utracone. Byłoby lepiej mieć nieznacznie mniej rozproszonego kodu skrótu, jeśli generowanie go jest znacznie mniej kosztowne.