Entity Framework Interview Questions and Answers

As data access remains a core function of enterprise .NET applications, Entity Framework (EF) has become the go-to ORM (Object-Relational Mapper) for developers working with C# and SQL Server. Recruiters must identify developers who can design scalable data models and write efficient queries using EF—whether with EF Core or traditional EF 6.x.

This resource, "100+ Entity Framework Interview Questions and Answers," is tailored for recruiters to simplify the evaluation process. It covers topics from basic ORM concepts to advanced querying, migrations, and performance tuning.

Whether hiring .NET Developers, Full-Stack Engineers, or Backend Specialists, this guide enables you to assess a candidate’s:

• Core EF Knowledge: Understanding of DbContext, DbSet, entity relationships, LINQ-to-Entities, and EF workflows.
• Advanced Concepts: Expertise in lazy/eager loading, migrations, Fluent API configuration, and raw SQL integration.
• Real-World Proficiency: Ability to optimize queries, prevent N+1 issues, implement unit tests with in-memory providers, and handle database versioning.

For a streamlined assessment process, consider platforms like WeCP, which allow you to:

✅ Create customized Entity Framework assessments tailored to EF Core or legacy EF versions.
✅ Include hands-on coding tasks for modeling data, writing LINQ queries, and performing migrations.
✅ Remotely proctor assessments with anti-cheating measures.
✅ Leverage AI-powered grading to evaluate both code quality and correctness.

Save time, improve assessment precision, and confidently hire Entity Framework experts who can deliver secure, efficient, and scalable data access solutions from day one.

Entity Framework Interview Questions

Entity Framework Interview Questions for Beginners

1. What is Entity Framework?
2. What are the different types of Entity Framework?
3. What is the difference between Entity Framework and ADO.NET?
4. What are the benefits of using Entity Framework?
5. Explain Code First approach in Entity Framework.
6. What is Database First approach in Entity Framework?
7. What is Model First approach in Entity Framework?
8. What is the DbContext class in Entity Framework?
9. What is a DbSet in Entity Framework?
10. What is LINQ and how is it used in Entity Framework?
11. What is lazy loading in Entity Framework?
12. What is eager loading in Entity Framework?
13. What is explicit loading in Entity Framework?
14. What is the difference between eager loading and lazy loading in Entity Framework?
15. What is the purpose of migrations in Entity Framework?
16. How can you enable migrations in Entity Framework?
17. How does Entity Framework perform CRUD operations?
18. What is a primary key in Entity Framework?
19. What is a foreign key in Entity Framework?
20. How do you define relationships between entities in Entity Framework?
21. What is a composite key in Entity Framework?
22. What is the purpose of the "Include" method in Entity Framework?
23. What is the difference between "Include" and "Select" in Entity Framework?
24. How can you perform transactions in Entity Framework?
25. What are the common types of relationships in Entity Framework?
26. How does Entity Framework handle concurrency?
27. What is the difference between "Attached" and "Detached" entities in Entity Framework?
28. What is the purpose of the SaveChanges method in Entity Framework?
29. How does Entity Framework handle optimistic concurrency?
30. How can you prevent lazy loading in Entity Framework?
31. What is the purpose of the "AsNoTracking" method in Entity Framework?
32. What is the difference between an entity and a DTO (Data Transfer Object)?
33. What is the use of the "HasKey" method in Entity Framework?
34. What is the difference between "Add" and "Attach" methods in Entity Framework?
35. How can you perform a raw SQL query in Entity Framework?
36. What are annotations in Entity Framework?
37. How can you use data annotations in Entity Framework for validation?
38. How do you configure relationships using Fluent API in Entity Framework?
39. What is an Entity Framework database connection string?
40. How can you perform a bulk insert using Entity Framework?

Entity Framework Interview Questions for Intermediates

1. What is the difference between the "First" and "FirstOrDefault" methods in Entity Framework?
2. How can you implement custom validation in Entity Framework?
3. Explain the concept of "change tracking" in Entity Framework.
4. What is the difference between "Attach" and "Update" methods in Entity Framework?
5. What is "TransactionScope" in Entity Framework, and how do you use it?
6. What is the role of the "DbContext" class in Entity Framework?
7. How can you manage entity state in Entity Framework?
8. What are "Shadow Properties" in Entity Framework?
9. What is the difference between "IQueryable" and "IEnumerable" in Entity Framework?
10. How can you configure a many-to-many relationship in Entity Framework?
11. What are "Global Query Filters" in Entity Framework?
12. What is the use of "DbSet<TEntity>.AddRange" method in Entity Framework?
13. What is the purpose of the "Update" method in Entity Framework?
14. What is the difference between the "DbContext.SaveChanges()" and "DbContext.SaveChangesAsync()" methods?
15. Explain how Entity Framework handles cascading deletes.
16. What is a "concurrency conflict" in Entity Framework, and how do you resolve it?
17. What are the best practices for performance tuning in Entity Framework?
18. How can you implement pagination in Entity Framework?
19. How do you handle many-to-many relationships without using a junction table in Entity Framework?
20. What is the "DbSet<TEntity>.Remove" method used for in Entity Framework?
21. How does Entity Framework handle lazy loading in a disconnected scenario?
22. How can you configure Entity Framework to use stored procedures for CRUD operations?
23. What is the purpose of "AsQueryable" method in Entity Framework?
24. How can you disable change tracking in Entity Framework?
25. What is a "DbContextFactory" in Entity Framework, and when do you use it?
26. How do you use an in-memory database with Entity Framework for unit testing?
27. How can you retrieve only specific columns from a table using Entity Framework?
28. How can you map a property in Entity Framework to a column in the database that has a different name?
29. How can you handle multiple database contexts in an application with Entity Framework?
30. What is the role of the "OnModelCreating" method in Entity Framework?
31. How do you configure a one-to-many relationship in Entity Framework using Fluent API?
32. What are the common performance bottlenecks in Entity Framework?
33. How do you implement auditing or logging in Entity Framework?
34. Explain how "DbContextPooling" works in Entity Framework.
35. What is the difference between "Database First" and "Code First" approaches in Entity Framework?
36. How can you handle database migrations in a production environment?
37. What is a "detached entity" in Entity Framework?
38. What is "Foreign Key Constraint" in Entity Framework and how does it affect data manipulation?
39. What is the difference between "DbSet<TEntity>.Add" and "DbSet<TEntity>.Attach" methods?
40. How do you configure Entity Framework to support optimistic concurrency?

Entity Framework Interview Questions for Experienced

1. What is the role of "IUnitOfWork" and "IRepository" patterns in Entity Framework?
2. How can you improve performance when working with large datasets in Entity Framework?
3. What is the difference between "NoTracking" and "Trackable" entities in Entity Framework?
4. How can you manage database schema changes in a live application using Entity Framework?
5. What are the advantages and disadvantages of using Entity Framework with a NoSQL database?
6. How does Entity Framework handle large object graph loading, and how can you optimize it?
7. How do you implement soft deletes in Entity Framework?
8. What are the various strategies for implementing pagination in Entity Framework with large datasets?
9. How can you use a custom query with Entity Framework while maintaining its performance?
10. What is a "Lazy Loading Proxy" in Entity Framework?
11. How can you handle multiple DbContexts with multiple databases in the same application?
12. What is the purpose of the "Migration" feature in Entity Framework Core and how do you handle it in production?
13. How do you implement caching with Entity Framework to improve performance?
14. Explain the concept of "Query Splitting" in Entity Framework.
15. How can you prevent N+1 query problems in Entity Framework?
16. What is "Connection Pooling" in Entity Framework, and how can it be configured?
17. How do you handle multiple relationships between the same entities in Entity Framework?
18. How do you perform advanced joins (e.g., self-joins, multiple joins) in Entity Framework?
19. How do you manage database seeding with Entity Framework in production environments?
20. How does Entity Framework deal with migrations and rollback changes?
21. Explain the concept of "Fluent API" in Entity Framework, and how is it different from Data Annotations?
22. How can you implement multi-tenancy with Entity Framework?
23. How do you implement custom conventions with Entity Framework?
24. How can you test Entity Framework code in a unit test?
25. What is a "Batched Save" in Entity Framework, and how can you optimize it for performance?
26. How do you handle bulk operations (e.g., bulk inserts/updates) efficiently in Entity Framework?
27. What is the impact of Entity Framework's change tracking on performance?
28. How do you implement a custom data provider in Entity Framework?
29. How can you use multiple queries in a single transaction with Entity Framework?
30. What are some advanced techniques for optimizing the performance of Entity Framework queries?
31. How do you configure Entity Framework to handle database concurrency in a multi-user application?
32. What is "Read Uncommitted" isolation level, and how can you use it in Entity Framework?
33. How can you manually configure mappings in Entity Framework (without using attributes or Fluent API)?
34. How can you create and manage database indexes using Entity Framework?
35. How can you use Entity Framework Core with distributed systems (e.g., microservices)?
36. How do you handle complex type mapping in Entity Framework?
37. Explain the concept of "Queryable Extensions" in Entity Framework.
38. What are "Indexes" in the context of Entity Framework, and how do you define them?
39. How does Entity Framework handle data migrations in a multi-database or multi-schema environment?
40. How can you manage the lifecycle of DbContext in a long-running application, such as in a web API?

Entity Framework Interview Questions and Answers

Beginners Question with Answers

1. What is Entity Framework?

Entity Framework (EF) is an Object-Relational Mapping (ORM) framework provided by Microsoft for .NET applications. It serves as a bridge between the object-oriented model used in C# or VB.NET and relational databases. EF allows developers to interact with a database using high-level, object-oriented code rather than directly writing SQL queries. This significantly simplifies database interactions by abstracting away the details of the underlying relational data.

In more detail, EF maps database tables to entities in C# (or another .NET language), where each entity corresponds to a table in the database, and the properties of an entity correspond to columns in that table. Instead of dealing with raw SQL statements to manipulate data, developers interact with DbContext objects, and EF automatically generates the SQL queries needed to perform operations like querying data, inserting, updating, or deleting records.

EF provides several benefits:

• Productivity: Developers can focus on business logic and data modeling, rather than worrying about the intricacies of database access.
• Maintainability: EF simplifies code maintenance by reducing the need to write repetitive SQL and by allowing changes to the database schema without requiring widespread changes to the application code.
• Integration with LINQ: EF allows you to write queries using LINQ (Language Integrated Query), which integrates database queries seamlessly into the C# language. This provides a much more readable and concise way to interact with databases.
• Automatic Change Tracking: EF automatically tracks changes made to entities and generates the appropriate SQL commands when SaveChanges() is called.

Entity Framework supports three main approaches for database interaction:

1. Code First
2. Database First
3. Model First

The flexibility of these approaches makes EF adaptable to a variety of project requirements, whether you're starting a new project or working with an existing database.

2. What are the different types of Entity Framework?

Entity Framework offers three primary approaches for interacting with databases, each with different workflows:

1. Code First

