Teil 5: Razor-Seiten mit EF Core in ASP.NET Core – Datenmodell

Von Tom Dykstra, Jeremy Likness und Jon P. Smith

Die Web-App Contoso University veranschaulicht, wie Razor-Seiten-Web-Apps mit EF Core und Visual Studio erstellt werden können. Informationen zu den Tutorials finden Sie im ersten Tutorial.

Wenn Probleme auftreten, die Sie nicht beheben können, laden Sie die vollständige App herunter, und vergleichen Sie diesen Code mit dem Code, den Sie anhand des Tutorials erstellt haben.

In den vorherigen Tutorials wurde mit einem einfachen Datenmodell gearbeitet, das aus drei Entitäten bestand. In diesem Tutorial wird Folgendes durchgeführt:

• Weitere Entitäten und Beziehungen werden hinzugefügt.
• Das Datenmodell wird angepasst, indem Regeln zur Formatierung, Validierung und Datenbankzuordnung angegeben werden.

Das vollständige Datenmodell wird in der folgenden Abbildung dargestellt:

Das folgende Datenbankdiagramm wurde mit Dataedoerstellt:

So erstellen Sie ein Datenbankdiagramm mit Dataedo:

• Bereitstellen der Anwendung in Azure
• Laden Sie Dataedo herunter, und installieren Sie das Tool auf Ihrem Computer.
• Befolgen Sie die Anweisungen zum Generieren von Dokumentation für Azure SQL-Datenbank in 5 Minuten.

Im Dataedo-Diagramm oben ist CourseInstructor eine Jointabelle, die von Entity Framework erstellt wurde. Weitere Informationen finden Sie unter m:n-Beziehung.

Die Entität „Student“

Ersetzen Sie den Code in Models/Student.cs durch folgenden Code:

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; }
    }
}

Der Code oben fügt eine FullName-Eigenschaft hinzu und fügt den vorhandenen Eigenschaften die folgenden Attribute hinzu:

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

Die berechnete FullName-Eigenschaft

Bei FullName handelt es sich um eine berechnete Eigenschaft, die einen Wert zurückgibt, der durch das Verketten von zwei weiteren Eigenschaften erstellt wird. FullName kann nicht festgelegt werden und verfügt daher lediglich über einen get-Accessor. In der Datenbank wird keine FullName-Spalte erstellt.

Das DataType-Attribut

[DataType(DataType.Date)]

Für die Anmeldedaten von Studenten zeigen alle Webseiten derzeit die Zeit und das Datum an, obwohl nur das Datum relevant ist. Indem Sie Attribute für die Datenanmerkung verwenden, können Sie eine Codeänderungen vornehmen, durch die das Anzeigeformat auf jeder Seite korrigiert wird, in der die Daten angezeigt werden.

Das DataType-Attribut gibt einen Datentyp an, der spezifischer als der datenbankinterne Typ ist. In diesem Fall sollte nur das Datum angezeigt werden, nicht das Datum und die Uhrzeit. Die DataType-Enumeration stellt viele Datentypen bereit, wie z.B. „Date“, „Time“, „PhoneNumber“, „Currency“, „EmailAddress“. Das DataType-Attribut kann der App auch das Bereitstellen typspezifischer Features ermöglichen. Zum Beispiel:

• Der Link mailto: wird automatisch für DataType.EmailAddress erstellt.
• Die Datumsauswahl für DataType.Date wird in den meisten Browsern bereitgestellt.

Das DataType-Attribut gibt data--HTML5-Attribute (ausgesprochen „Datadash“) aus. Die DataType-Attribute bieten keine Validierung.

Das DisplayFormat-Attribut

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

DataType.Date gibt nicht das Format des Datums an, das angezeigt wird. Standardmäßig wird das Datumsfeld gemäß den Standardformaten basierend auf der CultureInfo-Klasse des Servers angezeigt.

