Entity Framework Quick Guide: Start-to-End

 public class Student
{
    public int StudentId { get; set; }
    public string Name { get; set; } = string.Empty;
    public DateTime EnrolledOn { get; set; }
    public ICollection<Enrollment> Enrollments { get; set; } = new List<Enrollment>();
}

public class Course
{
    public int CourseId { get; set; }
    public string Title { get; set; } = string.Empty;
    public ICollection<Enrollment> Enrollments { get; set; } = new List<Enrollment>();
}

public class Enrollment
{
    public int StudentId { get; set; }
    public Student Student { get; set; } = null!;
    public int CourseId { get; set; }
    public Course Course { get; set; } = null!;
    public decimal Grade { get; set; }
}

 public class SchoolContext : DbContext
{
    public SchoolContext(DbContextOptions<SchoolContext> options) : base(options) {}

    public DbSet<Student> Students => Set<Student>();
    public DbSet<Course> Courses => Set<Course>();
    public DbSet<Enrollment> Enrollments => Set<Enrollment>();

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Enrollment>()
            .HasKey(e => new { e.StudentId, e.CourseId });
    }
}

 modelBuilder.Entity<Course>()
    .HasMany(c => c.Enrollments)
    .WithOne(e => e.Course)
    .HasForeignKey(e => e.CourseId);

 
dotnet ef migrations add InitialCreate
dotnet ef database update

 
dotnet ef dbcontext scaffold "<connection-string>" Microsoft.EntityFrameworkCore.SqlServer

 // Create
context.Students.Add(new Student { Name = "Ana" });
await context.SaveChangesAsync();

// Read
var list = await context.Students.OrderBy(s => s.Name).ToListAsync();

// Update
var s = await context.Students.FindAsync(1);
if (s != null) { s.Name = "Ana Maria"; await context.SaveChangesAsync(); }

// Delete
if (s != null) { context.Students.Remove(s); await context.SaveChangesAsync(); }

 public class Student {
    public int StudentId { get; set; }
    [Timestamp] public byte[] RowVersion { get; set; } = Array.Empty<byte>();
}

 await using var tx = await context.Database.BeginTransactionAsync();
try {
    // ... multiple operations
    await context.SaveChangesAsync();
    await tx.CommitAsync();
} catch {
    await tx.RollbackAsync();
    throw;
}

 modelBuilder.Entity<TopStudents>().HasNoKey().ToView("vw_TopStudents");

 [Index(nameof(Name), IsUnique = true)]
public class Student { public string Name { get; set; } = string.Empty; }

 var result = await context.Set<ReportRow>()
    .FromSqlRaw("EXEC dbo.GetReport @p0, @p1", from, to)
    .ToListAsync();

 context.Attach(student).State = EntityState.Modified; // or Update(student)
await context.SaveChangesAsync();

 modelBuilder.HasDbFunction(() => DbFuncs.Search(""))
    .HasName("Search").HasSchema("dbo");

 var students = await context.Students
    .FromSqlRaw("SELECT TOP 10 * FROM Students WHERE Name LIKE 'A%'")
    .ToListAsync();

 public enum GradeLetter { A, B, C, D, F }
public class Transcript { public GradeLetter Grade { get; set; } }

 var items = await context.Courses.AsNoTracking().ToListAsync();

 var dto = await context.Students
    .Select(s => new StudentDto { Id = s.StudentId, Name = s.Name })
    .ToListAsync();

 builder.Logging.AddConsole(); // in host builder
// or use DbContextOptionsBuilder.LogTo(Console.WriteLine)

 public class TimingInterceptor : DbCommandInterceptor {
    public override InterceptionResult<DbDataReader> ReaderExecuting(
        DbCommand command, CommandEventData eventData, InterceptionResult<DbDataReader> result) {
        // inspect/measure command.CommandText
        return base.ReaderExecuting(command, eventData, result);
    }
}

 dotnet add package Microsoft.EntityFrameworkCore.SqlServer.NetTopologySuite

 var students = await context.Students
    .Include(s => s.Enrollments)
    .ThenInclude(e => e.Course)
    .ToListAsync();

 var s = await context.Students.FirstAsync();
await context.Entry(s).Collection(x => x.Enrollments).LoadAsync();

 public class Student {
    public int StudentId { get; set; }
    [Required, StringLength(100)] public string Name { get; set; } = string.Empty;
}

 var builder = WebApplication.CreateBuilder(args);
builder.Services.AddDbContext<SchoolContext>(o =>
    o.UseSqlServer(builder.Configuration.GetConnectionString("Default")));
var app = builder.Build();

app.MapGet("/students", async (SchoolContext db) =>
    await db.Students.AsNoTracking().ToListAsync());

app.Run();

 public class Course {
    public int CourseId { get; set; }
    [Required, MaxLength(80)] public string Title { get; set; } = string.Empty;
}

 protected override void OnModelCreating(ModelBuilder mb)
{
    mb.Entity<Course>().Property(p => p.Title).HasMaxLength(80).IsRequired();
}

 mb.Entity<Course>().HasData(
    new Course { CourseId = 1, Title = "Math" },
    new Course { CourseId = 2, Title = "Physics" }
);

 public class Address { public string City { get; set; } = string.Empty; }
public class Teacher { public int Id { get; set; } public Address Address { get; set; } = new(); }
mb.Entity<Teacher>().OwnsOne(t => t.Address);