• Code First is a popular approach in EF where the database schema is derived from C# code. In this approach, developers define classes that represent entities, which are mapped to database tables by EF. These entities are usually POCOs (Plain Old CLR Objects).
• In Code First, you don’t need to have an existing database. You can start by defining classes in code, and EF will generate a database schema based on these classes. When the application runs, EF uses the provided class definitions to create the database or update its schema if it already exists.
• EF Code First supports migrations, which allow you to apply changes to the database schema incrementally, without needing to drop and recreate the database every time the model changes.
• Use case: Best suited for new applications or when you don’t have an existing database, and you want complete control over the database schema.

2. Database First

• Database First is the approach where the database already exists, and you reverse-engineer it to generate C# entity classes. EF uses the existing schema of the database and creates a data model based on the database structure. You can then interact with the database using the generated classes, which map to the tables in the database.
• This approach is useful when you're working with an existing database that has already been created by a database administrator (DBA) or in legacy systems.
• With Database First, you use EF Designer (or scaffolding in EF Core) to generate the classes from the database schema, and any updates to the database schema can be regenerated into your entity classes.
• Use case: Best suited for projects where the database schema already exists and needs to be mapped to application code.

3. Model First

• Model First is a hybrid approach where you design the database schema using an Entity Data Model (EDM), often using the visual tools provided in Visual Studio. The model is created first, and then you can generate the database schema from this model.
• This approach can be useful when you need a visual representation of your database and want to ensure that the database design matches the application model.
• While similar to Database First, the key difference is that with Model First, you’re actively creating the conceptual model before the database schema is even defined.
• Use case: Often used in projects where the design of the database is part of the development process, and the schema needs to be visualized and managed upfront.

3. What is the difference between Entity Framework and ADO.NET?

ADO.NET (ActiveX Data Objects for .NET) and Entity Framework are both technologies used for accessing data in .NET applications, but they differ significantly in terms of abstraction, ease of use, and purpose.

ADO.NET:

• ADO.NET is a low-level, data access framework that allows you to connect to databases, execute queries, and retrieve results using raw SQL commands. It provides classes like SqlConnection, SqlCommand, and SqlDataReader to manage the interaction with the database.
• Manual SQL Writing: With ADO.NET, developers must manually write SQL queries and handle result sets (often in the form of DataTables or DataReaders). This gives more control over the database interactions but requires detailed knowledge of SQL.
• Fine-grained Control: ADO.NET is suitable when you need fine control over database operations, such as executing complex SQL queries, stored procedures, or managing connections at a low level.
• Performance: Since ADO.NET doesn’t introduce any ORM overhead, it can be faster in scenarios where raw SQL execution is critical for performance.

Entity Framework:

• Entity Framework, on the other hand, is a higher-level ORM framework that abstracts away much of the complexity of data access by working with objects. EF handles the generation of SQL queries, CRUD operations, and database management tasks behind the scenes, allowing developers to work with C# objects and LINQ queries.
• Object-Oriented: With EF, developers define entity classes that correspond to database tables, and EF manages the data access. EF automatically generates the required SQL and handles issues like object state tracking, concurrency control, and relationships.
• Easier to Use: EF simplifies complex tasks like change tracking, lazy loading, and eager loading, which would require additional code in ADO.NET. It reduces the need for manual SQL management.
• Less Control: While EF offers many conveniences, it can sometimes obscure the underlying SQL and performance characteristics, which might be a concern in highly optimized scenarios or when working with complex queries that need fine-tuning.

Key Difference:

• ADO.NET is lower-level and requires explicit control over SQL queries and connections, while Entity Framework is a higher-level ORM that abstracts most of the data access logic, providing more productivity at the expense of fine-grained control.

4. What are the benefits of using Entity Framework?

Entity Framework provides numerous benefits that improve developer productivity and application maintainability:

1. Productivity:

• Less Boilerplate Code: EF eliminates the need for manually writing repetitive data access code, such as SQL queries and parameterized queries. It automatically generates SQL queries based on LINQ queries written in C# or VB.NET.
• Intelligent Change Tracking: EF tracks changes made to the data in-memory, which eliminates the need to manually track what has changed. This simplifies writing update logic.

2. Object-Oriented Access:

• EF provides object-oriented access to relational data, so developers can work with C# objects, making it easier to work with and understand the data. It maps database tables directly to classes and columns to properties.

3. Database Agnostic:

• EF supports multiple database providers (SQL Server, SQLite, PostgreSQL, etc.), allowing developers to easily switch between different databases or support multiple databases with minimal changes to the codebase.

4. Automatic SQL Generation:

• EF automatically generates the appropriate SQL queries for CRUD operations, eliminating the need for developers to manually write these SQL commands. This allows developers to focus more on the application's business logic.

5. Maintainability:

• Migrations: EF supports migrations that allow you to track and manage changes to the database schema over time, making it easier to evolve the database schema without losing data.
• Consistency: The use of a single codebase for both the data layer and the application layer improves consistency and reduces the likelihood of errors or mismatches between code and database.

6. LINQ Integration:

• Entity Framework allows you to write LINQ queries that are translated into SQL, enabling you to use C# or VB.NET language features like lambda expressions, LINQ syntax, and anonymous types to query the database. This makes database queries more readable and easier to understand than raw SQL.

7. Eager and Lazy Loading:

• EF provides support for lazy loading and eager loading. Lazy loading allows related data to be loaded on demand, while eager loading can load related data upfront, all controlled via simple syntax in LINQ.

5. Explain Code First approach in Entity Framework.

The Code First approach in Entity Framework is where the developer defines the data model entirely in code using POCO (Plain Old CLR Objects) classes. From these classes, Entity Framework will generate the database schema. This means you don’t have to manually design the database schema upfront; EF will create it for you based on the code.

Key Concepts:

• Model Definition: You define your domain classes (models) with properties that map to database columns.
• DbContext: You create a class that inherits from DbContext to manage the interaction between your application and the database. This class will contain DbSet<TEntity> properties representing tables in the database.
• Migrations: Code First supports migrations, which allow you to update the database schema in a controlled manner. With migrations, you can track changes to the model and apply these changes to the database without losing data.
• Automatic Schema Generation: The first time you run your application, EF will create the database based on the model you defined. It will automatically create tables, foreign keys, indexes, and relationships based on your class properties and attributes (like [Key], [ForeignKey], etc.).

Advantages:

• Flexibility in evolving your data model over time.
• The ability to change the database schema incrementally without dropping data.
• Developers can focus on business logic and let EF manage the database layer.

6. What is Database First approach in Entity Framework?

The Database First approach in Entity Framework is used when you have an existing database, and you want to generate a data model that maps directly to that database. In this approach, Entity Framework generates C# classes (entities) based on the schema of the database. These classes can then be used to interact with the data in your application, effectively creating an ORM layer on top of the database.

Key Concepts:

• Reverse Engineering: With Database First, EF uses the existing database schema to generate entity classes and a DbContext class. This is often done through tools in Visual Studio, such as Entity Data Model Designer or Scaffolding (for EF Core).
• Entity Framework Designer: Visual tools in Visual Studio (EF Designer) allow you to map tables, relationships, and views to C# classes in a visual manner. After generating the model, you can make changes to the code if needed.
• Database Synchronization: In this approach, if you make any changes to the model, you need to update the database schema manually, as the model is a reflection of the existing schema. Entity Framework can help generate SQL scripts to apply database changes, but this approach typically requires more manual intervention in terms of database management compared to Code First.

Advantages:

• Existing Database: Ideal for projects where the database schema already exists, such as in legacy systems, and you need to map it to your application.
• Automatic Class Generation: EF automatically generates entity classes based on the database schema, eliminating the need to manually write those classes.
• Stored Procedures & Views: You can use the Database First approach to map stored procedures and views to entity methods, making it easier to encapsulate complex queries or operations within the database.
• Flexibility in Database Changes: Database changes are easily reflected in the code by regenerating the model from the database.

7. What is Model First approach in Entity Framework?

Model First is a hybrid approach in Entity Framework where you define a conceptual model (using an Entity Data Model or EDM), and from that model, EF generates both the database schema and the C# entity classes. It’s different from the Code First and Database First approaches because you start with a visual model of your data rather than code or an existing database.

Key Concepts:

• Model Design: In Model First, you use a visual tool (such as Entity Framework Designer in Visual Studio) to create the conceptual model of your database. This is a high-level abstraction that defines entities, relationships, and keys.
• Database Generation: After creating the model, EF can generate the actual database schema (tables, relationships, constraints, etc.) based on the model. This is similar to what EF Code First does, except you define the model visually in the designer rather than in code.
• Class Generation: Entity Framework will also generate C# entity classes that map to your visual model, which you can use to interact with the database in your application.

Advantages:

• Visual Modeling: Developers can use a graphical design tool to lay out the database structure, which can be particularly useful for those who prefer to see the relationships and design on a high level.
• Database and Code Generation: Model First generates both the database and the code, saving time and effort when starting a project.
• Synchronization: Changes made to the conceptual model can be propagated to both the generated database schema and the entity classes.

Use Case: This approach is typically useful for projects where you want to design the data model visually first, and then generate both the database and the C# code based on that design.

8. What is the DbContext class in Entity Framework?

The DbContext class is one of the core components of Entity Framework. It acts as a bridge between your application’s C# code (or another .NET language) and the underlying database. The DbContext is responsible for managing the database connection, querying and saving data, and managing entity objects during their lifecycle.

Key Concepts:

• Connection Management: The DbContext manages the database connection. You define the connection string in your application, and EF uses that to connect to the database. The connection is typically opened and closed automatically when interacting with the database.
• DbSets: A DbContext contains DbSet<TEntity> properties, where each DbSet represents a collection of entities (i.e., database tables). For example, if you have an Employee entity, you would have a DbSet<Employee> property in your DbContext.
• Query Execution: The DbContext is used to execute queries. When you write LINQ queries against DbSet<TEntity>, the DbContext translates these into SQL queries and sends them to the database.
• Change Tracking: The DbContext automatically tracks changes to entities. It detects changes like additions, modifications, and deletions. When SaveChanges() is called, the DbContext generates the necessary SQL commands to persist these changes to the database.
• Lifecycle Management: It handles entity lifecycle management (e.g., Attached, Detached, and Modified states). When you load data into an entity, the DbContext will track changes, and when you call SaveChanges(), it knows which changes to commit to the database.

Advantages:

• Centralized Data Management: The DbContext provides a centralized mechanism for querying, saving, and managing entities.
• Simplifies CRUD Operations: With the DbContext, you can easily perform create, read, update, and delete operations without manually managing connections or SQL queries.
• Supports Transactions: The DbContext automatically supports transaction management, so changes are only persisted if all operations within the scope are successful.

9. What is a DbSet in Entity Framework?

A DbSet<TEntity> represents a collection of entities of type TEntity in your DbContext. It is used to interact with the database tables corresponding to that entity type. In simpler terms, DbSet<TEntity> acts as an in-memory representation of a database table, allowing you to query, insert, update, and delete records in that table.

Key Concepts:

• Representation of Tables: Each DbSet<TEntity> corresponds to a database table. For example, if you have a Student class, you would define a DbSet<Student> in your DbContext. EF will map this DbSet to the Students table in the database.
• Querying: You can perform queries on a DbSet using LINQ or Entity SQL. For example, dbContext.Students.Where(s => s.Age > 18) would translate into a SQL query fetching all students older than 18.
• Adding Data: You can add entities to a DbSet using methods like Add, AddRange, or Remove to interact with the database.
• Save Changes: When changes are made to the entities within a DbSet, calling SaveChanges() on the DbContext will persist those changes to the database.

Advantages:

• CRUD Operations: The DbSet makes it easy to perform all CRUD operations in a strongly-typed manner.
• Queryable Interface: You can use LINQ to query the DbSet and execute SQL-like operations against it, all while working in the object-oriented C# environment.
• Efficient Change Tracking: It keeps track of the state of the entities in memory (i.e., whether they are new, modified, or deleted), and when SaveChanges() is called, it updates the database accordingly.

10. What is LINQ and how is it used in Entity Framework?

LINQ (Language Integrated Query) is a feature in .NET that allows developers to query data using a syntax integrated into C# or other .NET languages. LINQ queries can be written directly in the programming language, providing a more concise and readable way to interact with data.

Key Concepts:

• LINQ Syntax: LINQ allows you to write queries in a declarative way, similar to SQL, but using C# syntax. It supports queries over various data sources, including in-memory collections, XML, and relational databases (when combined with Entity Framework).
• Entity Framework and LINQ: In EF, you can use LINQ to query a DbSet<TEntity> and retrieve entities from the database. When you use LINQ in EF, it is translated into SQL by Entity Framework, and the query is executed on the database server.
  
  • For example, a LINQ query like var students = dbContext.Students.Where(s => s.Age > 18).ToList(); will be translated into SQL that retrieves students with an age greater than 18 from the database.
• Deferred Execution: LINQ queries in EF are deferred in execution, meaning that the query isn’t executed until you actually iterate over the results (e.g., when you call ToList(), FirstOrDefault(), etc.). This allows for query composition, where you can build more complex queries step by step.
• LINQ to Entities: When using EF, LINQ queries are translated into SQL commands by the LINQ to Entities provider. This makes the queries highly optimized and allows EF to handle database-specific translation.

Advantages:

• Readability: LINQ queries are easier to read and write compared to raw SQL. You can use familiar C# syntax to filter, sort, and project data.
• Strongly Typed: Since LINQ queries are written in C#, they are checked at compile-time for errors, which reduces runtime errors common in SQL-based queries.
• Integration: LINQ allows you to seamlessly integrate your application’s data layer with business logic, making your code more concise and maintainable.
• SQL Abstraction: LINQ abstracts the need for writing SQL directly, which can simplify data access and make the code more portable across different database systems.

11. What is lazy loading in Entity Framework?

Lazy loading is a feature in Entity Framework (EF) that automatically loads related entities from the database only when they are accessed for the first time. It is a way to delay the loading of related data until it's actually needed in the application.

How Lazy Loading Works:

• When an entity is loaded from the database, related entities (like navigation properties) are not immediately retrieved from the database.
• Instead, when a property that represents a related entity (e.g., a collection or reference navigation property) is accessed, EF sends a separate query to the database to retrieve the data at that point.
• Lazy loading is typically implemented by creating virtual navigation properties in the entity classes, allowing EF to override the behavior and load data automatically when accessed.

Example:

public class Student
{
    public int StudentId { get; set; }
    public string Name { get; set; }
    public virtual ICollection<Course> Courses { get; set; } // Lazy-loaded property
}

Advantages:

• On-demand Data: Only loads related data when it's actually needed, which can be more efficient in some scenarios.
• Reduced Initial Load Time: The initial query to fetch the main entity is faster, as related entities are loaded only when they are required.

Disadvantages:

• Multiple Queries: Lazy loading can lead to multiple round-trips to the database if many related entities are accessed, which can result in performance issues, especially in large data sets (also called the "N+1 problem").
• Control: Sometimes lazy loading can result in unexpected behavior if you're unaware that additional queries will be sent to the database.

12. What is eager loading in Entity Framework?

Eager loading is the opposite of lazy loading. In eager loading, related entities are loaded at the same time as the main entity in a single query. This is done using the Include() method in Entity Framework.

How Eager Loading Works:

• When you use eager loading, EF generates a single query that retrieves both the main entity and its related entities in a single round-trip to the database.
• The Include() method is used to specify the related entities that should be loaded along with the main entity.

Example:

var students = dbContext.Students.Include(s => s.Courses).ToList();

This query retrieves all Students and their related Courses in a single SQL query, which helps avoid multiple database hits.

Advantages:

• Single Query: Eager loading reduces the number of queries sent to the database, especially when you know in advance that related data will be required.
• Improved Performance: It is generally more efficient than lazy loading when multiple related entities need to be accessed, as it minimizes database round trips.

Disadvantages:

• Performance Hit for Large Data Sets: If too many related entities are included, the resulting query can become very large and may negatively impact performance, especially if you are retrieving large amounts of data.
• Complexity: In some cases, eager loading can lead to retrieving more data than needed, which could increase memory usage and degrade performance.

13. What is explicit loading in Entity Framework?

Explicit loading is a technique used when you want to load related entities after the main entity has been retrieved, but you do so explicitly in your code, rather than automatically (as with lazy or eager loading).

With explicit loading, you use methods like Load() or LoadAsync() to load related entities after the main entity has been loaded. This provides more control over when and how related data is retrieved from the database.

How Explicit Loading Works:

• First, you load the main entity.
• Then, you use the Load() method to explicitly load the related entities (e.g., navigation properties).

Example:

var student = dbContext.Students.Find(1);  // Load the student
dbContext.Entry(student).Collection(s => s.Courses).Load();  // Explicitly load courses for this student

Advantages:

• Control Over Loading: You have full control over when related data is loaded, which can help in scenarios where you want to optimize the number of queries or avoid unnecessary loading.
• Avoiding N+1 Problem: By explicitly loading data, you can avoid the N+1 problem that might occur with lazy loading if you access related entities in a loop.

Disadvantages:

• More Code: You need to explicitly tell EF when and how to load related entities, which can lead to more verbose code.
• Multiple Queries: Like lazy loading, explicit loading can result in multiple queries to the database, which can impact performance if not managed properly.

14. What is the difference between eager loading and lazy loading in Entity Framework?

The primary difference between eager loading and lazy loading in Entity Framework lies in when and how related data is fetched from the database:

Feature

Lazy Loading

Eager Loading

Definition

Related data is loaded only when it is accessed.

Related data is loaded at the same time as the main entity.

How it Works

EF automatically loads related entities when their navigation property is accessed.

You specify related entities to load upfront using .Include().

Performance

Can cause the N+1 query problem (multiple queries for related data).

Fewer queries (1 query), but can result in a large and expensive query.

Control

No control over when related data is loaded.

Full control over what data is loaded and when.

Use Case

Useful when you don’t know if related data will be needed.

Useful when you know in advance that related data will be required.

Summary: Eager loading loads all necessary data in one go, reducing the number of database round trips, while lazy loading delays loading related data until it is needed. Eager loading might retrieve more data than needed, whereas lazy loading can generate multiple database calls, resulting in performance overhead.

15. What is the purpose of migrations in Entity Framework?

Migrations in Entity Framework are used to manage changes in the database schema over time. They allow developers to evolve the database schema as the data model changes without manually altering the database or losing data. Migrations are especially useful in scenarios where the application model is evolving, such as adding new fields, modifying relationships, or deleting tables.

Key Features of Migrations:

• Tracking Changes: Migrations track changes made to the model, such as added, removed, or modified properties and tables.
• Versioning: Migrations provide versioning for database schema changes, making it easier to apply and revert changes.
• Automatic Schema Updates: Migrations generate the SQL commands required to update the database schema, and you can apply those changes in a controlled manner.
• Data Preservation: Migrations are designed to modify the schema without dropping existing data (although certain changes, like dropping a column, may require special handling).

How Migrations Work:

1. You define or modify your models.
2. You run Add-Migration in the Package Manager Console to generate a new migration file.
3. You run Update-Database to apply the migration to the database, which will execute the necessary SQL commands.

16. How can you enable migrations in Entity Framework?

To enable migrations in Entity Framework, you need to follow these steps:

1. Install Entity Framework NuGet Package: Make sure that the Entity Framework package is installed in your project. You can install it using NuGet Package Manager in Visual Studio.
2. Enable Migrations in Your Project:
   
   • Open the Package Manager Console in Visual Studio.

Run the following command to enable migrations:

Enable-Migrations

• This creates a Migrations folder in your project, where EF will store migration files.

2. Create a Migration:

After making changes to your data model (adding/removing entities, properties, or relationships), create a migration using:

Add-Migration <MigrationName>

• This will generate a C# file that describes the changes made to the database schema.

2. Apply the Migration:

To apply the migration and update the database schema, run:

Update-Database

• This will apply the generated migration to the database, updating its schema as needed.

17. How does Entity Framework perform CRUD operations?

Entity Framework performs CRUD (Create, Read, Update, Delete) operations through its DbContext and DbSet objects. Each operation corresponds to a specific method call on DbContext or DbSet:

1. Create:
   
   • You can add new entities to the database by adding them to a DbSet and calling SaveChanges().

var student = new Student { Name = "John Doe" };
dbContext.Students.Add(student);
dbContext.SaveChanges(); // Inserts into the database

1. Read:

To read data, you use LINQ queries or DbSet methods like Find(),

• FirstOrDefault(), or Where():

var student = dbContext.Students.Find(1);  // Find by primary key
var students = dbContext.Students.Where(s => s.Age > 18).ToList();  // Filtered read

1. Update:

When updating, you modify the entity and call SaveChanges(). EF automatically tracks changes to the entity

var student = dbContext.Students.Find(1);
student.Name = "Jane Doe";
dbContext.SaveChanges(); // Updates in the database

1. Delete:
   
   • You remove entities by calling Remove() on a DbSet, then calling SaveChanges().

var student = dbContext.Students.Find(1);
dbContext.Students.Remove(student);
dbContext.SaveChanges(); // Deletes from the database

EF automatically generates the corresponding SQL queries to perform the actual database operations.

18. What is a primary key in Entity Framework?

A primary key in Entity Framework is a unique identifier for each entity in the database. It ensures that each row in a table can be uniquely identified. In EF, the primary key is typically represented by a property marked with the [Key] attribute or conventionally by a property named Id or <EntityName>Id.

How Primary Key Works:

• The primary key is used by EF to track entities and ensure that they are uniquely identifiable.
• It is also used in relationships (e.g., foreign keys) to establish associations between tables.

Example:

public class Student
{
    [Key]
    public int StudentId { get; set; }
    public string Name { get; set; }
}

EF automatically treats the StudentId as the primary key because it follows the naming convention.

19. What is a foreign key in Entity Framework?

A foreign key is a field (or a set of fields) in a table that uniquely identifies a row in another table. In Entity Framework, a foreign key is used to represent relationships between entities, such as one-to-many or many-to-many relationships.

How Foreign Key Works:

• In a one-to-many relationship, a foreign key in the child table refers to the primary key of the parent table.
• EF automatically creates foreign key relationships when you define navigation properties, but you can also explicitly define the foreign key using the [ForeignKey] attribute or by configuring it in the OnModelCreating() method.

Example:

public class Student
{
    public int StudentId { get; set; }
    public string Name { get; set; }
    public int CourseId { get; set; } // Foreign Key
    public Course Course { get; set; } // Navigation Property
}

public class Course
{
    public int CourseId { get; set; }
    public string Title { get; set; }
}

In this case, the CourseId in Student is the foreign key that relates each student to a course.

20. How do you define relationships between entities in Entity Framework?

In Entity Framework, relationships between entities are defined using navigation properties and foreign keys. The most common types of relationships are:

1. One-to-Many: A single record in one table can relate to many records in another table (e.g., one department has many employees).
   
   • Defined using a navigation property on the "many" side and a foreign key.
   • EF automatically understands relationships based on conventions (e.g., DepartmentId on Employee).
2. One-to-One: Each record in one table relates to exactly one record in another table.
   
   • Defined using a navigation property and a foreign key, with explicit configuration to enforce the one-to-one relationship.
3. Many-to-Many: Many records in one table can relate to many records in another table (e.g., students and courses).
   
   • Defined using a junction table that contains two foreign keys.
   • In EF Core, you can configure a many-to-many relationship directly without needing an explicit join table in the model (EF will generate it automatically).

Example of One-to-Many:

public class Department
{
    public int DepartmentId { get; set; }
    public string Name { get; set; }
    public ICollection<Employee> Employees { get; set; } // Navigation property
}

public class Employee
{
    public int EmployeeId { get; set; }
    public string Name { get; set; }
    public int DepartmentId { get; set; } // Foreign Key
    public Department Department { get; set; } // Navigation property
}

21. What is a composite key in Entity Framework?

A composite key in Entity Framework is a primary key composed of multiple columns. This is useful when no single column uniquely identifies a row, but a combination of columns can be used to create a unique identifier for each record.

How Composite Keys Work:

• In Entity Framework, a composite key is defined by marking multiple properties with the [Key] attribute or using the HasKey() method in the OnModelCreating() method.
• EF can use composite keys in relationships, ensuring that each record in the table is uniquely identified by the combination of these fields.

Example:

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

    public Student Student { get; set; }
    public Course Course { get; set; }
}

Here, a composite key can be created on StudentId and CourseId since together they uniquely identify the StudentCourse relationship.

In Fluent API:

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    modelBuilder.Entity<StudentCourse>()
        .HasKey(sc => new { sc.StudentId, sc.CourseId });
}

Advantages of Composite Keys:

• Used for complex relationships, often in many-to-many join tables.
• Ensures uniqueness across multiple columns, not just a single column.

22. What is the purpose of the "Include" method in Entity Framework?

The Include() method in Entity Framework is used to specify eager loading for related entities. When you use Include(), EF retrieves not just the main entity but also the related entities (such as navigation properties) in the same query.

How Include() Works:

• You call Include() on a query to tell EF to also retrieve related data. EF then automatically joins the related data in the generated SQL query.

Example:

var studentsWithCourses = dbContext.Students.Include(s => s.Courses).ToList();

This query retrieves all students and their associated courses in one query, avoiding lazy loading or multiple round trips to the database.

Advantages:

• Improved Performance: It avoids multiple database round trips by fetching related data upfront in a single query.
• Reduced N+1 Problem: When used correctly, Include() helps prevent the N+1 query problem, where multiple queries are sent to the database for related entities.

23. What is the difference between "Include" and "Select" in Entity Framework?

Both Include() and Select() are used to work with related data in Entity Framework, but they serve different purposes:

Feature

Include()

Select()

Purpose

Used for eager loading to load related entities.

Used for projection, i.e., transforming the data returned by a query.

Functionality

Loads the entire related entity along with the main entity.

Projects the result into a new shape, typically a custom object or anonymous type.

Returned Data

Returns the main entity along with its related entities.

Returns a subset or transformation of the data (e.g., selecting specific fields).

Example

dbContext.Students.Include(s => s.Courses)dbContext.Students.Select(s => new { s.Name, s.Age })

‍

Example of Include():

var students = dbContext.Students.Include(s => s.Courses).ToList();

Example of Select():

var studentNames = dbContext.Students.Select(s => new { s.Name, s.Age }).ToList();

Key Differences:

• Include() is specifically used for eager loading, ensuring that related entities are included in the result set.
• Select() is used for transforming the query results, often for performance optimization or projecting a subset of data.

24. How can you perform transactions in Entity Framework?

In Entity Framework, transactions are automatically handled when you call SaveChanges(), but you can also manage transactions manually if needed. EF supports both implicit and explicit transactions.

Implicit Transactions: When you call SaveChanges(), EF automatically wraps the changes in a transaction. If SaveChanges() completes successfully, the transaction is committed; if there is an error, it is rolled back.

Explicit Transactions: You can explicitly begin, commit, or roll back transactions using

DbContext.Database.BeginTransaction().

Example:

using (var transaction = dbContext.Database.BeginTransaction())
{
    try
    {
        // Perform multiple operations
        dbContext.Students.Add(new Student { Name = "John Doe" });
        dbContext.Courses.Add(new Course { Title = "Mathematics" });
        
        dbContext.SaveChanges();

        // Commit the transaction
        transaction.Commit();
    }
    catch (Exception)
    {
        // Rollback the transaction in case of an error
        transaction.Rollback();
    }
}

Advantages of Explicit Transactions:

• Atomicity: All changes inside the transaction are committed or rolled back as a unit.
• Control: Gives you fine-grained control over when to commit or roll back changes.

25. What are the common types of relationships in Entity Framework?

In Entity Framework, the three most common types of relationships between entities are:

1. One-to-One:
   
   • Each record in one table is related to exactly one record in another table.
   • Example: A Person entity might have exactly one Passport.
2. One-to-Many:
   
   • A single record in one table can be related to many records in another table.
   • Example: A Department can have many Employees, but each Employee belongs to only one Department.
3. Many-to-Many:
   
   • Many records in one table can be related to many records in another table.
   • Example: Students can enroll in many Courses, and each Course can have many Students.

Entity Framework Mapping:

• One-to-many relationships are automatically handled by EF using foreign keys.
• Many-to-many relationships often use a junction table or are automatically managed by EF Core (in recent versions).
• One-to-one relationships need explicit configuration, as they are less common.

26. How does Entity Framework handle concurrency?

Concurrency in Entity Framework refers to situations where multiple users or processes try to update the same data simultaneously. EF provides several ways to handle concurrency:

1. Optimistic Concurrency (default in EF):
   
   • EF assumes that conflicts will be rare and does not lock data for reading. Instead, it checks for concurrency conflicts when changes are saved.
   • A concurrency conflict occurs when one entity is modified by two users between the time it was read and the time it is saved.
2. How it works:
   
   • EF adds a timestamp or row version column to your table.
   • When an entity is retrieved, EF reads the row version. When attempting to save, EF compares the original row version with the current one in the database.
   • If the versions match, the update is allowed; if they don't, a DbUpdateConcurrencyException is thrown.

Example:

public class Product
{
    public int ProductId { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
    [Timestamp]
    public byte[] RowVersion { get; set; }
}

1. Pessimistic Concurrency (via manual locking):
   
   • EF does not natively support pessimistic concurrency, but you can implement it using database locks (e.g., WITH (ROWLOCK) in SQL).
   • This approach locks the record for the duration of the transaction, preventing other users from making changes.

27. What is the difference between "Attached" and "Detached" entities in Entity Framework?

In Entity Framework, the state of an entity indicates whether it is being tracked by the DbContext and whether any changes are pending.

1. Attached Entities:
   
