Esercitazione: Introduzione a Entity Framework 6 Code First con MVC 5

Articolo
07/13/2023

Nota

Per il nuovo sviluppo, è consigliabile ASP.NET Core Razor Pages su ASP.NET controller e visualizzazioni MVC. Per una serie di esercitazioni simile a questa con Razor Pages, vedere Esercitazione: Introduzione a Razor Pages in ASP.NET Core. La nuova esercitazione:

È più semplice da seguire.
Offre un maggior numero di procedure consigliate per EF Core.
Usa query più efficienti.
È più aggiornata con le API più recenti.
Riguarda più funzionalità.
È l'approccio consigliato per lo sviluppo di nuove applicazioni.

In questa serie di esercitazioni si apprenderà come creare un'applicazione ASP.NET MVC 5 che usa Entity Framework 6 per l'accesso ai dati. Questa esercitazione usa il flusso di lavoro Code First. Per informazioni su come scegliere tra Code First, Database First e Model First, vedere Creare un modello.

Questa serie di esercitazioni illustra come compilare l'applicazione di esempio Contoso University. L'applicazione di esempio è un semplice sito Web universitario. Con esso, è possibile visualizzare e aggiornare le informazioni degli studenti, dei corsi e degli insegnanti. Ecco due schermate create:

Students_Index_page

Modifica studente

In questa esercitazione:

Creare un'app Web MVC
Impostare lo stile del sito
Installare Entity Framework 6
Creare il modello di dati
Creare il contesto di database
Inizializzare il database con dati di test
Configurare EF 6 per l'uso di LocalDB
Creare controller e visualizzazioni
Visualizzare il database

Prerequisiti

Visual Studio 2017

Creare un'app Web MVC

Aprire Visual Studio e creare un progetto Web C# usando il modello applicazione Web ASP.NET (.NET Framework). Assegnare al progetto il nome ContosoUniversity e selezionare OK.
In Nuova applicazione Web ASP.NET - ContosoUniversity selezionare MVC.

Nota

Per impostazione predefinita, l'opzione Autenticazione è impostata su Nessuna autenticazione. Per questa esercitazione, l'app Web non richiede agli utenti di accedere. Inoltre, non limita l'accesso in base a chi ha eseguito l'accesso.
Selezionare OK per creare il progetto.

Impostare lo stile del sito

Con alcune modifiche è possibile impostare il menu del sito, il layout e la home page.

Aprire Views\Shared\_Layout.cshtml e apportare le modifiche seguenti:

Modificare ogni occorrenza di "My ASP.NET Application" e "Application name" in "Contoso University".
Aggiungere voci di menu per Studenti, Corsi, Insegnanti e Reparti ed eliminare la voce Contatto.

Le modifiche sono evidenziate nel frammento di codice seguente:

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>@ViewBag.Title - Contoso University</title>
    @Styles.Render("~/Content/css")
    @Scripts.Render("~/bundles/modernizr")
</head>
<body>
    <div class="navbar navbar-inverse navbar-fixed-top">
        <div class="navbar-inner">
            <div class="container">
                <button type="button" class="btn btn-navbar" data-toggle="collapse" data-target=".nav-collapse">
                    <span class="icon-bar"></span>
                    <span class="icon-bar"></span>
                    <span class="icon-bar"></span>
                </button>
                @Html.ActionLink("Contoso University", "Index", "Home", new { area = "" }, new { @class = "navbar-brand" })
                <div class="nav-collapse collapse">
                    <ul class="nav">
                        <li>@Html.ActionLink("Home", "Index", "Home")</li>
                        <li>@Html.ActionLink("About", "About", "Home")</li>
                        <li>@Html.ActionLink("Students", "Index", "Student")</li>
                        <li>@Html.ActionLink("Courses", "Index", "Course")</li>
                        <li>@Html.ActionLink("Instructors", "Index", "Instructor")</li>
                        <li>@Html.ActionLink("Departments", "Index", "Department")</li>
                    </ul>
                </div>
            </div>
        </div>
    </div>

    <div class="container">
        @RenderBody()
        <hr />
        <footer>
            <p>&copy; @DateTime.Now.Year - Contoso University</p>
        </footer>
    </div>

    @Scripts.Render("~/bundles/jquery")
    @Scripts.Render("~/bundles/bootstrap")
    @RenderSection("scripts", required: false)
