5부. ASP.NET Core에서 EF Core를 사용한 Razor Pages - 데이터 모델

작성자 : Tom Dykstra, Jeremy Likness, Jon P Smith

Contoso University 웹앱은 EF Core 및 Visual Studio를 사용하여 Razor Pages 웹앱을 만드는 방법을 보여줍니다. 자습서 시리즈에 대한 정보는 첫 번째 자습서를 참조합니다.

해결할 수 없는 문제가 발생한 경우 완성된 앱을 다운로드하고 자습서를 따라 만든 코드와 해당 코드를 비교합니다.

이전 자습서에서는 세 가지 엔터티로 구성된 기본 데이터 모델을 사용했습니다. 이 자습서에서:

• 더 많은 엔터티 및 관계가 추가됩니다.
• 데이터 모델은 서식 지정, 유효성 검사 및 데이터베이스 매핑 규칙을 지정하여 사용자 지정됩니다.

다음 그림에서는 완료된 데이터 모델을 보여 줍니다.

Dataedo를 사용하여 만든 데이터베이스 다이어그램은 다음과 같습니다.

Dataedo를 사용해 데이터베이스 다이어그램 만들기

• Azure에 앱 배포
• Dataedo를 컴퓨터에 다운로드하여 설치합니다.
• 5분만에 Azure SQL Database용 설명서 생성 지침을 따릅니다.

위의 Dataedo 다이어그램에서는 CourseInstructor은 Entity Framework에서 만든 조인 테이블입니다. 자세한 정보는 다대다를 참조하세요.

학생 엔터티

Models/Student.cs의 코드를 다음 코드로 바꿉니다.

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;

namespace ContosoUniversity.Models
{
    public class Student
    {
        public int ID { get; set; }
        [Required]
        [StringLength(50)]
        [Display(Name = "Last Name")]
        public string LastName { get; set; }
        [Required]
        [StringLength(50, ErrorMessage = "First name cannot be longer than 50 characters.")]
        [Column("FirstName")]
        [Display(Name = "First Name")]
        public string FirstMidName { get; set; }
        [DataType(DataType.Date)]
        [DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}", ApplyFormatInEditMode = true)]
        [Display(Name = "Enrollment Date")]
        public DateTime EnrollmentDate { get; set; }
        [Display(Name = "Full Name")]
        public string FullName
        {
            get
            {
                return LastName + ", " + FirstMidName;
            }
        }

        public ICollection<Enrollment> Enrollments { get; set; }
    }
}

앞의 코드는 FullName 속성을 추가하고 기존 속성에 다음 특성을 추가합니다.

• [DataType]
• [DisplayFormat]
• [StringLength]
• [Column]
• [Required]
• [Display]

FullName 계산된 속성

FullName은 다른 두 개의 속성을 연결하여 생성되는 값을 반환하는 계산된 속성입니다. FullName은 설정될 수 없으므로 get 접근자만 포함합니다. 데이터베이스에서 FullName 열이 생성되지 않습니다.

DataType 특성

[DataType(DataType.Date)]

학생 등록 날짜의 경우 해당 날짜만 관련이 있지만 모든 페이지에는 현재 해당 날짜와 함께 하루의 시간이 표시됩니다. 데이터 주석 특성을 사용하면 데이터를 표시하는 모든 페이지에서 표시 형식을 해결하는 하나의 코드 변경을 만들 수 있습니다.

DataType 특성은 데이터베이스 내장 형식보다 구체적인 데이터 형식을 지정합니다. 이 경우 날짜 및 시간이 아닌 날짜만 표시되어야 합니다. DataType 열거형은 날짜, 시간, 전화 번호, 통화, 전자 메일 주소 등과 같은 많은 데이터 형식을 제공합니다. DataType 특성을 통해 앱에서 자동으로 유형별 기능을 제공하도록 설정할 수도 있습니다. 예시:

• mailto: 링크는 DataType.EmailAddress에 대해 자동으로 만들어집니다.
• 날짜 선택기는 대부분의 브라우저에서 DataType.Date에 대해 제공됩니다.

DataType 특성은 HTML 5 data-(데이터 대시로 발음) 특성을 내보냅니다. DataType 특성은 유효성 검사를 제공하지 않습니다.

DisplayFormat 특성

[DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}", ApplyFormatInEditMode = true)]

DataType.Date는 표시되는 날짜의 서식을 지정하지 않습니다. 기본적으로 날짜 필드는 서버의 CultureInfo를 기본으로 하는 기본 형식에 따라 표시됩니다.

DisplayFormat 특성은 날짜 형식을 명시적으로 지정하는 데 사용됩니다. ApplyFormatInEditMode 설정은 서식 지정이 편집 UI에도 적용되어야 함을 지정합니다. 일부 필드는 ApplyFormatInEditMode를 사용하면 안 됩니다. 예를 들어 통화 기호는 일반적으로 편집 텍스트 상자에 표시되면 안 됩니다.

