How to achieve remove_if functionality in .NET ConcurrentDictionary

by

.NET doesn’t expose a RemoveIf directly, but it does expose the building blocks necessary to make it work without doing your own locking.

ConcurrentDictionary implements ICollection<T>, which has a Remove that takes and tests for a full KeyValuePair instead of just a key. Despite being hidden, this Remove is still thread-safe and we’ll use it to implement this. One caveat for this to work is that Remove uses EqualityComparer<T>.Default to test the value, so it must be equality comparable. Your current one is not, so we’ll re-implement that as such:

struct ObjectCount : IEquatable<ObjectCount>
{
    public object Object { get; }
    public int Count { get; }

    public ObjectCount(object o, int c)
    {
        Object = o;
        Count = c;
    }

    public bool Equals(ObjectCount o) =>
       object.Equals(Object, o.Object) && Count == o.Count;

    public override bool Equals(object o) =>
       (o as ObjectCount?)?.Equals(this) == true;

    // this hash combining will work but you can do better.
    // it is not actually used by any of this code.
    public override int GetHashCode() =>
       (Object?.GetHashCode() ?? 0) ^ Count.GetHashCode();
}

And finally, we’ll define a method to increment/decrement counts from your dictionary:

void UpdateCounts(ConcurrentDictionary<string, ObjectCount> dict, string key, int toAdd)
{
    var addOrUpdateValue = dict.AddOrUpdate(key,
        new ObjectCount(new object(), 1),
        (k, pair) => new ObjectCount(pair.Key, pair.Value + toAdd));

    if(addOrUpdateValue.Count == 0)
    {
        ((ICollection<KeyValuePair<string, ObjectCount>>)dict).Remove(
            new KeyValuePair<string, ObjectCount>(key, addOrUpdateValue));
    }
}

The value for that key might be changed between the calls of AddOrUpdate and Remove, but that doesn’t matter to us: because Remove tests the full KeyValuePair, it will only remove it if the value hasn’t changed since the update.

This is the common lock-free pattern of setting up a change and then using a final thread-safe op to safely “commit” the change only if our data structure hasn’t been updated in the meantime.

More Related Contents:

  1. Is it considered acceptable to not call Dispose() on a TPL Task object?
  2. Multiple Parallel.ForEach loops in .Net
  3. How to put a task to sleep (or delay) in C# 4.0?
  4. Cancelling a pending task synchronously on the UI thread
  5. ConfigureAwait pushes the continuation to a pool thread
  6. The lack of non-capturing Task.Yield forces me to use Task.Run, why follow that?
  7. Wrapping ManualResetEvent as awaitable task
  8. How to cancel Task await after a timeout period
  9. When to use BlockingCollection and when ConcurrentBag instead of List?
  10. Attempted to read or write protected memory. This is often an indication that other memory is corrupt
  11. Why should I prefer single ‘await Task.WhenAll’ over multiple awaits?
  12. Starting Tasks In foreach Loop Uses Value of Last Item [duplicate]
  13. Re-entrant locks in C#
  14. Synchronously waiting for an async operation, and why does Wait() freeze the program here
  15. Getting the thread ID from a thread
  16. What does SynchronizationContext do?
  17. Is there a way to indefinitely pause a thread?
  18. Task continuation on UI thread
  19. Simplest way to do a fire and forget method in c# 4.0
  20. Async/Await vs Threads
  21. Unhandled exceptions in BackgroundWorker
  22. If my interface must return Task what is the best way to have a no-operation implementation?
  23. ThreadPool.QueueUserWorkItem vs Task.Factory.StartNew
  24. Do I need to lock or mark as volatile when accessing a simple boolean flag in C#?
  25. Looking for an example of a custom SynchronizationContext (Required for unit testing)
  26. Can .NET Task instances go out of scope during run?
  27. Should thread-safe class have a memory barrier at the end of its constructor?
  28. Faulted vs Canceled task status after CancellationToken.ThrowIfCancellationRequested
  29. ReaderWriterLock vs lock{}
  30. Create a completed Task

Leave a Comment