Top 30 Entity Framework Interview Questions and Answers for Freshers

Entity Framework (EF) is a widely-used Object-Relational Mapping (ORM) framework for .NET applications, simplifying data access by allowing developers to work with databases using .NET objects. For freshers preparing for interviews, it’s essential to understand both fundamental and advanced concepts of EF. Below are 30 Entity Framework commonly asked interview questions and answers to help you prepare effectively.

Top 30 Entity Framework Interview Questions for Freshers

1. What is Entity Framework (EF)?
2. Explain Lazy Loading and Eager Loading in Entity Framework.
3. What are the key components of Entity Framework Core?
4. Explain the differences between Add, Attach, and Update methods in Entity Framework Core.
5. What is the purpose of migrations in Entity Framework Core?
6. How does Entity Framework handle relationships between entities?
7. Explain how Entity Framework handles transactions.
8. What is the role of DbSet in Entity Framework?
9. Explain concurrency handling in Entity Framework.
10. Explain shadow properties in EF Core.
11. What Is Entity Framework Core, and How Does It Differ from Entity Framework 6?
12. Explain the Role of LINQ in Entity Framework.
13. What Is a Navigation Property in Entity Framework?
14. How Do You Configure a One-to-Many Relationship in Entity Framework Code First?
15. What Is the Purpose of the OnModelCreating Method in Entity Framework?
16. How Can You Disable Lazy Loading in Entity Framework?
17. Explain the Difference Between the Add and Attach Methods in DbSet.
18. How Does Entity Framework Track Changes in Entities?
19. What Is Change Tracking in Entity Framework?
20. What Are Data Annotations in Entity Framework, and How Are They Used?
21. How Can You Use Fluent API to Configure Your Models in Entity Framework?
22. What Is TPH (Table per Hierarchy) Inheritance in Entity Framework?
23. What Is TPT (Table per Type) Inheritance in Entity Framework?
24. How Do You Implement Auditing (e.g., Created Date, Modified Date) in Entity Framework?
25. Explain the Concept of Shadow Properties in Entity Framework Core.
26. What Is the Use of Value Conversions in Entity Framework Core?
27. How Can You Log SQL Queries Generated by Entity Framework?
28. What Are Compiled Queries in Entity Framework?
29. Explain the Use of the Database.EnsureCreated and Database.Migrate Methods.
30. How Can You Handle Cascading Deletes in Entity Framework?

1. What is Entity Framework (EF)?

Answer: Entity Framework (EF) is an open-source object-relational mapping (ORM) framework for .NET applications. It allows developers to work with databases using .NET objects, eliminating the need for most data-access code. EF simplifies database interactions by providing a higher-level abstraction over raw SQL queries, enabling developers to focus more on business logic rather than database schema and queries.

EF supports three primary approaches to database interaction:

• Code First: In this approach, developers define their data models using C# or VB.NET classes. EF then generates the database schema based on these classes. This method is particularly useful for new projects where the database design can evolve alongside the application code.
• Database First: This approach starts with an existing database. EF generates the data model classes from the current schema. It’s ideal for projects that involve legacy databases or where the database design is managed separately from the application code.
• Model First: Developers create a visual model of the database using a designer tool, and EF generates both the classes and the database schema from this model. This approach is beneficial for planning and modifying the database schema visually before implementation.

2. Explain Lazy Loading and Eager Loading in Entity Framework.

Answer: Lazy loading and eager loading are two strategies used by Entity Framework to manage related data retrieval.

• Lazy Loading: This technique delays the loading of related data until it is specifically accessed. For example, if you have a Blog entity with a collection of Posts, the Posts collection will not be loaded until you explicitly access it (e.g., blog.Posts). This can improve performance by reducing initial load times but may lead to multiple database queries if many related entities are accessed individually.
• Eager Loading: In contrast, eager loading retrieves related data at the same time as the main entity query. This is done using the Include method. For instance, context.Blogs.Include(b => b.Posts) fetches both blogs and their associated posts in a single query. Eager loading can be more efficient when you know you will need related data upfront, as it minimizes round trips to the database.

3.What are the key components of Entity Framework Core?

Answer: Entity Framework Core (EF Core) includes several key components that facilitate its functionality:

• DbContext: This is the primary class responsible for interacting with the database. It manages entity objects during runtime, allowing CRUD (Create, Read, Update, Delete) operations and tracking changes made to those entities.
• DbSet: Represents a collection of entities of a specific type that can be queried from the database. Each DbSet corresponds to a table in the database.
• Entity Configuration: EF Core uses Fluent API or Data Annotations to configure how entities map to database tables. This includes defining primary keys, relationships, and constraints.
• Migrations: A feature that helps manage changes to the data model over time by creating scripts that update the database schema without losing existing data.

4. Explain the differences between Add, Attach, and Update methods in Entity Framework Core.

Answer: The methods Add, Attach, and Update in EF Core serve different purposes when managing entity states:

• Add: This method is used to add a new entity to the context. When you call context.Add(entity), EF marks it as “Added,” indicating that it should be inserted into the database upon saving changes.
• Attach: Use this method when you have an existing entity that was not tracked by the context but you want to start tracking it without making any changes. For example, if you retrieve an entity from another context or from a detached state, calling context.Attach(entity) marks it as “Unchanged.”
• Update: This method is used when you want to modify an existing entity in your context. When you call context.Update(entity), EF marks all properties of that entity as modified and will generate an update statement when saving changes.

5. What is the purpose of migrations in Entity Framework Core?

Answer: Migrations in EF Core are designed to manage changes to your data model over time while preserving existing data in your database. They allow developers to:

• Create a versioned history of changes made to the model.
• Generate SQL scripts that can be executed against a database to apply these changes.
• Roll back changes if needed by reverting to previous migration states.

When you modify your data model (e.g., adding or removing properties), you can create a new migration using commands like Add-Migration MigrationName, which captures these changes. Applying migrations with Update-Database updates your actual database schema accordingly.

6. How does Entity Framework handle relationships between entities?

Answer: Entity Framework supports various types of relationships between entities:

• One-to-One: A relationship where one entity instance is related to one instance of another entity. For example, each user may have one profile.
• One-to-Many: A common relationship where one entity can be related to multiple instances of another entity. For instance, one blog can have many posts.
• Many-to-Many: In this relationship type, multiple instances of one entity can relate to multiple instances of another entity. For example, students can enroll in multiple courses while each course can have multiple students enrolled.

To define these relationships in EF Core, developers use navigation properties within their entities along with Fluent API or Data Annotations for configuration.

7. Explain how Entity Framework handles transactions.

Answer: Entity Framework manages transactions through its DbContext class and provides mechanisms for handling transactions explicitly:

1. SaveChanges: When calling context.SaveChanges(), EF wraps all operations in a transaction by default. If any operation fails, all changes are rolled back automatically.
2. Database.BeginTransaction: For more complex scenarios where multiple SaveChanges calls need to be treated as a single transaction, developers can create explicit transactions using IDbContextTransaction. For example:

   using var transaction = context.Database.BeginTransaction();
   try
   {
       // Perform multiple operations
       context.SaveChanges();
       transaction.Commit();
   }
   catch
   {
       transaction.Rollback();
   }

This allows for fine-grained control over transaction management beyond simple SaveChanges calls.

8. What is the role of DbSet in Entity Framework?

Answer: The DbSet class represents a collection of entities that can be queried from or saved to a database table within Entity Framework. Each DbSet corresponds directly to a table in your underlying database and provides methods for querying and manipulating data:

• Querying Data: You can use LINQ queries on DbSet properties to retrieve data from your tables easily.
• Adding Data: New entities can be added directly through DbSet using methods like Add() or AddRange().
• Updating Data: Existing entities can be updated by retrieving them via DbSet and modifying their properties before calling SaveChanges().

DbSets are essential for working with collections of entities and facilitate CRUD operations within your application’s context.

9. Explain concurrency handling in Entity Framework.

Answer: Concurrency handling in Entity Framework ensures that multiple users do not inadvertently overwrite each other’s changes when updating shared data. There are two primary strategies for handling concurrency:

1. Optimistic Concurrency Control: This approach assumes that conflicts are rare; thus, it allows multiple users to read data without locking it but checks for conflicts before saving changes. If another user has modified an entity since it was retrieved, an exception is thrown when attempting to save changes. Developers typically handle this exception by prompting users or merging changes manually.
2. Pessimistic Concurrency Control: In this strategy, locks are placed on records while they are being edited, preventing other users from accessing them until they are released. While effective at preventing conflicts, this approach can lead to reduced performance due to waiting times for locked resources.

To implement optimistic concurrency control in EF Core, developers often use timestamp columns or version numbers in their entities and configure them accordingly using Fluent API or Data Annotations.

10. Explain shadow properties in EF Core.

Answer: Shadow properties are properties defined in your model that do not have corresponding CLR (Common Language Runtime) properties in your entity classes but exist solely within EF’s context for tracking purposes. They allow developers to maintain additional information about an entity without modifying its class definition directly.

For example:

modelBuilder.Entity<Blog>()
    .Property<DateTime>("LastUpdated");

In this case, “LastUpdated” becomes a shadow property that EF tracks but isn’t accessible through standard property accessors on Blog instances directly. Shadow properties are particularly useful for scenarios like auditing or maintaining metadata without cluttering your domain models with additional fields that might not be relevant at all times.

11. What Is Entity Framework Core, and How Does It Differ from Entity Framework 6?

Answer: Entity Framework Core (EF Core) is a lightweight, extensible, and cross-platform version of Entity Framework, an object-relational mapper (ORM) developed by Microsoft. EF Core is designed to work with .NET Core applications but is also compatible with .NET Framework. It enables developers to work with a database using .NET objects, eliminating the need for most data-access code.

Differences between EF Core and EF 6:

• Cross-Platform Support: EF Core supports multiple platforms, including Windows, Linux, and macOS, while EF 6 is primarily designed for Windows.
• Lightweight and Modular: EF Core has a more lightweight and modular design, allowing developers to include only the features they need.
• New Features: EF Core introduces new features like batch updates, mixed client/database evaluation in LINQ queries, and improved performance.
• Missing Features: Some features available in EF 6, such as lazy loading without proxies, are either different or not available in EF Core.

12. Explain the Role of LINQ in Entity Framework.

Answer: Language Integrated Query (LINQ) is a powerful querying tool in .NET that allows developers to write queries using C# or VB.NET syntax. In Entity Framework, LINQ to Entities enables querying the database using LINQ expressions.

Role of LINQ in Entity Framework:

• Ease of Use: LINQ provides a more readable and concise way to write queries compared to traditional SQL.
• Type Safety: Queries are checked at compile-time for syntax errors, reducing runtime errors.
• Integration with Code: LINQ queries are integrated into the programming language, allowing the use of functions, variables, and object-oriented features.
• Deferred Execution: LINQ supports deferred execution, meaning the query is executed when the data is actually accessed.

13. What Is a Navigation Property in Entity Framework?

Answer: A navigation property in Entity Framework represents a relationship between two entity types. It allows you to navigate from one entity to related entities. Navigation properties can be used in LINQ queries to load related data.

Types of Navigation Properties:

• Collection Navigation Property: Represents a collection of related entities (e.g., one-to-many or many-to-many relationships).
• Reference Navigation Property: Represents a single related entity (e.g., one-to-one or many-to-one relationships).

Usage:

Navigation properties are crucial for:

• Data Retrieval: They allow easy access to related data.
• Relationship Configuration: They help Entity Framework understand how entities are related.
• Eager Loading: They are used with methods like Include to load related data eagerly.

14. How Do You Configure a One-to-Many Relationship in Entity Framework Code First?

Answer: To configure a one-to-many relationship using Entity Framework Code First, you define navigation properties and, if necessary, use data annotations or Fluent API for more control.

Using Data Annotations:

public class Parent
{
    public int ParentId { get; set; }
    public string Name { get; set; }
    public ICollection<Child> Children { get; set; }
}

public class Child
{
    public int ChildId { get; set; }
    public string Name { get; set; }
    public int ParentId { get; set; }

    [ForeignKey("ParentId")]
    public Parent Parent { get; set; }
}

Using Fluent API:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Child>()
        .HasOne(c => c.Parent)
        .WithMany(p => p.Children)
        .HasForeignKey(c => c.ParentId);
}

Explanation:

• Parent Entity: Has a collection of Children.
• Child Entity: Has a reference to Parent and a foreign key ParentId.
• Configuration: Specifies the relationship and the foreign key.

15. What Is the Purpose of the OnModelCreating Method in Entity Framework?

Answer:

The OnModelCreating method is part of the DbContext class in Entity Framework. It is used to configure the model by overriding it in your context class.

Purpose:

• Model Configuration: Configure entity properties, relationships, and database schema details that cannot be expressed using data annotations.
• Fluent API Usage: The method provides access to the Fluent API, allowing for more granular and advanced configuration.
• Customization: Customize table names, column names, data types, indexes, and keys.

Example:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Student>()
        .Property(s => s.Name)
        .IsRequired()
        .HasMaxLength(50);

    modelBuilder.Entity<Course>()
        .ToTable("CoursesTable");
}

16. How Can You Disable Lazy Loading in Entity Framework?

Answer: Lazy loading can be disabled in Entity Framework to prevent unintentional loading of related data, which can improve performance.

Methods to Disable Lazy Loading:

• At the Context Level:

public class MyDbContext : DbContext
{
    public MyDbContext()
    {
        this.Configuration.LazyLoadingEnabled = false;
    }
}

In EF Core:

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
    optionsBuilder.UseLazyLoadingProxies(false);
}

• Removing Virtual Keyword:

Do not mark navigation properties as virtual. Lazy loading relies on creating proxy classes, which require virtual navigation properties.

• Using Eager Loading:

Explicitly load related entities using Include method in your queries.

17. Explain the Difference Between the Add and Attach Methods in DbSet.

Answer: Both Add and Attach methods are used to inform the context about entities, but they serve different purposes regarding the entity’s state.

• Add Method:
  • Purpose: Marks the entity as Added. The entity will be inserted into the database when SaveChanges is called.
  • Use Case: Use when adding new entities that do not exist in the database.
  context.Entities.Add(newEntity);
• Attach Method:
  • Purpose: Marks the entity as Unchanged. Entity Framework assumes the entity already exists in the database.
  • Use Case: Use when you have an entity that exists in the database, and you want to attach it to the context without making changes.
  context.Entities.Attach(existingEntity);

18. How Does Entity Framework Track Changes in Entities?

Answer: Entity Framework uses a mechanism called Change Tracking to keep track of changes made to entities after they are retrieved from the database.

Process:

• State Management: Each entity has a state (Added, Unchanged, Modified, Deleted, Detached).
• ObjectStateManager (EF 6) or ChangeTracker (EF Core): These components track the state of each entity.
• Detecting Changes:
  • Automatic Change Tracking: Entity Framework proxies detect changes automatically when using POCO entities with virtual properties.
  • Manual Change Detection: If proxies are not used, you may need to call context.ChangeTracker.DetectChanges() manually.
• Saving Changes: When SaveChanges is called, Entity Framework generates SQL commands based on the state of each entity.

19. What Is Change Tracking in Entity Framework?

Answer: Change Tracking is the process by which Entity Framework keeps track of changes to entities since they were retrieved from the database.

Key Points:

• Purpose: To determine what SQL commands need to be sent to the database when SaveChanges is called.
• ChangeTracker API: Provides access to information about tracked entities and their states.
• Performance Impact: Change tracking can have performance implications; disabling it for read-only operations can improve performance.

Disabling Change Tracking:

• For read-only queries, use AsNoTracking() to disable change tracking. var users = context.Users.AsNoTracking().ToList();

20. What Are Data Annotations in Entity Framework, and How Are They Used?

Answer: Data Annotations are attributes that can be applied to classes and properties to configure the model. They are part of the System.ComponentModel.DataAnnotations namespace.

Usage:

• Validation: Enforce validation rules (e.g., [Required], [MaxLength(50)]).
• Mapping: Configure how classes and properties map to the database (e.g., [Table("Students")], [Column("StudentName")]).
• Relationships: Define relationships between entities (e.g., [ForeignKey("DepartmentId")]).

Example:

[Table("Students")]
public class Student
{
    [Key]
    public int StudentId { get; set; }

    [Required, MaxLength(50)]
    public string Name { get; set; }

    [ForeignKey("Department")]
    public int DepartmentId { get; set; }
}