</body>
</html>

In Views\Home\Index.cshtml sostituire il contenuto del file con il codice seguente per sostituire il testo relativo a ASP.NET e MVC con testo su questa applicazione:

@{
    ViewBag.Title = "Home Page";
}

<div class="jumbotron">
    <h1>Contoso University</h1>
</div>
<div class="row">
    <div class="col-md-4">
        <h2>Welcome to Contoso University</h2>
        <p>Contoso University is a sample application that
        demonstrates how to use Entity Framework 6 in an 
        ASP.NET MVC 5 web application.</p>
    </div>
    <div class="col-md-4">
        <h2>Build it from scratch</h2>
        <p>You can build the application by following the steps in the tutorial series on the ASP.NET site.</p>
        <p><a class="btn btn-default" href="http://www.asp.net/mvc/tutorials/getting-started-with-ef-using-mvc/">See the tutorial &raquo;</a></p>
    </div>
    <div class="col-md-4">
        <h2>Download it</h2>
        <p>You can download the completed project.</p>
        <p><a class="btn btn-default" href="https://webpifeed.blob.core.windows.net/webpifeed/Partners/ASP.NET%20MVC%20Application%20Using%20Entity%20Framework%20Code%20First.zip">Download &raquo;</a></p>
    </div>
</div>

Premere CTRL+F5 per eseguire il sito Web. Viene visualizzata la home page con il menu principale.

Installare Entity Framework 6

Scegliere Gestione pacchetti NuGet dal menu Strumenti e quindi scegliere Gestione pacchetti Console.
Nella finestra Console di Gestione pacchetti immettere il comando seguente:
```
Install-Package EntityFramework
```

Questo passaggio è uno dei pochi passaggi che questa esercitazione prevede manualmente, ma che potrebbe essere stata eseguita automaticamente dalla funzionalità di scaffolding MVC ASP.NET. Vengono usata manualmente in modo che sia possibile visualizzare i passaggi necessari per usare Entity Framework (EF). Si userà lo scaffolding in un secondo momento per creare il controller e le visualizzazioni MVC. Un'alternativa consiste nel consentire allo scaffolding di installare automaticamente il pacchetto NuGet ef, creare la classe di contesto del database e creare il stringa di connessione. Quando si è pronti a farlo in questo modo, è necessario ignorare questi passaggi e eseguire lo scaffolding del controller MVC dopo aver creato le classi di entità.

Creare il modello di dati

A questo punto è possibile creare le classi delle entità per l'applicazione di Contoso University. Si inizierà con le tre entità seguenti:

Corso-Iscrizione-Studente<><>

Entità	Relationship
Corso per la registrazione	Uno-a-molti
Studente alla registrazione	Uno-a-molti

Esiste una relazione uno-a-molti tra le entità Student e Enrollment ed esiste una relazione uno-a-molti tra le entità Course e Enrollment. In altre parole, uno studente può iscriversi a un numero qualsiasi di corsi e un corso può avere un numero qualsiasi di studenti iscritti.

Nelle sezioni seguenti si creerà una classe per ognuna di queste entità.

Nota

Se si tenta di compilare il progetto prima di completare la creazione di tutte queste classi di entità, si otterranno errori del compilatore.

Entità Student (Studente)

Nella cartella Models creare un file di classe denominato Student.cs facendo clic con il pulsante destro del mouse sulla cartella in Esplora soluzioni e scegliendo Aggiungi>classe. Sostituire il codice del modello con il codice seguente:

using System;
using System.Collections.Generic;

namespace ContosoUniversity.Models
{
    public class Student
    {
        public int ID { get; set; }
        public string LastName { get; set; }
        public string FirstMidName { get; set; }
        public DateTime EnrollmentDate { get; set; }
        
        public virtual ICollection<Enrollment> Enrollments { get; set; }
    }
}

