Entity Framework Core 10

What is Entity Framework Core?

Entity Framework Core is the main object-relational mapper used by many .NET developers. It lets you work with database rows as C# objects while still allowing you to inspect and optimize the SQL that is generated.

In a typical ASP.NET Core application, EF Core sits between your API/service layer and your database. Your controllers or Minimal API endpoints call services, services call the DbContext, and the DbContext translates LINQ queries into database operations.

Create the entity model

Start with small, clear entity classes. Avoid putting too much behavior into the database model at the beginning. A clean first model is easier to migrate, query, test, and explain to Copilot.

public class Customer
{
    public int Id { get; set; }
    public required string Name { get; set; }
    public required string Email { get; set; }

    public List<Order> Orders { get; set; } = [];
}

public class Order
{
    public int Id { get; set; }
    public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
    public string Status { get; set; } = "Pending";
    public decimal Total { get; set; }

    public int CustomerId { get; set; }
    public Customer Customer { get; set; } = default!;

    public ShippingInfo Shipping { get; set; } = new();
}

The relationship is expressed by CustomerId and the Customer navigation property. EF Core can infer many relationships, but professional projects should configure important behavior explicitly.

Add the DbContext and connection

A DbContext represents a session with the database. It stores the model configuration, exposes DbSet properties, tracks changes, and sends updates to the database when you call SaveChangesAsync.

using Microsoft.EntityFrameworkCore;

public class StoreDbContext(DbContextOptions<StoreDbContext> options)
    : DbContext(options)
{
    public DbSet<Customer> Customers => Set<Customer>();
    public DbSet<Order> Orders => Set<Order>();

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Customer>()
            .HasIndex(c => c.Email)
            .IsUnique();

        modelBuilder.Entity<Order>()
            .Property(o => o.Total)
            .HasPrecision(18, 2);
    }
}

// Program.cs
builder.Services.AddDbContext<StoreDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("StoreDb")));

Create and review migrations

Migrations let you evolve the database schema as your model changes. The common beginner mistake is to generate migrations and apply them without reading the generated code. For real projects, always review the migration before applying it.

Query data with LINQ

EF Core translates LINQ queries into SQL. That is powerful, but it also means your C# query shape affects database performance. Start with clear queries, then inspect the SQL for important operations.

var recentOrders = await context.Orders
    .Where(o => o.Status == "Pending" && o.CreatedAt > DateTime.UtcNow.AddDays(-30))
    .OrderByDescending(o => o.CreatedAt)
    .Select(o => new OrderListItemDto(
        o.Id,
        o.Customer.Name,
        o.Total,
        o.CreatedAt))
    .AsNoTracking()
    .ToListAsync();

Create, update, and delete records

For normal entity updates, load or attach the entity, make changes, and call SaveChangesAsync. EF Core tracks changes and sends the required SQL statements.

var customer = new Customer
{
    Name = "Alicia Tan",
    Email = "alicia@example.com"
};

context.Customers.Add(customer);
await context.SaveChangesAsync();

var order = await context.Orders.FindAsync(id);
if (order is null) return Results.NotFound();

order.Status = "Paid";
await context.SaveChangesAsync();

return Results.Ok(order);

Configure relationships and delete behavior

Relationships are where many beginner EF Core problems start. Decide clearly whether a relationship is required, optional, one-to-many, one-to-one, or many-to-many. Also decide what happens when a parent record is deleted.

modelBuilder.Entity<Order>()
    .HasOne(o => o.Customer)
    .WithMany(c => c.Orders)
    .HasForeignKey(o => o.CustomerId)
    .OnDelete(DeleteBehavior.Restrict);

DeleteBehavior.Restrict prevents accidental deletion of a customer if orders still reference that customer. This is often safer for business records such as orders, invoices, audit logs, and payments.

Use complex types and JSON columns carefully

Complex types model values that belong to an entity but do not need a separate identity. Examples include address, money, dimensions, settings, or shipment details. EF Core 10 improves document-style modeling by allowing complex types to be mapped to JSON columns in supported relational databases.

public class ShippingInfo
{
    public string Recipient { get; set; } = "";
    public string Country { get; set; } = "";
    public string PostalCode { get; set; } = "";
}

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Order>()
        .ComplexProperty(o => o.Shipping, s => s.ToJson());
}

var localOrders = await context.Orders
    .Where(o => o.Shipping.Country == "Malaysia")
    .ToListAsync();

Apply named query filters

Global query filters are useful for soft deletion and multi-tenant systems. EF Core 10 adds named query filters, so you can define multiple filters and selectively disable a specific filter for special administrative queries.

modelBuilder.Entity<Order>()
    .HasQueryFilter("SoftDelete", o => !o.IsDeleted)
    .HasQueryFilter("Tenant", o => o.TenantId == tenantId);

var deletedOrders = await context.Orders
    .IgnoreQueryFilters(["SoftDelete"])
    .ToListAsync();

This is cleaner than combining every rule into one large filter because you can reason about each concern separately.

Use ExecuteUpdate and ExecuteDelete for set-based operations

When you need to update many rows based on a condition, set-based operations are usually better than loading every row into memory. EF Core 10 also improves bulk update scenarios involving JSON properties.

await context.Orders
    .Where(o => o.Status == "Pending" && o.CreatedAt < cutoff)
    .ExecuteUpdateAsync(setters => setters
        .SetProperty(o => o.Status, "Expired")
        .SetProperty(o => o.UpdatedAt, DateTime.UtcNow));

// Example: increment a value inside a JSON-mapped complex type
await context.Blogs.ExecuteUpdateAsync(setters => setters
    .SetProperty(b => b.Details.Views, b => b.Details.Views + 1));

Important EF Core 10 features to know

Performance and maintainability checklist

EF Core is productive, but production performance still depends on database knowledge. Use Visual Studio, SQL logs, and your database tools together.

Useful Copilot prompts for EF Core

Copilot can help with EF Core, but you should ask for reviewable steps, not silent magic. Good prompts include your database provider, entity names, migration expectations, and performance constraints.

What you learned

You learned how EF Core fits into a Visual Studio 2026 application, how to design entities and a DbContext, how to manage migrations, and how to write safer LINQ queries. You also saw EF Core 10 topics such as complex types mapped to JSON, named query filters, JSON bulk updates, LeftJoin/RightJoin support, and vector search awareness.

In the next lesson, you will test this kind of code with xUnit and use Copilot to help understand test failures without blindly accepting generated fixes.