Entity Framework Core (EF Core) is a new, cross-platform, lightweight, and open-source version of Entity Framework that follows Entity Framework 6.x. The EF core current version is 6.0, released in November 2021.
For software developers, EF Core serves as an object-relational mapper (ORM). It enables interaction with the database using .NET objects, so you don’t need most of the code usually required for database-related operations.
Object-Relational Mapper (ORM) is a kind of bridge between strongly-typed objects and a relational data source. The purpose is to enable developers to work with the data stored in databases in an object-oriented way. To achieve that, EF Core ORM provides a map between the objects defined in the application domain and the data stored in the database.
A typical way to work with relational databases is through some kind of recordset-like data structure. Assume we need to retrieve a list of students from the database. We can do it through ADO.NET:
using (var conn = new SqlConnection(connString))
{
using (var da = new SqlDataAdapter("SELECT * FROM
[dbo].[Students]", conn))
{
var dt = new DataTable();
da.Fill(dt);
foreach (DataRow dr in dt.Rows)
{
Console.WriteLine("\t{0} - {1} {2} - {3}",
dr["BirthYear"],
dr["FirstName"],
dr["LastName"],
(int)dr["Gender"] == 1 ? "Male" : "Female");
}
}
}
public class Student
{
public int Id { get; set; }
public string FirstName { get; set; }
public string LastName { get; set; }
public int BirthYear { get; set; }
public GenderType Gender { get; set; }
public GenderType Gender { get; set; }
public string Interests { get; set; }
}
public enum GenderType { Female, Male }
The problem is, this approach to data access is prone to errors. The code may compile in without any issues but problems can show up in runtime. Common errors happen because the code might not reflect the state of the data source. Or, we might address columns that are removed or changed, or with incorrect column names.
The strongly-typed approach to the data suggests using definite classes in an object-oriented way.
We still need to retrieve the data from the database and map it to our data model. That is where Entity Framework Core ORM enters.
var ctx = new MyDbContext();
var query = ctx.Students.ToList();
foreach (Student student in query)
{
Console.WriteLine("\t\{0} - {1} {2} - {3}",
student.BirthYear,
student.FirstName,
student.LastName,
student.Gender);
}
To understand the EF Core hierarchy, we need to explore all its components, from the bottom up. So, have a look at the below table – it presents the Entity Framework architecture:
| Component | Role |
|---|---|
| Data source specific providers | Abstracts the ADO.NET interfaces to connect to the database |
| Map provider | Translates LINQ command tree into a database native SQL query. Includes Store-Specific bridge which translates the generic command tree into a store-specifica command tree. |
| EDM parser and view mapping | Based on the SLD specification of the data model, maps the model onto a underlying relational database. It creates views of the data based on the conceptual model by aggregating data from multiple tables. It also splits entity update into multiple updates to the corresponding tables. |
| Query and update pipeline | Processes queries, filters and update requests to convert them into canonical command trees which are then converted into store specific queries by the Map Provider. |
| Metadata services | Handles all metadata related ot the entities, relationships and mappings. |
| Transactions | Integrates into transactional capabilities of the underlying store if it is supported by the underlying store.. |
| Conceptual layer API | Exposes the programming model for coding against the conceptual schema. It follows the ADO.NET pattern of using Connection objects to refer to the map provider, using Command objects to send the query, and returning EntityResultSets or EntitySets containing the result. |
| Disconnected components | Cache datasets and entity sets into the Embedded database. |
| Embedded database | Stores the cached data. |
| Design tools | Set of tools that simplifies mapping of the conceptual schema to the relational schema. |
| Programming layer | Exposes Entity Data Model (EDM) to be consumed by the programming languages. It contains Object Services and Web Services components. |
| Object services | Generates a code for CLR classes that has the same properties as the entity which enables instantiation of entities as .NET objects. |
| Web services | Exposes entities as web services |
| High-level services | Reporting and similar services that work on the entities and not on the relational data. |
As we mentioned earlier, Entity Framework Core was born in 2016, but years have passed since then. By this time, we have witnessed several EF Core versions. For your convenience, we have compiled a table with brief information about them.
| Version | Release Date | Description |
|---|---|---|
| EF Core 1.0 | 27 June 2016 | First version after EF 6 |
| EF Core 2.0 | 14 August 2017 | Released with Visual Studio 2017 15.3 and ASP.NET Core 2.0 |
| EF Core 3.0 | 23 September 2019 | Released with Visual Studio 2019 16.3 and ASP.NET Core 3.0 |
| EF Core 3.1 | 3 December 2019 | Preferred long-term supported version until at least 3 December 2022. |
| EF Core 5.0.2 | 12 January 2021 | |
| EF Core 6.0 | 10 November 2021 | |
| EF Core 7.0 | November 2022 | Latest available version |
At the point of writing this article, the latest available version is EF Core 6.0.7. Here is a short list of the changes in this version:
Entity Framework Core is a significantly improved version of Entity Framework 6, the separate and popular product. But it is not mature yet, even the latest Entity Framework Core 6.0. It does not support certain features and concepts yet.
Thus, many specialists need the platforms where both Entity Framework Core and Entity Framework 6 are installed.
Certain features are much smoother in EF Core, and others are better in EF 6. Here the necessity to define the similar features and differences between the technologies will become burning. So, here is the EF Core vs EF6 overview for your consideration:
In November 2022, Entity Framework Core 7.0 has been released, and is now latest version available. The target of EF Core 7.0 is .NET 6 - existing applications that also target .NET 6 will continue to do so, whereas the older applications that target older .NET, .NET Core, and .NET Framework versions should target .NET 6 or .NET 7 for EF Core 7.0 usage. The update includes multiple breaking changes and highly requested features, while the general direction of EF Core 7.0 concentrates on NET platforms and ecosystem, clear and direct path from EF Core 6.0, performance and miltiple general improvements.
Due to security update, Encrypt is now True by default - the change cannot be reverted or mitigated. This means that valid certificate should be used for the server, whereas the client should trust the said certificate; otherwise, SqlException shall be thrown.
The aforementioned changes concern only Microsoft SQL Server (including Azure SQL Database). Moreover, the efficiency of saving the changes has also improved; the changes are not supported by SQL server if there are database triggers or specific computed columns in the target table. Besides the mentioned changes, there are multiple medium and low impact updates in EF Core 7.0.
Entity Framework Core supports two development approaches: Database First and Code First. Besides, there is the Model First approach – it is supported in EF 6.4 but is not in EF Core now.
Database First suggests creating the data model from the existing database and tables.
Database First in Entity Framework Core creates DbContext and Domain classes based on the existing database schema.
For example, we have an existing database with the following structure:
We run the following command to build our application data model:
PM> Scaffold-DbContext "Data Source=SQLEXPRESS;Initial Catalog=FacultyDatabase;Integrated Security=True" Microsoft.EntityFrameworkCore.SqlServer -OutputDir Models
The result are these data model classes:
This is an illustration of the EF Core db first approach, so you can see how it works.
Code First suggests the creation of the application domain classes first. That includes a special class that derives from the EF DbContext class. As for the Code First in Entity Framework Core, it is based on the domain entity classes and DBContect class. This way, EF Core creates databases and corresponding tables.
By default, EF Core API creates the database and tables using migration classes based on the default conventions and configuration. It is possible to customize these settings to adjust the model to the business requirements. This is common in Domain-Driven Design (DDD).
Once we have the data model classes and DbContext class created, we can use the Code First to generate the database.
Let us have a look at the example of the Entity Framework Core Code First. We will use classes generated in the Database First example and generate a new database FacultyDatabase2 and the corresponding tables.
Run the following command to generate the initial migration class:
PM> Add-Migration FirstMigration
This will result with the FirstMiration class.
Now we can use update-database command to generate the database.
If the command ends successfully, we will get the database with the identical structure as the initial database. This is how the Code First in .NET Core works.
There is one more approach we should review, so let us proceed.
Model First requires that we use the EDMX editor to create the data model. This editor creates entities, relationships, and inheritance hierarchies in the design surface. The database is created based on that model.
However, as we already mentioned, the Model First in Entity Framework Core is not available at the moment. It does not mean it will not be added in the further versions, but if you need the Entity Framework Core model first now, it won’t work, unfortunately.
Entity Framework Core is good at abstracting details. And it offers great prospects to specialists. Here we offer you some Entity Framework performance tips that will help you achieve the best results.
You need to understand the underlying database to design, debug and maintain production app performance at the highest possible level.
Try to replicate the production environment in functional and integration testing as close as possible. It allows you to catch errors that can be caused by the server version's compatibility.
Stress test your application with the representative loads.
Always follow the security guidelines.
Optimize logging configuration.
Prepare a plan for possible failures such as version rollback, server fallback, etc.
Prepare a plan for application deployment and migration during the deployment. Doing migrations at the application start can cause concurrency issues.
Do the detailed examination and testing of the generated migrations. Database schema and column types cannot be easily changed if the database already contains data.
These Entity Framework Core best practices when applied regularly bring excellent results, so we do recommend making a good habit of using them.
We use cookies to provide you with a better experience on the Devart website. You can read more about our use of cookies in our Cookies Policy.
Click OK to continue browsing the Devart site. Be aware you can disable cookies at any time.
