Entity Framework Core에서 기존 데이터베이스에 대한 모델 만들기 

Entity Framework Core에서 기존 데이터베이스에 대한 컨텍스트 및 엔터티 클래스를 만드는 방법을 배웁니다.

기존 데이터베이스에 대한 엔터티 및 컨텍스트 클래스를 생성하는 것을 데이터베이스 우선 접근 방식이라고 합니다.

EF Core는 EF 6과 유사한 엔터티 및 컨텍스트 클래스를 생성하기 위한 DB 모델 및 마법사용 비주얼 디자이너를 지원하지 않습니다.

따라서 Scaffold-DbContext 명령을 사용 하여 리버스 엔지니어링을 수행 해야 합니다.

이 명령은 기존 데이터베이스의 스키마를 기반으로 엔터티 및 컨텍스트 클래스(DbContext 파생)를 만듭니다.

아래 표시된 로컬 MS SQL Server에서 다음 SchoolDB 데이터베이스에 대한 엔터티 및 컨텍스트 클래스를 생성해 보겠습니다.

Scaffold-DbContext Command

Scaffold-DbContext [-Connection] [-Provider] [-OutputDir] [-Context] [-Schemas>] [-Tables>] 
                    [-DataAnnotations] [-Force] [-Project] [-StartupProject] [<CommonParameters>]

PM> Scaffold-DbContext "Server=.\SQLExpress;Database=SchoolDB;Trusted_Connection=True;" Microsoft.EntityFrameworkCore.SqlServer -OutputDir Models

Database=SchoolDB; 클래스를 생성할 데이터베이스 이름 "SchoolDB"를 지정합니다.

Trusted_Connection=True; Windows 인증을 지정합니다. Windows 자격 증명을 사용하여 SQL Server에 연결합니다.

두 번째 매개변수는 공급자 이름입니다.

우리는 SQL Server용 공급자를 사용하므로 Microsoft.EntityFrameworkCore.SqlServer입니다.

-OutputDir 매개변수는 이 경우 Models 폴더인 모든 클래스를 생성하려는 디렉토리를 지정합니다.

Scaffold-DbContext 명령에 대한 자세한 도움말을 보려면 다음 명령을 사용하십시오.

PM> get-help scaffold-dbcontext –detailed

위의 Scaffold-DbContext 명령은 Models폴더의 모든 엔터티에 대한 Fluent API 구성을 사용하여 SchoolDB 데이터베이스 및 컨텍스트 클래스(DbContext 파생)의 각 테이블에 대한 엔터티 클래스를 만듭니다.

다음은 Student 테이블에 대해 생성된 Student 엔터티 클래스입니다.

using System;
using System.Collections.Generic;

namespace EFCoreTutorials.Models
{
    public partial class Student
    {
        public Student()
        {
            StudentCourse = new HashSet<StudentCourse>();
        }