Das DisplayFormat-Attribut dient zum expliziten Angeben des Datumsformats. Die ApplyFormatInEditMode-Einstellung gibt an, dass die Formatierung ebenfalls auf die Benutzeroberfläche für die Bearbeitung angewendet wird. Einige Felder sollten ApplyFormatInEditMode nicht verwenden. Das Währungssymbol sollte beispielsweise nicht im Textfeld für die Bearbeitung angezeigt werden.

Das DisplayFormat-Attribut kann eigenständig verwendet werden. Meist empfiehlt es sich, das DataType-Attribut mit dem DisplayFormat-Attribut zu verwenden. Das DataType-Attribut übermittelt die Semantik der Daten im Gegensatz zu deren Rendern auf einem Bildschirm. Das DataType-Attribut bietet folgende Vorteile, die in DisplayFormat nicht verfügbar sind:

• Der Browser kann HTML5-Features aktivieren. Dazu zählen beispielsweise das Anzeigen eines Kalendersteuerelements, des dem Gebietsschema entsprechenden Währungssymbols, von E-Mail-Links und einigen clientseitigen Eingabevalidierungen.
• Standardmäßig rendert der Browser Daten mit dem auf Ihrem Gebietsschema basierenden richtigen Format.

Weitere Informationen finden Sie in der Dokumentation zum <input>-Taghilfsprogramm.

Das StringLength-Attribut

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

Die Regeln für die Datenvalidierung und Meldungen für Validierungsfehler können mithilfe von Attributen angegeben werden. Das StringLength-Attribut gibt den mindestens erforderlichen und maximal zulässigen Wert für die Zeichenlänge eines Datenfelds an. Der gezeigte Code beschränkt Namen auf maximal 50 Zeichen. Ein Beispiel, das die minimale Zeichenfolgenlänge festlegt, wird später gezeigt.

Das StringLength-Attribut stellt ebenfalls die clientseitige und serverseitige Validierung bereit. Der mindestens erforderliche Wert hat keine Auswirkungen auf das Datenbankschema.

Das StringLength-Attribut verhindert nicht, dass ein Benutzer einen Leerraum als Namen eingibt. Das Attribut RegularExpression kann verwendet werden, um Einschränkungen auf die Eingabe anzuwenden. Folgender Code erfordert beispielsweise, dass das erste Zeichen ein Großbuchstabe sein muss und die restlichen Zeichen alphabetisch sein müssen:

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

Visual Studio

Öffnen Sie im SQL Server-Objekt-Explorer (SSOX) den Tabellen-Designer „Student“, indem Sie auf die Tabelle Student doppelklicken.

In der vorangehenden Abbildung wird das Schema der Student-Tabelle dargestellt. Die Namensfelder weisen den Typ nvarchar(MAX) auf. Wenn eine Migration später in diesem Tutorial erstellt und angewendet wird, werden die Namensfelder nvarchar(50) als Ergebnis der Attribute für die Zeichenfolgenlänge.

Visual Studio Code

Überprüfen Sie mit einem SQLite-Tool die Spaltendefinitionen für die Student-Tabelle. Die Namensfelder weisen den Typ Text auf. Beachten Sie, dass das Feld für den Vornamen den Namen FirstMidName trägt. Im nächsten Abschnitt wird in FirstMidNameFirstName geändert.

Das Column-Attribut

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

Durch Attribute kann gesteuert werden, wie Ihre Klassen und Eigenschaften der Datenbank zugeordnet werden. Im Student-Modell wird das Column-Attribut verwendet, um den Namen der FirstMidName-Eigenschaft in der Datenbank auf „FirstName“ festzulegen.

Wenn die Datenbank erstellt wird, werden die Eigenschaftsnamen des Moduls für Spaltennamen verwendet (außer bei Verwendung des Column-Attributs). Das Student-Modell verwendet FirstMidName für das Feld „first-name“, da dieses ebenfalls einen Zweitnamen enthalten kann.

