Dictionary GetValueOrDefault

Question

I'm pretty sure there's no better way to do this but I thought a consensus on here might be nice. Let me know what you think.

public static TValue GetValueOrDefault<TKey, TValue>(this Dictionary<TKey, TValue> dictionary, TKey key, TValue defaultValue = default(TValue))
{
    TValue value;
    return dictionary.TryGetValue(key, out value) ? value : defaultValue;
}

Answer 1

I'm pretty sure there's no better way to do this but I thought a consensus on here might be nice. Let me know what you think.

At first glance it seems to be ok but one could assume that he/she is always getting either the value or the default value. If one would get the default value for e.g if the dictionary is empty, why shouldn't he/she get the default value if the dictionary is null or the key is null ?

If this isn't the way the method should work, then you need some documentation which cleary states the purpose and any expected exceptions.

Now, what happens if the method is called either like so

Dictionary<string, int> dict = null;
dict.GetValueOrDefault("someKey");

or (assuming the method lives in the "DictionaryExtensions" class)

Dictionary<string, int> dict = null;
DictionaryExtensions.GetValueOrDefault(dict, "someKey");  

sure you get a NullReferenceException but is this the type of exception one would expect ? If I call a method with an parameter being null I would expect to get either no exception or to get an ArgumentNullException.

What about if the key is null ? Sure you get an ArgumentNullException but it takes some time because it is thrown at the FindEntry() method of the Dictionary and this is also shown in the StackTrace.

IMO it would be better to check this cases inside the GetValueOrDefault() method and throw the exceptions there.

public static TValue GetValueOrDefault<TKey, TValue>(this Dictionary<TKey, TValue> dictionary, TKey key, TValue defaultValue = default(TValue))
{
    if (dictionary == null) { throw new ArgumentNullException(nameof(dictionary)); } // using C# 6
    if (key == null) { throw new ArgumentNullException(nameof(key)); } //  using C# 6

    TValue value;
    return dictionary.TryGetValue(key, out value) ? value : defaultValue;
}  

Answer 2

Another way to handle null is to return the default value also in this case. It could be not acceptable in some scenarios, but I think usually it is normal expectation when you call the method GetValueOrDefault. The Default word here means you like to get the default value if the item does not exist not throwing an exception which again requires to handle it in the code and decrease the usability of this helper extension.

For example, in a web app if you want to show some values in a text input or span(label), it isn't important whether dic is itself null or it doesn't contain the key. So, in this case the extension can be written as following:

public static class DictionaryExtensions
{
    /// <summary> Gets the value of specified key. Simply returns the default value if dic or key are null or specified key does not exists.</summary>
    public static TValue GetValueOrDefault<TKey, TValue>(this IDictionary<TKey, TValue> dic, TKey key, TValue defaultValue = default(TValue))
    {
        return (dic != null && key != null && dic.TryGetValue(key, out TValue value)) ? value : defaultValue;
    }
}

Answer 3

You can use:

dict.ContainsKey(key) ? dict[Key] : defaultValue

so you don't need to declare TValue.

Answer 4

There is a potential issue when providing an argument to a method that would only be used in a certain condition. defaultValue is only returned when the dictionary does not contain an instance of TValue for the given key.

• What if the default value is the result of an exhaustive algorithm or a service call? It would be a pitty to fetch this object when GetValueOrDefault would not require it.

public static TValue GetValueOrDefault<TKey, TValue>(
   this Dictionary<TKey, TValue> dictionary, TKey key, TValue defaultValue = default(TValue))
{
    TValue value;
    return dictionary.TryGetValue(key, out value) ? value : defaultValue;
}

For this reason, I suggest an alteration to the method signature and a convenience overload for the initial situation. (Edited after remark below)

public static TValue GetValueOrDefault<TKey, TValue>(
   this Dictionary<TKey, TValue> dictionary, TKey key, Func<TValue> defaultValueSelector)
{
    // arg checking left out for brevity
    TValue value;
    return dictionary.TryGetValue(key, out value) ? value 
       : defaultValueSelector != null ? defaultValueSelector() : default(TValue);
}

public static TValue GetValueOrDefault<TKey, TValue>(
   this Dictionary<TKey, TValue> dictionary, TKey key, TValue defaultValue = default(TValue))
{
     return GetValueOrDefault(dictionary, key, () => defaultValue);
}