LINQ interview questions covering deferred execution, materialization, multiple enumeration, query composition, pagination and execution behavior.
Open a question for the full answer, code and interview guidance.
Deferred execution means that defining a LINQ query does not necessarily execute it immediately. Many sequence-returning operators, including Where and Select, store the query logic and perform the work when the result is enumerated.
Operators that return another sequence commonly use deferred execution. Examples include Where, Select, SelectMany, Take, Skip, Distinct, and many ordering or grouping operations.
Operators that produce a scalar value or materialize a collection execute the source immediately. Common examples include ToList, ToArray, ToDictionary, Count, LongCount, Any, All, First, Single, Sum, Average, Min, and Max.
Deferred execution means execution is postponed until the result is needed. Lazy evaluation is closely related but emphasizes producing values only as they are requested.
A streaming LINQ operator can process and yield elements without first consuming the entire source. Where and Select are common examples.
A deferred query normally reads the source when it is enumerated, not when the query variable is created. Therefore, changes made before enumeration can affect the results.
Multiple enumeration occurs when an IEnumerable<T> query is enumerated more than once. With a deferred query, the underlying operations can run again each time.
Materialize a sequence once when its results will be reused and a snapshot is appropriate. A List<T> or array can then be enumerated repeatedly without re-running the original deferred pipeline.
ToList immediately enumerates the source and stores the results in a new List<T>. It creates an in-memory snapshot of the query result at that moment.
Both enumerate the source immediately and materialize the results. ToList returns List<T>, while ToArray returns T[].
ToDictionary materializes a sequence into a Dictionary<TKey,TValue> using a key selector and, optionally, an element selector or comparer.
ToDictionary expects one value per unique key and throws when duplicate keys are produced. ToLookup supports multiple elements for the same key.
AsEnumerable exposes a source as IEnumerable<T>. It does not itself copy or materialize the data.
AsQueryable exposes a compatible source through IQueryable<T>. If the source already implements IQueryable<T>, it is returned as a queryable source. For an in-memory IEnumerable<T>, LINQ can provide a queryable wrapper.
AsEnumerable does not materialize the source; it changes the compile-time query interface used for subsequent operations. ToList immediately enumerates the source and stores the results in a new list.
IQueryable<T> represents a query definition that a provider may continue translating. A materialized List<T> or array contains actual in-memory results that have already been retrieved.
Early materialization can retrieve more rows or columns than the application needs and forces later filtering or projection to happen in memory. This can increase database work, network traffic, application memory usage, and response time.
Because a deferred query is not fully executed when it is defined, some exceptions caused by enumeration occur later, when the query is consumed.
Query composition means building a query incrementally by applying additional operators before execution. This is especially useful with IQueryable because each step can contribute to one expression tree that a provider later translates.
Start with an IEnumerable<T> or IQueryable<T> variable and conditionally append operators. For more complex provider-based scenarios, expression trees can be constructed or combined to create dynamic predicates.
Some LINQ operators stop enumeration as soon as they have enough information to produce a result. Examples include Any, First, FirstOrDefault, and Take.
Skip ignores a specified number of elements, while Take returns a specified number of following elements. Together they can implement offset-based pagination.
Pagination requires a defined sequence order. Without deterministic ordering, a database is not required to return rows in a stable natural order, so records can appear on unexpected pages or move between requests.
The result depends on what data the predicate requires and what shape Select produces. Filtering before projection is often natural when the predicate uses source properties. Filtering after projection is valid when the projected shape contains everything required.
Know whether the source is IEnumerable<T> or IQueryable<T>, understand which operators are deferred, and materialize only when a concrete snapshot is needed. Avoid accidental multiple enumeration of expensive sources.