Updating List in ConcurrentDictionary

Question

So I have a IList as the value in my ConcurrentDictionary.

ConcurrentDictionary<int, IList<string>> list1 = new ConcurrentDictionary<int, IList<string>>;

In order to update a value in a list I do this:

if (list1.ContainsKey[key])
{
  IList<string> templist;
  list1.TryGetValue(key, out templist);
  templist.Add("helloworld");
}

However, does adding a string to templist update the ConcurrentDictionary? If so, is the update thread-safe so that no data corruption would occur?

Or is there a better way to update or create a list inside the ConcurrentDictionary

EDIT

If I were to use a ConcurrentBag instead of a List, how would I implement this? More specifically, how could I update it? ConcurrentDictionary's TryUpdate method feels a bit excessive.

Does ConcurrentBag.Add update the ConcurrentDictionary in a thread-safe mannar?

ConcurrentDictionary<int, ConcurrentBag<string>> list1 = new ConcurrentDictionary<int, ConcurrentBag<string>>

Answer 1

Firstly, there's no need to do ContainsKey() and TryGetValue().

You should just do this:

IList<string> templist;

if (list1.TryGetValue(key, out templist))
    templist.Add("helloworld");

In fact your code as written has a race condition.

Inbetween one thread calling ContainsKey() and TryGetValue() a different thread may have removed the item with that key. Then TryGetValue() will return tempList as null, and then you'll get a null reference exception when you call tempList.Add().

Secondly, yes: There's another possible threading issue here. You don't know that the IList<string> stored inside the dictionary is threadsafe.

Therefore calling tempList.Add() is not guaranteed to be safe.

You could use ConcurrentQueue<string> instead of IList<string>. This is probably going to be the most robust solution.

Note that simply locking access to the IList<string> wouldn't be sufficient.

This is no good:

if (list1.TryGetValue(key, out templist))
{
    lock (locker)
    {
        templist.Add("helloworld");
    }
}

unless you also use the same lock everywhere else that the IList may be accessed. This is not easy to achieve, hence it's better to either use a ConcurrentQueue<> or add locking to this class and change the architecture so that no other threads have access to the underlying IList.

Answer 2

Operations on a thread-safe dictionary are thread-safe by key, so to say. So as long as you access your values (in this case an IList<T>) only from one thread, you're good to go.

The ConcurrentDictionary does not prevent two threads at the same time to access the value beloning to one key.

Answer 3

You can use ConcurrentDictionary.AddOrUpdate method to add item to list in thread-safe way. Its simpler and should work fine.

var list1 = new ConcurrentDictionary<int, IList<string>>();
list1.AddOrUpdate(key, 
      new List<string>() { "test" }, (k, l) => { l.Add("test"); return l;});

UPD

According to docs and sources, factories, which was passed to AddOrUpdate method will be run out of lock scope, so calling List methods inside factory delegate is NOT thread safe.

See comments under this answer.

Answer 4

The ConcurrentDictionary has no effect on whether you can apply changes to value objects in a thread-safe manner or not. That is the reponsiblity of the value object (the IList-implementation in your case).

Looking at the answers of No ConcurrentList<T> in .Net 4.0? there are some good reasons why there is no ConcurrentList implementation in .net.

Basically you have to take care of thread-safe changes yourself. The most simple way is to use the lock operator. E.g.

lock (templist)
{
   templist.Add("hello world");
}

Another way is to use the ConcurrentBag in the .net Framework. But this way is only useful for you, if you do not rely on the IList interface and the ordering of items.

Answer 5

it has been already mentioned about what would be the best solution ConcurrentDictionary with ConcurrentBag. Just going to add how to do that

 ConcurrentBag<string> bag= new ConcurrentBag<string>();
 bag.Add("inputstring"); 
 list1.AddOrUpdate(key,bag,(k,v)=>{
     v.Add("inputString");
     return v;
 });

Answer 6

does adding a string to templist update the ConcurrentDictionary?

It does not.

Your thread safe collection (Dictionary) holds references to non-thread-safe collections (IList). So changing those is not thread safe.

I suppose you should consider using mutexes.

Answer 7

If you use ConcurrentBag<T>:

var dic = new ConcurrentDictionary<int, ConcurrentBag<string>>();

Something like this could work OK:

public static class ConcurentDictionaryExt
{
    public static ConcurrentBag<V> AddToInternal<K, V>(this ConcurrentDictionary<K, ConcurrentBag<V>> dic, K key, V value)
        => dic.AddOrUpdate(key,
            k => new ConcurrentBag<V>() { value },
            (k, existingBag) =>
                {
                    existingBag.Add(value);
                    return existingBag;
                }
            );

    public static ConcurrentBag<V> AddRangeToInternal<K, V>(this ConcurrentDictionary<K, ConcurrentBag<V>> dic, K key, IEnumerable<V> values)
        => dic.AddOrUpdate(key,
            k => new ConcurrentBag<V>(values),
            (k, existingBag) =>
                {
                    foreach (var v in values)
                        existingBag.Add(v);
                    return existingBag;
                }
            );
}

I didn't test it yet :)