La proprietà ID diventa la colonna di chiave primaria della tabella di database che corrisponde a questa classe. Per impostazione predefinita, Entity Framework interpreta una proprietà denominata ID o classname ID come chiave primaria.

La proprietà Enrollments rappresenta una proprietà di navigazione. Le proprietà di navigazione contengono altre entità correlate a questa entità. In questo caso, la Enrollments proprietà di un'entità Student conterrà tutte le Enrollment entità correlate a tale Student entità. In altre parole, se una determinata Student riga nel database ha due righe correlate Enrollment (righe che contengono il valore della chiave primaria dello studente nella colonna StudentID chiave esterna), la Student proprietà di navigazione dell'entità Enrollments conterrà queste due Enrollment entità.

Le proprietà di navigazione vengono in genere definite in virtual modo che possano sfruttare determinate funzionalità di Entity Framework, ad esempio il caricamento differita. (Il caricamento differita verrà spiegato più avanti, nel Esercitazione sulla lettura dei dati correlati più avanti in questa serie.

Se una proprietà di navigazione può contenere più entità (come nel caso di relazioni molti-a-molti e uno-a-molti), il tipo della proprietà deve essere un elenco in cui le voci possono essere aggiunte, eliminate e aggiornate, come ad esempio ICollection.

Entità Enrollment (Iscrizione)

Nella cartella Models creare Enrollment.cs e sostituire il codice esistente con il codice seguente:

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; }
        public Grade? Grade { get; set; }
        
        public virtual Course Course { get; set; }
        public virtual Student Student { get; set; }
    }
}

La EnrollmentID proprietà sarà la chiave primaria. Questa entità usa il modello classname ID anziché ID da solo come si è visto nell'entità Student . In genere si sceglie un criterio e lo si usa poi in tutto il modello di dati. In questo caso la variazione illustra che è possibile sia uno sia l'altro criterio. In un'esercitazione successiva si vedrà come usare ID senza classname semplificare l'implementazione dell'ereditarietà nel modello di dati.

La Grade proprietà è un'enumerazione. Il punto interrogativo dopo la dichiarazione del tipo Grade indica che la proprietà Gradeammette i valori Null. Un grado null è diverso da un grado zero. Null significa che un grado non è noto o non è ancora stato assegnato.

La proprietà StudentID è una chiave esterna e la proprietà di navigazione corrispondente è Student. Un'entità Enrollment è associata a un'entità Student, pertanto la proprietà può contenere un'unica entità Student, a differenza della proprietà di navigazione Student.Enrollments vista in precedenza, che può contenere più entità Enrollment.

La proprietà CourseID è una chiave esterna e la proprietà di navigazione corrispondente è Course. Un'entità Enrollment è associata a un'entità Course.

Entity Framework interpreta una proprietà come proprietà di chiave esterna se è denominata nome della proprietà> della proprietà di navigazione della><chiave primaria (ad esempio, StudentID per la Student proprietà di navigazione perché la Student chiave primaria dell'entità è ID).< Le proprietà della chiave esterna possono anche essere denominate con lo stesso nome> della <proprietà della chiave primaria, ad esempio perché CourseID la Course chiave primaria dell'entità è CourseID.

Entità Course (Corso)

Nella cartella Models creare Course.cs, sostituendo il codice del modello con il codice seguente:

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

namespace ContosoUniversity.Models
{
    public class Course
    {
        [DatabaseGenerated(DatabaseGeneratedOption.None)]
        public int CourseID { get; set; }
        public string Title { get; set; }
        public int Credits { get; set; }
        
        public virtual ICollection<Enrollment> Enrollments { get; set; }
    }
}

La proprietà Enrollments rappresenta una proprietà di navigazione. È possibile correlare un'entità Course a un numero qualsiasi di entità Enrollment.

In questa serie verranno fornite altre informazioni sull'attributo DatabaseGeneratedAttribute in un'esercitazione successiva. In pratica, questo attributo consente di immettere la chiave primaria per il corso invece di essere generata dal database.

Creare il contesto di database

La classe principale che coordina la funzionalità di Entity Framework per un determinato modello di dati è la classe di contesto del database. Per creare questa classe, derivare dalla classe System.Data.Entity.DbContext . Nel codice specificare le entità incluse nel modello di dati. È anche possibile personalizzare un determinato comportamento di Entity Framework. In questo progetto la classe è denominata SchoolContext.

Per creare una cartella nel progetto ContosoUniversity, fare clic con il pulsante destro del mouse sul progetto in Esplora soluzioni e scegliere Aggiungi, quindi fare clic su Nuova cartella. Assegnare alla nuova cartella il nome DAL (per Livello di accesso ai dati). In tale cartella creare un nuovo file di classe denominato SchoolContext.cs e sostituire il codice del modello con il codice seguente:

using ContosoUniversity.Models;
using System.Data.Entity;
using System.Data.Entity.ModelConfiguration.Conventions;

namespace ContosoUniversity.DAL
{
    public class SchoolContext : DbContext
    {
    
        public SchoolContext() : base("SchoolContext")
        {
        }
        
        public DbSet<Student> Students { get; set; }
        public DbSet<Enrollment> Enrollments { get; set; }
        public DbSet<Course> Courses { get; set; }

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();
        }
    }
}

