Eşittir yöntemi geçersiz kılındığında GetHashCode'u geçersiz kılmak neden önemlidir?

Aşağıdaki sınıf verildi

public class Foo
{
    public int FooId { get; set; }
    public string FooName { get; set; }

    public override bool Equals(object obj)
    {
        Foo fooItem = obj as Foo;

        if (fooItem == null) 
        {
           return false;
        }

        return fooItem.FooId == this.FooId;
    }

    public override int GetHashCode()
    {
        // Which is preferred?

        return base.GetHashCode();

        //return this.FooId.GetHashCode();
    }
}

EqualsÇünkü s tablo Fooiçin bir satır temsil yöntemi geçersiz kılınmıştır Foo. Geçersiz kılmak için tercih edilen yöntem GetHashCodehangisidir?

Geçersiz kılmak neden önemlidir GetHashCode?

Evet, öğenizin bir sözlükte bir anahtar olarak mı yoksa HashSet<T>vb. Kullanılıp kullanılmayacağı önemlidir - çünkü bu (özel bir yokluğunda IEqualityComparer<T>) öğeleri gruplara ayırmak için kullanılır. İki öğenin karma kodu eşleşmezse, bunlar asla eşit kabul edilemez ( Eşittirler asla çağrılmaz).

GetHashCode () metodu yansıtmalıdır Equalsmantık; kurallar:

• iki şey (eşitse Equals(...) == true) o zaman gerekir için aynı değeri döndürürGetHashCode()
• Eğer GetHashCode()eşit, bunun değil onları aynı olması için gerekli olan; bu bir çarpışmadır ve Equalsgerçek bir eşitlik olup olmadığını görmek için çağrılır.

Bu durumda, " return FooId;" uygun bir GetHashCode()uygulama gibi görünüyor . Birden fazla özelliği test ediyorsanız, çapraz çarpışmaları azaltmak için bunları (örneğin new Foo(3,5), farklı bir karma kodu vardır new Foo(5,3)) aşağıdaki gibi kod kullanarak birleştirmek yaygındır :

unchecked // only needed if you're compiling with arithmetic checks enabled
{ // (the default compiler behaviour is *disabled*, so most folks won't need this)
    int hash = 13;
    hash = (hash * 7) + field1.GetHashCode();
    hash = (hash * 7) + field2.GetHashCode();
    ...
    return hash;
}

Oh - kolaylık için, ayrıca sağlayarak düşünebilirsiniz ==ve !=operatörler geçersiz kılmak için Equalsve GetHashCode.

Bunu yanlış anladığınızda ne olduğuna dair bir gösteri burada .

GetHashCode()Doğru bir şekilde uygulanması çok zordur, çünkü Marc'ın daha önce bahsettiği kurallara ek olarak, karma kodu bir nesnenin ömrü boyunca değişmemelidir. Bu nedenle, karma kodunu hesaplamak için kullanılan alanların değiştirilemez olması gerekir.

Nihayet NHibernate ile çalışırken bu soruna bir çözüm buldum. Benim yaklaşım nesnenin kimliğinden karma kodu hesaplamaktır. Kimlik yalnızca kurucudan ayarlanabilir, bu nedenle çok düşük bir olasılıkla kimliğini değiştirmek isterseniz, yeni bir kimliği ve dolayısıyla yeni bir karma kodu olan yeni bir nesne oluşturmanız gerekir. Bu yaklaşım GUID'lerle en iyi şekilde çalışır, çünkü rastgele bir kimlik oluşturan parametresiz bir kurucu sağlayabilirsiniz.

Eşittirleri geçersiz kılarak temel olarak, belirli bir türün iki örneğini nasıl karşılaştıracağınızı daha iyi bilen kişi olduğunuzu belirlersiniz, bu nedenle en iyi karma kodunu sağlamak için en iyi aday olmanız muhtemeldir.

Bu, ReSharper'ın sizin için GetHashCode () işlevini nasıl yazdığına bir örnektir:

public override int GetHashCode()
{
    unchecked
    {
        var result = 0;
        result = (result * 397) ^ m_someVar1;
        result = (result * 397) ^ m_someVar2;
        result = (result * 397) ^ m_someVar3;
        result = (result * 397) ^ m_someVar4;
        return result;
    }
}

Gördüğünüz gibi, sınıftaki tüm alanlara dayalı olarak iyi bir karma kodu tahmin etmeye çalışır, ancak nesnenizin etki alanını veya değer aralıklarını bildiğiniz için daha iyi bir kod sağlayabilirsiniz.

Lütfen nullgeçersiz kılma sırasında obj parametresini kontrol etmeyi unutmayın Equals(). Ve ayrıca türü karşılaştırın.

public override bool Equals(object obj)
{
    Foo fooItem = obj as Foo;

    if (fooItem == null)
    {
       return false;
    }

    return fooItem.FooId == this.FooId;
}

Bunun nedeni: Equalsile karşılaştırıldığında yanlış döndürmelidir null. Ayrıca bkz. Http://msdn.microsoft.com/en-us/library/bsc2ak47.aspx

