C# dictionary TryGetValue with int values, how to avoid double lookup

Question

When doing something like:

int value;
if (dict.TryGetValue(key, out value))
{
    if (condition)
    {
        //value = 0;  this copies by value so it doesn't change the existing value
        dict[key] = 0;
    }
}
else
{
    dict[key] = 0;
}

Is there any way I can avoid index lookup to replace the existing value? I'm already verifying the key exists using TryGetValue so it seems like a waste to have to retrieve value by index again.

On a separate note, as in the else{} part of my code, is it generally considered good practice to use the indexer when adding new or replacing old values, and add to make it clear you are adding and not replacing? Or should I just use the indexer every time? The way I have learned to use dictionary, I always do a TryGetValue lookup and in the else portion I handle cases where no key exists.

Answer 1

Is there any way I can avoid index lookup to replace the existing value?

Not that I know of - but dictionary access should be very fast unless you have a custom class that's overridden GetHashCode poorly.

If you're not seeing a performance problem because of the double lookup I'd leave it alone.

Answer 2

You can try this out

Object value;
if (dict.TryGetValue(key, out value))
{
    if (condition)
    {
        //value.data = 0;  this copies by value so it doesn't change the existing value
        value.data = 0;
    }
}
else
{
    value.data = 0;
}

The essense of story is, the type you are fetching out is a generic type and is allocated on heap. i.e. when you fetch it out, it will come out as value. However, if you fetch out object, it will be a reference to the original allocated object and you can modify the value of a particular property of object.

Answer 3

I prefer to define convenience extension methods for things like this. For example:

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

    public static TValue GetOrSet<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key, TValue value)
    {
        return dictionary[key] = dictionary.GetValueOrDefault(key, value);
    }

There is little need to worry about performance of dictionary hashing & lookups - I am primarily concerned with readability and maintainability. With the above extension methods, this kind of thing is a one-liner:

int value = dict.GetOrSet(key, 0);

(Disclaimer: doesn't perform the if (condition) check - I rarely experience these scenarios)