DisplayFormat 특성은 단독으로 사용될 수 있습니다. 일반적으로 DisplayFormat 특성과 함께 DataType 특성을 사용하는 것이 좋습니다. DataType 특성은 화면에서 렌더링하는 방법과 대조적으로 데이터의 의미 체계를 전달합니다. DataType 특성은 DisplayFormat에서 사용할 수 없는 다음과 같은 이점을 제공합니다.

• 브라우저는 HTML5 기능을 활성화할 수 있습니다. 예를 들어 달력 컨트롤, 로캘에 적합한 통화 기호, 메일 링크, 클라이언트 쪽 입력 유효성 검사를 표시합니다.
• 기본적으로 브라우저는 로캘에 따른 올바른 형식을 사용하여 데이터를 렌더링합니다.

자세한 내용은 <입력> 태그 도우미 설명서를 참조하세요.

StringLength 특성

[StringLength(50, ErrorMessage = "First name cannot be longer than 50 characters.")]

데이터 유효성 검사 규칙 및 유효성 검사 오류 메시지는 특성으로 지정될 수 있습니다. StringLength 특성은 데이터 필드에서 허용되는 최소 및 최대 문자 길이를 지정합니다. 표시된 코드는 이름을 최대 50자로 제한합니다. 최소 문자열 길이를 설정하는 예제는 뒷부분에 나와 있습니다.

StringLength 특성은 또한 클라이언트 쪽 및 서버 쪽 유효성 검사를 제공합니다. 최소값은 데이터베이스 스키마에 영향을 주지 않습니다.

StringLength 특성은 이름에 공백을 입력할 수 있습니다. RegularExpression 특성은 입력에 제한을 적용하는 데 사용될 수 있습니다. 예를 들어 다음 코드는 첫 번째 문자가 대문자여야 하고, 나머지 문자는 사전순이어야 합니다.

[RegularExpression(@"^[A-Z]+[a-zA-Z]*$")]

Visual Studio

SQL Server 개체 탐색기(SSOX)에서 학생 테이블을 두 번 클릭하여 학생 테이블 디자이너를 엽니다.

위의 이미지는 Student 테이블에 대한 스키마를 보여 줍니다. 이름 필드의 형식은 nvarchar(MAX)입니다. 이 자습서의 뒷부분에서 마이그레이션을 만들고 적용하면 문자열 길이 특성의 결과로 이름 필드가 nvarchar(50)이 됩니다.

Visual Studio Code

SQLite 도구를 사용하여 Student 테이블에 대한 열 정의를 검토합니다. 이름 필드의 형식은 Text입니다. 이름 필드를 FirstMidName이라고 하는 것을 확인할 수 있습니다. 다음 섹션에서 FirstMidName는 FirstName로 변경됩니다.

열 특성

[Column("FirstName")]
public string FirstMidName { get; set; }

특성은 클래스 및 속성이 데이터베이스에 매핑되는 방법을 제어할 수 있습니다. Student 모델에서 Column 특성은 데이터베이스에서 FirstMidName 속성의 이름을 “FirstName”에 매핑하는 데 사용됩니다.

데이터베이스가 만들어질 때 모델의 속성 이름은 열 이름에 사용됩니다(Column 특성이 사용되는 경우 제외). 필드에 중간 이름도 포함될 수 있으므로 Student 모델은 첫 번째 이름 필드에 대해 FirstMidName을 사용합니다.

[Column] 특성을 사용하면 데이터 모델의 Student.FirstMidName은 Student 테이블의 FirstName 열에 매핑됩니다. Column 특성을 추가하면 SchoolContext를 지원하는 모델이 변경됩니다. SchoolContext를 지원하는 모델은 데이터베이스와 더 이상 일치하지 않습니다. 해당 불일치는 이 자습서의 뒷부분에서 마이그레이션을 추가하여 해결할 수 있습니다.

필수 특성

[Required]

Required 특성에서 이름 속성은 필수 필드입니다. Required 특성은 값 형식(예: DateTime, int 및 double)과 같은 비 nullable 형식에 필요하지 않습니다. Null일 수 없는 형식은 자동으로 필수 필드로 처리됩니다.

MinimumLength가 적용되려면 Required 특성이 MinimumLength와 함께 사용되어야 합니다.

[Display(Name = "Last Name")]
[Required]
[StringLength(50, MinimumLength=2)]
public string LastName { get; set; }

MinimumLength와 Required는 유효성 검사 충족에 공백을 허용합니다. 문자열을 완전히 제어할 수 있도록 RegularExpression 특성을 사용합니다.

표시 특성

[Display(Name = "Last Name")]