Nasıl olur:

public override int GetHashCode()
{
    return string.Format("{0}_{1}_{2}", prop1, prop2, prop3).GetHashCode();
}

Performansın bir sorun olmadığını varsaymak :)

Başa çıkmak için iki sorunumuz var.

1. GetHashCode()Nesnedeki herhangi bir alan değiştirilebilirse, mantıklı bir bilgi sağlayamazsınız . Ayrıca genellikle bağımlı bir koleksiyonda ASLA bir nesne kullanılmayacaktır GetHashCode(). Dolayısıyla, uygulamanın maliyeti GetHashCode()genellikle buna değmez veya mümkün değildir.

2. Birisi nesnenizi çağıran bir koleksiyona koyarsa GetHashCode()ve doğru bir şekilde davranmadan Equals()da geçersiz kıldığınızda GetHashCode(), o kişi sorunu izlemek için günler geçirebilir.

Bu yüzden varsayılan olarak yaparım.

public class Foo
{
    public int FooId { get; set; }
    public string FooName { get; set; }

    public override bool Equals(object obj)
    {
        Foo fooItem = obj as Foo;

        if (fooItem == null)
        {
           return false;
        }

        return fooItem.FooId == this.FooId;
    }

    public override int GetHashCode()
    {
        // Some comment to explain if there is a real problem with providing GetHashCode() 
        // or if I just don't see a need for it for the given class
        throw new Exception("Sorry I don't know what GetHashCode should do for this class");
    }
}

Bunun nedeni, çerçevenin aynı olan iki nesnenin aynı karma koduna sahip olmasını gerektirmesidir. İki nesnenin özel bir karşılaştırmasını yapmak için eşittir yöntemini geçersiz kılarsanız ve iki nesne yöntemle aynı kabul edilirse, iki nesnenin karma kodunun da aynı olması gerekir. (Sözlükler ve Hashtables bu ilkeye dayanır).

Sadece yukarıdaki cevapları eklemek için:

Eşittirleri geçersiz kılmazsanız, varsayılan davranış, nesnelerin başvurularının karşılaştırılmasıdır. Aynı durum karma kod için de geçerlidir - varsayılan uygulama genellikle başvurunun bellek adresini temel alır. Eşittirleri geçersiz kıldığınızdan, doğru davranış, başvurularda değil Eşitlerde uyguladığınız her şeyi karşılaştırmak anlamına gelir, bu nedenle hashcode için aynısını yapmanız gerekir.

Sınıfınızın istemcileri, hashcode'un eşittir yöntemine benzer bir mantığa sahip olmasını bekler, örneğin bir IEqualityComparer kullanan linq yöntemleri önce hashcode'ları karşılaştırır ve yalnızca eşit olduklarında daha pahalı olabilecek Equals () yöntemini karşılaştırırlar hashcode uygulamazsak, eşit nesnenin muhtemelen farklı hashcode'ları olacaktır (çünkü farklı bellek adresleri vardır) ve yanlış olarak eşit olarak belirlenir (Eşittir () bile vurulmaz).

