Using List.RemoveAll in C# to Filter Elements

c# list removeall requires a clear understanding of the core syntax, runtime behavior, and practical implementation patterns demonstrated in the examples below.

The List<T>.RemoveAll method in C# removes every element that satisfies a condition supplied as a Predicate<T>. It modifies the list in place and returns the number of elements removed. This makes it the direct way to filter a list without creating a new collection. The method is available on List<T> instances and is part of the .NET Base Class Library, so it works across all modern .NET versions.

Using RemoveAll with a Predicate

The RemoveAll method takes a single argument: a Predicate<T> delegate that returns true for elements that should be removed. The method iterates through the list, evaluates the predicate for each element, and removes every match. The signature looks like this:

public int RemoveAll(Predicate<T> match)

Here is a minimal example that removes all negative numbers from a list of integers:

List<int> numbers = new List<int> { 5, -3, 8, -1, 0, 7 };
int removed = numbers.RemoveAll(n => n < 0);
Console.WriteLine(removed); // Output: 2
Console.WriteLine(string.Join(", ", numbers)); // Output: 5, 8, 0, 7

The lambda n => n < 0 is the predicate. It is evaluated for each element. The method returns the count of removed items, which is useful for logging or validation. Note that RemoveAll modifies the original list; it does not return a new list.

How RemoveAll Behaves at Runtime

Internally, RemoveAll uses a single pass over the list. It shifts elements that survive the predicate to fill the gaps left by removed items. This is more efficient than repeatedly calling Remove in a loop, because Remove scans the list from the beginning each time, leading to O(n²) behavior in the worst case. RemoveAll runs in O(n) time, assuming the predicate itself is constant-time.

The method also handles the case where the predicate throws an exception. If an exception occurs during evaluation, the list is left in an undefined partial state. The method does not roll back changes made before the exception. This is an important consideration when the predicate has side effects or can fail.

Another subtle behavior is that RemoveAll does not create a new list. It works in-place, which means the original list reference remains valid and the capacity of the list is not automatically reduced. The Capacity property stays the same after removal, so memory is not reclaimed immediately. If memory usage is a concern, you can call TrimExcess() after RemoveAll to shrink the internal array.

Common Predicate Patterns

While a lambda is the most common way to write a predicate, you can also use a method group or a local function. This is useful when the condition is complex or reused elsewhere.

static bool IsExpired(Order order) => order.ExpiryDate < DateTime.UtcNow;

List<Order> orders = GetOrders();
orders.RemoveAll(IsExpired);

You can also combine conditions using logical operators:

list.RemoveAll(x => x.IsActive == false && x.LastLogin < DateTime.UtcNow.AddMonths(-6));

For reference types, the predicate receives each element. Be careful with closures that capture loop variables. In older C# versions, a foreach loop variable captured in a lambda could cause unexpected behavior, but since C# 5, the loop variable is unique per iteration. Still, it is safer to assign the loop variable to a local inside the lambda if you need to reference it.

Performance and Memory Considerations

RemoveAll is generally the fastest way to remove multiple elements from a List<T> when the removal condition is known. The single-pass algorithm minimizes element shifting. In contrast, using Where followed by ToList creates a new list and leaves the original unchanged, which is a different operation. If you need to keep the original list reference and mutate it, RemoveAll is the appropriate choice.

The memory impact is minimal because no new collection is allocated. However, the list's internal array retains its size. If you remove many elements and keep the list for a long time, the unused capacity can waste memory. Calling TrimExcess() after a large removal can help, but it is an O(n) operation itself, so weigh the benefit against the cost.

For very large lists, the predicate's cost dominates. If the predicate is expensive, consider whether you can restructure the data to avoid scanning the entire list. For example, maintaining a separate set of items to remove can reduce the scan to O(n) but still requires evaluating the predicate for each element. There is no way to avoid iterating over all elements unless you have an index or a dictionary-based structure.

Comparison with Other Removal Approaches

RemoveAll is not the only way to remove elements from a list. The Remove method removes the first occurrence of a specific item, and RemoveAt removes an element at a given index. These are useful for single removals, but they do not accept a predicate. To remove multiple elements matching a condition, you could write a manual loop with RemoveAt, but that is error-prone and inefficient because indices shift after each removal.

Another common alternative is LINQ: list = list.Where(x => !condition).ToList(). This creates a new list and reassigns the variable. It is functionally similar but has different semantics. The original list is not modified; any other references to it remain unchanged. This can be beneficial if you need to preserve the original collection, but it allocates a new list and may be slower due to the extra allocation and copying.

The following table summarizes the key differences:

Choose RemoveAll when you want to modify the existing list and avoid extra allocations. Choose Where + ToList when you need the original list to remain intact or when you are working with IEnumerable<T> rather than a concrete List<T>.

Edge Cases and Compatibility

RemoveAll works on any List<T>, including lists of custom classes, structs, and nullable types. The predicate must be able to handle null if the list contains null elements. For example, if you have List<string> with null values and you want to remove nulls, the predicate should check x == null. The lambda x => x == null is valid, but if you use a method that assumes non-null, it will throw a NullReferenceException.

If the list is empty, RemoveAll returns 0 and does nothing. If the predicate is null, the method throws ArgumentNullException. This is a common mistake when passing a method that might be null. Always ensure the predicate is non-null.

Regarding .NET versions, RemoveAll has been available since .NET Framework 2.0 and is present in .NET Core and .NET 5+. There is no version-specific behavior difference that affects typical usage. The method is also available on List<T> in the System.Collections.Generic namespace, so you need using System.Collections.Generic;.

One subtle edge case is when the predicate modifies the list itself. For example, if the predicate adds or removes elements during iteration, the behavior is undefined. The method does not protect against concurrent modification. You should avoid side effects in the predicate. If you need to perform complex logic, extract the condition into a separate method that does not mutate the collection.

For thread safety, List<T> is not thread-safe. If multiple threads access the same list and one calls RemoveAll, you must synchronize access. Using a ConcurrentBag or a lock is necessary in concurrent scenarios. RemoveAll itself does not provide any synchronization.

In summary, RemoveAll is a powerful and efficient method for in-place filtering. Understanding its runtime behavior and edge cases helps you use it correctly in production code. When you need to remove elements conditionally from a List<T>, it is often the best choice, but always consider whether you need to preserve the original list or if a new collection is acceptable.