Display 특성은 텍스트 상자에 대한 캡션이 “First Name”, “Last Name”, “Full Name” 및 “Enrollment Date”여야 함을 지정합니다. 기본 캡션에는 단어를 분할하는 공백이 없습니다(예: “Last Name”).

마이그레이션 만들기

앱을 실행하고 [학생] 페이지로 이동합니다. 예외가 throw됩니다. [Column] 특성을 사용하면 EF가 FirstName 열을 찾아야 하지만 데이터베이스의 열 이름은 FirstMidName입니다.

Visual Studio

다음 예제와 유사한 오류 메시지가 표시됩니다.

SqlException: Invalid column name 'FirstName'.
There are pending model changes
Pending model changes are detected in the following:

SchoolContext

• PMC에서 다음 명령을 입력하여 새 마이그레이션을 만들고 데이터베이스를 업데이트합니다.

  Add-Migration ColumnFirstName
  Update-Database
  
  

  이 명령 중 첫 번째는 다음 경고 메시지를 생성합니다.

  An operation was scaffolded that may result in the loss of data.
  Please review the migration for accuracy.
  

  이름 필드는 이제 50자로 제한되기 때문에 경고가 생성됩니다. 데이터베이스의 이름에 50자 이상의 문자가 있는 경우 51자부터 마지막 문자까지 손실됩니다.

• SSOX에서 학생 테이블을 엽니다.

  

  마이그레이션이 적용되기 전에 이름 열의 형식은 nvarchar(MAX)이었습니다. 이름 열은 이제 nvarchar(50)입니다. 열 이름은 FirstMidName에서 FirstName으로 변경되었습니다.

Visual Studio Code

다음 예제와 유사한 오류 메시지가 표시됩니다.

SqliteException: SQLite Error 1: 'no such column: s.FirstName'.

• 프로젝트 폴더의 명령 창을 엽니다. 다음 명령을 입력하여 새 마이그레이션을 만들고 데이터베이스를 업데이트합니다.

  dotnet ef migrations add ColumnFirstName
  dotnet ef database update
  

• SQLite 도구에서 학생 테이블을 검토합니다. FirstMidName였던 열이 이제 FirstName입니다.

• 앱을 실행하고 [학생] 페이지로 이동합니다.
• 시간이 날짜와 함께 입력되거나 표시되지 않는 것을 알 수 있습니다.
• 새로 만들기를 선택하고, 50자보다 긴 이름을 입력해 보세요.

참고 항목

다음 섹션의 일부 단계에서 앱 빌드는 컴파일러 오류를 생성합니다. 지침은 앱을 빌드하는 시기를 지정합니다.

Instructor 엔터티

다음 코드로 Models/Instructor.cs를 만듭니다.

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;

namespace ContosoUniversity.Models
{
    public class Instructor
    {
        public int ID { get; set; }

        [Required]
        [Display(Name = "Last Name")]
        [StringLength(50)]
        public string LastName { get; set; }

        [Required]
        [Column("FirstName")]
        [Display(Name = "First Name")]
        [StringLength(50)]
        public string FirstMidName { get; set; }

        [DataType(DataType.Date)]
        [DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}", ApplyFormatInEditMode = true)]
        [Display(Name = "Hire Date")]
        public DateTime HireDate { get; set; }

        [Display(Name = "Full Name")]
        public string FullName
        {
            get { return LastName + ", " + FirstMidName; }
        }

        public ICollection<Course> Courses { get; set; }
        public OfficeAssignment OfficeAssignment { get; set; }
    }
}

한 줄에 여러 특성이 있을 수 있습니다. HireDate 특성은 다음과 같이 작성될 수 있습니다.

[DataType(DataType.Date),Display(Name = "Hire Date"),DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}", ApplyFormatInEditMode = true)]

탐색 속성

Courses 및 OfficeAssignment 속성은 탐색 속성입니다.

강사는 여러 강좌를 가르칠 수 있으므로 Courses는 컬렉션으로 정의됩니다.

public ICollection<Course> Courses { get; set; }

강사는 최대 하나의 사무실을 가질 수 있으므로 OfficeAssignment 속성은 단일 OfficeAssignment 엔터티를 포함합니다. 사무실이 할당되지 않은 경우 OfficeAssignment는 Null입니다.

public OfficeAssignment OfficeAssignment { get; set; }

OfficeAssignment 엔터티

다음 코드로 Models/OfficeAssignment.cs를 만듭니다.

using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;

namespace ContosoUniversity.Models
{
    public class OfficeAssignment
    {
        [Key]
        public int InstructorID { get; set; }
        [StringLength(50)]
        [Display(Name = "Office Location")]
        public string Location { get; set; }

        public Instructor Instructor { get; set; }
    }
}

키 특성