Buna ek olarak, bir sözlükte kullandıysanız nesnenizi bulamayabileceğiniz sorun dışında (bir hashcode tarafından eklendiğinden ve aradığınızda varsayılan hashcode muhtemelen farklı ve yine Eşittir () Marc Gravell'in cevabında açıkladığı gibi, aynı anahtarlara izin vermemesi gereken sözlük veya hashset kavramını da ihlal ediyorsunuz - Eşit değerleri aştığınızda bu nesnelerin temelde aynı olduğunu zaten beyan ettiniz, böylece Her ikisinin de benzersiz bir anahtarı olduğu düşünülen bir veri yapısında farklı anahtarlar olmasını istemezler, ancak farklı bir karma kodları olduğundan "aynı" anahtar farklı anahtar olarak eklenir.

Hash kodu, Dictionary, Hashtable, HashSet vb. Gibi karma tabanlı koleksiyonlar için kullanılır. Bu kodun amacı, belirli bir nesneyi belirli bir gruba (kova) koyarak çok hızlı bir şekilde önceden sıralamaktır. Bu ön sıralama, hash-koleksiyonundan geri almanız gerektiğinde bu nesneyi bulmanıza çok yardımcı olur, çünkü kod, nesnenizi tüm nesneler yerine yalnızca bir kovada aramak zorundadır. Karma kodların daha iyi dağılımı (daha iyi benzersizlik) daha hızlı geri alma. Her nesnenin benzersiz bir karma koduna sahip olduğu ideal durumda, onu bulmak O (1) işlemidir. Çoğu durumda O (1) 'e yaklaşır.

Mutlaka önemli değildir; koleksiyonlarınızın boyutuna ve performans gereksinimlerinize ve sınıfınızın performans gereksinimlerini bilmediğiniz bir kütüphanede kullanılıp kullanılmayacağına bağlıdır. Koleksiyon boyutlarının çok büyük olmadığını ve zamanımın mükemmel bir karma kodu oluşturarak elde edilen birkaç mikrosaniye performanstan daha değerli olduğunu sık sık biliyorum; yani (derleyici tarafından rahatsız edici uyarı kurtulmak için) Ben sadece kullanın:

   public override int GetHashCode()
   {
      return base.GetHashCode();
   }

(Tabii ki uyarıyı da kapatmak için #pragma kullanabilirim ama bu yolu tercih ederim.)

Eğer konumda olduğunda bunu yapmak Burada elbette uygulamak başkaları tarafından bahsedilen sorunların hepsinden daha performansı gerekir. En önemlisi - aksi takdirde, bir karma kümesinden veya sözlükten öğe alırken yanlış sonuçlar alırsınız: karma kodu, nesnenin yaşam süresine göre değişmemelidir (daha doğru, karma kodunun gerektiği zaman, örneğin, sözlükte bir anahtar)): örneğin, Değer herkese açık olduğu için aşağıdakiler yanlıştır ve bu nedenle örneğin yaşam süresi boyunca sınıfa harici olarak değiştirilebilir, bu nedenle hash kodu için temel olarak kullanmamalısınız:

   class A
   {
      public int Value;

      public override int GetHashCode()
      {
         return Value.GetHashCode(); //WRONG! Value is not constant during the instance's life time
      }
   }    

Öte yandan, Değer değiştirilemezse kullanmakta fayda vardır:

   class A
   {
      public readonly int Value;

      public override int GetHashCode()
      {
         return Value.GetHashCode(); //OK  Value is read-only and can't be changed during the instance's life time
      }
   }

İki nesne Eşittir () ile tanımlandığı gibi eşitse, aynı karma kodunu döndürmeleri gerektiğini her zaman garanti etmelisiniz. Diğer yorumların bazılarının belirttiği gibi, teoride, nesne HashSet veya Dictionary gibi karma tabanlı bir kapta asla kullanılmayacaksa, bu zorunlu değildir. Yine de bu kurala uymanızı tavsiye ederim. Bunun nedeni, basitçe performansı gerçekten artırmak veya kod anlambilimini daha iyi bir şekilde iletmek amacıyla bir koleksiyonu bir türden diğerine değiştirmek için çok kolay olmasıdır.

Örneğin, bazı nesneleri Listede tuttuğumuzu varsayalım. Bir süre sonra birisi, örneğin daha iyi arama özellikleri nedeniyle bir HashSet'in çok daha iyi bir alternatif olduğunu fark eder. İşte o zaman başımız belaya girebilir. Liste, HashSet GetHashCode () yöntemini kullanırken durumunuzda Eşittir anlamına gelen tür için varsayılan eşitlik karşılaştırıcısını dahili olarak kullanır. İkisi farklı davranırsa, programınız da farklı davranır. Ayrıca, bu tür sorunların giderilmesinin en kolay yolu olmadığını unutmayın.

Bu davranışı, daha fazla örnek ve açıklama bulabileceğiniz bir blog yayınında diğer bazı GetHashCode () tuzaklarıyla özetledim .

İtibariyle .NET 4.7geçersiz kılma için tercih edilen bir yöntem GetHashCode()aşağıda gösterilmiştir. Daha eski .NET sürümlerini hedefliyorsanız, System.ValueTuple nuget paketini ekleyin .

// C# 7.0+
public override int GetHashCode() => (FooId, FooName).GetHashCode();

Performans açısından, bu yöntem birçok karma karma kod uygulamasından daha iyi performans gösterecektir . ValueTuple bir olduğunu structbu nedenle herhangi bir çöp olmayacak ve altta yatan algoritma kadar hızlı o alır gibi olduğunu.

Anladığım kadarıyla orijinal GetHashCode () nesnenin bellek adresini döndürüyor, bu nedenle iki farklı nesneyi karşılaştırmak istiyorsanız geçersiz kılmak önemlidir.

DÜZENLENMİŞ: Bu yanlıştı, özgün GetHashCode () yöntemi 2 değerin eşitliğini sağlayamaz. Eşit olan nesneler aynı karma kodu döndürür.

Aşağıda yansımayı kullanmak bana kamu mülkleri göz önüne alındığında daha iyi bir seçenek gibi görünüyor, çünkü bununla mülklerin eklenmesi / kaldırılması konusunda endişelenmenize gerek yok (çok yaygın olmasa da). Ben de daha iyi performans buldum. (Diagonistics kronometre kullanarak karşılaştırıldığında zaman).

    public int getHashCode()
    {
        PropertyInfo[] theProperties = this.GetType().GetProperties();
        int hash = 31;
        foreach (PropertyInfo info in theProperties)
        {
            if (info != null)
            {
                var value = info.GetValue(this,null);
                if(value != null)
                unchecked
                {
                    hash = 29 * hash ^ value.GetHashCode();
                }
            }
        }
        return hash;  
    }