Specificare i set di entità

Questo codice crea una proprietà DbSet per ogni set di entità. Nella terminologia di Entity Framework un set di entità corrisponde in genere a una tabella di database e un'entità corrisponde a una riga nella tabella.

Nota

È possibile omettere le DbSet<Enrollment> istruzioni e DbSet<Course> e funzionerebbe allo stesso modo. Entity Framework li include in modo implicito perché l'entità Student fa riferimento all'entità Enrollment e l'entità Enrollment fa riferimento all'entità Course .

Specificare il stringa di connessione

Il nome del stringa di connessione (che verrà aggiunto al file Web.config in un secondo momento) viene passato al costruttore.

public SchoolContext() : base("SchoolContext")
{
}

È anche possibile passare il stringa di connessione stesso anziché il nome di uno archiviato nel file Web.config. Per altre informazioni sulle opzioni per specificare il database da usare, vedere Stringhe di connessione e modelli.

Se non si specifica un stringa di connessione o il nome di uno in modo esplicito, Entity Framework presuppone che il nome stringa di connessione corrisponda al nome della classe. Il nome stringa di connessione predefinito in questo esempio sarà SchoolContext, uguale a quello specificato in modo esplicito.

Specificare nomi di tabella singolari

L'istruzione modelBuilder.Conventions.Remove nel metodo OnModelCreating impedisce che i nomi delle tabelle vengano pluralizzati. In caso contrario, le tabelle generate nel database saranno denominate Students, Coursese Enrollments. I nomi delle tabelle saranno Studentinvece , Coursee Enrollment. Gli sviluppatori non hanno un'opinione unanime sul fatto che i nomi di tabella debbano essere pluralizzati oppure no. Questa esercitazione usa il formato singolare, ma il punto importante è che è possibile selezionare qualsiasi modulo preferito includendo o omettendo questa riga di codice.

Inizializzare il database con dati di test

Entity Framework può creare (o eliminare e ricreare) automaticamente un database quando viene eseguita l'applicazione. È possibile specificare che questa operazione deve essere eseguita ogni volta che l'applicazione viene eseguita o solo quando il modello non è sincronizzato con il database esistente. È anche possibile scrivere un Seed metodo che Entity Framework chiama automaticamente dopo aver creato il database per popolarlo con i dati di test.

Il comportamento predefinito consiste nel creare un database solo se non esiste e generare un'eccezione se il modello è stato modificato e il database esiste già. In questa sezione si specifica che il database deve essere eliminato e ricreato ogni volta che il modello cambia. L'eliminazione del database causa la perdita di tutti i dati. Questo problema è in genere corretto durante lo sviluppo, perché il Seed metodo verrà eseguito quando il database viene ricreato e creerà nuovamente i dati di test. Ma in produzione in genere non si vogliono perdere tutti i dati ogni volta che è necessario modificare lo schema del database. Successivamente si vedrà come gestire le modifiche del modello usando Migrazioni Code First per modificare lo schema del database invece di eliminare e creare nuovamente il database.

