LINQ Interview Questions

Analogy categoryAnalogies

The Conceptual Question Every Interviewer Asks

Almost every C# interview that touches LINQ opens with some version of 'explain deferred execution and the difference between IEnumerable<T> and IQueryable<T>.' The correct answer is that a LINQ query built with Where/Select/OrderBy is not executed when it is written — it is a description of work that runs when the sequence is actually enumerated, whether by a foreach, ToList(), or a similar trigger. IQueryable<T> extends this idea one step further: the query is represented as an Expression<Func<...>> expression tree rather than a compiled delegate, so a provider like EF Core can translate it into another language (SQL) before execution, whereas IEnumerable<T> LINQ always runs as compiled C# against objects already in memory.

🏏

Cricket analogy: It's like a bowling plan discussed in the dressing room before the match — the plan (the query) isn't 'executed' until the bowler actually runs in and delivers the ball (enumeration), and a plan written for a specific pitch (IQueryable, translated to conditions) differs from generic net-practice drills (IEnumerable, always the same regardless of context).

Method Syntax vs Query Syntax

Interviewers sometimes probe whether a candidate understands that query syntax (from x in source where x.IsActive select x) and method syntax (source.Where(x => x.IsActive)) are two spellings of the same thing — the C# compiler translates query syntax into method syntax at compile time, so they produce identical expression trees or delegates. The nuance worth knowing is that not every LINQ operator has a query-syntax keyword: SelectMany, GroupJoin, and most aggregate operators like Sum, Any, or FirstOrDefault have no direct query-syntax equivalent for their most common forms, so real code frequently mixes a query-syntax block with a trailing method call, such as (from o in orders where o.Total > 100 select o).Any().

🏏

Cricket analogy: It's like reporting the same delivery as either 'good length outside off, angled away' (query syntax, descriptive) or as a raw ball-tracking data line (method syntax, terse) — both describe the identical delivery, but a stat like 'economy rate' has no natural descriptive-commentary phrasing and just gets reported as a number, the way Sum or Any has no query-syntax keyword.

Coding Challenges Interviewers Actually Ask

A staple LINQ coding challenge is 'find duplicate elements in a list,' typically solved with numbers.GroupBy(n => n).Where(g => g.Count() > 1).Select(g => g.Key), which groups by value and keeps only groups with more than one member. A close cousin is 'find the top N items by some metric,' solved with OrderByDescending(x => x.Score).Take(n), and interviewers often follow up by asking how to do it without sorting the entire sequence, expecting the candidate to at least mention that OrderBy is O(n log n) and that a heap-based approach would be more efficient for very large n with small fixed n, even though plain LINQ doesn't expose that natively.

🏏

Cricket analogy: It's like being asked to find every batter who's scored a century in more than one match this season — GroupBy value, filter groups with Count() > 1 — and then asked for 'top 5 run-scorers,' which is OrderByDescending on runs followed by Take(5), the standard way any season leaderboard is built.

csharp

// Classic interview task: find duplicate values in a list.
var duplicates = numbers
    .GroupBy(n => n)
    .Where(g => g.Count() > 1)
    .Select(g => g.Key)
    .ToList();

// Follow-up: top 5 highest scores without sorting the whole list conceptually
// (LINQ's OrderBy is O(n log n); mention a heap/priority-queue alternative
// exists for very large n with small fixed top-N counts).
var top5 = players
    .OrderByDescending(p => p.Score)
    .Take(5)
    .ToList();

A common trap: calling First() when you mean FirstOrDefault(). First() throws InvalidOperationException on an empty sequence, which is exactly the kind of edge case interviewers probe for — always ask (or state aloud) whether the sequence is guaranteed non-empty before choosing between First and FirstOrDefault, or Single and SingleOrDefault.

Performance and Gotchas Interviewers Probe

Beyond syntax, strong candidates are expected to flag that LINQ queries are lazily evaluated, so enumerating the same IEnumerable<T> query twice (say, once in an if (query.Any()) and again in a foreach (var x in query)) re-runs the entire query both times unless it was materialized with ToList() first — for an expensive query (a database call, a file read) this is a real performance bug, not just a style nitpick. Interviewers also like asking about exception-throwing operators versus their safe counterparts: First/Single/Last throw on failure while FirstOrDefault/SingleOrDefault/LastOrDefault return default(T), and a sharp answer notes that Single specifically also throws if more than one element matches, which makes it useful as an implicit uniqueness assertion, not just a fetch.

🏏

Cricket analogy: It's like re-running a full ball-by-ball replay of an entire innings twice because you asked 'did anyone hit a six?' and then separately asked 'list all the sixes' — a smart analyst caches the innings data once (materializes with ToList) instead of replaying it from scratch for each question.

A strong interview answer connects the concept back to Big-O: mention that Where/Select/OrderBy over an in-memory List<T> are O(n) or O(n log n) respectively, that Contains on a List<T> is O(n) while Contains on a HashSet<T> is O(1) average, and that choosing the right underlying collection matters as much as choosing the right LINQ operator.

Deferred execution means a LINQ query runs when enumerated, not when it is written — enumerating twice without materializing re-runs the whole query.
IQueryable<T> builds an expression tree that a provider (like EF Core) can translate to another query language; IEnumerable<T> always runs compiled C# in memory.
Query syntax and method syntax compile to the same result, but operators like SelectMany, Any, and Sum have no direct query-syntax keyword.
The GroupBy-then-filter-by-Count()-greater-than-one pattern is the standard way to find duplicates in LINQ.
First/Single/Last throw on failure; their OrDefault counterparts return default(T) instead — Single additionally throws on more than one match.
Being able to reason about Big-O (Any's short-circuiting, OrderBy's O(n log n), HashSet<T>'s O(1) Contains) signals a stronger candidate than syntax recall alone.