Mit dem [Column]-Attribut wird Student.FirstMidName im Datenmodell der Spalte FirstName in der Tabelle Student zugeordnet. Durch das Hinzufügen des Column-Attributs wird das Modell geändert, das SchoolContext unterstützt. Das Modell, das SchoolContext unterstützt, stimmt nicht mehr mit der Datenbank überein. Diese Diskrepanz wird durch Hinzufügen einer Migration zu einem späteren Zeitpunkt in diesem Tutorial aufgelöst.

Das Attribut „Required“

[Required]

Durch das Required-Attribut werden die Name-Eigenschaften zu Pflichtfeldern. Das Required-Attribut ist für Typen, die keine NULL-Werte annehmen können (etwas Werttypen, z.B. DateTime, int und double) nicht erforderlich. Typen, die nicht auf NULL festgelegt werden können, werden automatisch als Pflichtfelder behandelt.

Das Required-Attribut muss mit MinimumLength verwendet werden, damit die MinimumLength erzwungen wird.

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

MinimumLength und Required lassen Leerzeichen zu, um die Überprüfung zu bestehen. Verwenden Sie das RegularExpression-Attribut, um vollständige Kontrolle über die Zeichenfolge zu erhalten.

Das Display-Attribut

[Display(Name = "Last Name")]

Das Display-Attribut gibt an, dass die Beschriftung der Textfelder „First Name“ (Vorname), „Last Name“ (Nachname), „Full Name“ (Vollständiger Name) und „Enrollment Date“ (Registrierungsdatum) lauten soll. Die Standardbeschriftungen hatten kein Leerzeichen zwischen den Wörtern, wie zum Beispiel „Lastname“.

Erstellen einer Migration

Führen Sie die Anwendung aus. Wechseln Sie zur Studentenseite. Es wird eine Ausnahme ausgelöst. Das [Column]-Attribut bewirkt, dass EF eine Spalte mit dem Namen FirstName erwartet, aber der Spaltenname in der Datenbank ist weiterhin FirstMidName.

Visual Studio

Die Fehlermeldung lautet ungefähr wie im folgenden Beispiel:

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

SchoolContext

• Geben Sie in der PMC folgende Befehle ein, um eine neue Migration zu erstellen und die Datenbank zu aktualisieren:

  Add-Migration ColumnFirstName
  Update-Database
  
  

  Mit dem ersten dieser Befehle wird die folgende Warnmeldung generiert:

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

  Die Warnung wird generiert, weil die Namensfelder nun auf 50 Zeichen beschränkt sind. Wenn der Name der Datenbank aus mehr als 50 Zeichen besteht, gehen alle Zeichen ab dem 51. verloren.

• Öffnen Sie die Tabelle „Student“ im SSOX:

  

  Bevor die Migration angewendet wurde, wiesen die Namensspalten den Typ nvarchar(MAX) auf. Die Namensspalten weisen nun den Typ nvarchar(50) auf. Der Spaltenname wurde von FirstMidName in FirstName geändert.

Visual Studio Code

Die Fehlermeldung lautet ungefähr wie im folgenden Beispiel:

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

• Öffnen Sie ein Befehlsfenster im Projektordner. Geben Sie folgende Befehle ein, um eine neue Migration zu erstellen und die Datenbank zu aktualisieren:

  dotnet ef migrations add ColumnFirstName
  dotnet ef database update
  

• Überprüfen Sie die Tabelle „Student“ mit einem SQLite-Tool. Die Spalte, die FirstMidName war, ist jetzt FirstName.

• Führen Sie die Anwendung aus. Wechseln Sie zur Studentenseite.
• Beachten Sie, dass die Uhrzeiten nicht mit Datumsangaben eingegeben oder angezeigt werden.
• Klicken Sie auf Neu erstellen, und versuchen Sie, einen Namen einzugeben, der länger als 50 Zeichen ist.

Hinweis

In den folgenden Abschnitten werden beim Erstellen der App in einigen Phasen Compilerfehler generiert. Diese Anweisungen präzisieren, wann die App erstellt werden soll.

Die Instructor-Entität

Erstellen Sie Models/Instructor.cs mit dem folgenden Code:

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; }
    }
}