Nella cartella DAL creare un nuovo file di classe denominato SchoolInitializer.cs e sostituire il codice del modello con il codice seguente, che determina la creazione di un database quando necessario e carica i dati di test nel nuovo database.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Data.Entity;
using ContosoUniversity.Models;

namespace ContosoUniversity.DAL
{
    public class SchoolInitializer : System.Data.Entity. DropCreateDatabaseIfModelChanges<SchoolContext>
    {
        protected override void Seed(SchoolContext context)
        {
            var students = new List<Student>
            {
            new Student{FirstMidName="Carson",LastName="Alexander",EnrollmentDate=DateTime.Parse("2005-09-01")},
            new Student{FirstMidName="Meredith",LastName="Alonso",EnrollmentDate=DateTime.Parse("2002-09-01")},
            new Student{FirstMidName="Arturo",LastName="Anand",EnrollmentDate=DateTime.Parse("2003-09-01")},
            new Student{FirstMidName="Gytis",LastName="Barzdukas",EnrollmentDate=DateTime.Parse("2002-09-01")},
            new Student{FirstMidName="Yan",LastName="Li",EnrollmentDate=DateTime.Parse("2002-09-01")},
            new Student{FirstMidName="Peggy",LastName="Justice",EnrollmentDate=DateTime.Parse("2001-09-01")},
            new Student{FirstMidName="Laura",LastName="Norman",EnrollmentDate=DateTime.Parse("2003-09-01")},
            new Student{FirstMidName="Nino",LastName="Olivetto",EnrollmentDate=DateTime.Parse("2005-09-01")}
            };

            students.ForEach(s => context.Students.Add(s));
            context.SaveChanges();
            var courses = new List<Course>
            {
            new Course{CourseID=1050,Title="Chemistry",Credits=3,},
            new Course{CourseID=4022,Title="Microeconomics",Credits=3,},
            new Course{CourseID=4041,Title="Macroeconomics",Credits=3,},
            new Course{CourseID=1045,Title="Calculus",Credits=4,},
            new Course{CourseID=3141,Title="Trigonometry",Credits=4,},
            new Course{CourseID=2021,Title="Composition",Credits=3,},
            new Course{CourseID=2042,Title="Literature",Credits=4,}
            };
            courses.ForEach(s => context.Courses.Add(s));
            context.SaveChanges();
            var enrollments = new List<Enrollment>
            {
            new Enrollment{StudentID=1,CourseID=1050,Grade=Grade.A},
            new Enrollment{StudentID=1,CourseID=4022,Grade=Grade.C},
            new Enrollment{StudentID=1,CourseID=4041,Grade=Grade.B},
            new Enrollment{StudentID=2,CourseID=1045,Grade=Grade.B},
            new Enrollment{StudentID=2,CourseID=3141,Grade=Grade.F},
            new Enrollment{StudentID=2,CourseID=2021,Grade=Grade.F},
            new Enrollment{StudentID=3,CourseID=1050},
            new Enrollment{StudentID=4,CourseID=1050,},
            new Enrollment{StudentID=4,CourseID=4022,Grade=Grade.F},
            new Enrollment{StudentID=5,CourseID=4041,Grade=Grade.C},
            new Enrollment{StudentID=6,CourseID=1045},
            new Enrollment{StudentID=7,CourseID=3141,Grade=Grade.A},
            };
            enrollments.ForEach(s => context.Enrollments.Add(s));
            context.SaveChanges();
        }
    }
}

Il Seed metodo accetta l'oggetto contesto di database come parametro di input e il codice nel metodo usa tale oggetto per aggiungere nuove entità al database. Per ogni tipo di entità, il codice crea una raccolta di nuove entità, le aggiunge alla proprietà appropriata DbSet e quindi salva le modifiche nel database. Non è necessario chiamare il SaveChanges metodo dopo ogni gruppo di entità, come avviene qui, ma ciò consente di individuare l'origine di un problema se si verifica un'eccezione durante la scrittura del codice nel database.

