Kann ich eine Liste von Objekten als Dictionary-Schlüssel verwenden?

Question

// No overrides required .. let CLR take care of equal and hashcode. 
Class Foo {public Name{get; set;} public Address{get; set;}} 

Dictionary<List<Foo>, int> map = new Dictionary<List<Foo>, int>(); 

Frage:

Ist dieser Code in Ordnung aussehen? Ich verstehe, dass Foo, um ein Schlüssel in der Map zu sein, Gleichheiten und Hashcode-Methoden überschreiben muss - entweder überschreiben oder keine.

Ich fragte mich, was ist mit Liste von Objekten als Schlüssel? Was bedeutet Gleichheit, wenn es um List geht? Ist die oben definierte Karte sicher vor dem "object-lost-in-the-map" -Problem?

-Karephul

Answer 1

List<int> a = new List<int>(1, 2, 3); 
List<int> b = new List<int>(1, 2, 3); //different instance than a 

Dictionary<List<int>, int>> map = new Dictionary<List<int>, int>>(); 
map.Add(a, a.Sum()); 
int aSum = map[b]; //KeyNotFoundException because this is a different instance. 


HashSet<int> a = new HashSet<int>(1, 2, 3); 
HashSet<int> b = new HashSet<int>(1, 2, 3); //different instance than a 

Dictionary<HashSet<int>, int>> map1 = new Dictionary<HashSet<int>, int>>(); 
map1.Add(a, a.Sum()); 
int aSum = map1[b]; //KeyNotFoundException because this is a different instance. 


HashSet<int> a = new HashSet<int>(1, 2, 3); 
HashSet<int> b = new HashSet<int>(1, 2, 3); //different instance than a 

Dictionary<HashSet<int>, int>> map2 = new Dictionary<HashSet<int>, int>> 
    (HashSet<int>.CreateSetComparer()); //instance comparison not used - equal sets are equal 
map2.Add(a, a.Sum()); 
int aSum = map2[b]; //6 

Answer 2

Dies funktioniert nur, wenn Sie die ursprünglichen List<T> Instanzen als Schlüssel verwenden.
Wenn Sie ein neues List<T> mit den gleichen Elementen erstellen, wird es nicht als derselbe Schlüssel behandelt, da List<T>Equals() und GetHashCode() nicht überschreibt.

Mit anderen Worten, es wird Referenzgleichheit verwendet. Wenn Sie das ändern möchten, können Sie eine IEqualityComparer<List<T>> schreiben.

Answer 3

Sicher, man könnte , aber das würde unglaublich begrenzt werden. Einfach gesagt, eine Liste einer Kombination von Foo, auch wenn die Listenelemente alle gleich sind Foo, ist nicht notwendigerweise die gleiche List<Foo>. Sie müssen also die Referenzen in nicht eindeutiger Weise beibehalten, um sicherzustellen, dass der Schlüssel derselbe ist, oder eine komplizierte Schlüsselübereinstimmungsfunktion ausführen.

Es wäre weit, weit besser, einfach einen besseren Schlüsseltyp zu verwenden.