[Key] 특성은 속성 이름이 classnameID또는 ID가 아닌 다른 것일 때 PK(기본 키)로 속성을 식별하는 데 사용됩니다.

Instructor 및 OfficeAssignment 엔터티 사이에는 일대영 또는 일 관계가 있습니다. 사무실 할당은 할당된 강사와 관련하여 존재합니다. OfficeAssignment PK는 Instructor 엔터티에 대한 해당 FK(외래 키)이기도 합니다. 일대영/일 관계는 한 테이블의 PK가 PK이자 다른 테이블의 FK인 경우에 발생합니다.

InstructorID는 ID 또는 classnameID 명명 규칙을 따르지 않으므로 EF Core는 InstructorID를 OfficeAssignment의 PK로 자동으로 인식할 수 없습니다. 따라서 Key 특성은 PK로 InstructorID를 식별하는 데 사용됩니다.

[Key]
public int InstructorID { get; set; }

기본적으로 EF Core는 열이 관계 확인을 위한 것이기 때문에 키를 데이터베이스에서 생성되지 않은 것으로 처리합니다. 자세한 내용은 EF Keys를 참조하세요.

강사 탐색 속성

지정된 강사에 대한 OfficeAssignment 행이 없을 수 있으므로 Instructor.OfficeAssignment 탐색 속성은 Null일 수 있습니다. 강사는 사무실 할당이 없을 수 있습니다.

외래 키 InstructorID 형식이 비 nullable 값 형식인 int이므로 OfficeAssignment.Instructor 탐색 속성은 항상 강사 엔터티를 포함합니다. 사무실 할당은 강사 없이 존재할 수 없습니다.

Instructor 엔터티에 관련된 OfficeAssignment 엔터티가 있는 경우 각 엔터티는 해당 탐색 속성의 다른 엔터티에 대한 참조를 갖습니다.

Course 엔터티

다음 코드를 사용하여 Models/Course.cs을 업데이트합니다.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;

namespace ContosoUniversity.Models
{
    public class Course
    {
        [DatabaseGenerated(DatabaseGeneratedOption.None)]
        [Display(Name = "Number")]
        public int CourseID { get; set; }

        [StringLength(50, MinimumLength = 3)]
        public string Title { get; set; }

        [Range(0, 5)]
        public int Credits { get; set; }

        public int DepartmentID { get; set; }

        public Department Department { get; set; }
        public ICollection<Enrollment> Enrollments { get; set; }
        public ICollection<Instructor> Instructors { get; set; }
    }
}

Course 엔터티에는 FK(외래 키) 속성 DepartmentID가 있습니다. DepartmentID는 관련된 Department 엔터티를 가리킵니다. Course 엔터티에는 Department 탐색 속성이 있습니다.

모델에 관련된 엔터티에 대한 탐색 속성이 있는 경우 EF Core는 데이터 모델에 대한 외래 키 속성이 필요하지 않습니다. EF Core는 필요한 어디든지 데이터베이스에 FK를 자동으로 만듭니다. EF Core는 자동으로 만들어진 FK에 대한 섀도 속성을 만듭니다. 그러나 데이터 모델에 FK를 명시적으로 포함하면 더 간단하고 더 효율적으로 업데이트를 수행할 수 있습니다. 예를 들어 FK 키 속성 DepartmentID가 포함되지 않은 모델을 가정합니다. 과정 엔터티가 편집을 위해 페치되는 경우:

• Department 속성은 명시적으로 로드되지 않은 경우 null입니다.
• 과정 엔터티를 업데이트하려면 Department 엔터티를 먼저 페치해야 합니다.

FK 속성 DepartmentID가 데이터 모델에 포함된 경우 업데이트하기 전에 Department 엔터티를 페치할 필요가 없습니다.

DatabaseGenerated 특성

[DatabaseGenerated(DatabaseGeneratedOption.None)] 특성은 PK가 데이터베이스에서 생성되지 않고 애플리케이션에서 제공되는 것을 지정합니다.

[DatabaseGenerated(DatabaseGeneratedOption.None)]
[Display(Name = "Number")]
public int CourseID { get; set; }

기본적으로 EF Core는 PK 값이 데이터베이스에서 생성되었다고 가정합니다. 일반적으로 데이터베이스에서 생성된 PK 값을 사용하는 것이 가장 좋습니다. Course 엔터티의 경우 사용자는 PK를 지정합니다. 예를 들어 수학 부서에 대한 1000 시리즈, 영어 부서에 대한 2000 시리즈와 같은 강좌 번호입니다.

DatabaseGenerated 특성은 기본 값을 생성하는 데 사용될 수도 있습니다. 예를 들어 데이터베이스는 행이 만들어지거나 업데이트된 날짜를 기록하기 위해 날짜 필드를 자동으로 생성할 수 있습니다. 자세한 내용은 생성된 속성을 참조하세요.