In einer Zeile können mehrere Attribute enthalten sein. Das HireDate-Attribut kann folgendermaßen geschrieben werden:

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

Navigationseigenschaften

Bei den Eigenschaften Courses und OfficeAssignment handelt es sich um Navigationseigenschaften.

Da ein Dozent eine beliebige Anzahl von Kursen geben kann, wird Courses als Auflistung definiert.

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

Ein Dozent kann höchstens ein Büro haben, sodass die OfficeAssignment-Eigenschaft eine einzelne OfficeAssignment-Entität enthält. OfficeAssignment ist NULL, wenn kein Büro zugewiesen ist.

public OfficeAssignment OfficeAssignment { get; set; }

Die Entität „OfficeAssignment“

Erstellen Sie Models/OfficeAssignment.cs mit dem folgenden Code:

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; }
    }
}

Das Key-Attribut

Das [Key]-Attribut wird verwendet, um eine Eigenschaft als Primärschlüssel zu identifizieren, wenn der Eigenschaftsname nicht classnameID oder ID entspricht.

Es besteht eine 1:0..1-Beziehung zwischen der Instructor- und der OfficeAssignment-Entität. Eine Bürozuweisung ist nur in Beziehung zu dem Dozenten vorhanden, dem sie zugewiesen ist. Der Primärschlüssel OfficeAssignment ist ebenfalls der Fremdschlüssel der Instructor-Entität. Eine 1:0..1-Beziehung liegt vor, wenn ein Primärschlüssel in einer Tabelle sowohl ein Primärschlüssel als auch ein Fremdschlüssel in einer anderen Tabelle ist.

EF Core kann InstructorID nicht automatisch als Primärschlüssel von OfficeAssignment erkennen, da InstructorID nicht den ID- oder classnameID-Benennungskonventionen folgt. Deshalb wird das Key-Attribut verwendet, um InstructorID als Primärschlüssel zu erkennen:

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

Standardmäßig behandelt EF Core den Schlüssel nicht als datenbankgeneriert, da die Spalte für eine identifizierende Beziehung vorgesehen ist. Weitere Informationen finden Sie unter EF-Schlüssel.

Die Navigationseigenschaft „Instructor“

Die Instructor.OfficeAssignment-Navigationseigenschaft kann NULL sein, da möglicherweise keine OfficeAssignment-Zeile für einen bestimmten Dozenten vorhanden ist. Einem Dozenten möglicherweise kein Büro zugewiesen ist.

Die OfficeAssignment.Instructor-Navigationseigenschaft hat immer eine Instructor-Entität, da der Typ InstructorID des Fremdschlüssels int ist, ein Typ, der keine NULL-Werte annehmen kann. Eine Bürozuweisung nicht ohne einen Dozenten vorhanden sein kann.

Wenn die Entität Instructor mit der Entität OfficeAssignment verknüpft ist, besitzt jede Entität in den Navigationseigenschaften einen Verweis auf die andere.

Die Entität „Course“

Aktualisieren Sie Models/Course.cs mit folgendem Code:

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; }
    }
}

Die Course-Entität besitzt die Fremdschlüsseleigenschaft DepartmentID. DepartmentID zeigt auf die verknüpfte Department-Entität. Die Course-Entität besitzt eine Department-Navigationseigenschaft.

EF Core erfordert keine Fremdschlüsseleigenschaft für ein Datenmodell, wenn das Modell über eine Navigationseigenschaft für eine verknüpfte Entität verfügt. EF Core erstellt an den erforderlichen Stellen automatisch Fremdschlüssel in der Datenbank. EF Core erstellt Schatteneigenschaften für automatisch erstellte Fremdschlüssel. Durch explizites Einschließen des Fremdschlüssels in das Datenmodell können Updates jedoch einfacher und effizienter durchgeführt werden. Betrachten Sie beispielsweise ein Modell, bei dem die Fremdschlüsseleigenschaft DepartmentIDnicht enthalten ist. Folgendes wird durchgeführt, wenn eine Course-Entität zum Bearbeiten abgerufen wird:

• Die Department-Eigenschaft ist null, wenn sie nicht explizit geladen wird.
• Die Department-Entität muss abgerufen werden, um die Course-Entität zu aktualisieren.

Wenn die Fremdschlüsseleigenschaft DepartmentID im Datenmodell enthalten ist, muss die Department-Entität vor einem Update nicht abgerufen werden.

Das Attribut „DatabaseGenerated“

Das [DatabaseGenerated(DatabaseGeneratedOption.None)]-Attribut gibt an, dass der Primärschlüssel von der Anwendung bereitgestellt wird, statt von der Datenbank generiert zu werden.

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

Standardmäßig geht EF Core davon aus, dass Primärschlüsselwerte von der Datenbank generiert werden. Bei von der Datenbank generierten Primärschlüsselwerten handelt es sich in der Regel um die beste Herangehensweise. Bei Course-Entitäten wird der Primärschlüssel vom Benutzer angegeben, z.B. eine Kursnummer wie eine 1000er-Reihe für den Fachbereich Mathematik, eine 2000er-Reihe für den Fachbereich Englisch usw.

Das DatabaseGenerated-Attribut kann ebenfalls zum Generieren von Standardwerten verwendet werden. Die Datenbank kann beispielsweise automatisch ein Datenfeld generieren, um das Datum aufzuzeichnen, an dem eine Zeile erstellt oder aktualisiert wurde. Weitere Informationen finden Sie unter Generated Properties (Generierte Eigenschaften).

Fremdschlüssel- und Navigationseigenschaften

Die Fremdschlüssel- und Navigationseigenschaften in der Entität Course stellen folgende Beziehungen dar:

Ein Kurs ist einem Fachbereich zugeordnet, es gibt also eine DepartmentID-Fremdschlüsseleigenschaft und eine Department-Navigationseigenschaft.

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

In einem Kurs können beliebig viele Studenten angemeldet sein, darum stellt die Enrollments-Navigationseigenschaft eine Auflistung dar:

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

Ein Kurs kann von mehreren Dozenten unterrichtet werden, darum stellt die Instructors-Navigationseigenschaft eine Auflistung dar:

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

Entität „Department“

Erstellen Sie Models/Department.cs mit dem folgenden Code:

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; }
    }
}

Das Column-Attribut

Zuvor wurde das Column-Attribut verwendet, um die Zuordnung des Spaltennamens zu ändern. Im Code für die Department-Entität wird das Column-Attribut verwendet, um die Zuordnung des SQL-Datentyps zu ändern. Die Budget-Spalte wird mithilfe des SQL Server-Typs „money“ in der Datenbank definiert:

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

Die Spaltenzuordnung ist im Allgemeinen nicht erforderlich. EF Core wählt den geeigneten SQL Server-Datentyp basierend auf dem CLR-Typ der Eigenschaft aus. Der CLR-Typ decimal wird dem SQL Server-Typ decimal zugeordnet. Bei Budget wird eine Währung verwendet, und der Datentyp „money“ ist für Währungen besser geeignet.

Fremdschlüssel- und Navigationseigenschaften

Die Fremdschlüssel- und Navigationseigenschaften stellen folgende Beziehungen dar:

• Ein Fachbereich kann einen Administrator besitzen oder nicht.
• Bei einem Administrator handelt es sich immer um einen Dozenten. Aus diesem Grund wird die InstructorID-Eigenschaft als Fremdschlüssel zur Instructor-Entität hinzugefügt.

Die Navigationseigenschaft heißt Administrator, enthält jedoch eine Instructor-Entität:

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

Das ? im Code oben gibt an, dass die Eigenschaft Nullwerte zulassend ist.

Eine Abteilung kann viele Kurse aufweisen, darum gibt es die Navigationseigenschaft „Courses“:

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

