Interview Q&A

Answer: re loaded, and compares them before saving. Notifications: If your entities implement INotifyPropertyChanged, EF can track changes immediately. EF compares the current values to the original snapshot during SaveChanges().

What interviewers expect

• A clear definition tied to EF Core in Entity Framework Core projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Entity Framework Core application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Entity Framework Core architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

EF Core tracks changes via:

• Snapshot change tracking: EF stores a snapshot of original values when entities

are loaded, and compares them before saving.

• Notifications: If your entities implement INotifyPropertyChanged, EF can track

changes immediately.

EF compares the current values to the original snapshot during SaveChanges().

Answer: You can disable tracking by default for a specific DbContext using: optionsBuilder.UseQueryTrackingBehavior(QueryTrackingBehavior.NoTrac king); Or per-query using .AsNoTracking().

What interviewers expect

• A clear definition tied to EF Core in Entity Framework Core projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Entity Framework Core application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Entity Framework Core architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

Use the Entry() method:

context.Entry(entity).State = EntityState.Modified;
context.Entry(entity).State = EntityState.Detached;

This is helpful when:

• You’re updating data without reloading it
• Working with disconnected scenarios (e.g., APIs)

What is optimistic concurrency vs

pessimistic concurrency?

• Optimistic concurrency: Assumes that conflicts are rare. EF checks for changes

before saving using concurrency tokens.

• Pessimistic concurrency: Locks records in the DB to prevent other updates (not

supported out-of-the-box in EF Core).

EF Core supports optimistic concurrency using [ConcurrencyCheck] or

[Timestamp].

EF Core supports the standard types of relationships:

• One-to-One (1:1) – One entity has one related entity.
• One-to-Many (1:N) – One entity relates to many others.
• Many-to-Many (M:N) – Many entities relate to many others.

Each of these can be configured in EF Core using navigation properties and Fluent API or

Data Annotations.

Example using Fluent API:

modelBuilder.Entity<User>()

.HasOne(u => u.Profile)

.WithOne(p => p.User)

.HasForeignKey<Profile>(p => p.UserId);

Or with data annotations:

public class Profile
{

[Key, ForeignKey("User")]

public int UserId { get; set; }
public User User { get; set; }
}

• Requires a unique foreign key.
• EF assumes optional by default unless marked as required.

Fluent API:

modelBuilder.Entity<Blog>()

.HasMany(b => b.Posts)

.WithOne(p => p.Blog)

.HasForeignKey(p => p.BlogId);

Data annotations:

public class Post
{
public int BlogId { get; set; }

[ForeignKey("BlogId")]

public Blog Blog { get; set; }
}

• A foreign key exists in the many-side entity (Post).
• EF infers this relationship from navigation + FK.

In EF Core 5.0+, you can define many-to-many relationships without an explicit join entity:

public class Student
{
public ICollection<Course> Courses { get; set; }
}
public class Course
{
public ICollection<Student> Students { get; set; }
}

EF will automatically create a join table CourseStudent behind the scenes.

If you want to customize the join table, define a join entity explicitly.

join table maps a many-to-many relationship. In EF Core:

✅ Auto-created (EF Core 5+):

If you define many-to-many with ICollection<T>, EF creates the join table.

🛠 Manual (custom join entity):

public class StudentCourse
{
public int StudentId { get; set; }
public Student Student { get; set; }
public int CourseId { get; set; }
public Course Course { get; set; }
}

nd configure with Fluent API.

How to represent them in EF

Core?

A join table maps a many-to-many relationship. In EF Core:

✅ Auto-created (EF Core 5+):

If you define many-to-many with ICollection<T>, EF creates the join table.

🛠 Manual (custom join entity):

public class StudentCourse

public int StudentId { get; set; }

public Student Student { get; set; }

public int CourseId { get; set; }

public Course Course { get; set; }

And configure with Fluent API.

How to define them via

annotations & Fluent API?

• Primary Key (PK): Unique identifier of a record.
• Foreign Key (FK): A field that references a PK in another table.

Data Annotations:

[Key]

public int Id { get; set; }

[ForeignKey("Blog")]

public int BlogId { get; set; }

Fluent API:

modelBuilder.Entity<Post>()

.HasKey(p => p.Id);

modelBuilder.Entity<Post>()

.HasOne(p => p.Blog)

.WithMany(b => b.Posts)

.HasForeignKey(p => p.BlogId);

