Explore topic-wise InterviewSolutions in .

DEFERRED Execution refers to the process of delaying the evaluation of an expression until its realized value is actually REQUIRED. As a result, performance is GREATLY improved since unnecessary execution is avoided. Queries are deferred until the QUERY variable or query object is iterated over a LOOP.

The SaveChanges() METHOD in EF always WRAPS any operation involving inserting, UPDATING, or deleting data into a transaction. Hence, you do not have to EXPLICITLY open the transaction scope.

EF6's Migration's history table (__MigrationHistory) is basically a database table that is USED to STORE data about migrations APPLIED to a database by Code First Migrations. A table like this is created when the first migration is applied to the database. Within a GIVEN database, this table contains meta-data describing the EF Code First models' schema versions. When you used the Microsoft SQL Server database, this table was considered a system table in EF5. 

DATASET OBJECTS PROVIDE the following methods for generating XML:  

• ReadXml(): This method reads an XML document into a DataSet object.
• GetXml(): This method returns a string containing an XML document.
• WriteXml(): This method writes XML DATA to DISK.

Entity Framework's performance is enhanced by following these steps:

• Choose the RIGHT collection for data manipulation.
• Do not put all DB objects into one entity model.
• When the entity is no longer REQUIRED, its tracking should be disabled and altered.
• Use pre-generating Views to reduce response TIME for the first request.
• Don't fetch all fields unless needed.
• Whenever possible, avoid USING Views and Contains.
• Bind data to a grid or paging only by retrieving the number of records needed.
• Optimize and debug LINQ queries.
• Whenever possible, use compiled queries.

• CSDL: This stands for Conceptual Schema Definition LANGUAGE. BASICALLY, it's a conceptual abstraction that is exposed to the application. In this FILE, you will find a description of the model object.
• SSDL: This stands for Storage Schema Definition Language. In this section, we define the MAPPING to our RDBMS data structure.
• MSL: This stands for Mapping Schema Language. SSDL and CSDL are connected by it. It bridges the gap between the CSDL and SSDL or maps the model and the storage.

In Entity FRAMEWORK code generation, T4 FILES are crucial. EDMX XML files are READ by T4 code templates, which generate C# behind code. The generated C# behind code consists only of your entity and CONTEXT classes.

There are five possible states where an entity can exist:

• Added: It is a state in which an entity exists WITHIN the context but does not exist within the database. When the user invokes the SaveChanges method, DbContext usually generates an INSERT SQL QUERY to insert the data into the database. Upon successful COMPLETION of the SaveChanges method, the entity's state changes to unchanged.
• Deleted: This state indicates that the entity is marked for deletion has not been removed from the database. Also, it indicates the existence of the entity in the database. When the user invokes the SaveChanges method, DbContext usually generates a DELETE SQL query to delete or remove the entity from the database. Upon successful completion of the delete operation, DbContext removes the entity.
• Modified: When the entity is modified, its state BECOMES Modified. Also, it indicates the existence of the entity in the database. When the user invokes the SaveChanges method, DbContext usually generates an UPDATE SQL query to update the entity from the database. Upon successful completion of the SaveChanges method, the entity's state changes to unchanged.
• Unchanged: Since the context retrieved the entity's property values from the database, the values have not changed. This entity is ignored by SaveChanges.
• Detached: This state indicates that the entity is not TRACKED by the DbContext. If an entity was created or retrieved outside the domain of the current instance of DbContext, then its entity state will be Detached.

The following diagram represents the different entity states in Entity Framework:

A foreign key relationship in the database is represented by the NAVIGATION property supported by the Entity Framework. It is possible to SPECIFY RELATIONSHIPS between ENTITIES in a database using this property type. Relationships are defined in a way as to REMAIN coherent in object-oriented code.

It is IMPOSSIBLE to define one approach as the OPTIMAL approach when using the Entity Framework. Project requirements and the type of project determine which development approach should be USED. Database First is a good approach if there is a database present. Model First is the optimal choice if no database and model classes EXIST. As long as the domain classes are available, the Code First method is the BEST choice. 

Three DIFFERENT approaches to implement ENTITY Framework are as follows:

• Code First Approach: The Code First approach primarily uses classes to create the model and its relations, which are then used to create a database. This way, developers can work in an object-oriented manner without considering the database structure. By following this model, developers first WRITE POCO classes and then use these classes to create the database. Code First is the method used by most developers using Domain-Driven Design (DDD).
• Model First Approach: In contrast, the Model First approach uses ORM to build model classes and their RELATIONSHIPS. Following the successful creation of the model classes and relationships, the physical database is created using these models.
• Database-First Approach: In Entity Framework, Database First approach is used to build entity models based on existing databases and reduce the amount of code required. By using this approach, domain and context classes can be created based on existing classes.

Migration is a tool that was introduced in EF to update the database schema automatically when a model is modified without losing any data or other objects. Migrate Database To LATEST Version is a new database initializer used by it. Entity FRAMEWORK offers two types of migration:    

• Automated Migration: Entity Framework 4.3 was the first to introduce automated migration so you don't have to manually migrate databases every time you alter a domain class. For example, you MUST also change the domain classes for each time you make a change, but with automated migration, you can simply run a command through the Package Manager Console.
• Code-based Migration: When you use a code-based migration, you can configure additional aspects of the migration, like SETTING the default value of a column, configuring a computed column, ETC.