Gemäß der Konvention aktiviert EF Core das kaskadierende Delete für nicht auf NULL festlegbare Fremdschlüssel und für m:n-Beziehungen. Das Standardverhalten kann zu Zirkelregeln für kaskadierende Löschvorgänge führen. Durch Zirkelregeln für kaskadierende Löschvorgänge wird eine Ausnahme ausgelöst, wenn eine Migration hinzugefügt wird.

Wenn die Department.InstructorID-Eigenschaft beispielsweise als nicht auf NULL festlegbare Eigenschaft definiert wurde, konfiguriert EF Core eine Löschregel für kaskadierende Löschvorgänge. In diesem Fall würde der Fachbereich gelöscht, wenn der als Administrator zugewiesene Dozent gelöscht wird. In diesem Szenario wäre eine Einschränkungsregel sinnvoller. Die folgende Fluent-API würde eine Einschränkungsregel festlegen und das kaskadierende Delete deaktivieren.

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

Enrollment-Fremdschlüssel und -Navigationseigenschaften

Ein Enrollment-Datensatz gilt für einen Kurs, der von einem Studenten besucht wird.

Aktualisieren Sie Models/Enrollment.cs mit folgendem Code:

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; }
    }
}

Die Fremdschlüssel- und Navigationseigenschaften stellen folgende Beziehungen dar:

Ein Anmeldungsdatensatz gilt für einen einzelnen Kurs, sodass es eine CourseID-Fremdschlüsseleigenschaft und eine Course-Navigationseigenschaft gibt:

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

Ein Anmeldungsdatensatz gilt für einen einzelnen Studenten, sodass es eine StudentID-Fremdschlüsseleigenschaft und eine Student-Navigationseigenschaft gibt:

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

n:n-Beziehungen

Es besteht eine m:n-Beziehung zwischen der Student- und der Course-Entität. Die Enrollment-Entität fungiert in der Datenbank als m:n-Jointabelle mit Nutzdaten. Mit Nutzdaten bedeutet, dass die Enrollment-Tabelle außer den Fremdschlüsseln für die verknüpften Tabellen zusätzliche Daten enthält. In der Enrollment-Entität sind die zusätzlichen Daten neben Fremdschlüsseln der Primärschlüssel und Grade.

Die folgende Abbildung stellt dar, wie diese Beziehungen in einem Entitätsdiagramm aussehen. (Dieses Diagramm wurde mit EF Power Tools für EF 6.x erstellt. Die Erstellung des Diagramms ist nicht Teil des Tutorials.)

Jede Beziehung weist an einem Ende „1“ und am anderen Ende „*“ auf, wodurch eine 1:n-Beziehung dargestellt wird.

Wenn in der Tabelle Enrollment nicht die Information „Grade“ enthalten wäre, müsste diese nur die beiden Fremdschlüssel (CourseID und StudentID) enthalten. Eine m:n-Jointabelle ohne Nutzlast wird manchmal als „reine Jointabelle“ bezeichnet.

Zwischen den Entitäten Instructor und Course besteht eine m:n-Beziehung mithilfe einer PJT (reine Jointabelle).

Aktualisieren des Datenbankkontexts

Aktualisieren Sie Data/SchoolContext.cs mit folgendem Code:

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));
        }
    }
}

Der vorstehende Code fügt die neuen Entitäten hinzu und konfiguriert die M:N-Beziehung zwischen den Entitäten Instructor und Course.

Fluent-API-Alternativen für Attribute

Die OnModelCreating-Methode im vorangehenden Code verwendet die Fluent-API zum Konfigurieren des Verhaltens von EF Core. Die API wird als „Fluent“ bezeichnet, da sie häufig durch das Verketten mehrerer Methodenaufrufe zu einer einzigen Anweisung verwendet wird. Der folgende Code veranschaulicht die Fluent-API beispielhaft:

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

In diesem Tutorial wird die Fluent-API nur für die Datenbankzuordnung verwendet, die nicht mit Attributen erfolgen kann. Die Fluent-API kann jedoch den Großteil der Regeln für Formatierung, Validierung und Zuordnung angeben, die mithilfe von Attributen festgelegt werden können.

