InvalidOperationException on modifying List<T> during foreach enumeration

Resolution

To avoid InvalidOperationException when modifying a List<T>, you must avoid using foreach. .NET does not provide a built-in, zero-allocation "safe-foreach" helper that automatically snapshots the collection. You must either manually snapshot the list or use a index-based for loop.

Recommended Implementation Patterns

Depending on your performance requirements, use one of the following two patterns:

• For Removals (Zero Allocation): Use a reverse for loop. This avoids the enumerator's version check and prevents index shifting issues.

for (int i = list.Count - 1; i >= 0; i--)
{
    if (ShouldRemove(list[i]))
    {
        list.RemoveAt(i);
    }
}

• For Complex Logic (Snapshot): Create a shallow copy. This is safe but incurs O(n) allocation and time complexity.

foreach (var item in list.ToList())
{
    if (ShouldRemove(item))
    {
        list.Remove(item);
    }
}

Technical Analysis

The Version Check Cost

The List<T> enumerator maintains a local version field. On every call to MoveNext(), it performs a simple integer comparison against the list's internal version. While this is technically slower than a raw for loop (which accesses the underlying array directly), the cycle cost is typically negligible compared to the logic within the loop body.

Allocation and Performance Trade-offs

Method	Allocation	Version Check	Safety
foreach	Minimal (Struct)	Yes	Throws on modification
for loop	Zero	No	Safe (if index managed)
.ToList()	O(n)	Yes (on copy)	Safe

Assumptions and Verification

This analysis assumes a standard .NET implementation (Core/5+ or Framework). To verify the overhead in a specific hot path, use BenchmarkDotNet to compare a foreach loop against a for loop with an empty body; this isolates the enumerator's version check cost from your business logic.

Diagnostic Detail Needed: Are these modifications occurring in a single-threaded context or a multi-threaded environment? If multi-threaded, snapshotting is insufficient, and you must migrate to System.Collections.Concurrent types.