Convenience method to find or add value to generic dictionary

Question

Many times over the years, I have needed code that does:

Find a value in a dictionary; if it is not there, add it to the dictionary (and return that new value).

For example:

    // Only one per account, so loading can be efficiently managed.
    // <AccountID, LCProfilePicture>
    public readonly static Dictionary<int, LCProfilePicture> All = new Dictionary<int, LCProfilePicture>();

    public static LCProfilePicture GetOrCreate( int accountID )
    {
        LCProfilePicture pic;
        if (!All.TryGetValue( accountID, out pic )) {
            pic = new LCProfilePicture( accountID );
            All[ accountID ] = pic;
        }

        return pic;
    }

Instead of having to write that boilerplate each time, I'd like to have a generic method that will do the work. How to do so in c#?

So far, I have thought of three ways to proceed:

1. Wrap the construction that will be needed if the dictionary does not already contain an object for the key, into an Action (or Func?). Then call that if necessary.

2. Require TValue to have a constructor of that form, and then somehow describe that requirement as a constraint on the generic method.

3. Define some interface that TValue has to satisfy, and somehow use that interface to write the generic method.

---

I think I know how to do #1, so will submit an answer doing so, as soon as I work out the details. UPDATE: I have now worked that out, and posted that as an answer.

But maybe #2 is possible? Then I could just add that constraint, and be done.