외래 키 및 탐색 속성

Course 엔터티의 FK(외래 키) 속성 및 탐색 속성은 다음과 같은 관계를 반영합니다.

강좌는 하나의 부서에 할당되었으므로 DepartmentID FK 및 Department 탐색 속성이 있습니다.

public int DepartmentID { get; set; }
public Department Department { get; set; }

강좌에는 등록된 학생이 여러 명 있을 수 있으므로 Enrollments 탐색 속성은 컬렉션입니다.

public ICollection<Enrollment> Enrollments { get; set; }

여러 강사가 한 강좌를 수업할 수 있으므로 Instructors 탐색 속성은 컬렉션입니다.

public ICollection<Instructor> Instructors { get; set; }

Department 엔터티

다음 코드로 Models/Department.cs를 만듭니다.

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;

namespace ContosoUniversity.Models
{
    public class Department
    {
        public int DepartmentID { get; set; }

        [StringLength(50, MinimumLength = 3)]
        public string Name { get; set; }

        [DataType(DataType.Currency)]
        [Column(TypeName = "money")]
        public decimal Budget { get; set; }

        [DataType(DataType.Date)]
        [DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}",
                       ApplyFormatInEditMode = true)]
        [Display(Name = "Start Date")]
        public DateTime StartDate { get; set; }

        public int? InstructorID { get; set; }

        public Instructor Administrator { get; set; }
        public ICollection<Course> Courses { get; set; }
    }
}

열 특성

이전에 Column 특성은 열 이름 매핑을 변경하는 데 사용되었습니다. Department 엔터티에 대한 코드에서 Column 특성은 SQL 데이터 형식 매핑을 변경하는 데 사용됩니다. Budget 열은 데이터베이스에서 SQL Server money 형식을 사용하여 정의됩니다.

[Column(TypeName="money")]
public decimal Budget { get; set; }

열 매핑은 일반적으로 필요하지 않습니다. EF Core는 속성에 대한 CLR 형식에 따라 적절한 SQL Server 데이터 형식을 선택합니다. CLR decimal 형식은 SQL Server decimal 유형에 매핑됩니다. Budget은 통화에 대한 것이고 money 데이터 형식은 통화에 더욱 적합합니다.

외래 키 및 탐색 속성

FK 및 탐색 속성은 다음과 같은 관계를 반영합니다.

• 부서는 관리자를 갖거나 갖지 않을 수 있습니다.
• 관리자는 항상 강사입니다. 따라서 InstructorID 속성은 Instructor 엔터티에 FK로 포함됩니다.

탐색 속성이 Administrator로 명명되나, Instructor 엔터티를 포함합니다.

public int? InstructorID { get; set; }
public Instructor Administrator { get; set; }

위의 코드에서 ?는 속성이 null 허용임을 지정합니다.

부서에는 강좌가 많이 있을 수 있으므로 강좌 탐색 속성이 있습니다.

public ICollection<Course> Courses { get; set; }

규칙에 따라 EF Core는 Null을 허용하지 않는 FK 및 다대다 관계에 대한 계단식 삭제를 활성화합니다. 이 기본 동작으로 인해 순환 계단식 삭제 규칙이 발생할 수 있습니다. 순환 계단식 삭제 규칙은 마이그레이션이 추가될 때 예외를 발생시킵니다.

예를 들어 Department.InstructorID 속성이 비 nullable로 정의된 경우 EF Core는 계단식 삭제 규칙을 구성합니다. 이 경우 관리자로 할당된 강사가 삭제되면 부서가 삭제됩니다. 이 시나리오에서는 제한 규칙을 사용하는 것이 좋습니다. 다음 흐름 API는 제한 규칙을 설정하고 계단식 삭제를 사용하지 않도록 설정합니다.

modelBuilder.Entity<Department>()
   .HasOne(d => d.Administrator)
   .WithMany()
   .OnDelete(DeleteBehavior.Restrict)

등록 외래 키 및 탐색 속성

등록 레코드는 한 명의 학생이 수행하는 하나의 강좌에 대한 것입니다.

다음 코드를 사용하여 Models/Enrollment.cs을 업데이트합니다.

using System.ComponentModel.DataAnnotations;

namespace ContosoUniversity.Models
{
    public enum Grade
    {
        A, B, C, D, F
    }

    public class Enrollment
    {
        public int EnrollmentID { get; set; }
        public int CourseID { get; set; }
        public int StudentID { get; set; }
        [DisplayFormat(NullDisplayText = "No grade")]
        public Grade? Grade { get; set; }

        public Course Course { get; set; }
        public Student Student { get; set; }
    }
}

FK 속성 및 탐색 속성은 다음 관계를 반영합니다.

등록 레코드는 하나의 강좌에 해당하므로 CourseID FK 속성 및 Course 탐색 속성이 있습니다.

