How to remove items from a list while iterating in C#

• Use List.RemoveAll() and specify the conditions for removal.
• Iterate backward through the list, check conditions, and use List.RemoveAt().

Both approaches modify the original list in place and avoid issues such as skipping items when using a forward loop.

1. Using List.RemoveAll() to Remove Items

The simplest way is to use List.RemoveAll() with a lambda expression to specify the condition for removal. It iterates through the list and removes the elements that meet the condition. After removal, it returns the count of the items removed.

var numbers = new List<int> { 10, 20, 30, 40, 50, 60, 70, 80, 90 };
numbers.RemoveAll(n => n < 50);

Console.WriteLine($"List after removal: {string.Join(", ", numbers)}");

Output:

List after removal: 50, 60, 70, 80, 90

This approach removes all integers less than 50 from the list in a straightforward way.

2. Using a Backward Loop with List.RemoveAt()

Alternatively, you can iterate backward through the list and remove items based on the condition using List.RemoveAt().

var numbers = new List<int> { 10, 20, 30, 40, 50, 60, 70, 80, 90 };

for (int i = numbers.Count - 1; i >= 0; i--)
{
    if (numbers[i] < 50)
    {
        numbers.RemoveAt(i);
    }
}

Console.WriteLine($"List after removal: {string.Join(", ", numbers)}");

Output:

List after removal: 50, 60, 70, 80, 90

This approach also removes numbers less than 50, but iterates through the list backward, which avoids skipping items due to index shifting.

Why Not Use a Forward Loop?

In a forward loop, removing items causes the list to shift elements to the left. As the loop progresses, the next item may be skipped, leading to incorrect results. For example, consider this situation:

var arr = new List<string> { "a", "b", "c" };
for (int i = 0; i < arr.Count; i++)
{
    if (arr[i] == "a")
    {
        arr.RemoveAt(i);
    }
}

Console.WriteLine(string.Join(", ", arr));  // Output: "b, c"

Here, the item "b" is skipped because after "a" is removed, the remaining items shift left, and the loop moves forward, missing "b". This issue is avoided by iterating backward, ensuring that no items are skipped.

Why Does List.RemoveAll() Perform Better?

The reason behind this is that List.RemoveAll() works by iterating through the list and shifting elements only when necessary. It efficiently checks and removes items, minimizing costly operations. In contrast, List.RemoveAt() requires shifting all elements after a removal, which becomes increasingly costly, especially when many items need to be removed from the start of the list.

• List.RemoveAll() is the more efficient approach for most cases, as it consistently performs better.
• backward iteration with List.RemoveAt() may be necessary in specific scenarios where you need more control or a custom removal logic, but it tends to be slower, particularly when removing multiple items.