Walk through C# control flow: if, switch, for, foreach, while, break, continue and return. What does foreach compile to, and which loop bugs should you watch for?

1. foreach is duck-typed

The compiler's rules for foreach (V v in x):

1. If x is an array or span, emit an index loop (for (int i = 0; i < x.Length; i++)). The JIT can then remove bounds checks.
2. Otherwise, look for an accessible instance (or, since C# 9, extension) GetEnumerator() whose return type has bool MoveNext() and a Current property. Use that — no interface required.
3. Otherwise, fall back to IEnumerable<T> / IEnumerable.
4. If the enumerator type implements IDisposable (or, for ref struct enumerators, has a Dispose method), wrap the loop in try/finally and dispose it.

This duck typing is why List<T>, Dictionary<TKey,TValue>, HashSet<T> and ImmutableArray<T> expose public struct enumerators: foreach over the concrete type avoids a heap allocation and allows the JIT to inline MoveNext. When the same collection is typed as IEnumerable<T>, GetEnumerator() returns IEnumerator<T>, the struct is boxed, and every MoveNext/Current is an interface call (though dynamic PGO in .NET 8+ can often guarded-devirtualise them).

2. The version check behind "Collection was modified"

// Simplified from List<T>
public void Add(T item) { _version++; ... }

public bool MoveNext()
{
    if (_version != _list._version) ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumFailedVersion();
    ...
}

Every mutating method increments _version; the enumerator captured the version at creation and checks it. It is a best-effort check for single-threaded misuse, not a thread-safety mechanism — concurrent writers can still corrupt the list without throwing. Safe alternatives:

• list.RemoveAll(predicate) — single O(n) compaction pass.
• Iterate backwards with for when removing by index.
• Iterate over a snapshot: foreach (var x in list.ToArray()).
• Dictionary<TKey,TValue>.Remove during enumeration is allowed since .NET Core 3.0 (it does not bump the version), but Add is not.

3. Closure capture and the loop variable

Before C# 5, the foreach variable was declared outside the loop, so lambdas created in the loop all captured the same variable. C# 5 changed the spec so each iteration gets a fresh variable — one of the few breaking changes in C# history.

The for loop was deliberately not changed, because its variable is genuinely shared and mutated by the iterator expression:

var actions = new List<Action>();
for (int i = 0; i < 3; i++) actions.Add(() => Console.Write(i));
foreach (var a in actions) a();   // prints 333

The compiler hoists i into a closure class (a "display class") shared by all lambdas; by the time they run, i is 3. Fix: copy to a local inside the body (int copy = i;).

4. Iterators and early exit

An iterator method (yield return) compiles into a state-machine class implementing IEnumerable<T> and IEnumerator<T>. try/finally and using inside the iterator become part of the state machine's Dispose. If the consumer breaks out of foreach, the compiler-generated finally calls Dispose, which runs the iterator's pending finally blocks — so a using var reader = ... inside an iterator is closed correctly. If you enumerate manually with GetEnumerator() and forget Dispose, those resources leak.

Iterators are lazy and re-runnable: each foreach calls GetEnumerator() again and re-executes the method from the start. That is the root of the multiple-enumeration bug.

5. Loop performance basics

• for over an array or span with i < arr.Length lets the JIT eliminate bounds checks. Caching the length in a local can prevent that optimisation for arrays in older runtimes — write the idiomatic form.
• foreach over a List<T> is as fast as for in modern .NET; CollectionsMarshal.AsSpan(list) gives a span when you need the absolute fastest loop (and promise not to resize the list meanwhile).
• Hoist invariant work out of loops (regex construction, DateTime.Now, LINQ Count() in the condition).
• while (true) with a clear break is fine; what matters is a guaranteed exit and, for retries, a cap plus backoff with jitter.

6. switch statement details

• Since C# 7, cases can be patterns with when guards, and order matters.
• goto case X; and goto default; are the explicit fall-through mechanism.
• A switch on dense integers or enums compiles to a jump table (switch IL opcode); on strings, the compiler computes a hash and then compares (or, in newer compilers, switches on length and characters) to avoid sequential comparisons.

Try it yourself

1. Paste a foreach over List<int> and over IEnumerable<int> into SharpLab and compare the lowered code and allocations.
2. Benchmark both with BenchmarkDotNet using [MemoryDiagnoser].
3. Write an iterator with a try/finally that logs, break after the first item, and observe the log.
4. Reproduce the for-loop closure bug and fix it.

namespace Basics;

public sealed record Session(string Id, DateTimeOffset ExpiresAt);

public static class Loops
{
    public static void Main()
    {
        // 1. Closure over a for variable
        var actions = new List<Func<int>>();
        for (int i = 0; i < 3; i++)
        {
            int copy = i;              // fix: per-iteration copy
            actions.Add(() => copy);
        }
        Console.WriteLine(string.Join(",", actions.Select(a => a()))); // 0,1,2

        // 2. Modifying during foreach: use RemoveAll instead
        var now = DateTimeOffset.UtcNow;
        var sessions = new List<Session>
        {
            new("a", now.AddMinutes(-5)),
            new("b", now.AddMinutes(10)),
            new("c", now.AddMinutes(-1))
        };
        int removed = sessions.RemoveAll(s => s.ExpiresAt < now);
        Console.WriteLine($"Removed {removed}, left {sessions.Count}");

        // 3. Reverse loop when you need the index
        var numbers = new List<int> { 1, 2, 3, 4, 5, 6 };
        for (int i = numbers.Count - 1; i >= 0; i--)
        {
            if (numbers[i] % 2 == 0) numbers.RemoveAt(i);
        }

        // 4. Breaking out of nested loops: extract a method
        Console.WriteLine(FindPair([1, 4, 6, 9], target: 10));

        // 5. Multiple enumeration: materialise once
        IEnumerable<int> expensive = Generate();
        var list = expensive.ToList();   // runs once
        Console.WriteLine($"{list.Count} items, first {list[0]}");
    }

    private static (int, int)? FindPair(int[] values, int target)
    {
        for (int i = 0; i < values.Length; i++)
            for (int j = i + 1; j < values.Length; j++)
                if (values[i] + values[j] == target)
                    return (values[i], values[j]);   // exits both loops
        return null;
    }

    private static IEnumerable<int> Generate()
    {
        Console.WriteLine("Generating...");
        for (int i = 0; i < 3; i++) yield return i * 10;
    }
}