public int CourseID { get; set; }
public Course Course { get; set; }

등록 레코드는 한 명의 학생에 해당하므로 StudentID FK 속성 및 Student 탐색 속성이 있습니다.

public int StudentID { get; set; }
public Student Student { get; set; }

다대다 관계

Student 및 Course 엔터티 사이에 다대다 관계가 있습니다. Enrollment 엔터티는 데이터베이스에서 페이로드를 사용하여 다대다 조인 테이블로 작동합니다. 페이로드를 사용한다는 것은 Enrollment 테이블이 조인된 테이블에 대한 FK 외에도 추가 데이터를 포함하는 것을 의미합니다. Enrollment 엔터티에서 FK 외의 추가 데이터는 PK 및 Grade입니다.

다음 그림은 이러한 관계 모양을 엔터티 다이어그램으로 보여 줍니다. (이 다이어그램은 EF 6.x에 대한 EF 파워 도구를 사용하여 생성되었습니다. 다이어그램 만들기는 자습서 내용에 해당하지 않습니다.)

각 관계 줄에는 한쪽 끝에 1, 다른 한쪽 끝에는 별표(*)가 있으며, 이는 일대다 관계를 나타냅니다.

Enrollment 테이블에 등급 정보가 포함되지 않은 경우 두 개의 FK(CourseID 및 StudentID)를 포함해야 합니다. 페이로드가 없는 다대다 조인 테이블은 PJT(순수 조인 테이블)라고도 합니다.

Instructor 및 Course 엔터티에는 PJT를 사용하는 다대다 관계가 있습니다.

데이터베이스 컨텍스트 업데이트

다음 코드를 사용하여 Data/SchoolContext.cs을 업데이트합니다.

using ContosoUniversity.Models;
using Microsoft.EntityFrameworkCore;

namespace ContosoUniversity.Data
{
    public class SchoolContext : DbContext
    {
        public SchoolContext(DbContextOptions<SchoolContext> options) : base(options)
        {
        }

        public DbSet<Course> Courses { get; set; }
        public DbSet<Enrollment> Enrollments { get; set; }
        public DbSet<Student> Students { get; set; }
        public DbSet<Department> Departments { get; set; }
        public DbSet<Instructor> Instructors { get; set; }
        public DbSet<OfficeAssignment> OfficeAssignments { get; set; }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Course>().ToTable(nameof(Course))
                .HasMany(c => c.Instructors)
                .WithMany(i => i.Courses);
            modelBuilder.Entity<Student>().ToTable(nameof(Student));
            modelBuilder.Entity<Instructor>().ToTable(nameof(Instructor));
        }
    }
}

위의 코드는 새 엔터티를 추가하고 Instructor 및 Course 엔터티 간의 다대다 관계를 구성합니다.

특성에 대한 흐름 API 대안

이전 코드의 메서드는 OnModelCreating 흐름 API를 사용하여 동작을 구성 EF Core 합니다. API는 종종 일련의 메서드 호출을 단일 명령문으로 함께 연결하여 사용되기 때문에 “흐름”이라고 부릅니다. 다음 코드는 흐름 API의 예제입니다.

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .Property(b => b.Url)
        .IsRequired();
}

이 자습서에서 흐름 API는 특성으로 수행될 수 없는 데이터베이스 매핑을 위해서만 사용됩니다. 그러나 흐름 API는 특성으로 수행될 수 있는 대부분의 서식 지정, 유효성 검사 및 매핑 규칙을 지정할 수 있습니다.

MinimumLength와 같은 일부 특성은 흐름 API를 통해 적용할 수 없습니다. MinimumLength는 스키마를 변경하지 않으며 최소 길이 유효성 검사 규칙만 적용합니다.

일부 개발자는 자신의 엔터티 클래스를 정리할 수 있기 때문에 흐름 API를 단독으로 사용하는 것을 선호합니다. 특성 및 흐름 API를 함께 사용할 수 있습니다. 복합 PK 지정과 같이 흐름 API로만 수행될 수 있는 일부 구성이 있습니다. 특성으로만 수행될 수 있는 일부 구성이 있습니다(MinimumLength). 흐름 API 또는 특성을 사용하기 위한 권장 방법:

• 이 두 가지 방법 중 하나를 선택합니다.
• 가능한 한 계속 선택한 방법을 사용합니다.

이 자습서에서 사용되는 일부 특성은 다음에 사용됩니다.

• 유효성 검사에만(예: MinimumLength)
• EF Core 구성에만(예: HasKey)
• 유효성 검사 및 EF Core 구성(예: [StringLength(50)])

특성 대 흐름 API의 비교에 관한 자세한 내용은 구성 메서드를 참조하세요.

데이터베이스 시드

Data/DbInitializer.cs의 코드를 업데이트합니다.