Per indicare a Entity Framework di usare la classe di inizializzatore, aggiungere un elemento all'elemento entityFramework nel file Web.config dell'applicazione (quello nella cartella del progetto radice), come illustrato nell'esempio seguente:
```
<entityFramework>
  <contexts>
    <context type="ContosoUniversity.DAL.SchoolContext, ContosoUniversity">
      <databaseInitializer type="ContosoUniversity.DAL.SchoolInitializer, ContosoUniversity" />
    </context>
  </contexts>
  <defaultConnectionFactory type="System.Data.Entity.Infrastructure.LocalDbConnectionFactory, EntityFramework">
    <parameters>
      <parameter value="v11.0" />
    </parameters>
  </defaultConnectionFactory>
  <providers>
    <provider invariantName="System.Data.SqlClient" type="System.Data.Entity.SqlServer.SqlProviderServices, EntityFramework.SqlServer" />
  </providers>
</entityFramework>
```
context type Specifica il nome completo della classe di contesto e l'assembly in cui si trova e databaseinitializer type specifica il nome completo della classe di inizializzatore e l'assembly in cui si trova. Quando non si vuole che Entity Framework usi l'inizializzatore, è possibile impostare un attributo sull'elemento context : disableDatabaseInitialization="true".) Per altre informazioni, vedere Impostazioni del file di configurazione.

Un'alternativa all'impostazione dell'inizializzatore nel file Web.config consiste nell'aggiungerlo nel codice aggiungendo un'istruzione Database.SetInitializer al Application_Start metodo nel file Global.asax.cs. Per altre informazioni, vedere Informazioni sugli inizializzatori di database in Entity Framework Code First.

L'applicazione è ora configurata in modo che quando si accede al database per la prima volta in una determinata esecuzione dell'applicazione, Entity Framework confronta il database con il modello ( SchoolContext le classi di entità e ). In caso di differenza, l'applicazione elimina e ricrea il database.

Nota

Quando si distribuisce un'applicazione in un server Web di produzione, è necessario rimuovere o disabilitare il codice che elimina e ricrea il database. Questa operazione verrà eseguita in un'esercitazione successiva di questa serie.

Configurare EF 6 per l'uso di LocalDB

LocalDB è una versione leggera del motore di database di SQL Server Express. È facile installare e configurare, avvia su richiesta ed esegue in modalità utente. LocalDB viene eseguito in una modalità di esecuzione speciale di SQL Server Express che consente di usare i database come file .mdf . È possibile inserire i file di database LocalDB nella cartella App_Data di un progetto Web se si vuole poter copiare il database con il progetto. La funzionalità dell'istanza utente in SQL Server Express consente anche di usare i file di .mdf, ma la funzionalità dell'istanza utente è deprecata. È pertanto consigliabile usare LocalDB per l'uso di file .mdf. LocalDB viene installato per impostazione predefinita con Visual Studio.

In genere, SQL Server Express non viene usato per le applicazioni Web di produzione. LocalDB in particolare non è consigliato per l'uso di produzione con un'applicazione Web perché non è progettato per funzionare con IIS.

In questa esercitazione si userà LocalDB. Aprire il file Web.config dell'applicazione e aggiungere un connectionStrings elemento che precede l'elemento appSettings , come illustrato nell'esempio seguente. Assicurarsi di aggiornare File Web.config nella cartella del progetto radice. Esiste anche un file Web.config nella sottocartella Views che non è necessario aggiornare.

<connectionStrings>
    <add name="SchoolContext" connectionString="Data Source=(LocalDb)\MSSQLLocalDB;Initial Catalog=ContosoUniversity1;Integrated Security=SSPI;" providerName="System.Data.SqlClient"/>
</connectionStrings>
<appSettings>
  <add key="webpages:Version" value="3.0.0.0" />
  <add key="webpages:Enabled" value="false" />
  <add key="ClientValidationEnabled" value="true" />
  <add key="UnobtrusiveJavaScriptEnabled" value="true" />
</appSettings>

