Notitie
Voor toegang tot deze pagina is autorisatie vereist. U kunt proberen u aan te melden of de directory te wijzigen.
Voor toegang tot deze pagina is autorisatie vereist. U kunt proberen de mappen te wijzigen.
In de vorige zelfstudies hebt u gewerkt met een eenvoudig gegevensmodel dat bestaat uit drie entiteiten. In deze zelfstudie voegt u meer entiteiten en relaties toe en past u het gegevensmodel aan door opmaak-, validatie- en databasetoewijzingsregels op te geven.
Wanneer u klaar bent, vormen de entiteitsklassen het voltooide gegevensmodel dat wordt weergegeven in de volgende afbeelding:
In deze handleiding leert u:
- Het gegevensmodel aanpassen
- Wijzigingen aanbrengen in de entiteit Student
- Docententiteit maken
- Een OfficeAssignment-entiteit maken
- Cursusentiteit bewerken
- Entiteit Afdeling maken
- Inschrijvingsentiteit bewerken
- De databasecontext bijwerken
- Database seeden met testgegevens
- Een migratie toevoegen
- De verbindingsreeks wijzigen
- De database bijwerken
Prerequisites
Het gegevensmodel aanpassen
In deze sectie ziet u hoe u het gegevensmodel kunt aanpassen met behulp van kenmerken die opmaak-, validatie- en databasetoewijzingsregels opgeven. Vervolgens maakt u in verschillende van de volgende secties het volledige schoolgegevensmodel door kenmerken toe te voegen aan de klassen die u al hebt gemaakt en nieuwe klassen te maken voor de resterende entiteitstypen in het model.
Het kenmerk DataType
Voor inschrijvingsdatums van leerlingen/studenten geven alle webpagina's momenteel de tijd weer, samen met de datum, hoewel het enige wat u belangrijk vindt voor dit veld de datum is. Met behulp van kenmerken voor gegevensaantekening kunt u één codewijziging aanbrengen waarmee de weergave-indeling wordt hersteld in elke weergave waarin de gegevens worden weergegeven. Als u een voorbeeld wilt zien van hoe u dit doet, voegt u een kenmerk toe aan de EnrollmentDate eigenschap in de Student klasse.
Voeg in Models/Student.cs een using-instructie toe voor de naamruimte System.ComponentModel.DataAnnotations en voeg de kenmerken DataType en DisplayFormat toe aan de eigenschap EnrollmentDate, zoals in het volgende voorbeeld wordt getoond:
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
namespace ContosoUniversity.Models
{
public class Student
{
public int ID { get; set; }
public string LastName { get; set; }
public string FirstMidName { get; set; }
[DataType(DataType.Date)]
[DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}", ApplyFormatInEditMode = true)]
public DateTime EnrollmentDate { get; set; }
public ICollection<Enrollment> Enrollments { get; set; }
}
}
Het kenmerk DataType wordt gebruikt om een gegevenstype op te geven dat specifieker is dan het intrinsieke type database. In dit geval willen we alleen de datum bijhouden, niet de datum en tijd. De DataType opsomming biedt veel gegevenstypen, zoals Datum, Tijd, PhoneNumber, Valuta, EmailAddress en meer. Het DataType kenmerk kan de toepassing ook inschakelen om automatisch typespecifieke functies te bieden. Er kan bijvoorbeeld een mailto: koppeling worden gemaakt voor DataType.EmailAddress, en er kan een datumkiezer worden opgegeven in DataType.Date browsers die HTML5 ondersteunen. Het DataType attribuut genereert HTML 5 data--attributen (uitgesproken als data-dash) die HTML 5-browsers kunnen begrijpen. De DataType attributen bieden geen validatie.
DataType.Date specificeert niet het formaat van de datum die wordt weergegeven. Het gegevensveld wordt standaard weergegeven volgens de standaardindelingen op basis van cultureinfo van de server.
Het kenmerk DisplayFormat wordt gebruikt om expliciet de datumnotatie op te geven:
[DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}", ApplyFormatInEditMode = true)]
De ApplyFormatInEditMode instelling geeft aan dat de opmaak ook moet worden toegepast wanneer de waarde wordt weergegeven in een tekstvak voor bewerking. (Mogelijk wilt u dat niet voor sommige velden -- bijvoorbeeld voor valutawaarden wilt u mogelijk het valutasymbool niet in het tekstvak hebben bij het bewerken.)
U kunt het DisplayFormat kenmerk zelf gebruiken, maar het is over het algemeen ook een goed idee om het DataType kenmerk te gebruiken. Het DataType kenmerk brengt de semantiek van de gegevens over in plaats van hoe u deze op een scherm weergeeft en biedt de volgende voordelen die u niet krijgt met DisplayFormat:
De browser kan HTML5-functies inschakelen (bijvoorbeeld om een agendabesturingselement weer te geven, het valutasymbool dat geschikt is voor landinstellingen, e-mailkoppelingen, bepaalde invoervalidatie aan de clientzijde, enzovoort).
Standaard worden in de browser gegevens weergegeven met de juiste indeling op basis van uw landinstelling.
Zie de <documentatie over de taghelper input> voor meer informatie.
Voer de app uit, ga naar de pagina Studentenindex en u ziet dat tijden niet meer worden weergegeven voor de inschrijvingsdatums. Hetzelfde geldt voor elke weergave die gebruikmaakt van het studentmodel.
Het kenmerk StringLength
U kunt ook regels voor gegevensvalidatie en validatiefoutberichten opgeven met behulp van kenmerken. Het StringLength kenmerk stelt de maximale lengte in de database in en biedt validatie aan de clientzijde en serverzijde voor ASP.NET Core MVC. U kunt ook de minimale tekenreekslengte in dit kenmerk opgeven, maar de minimumwaarde heeft geen invloed op het databaseschema.
Stel dat u ervoor wilt zorgen dat gebruikers niet meer dan 50 tekens voor een naam invoeren. Als u deze beperking wilt toevoegen, voegt u kenmerken toe StringLength aan de LastName en FirstMidName eigenschappen, zoals wordt weergegeven in het volgende voorbeeld:
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
namespace ContosoUniversity.Models
{
public class Student
{
public int ID { get; set; }
[StringLength(50)]
public string LastName { get; set; }
[StringLength(50)]
public string FirstMidName { get; set; }
[DataType(DataType.Date)]
[DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}", ApplyFormatInEditMode = true)]
public DateTime EnrollmentDate { get; set; }
public ICollection<Enrollment> Enrollments { get; set; }
}
}
Het StringLength kenmerk voorkomt niet dat een gebruiker witruimte invoert in een naam. U kunt het RegularExpression kenmerk gebruiken om beperkingen toe te passen op de invoer. Voor de volgende code moet het eerste teken bijvoorbeeld hoofdletters en de resterende tekens alfabetisch zijn:
[RegularExpression(@"^[A-Z]+[a-zA-Z]*$")]
Het MaxLength kenmerk biedt functionaliteit die vergelijkbaar is met het StringLength kenmerk, maar biedt geen validatie aan de clientzijde.
Het databasemodel is nu gewijzigd op een manier die een wijziging in het databaseschema vereist. U gebruikt migraties om het schema bij te werken zonder gegevens te verliezen die u mogelijk hebt toegevoegd aan de database met behulp van de gebruikersinterface van de toepassing.
Sla uw wijzigingen op en bouw het project. Open vervolgens het opdrachtvenster in de projectmap en voer de volgende opdrachten in:
dotnet ef migrations add MaxLengthOnNames
dotnet ef database update
De migrations add opdracht waarschuwt dat gegevensverlies kan optreden, omdat de wijziging de maximale lengte korter maakt voor twee kolommen. Migrations maakt een bestand met de naam <timeStamp>_MaxLengthOnNames.cs. Dit bestand bevat code in de Up methode waarmee de database wordt bijgewerkt zodat deze overeenkomt met het huidige gegevensmodel. De database update opdracht heeft die code uitgevoerd.
De tijdstempel die aan de bestandsnaam van het migratiebestand voorafgaat, wordt door Entity Framework gebruikt om de migraties te ordenen. U kunt meerdere migraties maken voordat u de opdracht update-database uitvoert, waarna alle migraties worden toegepast in de volgorde waarin ze zijn gemaakt.
Voer de app uit, selecteer het tabblad Studenten, klik op Nieuw maken en probeer een van beide namen in te voeren die langer is dan 50 tekens. De toepassing moet voorkomen dat u dit doet.
Het kenmerk Kolom
U kunt ook kenmerken gebruiken om te bepalen hoe uw klassen en eigenschappen worden toegewezen aan de database. Stel dat u de naam voor het voornaamveld FirstMidName hebt gebruikt, omdat het veld mogelijk ook een middelste naam bevat. Maar u wilt dat de databasekolom een naam krijgt FirstName, omdat gebruikers die ad-hocquery's voor de database schrijven, gewend zijn aan die naam. Als u deze toewijzing wilt maken, kunt u het Column kenmerk gebruiken.
Het Column kenmerk geeft aan dat wanneer de database wordt gemaakt, de kolom van de Student tabel die aan de FirstMidName eigenschap wordt toegewezen, de naam FirstNamekrijgt. Met andere woorden, wanneer uw code naar Student.FirstMidName verwijst, zullen de gegevens afkomstig zijn van of bijgewerkt worden in de FirstName kolom van de Student tabel. Als u geen kolomnamen opgeeft, krijgen ze dezelfde naam als de eigenschapsnaam.
Voeg in het Student.cs bestand een using instructie toe voor System.ComponentModel.DataAnnotations.Schema en voeg het kolomnaamkenmerk toe aan de FirstMidName eigenschap, zoals wordt weergegeven in de volgende gemarkeerde 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; }
[StringLength(50)]
public string LastName { get; set; }
[StringLength(50)]
[Column("FirstName")]
public string FirstMidName { get; set; }
[DataType(DataType.Date)]
[DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}", ApplyFormatInEditMode = true)]
public DateTime EnrollmentDate { get; set; }
public ICollection<Enrollment> Enrollments { get; set; }
}
}
De toevoeging van het kenmerk Column wijzigt de onderliggende ondersteuning van het model voor SchoolContext, zodat deze niet overeenkomt met de database.
Sla uw wijzigingen op en bouw het project. Open vervolgens het opdrachtvenster in de projectmap en voer de volgende opdrachten in om een andere migratie te maken:
dotnet ef migrations add ColumnFirstName
dotnet ef database update
Open in SQL Server Objectverkenner de ontwerpweergave van de tabel Student door te dubbelklikken op de tabel Student.
Voordat u de eerste twee migraties hebt toegepast, waren de naamkolommen van het type nvarchar(MAX). Ze zijn nu nvarchar(50) en de kolomnaam is gewijzigd van FirstMidName naar FirstName.
Note
Als u probeert te compileren voordat u klaar bent met het maken van alle entiteitsklassen in de volgende secties, krijgt u mogelijk compilerfouten.
Wijzigingen in de entiteit Student
Vervang Models/Student.csde code die u eerder hebt toegevoegd door de volgende code. De wijzigingen zijn gemarkeerd.
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)]
[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; }
}
}
Het Vereiste kenmerk
Het Required kenmerk maakt de naamkenmerken verplichte velden. Het Required attribuut is niet nodig voor niet-nullbare typen, zoals waardetypen (DateTime, int, double, float, enzovoort). Typen die niet null kunnen zijn, worden automatisch behandeld als vereiste velden.
Het kenmerk Required moet samen met MinimumLength worden gebruikt om MinimumLength te handhaven.
[Display(Name = "Last Name")]
[Required]
[StringLength(50, MinimumLength=2)]
public string LastName { get; set; }
Het kenmerk Weergave
Het Display kenmerk geeft aan dat het bijschrift voor de tekstvakken 'Voornaam', 'Achternaam', 'Volledige naam' en 'Inschrijvingsdatum' moet zijn in plaats van de naam van de eigenschap in elk exemplaar (zonder spatie tussen de woorden).
De berekende eigenschap FullName
FullName is een berekende eigenschap die een waarde retourneert die wordt gemaakt door twee andere eigenschappen samen te voegen. Daarom heeft het alleen een get accessor en wordt er geen FullName kolom gegenereerd in de database.
Docententiteit maken
Maak Models/Instructor.cs, vervang de sjablooncode door de volgende 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<CourseAssignment> CourseAssignments { get; set; }
public OfficeAssignment OfficeAssignment { get; set; }
}
}
U ziet dat verschillende eigenschappen hetzelfde zijn in de entiteiten Student en Docent. In de zelfstudie Overerving implementeren verderop in deze reeks gaat u deze code herstructureren om de redundantie te elimineren.
U kunt meerdere kenmerken op één regel plaatsen, zodat u de HireDate kenmerken ook als volgt kunt schrijven:
[DataType(DataType.Date),Display(Name = "Hire Date"),DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}", ApplyFormatInEditMode = true)]
De navigatie-eigenschappen van CourseAssignments en OfficeAssignment
De CourseAssignments eigenschappen en OfficeAssignment eigenschappen zijn navigatie-eigenschappen.
Een docent kan een willekeurig aantal cursussen leren, dus CourseAssignments wordt gedefinieerd als een verzameling.
public ICollection<CourseAssignment> CourseAssignments { get; set; }
Als een navigatie-eigenschap meerdere entiteiten kan bevatten, moet het bijbehorende type een lijst zijn waarin vermeldingen kunnen worden toegevoegd, verwijderd en bijgewerkt. U kunt ICollection<T> opgeven of een type zoals List<T> of HashSet<T>. Als u opgeeft ICollection<T>, maakt EF standaard een HashSet<T> verzameling.
De reden waarom deze CourseAssignment entiteiten zijn, wordt hieronder uitgelegd in de sectie over veel-op-veel-relaties.
Contoso University-bedrijfsregels geven aan dat een docent maximaal één kantoor kan hebben, dus de OfficeAssignment eigenschap heeft één OfficeAssignment-entiteit (die null kan zijn als er geen kantoor is toegewezen).
public OfficeAssignment OfficeAssignment { get; set; }
Een OfficeAssignment-entiteit maken
Maak Models/OfficeAssignment.cs met de volgende 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; }
}
}
Het Sleutelkenmerk
Er is een een-op-nul-of-een-relatie tussen de Instructor en de OfficeAssignment entiteiten. Er bestaat alleen een kantoortoewijzing in relatie tot de docent waaraan deze is toegewezen; daarom is de primaire sleutel ook de vreemde sleutel voor de Instructor entiteit. Maar het Entity Framework kan InstructorID echter niet automatisch herkennen als de primaire sleutel van deze entiteit, omdat de naam niet voldoet aan de naamconventie ID of classnameID. Daarom wordt het Key kenmerk gebruikt om het te identificeren als de sleutel:
[Key]
public int InstructorID { get; set; }
U kunt het Key kenmerk ook gebruiken als de entiteit wel een eigen primaire sleutel heeft, maar u de eigenschap een andere naam wilt geven dan classnameID of id.
EF behandelt de sleutel standaard als niet door de database gegenereerd omdat de kolom voor een identificerende relatie is.
De navigatie-eigenschap Instructeur
De entiteit Docent heeft een nullbare navigatie-eigenschap OfficeAssignment (omdat een docent mogelijk geen OfficeAssignment heeft), en de entiteit OfficeAssignment heeft een niet-nullbare Instructor navigatie-eigenschap (omdat een OfficeAssignment niet kan bestaan zonder een docent — InstructorID is niet-nullbaar). Wanneer een entiteit Docent een gerelateerde OfficeAssignment-entiteit heeft, krijgt elke entiteit een verwijzing naar de andere entiteit in de navigatie-eigenschap.
U kunt een [Required] kenmerk op de eigenschap Docentnavigatie plaatsen om op te geven dat er een gerelateerde docent moet zijn, maar dat hoeft u niet te doen, omdat de InstructorID vreemde sleutel (die ook de sleutel voor deze tabel is) niet null is.
Cursusentiteit bewerken
Vervang Models/Course.csde code die u eerder hebt toegevoegd door de volgende code. De wijzigingen zijn gemarkeerd.
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<CourseAssignment> CourseAssignments { get; set; }
}
}
De cursusentiteit heeft een foreign key-eigenschap DepartmentID die verwijst naar de gerelateerde afdelingsentiteit en deze heeft een Department navigatie-eigenschap.
Het Entity Framework vereist niet dat u een vreemde-sleuteleigenschap aan uw gegevensmodel toevoegt wanneer u een navigatie-eigenschap voor een gerelateerde entiteit hebt. EF maakt automatisch externe sleutels in de database waar ze nodig zijn en maakt shadow properties voor deze sleutels. Maar als u de foreign key in het gegevensmodel hebt, kunnen updates eenvoudiger en efficiënter worden. Wanneer u bijvoorbeeld een Course entiteit ophaalt om te bewerken, is de Department entiteit null als u deze niet laadt, dus wanneer u de Course entiteit bijwerkt, moet u eerst de Department entiteit ophalen. Wanneer de foreign key-eigenschap DepartmentID is opgenomen in het gegevensmodel, hoeft u de Department-entiteit niet op te halen voordat u deze wijzigt.
Het kenmerk DatabaseGenerated
Het DatabaseGenerated kenmerk met de None parameter op de CourseID eigenschap geeft aan dat de primaire sleutelwaarden worden opgegeven door de gebruiker in plaats van gegenereerd door de database.
[DatabaseGenerated(DatabaseGeneratedOption.None)]
[Display(Name = "Number")]
public int CourseID { get; set; }
In Entity Framework wordt standaard ervan uitgegaan dat primaire-sleutelwaarden worden gegenereerd door de database. Dat is wat u in de meeste scenario's wilt. Voor Course entiteiten gebruikt u echter een door de gebruiker opgegeven cursusnummer, zoals een reeks van 1000 voor één afdeling, een reeks van 2000 voor een andere afdeling, enzovoort.
Het DatabaseGenerated kenmerk kan ook worden gebruikt om standaardwaarden te genereren, zoals in het geval van databasekolommen die worden gebruikt om de datum vast te leggen waarop een rij werd aangemaakt of bijgewerkt. Zie Gegenereerde eigenschappen voor meer informatie.
Eigenschappen van vreemde sleutel en navigatie-eigenschappen
De eigenschappen van vreemde sleutels en navigatie-eigenschappen in de Course-entiteit weerspiegelen de volgende relaties.
Een cursus wordt toegewezen aan één afdeling, dus er is een DepartmentID vreemde sleutel en een Department navigatie-eigenschap om bovengenoemde redenen.
public int DepartmentID { get; set; }
public Department Department { get; set; }
Een cursus kan een willekeurig aantal leerlingen/studenten hebben ingeschreven, zodat de Enrollments navigatie-eigenschap een verzameling is:
public ICollection<Enrollment> Enrollments { get; set; }
Een cursus kan door meerdere instructeurs worden gegeven, dus de CourseAssignments navigatie-eigenschap is een verzameling (het type CourseAssignment wordt later uitgelegd):
public ICollection<CourseAssignment> CourseAssignments { get; set; }
Entiteit Afdeling maken
Maak Models/Department.cs met de volgende 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; }
}
}
Het kenmerk Kolom
Eerder hebt u het Column kenmerk gebruikt om de kolomnaamtoewijzing te wijzigen. In de code voor de Department entiteit wordt het Column kenmerk gebruikt om de toewijzing van het SQL-gegevenstype te wijzigen, zodat de kolom wordt gedefinieerd met behulp van het SQL Server money type in de database:
[Column(TypeName="money")]
public decimal Budget { get; set; }
Kolomtoewijzing is over het algemeen niet vereist, omdat entity framework het juiste SQL Server gegevenstype kiest op basis van het CLR-type dat u voor de eigenschap definieert. Het CLR-type decimal wordt toegewezen aan een SQL Server-type decimal . Maar in dit geval weet u dat de kolom valutabedragen vasthoudt en dat het gegevenstype geld meer geschikt is.
Eigenschappen van vreemde sleutel en navigatie-eigenschappen
De vreemde sleutel en navigatie-eigenschappen weerspiegelen de volgende relaties:
Een afdeling heeft al dan niet een beheerder en een beheerder is altijd een instructeur. Daarom is de InstructorID eigenschap opgenomen als de vreemde sleutel voor de entiteit Docent en wordt er een vraagteken toegevoegd na de int typeaanduiding om de eigenschap als nullable te markeren. De navigatie-eigenschap heet Administrator, maar bevat een entiteit Docent:
public int? InstructorID { get; set; }
public Instructor Administrator { get; set; }
Een afdeling kan veel cursussen hebben, daarom is er een navigatie-eigenschap genaamd Cursussen.
public ICollection<Course> Courses { get; set; }
Note
Conventioneel maakt het Entity Framework cascadeverwijdering mogelijk voor niet-nullable vreemde sleutels en voor veel-op-veel-relaties. Dit kan leiden tot circulaire regels voor trapsgewijs verwijderen, wat een uitzondering veroorzaakt wanneer u een migratie probeert toe te voegen. Als u de Department.InstructorID eigenschap bijvoorbeeld niet hebt gedefinieerd als nullable, zou EF een trapsgewijze verwijderingsregel configureren om de afdeling te verwijderen wanneer u de docent verwijdert. Dit is niet wat u wilt doen. Als uw bedrijfsregels vereisen dat de InstructorID eigenschap niet nullable is, moet u de volgende Fluent API-instructie gebruiken om trapsgewijs verwijderen van de relatie uit te schakelen:
modelBuilder.Entity<Department>()
.HasOne(d => d.Administrator)
.WithMany()
.OnDelete(DeleteBehavior.Restrict)
Inschrijvingsentiteit bewerken
Vervang Models/Enrollment.csde code die u eerder hebt toegevoegd door de volgende code:
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
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; }
}
}
Eigenschappen van vreemde sleutel en navigatie-eigenschappen
De eigenschappen van externe sleutels en navigatie-eigenschappen weerspiegelen de volgende relaties.
Een inschrijvingsrecord is voor één cursus, dus er is een CourseID refererende sleuteleigenschap en een Course navigatie-eigenschap:
public int CourseID { get; set; }
public Course Course { get; set; }
Een inschrijvingsrecord is voor één student, dus er is een StudentID refererende sleuteleigenschap en een Student navigatie-eigenschap:
public int StudentID { get; set; }
public Student Student { get; set; }
Veel-op-veel relaties
Er is een veel-op-veel-relatie tussen de Student en Course entiteiten, en de Enrollment entiteit fungeert als een veel-op-veel join-tabel met payload in de database. 'Met payload' betekent dat de Enrollment tabel naast vreemde sleutels voor de gekoppelde tabellen aanvullende gegevens bevat (in dit geval een primaire sleutel en een Grade eigenschap).
In de volgende afbeelding ziet u hoe deze relaties eruitzien in een entiteitsdiagram. (Dit diagram is gegenereerd met behulp van de Entity Framework Power Tools voor EF 6.x; het maken van het diagram maakt geen deel uit van de zelfstudie, maar wordt hier gewoon gebruikt als illustratie.)
Elke relatielijn heeft een 1 aan het ene uiteinde en een sterretje (*) aan de andere, wat een een-op-veel-relatie aangeeft.
Als de Enrollment tabel geen cijferinformatie bevat, hoeft deze alleen de twee vreemde sleutels CourseID en StudentID te bevatten. In dat geval is het een veel-op-veel-join-tabel zonder payload (of een pure jointabel) in de database. De Instructor- en Course-entiteiten hebben dat soort veel-op-veel-relatie, en je volgende stap is het maken van een entiteitsklasse die fungeert als een jointabel zonder payload.
EF Core biedt ondersteuning voor impliciete jointabellen voor veel-op-veel-relaties, maar deze zelfstudie is niet bijgewerkt voor het gebruik van een impliciete jointabel. Zie Veel-op-veel-relaties, de Razor Pages-versie van deze zelfstudie die is bijgewerkt.
De entiteit CourseAssignment
Maak Models/CourseAssignment.cs met de volgende code:
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
namespace ContosoUniversity.Models
{
public class CourseAssignment
{
public int InstructorID { get; set; }
public int CourseID { get; set; }
public Instructor Instructor { get; set; }
public Course Course { get; set; }
}
}
Namen van koppelentiteiten
Er is een join-tabel vereist in de database voor de veel-op-veel-relatie tussen docenten en cursussen en moet worden vertegenwoordigd door een entiteitsset. Het is gebruikelijk om een join-entiteit EntityName1EntityName2een naam te geven, wat in dit geval zou zijn CourseInstructor. We raden u echter aan een naam te kiezen die de relatie beschrijft. Gegevensmodellen beginnen eenvoudig en groeien, met joins zonder payload die later vaak payloads krijgen. Als u begint met een beschrijvende entiteitsnaam, hoeft u de naam later niet meer te wijzigen. Idealiter heeft de join-entiteit een eigen natuurlijke naam (mogelijk één woord) in het bedrijfsdomein. Boeken en klanten kunnen bijvoorbeeld worden gekoppeld via beoordelingen. Voor deze relatie is CourseAssignment een betere keuze dan CourseInstructor.
Samengestelde sleutel
Omdat de vreemde sleutels niet nullable zijn en samen elke rij van de tabel uniek identificeren, is er geen afzonderlijke primaire sleutel nodig. De eigenschappen InstructorID en CourseID moeten functioneren als een samengestelde primaire sleutel. De enige manier om samengestelde primaire sleutels voor EF te identificeren, is door de Fluent-API te gebruiken (dit kan niet worden gedaan met behulp van kenmerken). In de volgende sectie ziet u hoe u de samengestelde primaire sleutel configureert.
De samengestelde sleutel zorgt ervoor dat hoewel u meerdere rijen voor één cursus en meerdere rijen voor één docent kunt hebben, u niet meerdere rijen voor dezelfde docent en cursus kunt hebben. De Enrollment join-entiteit definieert een eigen primaire sleutel, zodat duplicaten van dit type mogelijk zijn. Als u dergelijke duplicaten wilt voorkomen, kunt u een unieke index toevoegen aan de velden met refererende sleutels of Enrollment configureren met een primaire samengestelde sleutel die vergelijkbaar is met CourseAssignment. Zie Indexen voor meer informatie.
De databasecontext bijwerken
Voeg de volgende gemarkeerde code toe aan het Data/SchoolContext.cs bestand:
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; }
public DbSet<CourseAssignment> CourseAssignments { get; set; }
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.Entity<Course>().ToTable("Course");
modelBuilder.Entity<Enrollment>().ToTable("Enrollment");
modelBuilder.Entity<Student>().ToTable("Student");
modelBuilder.Entity<Department>().ToTable("Department");
modelBuilder.Entity<Instructor>().ToTable("Instructor");
modelBuilder.Entity<OfficeAssignment>().ToTable("OfficeAssignment");
modelBuilder.Entity<CourseAssignment>().ToTable("CourseAssignment");
modelBuilder.Entity<CourseAssignment>()
.HasKey(c => new { c.CourseID, c.InstructorID });
}
}
}
Met deze code worden de nieuwe entiteiten toegevoegd en wordt de samengestelde primaire sleutel van de CourseAssignment-entiteit geconfigureerd.
Over een fluent API-alternatief
De code in de OnModelCreating methode van de DbContext klasse maakt gebruik van de fluent-API om EF-gedrag te configureren. De API wordt 'fluent' genoemd, omdat deze vaak wordt gebruikt door een reeks methode-aanroepen samen te voegen in één instructie, zoals in dit voorbeeld uit de EF Core documentatie:
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.Entity<Blog>()
.Property(b => b.Url)
.IsRequired();
}
In deze zelfstudie gebruikt u de fluent-API alleen voor databasemappingen die u niet met kenmerken kunt doen. U kunt echter ook de fluent-API gebruiken om de meeste opmaak-, validatie- en toewijzingsregels op te geven die u kunt doen met behulp van kenmerken. Sommige kenmerken, zoals MinimumLength kunnen niet worden toegepast met de fluent-API. Zoals eerder vermeld, MinimumLength wijzigt het schema niet, maar past alleen een validatieregel aan de client- en serverzijde toe.
Sommige ontwikkelaars gebruiken de fluent API liever uitsluitend, zodat ze hun entiteitsklassen 'schoon' kunnen houden. U kunt kenmerken en fluent-API combineren als u wilt, en er zijn enkele aanpassingen die alleen kunnen worden uitgevoerd met behulp van fluent-API, maar in het algemeen is de aanbevolen procedure om een van deze twee benaderingen te kiezen en die consistent zoveel mogelijk te gebruiken. Als u beide wel gebruikt, moet u er rekening mee houden dat waar er een conflict is, Fluent API attributen overschrijft.
Zie Methoden voor configuratie voor meer informatie over kenmerken versus fluent API.
Entiteitsdiagram met relaties
In de volgende afbeelding ziet u het diagram dat de Entity Framework Power Tools maakt voor het voltooide schoolmodel.
Naast de een-op-veel-relatielijnen (1 tot *), ziet u hier de een-op-nul-of-een-relatielijn (1 tot 0..1) tussen de entiteiten Instructor en OfficeAssignment en de nul-of-een-op-veel-relatielijn (0..1 tot *) tussen de entiteiten Docent en Afdeling.
Database seeden met testgegevens
Vervang de code in het Data/DbInitializer.cs bestand door de volgende code om seed-gegevens op te geven voor de nieuwe entiteiten die u hebt gemaakt.
using System;
using System.Linq;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using ContosoUniversity.Models;
namespace ContosoUniversity.Data
{
public static class DbInitializer
{
public static void Initialize(SchoolContext context)
{
//context.Database.EnsureCreated();
// Look for any students.
if (context.Students.Any())
{
return; // DB has been seeded
}
var students = new Student[]
{
new Student { FirstMidName = "Carson", LastName = "Alexander",
EnrollmentDate = DateTime.Parse("2010-09-01") },
new Student { FirstMidName = "Meredith", LastName = "Alonso",
EnrollmentDate = DateTime.Parse("2012-09-01") },
new Student { FirstMidName = "Arturo", LastName = "Anand",
EnrollmentDate = DateTime.Parse("2013-09-01") },
new Student { FirstMidName = "Gytis", LastName = "Barzdukas",
EnrollmentDate = DateTime.Parse("2012-09-01") },
new Student { FirstMidName = "Yan", LastName = "Li",
EnrollmentDate = DateTime.Parse("2012-09-01") },
new Student { FirstMidName = "Peggy", LastName = "Justice",
EnrollmentDate = DateTime.Parse("2011-09-01") },
new Student { FirstMidName = "Laura", LastName = "Norman",
EnrollmentDate = DateTime.Parse("2013-09-01") },
new Student { FirstMidName = "Nino", LastName = "Olivetto",
EnrollmentDate = DateTime.Parse("2005-09-01") }
};
foreach (Student s in students)
{
context.Students.Add(s);
}
context.SaveChanges();
var instructors = new Instructor[]
{
new Instructor { FirstMidName = "Kim", LastName = "Abercrombie",
HireDate = DateTime.Parse("1995-03-11") },
new Instructor { FirstMidName = "Fadi", LastName = "Fakhouri",
HireDate = DateTime.Parse("2002-07-06") },
new Instructor { FirstMidName = "Roger", LastName = "Harui",
HireDate = DateTime.Parse("1998-07-01") },
new Instructor { FirstMidName = "Candace", LastName = "Kapoor",
HireDate = DateTime.Parse("2001-01-15") },
new Instructor { FirstMidName = "Roger", LastName = "Zheng",
HireDate = DateTime.Parse("2004-02-12") }
};
foreach (Instructor i in instructors)
{
context.Instructors.Add(i);
}
context.SaveChanges();
var departments = new Department[]
{
new Department { Name = "English", Budget = 350000,
StartDate = DateTime.Parse("2007-09-01"),
InstructorID = instructors.Single( i => i.LastName == "Abercrombie").ID },
new Department { Name = "Mathematics", Budget = 100000,
StartDate = DateTime.Parse("2007-09-01"),
InstructorID = instructors.Single( i => i.LastName == "Fakhouri").ID },
new Department { Name = "Engineering", Budget = 350000,
StartDate = DateTime.Parse("2007-09-01"),
InstructorID = instructors.Single( i => i.LastName == "Harui").ID },
new Department { Name = "Economics", Budget = 100000,
StartDate = DateTime.Parse("2007-09-01"),
InstructorID = instructors.Single( i => i.LastName == "Kapoor").ID }
};
foreach (Department d in departments)
{
context.Departments.Add(d);
}
context.SaveChanges();
var courses = new Course[]
{
new Course {CourseID = 1050, Title = "Chemistry", Credits = 3,
DepartmentID = departments.Single( s => s.Name == "Engineering").DepartmentID
},
new Course {CourseID = 4022, Title = "Microeconomics", Credits = 3,
DepartmentID = departments.Single( s => s.Name == "Economics").DepartmentID
},
new Course {CourseID = 4041, Title = "Macroeconomics", Credits = 3,
DepartmentID = departments.Single( s => s.Name == "Economics").DepartmentID
},
new Course {CourseID = 1045, Title = "Calculus", Credits = 4,
DepartmentID = departments.Single( s => s.Name == "Mathematics").DepartmentID
},
new Course {CourseID = 3141, Title = "Trigonometry", Credits = 4,
DepartmentID = departments.Single( s => s.Name == "Mathematics").DepartmentID
},
new Course {CourseID = 2021, Title = "Composition", Credits = 3,
DepartmentID = departments.Single( s => s.Name == "English").DepartmentID
},
new Course {CourseID = 2042, Title = "Literature", Credits = 4,
DepartmentID = departments.Single( s => s.Name == "English").DepartmentID
},
};
foreach (Course c in courses)
{
context.Courses.Add(c);
}
context.SaveChanges();
var officeAssignments = new OfficeAssignment[]
{
new OfficeAssignment {
InstructorID = instructors.Single( i => i.LastName == "Fakhouri").ID,
Location = "Smith 17" },
new OfficeAssignment {
InstructorID = instructors.Single( i => i.LastName == "Harui").ID,
Location = "Gowan 27" },
new OfficeAssignment {
InstructorID = instructors.Single( i => i.LastName == "Kapoor").ID,
Location = "Thompson 304" },
};
foreach (OfficeAssignment o in officeAssignments)
{
context.OfficeAssignments.Add(o);
}
context.SaveChanges();
var courseInstructors = new CourseAssignment[]
{
new CourseAssignment {
CourseID = courses.Single(c => c.Title == "Chemistry" ).CourseID,
InstructorID = instructors.Single(i => i.LastName == "Kapoor").ID
},
new CourseAssignment {
CourseID = courses.Single(c => c.Title == "Chemistry" ).CourseID,
InstructorID = instructors.Single(i => i.LastName == "Harui").ID
},
new CourseAssignment {
CourseID = courses.Single(c => c.Title == "Microeconomics" ).CourseID,
InstructorID = instructors.Single(i => i.LastName == "Zheng").ID
},
new CourseAssignment {
CourseID = courses.Single(c => c.Title == "Macroeconomics" ).CourseID,
InstructorID = instructors.Single(i => i.LastName == "Zheng").ID
},
new CourseAssignment {
CourseID = courses.Single(c => c.Title == "Calculus" ).CourseID,
InstructorID = instructors.Single(i => i.LastName == "Fakhouri").ID
},
new CourseAssignment {
CourseID = courses.Single(c => c.Title == "Trigonometry" ).CourseID,
InstructorID = instructors.Single(i => i.LastName == "Harui").ID
},
new CourseAssignment {
CourseID = courses.Single(c => c.Title == "Composition" ).CourseID,
InstructorID = instructors.Single(i => i.LastName == "Abercrombie").ID
},
new CourseAssignment {
CourseID = courses.Single(c => c.Title == "Literature" ).CourseID,
InstructorID = instructors.Single(i => i.LastName == "Abercrombie").ID
},
};
foreach (CourseAssignment ci in courseInstructors)
{
context.CourseAssignments.Add(ci);
}
context.SaveChanges();
var enrollments = new Enrollment[]
{
new Enrollment {
StudentID = students.Single(s => s.LastName == "Alexander").ID,
CourseID = courses.Single(c => c.Title == "Chemistry" ).CourseID,
Grade = Grade.A
},
new Enrollment {
StudentID = students.Single(s => s.LastName == "Alexander").ID,
CourseID = courses.Single(c => c.Title == "Microeconomics" ).CourseID,
Grade = Grade.C
},
new Enrollment {
StudentID = students.Single(s => s.LastName == "Alexander").ID,
CourseID = courses.Single(c => c.Title == "Macroeconomics" ).CourseID,
Grade = Grade.B
},
new Enrollment {
StudentID = students.Single(s => s.LastName == "Alonso").ID,
CourseID = courses.Single(c => c.Title == "Calculus" ).CourseID,
Grade = Grade.B
},
new Enrollment {
StudentID = students.Single(s => s.LastName == "Alonso").ID,
CourseID = courses.Single(c => c.Title == "Trigonometry" ).CourseID,
Grade = Grade.B
},
new Enrollment {
StudentID = students.Single(s => s.LastName == "Alonso").ID,
CourseID = courses.Single(c => c.Title == "Composition" ).CourseID,
Grade = Grade.B
},
new Enrollment {
StudentID = students.Single(s => s.LastName == "Anand").ID,
CourseID = courses.Single(c => c.Title == "Chemistry" ).CourseID
},
new Enrollment {
StudentID = students.Single(s => s.LastName == "Anand").ID,
CourseID = courses.Single(c => c.Title == "Microeconomics").CourseID,
Grade = Grade.B
},
new Enrollment {
StudentID = students.Single(s => s.LastName == "Barzdukas").ID,
CourseID = courses.Single(c => c.Title == "Chemistry").CourseID,
Grade = Grade.B
},
new Enrollment {
StudentID = students.Single(s => s.LastName == "Li").ID,
CourseID = courses.Single(c => c.Title == "Composition").CourseID,
Grade = Grade.B
},
new Enrollment {
StudentID = students.Single(s => s.LastName == "Justice").ID,
CourseID = courses.Single(c => c.Title == "Literature").CourseID,
Grade = Grade.B
}
};
foreach (Enrollment e in enrollments)
{
var enrollmentInDataBase = context.Enrollments.Where(
s =>
s.Student.ID == e.StudentID &&
s.Course.CourseID == e.CourseID).SingleOrDefault();
if (enrollmentInDataBase == null)
{
context.Enrollments.Add(e);
}
}
context.SaveChanges();
}
}
}
Zoals u in de eerste zelfstudie hebt gezien, bestaat het grootste deel van deze code eenvoudig uit het aanmaken van nieuwe entiteitsobjecten en het laden van voorbeeldgegevens in eigenschappen zoals vereist voor het testen. U ziet hoe veel-op-veel-relaties worden verwerkt: met de code worden relaties gemaakt door entiteiten te maken in de Enrollments- en CourseAssignment-koppelentiteitensets.
Een migratie toevoegen
Sla uw wijzigingen op en bouw het project. Open vervolgens het opdrachtvenster in de projectmap en voer de migrations add opdracht in (voer de opdracht updatedatabase nog niet uit):
dotnet ef migrations add ComplexDataModel
U krijgt een waarschuwing over mogelijk gegevensverlies.
An operation was scaffolded that may result in the loss of data. Please review the migration for accuracy.
Done. To undo this action, use 'ef migrations remove'
Als u op dit moment de database update opdracht zou proberen uit te voeren (doe dit nog niet), zou u de volgende fout krijgen:
De ALTER TABLE-instructie conflicteerde met de beperking VREEMDE SLEUTEL "FK_dbo.Course_dbo.Department_DepartmentID". Het conflict is opgetreden in database "ContosoUniversity", tabel "dbo. Afdeling', kolom 'DepartmentID'.
Wanneer u migraties uitvoert met bestaande gegevens, moet u stubgegevens in de database invoegen om te voldoen aan foreign key-beperkingen. De gegenereerde code in de Up methode voegt een niet-nullable refererende DepartmentID sleutel toe aan de Course tabel. Als er al rijen in de cursustabel staan wanneer de code wordt uitgevoerd, mislukt de AddColumn bewerking omdat SQL Server niet weet welke waarde in de kolom moet worden geplaatst die niet null kan zijn. Voor deze zelfstudie voert u de migratie uit op een nieuwe database, maar in een productietoepassing moet u de migratie bestaande gegevens laten verwerken, dus in de volgende aanwijzingen ziet u een voorbeeld van hoe u dit doet.
Als u deze migratie wilt laten werken met bestaande gegevens, moet u de code wijzigen om de nieuwe kolom een standaardwaarde te geven en een stub-afdeling met de naam 'Temp' maken om te fungeren als de standaardafdeling. Als gevolg hiervan zijn bestaande cursusrecords allemaal gerelateerd aan de afdeling "Temp" nadat de Up methode is uitgevoerd.
Open het
{timestamp}_ComplexDataModel.csbestand.Maak van de coderegel waarmee de kolom DepartmentID wordt toegevoegd aan de cursustabel commentaar.
migrationBuilder.AlterColumn<string>( name: "Title", table: "Course", maxLength: 50, nullable: true, oldClrType: typeof(string), oldNullable: true); //migrationBuilder.AddColumn<int>( // name: "DepartmentID", // table: "Course", // nullable: false, // defaultValue: 0);Voeg de volgende gemarkeerde code toe na de code waarmee de tabel Afdeling wordt gemaakt:
migrationBuilder.CreateTable( name: "Department", columns: table => new { DepartmentID = table.Column<int>(nullable: false) .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn), Budget = table.Column<decimal>(type: "money", nullable: false), InstructorID = table.Column<int>(nullable: true), Name = table.Column<string>(maxLength: 50, nullable: true), StartDate = table.Column<DateTime>(nullable: false) }, constraints: table => { table.PrimaryKey("PK_Department", x => x.DepartmentID); table.ForeignKey( name: "FK_Department_Instructor_InstructorID", column: x => x.InstructorID, principalTable: "Instructor", principalColumn: "ID", onDelete: ReferentialAction.Restrict); }); migrationBuilder.Sql("INSERT INTO dbo.Department (Name, Budget, StartDate) VALUES ('Temp', 0.00, GETDATE())"); // Default value for FK points to department created above, with // defaultValue changed to 1 in following AddColumn statement. migrationBuilder.AddColumn<int>( name: "DepartmentID", table: "Course", nullable: false, defaultValue: 1);
In een productietoepassing schrijft u code of scripts om Department-rijen toe te voegen en Course-rijen te relateren aan de nieuwe Department-rijen. U hebt dan de afdeling Temp en de standaardwaarde in de Course.DepartmentID kolom niet meer nodig.
Sla uw wijzigingen op en bouw het project.
De verbindingsreeks wijzigen
U hebt nu nieuwe code in de DbInitializer klasse waarmee seed-gegevens voor de nieuwe entiteiten worden toegevoegd aan een lege database. Om EF een nieuwe lege database te laten maken, wijzigt u de naam van de database in de verbindingsreeks in appsettings.json in ContosoUniversity3 of een andere naam die u niet hebt gebruikt op de computer die u gebruikt.
{
"ConnectionStrings": {
"DefaultConnection": "Server=(localdb)\\mssqllocaldb;Database=ContosoUniversity3;Trusted_Connection=True;MultipleActiveResultSets=true"
},
Sla uw wijziging op naar appsettings.json.
Note
Als alternatief voor het wijzigen van de databasenaam kunt u de database verwijderen. Gebruik SQL Server Objectverkenner (SSOX) of de CLI-opdrachtdatabase drop:
dotnet ef database drop
De database bijwerken
Nadat u de databasenaam hebt gewijzigd of de database hebt verwijderd, voert u de database update opdracht uit in het opdrachtvenster om de migraties uit te voeren.
dotnet ef database update
Voer de app uit om ervoor te zorgen dat de DbInitializer.Initialize methode wordt uitgevoerd en de nieuwe database wordt gevuld.
Open de database in SSOX zoals u eerder hebt gedaan en vouw het knooppunt Tabellen uit om te zien dat alle tabellen zijn gemaakt. (Als u SSOX nog open hebt van de vorige keer, klikt u op de knop Vernieuwen.)
Voer de app uit om de initialisatiecode te activeren waarmee de database wordt gezaaid.
Klik met de rechtermuisknop op de tabel CourseAssignment en selecteer Gegevens weergeven om te controleren of er gegevens in staan.
De code ophalen
de voltooide toepassing downloaden of weergeven.
Volgende stappen
In deze handleiding leert u:
- Het gegevensmodel aangepast
- Wijzigingen aangebracht in de entiteit Student
- Entiteit Instructeur gemaakt
- OfficeAssignment-entiteit is gemaakt
- Gewijzigde cursusentiteit
- Afdelingsentiteit gemaakt
- Gewijzigde inschrijving
- De databasecontext bijgewerkt
- Database gevuld met testgegevens
- Een migratie toegevoegd
- De verbindingsreeks is gewijzigd
- De database bijgewerkt
Ga naar de volgende zelfstudie voor meer informatie over het openen van gerelateerde gegevens.