Best way to remove multiple items matching a predicate from a .NET Dictionary?


C# Problem Overview

I need to remove multiple items from a Dictionary. A simple way to do that is as follows :

  List<string> keystoremove= new List<string>();
  foreach (KeyValuePair<string,object> k in MyCollection)
     if (k.Value.Member==foo)
  foreach (string s in keystoremove)

The reason why I can't directly Remove the items in the foreach block is that this would throw an Exception ("Collection was modified...")

I'd like to do the following :

 MyCollection.RemoveAll(x =>x.Member==foo)

But the Dictionary<> class doesn't expose a RemoveAll(Predicate<> Match) method, like the List<> Class does.

What's the best way (both performance wise and elegant wise) to do that?

C# Solutions

Solution 1 - C#

Here's an alternate way

foreach ( var s in MyCollection.Where(kv => kv.Value.Member == foo).ToList() ) {

Pushing the code into a list directly allows you to avoid the "removing while enumerating" problem. The .ToList() will force the enumeration before the foreach really starts.

Solution 2 - C#

you can create an extension method:

public static class DictionaryExtensions
    public static void RemoveAll<TKey, TValue>(this IDictionary<TKey, TValue> dict, 
        Func<TValue, bool> predicate)
        var keys = dict.Keys.Where(k => predicate(dict[k])).ToList();
        foreach (var key in keys)


dictionary.RemoveAll(x => x.Member == foo);

Solution 3 - C#

Instead of removing, just do the inverse. Create a new dictionary from the old one containing only the elements you are interested in.

public Dictionary<T, U> NewDictionaryFiltered<T, U>
  Dictionary<T, U> source,
  Func<T, U, bool> filter
return source
  .Where(x => filter(x.Key, x.Value))
  .ToDictionary(x => x.Key, x => x.Value);

Solution 4 - C#

Modified version of Aku's extension method solution. Main difference is that it allows the predicate to use the dictionary key. A minor difference is that it extends IDictionary rather than Dictionary.

public static class DictionaryExtensions
    public static void RemoveAll<TKey, TValue>(this IDictionary<TKey, TValue> dic,
        Func<TKey, TValue, bool> predicate)
        var keys = dic.Keys.Where(k => predicate(k, dic[k])).ToList();
        foreach (var key in keys)

. . .

dictionary.RemoveAll((k,v) => v.Member == foo);

Solution 5 - C#

The fastest way to remove would be either:

public static void RemoveAll<TKey, TValue>(this IDictionary<TKey, TValue> idict, Func<KeyValuePair<TKey, TValue>, bool> predicate)
        foreach (var kvp in idict.Where(predicate).ToList())


public static void RemoveAll<T>(this ICollection<T> icollection, Predicate<T> predicate)
    var nonMatchingItems = new List<T>();

    // Move all the items that do not match to another collection.
    foreach (var item in icollection) 
        if (!predicate(item))

    // Clear the collection and then copy back the non-matched items.
    foreach (var item in nonMatchingItems)

depending on whether you have more cases of predicate returning true or not. Both are O(N) in nature, but 1st approach will be faster if you have very less cases of "removal/lookup", and the second one faster if items in collection matches the condition majority of the times.

Solution 6 - C#

Can you just change your loop to use an index (i.e. FOR instead of FOREACH)? You'd have to loop backwards, of course, i.e. count-1 down to zero.

Solution 7 - C#

Instead of removing just do the inverse (create a new dictionary from the old one containing only the elements you are interested in) and let the garbage collector take care of the old dictionary:

var newDictionary = oldDictionary.Where(x => x.Value != foo);

Solution 8 - C#

Starting from the .NET 3.0, it's now allowed to remove items from a Dictionary<TKey,TValue> while enumerating it. According to the documentation:

> .NET Core 3.0+ only: The only mutating methods which do not invalidate enumerators are Remove and Clear.

Here is the GitHub issue where this change was proposed and approved: Allow Dictionary.Remove during enumeration

So the RemoveAll extension method can be implemented simply like this:

/// <remarks>.NET Core 3.0+ only.</remarks>
public static void RemoveAll<TKey, TValue>(this Dictionary<TKey, TValue> source,
    Predicate<KeyValuePair<TKey, TValue>> predicate)
    foreach (var pair in source)
        if (predicate(pair))

Usage example:

myDictionary.RemoveAll(e => e.Value.Member == foo);

Solution 9 - C#

It's simple using LINQ. Just do the following :)

MyCollection = MyCollection.Where(mc => !keystoremove.Contains(mc.Key))
.ToDictionary(d => d.Key, d => d.Value);


All content for this solution is sourced from the original question on Stackoverflow.

The content on this page is licensed under the Attribution-ShareAlike 4.0 International (CC BY-SA 4.0) license.

Content TypeOriginal AuthorOriginal Content on Stackoverflow
QuestionBrannView Question on Stackoverflow
Solution 1 - C#JaredParView Answer on Stackoverflow
Solution 2 - C#akuView Answer on Stackoverflow
Solution 3 - C#Amy BView Answer on Stackoverflow
Solution 4 - C#JeromeView Answer on Stackoverflow
Solution 5 - C#nawfalView Answer on Stackoverflow
Solution 6 - C#GeoffView Answer on Stackoverflow
Solution 7 - C#Darin DimitrovView Answer on Stackoverflow
Solution 8 - C#Theodor ZouliasView Answer on Stackoverflow
Solution 9 - C#Siyavash HamdiView Answer on Stackoverflow