Entity Framework (EF) is an open-source object-relational mapper (ORM) for .NET. It allows developers to work with a database using .NET objects, eliminating the need for most of the data-access code that developers usually need to write. It supports various development workflows, including code-first, model-first, and database-first approaches.
Entity Framework (EF) offers several advantages for developers working with databases in .NET applications:
Entity Framework supports three main types of workflows for model creation and database interaction:
| Workflow | Definition | Advantages | Usage |
|---|---|---|---|
| Code-First | Developers define the domain model using C# or VB.NET classes, and Entity Framework generates the database schema. | Full control over code, ideal for new projects, allows version control and migrations. | Greenfield projects. |
| Database-First | Database schema is created first, then Entity Framework generates model classes from the existing database. | Ensures model matches existing database structure accurately. Suitable for projects with existing databases. | Legacy projects, integration with established databases. |
| Model-First | Developers design the model visually using Entity Framework Designer, and the database schema is generated. | Visual design of the model, easier conceptualization and modification of schema. | Projects preferring a visual approach to database design before schema generation. |
The Code-First approach in Entity Framework allows developers to define the domain model using C# or VB.NET classes, and then Entity Framework generates the corresponding database schema based on these classes. Here’s an in-depth explanation of the Code-First approach:
The DbContext class is the primary class responsible for interacting with the database. It acts as a bridge between your domain or entity classes and the database. DbContext is used for querying and saving data and manages the entity objects during runtime, including tracking changes and managing concurrency.
Migrations in Entity Framework provide a way to incrementally update the database schema to keep it in sync with the model. They allow you to evolve your database schema over time without losing data. Migrations include commands to create, update, or drop tables and columns.
To enable migrations, run the `Enable-Migrations` command in the Package Manager Console. This command creates a Migrations folder in your project, which includes a Configuration class where you can configure settings related to migrations.
DbSet represents a collection of entities of a specific type within the DbContext. It provides methods for performing CRUD operations, such as Add, Remove, and Find, as well as query capabilities using LINQ.
LINQ (Language Integrated Query) is a set of features that provides query capabilities directly in C# or VB.NET. In EF, LINQ to Entities is used to write queries against the DbContext that are translated into SQL and executed against the database. LINQ enhances the readability and maintainability of the code.
Eager Loading, Lazy Loading, and Explicit Loading in Entity Framework:
| Feature | Eager Loading | Lazy Loading | Explicit Loading |
|---|---|---|---|
| Definition | Loads related entities as part of the initial query | Loads related entities only when accessed | Manually loads related entities when needed |
| Usage | Uses the Include method | Requires virtual navigation properties and proxy creation | Uses the Load method |
| Advantages | Reduces the number of database queries | Loads data only when needed, reducing initial load | Provides control over when related data is loaded |
| Disadvantages | Can result in larger queries and more data being loaded | Can lead to multiple database queries (N+1 query problem) | Requires explicit code, increasing complexity |
EF provides optimistic concurrency control by default. You can use the ConcurrencyCheck attribute or the RowVersion data type to mark properties that should be checked for concurrency conflicts. If a conflict is detected during SaveChanges, an exception is thrown, which you can handle to resolve the conflict.
Some key difference between AsNoTracking and Regular Queries in Entity Framework:
| Feature | Regular Queries | AsNoTracking Queries |
|---|---|---|
| Change Tracking | Tracks changes to entities and includes them in the context. | Does not track changes to entities or include them in the context. |
| Usage | Default behavior; entities are tracked by the context. | Use AsNoTracking method to disable change tracking. |
| Performance | Slightly slower due to change tracking overhead. | Faster performance, especially for read-only operations. |
| Memory Usage | Consumes more memory as tracked entities are stored in memory. | Saves memory as entities are not tracked and not stored in memory. |
| Concurrency | Can result in concurrency issues if entities are modified outside the context. | No concurrency issues as entities are not tracked. |
| Scenario | Suitable for scenarios where changes need to be tracked and entities are modified frequently. | Ideal for read-only scenarios or short-lived contexts where tracking is not required. |
One-to-many relationships can be configured using data annotations or the Fluent API. Using data annotations, you can use the [ForeignKey] and [InverseProperty] attributes. With the Fluent API, you use the HasRequired or HasOptional methods with the WithMany and WithRequiredPrincipal or WithRequiredDependent methods to configure the relationship.
Navigation properties are properties on an entity that allow navigation from one entity to another. They represent the relationships between entities, such as foreign key associations, and can be used to access related data without writing explicit joins.
A complex type is a non-scalar property of an entity that maps to multiple columns in the database. It is used to encapsulate a set of related properties into a single object, which can then be reused across different entities. Complex types do not have their own identity or primary key.
The Include method is used to specify related entities to include in the query results. This is known as eager loading, which loads the related data along with the main entity, reducing the number of queries sent to the database and improving performance for certain scenarios.
Common exceptions in EF include DbUpdateConcurrencyException, DbUpdateException, and DbEntityValidationException. You can handle these exceptions using try-catch blocks around your SaveChanges call. For validation errors, you can inspect the DbEntityValidationResult to provide detailed error messages to the user.
The OnModelCreating method is used to configure the model using the Fluent API. It is called when the model for a derived context is being created. This method allows you to configure relationships, property mappings, table mappings, and other model-level settings that cannot be achieved using data annotations.
Seeding is done using the Seed method in the Configuration class created during migration configuration. This method is called after migrating to the latest version and can be used to insert or update initial data required for the application to function correctly.
Shadow properties are properties that are not defined in the .NET entity class but are defined in the EF model. They are useful for properties used only by the framework, such as for tracking changes or storing metadata, and are configured using the Fluent API.
SaveChanges commits all the tracked changes to the database. It translates the changes made to the tracked entities into SQL INSERT, UPDATE, and DELETE commands and executes them against the database. It ensures that the database is updated to reflect the current state of the DbContext.
In EF Core, you can use the DbContextOptionsBuilder's UseLoggerFactory method to configure logging. In EF6, you can set the Database.Log property to a delegate that writes the log to a desired output, such as a console or a file.
Global query filters are LINQ query predicates applied to entity types in the model. They are configured in the OnModelCreating method and are automatically applied to all queries involving those entity types. This is useful for implementing soft deletes, multi-tenancy, or other common filtering scenarios.
EF provides implicit transactions by default for each call to SaveChanges. For more control, you can use explicit transactions with the DbContext.Database.BeginTransaction method. This allows multiple SaveChanges calls to be wrapped in a single transaction, ensuring atomicity.
The AsNoTracking method improves performance by disabling change tracking for the entities returned by the query. This is beneficial for read-only scenarios where entities do not need to be updated. It reduces the overhead associated with tracking changes to entities.
Change tracking is the process where EF keeps track of changes made to entities since they were retrieved from the database. This allows EF to determine which entities need to be inserted, updated, or deleted when SaveChanges is called. It uses a snapshot of the entity's state to track modifications.
In EF Core, many-to-many relationships can be configured using a join entity that includes foreign keys to both related entities. In EF6, you can use the HasMany and WithMany methods in the Fluent API to configure the relationship without a join entity. EF Core 5.0 and later support direct many-to-many relationships without a join entity.
Data annotations are attributes applied to entity classes and properties to configure the model. They can specify constraints like Required, MaxLength, and Key. Data annotations provide a simple way to configure the model directly in the code, but they have limitations compared to the Fluent API.
Soft delete can be implemented by adding a boolean IsDeleted property to your entities and filtering out deleted entities using global query filters. Instead of physically deleting records, you set IsDeleted to true. This approach retains the data for auditing or historical purposes.
Some key difference between DbContext and ObjectContext in Entity Framework:
| Feature | DbContext | ObjectContext |
|---|---|---|
| Introduction | Introduced in Entity Framework 4.1 (EF 4.1) as a simpler and easier-to-use API for data access. | Part of the original Entity Framework (EF) introduced in .NET Framework 3.5. |
| Inheritance | Inherits from the DbContext class. | Directly represents the ObjectContext class. |
| Usage | Preferred choice for new development projects in Entity Framework. | Used in older projects or when advanced features of ObjectContext are required. |
| Features | Provides a simplified and higher-level API for data access, including DbSet and LINQ support. | Offers more advanced features and greater control over data access compared to DbContext. |
| Migration Support | Supports automatic migration using Code First Migrations in Entity Framework. | Does not support automatic migration and requires manual schema management. |
EntityState is an enumeration that represents the state of an entity with respect to the DbContext. The states include Added, Modified, Deleted, Unchanged, and Detached. EF uses these states to determine how to handle entities during SaveChanges, such as whether to insert, update, or delete records.
The DbSet.Find method is used to retrieve an entity by its primary key. It first checks the DbContext’s cache for the entity and, if not found, queries the database. This method is efficient for finding entities by their primary key and supports working with detached entities.
The Fluent API provides a way to configure your model using method calls instead of data annotations. It is more powerful and flexible, allowing configuration of complex mappings, relationships, and conventions that cannot be achieved with data annotations alone. It is defined in the OnModelCreating method of the DbContext.
Composite keys are configured using the Fluent API in the OnModelCreating method. You use the HasKey method and specify the properties that make up the composite key. Composite keys are not supported directly by data annotations and require Fluent API configuration.
The Remove method marks an entity for deletion. When SaveChanges is called, EF generates a SQL DELETE command to remove the entity from the database. The entity’s state is changed to Deleted, and it is removed from the DbContext after the transaction is committed.
Some key difference between TPH, TPT, and TPC inheritance strategies in Entity Framework:
| Inheritance Strategy | Description | Example | Advantages | Disadvantages |
|---|---|---|---|---|
| Table Per Hierarchy | All types in the hierarchy are mapped to a single database table. | A "Person" table with a discriminator column indicating the type. | Simplifies database schema, potentially better performance. | May lead to sparse tables with many nullable columns. |
| Table Per Type | Each type in the hierarchy has its own database table. | Separate "Employee" and "Customer" tables with distinct columns. | Ensures normalization, better performance for type-specific queries. | More complex schema with multiple tables and joins. |
| Table Per Concrete Class | Each concrete class in the hierarchy has its own database table. | Separate tables for "Employee" and "Customer" with no shared columns. | Ensures no null values, simpler queries with no joins necessary. | Redundant data storage if there are common properties. |
LINQ to Entities allows querying the database using LINQ syntax. Queries are written in C# or VB.NET and translated into SQL by EF. You can use standard LINQ operators such as Select, Where, OrderBy, and GroupBy to query the DbSet properties of your DbContext.
DbContextOptions is used to configure the DbContext. It provides options such as the database provider (e.g., SQL Server, SQLite), connection string, logging, and other settings. DbContextOptions is passed to the DbContext constructor to initialize it with the specified configuration.
The ToList method executes the query and returns the results as a List. It forces immediate execution of the query and materializes the results into a list. This is useful for executing deferred queries and retrieving the results for further processing or display.
DbUpdateConcurrencyException is thrown when a concurrency conflict is detected during SaveChanges. This occurs when another user has modified the same data since it was loaded into the DbContext. You can handle this exception to resolve conflicts, such as by reloading the data and retrying the operation.
Some key difference between Add and Attach methods in DbContext:
| Feature | Add Method | Attach Method |
|---|---|---|
| Purpose | Marks an entity as Added, ready to be inserted into the database. | Attaches an entity to the context, tracking changes made to it. |
| Usage | Typically used for new entities not yet tracked by the context. | Used to re-attach entities previously detached or not tracked. |
| Scenario | When creating new entities or adding entities retrieved from external sources. | When working with entities that were detached or not tracked by the context. |
| Behavior | Sets the entity state to Added, ready for insertion into the database. | Sets the entity state to Unchanged, requiring explicit changes to be tracked. |
| Database | EF generates an INSERT statement for the entity when SaveChanges is called. | EF does not generate any database commands until changes are made and tracked. |
| Tracking | Begins tracking the entity and its properties in the Added state. | Does not start tracking changes to the entity until explicitly modified. |
| Entity State | Marks the entity as Added, and its state transitions to Unchanged after successful insertion. | Marks the entity as Unchanged, requiring explicit modification to be tracked. |
Default values can be configured using the Fluent API in the OnModelCreating method. Use the HasDefaultValue method to specify the default value for a property. This ensures that when a new entity is added, the specified property will have the default value if not set explicitly.
The HasRequired and HasOptional methods are used to configure required and optional relationships between entities in the Fluent API. HasRequired specifies that the relationship is mandatory, while HasOptional indicates that it is optional. These methods help define the foreign key constraints and navigation properties.
Raw SQL queries can be executed using the DbContext.Database.SqlQuery method for queries that return entities and DbContext.Database.ExecuteSqlCommand for non-query commands (e.g., INSERT, UPDATE, DELETE). In EF Core, you use the FromSqlRaw method for queries and ExecuteSqlRaw for commands.
The DbFunctions class provides methods that map to database functions. These methods can be used in LINQ to Entities queries to perform operations that are translated to SQL functions. Examples include DbFunctions.TruncateTime and DbFunctions.DiffDays, which map to corresponding SQL functions.
Pagination can be implemented using the Skip and Take methods in a LINQ query. Skip specifies the number of records to skip, while Take specifies the number of records to return. This approach allows you to retrieve a specific subset of results, useful for implementing paging in applications.
DbContextOptionsBuilder is used to configure the options for a DbContext instance. It provides methods to set the database provider, connection string, logging, and other settings. This builder pattern allows for flexible and fluent configuration of the DbContext options.
Entity validation can be handled using data annotations and the IValidatableObject interface. Data annotations provide built-in validation attributes like Required and StringLength. Implementing IValidatableObject allows custom validation logic. EF validates entities before saving changes and throws a DbEntityValidationException for validation errors.
The Include method is used for eager loading of related data. It specifies the related entities to include in the query results, reducing the number of database queries. This method improves performance and avoids the N+1 query problem by loading related data in a single query.
Shadow properties are properties not defined in the .NET entity class but defined in the EF model. They are useful for properties needed by the framework but not part of the domain model. Shadow properties are configured using the Fluent API and can be used for tracking and metadata purposes.
One-to-one relationships can be configured using data annotations or the Fluent API. With data annotations, use the [Key] and [ForeignKey] attributes. With the Fluent API, use the HasRequired or HasOptional methods with the WithRequiredPrincipal or WithRequiredDependent methods to configure the relationship.
The ValueGeneratedOnAdd method is used to configure properties that have values generated by the database when a new entity is inserted. This is typically used for primary keys and timestamp columns. It ensures that EF expects the value to be generated by the database, not provided by the application.
EF does not natively support bulk operations like bulk insert, update, or delete efficiently. However, you can use third-party libraries like EFCore.BulkExtensions or EntityFramework.BulkInsert to perform these operations. These libraries provide methods to perform bulk operations efficiently, reducing the number of database round-trips.