Il stringa di connessione aggiunto specifica che Entity Framework userà un database LocalDB denominato ContosoUniversity1.mdf. Il database non esiste ancora, ma EF lo creerà. Se si desidera creare il database nella cartella App_Data, è possibile aggiungere AttachDBFilename=|DataDirectory|\ContosoUniversity1.mdf al stringa di connessione. Per altre informazioni sulle stringa di connessione, vedere Stringhe di connessione di SQL Server per applicazioni Web di ASP.NET.

Non è effettivamente necessario un stringa di connessione nel file Web.config. Se non si specifica un stringa di connessione, Entity Framework usa un stringa di connessione predefinito basato sulla classe di contesto. Per altre informazioni, vedere Code First in un nuovo database.

Creare controller e visualizzazioni

A questo punto si creerà una pagina Web per visualizzare i dati. Il processo di richiesta dei dati attiva automaticamente la creazione del database. Si inizierà creando un nuovo controller. Ma prima di eseguire questa operazione, compilare il progetto per rendere disponibili lo scaffolding del modello e del contesto per il controller MVC.

Fare clic con il pulsante destro del mouse sulla cartella Controllers in Esplora soluzioni, scegliere Aggiungi e quindi fare clic su Nuovo elemento con scaffolding.
Nella finestra di dialogo Aggiungi scaffolding selezionare Controller MVC 5 con visualizzazioni, usando Entity Framework e quindi scegliere Aggiungi.
Nella finestra di dialogo Aggiungi controller effettuare le selezioni seguenti e quindi scegliere Aggiungi:
- Classe modello: Student (ContosoUniversity.Models). Se questa opzione non viene visualizzata nell'elenco a discesa, compilare il progetto e riprovare.
- Classe contesto dati: SchoolContext (ContosoUniversity.DAL).
- Nome controller: StudentController (non StudentsController).
- Lasciare invariati i valori predefiniti negli altri campi.
  
  Quando si fa clic su Aggiungi, lo scaffolder crea un file StudentController.cs e un set di visualizzazioni (file con estensione cshtml ) che funzionano con il controller. In futuro, quando si creano progetti che usano Entity Framework, è anche possibile sfruttare alcune funzionalità aggiuntive dello scaffolder: creare la prima classe di modello, non creare un stringa di connessione e quindi nella casella Aggiungi controller specificare Nuovo contesto dati selezionando il + pulsante accanto alla classe Contesto dati. Lo scaffolder creerà la DbContext classe e il stringa di connessione, nonché il controller e le visualizzazioni.

Visual Studio apre il file Controllers\StudentController.cs . Si noterà che è stata creata una variabile di classe che crea un'istanza di un oggetto contesto di database:

private SchoolContext db = new SchoolContext();

Il Index metodo di azione ottiene un elenco di studenti dal set di entità Students leggendo la Students proprietà dell'istanza del contesto di database:

public ViewResult Index()
{
    return View(db.Students.ToList());
}

La visualizzazione Student\Index.cshtml visualizza questo elenco in una tabella:

<table>
    <tr>
        <th>
            @Html.DisplayNameFor(model => model.LastName)
        </th>
        <th>
            @Html.DisplayNameFor(model => model.FirstMidName)
        </th>
        <th>
            @Html.DisplayNameFor(model => model.EnrollmentDate)
        </th>
        <th></th>
    </tr>

@foreach (var item in Model) {
    <tr>
        <td>
            @Html.DisplayFor(modelItem => item.LastName)
        </td>
        <td>
            @Html.DisplayFor(modelItem => item.FirstMidName)
        </td>
        <td>
            @Html.DisplayFor(modelItem => item.EnrollmentDate)
        </td>
        <td>
            @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>
}

Premere CTRL+F5 per eseguire il progetto. Se viene visualizzato un errore "Impossibile creare copia shadow", chiudere il browser e riprovare.

Fare clic sulla scheda Students (Studenti ) per visualizzare i dati di test inseriti dal Seed metodo . A seconda della larghezza della finestra del browser, verrà visualizzato il collegamento della scheda Student nella barra degli indirizzi superiore oppure sarà necessario fare clic sull'angolo superiore destro per visualizzare il collegamento.

Visualizzare il database

