Can anyone explain why Dictionary<> in C# doesn't work like map<T,U> in STL?

Question

When I first started to program in C# last year, I immediately looked for the equivalent to STL's map, and learned about Dictionary.

UPDATE crossed out this garbage below, I was completely wrong. My experience with STL's map was that I hated when I requested it for a value, and if the key wasn't in the map, it would automatically create the value type (whatever its default constructor did) and add it to the map. I would have to then check for this condition in code and throw an exception.

Dictionary<> gets the whole shebang correct -- if the key isn't there, it throws the exception if you're requesting the value, or automatically adds it if it's not and you want to set the value.

But you all already knew that. I should have written my unit tests before posting here and embarrassing myself. :) They're written now!

Now I love Dictionary and all, but the thing that bugs me the most about it right now is that if the key isn't in the Dictionary, it throws a KeyNotFoundException. Therefore, I always need to write code like this:

Dictionary<string,string> _mydic;

public string this[string key]
{
  get {
    return _mydic[key]; // could throw KeyNotFoundException
  }
  set {
    if( _mydic.ContainsKey( key))
      _mydic[key] = value;
    else
      _mydic.Add( key, value);
  }
}

Why doesn't Dictionary automatically add the key value pair if the key doesn't exist, like STL's map?

Now the funny thing is that in a previous life, I used to get annoyed because I'd often have to try to prevent map from doing just that. I guess my use cases right now are a little different.

Answer 1

Which value would you want it to return if it didn't exist in the map already? It could return default(TValue) - but then it would be somewhat easy to accidentally use a value assuming it was correct. Note that if you want that behaviour, you can use:

get {
  string value;
  if (!_mydic.TryGetValue(key, out value))
    value = default(string);
  return value;
}

I wouldn't personally recommend it in general, but if you're happy not to be able to distinguish (via this indexer) between a key with a null value and a missing key, it will do the trick.

Note that your setter can me a lot simpler - just

_mydic[key] = value;

will overwrite if necessary.

Answer 2

I agree handling the exception is kind of annoying, especially for reference types when getting a null usually makes sense. In either case though you can use Dictionary<>.TryGetValue() to get the value in one call.