LINQ deferred execution: query evaluated multiple times on multiple enumerations

LINQ queries over IEnumerable<T> are lazy. Enumerating the same query variable twice executes the query twice — potentially hitting the database twice, producing different results, or being very slow for large in-memory sequences.

Materialize with ToList() or ToArray() when you need to enumerate multiple times or guarantee a point-in-time snapshot:

// BAD — query evaluated twice
var query = _db.Orders.Where(o => o.Status == OrderStatus.Pending);
var count = query.Count();    // executes SQL
var list = query.ToList();    // executes SQL again

// GOOD — materialize once
var pending = await _db.Orders
    .Where(o => o.Status == OrderStatus.Pending)
    .ToListAsync();
var count = pending.Count;    // in-memory, no DB call

// BAD — side effects run twice
var processed = items.Select(i => { Process(i); return i; });
foreach (var _ in processed) { } // Process called for each item
foreach (var _ in processed) { } // Process called again!

IEnumerable<T> LINQ operators build an iterator state machine. Each call to GetEnumerator() restarts execution from the source. For EF Core queries, this means a new database roundtrip per enumeration.