Utilisation du champ d'un objet comme clé de dictionnaire générique

Si je veux utiliser des objets comme clés pour un Dictionary , quelles méthodes devrai-je remplacer pour les comparer d'une manière spécifique?

Disons que j'ai une classe qui a des propriétés:

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

    // elided
} 

Et je veux créer un:

Dictionary<Foo, List<Stuff>>

Je veux que les Fooobjets avec le même FooIDsoient considérés comme le même groupe. Quelles méthodes dois-je remplacer dans la Fooclasse?

Pour résumer: je souhaite classer les Stuffobjets en listes, groupées par Fooobjets. Stuffles objets auront un FooIDpour les lier à leur catégorie.

Par défaut, les deux méthodes importantes sont GetHashCode()et Equals(). Il est important que si deux choses sont égales ( Equals()renvoie vrai), qu'elles aient le même code de hachage. Par exemple, vous pouvez "retourner FooID;" comme GetHashCode()si vous voulez que ce soit le match. Vous pouvez également implémenter IEquatable<Foo>, mais cela est facultatif:

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;
    }
}

Enfin, une autre alternative est de fournir un IEqualityComparer<T>pour faire de même.

Comme vous voulez que le FooIDsoit l'identificateur du groupe, vous devez l'utiliser comme clé dans le dictionnaire au lieu de l'objet Foo:

Dictionary<int, List<Stuff>>

Si vous utilisiez l' Fooobjet comme clé, vous implémenteriez simplement la méthode GetHashCodeand Equalspour ne considérer que la FooIDpropriété. La Namepropriété serait juste un poids mort en ce qui Dictionaryconcerne le, donc vous ne l'utiliseriez Fooque comme wrapper pour un fichier int.

Par conséquent, il est préférable d'utiliser la FooIDvaleur directement, et vous n'avez alors rien à implémenter car le Dictionaryprend déjà en charge l'utilisation de an intcomme clé.

Edit:
Si vous voulez Fooquand même utiliser la classe comme clé, le IEqualityComparer<Foo>est facile à implémenter:

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; }
}

Usage:

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

Pour Foo, vous devrez remplacer object.GetHashCode () et object.Equals ()

Le dictionnaire appellera GetHashCode () pour calculer un compartiment de hachage pour chaque valeur et Equals pour comparer si deux Foo sont identiques.

Assurez-vous de calculer de bons codes de hachage (évitez que de nombreux objets Foo égaux aient le même hashcode), mais assurez-vous que deux Foos égaux ont le même code de hachage. Vous voudrez peut-être commencer par la méthode Equals, puis (dans GetHashCode ()) xou le code de hachage de chaque membre que vous comparez dans Equals.

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();
     }
}

Et la Hashtableclasse!

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

De la manière ci-dessus, vous pouvez utiliser n'importe quel objet (votre objet de classe) comme clé de dictionnaire générique :)

J'ai eu le même problème. Je peux maintenant utiliser n'importe quel objet que j'ai essayé comme clé en raison de la substitution de Equals et GetHashCode.

Voici une classe que j'ai construite avec des méthodes à utiliser à l'intérieur des substitutions de Equals (object obj) et GetHashCode (). J'ai décidé d'utiliser des génériques et un algorithme de hachage qui devrait pouvoir couvrir la plupart des objets. Veuillez me faire savoir si vous voyez quelque chose ici qui ne fonctionne pas pour certains types d'objets et que vous avez un moyen de l'améliorer.

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;
    }
}

Voici comment il est utilisé dans une classe:

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

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