Question

I’m aware that exception trapping can be expensive, but I’m wondering if there are cases when it’s actually less expensive than a lookup?

For example, if I have a large dictionary, I could either test for the existence of a key:

If MyDictionary.ContainsKey(MyKey) Then _
  MyValue = MyDictionary(MyKey) ' This is 2 lookups just to get the value.

Or, I could catch an exception:

Try
  MyValue = MyDictionary(MyKey) ' Only doing 1 lookup now.
Catch(e As Exception)
  ' Didn't find it.
End Try

Is exception trapping always more expensive than lookups like the above, or is it less so in some circumstances?

Answer 1

The thing about dictionary lookups is that they happen in constant or near-constant time. It takes your computer about the same amount of time whether your dictionary holds one item or one million items. I bring this up because you’re worried about making two lookups in a large dictionary, and reality is that it’s not much different from making two lookups in a small dictionary. As a side note, one of the implications here is that dictionaries are not always the best choice for small collections, though I normally find the extra clarity still outweighs any performance issues for those small collections.

One of the things that determines just how fast a dictionary can make it’s lookups is how long it takes to generate a hash value for a particular object. Some objects can do this much faster than others. That means the answer here depends on the kind of object in your dictionary. Therefore, the only way to know for sure is to build a version that tests each method a few hundred thousand times to find out which completes the set faster.

Another factor to keep in mind here is that it’s mainly just the Catch block that is slow with exception handling, and so you’ll want to look for the right combination of lookup hits and misses that reasonably matches what you’d expect in production. For this reason, you can’t find a general guideline here, or if you do it’s likely to be wrong. If you only rarely have a miss, then I would expect the exception handler to do much better (and, by virtue of the a miss being somewhat, well, exceptional, it would also be the right solution). If you miss more often, I might prefer a different approach

And while we’re at it, let’s not forget about Dictionary.TryGetValue()