        public int StudentId { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public int? StandardId { get; set; }

        public Standard Standard { get; set; }
        public StudentAddress StudentAddress { get; set; }
        public ICollection<StudentCourse> StudentCourse { get; set; }
    }
}

다음은 데이터를 저장 하거나 검색하는 데 사용할 수 있는 SchoolDBContext 클래스입니다.

using System;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata;

namespace EFCoreTutorials.Models
{
    public partial class SchoolDBContext : DbContext
    {
        public virtual DbSet<Course> Course { get; set; }
        public virtual DbSet<Standard> Standard { get; set; }
        public virtual DbSet<Student> Student { get; set; }
        public virtual DbSet<StudentAddress> StudentAddress { get; set; }
        public virtual DbSet<StudentCourse> StudentCourse { get; set; }
        public virtual DbSet<Teacher> Teacher { get; set; }

        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            if (!optionsBuilder.IsConfigured)
            {
#warning To protect potentially sensitive information in your connection string, you should move it out of source code. See http://go.microsoft.com/fwlink/?LinkId=723263 for guidance on storing connection strings.
                optionsBuilder.UseSqlServer(@"Server=.\SQLExpress;Database=SchoolDB;Trusted_Connection=True;");
            }
        }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Course>(entity =>
            {
                entity.Property(e => e.CourseName)
                    .HasMaxLength(50)
                    .IsUnicode(false);

                entity.HasOne(d => d.Teacher)
                    .WithMany(p => p.Course)
                    .HasForeignKey(d => d.TeacherId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("FK_Course_Teacher");
            });

            modelBuilder.Entity<Standard>(entity =>
            {
                entity.Property(e => e.Description)
                    .HasMaxLength(50)
                    .IsUnicode(false);

                entity.Property(e => e.StandardName)
                    .HasMaxLength(50)
                    .IsUnicode(false);
            });

            modelBuilder.Entity<Student>(entity =>
            {
                entity.Property(e => e.StudentId).HasColumnName("StudentID");

                entity.Property(e => e.FirstName)
                    .HasMaxLength(50)
                    .IsUnicode(false);

                entity.Property(e => e.LastName)
                    .HasMaxLength(50)
                    .IsUnicode(false);

                entity.HasOne(d => d.Standard)
                    .WithMany(p => p.Student)
                    .HasForeignKey(d => d.StandardId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("FK_Student_Standard");
            });

            modelBuilder.Entity<StudentAddress>(entity =>
            {
                entity.HasKey(e => e.StudentId);

                entity.Property(e => e.StudentId)
                    .HasColumnName("StudentID")
                    .ValueGeneratedNever();

                entity.Property(e => e.Address1)
                    .IsRequired()
                    .HasMaxLength(50)
                    .IsUnicode(false);

                entity.Property(e => e.Address2)
                    .HasMaxLength(50)
                    .IsUnicode(false);

                entity.Property(e => e.City)
                    .IsRequired()
                    .HasMaxLength(50)
                    .IsUnicode(false);

                entity.Property(e => e.State)
                    .IsRequired()
                    .HasMaxLength(50)
                    .IsUnicode(false);

                entity.HasOne(d => d.Student)
                    .WithOne(p => p.StudentAddress)
                    .HasForeignKey<StudentAddress>(d => d.StudentId)
                    .HasConstraintName("FK_StudentAddress_Student");
            });

            modelBuilder.Entity<StudentCourse>(entity =>
            {
                entity.HasKey(e => new { e.StudentId, e.CourseId });

                entity.HasOne(d => d.Course)
                    .WithMany(p => p.StudentCourse)
                    .HasForeignKey(d => d.CourseId)
                    .OnDelete(DeleteBehavior.ClientSetNull)
                    .HasConstraintName("FK_StudentCourse_Course");

                entity.HasOne(d => d.Student)
                    .WithMany(p => p.StudentCourse)
                    .HasForeignKey(d => d.StudentId)
                    .HasConstraintName("FK_StudentCourse_Student");
            });

            modelBuilder.Entity<Teacher>(entity =>
            {
                entity.Property(e => e.StandardId).HasDefaultValueSql("((0))");

                entity.Property(e => e.TeacherName)
                    .HasMaxLength(50)
                    .IsUnicode(false);

                entity.HasOne(d => d.Standard)
                    .WithMany(p => p.Teacher)
                    .HasForeignKey(d => d.StandardId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("FK_Teacher_Standard");
            });
        }
    }
}

DotNet CLI 

dotnet 명령줄 인터페이스를 사용하여 EF Core 명령을 실행하는 경우 명령 프롬프트를 열고 루트 폴더로 이동하여 다음 dotnet ef dbcontext scaffold 명령을 실행합니다.

> dotnet ef dbcontext scaffold "Server=.\SQLEXPRESS;Database=SchoolDB;Trusted_Connection=True;" Microsoft.EntityFrameworkCore.SqlServer -o Models