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

Articolo
07/13/2023

Nota

Per un nuovo sviluppo, è consigliabile ASP.NET Core Razor Pages su ASP.NET controller e viste MVC. Per una serie di esercitazioni simili a questa usando Razor Pages, vedere Esercitazione: Introduzione a Razor Pages in ASP.NET Core. 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 dell'università. Con esso è possibile visualizzare e aggiornare le informazioni degli studenti, dei corsi e degli insegnanti. Ecco due delle 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 di applicazione Web ASP.NET (.NET Framework). Assegnare un nome al progetto 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 vengono 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

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

Questo passaggio è uno dei pochi passaggi che questa esercitazione include manualmente, ma che potrebbe essere stata eseguita automaticamente dalla funzionalità di scaffolding MVC ASP.NET. Si sta eseguendo 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 nell'installare automaticamente il pacchetto NuGet EF, creare la classe di contesto del database e creare la 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<->Enrollment-Student<>

Entità	Relazione
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 verrà creata 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 Modelli 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 nome classeID 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 Student determinata riga nel database ha due righe correlate Enrollment (righe che contengono il valore della chiave primaria dello studente nella StudentID colonna chiave esterna), la Student proprietà di spostamento dell'entità Enrollments conterrà queste due Enrollment entità.

Le proprietà di spostamento vengono in genere definite in virtual modo che possano sfruttare determinate funzionalità di Entity Framework, ad esempio il caricamento lazy. Il caricamento lazy verrà spiegato più avanti nell'esercitazione 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 proprietà sarà la chiave primaria. Questa EnrollmentID entità usa il modello di nomeID classe anziché ID se stesso come illustrato 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 livello 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à chiave esterna se il nome><> della proprietà della proprietà di spostamento è nome< della proprietà chiave primaria (ad esempio, StudentID per la proprietà di spostamento poiché la StudentStudent chiave primaria dell'entità è ID). Le proprietà chiave esterna possono essere denominate anche come nome della proprietà> chiave primaria (<ad esempio, CourseID poiché la Course chiave primaria dell'entità è CourseID).

Entità Course (Corso)

Nella cartella Modelli creare Course.cs sostituendo il codice 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.

Altre informazioni sull'attributo DatabaseGeneratedAttribute sono disponibili nell'esercitazione successiva di questa serie. 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 . Questa classe viene creata derivando 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 e quindi fare clic su Nuova cartella. Assegnare un nome alla nuova cartella DAL (per Livello di accesso ai dati). In tale cartella creare un nuovo file di classe denominato SchoolContext.cs e sostituire il codice 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 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 lo stesso funziona. Entity Framework li includerebbe in modo implicito perché l'entità Student fa riferimento all'entità Enrollment e l'entità Enrollment fa riferimento all'entità Course .

Specificare la stringa di connessione

Il nome della stringa di connessione (che si aggiungerà al file Web.config in un secondo momento) viene passato al costruttore.

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

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

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

Specificare nomi di tabella singolari

L'istruzione modelBuilder.Conventions.Remove nel metodo OnModelCreating impedisce che i nomi di tabella vengano pluralizzati. Se non è stata eseguita questa operazione, le tabelle generate nel database saranno denominate Students, Coursese Enrollments. Invece, i nomi delle tabelle saranno Student, 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 modulo singolare, ma il punto importante è che è possibile selezionare il modulo preferito includendo o omettendo questa riga di codice.

Inizializzare il database con dati di test

Entity Framework può creare automaticamente (o eliminare e ricreare) un database per l'utente quando l'applicazione viene eseguita. È 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 è generalmente corretto durante lo sviluppo, perché il metodo verrà eseguito quando il Seed database viene ricreato e creerà nuovamente i dati di test. In produzione in genere non si vuole perdere tutti i dati ogni volta che è necessario modificare lo schema del database. In seguito verrà illustrato come gestire le modifiche del modello usando Migrazioni Code First per modificare lo schema del database invece di eliminare e riprovare il database.

Nella cartella DAL creare un nuovo file di classe denominato SchoolInitializer.cs e sostituire il codice modello con il codice seguente, che causa 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 del 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 al 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 inizializzatore, aggiungere un elemento all'elemento entityFramework nell'applicazione Web.config file (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>
```
Specifica context type il nome completo della classe di contesto e l'assembly in cui si trova e specifica databaseinitializer type il nome completo della classe inizializzatore e l'assembly in cui si trova. Quando non si vuole che EF usi l'inizializzatore, è possibile impostare un attributo sull'elemento context : disableDatabaseInitialization="true".) Per altre informazioni, vedere Impostazioni file di configurazione.

Un'alternativa all'impostazione dell'inizializzatore nel file Web.config consiste nell'eseguirla 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 un'esecuzione specificata dell'applicazione, Entity Framework confronta il database con il modello (le SchoolContext classi e le entità). In caso di differenza, l'applicazione viene eliminata e ricreata 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 in questa serie.

Configurare EF 6 per l'uso di LocalDB

LocalDB è una versione leggera del motore di database 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 con estensione mdf. È possibile inserire i file di database LocalDB nella cartella App_Data di un progetto Web se si vuole essere in grado di copiare il database con il progetto. La funzionalità dell'istanza utente in SQL Server Express consente anche di usare file con estensione mdf, ma la funzionalità dell'istanza utente è deprecata. Di conseguenza, LocalDB è consigliata per l'uso di file con estensione 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 l'uso con IIS.

In questa esercitazione si userà LocalDB. Aprire l'applicazione Web.config file e aggiungere un connectionStrings elemento precedente all'elemento appSettings , come illustrato nell'esempio seguente. Assicurarsi di aggiornare il file diWeb.config nella cartella del progetto radice. Esiste anche un file Web.config nella sottocartella Visualizzazioni 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>

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

Non è effettivamente necessaria una stringa di connessione nel file Web.config . Se non si specifica una stringa di connessione, Entity Framework usa una stringa di connessione predefinita in base alla classe di contesto. Per altre informazioni, vedere Code First to a New Database (Code First to a New 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. Prima di eseguire questa operazione, compilare il progetto per rendere disponibili le classi di modello e contesto per lo scaffolding del controller MVC.

Fare clic con il pulsante destro del mouse sulla cartella Controller in Esplora soluzioni, scegliere Aggiungi e quindi fare clic su Nuovo elemento Scaffolded.
Nella finestra di dialogo Aggiungi Scaffold selezionare Controller MVC 5 con viste, usando Entity Framework e quindi scegliere Aggiungi.
Nella finestra di dialogo Aggiungi controller fare le selezioni seguenti e quindi scegliere Aggiungi:
- Classe Model: Student (ContosoUniversity.Models). Se non viene visualizzata questa opzione nell'elenco a discesa, compilare il progetto e riprovare.
- Classe contesto dati: SchoolContext (ContosoUniversity.DAL).
- Nome del controller: StudentController (non StudentsController ).
- Lasciare i valori predefiniti per gli 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 una stringa di connessione e quindi nella casella Aggiungi controller specificare Nuovo contesto dati selezionando il + pulsante accanto alla classe contesto di dati. Lo scaffolder creerà la DbContext classe e la stringa di connessione, nonché il controller e le viste.

Visual Studio apre il file Controller\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 action 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 del modo in cui si trova la 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 è presente alcun database e ne è stato creato uno. EF 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 aggiorna), 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 base 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 che è necessario 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 loro:

Le forme pluralizzate di nomi di 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 classnameID vengono riconosciute come proprietà della chiave primaria.
Una proprietà viene interpretata come proprietà di chiave esterna se è denominata <nome della proprietà della proprietà di navigazione nome><della proprietà> di chiave primaria , StudentID ad esempio per la Student proprietà di navigazione perché la Student chiave primaria dell'entità è ID. Le proprietà della chiave esterna possono anche essere denominate allo 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 di tabella 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
Installato Entity Framework 6
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 CRUD (Create, Read, Update, Delete) nei controller e nelle visualizzazioni.

Implementare funzionalità CRUD di base

Esercitazione: Introduzione a Entity Framework 6 Code First usando 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 set di entità

Specificare la 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

Commenti e suggerimenti

Risorse aggiuntive