using ContosoUniversity.Models;
using System;
using System.Collections.Generic;
using System.Linq;

namespace ContosoUniversity.Data
{
    public static class DbInitializer
    {
        public static void Initialize(SchoolContext context)
        {
            // Look for any students.
            if (context.Students.Any())
            {
                return;   // DB has been seeded
            }

            var alexander = new Student
            {
                FirstMidName = "Carson",
                LastName = "Alexander",
                EnrollmentDate = DateTime.Parse("2016-09-01")
            };

            var alonso = new Student
            {
                FirstMidName = "Meredith",
                LastName = "Alonso",
                EnrollmentDate = DateTime.Parse("2018-09-01")
            };

            var anand = new Student
            {
                FirstMidName = "Arturo",
                LastName = "Anand",
                EnrollmentDate = DateTime.Parse("2019-09-01")
            };

            var barzdukas = new Student
            {
                FirstMidName = "Gytis",
                LastName = "Barzdukas",
                EnrollmentDate = DateTime.Parse("2018-09-01")
            };

            var li = new Student
            {
                FirstMidName = "Yan",
                LastName = "Li",
                EnrollmentDate = DateTime.Parse("2018-09-01")
            };

            var justice = new Student
            {
                FirstMidName = "Peggy",
                LastName = "Justice",
                EnrollmentDate = DateTime.Parse("2017-09-01")
            };

            var norman = new Student
            {
                FirstMidName = "Laura",
                LastName = "Norman",
                EnrollmentDate = DateTime.Parse("2019-09-01")
            };

            var olivetto = new Student
            {
                FirstMidName = "Nino",
                LastName = "Olivetto",
                EnrollmentDate = DateTime.Parse("2011-09-01")
            };

            var students = new Student[]
            {
                alexander,
                alonso,
                anand,
                barzdukas,
                li,
                justice,
                norman,
                olivetto
            };

            context.AddRange(students);

            var abercrombie = new Instructor
            {
                FirstMidName = "Kim",
                LastName = "Abercrombie",
                HireDate = DateTime.Parse("1995-03-11")
            };

            var fakhouri = new Instructor
            {
                FirstMidName = "Fadi",
                LastName = "Fakhouri",
                HireDate = DateTime.Parse("2002-07-06")
            };

            var harui = new Instructor
            {
                FirstMidName = "Roger",
                LastName = "Harui",
                HireDate = DateTime.Parse("1998-07-01")
            };

            var kapoor = new Instructor
            {
                FirstMidName = "Candace",
                LastName = "Kapoor",
                HireDate = DateTime.Parse("2001-01-15")
            };

            var zheng = new Instructor
            {
                FirstMidName = "Roger",
                LastName = "Zheng",
                HireDate = DateTime.Parse("2004-02-12")
            };

            var instructors = new Instructor[]
            {
                abercrombie,
                fakhouri,
                harui,
                kapoor,
                zheng
            };

            context.AddRange(instructors);

            var officeAssignments = new OfficeAssignment[]
            {
                new OfficeAssignment {
                    Instructor = fakhouri,
                    Location = "Smith 17" },
                new OfficeAssignment {
                    Instructor = harui,
                    Location = "Gowan 27" },
                new OfficeAssignment {
                    Instructor = kapoor,
                    Location = "Thompson 304" }
            };

            context.AddRange(officeAssignments);

            var english = new Department
            {
                Name = "English",
                Budget = 350000,
                StartDate = DateTime.Parse("2007-09-01"),
                Administrator = abercrombie
            };

            var mathematics = new Department
            {
                Name = "Mathematics",
                Budget = 100000,
                StartDate = DateTime.Parse("2007-09-01"),
                Administrator = fakhouri
            };

            var engineering = new Department
            {
                Name = "Engineering",
                Budget = 350000,
                StartDate = DateTime.Parse("2007-09-01"),
                Administrator = harui
            };

            var economics = new Department
            {
                Name = "Economics",
                Budget = 100000,
                StartDate = DateTime.Parse("2007-09-01"),
                Administrator = kapoor
            };

            var departments = new Department[]
            {
                english,
                mathematics,
                engineering,
                economics
            };

            context.AddRange(departments);

            var chemistry = new Course
            {
                CourseID = 1050,
                Title = "Chemistry",
                Credits = 3,
                Department = engineering,
                Instructors = new List<Instructor> { kapoor, harui }
            };

            var microeconomics = new Course
            {
                CourseID = 4022,
                Title = "Microeconomics",
                Credits = 3,
                Department = economics,
                Instructors = new List<Instructor> { zheng }
            };

            var macroeconmics = new Course
            {
                CourseID = 4041,
                Title = "Macroeconomics",
                Credits = 3,
                Department = economics,
                Instructors = new List<Instructor> { zheng }
            };

            var calculus = new Course
            {
                CourseID = 1045,
                Title = "Calculus",
                Credits = 4,
                Department = mathematics,
                Instructors = new List<Instructor> { fakhouri }
            };

            var trigonometry = new Course
            {
                CourseID = 3141,
                Title = "Trigonometry",
                Credits = 4,
                Department = mathematics,
                Instructors = new List<Instructor> { harui }
            };

            var composition = new Course
            {
                CourseID = 2021,
                Title = "Composition",
                Credits = 3,
                Department = english,
                Instructors = new List<Instructor> { abercrombie }
            };

            var literature = new Course
            {
                CourseID = 2042,
                Title = "Literature",
                Credits = 4,
                Department = english,
                Instructors = new List<Instructor> { abercrombie }
            };

            var courses = new Course[]
            {
                chemistry,
                microeconomics,
                macroeconmics,
                calculus,
                trigonometry,
                composition,
                literature
            };

            context.AddRange(courses);

            var enrollments = new Enrollment[]
            {
                new Enrollment {
                    Student = alexander,
                    Course = chemistry,
                    Grade = Grade.A
                },
                new Enrollment {
                    Student = alexander,
                    Course = microeconomics,
                    Grade = Grade.C
                },
                new Enrollment {
                    Student = alexander,
                    Course = macroeconmics,
                    Grade = Grade.B
                },
                new Enrollment {
                    Student = alonso,
                    Course = calculus,
                    Grade = Grade.B
                },
                new Enrollment {
                    Student = alonso,
                    Course = trigonometry,
                    Grade = Grade.B
                },
                new Enrollment {
                    Student = alonso,
                    Course = composition,
                    Grade = Grade.B
                },
                new Enrollment {
                    Student = anand,
                    Course = chemistry
                },
                new Enrollment {
                    Student = anand,
                    Course = microeconomics,
                    Grade = Grade.B
                },
                new Enrollment {
                    Student = barzdukas,
                    Course = chemistry,
                    Grade = Grade.B
                },
                new Enrollment {
                    Student = li,
                    Course = composition,
                    Grade = Grade.B
                },
                new Enrollment {
                    Student = justice,
                    Course = literature,
                    Grade = Grade.B
                }
            };

            context.AddRange(enrollments);
            context.SaveChanges();
        }
    }
}