   • An entity is attached when it is being tracked by the DbContext. EF is aware of its state (whether it's new, modified, or deleted).
   • Once an entity is attached to the DbContext, any changes made to it will be tracked, and when SaveChanges() is called, those changes will be saved to the database.

Example:

var student = dbContext.Students.Find(1);
student.Name = "New Name";  // The entity is attached, and EF tracks the change.

1. Detached Entities:
   
   • An entity is detached when it is no longer being tracked by the DbContext. This can happen if you load an entity and then detach it, or if it was never attached to begin with.
   • Detached entities do not have their changes tracked. To update a detached entity, you must manually attach it back to the context and specify its state.

Example:

var student = new Student { StudentId = 1, Name = "Detached Name" };
dbContext.Entry(student).State = EntityState.Modified;
dbContext.SaveChanges();

28. What is the purpose of the SaveChanges method in Entity Framework?

The SaveChanges() method in Entity Framework is used to persist changes made to entities in memory to the underlying database. It synchronizes the changes made in the DbContext to the database by generating the appropriate SQL commands (INSERT, UPDATE, DELETE) and executing them.

How SaveChanges() Works:

• When you modify, add, or remove entities from a DbSet, EF tracks these changes.
• When you call SaveChanges(), EF generates the SQL for the changes (based on the entity's state) and executes them in a single transaction.

Example:

var student = new Student { Name = "John Doe" };
dbContext.Students.Add(student);
dbContext.SaveChanges();  // Adds the student to the database

29. How does Entity Framework handle optimistic concurrency?

Optimistic concurrency in Entity Framework assumes that concurrency conflicts are rare. It works by checking for conflicts when changes are saved, rather than locking the data during reads or writes.

• Concurrency Tokens: EF uses a concurrency token, typically a Timestamp or RowVersion column, to track changes. When an entity is loaded, EF reads the version number. When you save the changes, EF checks if the version number in the database is still the same.
• Concurrency Exception: If the versions don't match, EF throws a DbUpdateConcurrencyException, which allows the application to handle the conflict (e.g., by asking the user to resolve the conflict).

30. How can you prevent lazy loading in Entity Framework?

To prevent lazy loading in Entity Framework, you can disable it globally in the DbContext or individually for specific entities.

Disable Lazy Loading Globally: You can disable lazy loading for all entities in your context by setting the LazyLoadingEnabled property of the DbContext.Configuration to false.

dbContext.Configuration.LazyLoadingEnabled = false;

Disable Lazy Loading on Specific Navigation Properties: You can also disable lazy loading on specific navigation properties by marking the navigation property as non-virtual, since lazy loading relies on the proxy class created by EF, which can only work with virtual properties.

public class Student
{
    public int StudentId { get; set; }
    public string Name { get; set; }
    // Marking as non-virtual prevents lazy loading
    public ICollection<Course> Courses { get; set; }  
}

Benefits of Disabling Lazy Loading:

• Performance: Prevents multiple queries from being sent to the database when related data is accessed.
• Control: Gives developers more control over when related data is loaded.

31. What is the purpose of the "AsNoTracking" method in Entity Framework?

The AsNoTracking() method in Entity Framework is used to disable change tracking for the entities in a query. When you use AsNoTracking(), EF does not track changes to the entities, which can significantly improve performance when you only need to read data and do not intend to modify it.

How It Works:

• By default, EF tracks changes to all entities returned in a query. This tracking allows EF to detect changes and later persist them to the database when SaveChanges() is called.
• When AsNoTracking() is used, EF does not track these entities, making the query execution faster and consuming less memory.

Example:

var students = dbContext.Students.AsNoTracking().Where(s => s.Age > 18).ToList();

When to Use:

• Read-Only Operations: Use AsNoTracking() when you don't need to update the entities. It is typically used in scenarios where performance is critical, and you only need to fetch data for display or processing.
• Improves Performance: If you are querying a large dataset or executing queries multiple times, AsNoTracking() reduces the overhead associated with change tracking.

32. What is the difference between an entity and a DTO (Data Transfer Object)?

1. Entity:
   
   • An entity represents a table in the database and is a part of the domain model. It is typically mapped to a class that reflects the schema of the database.
   • Entities are used to interact with the database directly. They are usually tracked by DbContext for CRUD operations.
   • Example: A Student entity may contain properties like StudentId, Name, Age, etc.

Example Entity:

public class Student
{
    public int StudentId { get; set; }
    public string Name { get; set; }
    public int Age { get; set; }
}

1. DTO (Data Transfer Object):
   
   • A DTO is an object that is used to transfer data between layers of an application (e.g., between the UI layer and the service layer). DTOs are typically used to optimize the data that is sent over a network or returned to a client.
   • Unlike entities, DTOs don't necessarily correspond to a database table. They are usually shaped to include only the data needed for a specific operation.
   • DTOs are often used to decouple the internal domain model from external consumers.

Example DTO:

public class StudentDTO
{
    public string Name { get; set; }
    public int Age { get; set; }
}

Key Differences:

• Purpose: Entities are used to represent data in the database, while DTOs are used for transferring data between application layers.
• Complexity: Entities may include business logic or methods, while DTOs are simple objects used for serialization or transferring data.
• Structure: DTOs are often more lightweight and tailored for specific operations, whereas entities reflect the database schema.

33. What is the use of the "HasKey" method in Entity Framework?

The HasKey() method in Entity Framework is used to specify the primary key for an entity when using the Fluent API for model configuration. While EF conventions can automatically detect a property named Id or <EntityName>Id as the primary key, HasKey() allows you to explicitly define one or more properties as the primary key.

How it Works:

• You use HasKey() in the OnModelCreating() method to define composite keys or to override conventions if needed.

Example:

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

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    modelBuilder.Entity<StudentCourse>().HasKey(sc => new { sc.StudentId, sc.CourseId });
}

In this case, HasKey() is used to define a composite key using the StudentId and CourseId properties.

34. What is the difference between "Add" and "Attach" methods in Entity Framework?

Both Add() and Attach() methods are used to add entities to the DbContext in Entity Framework, but they serve different purposes:

1. Add():
   
   • The Add() method is used to add new entities to the DbContext, marking them as Added in the Entity State.
   • When you call Add(), EF assumes that the entity is new and will insert it into the database when SaveChanges() is called.

Example:

var student = new Student { Name = "John Doe" };
dbContext.Students.Add(student);
dbContext.SaveChanges();  // This will insert a new student record.

1. Attach():
   
   • The Attach() method is used to attach an existing entity to the DbContext. EF will not treat the entity as new but will track it as Unchanged unless the entity's state is modified.
   • You typically use Attach() when you want to work with an entity that already exists in the database but was not loaded into the DbContext (e.g., when working with disconnected scenarios).

Example:

var student = new Student { StudentId = 1, Name = "John Doe" };
dbContext.Students.Attach(student);  // Attach the existing student without marking it as new.
dbContext.SaveChanges();  // No new record is added; EF assumes this is an existing record.

Key Differences:

• Add() is for adding new entities, while Attach() is for attaching existing entities.
• Attach() does not affect the database, but Add() marks the entity as needing insertion.

35. How can you perform a raw SQL query in Entity Framework?

In Entity Framework, you can execute raw SQL queries using the FromSqlRaw() (or FromSqlInterpolated()) method. These methods allow you to execute raw SQL queries and map the results to entity types or anonymous types.

How it Works:

• FromSqlRaw() is used for executing raw SQL queries that return entities.
• ExecuteSqlRaw() is used for executing SQL commands that do not return entities (e.g., INSERT, UPDATE, DELETE).

Example:

var students = dbContext.Students
                        .FromSqlRaw("SELECT * FROM Students WHERE Age > {0}", 18)
                        .ToList();

This will execute the raw SQL query and return the results as a list of Student entities.

For non-query commands:

dbContext.Database.ExecuteSqlRaw("DELETE FROM Students WHERE Age < {0}", 18);

Benefits:

• Allows you to execute complex queries that cannot be expressed using LINQ.
• Can help optimize performance for specific queries or operations.

36. What are annotations in Entity Framework?

Annotations (also called data annotations) in Entity Framework are attributes that are applied to the properties of an entity to provide metadata about how the model should be mapped to the database. They are a form of declarative configuration that allow you to specify things like primary keys, column lengths, nullability, etc.

Common Annotations:

• [Key]: Specifies the primary key.
• [Required]: Ensures a property is not nullable.
• [StringLength]: Limits the length of a string property.
• [ForeignKey]: Specifies the foreign key for a relationship.
• [Timestamp]: Marks a property as a concurrency token.

Example:

public class Student
{
    [Key]
    public int StudentId { get; set; }

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

    [Range(18, 100)]
    public int Age { get; set; }
}

37. How can you use data annotations in Entity Framework for validation?

Data annotations can be used in Entity Framework to enforce validation rules on entity properties. These annotations are used to define rules such as required fields, maximum length, range limits, etc., both in the database schema and for validation purposes during model binding.

Common Validation Annotations:

• [Required]: Ensures a property cannot be null.
• [StringLength]: Specifies the maximum length of a string.
• [Range]: Specifies the range of numeric values allowed.
• [EmailAddress]: Validates that a string is in the correct email format.
• [RegularExpression]: Validates a string based on a regular expression pattern.

Example:

public class Student
{
    [Required]
    [StringLength(50)]
    public string Name { get; set; }

    [Range(18, 100)]
    public int Age { get; set; }
}

Data annotations ensure that the data being processed meets the required validation criteria, which can be validated before being saved to the database or displayed to the user.

38. How do you configure relationships using Fluent API in Entity Framework?

In Entity Framework, you can configure relationships between entities using the Fluent API inside the OnModelCreating() method of the DbContext. Fluent API provides more flexibility and is often used to configure complex relationships that cannot be expressed with data annotations.

Example of configuring a one-to-many relationship:

public class Student
{
    public int StudentId { get; set; }
    public string Name { get; set; }
    public ICollection<Course> Courses { get; set; }
}

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

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Student>()
        .HasMany(s => s.Courses)
        .WithOne(c => c.Student)
        .HasForeignKey(c => c.StudentId);
}

In this example, HasMany() and WithOne() define the one-to-many relationship between Student and Course.

39. What is an Entity Framework database connection string?

A database connection string in Entity Framework is used to specify how EF should connect to the underlying database. It contains details like the database provider (SQL Server, SQLite, etc.), server address, database name, and authentication credentials.

Example:

"ConnectionStrings": {
    "DefaultConnection": "Server=myServerAddress;Database=myDataBase;User Id=myUsername;Password=myPassword;"
}

This string is typically stored in the appsettings.json file (for ASP.NET Core) or in the web.config (for older ASP.NET applications) and is used by DbContext to connect to the database.

40. How can you perform a bulk insert using Entity Framework?

EF Core does not natively support bulk insert operations, but there are several ways to perform bulk inserts:

Using EF Core’s AddRange() method: This is the simplest way to insert multiple entities at once. However, it can be inefficient for large datasets because EF will track all entities individually.

dbContext.Students.AddRange(studentList);
dbContext.SaveChanges();

Using Third-Party Libraries: Libraries like EFCore.BulkExtensions provide efficient bulk insert functionality that avoids the overhead of tracking individual entities.Example using EFCore.BulkExtensions:

dbContext.BulkInsert(studentList);

Intermediate Question and Answers

1. What is the difference between the "First" and "FirstOrDefault" methods in Entity Framework?

Both First() and FirstOrDefault() are LINQ methods used to retrieve the first element from a collection that matches a given condition, but there are key differences:

1. First():
   
   • Throws an exception if no elements are found that match the condition.
   • Typically used when you are certain that at least one element will be returned.

Example:

var student = dbContext.Students.First(s => s.Name == "John");

1. If no student with the name "John" is found, an InvalidOperationException will be thrown.
2. FirstOrDefault():
   
   • Returns null (or the default value for value types) if no matching elements are found.
   • Safer to use when there's a possibility that no elements match the condition and you want to handle it gracefully.

Example:

var student = dbContext.Students.FirstOrDefault(s => s.Name == "John");
if (student == null)
{
    // Handle case where no student is found
}

Key Difference:

• First() is for situations where an element is expected, while FirstOrDefault() is more defensive and can handle cases where no elements exist.

2. How can you implement custom validation in Entity Framework?

Custom validation in Entity Framework can be achieved in two main ways: using data annotations for simple validation or implementing IValidatableObject for more complex logic.

Using Data Annotations: You can create custom validation attributes by extending ValidationAttribute. Example:

public class AgeGreaterThan18Attribute : ValidationAttribute
{
    public override bool IsValid(object value)
    {
        return value is int age && age > 18;
    }
}

public class Student
{
    public int StudentId { get; set; }
    [AgeGreaterThan18(ErrorMessage = "Age must be greater than 18.")]
    public int Age { get; set; }
}

Using IValidatableObject: For more complex validation, you can implement the IValidatableObject interface on the entity. This allows you to perform validation logic based on the entity’s state. Example:

public class Student : IValidatableObject
{
    public int Age { get; set; }

    public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
    {
        if (Age <= 18)
        {
            yield return new ValidationResult("Age must be greater than 18.", new[] { "Age" });
        }
    }
}

In both cases, validation can be triggered before saving to the database or when manually validating entities.

3. Explain the concept of "change tracking" in Entity Framework.

Change tracking in Entity Framework refers to the process by which EF keeps track of changes made to objects retrieved from the database, so that it can determine what changes to save to the database when SaveChanges() is called.

• How it works:
  
  • When an entity is fetched from the database, EF starts tracking changes made to its properties. If you modify an entity (e.g., changing a property’s value), EF records that modification.
  • When you call SaveChanges(), EF checks the tracked entities' states (Added, Modified, Deleted, or Unchanged) and generates the corresponding SQL commands (INSERT, UPDATE, DELETE) to persist the changes to the database.
• Entity States:
  
  • Added: The entity is newly created and needs to be inserted into the database.
  • Modified: The entity exists in the database but has been updated.
  • Deleted: The entity is marked for deletion.
  • Unchanged: The entity has not been modified.
  • Detached: The entity is not being tracked.

Example:

var student = dbContext.Students.Find(1);
student.Name = "John Doe";  // EF tracks this change.
dbContext.SaveChanges();  // EF will generate an UPDATE query.

4. What is the difference between "Attach" and "Update" methods in Entity Framework?

1. Attach():
   
