When would you use a List<KeyValuePair<T1, T2>> instead of a Dictionary<T1, T2>?

Question

What is the difference between a List of KeyValuePair and a Dictionary for the same types? Is there an appropriate time to use one or the other?

Answer 1

When you don't need fast lookups on key - maintaining the hashtable used by Dictionary has a certain overhead.

Answer 2

In short, the list does not enforce uniqueness of the key, so if you need that semantic then that's what you should use.

Answer 3

Dictionary is generic type that contains a collection of key-value pairs. Dictionary is fast for lookup operations, because is using hash function internally. That means, all the keys must be unique in dictionary.

Consider this examples:

List<KeyValuePair<int, string>> pairs = new List<KeyValuePair<int, string>>();
pairs.Add(new KeyValuePair<int, string>(1, "Miroslav"));
pairs.Add(new KeyValuePair<int, string>(2, "Naomi"));
pairs.Add(new KeyValuePair<int, string>(2, "Ingrid"));

Dictionary<int, string> dict = new Dictionary<int, string>();
dict.Add(1, "Miroslav");
dict.Add(2, "Naomi");
dict.Add(2, "Ingrid"); // System.ArgumentException: An item with the same key has already been added.

So you should always consider two at least two things:

1. Do you want to search concrete items in dictionary?
2. Do you want to have some fields non-unique (for example pairs: firstname/lastname).

Answer 4

The List would also be useful when you care about the order of the items.

Answer 5

Further to Phillip Ngan's answer, SOAP or otherwise, you cannot XML serialize objects that implements IDictionary.

Q: Why can't I serialize hashtables?

A: The XmlSerializer cannot process classes implementing the IDictionary interface. This was partly due to schedule constraints and partly due to the fact that a hashtable does not have a counterpart in the XSD type system. The only solution is to implement a custom hashtable that does not implement the IDictionary interface.

from here

Answer 6

In SOAP webservices for silverlight, we have found that Dictionary's do not serialize. This would be a situation where you would use a List of KeyValuePair over a Dictionary.

.

Answer 7

From http://blogs.msdn.com/bclteam/archive/2004/09/03/225473.aspx:

KeyValuePair vs. DictionaryEntry
[Krzysztof Cwalina]

We discussed a problem with implementation of IEnumerable on Dictionary<K,V>. What type should IEnumerable.GetEnumerator().Current return? KeyValuePair<K,V> or DictionaryEntry? Same for ICollection.CopyTo. Instances of what type should be copied to the array?

We decided the following: IEnumerable and ICollection interface implementations will use KeyValuePair<K,V> as the item type. IDictionary specific members (GetEnumerator returning IDictionaryEnumerator) will use DictionaryEntry as the item type.

The reason is that we are in a process of making a change where IEnumerator<T> would extend IEnumerator. It would be very strange if walking the hierarchy from Dictionary<K,V>->IEnumerable<T>->IEnumerable we suddenly changed the type of the item returned from enumerators.