Collection RemoveAll Extension Method

I had previously posted a RemoveAll extension method for the Dictionary<K,V> class, now it’s time to have one for the Collection<T> class.

The signature is the same as in the corresponding method already available in List<T> and the implementation relies on the RemoveAt method to perform the actual removal of each element.

Finally, here’s the code:

public static class CollectionExtensions
{
    /// <summary>
    /// Removes from the target collection all elements that match the specified predicate.
    /// </summary>
    /// <typeparam name="T">The type of elements in the target collection.</typeparam>
    /// <param name="collection">The target collection.</param>
    /// <param name="match">The predicate used to match elements.</param>
    /// <exception cref="ArgumentNullException">
    /// The target collection is a null reference.
    /// <br />-or-<br />
    /// The match predicate is a null reference.
    /// </exception>
    /// <returns>Returns the number of elements removed.</returns>
    public static int RemoveAll<T>(this Collection<T> collection, Predicate<T> match)
    {
        if (collection == null)
            throw new ArgumentNullException("collection");

        if (match == null)
            throw new ArgumentNullException("match");

        int count = 0;

        for (int i = collection.Count - 1; i >= 0; i--)
        {
            if (match(collection[i]))
            {
                collection.RemoveAt(i);
                count++;
            }
        }

        return count;
    }
}
Advertisements

RemoveAll Dictionary Extension Method

Removing from a dictionary all the elements where the keys satisfy a set of conditions is something I needed to do more than once so I implemented it as an extension method to the IDictionary<TKey, TValue> interface.

Here’s the code:

public static class DictionaryExtensions
{
    /// <summary>
    /// Removes all the elements where the key match the conditions defined by the specified predicate.
    /// </summary>
    /// <typeparam name="TKey">
    /// The type of the dictionary key.
    /// </typeparam>
    /// <typeparam name="TValue">
    /// The type of the dictionary value.
    /// </typeparam>
    /// <param name="dictionary">
    /// A dictionary from which to remove the matched keys.
    /// </param>
    /// <param name="match">
    /// The <see cref="Predicate{T}"/> delegate that defines the conditions of the keys to remove.
    /// </param>
    /// <exception cref="ArgumentNullException">
    /// dictionary is null
    /// <br />-or-<br />
    /// match is null.
    /// </exception>
    /// <returns>
    /// The number of elements removed from the <see cref="IDictionary{TKey, TValue}"/>.
    /// </returns>
    public static int RemoveAll<TKey, TValue>(
        this IDictionary<TKey, TValue> dictionary,
        Predicate<TKey> match)
    {
        if (dictionary == null)
            throw new ArgumentNullException("dictionary");

        if (match == null)
            throw new ArgumentNullException("match");

        var keysToRemove = dictionary.Keys.Where(k => match(k)).ToList();

        if (keysToRemove.Count == 0)
            return 0;

        foreach (var key in keysToRemove)
        {
            dictionary.Remove(key);
        }

        return keysToRemove.Count;
    }
}