Esercitazione: Leggere i dati correlati con EF in un'app MVC ASP.NET
Nell'esercitazione precedente è stato completato il modello di dati School. In questa esercitazione verranno letti e visualizzati i dati correlati, ovvero i dati caricati da Entity Framework nelle proprietà di spostamento.
Le figure seguenti illustrano le pagine che verranno usate.
Scaricare il progetto completato
L'applicazione Web di esempio Contoso University illustra come creare applicazioni ASP.NET MVC 5 usando Entity Framework 6 Code First e Visual Studio. Per informazioni sulla serie di esercitazioni, vedere la prima esercitazione della serie.
In questa esercitazione:
- Scoprire come caricare i dati correlati
- Creare una pagina Courses
- Creare una pagina Instructors
Prerequisiti
Scoprire come caricare i dati correlati
Esistono diversi modi in cui Entity Framework può caricare i dati correlati nelle proprietà di spostamento di un'entità:
Caricamento lazy. Quando un'entità viene letta per la prima volta, i dati correlati non vengono recuperati. La prima volta che si tenta di accedere a una proprietà di navigazione, tuttavia, i dati necessari per quest'ultima vengono recuperati automaticamente. Ciò comporta più query inviate al database, una per l'entità stessa e una ogni volta che i dati correlati per l'entità devono essere recuperati. La
DbContext
classe abilita il caricamento lazy per impostazione predefinita.Caricamento ansioso. Quando l'entità viene letta, i dati correlati corrispondenti vengono recuperati insieme ad essa. Ciò in genere ha come risultato una query join singola che recupera tutti i dati necessari. Specificare il caricamento ansioso usando il
Include
metodo .Caricamento esplicito. Questo è simile al caricamento lazy, ad eccezione del fatto che i dati correlati vengano recuperati in modo esplicito nel codice; non avviene automaticamente quando si accede a una proprietà di spostamento. I dati correlati vengono caricati manualmente recuperando la voce gestione stati oggetti per un'entità e chiamando il metodo Collection.Load per le raccolte o il metodo Reference.Load per le proprietà che contengono una singola entità. Nell'esempio seguente, se si vuole caricare la proprietà di spostamento Amministratore, sostituire
Collection(x => x.Courses)
conReference(x => x.Administrator)
.) In genere si userà il caricamento esplicito solo quando è stato disattivato il caricamento lazy.
Poiché non recuperano immediatamente i valori delle proprietà, il caricamento lazy e il caricamento esplicito sono entrambi noti come caricamento posticipato.
Considerazioni sulle prestazioni
Se si sa di aver bisogno di dati correlati per tutte le entità recuperate, il caricamento eager spesso garantisce le prestazioni migliori, perché l'invio di un'unica query al database è in genere più efficiente dell'invio di query separate per ogni entità recuperata. Ad esempio, negli esempi precedenti si supponga che ogni reparto abbia dieci corsi correlati. L'esempio di caricamento ansioso comporta solo una singola query (join) e un singolo round trip nel database. Gli esempi di caricamento e caricamento esplicito lazy comportano sia undici query che undici round trip nel database. I round trip aggiuntivi al database influiscono in modo particolarmente negativo sulle prestazioni quando la latenza è elevata.
D'altra parte, in alcuni scenari il caricamento lazy è più efficiente. Il caricamento ansioso potrebbe causare la generazione di un join molto complesso, che SQL Server non può elaborare in modo efficiente. In alternativa, se è necessario accedere alle proprietà di spostamento di un'entità solo per un subset di un set di entità che si sta elaborando, il caricamento in ritardo potrebbe risultare migliore perché il caricamento ansioso recupera più dati che è necessario. Se le prestazioni rappresentano un aspetto essenziale, per avere la certezza di scegliere il metodo più efficiente è consigliabile testare le prestazioni di entrambi i tipi di caricamento.
Il caricamento lazy può mascherare il codice che causa problemi di prestazioni. Ad esempio, il codice che non specifica caricamento ansioso o esplicito, ma elabora un volume elevato di entità e usa diverse proprietà di spostamento in ogni iterazione potrebbe essere molto inefficiente (a causa di molti round trip nel database). Un'applicazione che esegue correttamente lo sviluppo usando un server SQL locale potrebbe avere problemi di prestazioni quando viene spostata in Azure SQL Database a causa dell'aumento della latenza e del caricamento in ritardo. La profilatura delle query di database con un carico di test realistico consente di determinare se il caricamento in ritardo è appropriato. Per altre informazioni, vedere Demystifying Entity Framework Strategies: Caricamento di dati correlati e uso di Entity Framework per ridurre la latenza di rete in SQL Azure.
Disabilitare il caricamento lazy prima della serializzazione
Se si lascia il caricamento lazy abilitato durante la serializzazione, è possibile eseguire query in modo significativo su più dati rispetto a quanto previsto. La serializzazione funziona in genere accedendo a ogni proprietà in un'istanza di un tipo. L'accesso alle proprietà attiva il caricamento in ritardo e quelle entità caricate in ritardo vengono serializzate. Il processo di serializzazione accede quindi a ogni proprietà delle entità caricate con lazy, causando potenzialmente un caricamento e una serializzazione ancora più lazy. Per evitare questa reazione a catena di run-away, disattivare il caricamento lazy prima di serializzare un'entità.
La serializzazione può anche essere complicata dalle classi proxy usate da Entity Framework, come illustrato nell'esercitazione Scenari avanzati.
Un modo per evitare problemi di serializzazione consiste nel serializzare gli oggetti di trasferimento dei dati anziché gli oggetti di entità, come illustrato nell'esercitazione Uso dell'API Web con Entity Framework .
Se non si usano DTO, è possibile disabilitare il caricamento lazy ed evitare problemi di proxy disabilitando la creazione del proxy.
Ecco alcuni altri modi per disabilitare il caricamento lazy:
Per proprietà di spostamento specifiche, omettere la
virtual
parola chiave quando si dichiara la proprietà.Per tutte le proprietà di spostamento, impostare
LazyLoadingEnabled
sufalse
, inserire il codice seguente nel costruttore della classe di contesto:this.Configuration.LazyLoadingEnabled = false;
Creare una pagina Courses
L'entità Course
include una proprietà di navigazione che contiene l'entità Department
del reparto a cui viene assegnato il corso. Per visualizzare il nome del reparto assegnato in un elenco di corsi, è necessario ottenere la Name
proprietà dall'entità Department
presente nella Course.Department
proprietà di spostamento.
Creare un controller denominato CourseController
(non CoursesController) per il tipo di entità, usando le stesse opzioni per il Course
controller MVC 5 con viste, usando lo scaffolder di Entity Framework eseguito in precedenza per il Student
controller:
Impostazione | Valore |
---|---|
Classe Model | Selezionare Corso (ContosoUniversity.Models). |
Classe contesto dati | Selezionare SchoolContext (ContosoUniversity.DAL). |
Nome controller | Immettere CourseController. Di nuovo, non CoursesController con un s. Quando è stato selezionato Course (ContosoUniversity.Models), il valore del nome del controller è stato popolato automaticamente. È necessario modificare il valore. |
Lasciare gli altri valori predefiniti e aggiungere il controller.
Aprire Controller\CourseController.cs e esaminare il Index
metodo:
public ActionResult Index()
{
var courses = db.Courses.Include(c => c.Department);
return View(courses.ToList());
}
Lo scaffolding automatico ha specificato il caricamento eager per la proprietà di navigazione Department
tramite il metodo Include
.
Aprire Views\Course\Index.cshtml e sostituire il codice del modello con il codice seguente. Le modifiche sono evidenziate:
@model IEnumerable<ContosoUniversity.Models.Course>
@{
ViewBag.Title = "Courses";
}
<h2>Courses</h2>
<p>
@Html.ActionLink("Create New", "Create")
</p>
<table class="table">
<tr>
<th>
@Html.DisplayNameFor(model => model.CourseID)
</th>
<th>
@Html.DisplayNameFor(model => model.Title)
</th>
<th>
@Html.DisplayNameFor(model => model.Credits)
</th>
<th>
Department
</th>
<th></th>
</tr>
@foreach (var item in Model) {
<tr>
<td>
@Html.DisplayFor(modelItem => item.CourseID)
</td>
<td>
@Html.DisplayFor(modelItem => item.Title)
</td>
<td>
@Html.DisplayFor(modelItem => item.Credits)
</td>
<td>
@Html.DisplayFor(modelItem => item.Department.Name)
</td>
<td>
@Html.ActionLink("Edit", "Edit", new { id=item.CourseID }) |
@Html.ActionLink("Details", "Details", new { id=item.CourseID }) |
@Html.ActionLink("Delete", "Delete", new { id=item.CourseID })
</td>
</tr>
}
</table>
Al codice con scaffolding sono state apportate le modifiche seguenti:
- Modifica l'intestazione da Indice a Corsi.
- È stata aggiunta la colonna Number (Numero) con il valore della proprietà
CourseID
. Per impostazione predefinita, le chiavi primarie non vengono scaffolded perché normalmente sono senza significato agli utenti finali. In questo caso, tuttavia, la chiave primaria è significativa ed è necessario visualizzarla. - Spostata la colonna Reparto sul lato destro e modificata l'intestazione. Lo scaffolder ha scelto correttamente di visualizzare la proprietà dall'entità, ma qui nella pagina Corso l'intestazione
Name
Department
della colonna deve essere Reparto anziché Nome.
Si noti che per la colonna Reparto, il codice scaffolded visualizza la Name
proprietà dell'entità Department
caricata nella Department
proprietà di navigazione:
<td>
@Html.DisplayFor(modelItem => item.Department.Name)
</td>
Eseguire la pagina (selezionare la scheda Corsi nella home page di Contoso University) per visualizzare l'elenco con nomi di reparto.
Creare una pagina Instructors
In questa sezione si creerà un controller e una visualizzazione per l'entità per visualizzare la Instructor
pagina Insegnanti. Questa pagina legge e visualizza dati correlati nei modi seguenti:
- L'elenco degli insegnanti visualizza i dati correlati dall'entità
OfficeAssignment
. Tra le entitàInstructor
eOfficeAssignment
c'è una relazione uno-a-zero-o-uno. Si userà il caricamento ansioso per leOfficeAssignment
entità. Come spiegato in precedenza, il caricamento eager è in genere più efficiente quando sono necessari i dati correlati per tutte le righe recuperate della tabella primaria. In questo caso, si vogliono visualizzare le assegnazioni di ufficio per tutti gli insegnanti visualizzati. - Quando l'utente seleziona un insegnante, vengono visualizzate le entità
Course
correlate. Tra le entitàInstructor
eCourse
esiste una relazione molti-a-molti. Si userà il caricamento ansioso per le entità e leCourse
relative entità correlateDepartment
. In questo caso, il caricamento lazy potrebbe essere più efficiente perché sono necessari corsi solo per l'insegnante selezionato. Questo esempio, tuttavia, illustra come usare il caricamento eager per le proprietà di navigazione con entità esse stesse all'interno di proprietà di navigazione. - Quando l'utente seleziona un corso, vengono visualizzati i dati correlati dal
Enrollments
set di entità. Tra le entitàCourse
eEnrollment
esiste una relazione uno-a-molti. Si aggiungerà il caricamento esplicito per le entità e leEnrollment
relative entità correlateStudent
. Il caricamento esplicito non è necessario perché il caricamento lazy è abilitato, ma illustra come eseguire il caricamento esplicito.
Creare un modello di visualizzazione per la visualizzazione indice di istruttore
La pagina Insegnanti mostra tre tabelle diverse. Verrà quindi creato un modello di visualizzazione che includa tre proprietà, ognuna contenente i dati di una delle tabelle.
Nella cartella ViewModels creare InstructorIndexData.cs e sostituire il codice esistente con il codice seguente:
using System.Collections.Generic;
using ContosoUniversity.Models;
namespace ContosoUniversity.ViewModels
{
public class InstructorIndexData
{
public IEnumerable<Instructor> Instructors { get; set; }
public IEnumerable<Course> Courses { get; set; }
public IEnumerable<Enrollment> Enrollments { get; set; }
}
}
Creare il controller e le visualizzazioni dell'insegnante
Creare un InstructorController
controller (non InstructorsController) con un'azione di lettura/scrittura EF:
Impostazione | Valore |
---|---|
Classe Model | Selezionare Istruttore (ContosoUniversity.Models). |
Classe contesto dati | Selezionare SchoolContext (ContosoUniversity.DAL). |
Nome controller | Immettere InstructorController. Di nuovo, non InstructorsController con un s. Quando è stato selezionato Course (ContosoUniversity.Models), il valore del nome del controller è stato popolato automaticamente. È necessario modificare il valore. |
Lasciare gli altri valori predefiniti e aggiungere il controller.
Aprire Controller\InstructorController.cs e aggiungere un'istruzione using
per lo ViewModels
spazio dei nomi:
using ContosoUniversity.ViewModels;
Il codice scaffolded nel Index
metodo specifica il caricamento ansioso solo per la proprietà di OfficeAssignment
navigazione:
public ActionResult Index()
{
var instructors = db.Instructors.Include(i => i.OfficeAssignment);
return View(instructors.ToList());
}
Sostituire il metodo con il Index
codice seguente per caricare dati correlati aggiuntivi e inserirli nel modello di visualizzazione:
public ActionResult Index(int? id, int? courseID)
{
var viewModel = new InstructorIndexData();
viewModel.Instructors = db.Instructors
.Include(i => i.OfficeAssignment)
.Include(i => i.Courses.Select(c => c.Department))
.OrderBy(i => i.LastName);
if (id != null)
{
ViewBag.InstructorID = id.Value;
viewModel.Courses = viewModel.Instructors.Where(
i => i.ID == id.Value).Single().Courses;
}
if (courseID != null)
{
ViewBag.CourseID = courseID.Value;
viewModel.Enrollments = viewModel.Courses.Where(
x => x.CourseID == courseID).Single().Enrollments;
}
return View(viewModel);
}
Il metodo accetta dati di route facoltativi () e un parametro stringa di query (id
courseID
) che specificano i valori ID dell'insegnante selezionato e del corso selezionato e passa tutti i dati necessari alla visualizzazione. I parametri sono forniti dai collegamenti ipertestuali Select (Seleziona) nella pagina.
Il codice inizia creando un'istanza del modello di visualizzazione e inserendola nell'elenco degli insegnanti. Il codice specifica il caricamento per l'oggetto Instructor.OfficeAssignment
e la proprietà di Instructor.Courses
spostamento.
var viewModel = new InstructorIndexData();
viewModel.Instructors = db.Instructors
.Include(i => i.OfficeAssignment)
.Include(i => i.Courses.Select(c => c.Department))
.OrderBy(i => i.LastName);
Il secondo Include
metodo carica i corsi e per ogni corso caricato esegue il caricamento per la proprietà di Course.Department
navigazione.
.Include(i => i.Courses.Select(c => c.Department))
Come accennato in precedenza, il caricamento ansioso non è obbligatorio, ma viene fatto per migliorare le prestazioni. Poiché la vista richiede sempre l'entità OfficeAssignment
, è più efficiente recuperare la stessa query. Course
le entità sono necessarie quando un insegnante è selezionato nella pagina Web, quindi il caricamento ansioso è migliore del caricamento lazy solo se la pagina viene visualizzata più spesso con un corso selezionato rispetto a senza.
Se è stato selezionato un ID insegnante, l'insegnante selezionato viene recuperato dall'elenco degli insegnanti nel modello di visualizzazione. La proprietà del modello di Courses
visualizzazione viene quindi caricata con le Course
entità dalla proprietà di navigazione dell'insegnante Courses
.
if (id != null)
{
ViewBag.InstructorID = id.Value;
viewModel.Courses = viewModel.Instructors.Where(i => i.ID == id.Value).Single().Courses;
}
Il Where
metodo restituisce una raccolta, ma in questo caso i criteri passati a tale metodo generano solo una singola Instructor
entità restituita. Il Single
metodo converte la raccolta in una singola Instructor
entità, che consente di accedere alla proprietà dell'entità Courses
.
Si usa il metodo Single in una raccolta quando si sa che l'insieme avrà un solo elemento. Il Single
metodo genera un'eccezione se la raccolta passata è vuota o se è presente più di un elemento. Un'alternativa è SingleOrDefault, che restituisce un valore predefinito (null
in questo caso) se la raccolta è vuota. Tuttavia, in questo caso, ciò comporta comunque un'eccezione (dal tentativo di trovare una Courses
proprietà su un null
riferimento) e il messaggio di eccezione indica in modo meno chiaro la causa del problema. Quando si chiama il Single
metodo, è anche possibile passare la Where
condizione anziché chiamare il Where
metodo separatamente:
.Single(i => i.ID == id.Value)
Anziché:
.Where(I => i.ID == id.Value).Single()
Se è stato selezionato un corso, questo viene quindi recuperato dall'elenco dei corsi nel modello di visualizzazione. La proprietà del Enrollments
modello di visualizzazione viene quindi caricata con le Enrollment
entità dalla proprietà di spostamento del Enrollments
corso.
if (courseID != null)
{
ViewBag.CourseID = courseID.Value;
viewModel.Enrollments = viewModel.Courses.Where(
x => x.CourseID == courseID).Single().Enrollments;
}
Modificare la visualizzazione indice dell'insegnante
In Views\Instructor\Index.cshtml sostituire il codice del modello con il codice seguente. Le modifiche sono evidenziate:
@model ContosoUniversity.ViewModels.InstructorIndexData
@{
ViewBag.Title = "Instructors";
}
<h2>Instructors</h2>
<p>
@Html.ActionLink("Create New", "Create")
</p>
<table class="table">
<tr>
<th>Last Name</th>
<th>First Name</th>
<th>Hire Date</th>
<th>Office</th>
<th></th>
</tr>
@foreach (var item in Model.Instructors)
{
string selectedRow = "";
if (item.ID == ViewBag.InstructorID)
{
selectedRow = "success";
}
<tr class="@selectedRow">
<td>
@Html.DisplayFor(modelItem => item.LastName)
</td>
<td>
@Html.DisplayFor(modelItem => item.FirstMidName)
</td>
<td>
@Html.DisplayFor(modelItem => item.HireDate)
</td>
<td>
@if (item.OfficeAssignment != null)
{
@item.OfficeAssignment.Location
}
</td>
<td>
@Html.ActionLink("Select", "Index", new { id = item.ID }) |
@Html.ActionLink("Edit", "Edit", new { id = item.ID }) |
@Html.ActionLink("Details", "Details", new { id = item.ID }) |
@Html.ActionLink("Delete", "Delete", new { id = item.ID })
</td>
</tr>
}
</table>
Al codice esistente sono state apportate le modifiche seguenti:
La classe del modello è stata modificata in
InstructorIndexData
.Il titolo pagina è stato modificato da Index (Indice) a Instructors (Insegnanti).
Aggiunta di una colonna di Office che visualizza
item.OfficeAssignment.Location
solo seitem.OfficeAssignment
non è null. Poiché si tratta di una relazione uno-a-zero-o-uno, potrebbe non esserci un'entità correlataOfficeAssignment
.<td> @if (item.OfficeAssignment != null) { @item.OfficeAssignment.Location } </td>
Aggiunto codice che aggiungerà
class="success"
dinamicamente all'elemento dell'insegnantetr
selezionato. Questo imposta un colore di sfondo per la riga selezionata usando una classe Bootstrap .string selectedRow = ""; if (item.InstructorID == ViewBag.InstructorID) { selectedRow = "success"; } <tr class="@selectedRow" valign="top">
Aggiunta di una nuova
ActionLink
etichetta Seleziona immediatamente prima degli altri collegamenti in ogni riga, che causa l'invio dell'ID dell'insegnanteIndex
selezionato al metodo.
Eseguire l'applicazione e selezionare la scheda Insegnanti . La pagina visualizza la Location
proprietà delle entità correlate OfficeAssignment
e una cella di tabella vuota quando non è presente alcuna entità correlata OfficeAssignment
.
Nel file Views\Instructor\Index.cshtml , dopo l'elemento di chiusura table
(alla fine del file), aggiungere il codice seguente. Quando è selezionato un insegnante, Questo codice visualizza un elenco dei corsi correlati all'insegnante stesso.
@if (Model.Courses != null)
{
<h3>Courses Taught by Selected Instructor</h3>
<table class="table">
<tr>
<th></th>
<th>Number</th>
<th>Title</th>
<th>Department</th>
</tr>
@foreach (var item in Model.Courses)
{
string selectedRow = "";
if (item.CourseID == ViewBag.CourseID)
{
selectedRow = "success";
}
<tr class="@selectedRow">
<td>
@Html.ActionLink("Select", "Index", new { courseID = item.CourseID })
</td>
<td>
@item.CourseID
</td>
<td>
@item.Title
</td>
<td>
@item.Department.Name
</td>
</tr>
}
</table>
}
Questo codice legge la proprietà Courses
del modello di visualizzazione per visualizzare l'elenco dei corsi. Fornisce anche un Select
collegamento ipertestuale che invia l'ID del corso selezionato al Index
metodo action.
Eseguire la pagina e selezionare un insegnante. È ora possibile vedere una griglia con i corsi assegnati all'insegnante selezionato. Per ogni corso è possibile vedere il nome del dipartimento assegnato.
Dopo il blocco di codice appena aggiunto, aggiungere il codice seguente. Quando è selezionato un corso, questo codice visualizza l'elenco degli studenti iscritti al corso selezionato.
@if (Model.Enrollments != null)
{
<h3>
Students Enrolled in Selected Course
</h3>
<table class="table">
<tr>
<th>Name</th>
<th>Grade</th>
</tr>
@foreach (var item in Model.Enrollments)
{
<tr>
<td>
@item.Student.FullName
</td>
<td>
@Html.DisplayFor(modelItem => item.Grade)
</td>
</tr>
}
</table>
}
Questo codice legge la Enrollments
proprietà del modello di visualizzazione per visualizzare un elenco di studenti registrati nel corso.
Eseguire la pagina e selezionare un insegnante. Selezionare quindi un corso per visualizzare l'elenco degli studenti iscritti e i voti corrispondenti.
Aggiunta del caricamento esplicito
Aprire InstructorController.cs e esaminare come il metodo ottiene l'elenco Index
delle registrazioni per un corso selezionato:
if (courseID != null)
{
ViewBag.CourseID = courseID.Value;
viewModel.Enrollments = viewModel.Courses.Where(
x => x.CourseID == courseID).Single().Enrollments;
}
Quando hai recuperato l'elenco degli insegnanti, hai specificato il caricamento desiderato per la proprietà di navigazione e per la Courses
Department
proprietà di ogni corso. Quindi si inserisce la Courses
raccolta nel modello di visualizzazione e si accede alla Enrollments
proprietà di spostamento da un'entità nella raccolta. Poiché non è stato specificato il caricamento ansioso per la Course.Enrollments
proprietà di spostamento, i dati di tale proprietà vengono visualizzati nella pagina in seguito al caricamento in ritardo.
Se il caricamento lazy è stato disabilitato senza modificare il codice in qualsiasi altro modo, la Enrollments
proprietà sarà null indipendentemente dal numero di registrazioni effettivamente presenti nel corso. In tal caso, per caricare la Enrollments
proprietà, è necessario specificare il caricamento o il caricamento esplicito. Hai già visto come eseguire il caricamento ansioso. Per visualizzare un esempio di caricamento esplicito, sostituire il metodo con il Index
codice seguente, che carica in modo esplicito la Enrollments
proprietà. Il codice modificato è evidenziato.
public ActionResult Index(int? id, int? courseID)
{
var viewModel = new InstructorIndexData();
viewModel.Instructors = db.Instructors
.Include(i => i.OfficeAssignment)
.Include(i => i.Courses.Select(c => c.Department))
.OrderBy(i => i.LastName);
if (id != null)
{
ViewBag.InstructorID = id.Value;
viewModel.Courses = viewModel.Instructors.Where(
i => i.ID == id.Value).Single().Courses;
}
if (courseID != null)
{
ViewBag.CourseID = courseID.Value;
// Lazy loading
//viewModel.Enrollments = viewModel.Courses.Where(
// x => x.CourseID == courseID).Single().Enrollments;
// Explicit loading
var selectedCourse = viewModel.Courses.Where(x => x.CourseID == courseID).Single();
db.Entry(selectedCourse).Collection(x => x.Enrollments).Load();
foreach (Enrollment enrollment in selectedCourse.Enrollments)
{
db.Entry(enrollment).Reference(x => x.Student).Load();
}
viewModel.Enrollments = selectedCourse.Enrollments;
}
return View(viewModel);
}
Dopo aver ottenuto l'entità selezionata Course
, il nuovo codice carica in modo esplicito la proprietà di spostamento del Enrollments
corso:
db.Entry(selectedCourse).Collection(x => x.Enrollments).Load();
Carica quindi in modo esplicito l'entità correlata Student
di ogni Enrollment
entità:
db.Entry(enrollment).Reference(x => x.Student).Load();
Si noti che si usa il Collection
metodo per caricare una proprietà di raccolta, ma per una proprietà che contiene solo un'entità, si usa il Reference
metodo .
Eseguire la pagina Indice dell'istruttore ora e non si noterà alcuna differenza nella pagina visualizzata, anche se è stato modificato il modo in cui vengono recuperati i dati.
Ottenere il codice
Scaricare il progetto completato
Risorse aggiuntive
I collegamenti ad altre risorse di Entity Framework sono disponibili nella ASP.NET Accesso ai dati - Risorse consigliate.
Passaggi successivi
In questa esercitazione:
- Come caricare i dati correlati
- Creazione di una pagina Courses
- Creazione di una pagina Instructors
Passare all'articolo successivo per informazioni su come aggiornare i dati correlati.