Bir nesnenin alanını genel bir Sözlük anahtarı olarak kullanma

Nesneleri a için anahtar olarak kullanmak istersem, Dictionaryonları belirli bir şekilde karşılaştırmak için hangi yöntemleri geçersiz kılmam gerekir?

Diyelim ki şu özelliklere sahip bir sınıfım var:

class Foo {
    public string Name { get; set; }
    public int FooID { get; set; }

    // elided
} 

Ve bir oluşturmak istiyorum:

Dictionary<Foo, List<Stuff>>

FooAynı FooIDolan nesnelerin aynı grup olarak kabul edilmesini istiyorum . FooSınıfta hangi yöntemleri geçersiz kılmam gerekecek ?

Özetlemek gerekirse: StuffNesneleri nesnelere göre gruplanmış listeler halinde kategorilere ayırmak istiyorum Foo. Stuffnesneler, FooIDonları kategorilerine bağlayacaktır.

Varsayılan olarak, iki önemli yöntem GetHashCode()ve Equals(). İki şey eşitse ( Equals()doğru döndürürse), aynı karma koda sahip olmaları önemlidir . Örneğin, "FooID'yi döndürebilirsiniz;" olarak GetHashCode()siz eşleşme olarak bu istiyorum. Ayrıca uygulayabilirsiniz IEquatable<Foo>, ancak bu isteğe bağlıdır:

class Foo : IEquatable<Foo> {
    public string Name { get; set;}
    public int FooID {get; set;}

    public override int GetHashCode() {
        return FooID;
    }
    public override bool Equals(object obj) {
        return Equals(obj as Foo);
    }
    public bool Equals(Foo obj) {
        return obj != null && obj.FooID == this.FooID;
    }
}

Son olarak, başka bir alternatif IEqualityComparer<T>de aynı şeyi yapmaktır.

FooIDGrubun tanımlayıcısı olmasını istediğinizden , bunu Foo nesnesi yerine sözlükte anahtar olarak kullanmalısınız:

Dictionary<int, List<Stuff>>

FooNesneyi anahtar olarak kullanırsanız, yalnızca özelliği dikkate almak için GetHashCodeve Equalsyöntemini uygularsınız FooID. NameKadarıyla özellik sadece ölü ağırlık olurdu Dictionaryendişeliydi, bu yüzden sadece kullanacağınız Foobir için sarıcı olarak int.

Bu nedenle, FooIDdeğeri doğrudan kullanmak daha iyidir ve o zaman Dictionaryzaten intbir anahtar olarak kullanmayı desteklediği için hiçbir şey uygulamanıza gerek kalmaz .

Düzenleme: Sınıfı yine de anahtar olarak
kullanmak istiyorsanız Foo, IEqualityComparer<Foo>uygulanması kolaydır:

public class FooEqualityComparer : IEqualityComparer<Foo> {
   public int GetHashCode(Foo foo) { return foo.FooID.GetHashCode(); }
   public bool Equals(Foo foo1, Foo foo2) { return foo1.FooID == foo2.FooID; }
}

Kullanımı:

Dictionary<Foo, List<Stuff>> dict = new Dictionary<Foo, List<Stuff>>(new FooEqualityComparer());

Foo için object.GetHashCode () ve object.Equals () 'i geçersiz kılmanız gerekir.

Sözlük, her değer için bir karma grubu hesaplamak için GetHashCode () 'u çağırır ve iki Foo'nun aynı olup olmadığını karşılaştırmak için Eşittir.

İyi hash kodlarını hesapladığınızdan emin olun (aynı hashcode'a sahip birçok eşit Foo nesnesinden kaçının), ancak iki eşit Foo'nun aynı hash koduna sahip olduğundan emin olun. Eşittir Yöntemi ve ardından (GetHashCode ()) x veya Eşittir'de karşılaştırdığınız her üyenin karma kodu ile başlamak isteyebilirsiniz.

public class Foo { 
     public string A;
     public string B;

     override bool Equals(object other) {
          var otherFoo = other as Foo;
          if (otherFoo == null)
             return false;
          return A==otherFoo.A && B ==otherFoo.B;
     }

     override int GetHashCode() {
          return 17 * A.GetHashCode() + B.GetHashCode();
     }
}

Peki ya Hashtablesınıf!

Hashtable oMyDic = new Hashtable();
Object oAnyKeyObject = null;
Object oAnyValueObject = null;
oMyDic.Add(oAnyKeyObject, oAnyValueObject);
foreach (DictionaryEntry de in oMyDic)
{
   // Do your job
}

Yukarıdaki şekilde, herhangi bir nesneyi (sınıf nesneniz) genel Sözlük anahtarı olarak kullanabilirsiniz :)

Ben de aynı sorunu yaşadım. Equals ve GetHashCode'u geçersiz kıldığı için artık denediğim herhangi bir nesneyi anahtar olarak kullanabilirim.

Eşittir (nesne obj) ve GetHashCode () geçersiz kılmalarının içinde kullanmak için yöntemlerle oluşturduğum bir sınıf. Nesnelerin çoğunu kapsayabilecek jenerikler ve bir karma algoritma kullanmaya karar verdim. Burada bazı nesne türleri için işe yaramayan bir şey görürseniz ve onu iyileştirmenin bir yolunu bulursanız lütfen bana bildirin.

public class Equality<T>
{
    public int GetHashCode(T classInstance)
    {
        List<FieldInfo> fields = GetFields();

        unchecked
        {
            int hash = 17;

            foreach (FieldInfo field in fields)
            {
                hash = hash * 397 + field.GetValue(classInstance).GetHashCode();
            }
            return hash;
        }
    }

    public bool Equals(T classInstance, object obj)
    {
        if (ReferenceEquals(null, obj))
        {
            return false;
        }
        if (ReferenceEquals(this, obj))
        {
            return true;
        }
        if (classInstance.GetType() != obj.GetType())
        {
            return false;
        }

        return Equals(classInstance, (T)obj);
    }

    private bool Equals(T classInstance, T otherInstance)
    {
        List<FieldInfo> fields = GetFields();

        foreach (var field in fields)
        {
            if (!field.GetValue(classInstance).Equals(field.GetValue(otherInstance)))
            {
                return false;
            }
        }

        return true;
    }

    private List<FieldInfo> GetFields()
    {
        Type myType = typeof(T);

        List<FieldInfo> fields = myType.GetTypeInfo().DeclaredFields.ToList();
        return fields;
    }
}

Sınıfta şu şekilde kullanılır:

public override bool Equals(object obj)
    {
        return new Equality<ClassName>().Equals(this, obj);
    }

    public override int GetHashCode()
    {
        unchecked
        {
            return new Equality<ClassName>().GetHashCode(this);
        }
    }