Extension methods Dictionary<TKey,TValue>.RemoveAll? Is it possible?

Question

I've been trying to write an extension method to mimic List.RemoveAll(Predicate).

So far I've got this:

public static void RemoveAll<TKey,TValue>(this Dictionary<TKey,TValue> dict, 
                                     Predicate<KeyValuePair<TKey,TValue>> condition)
{
    Dictionary<TKey,TValue> temp = new Dictionary<TKey,TValue>();

    foreach (var item in dict)
    {
        if (!condition.Invoke(item))
            temp.Add(item.Key, item.Value);
    }

    dict = temp;
}

Any pointers? Is this a completely naive implementation?

Answer 1

Your code will not worck because you are passing the Dictionary class by value. This means the final assignment (dict = temp) will not be visible to a calling function. It is not legal in C# to pass extension method targets by ref or out (in VB it's legal to do ByRef).

Instead you will need to modify the Dictionary inline. Try the following

public static void RemoveAll<TKey,TValue>(this Dictionary<TKey,TValue> dict, 
                                     Func<KeyValuePair<TKey,TValue>,bool> condition)
{
    foreach ( var cur in dict.Where(condition).ToList() ) {
      dict.Remove(cur.Key);
    }
}

EDIT

Swapped the order of Where and ToList to reduce the size of the allocated memory of the list. It will now only allocate a list for the items that are to be removed.

Answer 2

public static void RemoveAll<TKey,TValue>(
    this Dictionary<TKey,TValue> dict, 
    Predicate<KeyValuePair<TKey,TValue>> condition)
{
    var toRemove = new List<TKey>();

    foreach (var item in dict)
    {
        if (!condition.Invoke(item))
            toRemove.Add(item);
    }
    foreach (var key in toRemove)
    {
        dict.Remove(key);
    }
}

If the number of keys to remove is small relative to the dictionary size this will be faster (if the number removed is likely to be zero you can make this even faster by lazily creating the toRemove list as well.

This boils down to the same as Jared's updated answer but allows you to defer the creation of the removal list if you so desire. If this is not an issue (and you have no reason to break point part way through the process) then Jared's is cleaner and simpler.

Answer 3

That method won't work because the "dict" parameter is not passed by reference, and in fact cannot be because ref is not supported as the first parameter of an extension method.

public static void RemoveAll<TKey,TValue>(this Dictionary<TKey,TValue> dict, 
                                 Predicate<KeyValuePair<TKey,TValue>> condition)
{
    var temp = new List<TKey>();

    foreach (var item in dict)
    {
        if (!condition(item))
            temp.Add(item.Key);
    }

    foreach (var itemKey in temp)
      dict.Remove(itemKey)
}

I'd like to see RemoveAllByKey and RemoveAllByValue implementations as well.

Answer 4

But if you wanted, you could return a new and different Dictionary. Your signature would change to this:

public static Dictionary<TKey, TValue> RemoveAll<TKey,TValue>(this Dictionary<TKey,TValue> dict, 
                                 Predicate<KeyValuePair<TKey,TValue>> condition)

And the calling code would say:

var newDict = oldDict.RemoveAll(kvp=> kvp.Name.StartsWith("something"));

And, if you wanted to modify oldDict, you would call it like this:

oldDict = oldDict.RemoveAll(kvp=> kvp.Name.StartsWith("something"));

Answer 5

I got an error with JaredPar's answer:

Inconsistent accessibility: parameter type 'System.Func,bool>' is less accessible than method 'System.Text.Extensions.RemoveAll(System.Collections.Generic.Dictionary, System.Func,bool>)'

Also, I thought RemoveAll() would remove all entries with matched value, not unmatched value, right?