   • The Attach() method is used to attach an existing entity to the DbContext without marking it as modified. This is useful when you know an entity already exists in the database but you don't want to update it yet.
   • Entities attached using Attach() are in the Unchanged state, meaning EF will not issue an UPDATE command unless the entity's properties are explicitly modified.

Example:

var student = new Student { StudentId = 1, Name = "John" };
dbContext.Students.Attach(student);  // Entity is attached, but not marked as modified.
dbContext.SaveChanges();  // No update will be sent to the database unless the entity is modified.

1. Update():
   
   • The Update() method marks an entity as Modified, so EF will generate an UPDATE query to update the database with the new values.
   • It's typically used when you have a disconnected entity and want to make sure EF performs an update on it, regardless of whether EF tracks it.

Example:

var student = new Student { StudentId = 1, Name = "John" };
dbContext.Students.Update(student);  // Entity is marked as Modified.
dbContext.SaveChanges();  // An UPDATE query will be sent to the database.

Key Difference:

• Attach() is used to track an existing entity without making any updates, while Update() is used to explicitly mark an entity for updating.

5. What is "TransactionScope" in Entity Framework, and how do you use it?

TransactionScope is a .NET class that allows you to create a transactional scope for database operations. It provides a simple way to manage transactions across multiple resources (e.g., databases, message queues) without needing to manually commit or roll back transactions.

• How it Works:
  
  • When you use TransactionScope, EF operations are automatically wrapped in a transaction. If all operations succeed, the transaction is committed; if any operation fails, the transaction is rolled back.

Example:

using (var transaction = new TransactionScope())
{
    var student = new Student { Name = "Jane" };
    dbContext.Students.Add(student);
    dbContext.SaveChanges();  // Part of the transaction

    var course = new Course { Title = "Math" };
    dbContext.Courses.Add(course);
    dbContext.SaveChanges();  // Part of the transaction

    transaction.Complete();  // Commit the transaction
}

If an exception occurs before transaction.Complete() is called, the transaction is automatically rolled back.

6. What is the role of the "DbContext" class in Entity Framework?

The DbContext class is the primary class that acts as a bridge between your application and the database. It is responsible for:

• Managing Entity States: Tracks changes to entities (added, modified, deleted, etc.).
• Querying the Database: Provides methods for querying and updating data, such as DbSet<TEntity>, LINQ queries, and raw SQL queries.
• Database Interactions: Coordinates interactions between the entity model and the database using the Unit of Work pattern.
• Saving Changes: The SaveChanges() method is used to persist changes to the database.

Example:

public class MyDbContext : DbContext
{
    public DbSet<Student> Students { get; set; }
    public DbSet<Course> Courses { get; set; }
}

DbContext Methods:

• DbSet<TEntity>: Represents collections of entities in the database.
• SaveChanges(): Saves changes made to tracked entities.
• Find(), Add(), Remove(): Methods to manage entities.
• OnModelCreating(): Used for configuring the model using Fluent API.

7. How can you manage entity state in Entity Framework?

In Entity Framework, managing entity state is crucial for controlling how changes are tracked and persisted to the database. EF uses the following states:

1. Added: The entity is new and will be inserted into the database.
2. Modified: The entity is tracked and has been modified.
3. Deleted: The entity is marked for deletion.
4. Unchanged: No changes have been made to the entity.
5. Detached: The entity is not being tracked by the context.

You can manage entity states explicitly using the DbContext.Entry() method.

Example:

var student = dbContext.Students.Find(1);
dbContext.Entry(student).State = EntityState.Modified;  // Mark as modified
dbContext.SaveChanges();

You can also change the state when attaching or updating entities.

8. What are "Shadow Properties" in Entity Framework?

Shadow properties are properties that are not defined in the entity class but are created by Entity Framework to track additional information in the database. These properties are typically used for features like concurrency tokens or audit fields.

• Usage: Shadow properties are usually added using the Fluent API to the model configuration. They are not part of the entity class and don’t appear in the entity code, but EF manages them in the database.

Example:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Student>().Property<DateTime>("LastModified");
}

In this case, LastModified is a shadow property that can be used to track the last modification time but isn’t defined in the Student class.

9. What is the difference between "IQueryable" and "IEnumerable" in Entity Framework?

• IEnumerable<T>:
  
  • Represents a collection of data that can be enumerated (iterated) in memory.
  • Works with in-memory collections and supports LINQ-to-Objects queries.
  • Not optimized for database querying; queries are executed in memory.
• IQueryable<T>:
  
  • Represents a collection of data that is queryable from a data source, typically a database.
  • Supports LINQ-to-Entities or LINQ-to-SQL queries and can be translated to SQL and executed on the database server.
  • More efficient for querying large datasets, as the query is executed on the database server rather than in memory.

Example:

IEnumerable<Student> students = dbContext.Students.ToList();  // Loaded in memory
IQueryable<Student> studentsQuery = dbContext.Students.Where(s => s.Age > 18);  // Query executed on database

10. How can you configure a many-to-many relationship in Entity Framework?

In Entity Framework Core, many-to-many relationships are configured by defining two entities and using a join table. EF Core automatically handles this relationship without needing to define a separate entity for the join table.

Example:

public class Student
{
    public int StudentId { get; set; }
    public string Name { get; set; }
    public ICollection<Course> Courses { get; set; }
}

public class Course
{
    public int CourseId { get; set; }
    public string Title { get; set; }
    public ICollection<Student> Students { get; set; }
}

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Student>()
        .HasMany(s => s.Courses)
        .WithMany(c => c.Students)
        .UsingEntity(j => j.ToTable("StudentCourses"));
}

In this case, EF Core will automatically create a StudentCourses join table to maintain the many-to-many relationship.

11. What are "Global Query Filters" in Entity Framework?

Global Query Filters are filters that can be applied to all queries that involve a specific entity in Entity Framework Core. These filters are automatically applied to all DbSet<TEntity> queries (such as Find(), ToList(), and LINQ queries) for that entity. They are often used for scenarios like soft deletes, multi-tenancy, or filtering out sensitive data.

• Use Case: A common use case is to implement soft deletes, where deleted entities are not physically removed from the database but instead marked with a Deleted flag. The global query filter ensures that deleted entities are excluded from all queries automatically.

Example:

public class MyDbContext : DbContext
{
    public DbSet<Student> Students { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // Apply a global query filter to exclude soft-deleted entities
        modelBuilder.Entity<Student>().HasQueryFilter(s => !s.IsDeleted);
    }
}

public class Student
{
    public int StudentId { get; set; }
    public string Name { get; set; }
    public bool IsDeleted { get; set; }  // Soft delete flag
}

In this example, any query on Students will automatically exclude records where IsDeleted == true, without needing to manually specify the condition in each query.

12. What is the use of "DbSet<TEntity>.AddRange" method in Entity Framework?

The AddRange() method is used to add multiple entities to the DbContext at once, which improves performance over adding entities one at a time with Add(). This method is ideal for batch insert operations.

• How it works: It adds a collection of entities to the context and marks them as Added. The SaveChanges() method will then generate an INSERT command for each entity in the collection.

Example:

var students = new List<Student>
{
    new Student { Name = "John" },
    new Student { Name = "Jane" },
    new Student { Name = "Mark" }
};

dbContext.Students.AddRange(students);
dbContext.SaveChanges();  // Adds all students at once

• Performance Benefit: AddRange() reduces the overhead of tracking individual entity additions and helps improve performance when adding large numbers of entities.

13. What is the purpose of the "Update" method in Entity Framework?

The Update() method is used to mark an entity as modified, which instructs Entity Framework to treat the entity as if it has been changed. It generates an UPDATE SQL query when SaveChanges() is called.

• When to use: This method is typically used when you have an entity that has been disconnected from the context (e.g., it was retrieved, modified elsewhere, and is now being reattached to the context) and you want to explicitly mark it as modified, even though EF might not have tracked the changes.

Example:

var student = new Student { StudentId = 1, Name = "John" };
dbContext.Students.Update(student);  // Marks the entity as modified
dbContext.SaveChanges();  // Will send an UPDATE query to the database

• Key Consideration: When using Update(), all properties of the entity are marked as modified by default. This might cause unnecessary updates to the database if only a few properties were actually changed. You can also set specific properties as modified manually via Entry().

14. What is the difference between the "DbContext.SaveChanges()" and "DbContext.SaveChangesAsync()" methods?

• SaveChanges():
  
  • Synchronous: It is a blocking call that performs database operations synchronously.
  • It will wait for the changes to be committed before the thread continues.

Example:

dbContext.SaveChanges();  // Synchronous operation

• SaveChangesAsync():
  
  • Asynchronous: This method is non-blocking and allows the operation to run asynchronously, freeing up the thread while the database operation is being processed.
  • Typically used in web applications or applications with heavy I/O to avoid blocking the thread.

Example:

await dbContext.SaveChangesAsync();  // Asynchronous operation

• Key Difference:
  
  • Use SaveChanges() for simple scenarios where async operations are not required.
  • Use SaveChangesAsync() in environments where high concurrency or responsiveness is needed, like in web applications.

15. Explain how Entity Framework handles cascading deletes.

Cascading deletes in Entity Framework refer to the automatic deletion of related entities when a parent entity is deleted. Entity Framework uses foreign key relationships and cascade rules to propagate deletes.

• Cascade Delete Rules: These are configured either through data annotations or Fluent API.
  
  • Cascade: Automatically deletes related entities.
  • Restrict: Prevents the delete if there are related entities.
  • SetNull: Sets the foreign key of related entities to null upon deletion.
  • NoAction: No action is taken on related entities.

Example using Fluent API:

modelBuilder.Entity<Order>()
    .HasMany(o => o.OrderItems)
    .WithOne(oi => oi.Order)
    .OnDelete(DeleteBehavior.Cascade);  // Cascade delete

• How it works: When you delete a parent entity (e.g., Order), all related child entities (e.g., OrderItems) are also deleted automatically based on the DeleteBehavior.Cascade configuration.

16. What is a "concurrency conflict" in Entity Framework, and how do you resolve it?

A concurrency conflict occurs when multiple users or processes attempt to modify the same data simultaneously, resulting in conflicting changes. Entity Framework handles concurrency using optimistic concurrency control.

• Optimistic Concurrency: This assumes that conflicts are rare and checks for conflicts only when saving changes. EF uses a concurrency token, typically a timestamp or version field, to detect if the data has changed since it was loaded.

Example of handling concurrency conflict:

public class Product
{
    public int ProductId { get; set; }
    public string Name { get; set; }
    [Timestamp]  // Concurrency token
    public byte[] RowVersion { get; set; }
}

try
{
    dbContext.SaveChanges();
}
catch (DbUpdateConcurrencyException ex)
{
    // Handle concurrency conflict
    var entry = ex.Entries.Single();
    var clientValues = (Product)entry.Entity;
    var databaseValues = entry.GetDatabaseValues();
    // Resolve conflict by merging changes, overwriting, etc.
}