First of all, a database LETS you reverse engineer a model from an existing database. Entity Framework Designer is used to view and EDIT models stored and created in EDMX files (.edmx extensions). Using the EDMX file, you automatically generate classes that you can INTERACT with within your application. 

EDMX files represent conceptual models, storage models, and their mappings. This file contains all the mapping information between SQL tables and objects. In addition, it also includes essential information required for rendering models graphically with ADO.NET Entity Data Designer. Furthermore, it is divided into three divisions, CSDL, MSL, and SSDL.

The Entity Data Model consists of 3 core components that form the basis for Entity Framework. The three main components of EDM are as follows:

• Conceptual Model: It is ALSO REFERRED to as the Conceptual Data DEFINITION Language Layer (C-Space). Typically, it consists of model classes (also known as entities) and their relationships.   Your database table DESIGN will not be affected by this. It makes sure that business objects and relationships are defined in XML files.
• MAPPING Model: It is also referred to as the Mapping Schema Definition Language layer (C-S Space). Information about how the conceptual model is mapped to the storage model is usually included in this model. In other words, this model enables the business objects and relationships defined at the conceptual layer to be mapped to tables and relationships defined at a logical layer.
• Storage Model: It is also referred to as the Store Space Definition Language Layer (S-Space). Schematically, it represents the storage area in the backend. Therefore, the storage model is also known as a database design model that is composed of tables, keys, stored procedures, views, and related relationships.

Entity Framework Architecture consists of the following components:

• Entity Data Model (EDM): EDMs abstract logical or relational schema and expose conceptual schema of data with a three-layered model, i.e., Conceptual (C-Space), Mapping (C-S Space), and Storage (S - Space).
• LINQ to Entities (L2E): L2E is basically a query language generally USED to write queries against the object model. The entities defined in the conceptual model are returned by L2E.
• Entity SQL (E-SQL): Similar to L2E, E-SQL is another query language (for EF6 only). The developer must however learn it separately since it is more difficult than L2E. Internally, E-SQL queries are translated or converted to data store-dependent SQL queries. EF is used for converting E-SQL queries to their respective datastore queries, such as T-SQL.
• Entity Client Data Provider: This LAYER's main task is to convert E-SQL or L2E queries into SQL queries that the database understands. In turn, the ADO.Net data provider sends and retrieves data from the database.
• Net Data Provider: It uses standard ADO.NET to enable interaction with the database.
• Object Service: It is a service that facilitates access to a database, and returns data for ANALYSIS when necessary. By using it, you are able to translate data coming from entity clients into entity object STRUCTURES.

Below are some of Entity Framework's basic features:

• Cross-Platform: It is lightweight, extensible, open-source, and can be used on Windows, Linux, and Mac.
• Querying: It allows us to retrieve data from underlying databases using LINQ queries, which are then TRANSFORMED into database-specific query languages.
• Modeling: EDMS (Entity Data Models) are typically created based on POCOs (Plain Old CLR Objects), which are entities with get/set properties of different types. This model is used when querying and saving entity data to the underlying database.
• Change Tracking: By using the SaveChanges method of the context, EF tracks changes to entities and their relationships and ensures the correct updates are performed on the database. Change tracking is enabled by default in EF but can be disabled by setting the AutoDetectChangesEnabled property of DbContext to false.
• Saving: Upon calling the "SaveChanges()" method, EF executes the INSERT, UPDATE, and DELETE commands to the database based on the changes made to entities. "SaveChangesAsync()" is another asynchronous method provided by EF.
• Concurrency: EF provides built-in support for Optimistic Concurrency to prevent an unknown user from overwriting data from the database.
• Transaction: EF's transaction management capabilities automate the querying and saving of data. Furthermore, you can customize the way that transactions are managed.
• Caching: First-level caching of entities is supported out of the box in the EF. Repeated queries will retrieve data from the cache RATHER than the database in this case.
• Built-in Conventions: EF conforms to the conventions of configuration programming and has a set of default settings that automatically configure the model.
• Configuration: By using the data annotation attribute or Fluent API, we can configure the EF model and override the default conventions.
• Migrations: EF provides migration commands that are executable on the command-line interface or NuGet Package Manager Console to incrementally update the database schema to keep it in sync with the application's data model.

Entity Framework has the following disadvantages: 

• If the developer does not use raw SQL codes, things can become complicated sometimes.   
• It is a slower form of the Object Relational MAPPER.   
• For a BIG DOMAIN model, it's not ideal.  
• Some RDMS do not offer this feature.   
• EF's main drawback is its lazy LOADING   
• This requires a non-traditional approach to handling data that isn't available for every database.  
• Since the data migration functionality is weak, it isn't fully effective in practice. 

Entity Framework has the following advantages:

• With its excellent prototypes, it is POSSIBLE to write object-oriented programs.  
• By allowing auto-migration, it is simple to create a database or modify it.   
• It simplifies the developer's job by REDUCING the code length with the help of alternate commands.   
• It reduces development time, development cost, and provides auto-generated code.   
• A unique syntax (LINQ / Yoda) is provided for all object queries, whether they are databases or not.  
• It enables the mapping of multiple CONCEPTUAL models to a single storage SCHEMA. 
• Business OBJECTS can be mapped easily (with drag & drop tables).