Manche Attribute, z.B. MinimumLength, können nicht mit der Fluent-API angewendet werden. Durch MinimumLength wird das Schema nicht geändert, sondern lediglich eine Validierungsregel für die mindestens erforderliche Länge angewendet.

Einige Entwickler bevorzugen die exklusive Verwendung der Fluent-API, um ihre Entitätsklassen sauber zu halten. Attribute und die Fluent-API können gemeinsam verwendet werden. Es gibt einige Konfigurationen, die nur mit der Fluent-API vorgenommen werden können (z. B. das Angeben eines zusammengesetzten Primärschlüssels). Es gibt einige Konfigurationen, die nur mit Attributen (MinimumLength) vorgenommen werden können. Folgende Vorgehensweise wird für die Verwendung der Fluent-API oder von Attributen empfohlen:

• Wählen Sie einen der beiden Ansätze aus.
• Verwenden Sie den ausgewählten Ansatz so konsistent wie möglich.

Einige der in diesem Tutorial verwendeten Attribute werden für Folgendes verwendet:

• Nur für die Validierung (z.B. MinimumLength)
• Nur für die Konfiguration von EF Core (z. B. HasKey)
• Für die Validierung und die Konfiguration von EF Core (z. B. [StringLength(50)])

Weitere Informationen zu Attributen und Fluent-API im Vergleich finden Sie unter Methods of configuration (Konfigurationsmethoden).

Ausführen eines Seedings für die Datenbank

Aktualisieren Sie den Code in 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();
        }
    }
}

Der vorangehende Code stellt Startwertdaten für die neuen Entitäten bereit. Durch diesen Code werden überwiegend neue Entitätsobjekte erstellt und Beispieldaten geladen. Die Beispieldaten werden für Tests verwendet.

Anwenden der Migration oder Löschen und erneutes Erstellen

Bei der vorhandenen Datenbank gibt es zwei Ansätze zum Ändern der Datenbank:

• Löschen und Neuerstellen der Datenbank. Wählen Sie diesen Abschnitt aus, wenn Sie SQLite verwenden.
• Anwenden der Migration auf die vorhandene Datenbank. Die Anleitungen in diesem Abschnitt funktionieren nur für SQL Server, nicht für SQLite.

Beide Optionen funktionieren für SQL Server. Obwohl die apply-migration-Methode komplexer und zeitaufwendiger ist, ist dies in der Praxis die bevorzugte Methode für Produktionsumgebungen.

Löschen und Neuerstellen der Datenbank

Löschen und aktualisieren Sie die Datenbank, um EF Core zum Erstellen einer neuen Datenbank zu zwingen:

Visual Studio

• Löschen Sie den Ordner Migrations.
• Führen Sie die folgenden Befehle in der Paket-Manager-Konsole (PMC) aus:

Drop-Database
Add-Migration InitialCreate
Update-Database

Visual Studio Code

• Öffnen Sie ein Befehlsfenster, und navigieren Sie zu dem Projektordner. Der Projektordner enthält die Datei ContosoUniversity.csproj.
• Löschen Sie den Ordner Migrations.
• Führen Sie die folgenden Befehle aus:

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

Führen Sie die App aus. Durch das Ausführen der App wird die DbInitializer.Initialize-Methode ausgeführt. Die DbInitializer.Initialize-Methode füllt die neue Datenbank mit Daten auf.

Visual Studio

Öffnen Sie die Datenbank in SSOX:

• Wenn der SSOX zuvor schon geöffnet war, klicken Sie auf die Schaltfläche Aktualisieren.
• Erweitern Sie den Knoten Tabellen. Die erstellten Tabellen werden angezeigt.

Visual Studio Code

Verwenden Sie ein SQLite-Tool, um die Datenbank zu untersuchen:

• Neue Tabellen und Spalten.
• Startwertdaten in Tabellen.

Nächste Schritte

In den nächsten beiden Tutorials wird gezeigt, wie verwandte Daten gelesen und aktualisiert werden.

Vorheriges TutorialNächstes Tutorial