• Resolution Strategies: You can choose to:
  
  • Overwrite the changes made by other users.
  • Merge changes.
  • Reject the save operation.

17. What are the best practices for performance tuning in Entity Framework?

To improve the performance of Entity Framework applications, consider the following best practices:

Use No-Tracking Queries: When you only need to read data without modifying it, use AsNoTracking() to avoid overhead from change tracking.

var students = dbContext.Students.AsNoTracking().ToList();

1. Optimize Queries: Avoid loading unnecessary data and use projections (Select()) to retrieve only the fields you need.

Avoid N+1 Query Problem: Use eager loading (Include()) or explicit loading to avoid multiple queries when fetching related data.

var students = dbContext.Students.Include(s => s.Courses).ToList();

1. Batch Inserts: Use AddRange() for adding multiple records instead of adding them one by one.
2. Indexing: Ensure that frequently queried columns are indexed in the database.
3. Limit Data: Use Take() and Skip() for pagination to avoid loading large datasets all at once.

18. How can you implement pagination in Entity Framework?

Pagination in Entity Framework can be implemented using the Skip() and Take() LINQ methods, which help retrieve a subset of records from the database.

Example:

int pageSize = 10;
int pageNumber = 2;

var students = dbContext.Students
    .Skip((pageNumber - 1) * pageSize)
    .Take(pageSize)
    .ToList();

In this example:

• Skip() skips the number of records based on the current page.
• Take() retrieves only the number of records defined by the page size.

19. How do you handle many-to-many relationships without using a junction table in Entity Framework?

Entity Framework Core (EF Core) 5 and later support many-to-many relationships without explicitly defining a junction table. EF Core will automatically create a join table for you when configuring a many-to-many relationship.

Example:

public class Student
{
    public int StudentId { get; set; }
    public string Name { get; set; }
    public ICollection<Course> Courses { get; set; }
}

public class Course
{
    public int CourseId { get; set; }
    public string Title { get; set; }
    public ICollection<Student> Students { get; set; }
}

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Student>()
        .HasMany(s => s.Courses)
        .WithMany(c => c.Students);
}

In this case, EF Core automatically creates a join table to handle the many-to-many relationship, and you don’t need to manually define it.

20. What is the "DbSet<TEntity>.Remove" method used for in Entity Framework?

The Remove() method is used to mark an entity for deletion. When you call Remove() on a DbSet<TEntity>, the entity is marked with the Deleted state. When SaveChanges() is called, EF generates a DELETE SQL query to remove the entity from the database.

Example:

var student = dbContext.Students.Find(1);
dbContext.Students.Remove(student);
dbContext.SaveChanges();  // DELETE query will be sent to the database

• Key Consideration: The entity is marked as Deleted, but it is not immediately removed from the database until SaveChanges() is called.

21. How does Entity Framework handle lazy loading in a disconnected scenario?

Lazy Loading allows Entity Framework to automatically load related entities when they are accessed for the first time. This is typically achieved using navigation properties that reference related entities.

• In a Disconnected Scenario: Lazy loading requires the entity to be tracked by the DbContext so that related entities can be loaded when accessed. However, in a disconnected scenario (where the DbContext is no longer in use, for example in a web application), lazy loading won't work by default because the context is disposed, and EF can no longer track entities.

To enable lazy loading in disconnected scenarios, you must explicitly enable it and configure it on your navigation properties. In a disconnected state, you can use techniques such as:

• Reattaching the entities to a new DbContext.
• Using explicit loading to load related entities manually.

Example:

// Assuming the navigation property is set to virtual
public virtual ICollection<Order> Orders { get; set; }

// In a disconnected scenario, reattach the entity to a new context
dbContext.Attach(customer);
dbContext.Entry(customer).Collection(c => c.Orders).Load();  // Explicitly load the Orders collection

• Key Consideration: Lazy loading is typically used for scenarios where the DbContext is still open and tracking entities, but for disconnected scenarios, explicit loading or eager loading is preferred.

22. How can you configure Entity Framework to use stored procedures for CRUD operations?

Entity Framework allows you to configure and call stored procedures for CRUD operations (Create, Read, Update, Delete) using the DbSet<TEntity> and DbContext API.

1. For Insert Operations:
   
   • You can use FromSqlRaw to call a stored procedure for inserting data.

Example:

dbContext.Database.ExecuteSqlRaw("EXEC InsertStudent @Name, @Age", 
    new SqlParameter("@Name", student.Name),
    new SqlParameter("@Age", student.Age));

1. For Update/Delete Operations:
   
   • Use stored procedures similarly by executing commands that modify data.

Example:

dbContext.Database.ExecuteSqlRaw("EXEC UpdateStudent @StudentId, @NewName", 
    new SqlParameter("@StudentId", studentId),
    new SqlParameter("@NewName", newName));

1. For Reading Data:
   
   • You can call a stored procedure that returns data using FromSqlRaw to execute a SELECT query.

Example:

var students = dbContext.Students.FromSqlRaw("EXEC GetStudents").ToList();

1. Mapping Stored Procedures to Model:
   
   • You can configure stored procedures for each operation by using the Fluent API in the OnModelCreating method.

1. Mapping Stored Procedures to Model:
   
   • You can configure stored procedures for each operation by using the Fluent API in the OnModelCreating method.

modelBuilder.Entity<Student>().MapToStoredProcedures(s => s.Insert().Update().Delete());

23. What is the purpose of the "AsQueryable" method in Entity Framework?

The AsQueryable() method is used to convert a collection or IEnumerable into an IQueryable sequence, allowing it to be queried further using LINQ methods that are specifically designed to be executed against a database or other queryable data sources.

• Purpose: This method is commonly used in scenarios where you have an IEnumerable or other non-queryable collection and you want to apply LINQ methods like Where, OrderBy, Select, etc., that are designed to be executed on a database or data source.
• Key Benefit: It enables deferred execution and the ability to translate LINQ queries to SQL queries for execution on the database.

Example:

var students = dbContext.Students.AsQueryable().Where(s => s.Age > 18);

Here, AsQueryable() converts the DbSet<Student> into an IQueryable, and further LINQ operations will be executed in the database.

24. How can you disable change tracking in Entity Framework?

Change tracking in Entity Framework is used to track changes to entities in memory so that when SaveChanges() is called, EF knows which records need to be updated in the database. However, change tracking can have overhead in certain scenarios, such as read-only queries or unit tests.

You can disable change tracking in Entity Framework using the AsNoTracking() method.

• When to Use: Use AsNoTracking() when you only need to read data and don’t need to track changes to entities, thus improving performance.

Example:

var students = dbContext.Students.AsNoTracking().ToList();

• Key Consideration: Disabling change tracking will make entities not be tracked for changes, which means you can't update them unless you manually attach them back to the context.

25. What is a "DbContextFactory" in Entity Framework, and when do you use it?

A DbContextFactory is a factory pattern used to create instances of DbContext in scenarios where you need to manage the lifecycle of the DbContext manually, such as in unit testing, dependency injection, or applications with multiple threads.

• When to Use:
  
  • In scenarios where you need to create DbContext instances on demand (e.g., inside a scoped or transient dependency).
  • In unit testing where you need to create a new DbContext instance for each test to ensure test isolation.

Example:

public class AppDbContextFactory : IDbContextFactory<AppDbContext>
{
    public AppDbContext CreateDbContext()
    {
        var options = new DbContextOptionsBuilder<AppDbContext>()
            .UseSqlServer("your_connection_string")
            .Options;

        return new AppDbContext(options);
    }
}

In unit tests, you can then use this factory to create DbContext instances without needing to deal with dependency injection.

26. How do you use an in-memory database with Entity Framework for unit testing?

In-memory databases allow you to simulate a database for unit testing without needing a physical database.

• Steps:
  
  1. Use the UseInMemoryDatabase method to configure Entity Framework to use an in-memory database.
  2. This is useful for scenarios where you need to test your code against a database without requiring a full setup.

Example:

var options = new DbContextOptionsBuilder<AppDbContext>()
    .UseInMemoryDatabase(databaseName: "TestDatabase")
    .Options;

using (var context = new AppDbContext(options))
{
    context.Students.Add(new Student { Name = "John Doe" });
    context.SaveChanges();

    var student = context.Students.First();
    Assert.Equal("John Doe", student.Name);
}

• Key Benefit: The in-memory database is very fast and allows for isolated unit tests with no persistence layer.

27. How can you retrieve only specific columns from a table using Entity Framework?

You can retrieve only specific columns by using projections in LINQ. This is done by selecting the properties you need rather than retrieving entire entities.

• Example:

var studentNames = dbContext.Students
    .Where(s => s.Age > 18)
    .Select(s => new { s.Name, s.Age })
    .ToList();

In this example, only the Name and Age columns are retrieved from the Students table. This approach is useful for reducing memory usage and improving query performance when you don't need all the properties of the entity.

28. How can you map a property in Entity Framework to a column in the database that has a different name?

To map a property in your entity class to a column with a different name in the database, you can use Fluent API or data annotations.

Using Fluent API:

modelBuilder.Entity<Student>()
    .Property(s => s.Name)
    .HasColumnName("StudentName");

Using Data Annotations:

public class Student
{
    [Column("StudentName")]
    public string Name { get; set; }
}

In both cases, the property Name in the Student class is mapped to the StudentName column in the database.

29. How can you handle multiple database contexts in an application with Entity Framework?

When working with multiple DbContext instances in an application, you can use dependency injection and configure each DbContext separately in the Startup class or Program.cs in ASP.NET Core.

Example:

public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext<FirstDbContext>(options => options.UseSqlServer("FirstConnectionString"));
    services.AddDbContext<SecondDbContext>(options => options.UseSqlServer("SecondConnectionString"));
}

• Key Consideration: In scenarios where both contexts need to be used together, you may want to ensure that they share the same connection string or that one context is scoped and the other is transient or singleton, depending on your application's needs.

30. What is the role of the "OnModelCreating" method in Entity Framework?

The OnModelCreating method is a method in the DbContext class where you can configure the model (entities and their relationships) using the Fluent API. This is where you can define things like:

• Entity relationships (one-to-many, many-to-many).
• Primary and foreign key constraints.
• Indexes.
• Naming conventions for tables and columns.
• Customizations for complex types or properties.
• Example:

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

    // Define a relationship
    modelBuilder.Entity<Student>()
        .HasMany(s => s.Courses)
        .WithMany(c => c.Students)
        .UsingEntity(j => j.ToTable("StudentCourse"));

    // Configure column names and other settings
    modelBuilder.Entity<Student>().Property(s => s.Name).HasColumnName("StudentFullName");
}

The OnModelCreating method is executed when the DbContext is initialized and is essential for fine-tuning the model, especially for scenarios where annotations are not sufficient.

31. How do you configure a one-to-many relationship in Entity Framework using Fluent API?

To configure a one-to-many relationship in Entity Framework using Fluent API, you typically define the relationship between two entities where one entity (the "one" side) can have multiple related entities (the "many" side). You specify this relationship using the HasMany() and WithOne() methods in the OnModelCreating method of your DbContext.

• Example:

public class Student
{
    public int StudentId { get; set; }
    public string Name { get; set; }
    public ICollection<Course> Courses { get; set; }  // Navigation property (many)
}

public class Course
{
    public int CourseId { get; set; }
    public string Title { get; set; }
    public int StudentId { get; set; }  // Foreign key property
    public Student Student { get; set; }  // Navigation property (one)
}

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Course>()
        .HasOne(c => c.Student)  // Course has one Student
        .WithMany(s => s.Courses) // Student has many Courses
        .HasForeignKey(c => c.StudentId);  // Specify the foreign key on the many side
}

In this example:

• Student is the "one" side, and Course is the "many" side.
• A Student can have multiple Courses, while a Course is associated with one Student via the StudentId foreign key.

32. What are the common performance bottlenecks in Entity Framework?

There are several performance bottlenecks to be aware of when working with Entity Framework:

N+1 Query Problem: When you fetch a list of entities and, for each one, issue additional queries to load related data. This can be avoided by using eager loading (Include()) or explicit loading.Example:

var students = dbContext.Students.Include(s => s.Courses).ToList();  // Eager loading

1. Inefficient Queries: Using inefficient LINQ queries or retrieving more data than needed can degrade performance. Always use Select() to fetch only the necessary fields.

Change Tracking Overhead: When working with large numbers of entities, change tracking can cause significant overhead. You can disable change tracking for read-only operations using AsNoTracking().Example:

var students = dbContext.Students.AsNoTracking().ToList();  // No change tracking

1. Database Round Trips: Entity Framework can issue multiple queries for complex operations. Try to minimize round trips to the database by using batch operations and optimizing queries.
2. Lazy Loading Overhead: If not carefully managed, lazy loading can lead to unnecessary queries and performance degradation.
3. Large Data Sets: Loading large amounts of data into memory can cause performance issues. Use pagination (Skip() and Take()) to limit the data loaded.

33. How do you implement auditing or logging in Entity Framework?

Auditing and logging can be implemented in Entity Framework by tracking changes made to entities and logging those changes. Here are several strategies to implement auditing and logging:

1. Interceptors in EF Core:
   
   • You can implement EF Core interceptors to log database operations. Interceptors allow you to hook into the execution of database commands, such as queries and commands (e.g., inserts, updates).

Example:

public class MyDbCommandInterceptor : DbCommandInterceptor
{
    public override InterceptionResult<DbDataReader> ReaderExecuting(
        DbCommand command, CommandEventData eventData, InterceptionResult<DbDataReader> result)
    {
        // Log the SQL query being executed
        Console.WriteLine(command.CommandText);
        return base.ReaderExecuting(command, eventData, result);
    }
}

1. Audit Trail Using Soft Deletes: You can maintain an audit trail by adding audit fields (e.g., CreatedDate, CreatedBy, ModifiedDate, ModifiedBy) to your entities and updating these fields during SaveChanges().

Overriding SaveChanges(): Override SaveChanges() to automatically capture changes to entities (e.g., who modified a record and when) before committing them to the database.Example:

public override int SaveChanges()
{
    var entries = ChangeTracker.Entries()
        .Where(e => e.State == EntityState.Modified || e.State == EntityState.Added);
    foreach (var entry in entries)
    {
        // Capture audit information
        if (entry.State == EntityState.Added)
        {
            entry.Property("CreatedDate").CurrentValue = DateTime.Now;
            entry.Property("CreatedBy").CurrentValue = "CurrentUser";  // Retrieve from session or context
        }
        else if (entry.State == EntityState.Modified)
        {
            entry.Property("ModifiedDate").CurrentValue = DateTime.Now;
            entry.Property("ModifiedBy").CurrentValue = "CurrentUser";
        }
    }
    return base.SaveChanges();
}

34. Explain how "DbContextPooling" works in Entity Framework.

DbContextPooling improves performance by reusing instances of DbContext instead of creating a new instance every time. When enabled, EF will keep a pool of DbContext instances ready to be reused, which can significantly reduce the overhead of object creation and garbage collection.

• How it Works:
  
  • When a DbContext is no longer needed, it is returned to the pool instead of being disposed of.
  • The pooled DbContext is reused by the next request, avoiding the need to create a new one from scratch.
• Enabling DbContextPooling: In ASP.NET Core or other dependency injection scenarios, you can enable DbContext pooling by using AddDbContextPool() in your Startup.cs or Program.cs.

Example:

public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContextPool<AppDbContext>(options =>
        options.UseSqlServer("your_connection_string"));
}

• Benefits:
  
  • Improved performance due to reduced object creation overhead.
  • The context is recycled and optimized for reuse.
• Key Considerations: Ensure that you don't store state within the DbContext because it will be reused across requests.

35. What is the difference between "Database First" and "Code First" approaches in Entity Framework?

1. Database First:
   
   • In the Database First approach, you start with an existing database, and EF generates the model classes (entities) and DbContext based on the database schema.
   • You use the Scaffold-DbContext command to reverse-engineer the database into models.

Use Case: This approach is used when you already have a database in place and you want to generate the corresponding code from it.Example:

Scaffold-DbContext "your_connection_string" Microsoft.EntityFrameworkCore.SqlServer -OutputDir Models

1. Code First:
   
   • In the Code First approach, you start by defining your model classes in code, and Entity Framework generates the database schema based on the model.
   • You can use migrations to evolve the database schema as your code changes.

Use Case: This approach is typically used in greenfield projects where you design the database through your code. Example:

public class Student
{
    public int StudentId { get; set; }
    public string Name { get; set; }
}

• You can then run migrations to create the database:

Add-Migration InitialCreate
Update-Database

36. How can you handle database migrations in a production environment?

Handling database migrations in a production environment requires careful planning to ensure data integrity and minimal downtime. Here’s how you can manage it:

1. Apply Migrations During Deployment:
   
   • Use dotnet ef commands to apply migrations during the deployment process. This can be automated in your CI/CD pipeline.

Example:

dotnet ef database update

1. Avoid Data Loss:
   
   • Ensure that your migrations are non-destructive (e.g., avoid dropping columns or tables unless necessary). Always test your migrations in a development or staging environment first.
2. Rolling Back Migrations:
   
   • If a migration introduces issues, you can roll it back using:

dotnet ef database update <previous-migration-name>

1. Data Seeding:
   
   • Use HasData() in migrations to seed data during migration or after it is applied to ensure the database is always in the correct state.

Example:

modelBuilder.Entity<Student>().HasData(new Student { StudentId = 1, Name = "John Doe" });

1. Zero-Downtime Migrations:
   
   • To minimize downtime, split changes into smaller, incremental migrations. Avoid large schema changes that may lock the database for long periods.

37. What is a "detached entity" in Entity Framework?

A detached entity in Entity Framework refers to an entity that is no longer being tracked by the DbContext. This typically happens when the DbContext is disposed of, or the entity is manually detached.

• Detached entities can be re-attached to a new or existing DbContext if needed, but changes made to them will not be automatically tracked by EF.

Example:

var student = dbContext.Students.First();
dbContext.Entry(student).State = EntityState.Detached;  // Detach the entity

• Key Consideration: Detached entities are useful when working with disconnected scenarios, such as in web applications where the DbContext is disposed after the request is completed.

38. What is "Foreign Key Constraint" in Entity Framework and how does it affect data manipulation?

A foreign key constraint ensures the referential integrity of data between two related tables. In Entity Framework, this means that any record in the "many" side of a one-to-many or many-to-many relationship must have a corresponding record in the "one" side.

• Impact on Data Manipulation: When performing CRUD operations, Entity Framework ensures that foreign key constraints are respected.
  
  • Inserts: EF ensures that a valid foreign key exists for the related entity.
  • Deletes: When a record on the "one" side is deleted, EF may trigger a cascading delete if configured, or it may throw an exception if the foreign key constraint is violated.

Example: If you try to insert a Course with an invalid StudentId that doesn't exist in the Students table, EF will throw a referential integrity violation error.

39. What is the difference between "DbSet<TEntity>.Add" and "DbSet<TEntity>.Attach" methods?

1. Add():
   
   • The Add() method is used to add new entities to the DbContext. When you call Add(), the entity is marked as Added in the change tracker, and when SaveChanges() is called, it will be inserted into the database.

Example:

dbContext.Students.Add(newStudent);

1. Attach():
   
   • The Attach() method is used to attach an existing entity to the DbContext. This is useful when the entity already exists in the database, and you want to track changes without reloading the entity.

Example:

dbContext.Students.Attach(existingStudent);

• Key Difference: Attach() assumes the entity already exists in the database, while Add() is used for new entities that need to be inserted.

40. How do you configure Entity Framework to support optimistic concurrency?

Optimistic concurrency allows multiple users to read and modify data simultaneously, but it checks whether the data has been changed since it was last read before committing changes to the database.

1. Add a Concurrency Token: A common approach is to add a RowVersion or Timestamp column to your entity to track changes.
2. Configure the Concurrency Token: In OnModelCreating, configure the RowVersion column to be used for concurrency checks.

Example:

public class Student
{
    public int StudentId { get; set; }
    public string Name { get; set; }
    public byte[] RowVersion { get; set; }  // Concurrency token
}

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Student>()
        .Property(s => s.RowVersion)
        .IsRowVersion();  // Configure as concurrency token
}

• When two users try to update the same record concurrently, Entity Framework will detect the conflict and throw a DbUpdateConcurrencyException. You can then handle the exception and prompt the user to resolve the conflict.

Experienced Question with Answers

1. What is the role of "IUnitOfWork" and "IRepository" patterns in Entity Framework?

The Unit of Work and Repository patterns are two commonly used patterns to manage and simplify data access logic in applications using Entity Framework. They help manage business logic and persistence concerns in a clean, organized way.

IUnitOfWork:

The Unit of Work pattern acts as a central point for managing transactions. It tracks changes made to entities, ensuring that all changes are committed in a single transaction. This pattern can manage multiple repositories and ensures that all updates are persisted atomically.

• Role in Entity Framework: It helps in coordinating changes across multiple repositories, managing transaction boundaries, and ensuring that the changes are committed or rolled back together.

Example:

public interface IUnitOfWork
{
    IStudentRepository Students { get; }
    ICourseRepository Courses { get; }
    Task<int> SaveChangesAsync();
}

In this example, the IUnitOfWork pattern holds references to repositories (like IStudentRepository and ICourseRepository) and provides a method for committing changes (SaveChangesAsync()).

IRepository:

The Repository pattern abstracts the data access layer and provides a set of methods for CRUD operations on entities. It allows you to interact with your data source without needing to deal directly with DbContext.

• Role in Entity Framework: It abstracts away the complexities of data access logic and provides a simple interface to interact with the database.

Example:

public interface IStudentRepository
{
    Task<Student> GetByIdAsync(int id);
    Task<IEnumerable<Student>> GetAllAsync();
    Task AddAsync(Student student);
    Task UpdateAsync(Student student);
    Task DeleteAsync(int id);
}

The IRepository pattern helps encapsulate the logic for interacting with the DbContext, making it easier to test and maintain.