위의 코드는 새 엔터티에 대한 시드 데이터를 제공합니다. 이 코드의 대부분은 새 엔터티 개체를 만들고 샘플 데이터를 로드합니다. 샘플 데이터는 테스트를 위해 사용됩니다.

마이그레이션 적용 또는 삭제하고 다시 만들기

기존 데이터베이스를 사용하는 경우 데이터베이스를 변경하는 두 가지 방법이 있습니다.

• 데이터베이스를 삭제하고 다시 만들기. SQLite를 사용하는 경우 이 섹션을 선택합니다.
• 기존 데이터베이스에 마이그레이션 적용. 이 섹션의 지침은 SQL Server에만 적용되며 SQLite에는 적용되지 않습니다.

두 방법 모두 SQL Server에서 사용할 수 있습니다. 마이그레이션 적용 방법은 더 복잡하고 시간이 오래 걸리지만 실제 프로덕션 환경에 권장되는 방법입니다.

데이터베이스를 삭제하고 다시 만들기

EF Core가 새로운 데이터베이스를 만들도록 강제하려면 데이터베이스를 삭제하고 업데이트합니다.

Visual Studio

• Migrations 폴더를 삭제합니다.
• PMC(패키지 관리자 콘솔)에서 다음 명령을 수행합니다.

Drop-Database
Add-Migration InitialCreate
Update-Database

Visual Studio Code

• 명령 창을 열고 프로젝트 폴더로 이동합니다. 프로젝트 폴더에 파일이 포함되어 있습니다 ContosoUniversity.csproj .
• Migrations 폴더를 삭제합니다.
• 다음 명령을 실행합니다.

dotnet ef database drop --force
dotnet ef migrations add InitialCreate
dotnet ef database update

앱을 실행합니다. 앱을 실행하면 DbInitializer.Initialize 메서드를 실행합니다. DbInitializer.Initialize는 새 데이터베이스를 채웁니다.

Visual Studio

SSOX에서 데이터베이스를 선택합니다.

• SSOX가 이전에 열려 있던 경우 새로 고침 단추를 클릭합니다.
• 테이블 노드를 확장합니다. 생성된 테이블이 표시됩니다.

Visual Studio Code

SQLite 도구를 사용하여 데이터베이스를 검사합니다.

• 새 테이블 및 열.
• 표로 정리된 시드된 데이터.

다음 단계

다음 두 자습서에서는 관련 데이터를 읽고 업데이트하는 방법을 보여 줍니다.

이전 자습서다음 자습서