⚡ LINQ is Beautiful, But Know Its Cost
LINQ makes code readable, but hidden performance traps exist. Multiple enumerations, wrong collection types, predicate order — fix them all.
❌ Multiple Enumeration
var filtered = items.Where(x => x.IsActive); // Executes query 3 times! var count = filtered.Count(); // Query executes var first = filtered.First(); // Query executes again var list = filtered.ToList(); // And again! // Database: 3 round trips!
✅ Materialize Once
// Materialize to list var filtered = items.Where(x => x.IsActive).ToList(); // Now uses the list, no re-query var count = filtered.Count; // O(1) var first = filtered.First(); // O(1) var list = filtered; // Already list
📊 Performance Comparison
// ❌ Slow: Where after OrderBy
var result = items.OrderBy(x => x.Name).Where(x => x.IsActive);
// Orders ALL items, then filters
// ✅ Fast: Where before OrderBy
var result = items.Where(x => x.IsActive).OrderBy(x => x.Name);
// Filters first (fewer items), then orders
// ❌ Slow: First() without Any()
if (items.Where(x => x.IsActive).FirstOrDefault() != null) { }
// Scans entire collection
// ✅ Fast: Any() first
if (items.Any(x => x.IsActive))
{
var item = items.First(x => x.IsActive);
}
// ✅ Best: Use FirstOrDefault
var item = items.FirstOrDefault(x => x.IsActive);
if (item != null) { }
✅ Collection Type Matters
- List.Count: O(1) → Fast
- IEnumerable.Count(): O(n) → Slow (enumerates)
- HashSet.Contains: O(1) → Fast for lookups
- List.Contains: O(n) → Slow for large collections
- Dictionary lookup: O(1) → Fast by key
📝 Real-World Example
// ❌ Bad: 3 enumerations + OrderBy before filter
var activeUsers = users.Where(u => u.IsActive);
var total = activeUsers.Count(); // Enumerates 1
var list = activeUsers.ToList(); // Enumerates 2
var first = activeUsers.First(); // Enumerates 3
var sorted = users.OrderBy(u => u.Name) // Orders all (1000 items)
.Where(u => u.IsActive); // Then filters (maybe 100)
// ✅ Good: Single enumeration + filter first
var activeUsers = users.Where(u => u.IsActive).ToList(); // 1 enumeration
var total = activeUsers.Count; // O(1)
var list = activeUsers; // Already list
var first = activeUsers[0]; // O(1)
var sorted = users.Where(u => u.IsActive) // Filters first (100)
.OrderBy(u => u.Name) // Orders only 100
.ToList();
💡 LINQ to SQL/EF Core Tips
- Use .Any() instead of .Count() > 0: Translates to EXISTS
- Avoid .ToList() too early: Let database filter, then materialize
- Use .Select() projections: Only get needed columns
- Use .Include() for navigation properties: Avoid N+1 queries
- Monitor generated SQL: Use logging to see what’s executed
“Method was called 10,000 times. Each call enumerated a collection 3 times. Total: 30,000 iterations. Fixed by materializing once. Method went from 500ms to 15ms. LINQ is great, but know what it’s doing.”
