How to remove elements from a generic list while iterating around it?

Question

I am looking for a better 'pattern' for working with a list of elements which each need processed and then depending on the outcome are removed from the list.

You can't use .Remove(element) inside a foreach (var element in X)... you also can't use for (int i = 0; i < elements.Count(); i++) and .RemoveAt(i).

Previously I have done crazy things like this (summary = building a generic structure around the 'element' to hold a true or false value which determines whether or not it should be removed from the list):

public List<String> AttemptToProcessList(List<string> list) {

    var listTracked = new List<KeyValuePair<string, bool>>();

    list.ForEach(item => listTracked.Add(new KeyValuePair<string, bool>(item, false)));

    for (int i = 0; i < listTracked.Count; i++) {

        var result = ProcessListItem(listTracked[i].Key);

        if (result) {
            listTracked[i] = new KeyValuePair<string, bool>(listTracked[i].Key, true);
        }
     }

     foreach (var item in listTracked.Where( listItem => listItem.Value )) {
         list.Remove(item.Key);
     }

     return list;
}

Answer 1

You can use for instead of foreach. Foreach relies on enumeration and you really cannot modify your collection while you're enumerating it.

Answer 2

I would reassign safePendingList from a LINQ query that filtered out the elements you didn't want to keep.

Answer 3

A simple and straightforward solution:

Use a standard for-loop running backwards on your collection and RemoveAt(i) to remove elements.

Answer 4

Iterate your list in reverse with a for loop:

for (int i = safePendingList.Count - 1; i >= 0; i--)
{
    // some code
    // safePendingList.RemoveAt(i);
}

Example:

var list = new List<int>(Enumerable.Range(1, 10));
for (int i = list.Count - 1; i >= 0; i--)
{
    if (list[i] > 5)
     list.RemoveAt(i);
}
list.ForEach(i => Console.WriteLine(i));

Alternately, you can use the RemoveAll method with a predicate to test against:

safePendingList.RemoveAll(item => item.Value == someValue);

Here's a simplified example to demonstrate:

var list = new List<int>(Enumerable.Range(1, 10));
Console.WriteLine("Before:");
list.ForEach(i => Console.WriteLine(i));
list.RemoveAll(i => i > 5);
Console.WriteLine("After:");
list.ForEach(i => Console.WriteLine(i));

Answer 5

Using the ToArray() on a generic list allows you to do a Remove(item) on your generic List:

        List<String> strings = new List<string>() { "a", "b", "c", "d" };
        foreach (string s in strings.ToArray())
        {
            if (s == "b")
                strings.Remove(s);
        }

Answer 6

Select the elements you do want rather than trying to remove the elements you don't want. This is so much easier (and generally more efficient too) than removing elements.

var newSequence = (from el in list
                   where el.Something || el.AnotherThing < 0
                   select el);

I wanted to post this as a comment in response to the comment left by Michael Dillon below, but it's too long and probably useful to have in my answer anyway:

Personally, I'd never remove items one-by-one, if you do need removal, then call RemoveAll which takes a predicate and only rearranges the internal array once, whereas Remove does an Array.Copy operation for every element you remove. RemoveAll is vastly more efficient.

And when you're backwards iterating over a list, you already have the index of the element you want to remove, so it would be far more efficient to call RemoveAt, because Remove first does a traversal of the list to find the index of the element you're trying to remove, but you already know that index.

So all in all, I don't see any reason to ever call Remove in a for-loop. And ideally, if it is at all possible, use the above code to stream elements from the list as needed so no second data structure has to be created at all.