LINQ is awesome. It makes querying data feel natural and readable. But I see the same mistakes in almost every code review I do. And honestly? I've made all of these myself at some point.

Let me show you the most common LINQ mistakes and how to avoid them. Some of these can absolutely tank your app's performance.

Mistake #1: Enumerating Multiple Times

This is probably the #1 mistake I see. Check this out:

var users = _context.Users.Where(u => u.IsActive);

// Executing query 1
var count = users.Count();

// Executing query 2 
var firstUser = users.FirstOrDefault();

// Executing query 3
foreach (var user in users)
{
    Console.WriteLine(user.Name);
}

The fix? Just call ToList() once:

var users = _context.Users
    .Where(u => u.IsActive)
    .ToList(); // Execute once, store in memory

var count = users.Count();        // In-memory
var firstUser = users.FirstOrDefault(); // In-memory
foreach (var user in users)       // In-memory
{
    Console.WriteLine(user.Name);
}

Mistake #2: Using Count() When You Mean Any()

I see this one everywhere:

if (_context.Users.Count() > 0)
{
    // Do something
}

if (_context.Orders.Where(o => o.UserId == userId).Count() > 0)
{
    // User has orders
}

Use Any() instead:

if (_context.Users.Any())
{
    // Do something
}

if (_context.Orders.Any(o => o.UserId == userId))
{
    // User has orders
}

Performance Comparison

Mistake #3: Loading Everything When You Need Two Fields

This kills performance in so many apps:

var users = _context.Users.ToList();

foreach (var user in users)
{
    Console.WriteLine($"{user.FirstName} {user.LastName}");
}

Use Select to get only what you need:

var users = _context.Users
    .Select(u => new 
    {
        u.FirstName,
        u.LastName
    })
    .ToList();

foreach (var user in users)
{
    Console.WriteLine($"{user.FirstName} {user.LastName}");
}

Pro tip: If you have 10,000 users and each User object is 5KB, you just saved 50MB of memory.

Mistake #4: Where() Then FirstOrDefault()

This one's subtle but I see it all the time:

var user = _context.Users
    .Where(u => u.Id == userId)
    .FirstOrDefault();

It works, but you can simplify it:

var user = _context.Users
    .FirstOrDefault(u => u.Id == userId);

Mistake #5: Calling ToList() Too Early

This is the opposite problem - calling ToList() before you're done building the query:

var users = _context.Users
    .Where(u => u.IsActive)
    .ToList(); // Too early!

// Now filtering in memory instead of database
var admins = users
    .Where(u => u.Role == "Admin")
    .ToList();

Keep it as IQueryable until the end:

var admins = _context.Users
    .Where(u => u.IsActive)
    .Where(u => u.Role == "Admin")
    .ToList(); // Now it's all in one SQL query

Mistake #6: The N+1 Query Problem

This is the classic. Probably the worst performance killer in LINQ:

var users = _context.Users.ToList();

foreach (var user in users)
{
    // Hitting database for EACH user!
    var orders = _context.Orders
        .Where(o => o.UserId == user.Id)
        .ToList();
    
    Console.WriteLine($"{user.Name} has {orders.Count} orders");
}

Use Include() or a join:

// Option 1: Include
var users = _context.Users
    .Include(u => u.Orders)
    .ToList();

foreach (var user in users)
{
    Console.WriteLine($"{user.Name} has {user.Orders.Count} orders");
}

// Option 2: Join with grouping
var userOrders = _context.Users
    .Select(u => new
    {
        u.Name,
        OrderCount = u.Orders.Count
    })
    .ToList();

foreach (var item in userOrders)
{
    Console.WriteLine($"{item.Name} has {item.OrderCount} orders");
}

Mistake #7: OrderBy Before Take/First

Sometimes the order matters. Look at this:

// Wrong order - sorts everything first
var user = _context.Users
    .Where(u => u.IsActive)
    .OrderBy(u => u.Name)
    .FirstOrDefault();

vs

// Better - filter first, then sort
var user = _context.Users
    .Where(u => u.IsActive)
    .Where(u => u.Role == "Admin")
    .OrderBy(u => u.Name)
    .FirstOrDefault();

Mistake #8: Complex Operations in Where Clauses

LINQ to SQL can't translate everything to SQL. This will bite you:

var users = _context.Users
    .Where(u => u.FirstName.ToUpper() + " " + u.LastName.ToUpper() == searchTerm)
    .ToList();

Keep your Where clauses simple:

var users = _context.Users
    .Where(u => u.FirstName.Contains(searchTerm) || 
                u.LastName.Contains(searchTerm))
    .ToList();

// Or do complex stuff after ToList()
var users = _context.Users
    .Where(u => u.IsActive)
    .ToList()
    .Where(u => (u.FirstName + " " + u.LastName).ToUpper() == searchTerm)
    .ToList();

The Bottom Line

LINQ is powerful, but it's easy to write code that looks fine but performs terribly. I've made every single one of these mistakes. Some of them multiple times.

Look, your code doesn't have to be perfect. But knowing these common mistakes will save you from some really painful debugging sessions when your app starts slowing down in production.

Now go fix those queries! Your future self (and your database) will thank you.