Question

For a small set of key/value pairs (default 2, max 5), a Dictionary<TKey, TValue> seems like overkill. Is there a much simpler data structure that could be used in my case ? I’m caching computed values for certain objects (i.e. <MyClass, double>), so retrieval speed is important.

Thanks

Answer 1

A List<KeyValuePair<TKey, TValue>> (created with an appropriate capacity) would probably work just as well in this case… but it wouldn’t be terribly idiomatic. (Just to be clear, you’d simply call Equals on each key element, ignoring the hash code completely.) If List<T> feels a bit heavy to you, you could even go down to KeyValuePair<TKey, TValue>[] if you wanted. Ick, but hey… it’s your code.

Have you actually tried Dictionary<TKey, TValue> and found it to be too slow? “Seems like overkill” doesn’t seem nearly as good an argument as “I’ve tried it, profiled it, and found an unacceptable amount of my application’s time is spent creating dictionaries and looking up entries in them. I need my application to have performance characteristic X and at the moment I only have Y.”

If your key type has a particular ordering (and if you were going to perform more lookups on the data structure than you were going to create instances) you could sort the list, meaning you would have a maximum of 3 comparisons for any particular lookup. With only 5 entries you could even hard-code all the potential paths, if you were looking to optimize to the hilt. (You might even have different implementations for 2, 3, 4 and 5 elements. It’s getting a little silly at that point though.) This is basically a SortedList<TKey, TValue> implementation, but you may be able to optimize it a little for your scenario of only having a few entries. Again, it’s worth trying the built-in types first.

What’s vital is that you know how important this part of your code really is to your overall performance – and when it will be “good enough” so you can stop appropriately.