• Pro: easier to use (don't have to wrap the construction into an Action or Func).
• Con: Not as flexible (if have a TValue that does not have such a constructor, can't use this generic method).

(#3 seems less promising; I mention it for completeness.)

Answer 1

You can combine constraints of new() and an interface for setting the key, like this:

interface IWithKey<T> {
    public T Key { get; set; }
}
static class DictExtensions {
    public static TVal GetorCreate<TKey,TVal>(this IDictionary<TKey,TVal> d, TKey key) where TVal : new(), IWithKey<TKey> {
        TVal res;
        if (!d.TryGetValue(key, out res)) {
            res = new TVal();
            res.Key = key;
            d.Add(key, res);
        }
        return res;
    }
}

Since GetorCreate is an extension, you can use it as follows:

static LCProfilePicture GetOrCreatePic( int accountID ) {
    return All.GetOrCreateEntry(accountID);
}

Answer 2

I noticed in your example you have a static dictionary

// Only one per account, so loading can be efficiently managed.
// <AccountID, LCProfilePicture>
public readonly static Dictionary<int, LCProfilePicture> All = 
  new Dictionary<int, LCProfilePicture>();

My first reaction to that is, since it is static, are you going to need it to be thread safe. If the answer is yes, maybe, or even no, then the answer might be, don't write it yourself, let Microsoft do it.

System.Collections.Concurrent.ConcurrentDictionary<TKey, TValue>

Which so happens to have 2 built in functions

TValue GetOrAdd(TKey key, TValue value)
TValue GetOrAdd(TKey key, Func<TKey, TValue> func)

And all of that done in a thread-safe manner. The second one where the parameter is a Func is the maybe the answer you are looking for.

If you are set on simplifying the usage, I would argue against having the loading of the data be part of the TValue. That is mostly based on my own person preference to store POCO (Plain Old CLR Objects) as values is Dictionaries and not objects with State and Behavior.

I would instead, move the "loading/constructing/deserializing" behavior to another service and/or the Dictionary itself.

This example creates a base class that you inherit from

public abstract class SmartConcurrentDictionaryBase<TKey, TValue> : 
  System.Collections.Concurrent.ConcurrentDictionary<TKey, TValue>
{
  public TValue GetOrAdd(TKey key) { return GetOrAdd(key, LoadNewValue); }
  protected abstract TValue LoadNewValue(TKey key);
}

public class LCProfilePictureDictionary : SmartConcurrentDictionaryBase<int, LCProfilePicture>
{
  protected override LCProfilePicture(int accountID)
  { 
    return new LCProfilePicture(accountID);
  }
}

// use is
// var pic = All.GetOrAdd(accountID);

This example is more of a reusable Dictionary object and takes in a Func as a constructor parameter, but could easily be changed to include an Interface where one of the functions on the interface match the pattern.

public class SimpleConcurrentDictionary<TKey, TValue> :
  System.Collections.Concurrent.ConcurrentDictionary<TKey, TValue>
{
  private readonly Func<TKey, TValue> _loadFunc;
  public SimpleConcurrentDictionary(Func<TKey, TValue> loadFunc)
  {
    _loadFunc = loadFunc;
  }
  public TValue GetOrAdd(TKey key) { return GetOrAdd(key, _loadFunc); }
} 

Answer 3

Solution #1 (most general):

public static TValue GetOrCreateEntry<TKey, TValue>( Dictionary<TKey, TValue> dict, TKey key, Func<TValue> creator )
{
    TValue value;
    if (!dict.TryGetValue( key, out value )) {
        value = creator();
        dict[ key ] = value;
    }

    return value;
}

Example usage:

static LCProfilePicture GetOrCreatePic( int accountID )
{
    return GetOrCreateEntry<int, LCProfilePicture>( All, accountID, () => new LCProfilePicture( accountID ) );
}

---

Solution #2 (for TValues that remember their key):

public static TValue GetOrCreateEntry<TKey, TValue>( Dictionary<TKey, TValue> dict, TKey key, Func<TKey, TValue> creator )
{
    TValue value;
    if (!dict.TryGetValue( key, out value )) {
        value = creator(key);
        dict[ key ] = value;
    }

    return value;
}

Example usage:

static LCProfilePicture GetOrCreatePic( int accountID )
{
    return GetOrCreateEntry<int, LCProfilePicture>( All, accountID, key => new LCProfilePicture( key ) );
}

---

Comparison of Solution #1 and Solution 2:

Solution #1 is more general - it can be used even for TValues that don't need to know about the key.

Solution #2 is cleaner style, for TValues that do retain a reference to the key.

Two reasons #2 is preferable, where appropriate:

• Reason #1: Solution #1 has the possibility of abuse: consider the case where TValue has two constructors, a parameterless one, and one that takes key as a parameter. An inexperienced programmer might use Solution #1 like this:

---

static LCProfilePicture GetOrCreatePic( int accountID )
{
    // OOPS, programmer has not set the key field to "accountID".
    return GetOrCreateEntry<int, LCProfilePicture>( All, accountID, () => new LCProfilePicture() );
}

If the lead programmer / architect wants to avoid that possibility, omit Solution #1, and only offer #2. In that case, the attempted usage won't compile, because there is no matching constructor.

• Reason #2: Using Solution #1 requires including a second copy of the key in the usage, if TValue needs to capture it. This unnecessarily encapsulates the key in the Func instance, and could lead to accidentally referring to a different key, e.g.:

---

//...
int keyA;
int keyB;
// OOPS, programmer referred to the wrong key the second time.
// Maybe copy/pasted code, and only changed it in the first location, not realizing it is used in two places.
var valA = GetOrCreateEntry<int, LCProfilePicture>( All, keyA, () => new LCProfilePicture( keyB) );  
enter code here

Answer 4

System.Reflection has a ConstructorInfo object and a GetConstructor method that can be used for this purpose. ConstructorInfo.Invoke returns an object of the type that you used to create your ConstructorInfo. If you went the reflection route, it would look something like this (not tested, but should be close):

//using System.Reflection;
public static TValue GetOrCreateEntry<TKey, TValue>(Dictionary<TKey, TValue> dict, TKey key)
{
    TValue value;
    if (!dict.TryGetValue(key, out value))
    {
        // not in dictionary
        ConstructorInfo ctor = typeof(TValue).GetConstructor(new Type[] { typeof(TKey) });
        if (ctor != null)
        {
            // we have a constructor that matches the type you need
            value = (TValue)ctor.Invoke(new object[] { key });
            dict[key] = value;
            return value;
        }
        else
            throw new NotImplementedException(); // because the TValue type does not implement the constructor you anticipate
    }

    // we got it from dictionary, so just return it
    return value;
}