Is there a generic collection with a key/value pair where key can occur more than once?

Question

I want to use a generic collection like Dictionary, but Dictionary requires that every key be unique. I have multiple values for the same "key", so I need a generic collection that will allow for that.

I realize that this makes the key no longer really a key, but I don't know what else to call it.

Answer 1

Several options for you to consider:

• use a Dictionary<TKey, List<TValue>> — keep a list of values for each key, not preventing duplicate values for the same key (i.e. duplicate pairs);
• use a Dictionary<TKey, HashSet<TValue>> — keep a set of value for each key, preventing duplicate values for the same key;
• use a List<KeyValuePair<TKey, TValue>> — keep a list of pair, not preventing duplicate values for the same key.

Note that in the latter case KeyValuePair is a struct, not a class, hence that implies a bit different handling.

The right option depends on your actual use case.

Answer 2

Try Dictionary<KeyType,List<ValueType>>.

You can create a custom dictionary which wraps this dictionary to handle all the required logic upon adding and removing.

Answer 3

You can create a Dictionary<TKey,List<TValue>> and do the manual work yourself, but there is no "multi-dictionary" collection by default.

That said, if you have an IEnumerable you can convert it to a lookup which is like what you described, but can't be constructed by itself (have to call ToLookup() to create from enumeration).

Answer 4

For your value, you could store a list of whatever it is you want to hold.

Answer 5

In C++, such a collection is called a multimap. A quick search for that term revealed this related question:

multimap in .NET

Answer 6

In .NET 3.5 and above, that is ILookup<TKey,TValue>. Unfortunately the only provided implementation is the immutable Lookup<TKey,TValue>, however it is easy to re-implement. An EditableLookup<TKey,TValue> is included in MiscUtil.

With an ILookup<TKey,TValue>, the TKey indexer returns an IEnumerable<TValue> (even if there were no matches for that key), so typical usage is:

foreach(var value in lookup[key])
    DoSomethingWith(value);