ConcurrentDictionary's optimistically concurrent Remove method

Question

I was looking for a method in ConcurrentDictionary that allows me to remove an entry by key, if and only if the value is equal to one that I specify, something like the equivalent of TryUpdate, but for removals.

The only method that does this seems to be this method:

ICollection<KeyValuePair<K, V>>.Remove(KeyValuePair<K, V> keyValuePair)

It is the explicit implementation of the ICollection interface, in other words, I have to cast my ConcurrentDictionary to an ICollection first so that I can call Remove.

Remove does exactly what I want, and that cast is no big deal either, also the source code shows it calls the private method TryRemovalInternal with bool matchValue = true, so it all looks nice and clean.

What worries me a bit however is the fact that it is not documented as the optimistically concurrent Remove method of ConcurrentDictionary, so http://msdn.microsoft.com/en-us/library/dd287153.aspx just duplicates the ICollection boilerplate, and the How to: Add and Remove Items from a ConcurrentDictionary does not mention that method either.

Does anyone know if that's the way to go, or is there some other method that I'm missing?

Looks about right (since it's the same method that `TryRemove` calls, just with `matchValue` set false and `oldValue` defaulted) — Damien_The_Unbeliever, Jan 04 '12 at 07:53
Though it is not official document, it can be helpful: http://blogs.msdn.com/b/pfxteam/archive/2011/04/02/10149222.aspx — alexm, Jan 04 '12 at 07:59
@alexm This is reassuring enough - If you turn that into an answer, I'll accept it! MS should really update their documentation, if its true that lately they have "seen several folks ask for further support on ConcurrentDictionary"... — Evgeniy Berezovsky, Jan 04 '12 at 08:35
Does this answer your question? [How to achieve remove\_if functionality in .NET ConcurrentDictionary](https://stackoverflow.com/questions/39679779/how-to-achieve-remove-if-functionality-in-net-concurrentdictionary) — Theodor Zoulias, Apr 30 '22 at 22:58

score 6 · Accepted Answer · edited Apr 30 '22 at 22:49

Though it is not an official document, this MSDN blog post can be helpful. The gist of that article: casting to ICollection and calling its Remove method, just as described in the question, is the way to go.

Here's a snippet from the above blog post, which wraps it into a TryRemove extension methods:

public static bool TryRemove<TKey, TValue>(
    this ConcurrentDictionary<TKey, TValue> dictionary, TKey key, TValue value)
{
    if (dictionary == null)
      throw new ArgumentNullException("dictionary");
    return ((ICollection<KeyValuePair<TKey, TValue>>)dictionary).Remove(
        new KeyValuePair<TKey, TValue>(key, value));
}

score 0 · Answer 2 · answered Nov 30 '13 at 16:48

0

If you don't need all the bells & whistles of ConcurrentDictionary, you can just declare your type as an IDictionary.

public class ClassThatNeedsDictionary
{
    private readonly IDictionary<string, string> storage;

    public ClassThatNeedsDictionary()
    {
        storage = new ConcurrentDictionary<string, string>();
    }

    public void TheMethod()
    {
        //still thread-safe
        this.storage.Add("key", "value");
        this.storage.Remove("key");
    }
}

I find this useful in situation in which you only need to add and remove, but still want a thread-safe iteration.

answered Nov 30 '13 at 16:48

greyalien007

510
4
13

If there are scenarios in where you'd use a ConcDic, but not need its specialized methods, I haven't come across them. But if there were, your suggestion certainly would make redundant that cast. Otoh, I'm pretty sure this is a "compile-time cast" anyway, so no performance penalty whatsoever. Just somewhat uglier code. – Evgeniy Berezovsky Dec 01 '13 at 23:28
In the scenario that you want to add and remove objects from the dictionary at the same time that it is being iterated. Being that the ConcurrentDictionary provides a key snapshot, you won't get an exception. – greyalien007 Dec 02 '13 at 16:27

ConcurrentDictionary's optimistically concurrent Remove method

2 Answers2