Entity Framework Core & Data Access

public class AppDbContext : DbContext {
    public DbSet<Product> Products { get; set; }
}

var product = await context.Products.FindAsync(1);
product.Price = 29.99m;
await context.SaveChangesAsync();  // Unit of Work: commits all tracked changes together

Common follow-ups: When would an additional Repository layer over EF Core still be justified?;How does DbContext's change tracking actually implement Unit of Work internally?

# Code-First: define classes, generate migrations
dotnet ef migrations add InitialCreate
dotnet ef database update

# Database-First: scaffold classes from existing DB
dotnet ef dbcontext scaffold "Server=...;Database=Legacy;" Microsoft.EntityFrameworkCore.SqlServer

Common follow-ups: How do you keep scaffolded classes in sync when the source database schema changes?;Can you mix both approaches within the same solution?

// Tracked (default): needed if you plan to modify and SaveChanges
var product = await context.Products.FirstAsync(p => p.Id == 1);
product.Price = 19.99m;
await context.SaveChangesAsync();

// No-tracking: faster for read-only display scenarios
var products = await context.Products.AsNoTracking().ToListAsync();

Common follow-ups: How much memory/performance overhead does tracking actually add per entity?;When would AsNoTrackingWithIdentityResolution be preferable to plain AsNoTracking?

// N+1 problem: 1 query for orders, then N queries for each order's customer
var orders = await context.Orders.ToListAsync();
foreach (var order in orders) {
    Console.WriteLine(order.Customer.Name);  // lazy-loads Customer, one query per order!
}

// Fixed with eager loading: exactly 1 query total
var orders = await context.Orders.Include(o => o.Customer).ToListAsync();

Common follow-ups: How does query logging help you detect N+1 problems in existing code?;What's the difference between eager, lazy, and explicit loading strategies?

dotnet ef migrations add AddProductDiscountColumn
# Review the generated Up()/Down() methods in the migration file before committing

# Production: apply as a distinct pipeline step, not on every app startup
dotnet ef database update --connection "$PROD_CONNECTION_STRING"

Common follow-ups: Why is calling Database.Migrate() on every app startup risky in a scaled-out deployment?;How do you generate a SQL script from migrations for DBA review instead of applying directly?

// Efficient: filtering happens in SQL (WHERE clause)
var expensive = context.Products.Where(p => p.Price > 100).ToList();

// Inefficient: loads ALL products into memory first, THEN filters in C#
var expensive = context.Products.ToList().Where(p => p.Price > 100).ToList();

Common follow-ups: How can you tell from code review whether a LINQ chain will execute in SQL or in memory?;What operations force premature materialization?

public class Product {
    public int Id { get; set; }
    public decimal Price { get; set; }
    [Timestamp] public byte[] RowVersion { get; set; }
}

try {
    await context.SaveChangesAsync();
} catch (DbUpdateConcurrencyException) {
    // Another user modified this row concurrently -- reload and prompt for resolution
}

Common follow-ups: What's the difference between optimistic and pessimistic concurrency control?;How do you resolve a DbUpdateConcurrencyException programmatically (client-wins vs store-wins)?

public abstract class Animal { public int Id { get; set; } public string Name { get; set; } }
public class Dog : Animal { public string Breed { get; set; } }
public class Cat : Animal { public bool IsIndoor { get; set; } }

// TPH (default): one 'Animals' table with a 'Discriminator' column and nullable Breed/IsIndoor columns
modelBuilder.Entity<Animal>().HasDiscriminator<string>("AnimalType");

Common follow-ups: What are the trade-offs that would push you toward TPT or TPC instead of the TPH default?;How does the discriminator column get automatically populated?

var query = context.Products.Where(p => p.Category == "Electronics").OrderBy(p => p.Price);
Console.WriteLine(query.ToQueryString());  // prints the exact generated SQL without executing

// Optimized: project only needed columns
var summaries = await context.Products
    .Where(p => p.Category == "Electronics")
    .Select(p => new { p.Id, p.Name, p.Price })  // avoids loading full entity
    .ToListAsync();

Common follow-ups: How do you enable EF Core's built-in query logging in appsettings.json?;What's the performance difference between projecting with Select() versus loading full entities?

// Blocks a thread pool thread for the entire database round-trip
context.SaveChanges();

// Releases the thread during the I/O wait, scales much better under load
await context.SaveChangesAsync();

Common follow-ups: What's the actual mechanism by which async I/O avoids blocking a thread?;Are there any scenarios where synchronous SaveChanges is actually preferable?