shadow property is a property not defined in the .NET class but exists in the EF model.

Example:

modelBuilder.Entity<Post>()

.HasOne<Blog>()

.WithMany()

.HasForeignKey("BlogId"); // BlogId is a shadow FK if not

defined in class

EF tracks it internally but you can't access it in C# code directly.

In Fluent API:

• Required:

.HasRequired(p => p.Blog)

• Optional:

.HasOne(p => p.Blog)

.WithMany()

.IsRequired(false);

EF infers:

• Reference type (e.g., Blog) → optional by default
• Non-nullable value type FK (e.g., int BlogId) → required

Entity Framework Core – Lazy vs

Eager vs Explicit Loading

Loading

Type

Pros Cons

Eager Fewer queries, good for large data

sets

Loads everything even if not used

Lazy Loads only when needed Risk of N+1 queries, more

round-trips

Explicit Fine-grained control More code complexity

✅ Eager is best for performance when you know you'll need related data.

❌ Lazy can hurt performance unless used carefully (e.g., in UI apps).

Answer: Yes. You can disable lazy loading globally: options.UseLazyLoadingProxies(false); Or don't install the proxy package at all. You can also disable it for specific navigation properties by not making them virtual.

What interviewers expect

• A clear definition tied to EF Core in Entity Framework Core projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Entity Framework Core application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Entity Framework Core architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

Answer: How? Yes. You can disable lazy loading globally: options.UseLazyLoadingProxies(false); Or don't install the proxy package at all. You can also disable it for specific navigation properties by not making them virtual.

What interviewers expect

• A clear definition tied to EF Core in Entity Framework Core projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Entity Framework Core application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Entity Framework Core architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

• EF Core translates LINQ queries into SQL using expression trees.
• Only supported LINQ operators and expressions can be translated.
• Limitations:
• Certain C# methods or complex expressions cannot be translated and

cause runtime exceptions.

• Client-side evaluation may occur, which can hurt performance.
• Use .AsEnumerable() to switch to client-side processing intentionally.

What limitations are there?

• EF Core translates LINQ queries into SQL using expression trees.
• Only supported LINQ operators and expressions can be translated.
• Limitations:
• Certain C# methods or complex expressions cannot be translated and

cause runtime exceptions.

• Client-side evaluation may occur, which can hurt performance.
• Use .AsEnumerable() to switch to client-side processing intentionally.

• IQueryable<T>:
• Represents a query against the data source.
• Query is translated to SQL and executed on the database.
• Supports deferred execution.
• IEnumerable<T>:
• Represents an in-memory collection.
• LINQ operators execute in memory.
• Usually results after the query has executed and data is loaded.

• Inner join example:

var query = from c in context.Customers

join o in context.Orders on c.Id equals o.CustomerId

select new { c.Name, o.OrderDate };

• Left join (using DefaultIfEmpty()):

var query = from c in context.Customers

join o in context.Orders on c.Id equals o.CustomerId

into orders

from o in orders.DefaultIfEmpty()

select new { c.Name, OrderDate = o != null ? o.OrderDate

: (DateTime?)null };

var groupedData = context.Orders

.GroupBy(o => o.CustomerId)

.Select(g => new

{

CustomerId = g.Key,

TotalOrders = g.Count(),

TotalAmount = g.Sum(o => o.Amount),

MaxAmount = g.Max(o => o.Amount),

MinAmount = g.Min(o => o.Amount)

});

Answer: Filtering: var filtered = context.Products.Where(p =&gt; p.Price &gt; 100); Ordering: var ordered = context.Products .OrderBy(p =&gt; p.Category) .ThenByDescending(p =&gt; p.Price);

What interviewers expect

• A clear definition tied to EF Core in Entity Framework Core projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Entity Framework Core application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Entity Framework Core architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

• First(): Returns the first element, throws if none found.
• FirstOrDefault(): Returns first element or default (null) if none.
• Single(): Returns the single element, throws if zero or more than one.
• SingleOrDefault(): Returns the single element or default if none; throws if more

than one.

Answer: Use .Skip() and .Take() for pagination: var page2 = context.Products .OrderBy(p =&gt; p.Id) .Skip(10) // Skip first 10 .Take(10) // Take next 10 .ToList();

What interviewers expect

• A clear definition tied to EF Core in Entity Framework Core projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Entity Framework Core application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Entity Framework Core architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.