Quando è stata eseguita la pagina Students e l'applicazione ha tentato di accedere al database, EF ha rilevato che non c'era un database e ne è stato creato uno. Entity Framework ha quindi eseguito il metodo di inizializzazione per popolare il database con i dati.

È possibile usare Esplora server o SQL Server Esplora oggetti (SSOX) per visualizzare il database in Visual Studio. Per questa esercitazione si userà Esplora server.

Chiudere il browser.
In Esplora server espandere Connessioni dati (potrebbe essere necessario selezionare prima il pulsante di aggiornamento), espandere Contesto dell'istituto di istruzione (ContosoUniversity) e quindi espandere Tabelle per visualizzare le tabelle nel nuovo database.
Fare clic con il pulsante destro del mouse sulla tabella Student e scegliere Mostra dati tabella per visualizzare le colonne create e le righe inserite nella tabella.
Chiudere la connessione Esplora server .

I file di database ContosoUniversity1.mdf e ldf si trovano nella cartella %USERPROFILE%.

Poiché si usa l'inizializzatore DropCreateDatabaseIfModelChanges , è ora possibile apportare una modifica alla Student classe , eseguire di nuovo l'applicazione e il database verrà ricreato automaticamente in modo che corrisponda alla modifica. Ad esempio, se si aggiunge una EmailAddress proprietà alla Student classe, eseguire di nuovo la pagina Students e quindi esaminare di nuovo la tabella, verrà visualizzata una nuova EmailAddress colonna.

Convenzioni

La quantità di codice da scrivere affinché Entity Framework sia in grado di creare un database completo per l'utente è minimo a causa di convenzioni o presupposti creati da Entity Framework. Alcuni di essi sono già stati annotati o sono stati usati senza essere a conoscenza di essi:

Le forme pluralizzate dei nomi delle classi di entità vengono usate come nomi di tabella.
I nomi della proprietà di entità vengono usati come nomi di colonna.
Le proprietà di entità denominate ID o classname ID vengono riconosciute come proprietà della chiave primaria.
Una proprietà viene interpretata come una proprietà di chiave esterna se è denominata nome della proprietà di navigazione nome><della proprietà> chiave primaria (ad esempio, StudentID per la Student proprietà di navigazione perché la Student chiave primaria dell'entità è ID).< Le proprietà della chiave esterna possono anche essere denominate con lo stesso nome della <proprietà della chiave primaria, ad esempio perché EnrollmentID la Enrollment chiave primaria dell'entità è EnrollmentID.>

Si è visto che le convenzioni possono essere sostituite. Ad esempio, è stato specificato che i nomi delle tabelle non devono essere pluralizzati e successivamente si vedrà come contrassegnare in modo esplicito una proprietà come proprietà di chiave esterna.

Ottenere il codice

Scaricare il progetto completato

Risorse aggiuntive

Per altre informazioni su EF 6, vedere gli articoli seguenti:

Passaggi successivi

In questa esercitazione:

Creazione di un'app Web MVC
Impostare lo stile del sito
Entity Framework 6 installato
Creare il modello di dati
Creare il contesto del database
Inizializzare il database con dati di test
Configurare EF 6 per l'uso di LocalDB
Creare controller e visualizzazioni
Visualizzare il database

Passare all'articolo successivo per informazioni su come esaminare e personalizzare il codice di creazione, lettura, aggiornamento, eliminazione (CRUD) nei controller e nelle visualizzazioni.

Implementare funzionalità CRUD di base

Condividi tramite

Esercitazione: Introduzione a Entity Framework 6 Code First con MVC 5

Prerequisiti

Creare un'app Web MVC

Impostare lo stile del sito

Installare Entity Framework 6

Creare il modello di dati

Entità Student (Studente)

Entità Enrollment (Iscrizione)

Entità Course (Corso)

Creare il contesto di database

Specificare i set di entità

Specificare il stringa di connessione

Specificare nomi di tabella singolari

Inizializzare il database con dati di test

Configurare EF 6 per l'uso di LocalDB

Creare controller e visualizzazioni

Visualizzare il database

Convenzioni

Ottenere il codice

Risorse aggiuntive

Passaggi successivi

Commenti e suggerimenti

Risorse aggiuntive