Question

I’m trying to write an extension method in .NET that will operate on a generic collection, and remove all items from the collection that match a given criteria.

This was my first attempt:

public static void RemoveWhere<T>(this ICollection<T> Coll, Func<T, bool> Criteria){     foreach (T obj in Coll.Where(Criteria))         Coll.Remove(obj); } 

However this throws an InvalidOperationException, ‘Collection was modified; enumeration operation may not execute’. Which does make sense, so I made a second attempt with a second collection variable to hold the items that need to be removed and iterate through that instead:

public static void RemoveWhere<T>(this ICollection<T> Coll, Func<T, bool> Criteria){     List<T> forRemoval = Coll.Where(Criteria).ToList();      foreach (T obj in forRemoval)         Coll.Remove(obj); } 

This throws the same exception; I’m not sure I really understand why as ‘Coll’ is no longer the collection being iterated over, so why can’t it be modified?

If anyone has any suggestions as to how I can get this to work, or a better way to achieve the same, that’d be great.

Thanks.

Answer 1

For List<T>, this exists already, as RemoveAll(Predicate<T>). As such, I’d suggest that you keep the name (allowing familiarity, and precedence).

Basically, you can’t remove while iterating. There are two common options:

• use indexer based iteration (for) and removal
• buffer the items to remove, and remove after the foreach (as you’ve already done)

So perhaps:

public static void RemoveAll<T>(this IList<T> list, Func<T, bool> predicate) {     for (int i = 0; i < list.Count; i++) {         if (predicate(list[i])) {             list.RemoveAt(i--);         }     } } 

Or more generally for any ICollection<T>:

public static void RemoveAll<T>(this ICollection<T> collection, Func<T, bool> predicate) {     T element;      for (int i = 0; i < collection.Count; i++) {         element = collection.ElementAt(i);         if (predicate(element)) {             collection.Remove(element);             i--;         }     } } 

This approach has the advantage of avoiding lots of extra copies of the list.