Entity Framework Core Overview

Entity Framework Core is an Object-Relational Mapper (ORM) for .NET, which simplifies working with databases. Instead of writing raw SQL queries to interact with databases, EF Core allows developers to interact with their data using C# objects. This reduces the complexity of managing database access in an application.EF Core makes working with databases in .NET easier and more efficient by allowing you to use C# to manage your data, removing the need to manually write SQL queries.

Basic Concepts:

• DbContext: This is the central class in EF Core that manages the connection to the database. It allows you to query and save data.
• Entities: These are your C# classes that map to tables in the database. Each class represents a table, and each property corresponds to a column in that table.
• Migration: EF Core can automatically create or update database schemas as your model (C# classes) changes, without needing manual SQL changes.

Example

Let’s say you're building an application to manage users. You want to store information like the user's name, email, and date of registration in a database. .

Step 1: Define the User Class

This class represents the structure of your table in the database.

   
public class User
{
public int Id { get; set; } // Primary Key
public string Name { get; set; }
public string Email { get; set; }
public DateTime RegistrationDate { get; set; }
}

The User class will map to a table in the database, with each property corresponding to a column.

Step 2: Create the DbContext

This class connects your application to the database and handles reading/writing data.

public class AppDbContext : DbContext
{
public DbSet Users { get; set; }  // Users table
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
optionsBuilder.UseSqlServer(@"Server=yourserver;Database=YourDatabase;Trusted_Connection=True;");
}
}

The AppDbContext connects to a SQL Server database. The Users property represents the "Users" table.

Adding Users to the Database Now

Step 3: Adding Users to the Database Now, you can add new users to the database with EF Core.

  
using (var context = new AppDbContext())
{
var newUser = new User
{
Name = "John Doe",
Email = "john.doe@example.com",
RegistrationDate = DateTime.Now
};
context.Users.Add(newUser);   // Adds the new user to the Users table
context.SaveChanges();// Saves the changes to the database
}

context.Users.Add(newUser) prepares a new user for the database.
context.SaveChanges() commits the data to the database.

Retrieving Users from the Database

using (var context = new AppDbContext())
{
var users = context.Users.ToList();  // Fetch all users from the Users table

foreach (var user in users)
{
Console.WriteLine($"{user.Name}, {user.Email}, {user.RegistrationDate}");
}
}

context.Users.ToList() retrieves all users from the "Users" table. The list of users is then printed in the console.

Why Use EF Core?

• Simplifies Database Operations: No need to write complex SQL queries; you use C# code to interact with the database.
• Automatic Migrations: EF Core can automatically update the database schema when your model changes.
• Object-Oriented Approach: You can work directly with C# objects, making your code easier to maintain and understand.

Disadvantages Of EF Core

While EF Core (Entity Framework Core) simplifies database interactions for developers, it also has some disadvantages that are important to consider:

1. Performance Overhead

• Slower execution : EF Core often generates more complex SQL queries than hand-written SQL, which can result in slower performance, especially for large datasets or complex queries.
• Lazy loading inefficiency: If not managed properly, lazy loading (where related data is only loaded when accessed) can cause performance issues by making multiple database queries unintentionally.

2. Limited Control Over SQL

• Complex queries: While EF Core handles basic queries well, more complex operations (like specific JOINs, subqueries, or advanced filtering) can be difficult to express in LINQ (the querying language used with EF Core). In some cases, EF Core-generated queries can be inefficient, and writing optimized SQL directly may be preferable.
• Migration limitations: EF Core's migration system is convenient, but for complex database changes, manual SQL scripts are sometimes required for precise control.

3. Limited Features for Certain Databases

• Database-specific features: EF Core abstracts database interactions, which can make it difficult to use certain features specific to a particular database system (like advanced indexing options or specific stored procedures in SQL Server or PostgreSQL). This abstraction can sometimes limit access to the full power of the underlying database.

4. Learning Curve

• Conceptual overhead: While EF Core simplifies data access, developers need to learn and understand how EF Core handles object-relational mapping, lazy loading, migrations, and querying through LINQ. For developers unfamiliar with ORMs, this can be a steep learning curve.

5. Lack of Fine-tuned Control

• Automatic behavior: EF Core makes a lot of decisions behind the scenes (like automatically mapping classes to tables, tracking changes, or lazy loading related data). While this can be convenient, it can also be restrictive if you need finer control over how data is queried or managed.

6. Limited Support for Older Databases

• Legacy databases: EF Core may struggle when integrating with older databases that don’t follow modern relational design principles, such as databases without primary keys or those with irregular schemas.

7. Concurrency Handling

• Concurrency conflicts: Managing data concurrency in EF Core (when multiple users access or modify the same data simultaneously) can be tricky. Although it supports concurrency tokens, the default handling can sometimes lead to unexpected results if not carefully managed.

In summary, EF Core is a powerful tool for developers working with databases, but it introduces performance overhead, lacks fine-grained control for complex queries, and has some limitations when dealing with specific database features or legacy systems.

Conclusion

• Simplifies Database Operations: No need to write complex SQL queries; you use C# code to interact with the database.
• Automatic Migrations: EF Core can automatically update the database schema when your model changes.
• Object-Oriented Approach: You can work directly with C# objects, making your code easier to maintain and understand.