21. How Can You Use Fluent API to Configure Your Models in Entity Framework?

Answer: The Fluent API is an alternative to Data Annotations for configuring the model. It provides a more powerful and flexible way to configure entities.

Usage:

Override OnModelCreating: Use the OnModelCreating method in your DbContext class.

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Student>()
        .HasKey(s => s.StudentId);

    modelBuilder.Entity<Student>()
        .Property(s => s.Name)
        .IsRequired()
        .HasMaxLength(50);
}

Advantages Over Data Annotations:

• Can configure properties that cannot be set using attributes.
• Useful for configurations that involve multiple entities.
• Keeps the domain classes clean from persistence concerns.

22. What Is TPH (Table per Hierarchy) Inheritance in Entity Framework?

Answer: Table per Hierarchy (TPH) is a pattern for mapping an inheritance hierarchy of .NET classes to a single database table.

Key Points:

• Single Table: All classes in the hierarchy are mapped to one table.
• Discriminator Column: A special column is used to distinguish between different types.
• Advantages:
  • Simplifies the database schema.
  • Can offer better performance due to fewer joins.
• Disadvantages:
  • The table can become sparse if subclasses have many unique properties.
  • Not all database constraints can be enforced.

Example Configuration:

modelBuilder.Entity<Person>()
    .HasDiscriminator<string>("PersonType")
    .HasValue<Student>("Student")
    .HasValue<Teacher>("Teacher");

23. What Is TPT (Table per Type) Inheritance in Entity Framework?

Answer: Table per Type (TPT) is a pattern where each entity in an inheritance hierarchy is mapped to its own table.

Key Points:

• Separate Tables: Each class has its own table.
• Joins Required: Queries require joins between tables.
• Advantages:
  • Tables have columns only for their specific properties.
  • Enforces strict schema and constraints.
• Disadvantages:
  • Can lead to complex queries with multiple joins.
  • Potentially slower performance due to joins.

Example Configuration:

modelBuilder.Entity<Student>().ToTable("Students");
modelBuilder.Entity<Teacher>().ToTable("Teachers");

24. How Do You Implement Auditing (e.g., Created Date, Modified Date) in Entity Framework?

Answer: Auditing involves tracking changes to data, such as when an entity was created or modified.

Implementation Steps:

Add Audit Properties:

public class BaseEntity
{
    public DateTime CreatedDate { get; set; }
    public DateTime? ModifiedDate { get; set; }
}

Inherit Entities from BaseEntity:

public class Student : BaseEntity
{
    // Other properties
}

Override SaveChanges:

public override int SaveChanges()
{
    var entries = ChangeTracker.Entries<BaseEntity>();
    foreach (var entry in entries)
    {
        if (entry.State == EntityState.Added)
        {
            entry.Entity.CreatedDate = DateTime.Now;
        }
        else if (entry.State == EntityState.Modified)
        {
            entry.Entity.ModifiedDate = DateTime.Now;
        }
    }
    return base.SaveChanges();
}

Explanation:

• CreatedDate: Set when the entity state is Added.
• ModifiedDate: Set when the entity state is Modified.
• ChangeTracker: Iterates over entries to apply auditing logic.

25. Explain the Concept of Shadow Properties in Entity Framework Core.

Answer: Shadow properties are properties that are not defined in the .NET entity class but are part of the EF Core model.

Key Points:

• Usage: Useful for properties needed for mapping or tracking but that should not be part of the entity class.
• Access: Can be accessed via the ChangeTracker API or in LINQ queries using the EF.Property method.
• Example Use Cases: Timestamp fields, foreign keys, or audit information.

Example Configuration:

modelBuilder.Entity<Student>()
    .Property<DateTime>("CreatedDate");

Accessing Shadow Property:

var students = context.Students
    .Where(s => EF.Property<DateTime>(s, "CreatedDate") > someDate)
    .ToList();

26. What Is the Use of Value Conversions in Entity Framework Core?

Answer: Value Conversions allow you to convert data between the entity property type and the database column type.

Use Cases:

• Encrypting Data: Store encrypted strings in the database while using plain strings in code.
• Custom Types: Map custom value objects or enums to primitive types.
• Format Adjustments: Adjust data formats, such as storing dates in a specific format.

