MauricioG Code

The Power of Entity Framework Core

Photo by Shubham Dhage on Unsplash

The Power of Entity Framework Core

mauriciog's photo
mauriciog

Introduction

Welcome to our blog, where we delve into the world of Entity Framework Core (EF Core)! In this post, we'll explore how EF Core, a library created by Microsoft, simplifies database access, particularly for relational databases. We'll also discuss its advantages, use cases, and the differences between EF and EF Core. So let's dive in and discover the potential of EF Core in enhancing your coding experience!

What is Entity Framework Core?

Entity Framework Core is a user-friendly library designed by Microsoft that provides a simple way to interact with databases, primarily relational ones. Its main advantage lies in the ability to use code instead of direct SQL queries, making it a powerful tool for developers. Additionally, EF Core seamlessly integrates with LINQ, a query language that allows for expressive and efficient data retrieval. However, it's important to exercise caution with complex LINQ queries, as they may impact performance.

This widely adopted library offers robust functionalities, including support for concurrency, transactions, caching, and the use of entity classes as representations of database tables. Furthermore, EF Core offers flexibility in terms of development approach, allowing developers to choose between Code First and Database First methodologies. Throughout the course, we'll explore examples of both scenarios.

When to Use Entity Framework Core

In the past, I was somewhat hesitant to use Entity Framework due to its performance issues when constructing complex queries. However, starting from .NET 6, EF Core has made significant improvements. In fact, with the latest release of .NET 7, it is now on par with Dapper, the ORM I have traditionally relied on.

Today, I highly recommend using Entity Framework Core in almost all scenarios, except for very complex queries. Its default functionality generally suffices, and we even have the flexibility to use raw SQL queries when necessary.

The Difference Between Entity Framework and EF Core

The main difference between Entity Framework and EF Core lies in their framework dependencies. Entity Framework is tied to .NET Framework, whereas EF Core is compatible with both .NET and .NET Core. Furthermore, EF Core is lighter in weight and receives more frequent updates, making it the more up-to-date and preferred choice.

It's worth noting that Microsoft's naming conventions can be a bit confusing. If you'd like a detailed breakdown of the differences, you can refer to my post on the topic.

Choosing the Right Database Access Methodology

When embarking on new projects that require a database, we often face the decision of whether to adopt a "Code First" or "Database First" approach. Let's briefly explore these methodologies:

Code First: With Code First, developers write the entity classes, and Entity Framework generates the corresponding tables based on those classes.

Database First: In the Database First approach, the database is created manually using SQL scripts or already exists, and Entity Framework generates the entity classes based on the existing database schema.

Alternatively, with Entity Framework and Visual Studio, we can utilize the Model First approach. This involves creating entities and defining their relationships using Visual Studio's designer.

I've been planning to create a course on EF because it has improved significantly since .NET 6. Consider this post as an introduction to Entity Framework Core.

Connecting to Different Databases using Entity Framework Core

Let's explore examples of connecting to various databases using Entity Framework Core. Each database requires specific NuGet packages, and for all cases, the relevant information is added using the AddDbContext method within the dependency container.

  1. Connect to MySQL with Entity Framework Core:
csharpCopy codeservices.AddDbContext<ExampleEFContext>(options =>
    options.UseMySQL("server=127.0.0.1;port=4306;database=exampleEF;user=root;password=exampleEFpass"));
  1. Connect to SQL Server with Entity Framework Core:
csharpCopy codeservices.AddDbContext<ExampleEFContext>(options =>
    options.UseSqlServer(configuration.GetConnectionString("SQLServerConnection")));
  1. Connect to PostgreSQL with Entity Framework Core:
csharpCopy codeservices.AddDbContext<ExampleEFContext>(options =>
    options.UseNpgsql(configuration.GetConnectionString("PostgreSQLConnection")));
  1. Connect to SQLite with Entity Framework Core:
csharpCopy codeservices.AddDbContext<ExampleEFContext>(options =>
    options.UseSqlite(configuration.GetConnectionString("SQLiteConnection")));
  1. Connect to Azure Cosmos DB with Entity Framework Core:
csharpCopy codeservices.AddDbContext<ExampleEFContext>(options =>
    options.UseCosmos(configuration.GetConnectionString("AzureCosmosConnection"), "dbName"));

Note: For AWS, both Aurora and RDS utilize different databases behind the scenes, so you need to use the appropriate connection, such as UseMySQL for MySQL.

  1. Connect to Oracle with Entity Framework Core:
csharpCopy codeservices.AddDbContext<ExampleEFContext>(options =>
    options.UseOracle(configuration.GetConnectionString("OracleConnection")));

In Conclusion

Entity Framework Core simplifies database access with its user-friendly approach and powerful features. Whether you're working with MySQL, SQL Server, PostgreSQL, SQLite, Azure Cosmos DB, or even Oracle, EF Core provides seamless integration and efficient data management. Stay tuned for more content as we delve deeper into Entity Framework Core in future posts!

entity framework