Entity Framework Core interview questions covering LINQ translation, filtering, projection, pagination, joins, grouping and query execution.
Open a question for the full answer, code and interview guidance.
EF Core builds an expression tree from an IQueryable LINQ query and asks the configured database provider to translate supported expressions into its query language, usually SQL. The query is normally sent only when it is enumerated or materialized.
IQueryable<T> represents a composable query whose expression can be translated by a query provider such as EF Core. Operators added before execution can become part of the SQL sent to the database.
IQueryable represents a query that EF Core can continue translating into SQL. IEnumerable represents normal .NET enumeration semantics, usually after data has already been materialized or when execution has moved to client-side objects.
Deferred execution means constructing an IQueryable does not usually execute the database query immediately. The query is executed when a terminal operation such as ToListAsync, FirstOrDefaultAsync, CountAsync, or enumeration requires results.
Immediate execution occurs when an operation requires the query result now. Methods such as ToListAsync, ToArrayAsync, FirstAsync, SingleAsync, CountAsync, AnyAsync, and MaxAsync normally trigger database execution.
Where adds a filtering predicate to the query. When the predicate can be translated, EF Core generates a corresponding SQL WHERE condition so unwanted rows are filtered by the database.
Select defines the shape of the query result. Instead of loading every column of an entity, projection can retrieve only the fields required by a page, API, or calculation.
OrderBy or OrderByDescending establishes the primary sort order. ThenBy or ThenByDescending adds secondary ordering when values in the previous sort key are equal.
Skip omits a number of rows and Take limits the number returned. Together they implement offset pagination and are translated by relational providers into suitable SQL constructs.
Keyset, or seek, pagination retrieves the next page relative to the last seen ordering key instead of skipping an increasing number of rows.
FirstOrDefault returns the first matching row or the default value when no row exists. SingleOrDefault expects zero or one matching row and fails if multiple rows match.
First expects at least one result and throws if the sequence is empty. FirstOrDefault returns the default value, usually null for a reference type, when no row matches.
Any asks whether at least one matching row exists. Count calculates how many matching rows exist.
LINQ aggregate operators such as Count, Sum, Average, Min, and Max can be translated into database aggregate functions.
GroupBy groups query rows by one or more keys. When followed by translatable aggregate operations, EF Core can commonly translate it into SQL GROUP BY.
EF Core can translate LINQ Join operations into SQL joins. However, when relationships are correctly modeled, navigation properties often provide more readable queries and allow EF Core to generate the required joins automatically.
When EF Core knows a relationship, a query can navigate through reference or collection properties and the provider can translate that navigation into appropriate SQL.
SelectMany flattens nested collections into a single sequence. In EF Core it can be useful for querying child entities through a parent's collection navigation or expressing certain join-like query shapes.
Contains can test whether a value exists in a collection or query. A local collection of identifiers is commonly translated into an SQL IN-style predicate by relational providers.
Many common string operations can be translated into database expressions, but exact translation and case-sensitivity behavior depend on the provider and database collation.
EF.Functions exposes database-oriented functions that can participate in LINQ translation. Providers may offer functions such as LIKE operations or provider-specific extensions through this API.
Client evaluation means part of a query is executed by .NET after data has been obtained rather than translated to the database. Modern EF Core restricts unsupported client evaluation in important query positions because silently downloading large tables could cause severe performance problems.
EF Core queries can expose their generated SQL through ToQueryString for diagnostic purposes before execution. Application logging can also capture executed database commands when appropriate logging categories and levels are enabled.
EF Core normally caches aspects of query compilation automatically, but explicit compiled queries can reduce repeated query-compilation overhead in selected hot paths.
Keep filtering, sorting, aggregation, and projection on the database side whenever practical. Project only required columns, use AsNoTracking for read-only entity queries, paginate large result sets, and avoid materializing data before the database-side query is complete.