Example:

modelBuilder.Entity<User>()
    .Property(u => u.PhoneNumber)
    .HasConversion(
        v => Encrypt(v),
        v => Decrypt(v));

Explanation:

• HasConversion: Takes two functions, one for converting to the database type and one for converting back to the property type.
• Custom Logic: You can apply any custom logic needed for the conversion.

27. How Can You Log SQL Queries Generated by Entity Framework?

Answer: Logging SQL queries can help in debugging and optimizing performance.

In Entity Framework 6:

context.Database.Log = Console.WriteLine;

In Entity Framework Core:

Using LoggerFactory:

public static readonly ILoggerFactory MyLoggerFactory
    = LoggerFactory.Create(builder => { builder.AddConsole(); });

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
    optionsBuilder
        .UseLoggerFactory(MyLoggerFactory)
        .UseSqlServer("connection_string");
}

Using Application Logging: Integrate with logging frameworks like Serilog or NLog.

Explanation:

• Database.Log: Assigns a delegate to handle the output of SQL commands.
• LoggerFactory: Configures logging for EF Core using the standard .NET Core logging infrastructure.

28. What Are Compiled Queries in Entity Framework?

Answer: Compiled Queries are precompiled LINQ queries that can improve performance by reducing the overhead of query compilation.

Key Points:

Performance Benefit: The query is compiled once and reused, which is faster than compiling it each time.

Usage Scenario: Beneficial when the same query is executed multiple times with different parameters.

Implementation:

static readonly Func<MyDbContext, int, IQueryable<Student>> getStudents =
    EF.CompileQuery((MyDbContext context, int age) =>
        context.Students.Where(s => s.Age > age));

Execution:

var students = getStudents(context, 18).ToList();

Explanation:

• EF.CompileQuery: Compiles the query expression into a delegate.
• Delegate Execution: The compiled delegate is called with the context and parameters.

29. Explain the Use of the Database.EnsureCreated and Database.Migrate Methods.

Answer: These methods are used to manage the database schema in code.

Database.EnsureCreated():

• Purpose: Creates the database and schema if it does not exist.Use Case: Useful for quick prototyping or when not using migrations.

• Limitation: Does not update the schema if the model changes.

context.Database.EnsureCreated();

Database.Migrate():

• Purpose: Applies pending migrations to the database.Use Case: Keeps the database schema in sync with the model using migrations.

• Advantage: Safely updates the database without data loss.

context.Database.Migrate();

Explanation:

• EnsureCreated vs. Migrate:
  • EnsureCreated is simpler but less flexible.
  • Migrate is more powerful and should be used in production environments.

30. How Can You Handle Cascading Deletes in Entity Framework?

Answer: Cascading deletes automatically delete dependent entities when a principal entity is deleted.

Configuration:

Data Annotations:

public class Order
{
    public int OrderId { get; set; }
    public ICollection<OrderDetail> OrderDetails { get; set; }
}

public class OrderDetail
{
    public int OrderDetailId { get; set; }
    public int OrderId { get; set; }

    [ForeignKey("OrderId")]
    public Order Order { get; set; }
}

Fluent API:

modelBuilder.Entity<OrderDetail>()
    .HasOne(od => od.Order)
    .WithMany(o => o.OrderDetails)
    .HasForeignKey(od => od.OrderId)
    .OnDelete(DeleteBehavior.Cascade);

Delete Behaviors:

• Cascade: Dependent entities are deleted.
• Restrict: Prevents deletion if dependent entities exist.
• SetNull: Sets foreign key values to null.

Explanation:

• OnDelete Method: Configures the delete behavior for the relationship.
• Database Enforcement: The database enforces cascading deletes based on the configuration.

Learn More: Carrer Guidance

Full Stack Developer Interview Questions and Answers

Avasoft Interview Questions and answers- Basic to Advanced

Deloitte NLA Interview Questions and Answers

ADF Interview Questions Scenario based Questions with detailed Answers

Generative AI System Design Interview Questions and Answers- Basic to Advanced

Business Development Executive Interview Questions and Answers

ServiceNow Interview Questions and Answers for Experienced

ServiceNow Interview Questions and Answers-Freshers