C# List Remove: Methods and Performance

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

When you need to remove an item from a List<T> in C#, the API gives you several options: Remove, RemoveAt, RemoveAll, and RemoveRange. Each behaves differently in terms of what you pass in, what gets removed, and how the list is modified. Choosing the wrong one can lead to subtle bugs or unnecessary performance cost.

Remove vs RemoveAt: Which One Fits Your Data?

The simplest removal method is Remove(T item). It searches the list for the first occurrence of the specified value using the default equality comparer and removes it. The method returns true if an element was removed and false if the item was not found. This is useful when you have the actual object or value and don't care about its position.

List<string> names = new List<string> { "Alice", "Bob", "Charlie" };
bool removed = names.Remove("Bob");
// names: Alice, Charlie; removed == true

If you know the index of the element you want to remove, RemoveAt(int index) is more direct. It removes the element at that position and shifts all subsequent elements left to fill the gap. Unlike Remove, it does not search the list, so it avoids the overhead of a linear scan. However, it throws an ArgumentOutOfRangeException if the index is invalid.

List<int> numbers = new List<int> { 10, 20, 30, 40 };
numbers.RemoveAt(1);
// numbers: 10, 30, 40

Use Remove when you have the item itself and only the first match matters. Use RemoveAt when you have the index, especially if you are already tracking positions or iterating with a numeric loop.

Removing by Predicate with RemoveAll

When you need to remove every element that satisfies a condition, RemoveAll(Predicate<T> match) is the right tool. It evaluates the predicate against each element and removes all matches in a single pass, returning the number of elements removed. This is more efficient than calling Remove in a loop because it avoids repeated searches and shifting.

List<int> scores = new List<int> { 85, 92, 78, 60, 95 };
int removedCount = scores.RemoveAll(s => s < 80);
// scores: 85, 92, 95; removedCount == 2

The predicate runs once per element, and the list is compacted in place. This method is ideal for filtering out invalid entries, expired records, or any set of items that share a common property.

Removing a Range of Elements with RemoveRange

If you need to remove a contiguous block of elements, RemoveRange(int index, int count) removes count items starting at index. It is the most efficient way to delete a large chunk from the middle of a list because it shifts only the elements after the removed range, not the entire tail.

List<char> letters = new List<char> { 'A', 'B', 'C', 'D', 'E', 'F' };
letters.RemoveRange(1, 3);
// letters: A, E, F

This method is useful when you have a known range, such as clearing a portion of a list after processing it. It also works well for implementing a sliding window where you periodically drop the oldest entries.

Performance: Why Removal Is Not Always O(1)

List<T> is backed by a dynamic array. Removing an element from the middle requires shifting every subsequent element one position to the left. That shift is an O(n) operation, where n is the number of elements after the removed position. Additionally, Remove must first find the item, which is an O(n) linear search in the worst case. RemoveAt skips the search but still pays the shifting cost.

RemoveAll scans the entire list once, which is O(n), and then performs a single compaction pass. In practice, it is usually faster than repeatedly calling Remove because it avoids multiple scans and multiple shifts. RemoveRange shifts only the elements after the removed block, so its cost is proportional to the number of elements after the range, not the size of the range itself.

If you frequently remove items from the middle of a collection, consider whether LinkedList<T> is a better fit. It offers O(1) removal when you have a reference to the node, but it lacks O(1) indexed access. For most scenarios where you need random access and occasional removal, List<T> is still the right choice, but you should be aware of the shifting cost when working with large lists.

Common Mistakes: Modifying a List During Iteration

A frequent error is attempting to remove elements from a List<T> while iterating over it with foreach. This throws an InvalidOperationException because the list's version changes during enumeration. For example:

List<int> values = new List<int> { 1, 2, 3, 4, 5 };
foreach (int v in values)
{
    if (v % 2 == 0)
        values.Remove(v); // Throws InvalidOperationException
}

To remove elements while iterating, use a for loop that goes backwards, or better, use RemoveAll with a predicate. The backward loop avoids index shifting issues because you only move toward lower indices:

for (int i = values.Count - 1; i >= 0; i--)
{
    if (values[i] % 2 == 0)
        values.RemoveAt(i);
}

RemoveAll is cleaner and often more performant for this pattern because it handles the compaction internally. Use it whenever you can express the removal condition as a predicate.

Choosing the Right Removal Strategy

The decision among the removal methods depends on what information you have and how many items you need to remove.

For example, if you are processing a queue of messages and want to drop all messages older than a certain timestamp, RemoveAll is the natural fit. If you are implementing an undo stack and need to discard the most recent action, RemoveAt with the last index is appropriate. When you have a list of unique IDs and want to remove a specific one, Remove is straightforward.

Keep in mind that Remove and RemoveAt modify the list in place and do not return the removed element. If you need the element itself, retrieve it first with the indexer or Find before removing.

When to Consider Alternatives to List<T>

If your removal pattern is dominated by frequent inserts and deletes at arbitrary positions, List<T> may not be optimal. A LinkedList<T> offers O(1) removal when you have a LinkedListNode<T> reference, but it sacrifices O(1) indexed access. A HashSet<T> provides O(1) removal by value but does not preserve order. A SortedSet<T> maintains order but has O(log n) removal.

For most line-of-business applications, List<T> is the default choice because it balances random access, iteration, and modification. The removal methods described here cover the common cases. When you find yourself writing complex loops to manage shifting indices, step back and consider whether a different collection type better matches your access and mutation patterns.