Entity Framework Core Basics

# CHAPTER 27

Entity Framework Core Basics #

1. Introduction #

Entity Framework Core (EF Core) is a modern Object-Relational Mapper (ORM). It allows you to interact with your database using 100% C# objects and LINQ. EF Core automatically translates your C# code into highly optimized, secure SQL commands behind the scenes.

2. Learning Objectives #

• Understand what an ORM is.

• Map a C# Class (Model) to a database table.

• Create a DbContext class.

• Understand Code-First Migrations.

• Perform CRUD operations using C# and LINQ.

3. The Model (The Table Blueprint) #

// This class will become a 'Products' table in SQL
public class Product
{
    public int Id { get; set; } // EF Core automatically makes properties named 'Id' the Primary Key!
    public string Name { get; set; }
    public decimal Price { get; set; }
}

4. The DbContext (The Database Session) #

using Microsoft.EntityFrameworkCore;

public class AppDbContext : DbContext
{
    // This tells EF Core: "Create a table called Products to hold Product objects"
    public DbSet<Product> Products { get; set; }

    // Configure the database connection
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        // Using a local SQLite database for simplicity
        optionsBuilder.UseSqlite("Data Source=app.db"); 
    }
}

5. Migrations (Creating the Database) #

In your terminal, you run:

1. 1. dotnet ef migrations add InitialCreate (Analyzes your C# classes and creates a blueprint).

1. 2. dotnet ef database update (Executes the blueprint, actually creating the database file/tables).

6. Performing CRUD Operations #

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        using (var db = new AppDbContext())
        {
            // CREATE (Insert)
            var newProduct = new Product { Name = "Laptop", Price = 999.99m };
            db.Products.Add(newProduct);
            db.SaveChanges(); // Actually sends the INSERT SQL to the database

            // READ (Select using LINQ!)
            var product = db.Products.FirstOrDefault(p => p.Name == "Laptop");
            Console.WriteLine($"Found: {product.Name} for ${product.Price}");

            // UPDATE
            product.Price = 850.00m;
            db.SaveChanges(); // Detects the change and sends an UPDATE SQL

            // DELETE
            db.Products.Remove(product);
            db.SaveChanges(); // Sends a DELETE SQL
        }
    }
}

7. Why use EF Core over ADO.NET? #

• Type Safety: If you rename a property from Price to Cost, the C# compiler ensures all your queries update. With raw SQL strings, you wouldn't know it was broken until runtime.

• Security: EF Core automatically uses parameterized queries, making SQL injection impossible.

• Productivity: Writing .Add() and .SaveChanges() takes 2 seconds. Writing standard SQL insert logic in ADO.NET takes 15 lines of code.

8. Common Mistakes #

• Forgetting .SaveChanges(): You can .Add() 100 items to the DbSet, but absolutely nothing happens in the actual database until you explicitly call db.SaveChanges().

• Querying inside a loop (N+1 Problem): Running a LINQ query to the database inside a foreach loop will execute hundreds of separate SQL commands, crashing server performance. Fetch the data once into a List, then loop.

9. Best Practices #

• Use EF Core's Asynchronous methods (SaveChangesAsync, ToListAsync) in web applications to prevent freezing the server threads during database I/O.

10. Exercises #

1. 1. Define a Student class with Id, Name, and Grade properties.

1. 2. Create a SchoolContext class inheriting from DbContext containing a DbSet<Student> Students.

11. MCQs with Answers #

Q3. In the EF Core "Code-First" approach, what determines the database schema? a) The SQL Server Administrator b) Your C# Models (Classes) c) An XML file Answer: b) Your C# Models (Classes)

12. Interview Questions #

• Q: Explain the Code-First vs Database-First approach in EF Core.

• Q: What is the N+1 Query Problem in Entity Framework, and how do you solve it using .Include() (Eager Loading)?

• Q: Explain the role of the DbContext.

13. Summary #

14. Next Chapter Recommendation #