LINQ

var numbers = new List<int> { 1, 2, 3 };
int first = numbers.First(n => n > 1);              // 2
int? firstOrNone = numbers.FirstOrDefault(n => n > 10); // 0 (default for int)
int single = numbers.Single(n => n == 2);            // 2 -- exactly one match required

Common follow-ups: Why might using Single() instead of First() actually help CATCH a subtle data bug rather than just being 'more strict for no reason'?

IEnumerable<User> inMemory = users.Where(u => u.IsActive); // runs entirely in C#, in-process

IQueryable<User> fromDb = dbContext.Users.Where(u => u.IsActive); // translated to SQL: WHERE IsActive = 1
// dbContext.Users.Where(u => SomeComplexCSharpOnlyMethod(u)); // may throw: can't translate to SQL

Common follow-ups: Why does calling .ToList() or .AsEnumerable() partway through an EF Core query change what CAN be used in the REMAINING LINQ chain?

public static IEnumerable<T> MyDistinctBy<T, TKey>(this IEnumerable<T> source, Func<T, TKey> keySelector) {
  var seenKeys = new HashSet<TKey>();
  foreach (var item in source) {
    if (seenKeys.Add(keySelector(item))) yield return item; // Add() returns false if already present
  }
}
var uniqueByEmail = users.MyDistinctBy(u => u.Email).ToList();

Common follow-ups: Why is it important that this custom extension method ALSO be implemented lazily (yield return), rather than eagerly building a List<T>?

var words = new[] { "Hello", "World", "LINQ" };
string sentence = words.Aggregate((acc, word) => acc + " " + word);
// "Hello World LINQ"

int product = new[] { 1, 2, 3, 4 }.Aggregate(1, (acc, n) => acc * n); // 24, with a seed value

Common follow-ups: What's the difference between the overload of Aggregate() with a seed value versus the one without?

var results = customers.GroupJoin(
    orders,
    customer => customer.Id,
    order => order.CustomerId,
    (customer, customerOrders) => new {
      customer.Name,
      OrderCount = customerOrders.Count() // 0 for customers with no matching orders, unlike an inner Join
    });

Common follow-ups: How does regular Join() (INNER JOIN semantics) behave differently for customers with no matching orders at all?

// N+1 problem: triggers a SEPARATE query for EACH order's Customer, inside the loop
var orders = dbContext.Orders.ToList();
foreach (var order in orders) { Console.WriteLine(order.Customer.Name); } // 1 + N queries!

// Fixed with eager loading: ONE query total
var ordersFixed = dbContext.Orders.Include(o => o.Customer).ToList();
foreach (var order in ordersFixed) { Console.WriteLine(order.Customer.Name); } // just 1 query

Common follow-ups: How would you detect an N+1 query problem occurring in a real application, using EF Core's logging or a profiling tool?

// Manual loop
var evenNumbers = new List<int>();
foreach (var n in numbers) { if (n % 2 == 0) evenNumbers.Add(n); }

// Equivalent LINQ, more concise and declarative
var evenNumbers = numbers.Where(n => n % 2 == 0).ToList();

// Deferred execution: no filtering happens until .ToList() is actually called
var query = numbers.Where(n => n > 2);
var result = query.ToList(); // filtering runs HERE, not when 'query' was defined

Common follow-ups: What specific LINQ operations (GroupBy, Join, Aggregate) go beyond simple filtering?;Why does deferred execution sometimes cause a query to unexpectedly re-run and produce different results?

// Inefficient: pulls ALL rows into memory, THEN filters
IEnumerable<User> users = dbContext.Users;
var adults = users.Where(u => u.Age >= 18); // filtering happens in memory, after loading everything

// Efficient: filter is translated to SQL and applied by the database
IQueryable<User> query = dbContext.Users.Where(u => u.Age >= 18);
var adults = query.ToList(); // only matching rows are ever retrieved

Common follow-ups: How would you detect in code review that an IEnumerable-typed query is about to cause a full table scan?;What's the risk of calling .ToList() too early in a LINQ chain against Entity Framework?