Nota
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare ad accedere o modificare le directory.
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare a modificare le directory.
di Microsoft
Questa esercitazione illustra come usare ASP.NET MVC con Microsoft Entity Framework. Si apprenderà come usare la Creazione guidata entità per creare un ADO.NET Entity Data Model. Nel corso di questa esercitazione viene creata un'applicazione Web che illustra come selezionare, inserire, aggiornare ed eliminare i dati del database usando Entity Framework.
L'obiettivo di questa esercitazione è spiegare come creare classi di accesso ai dati usando Microsoft Entity Framework durante la compilazione di un'applicazione MVC ASP.NET. In questa esercitazione non si presuppone alcuna conoscenza precedente di Microsoft Entity Framework. Al termine di questa esercitazione si apprenderà come usare Entity Framework per selezionare, inserire, aggiornare ed eliminare record di database.
Microsoft Entity Framework è uno strumento O/RM (Object Relational Mapping) che consente di generare automaticamente un livello di accesso ai dati da un database. Entity Framework consente di evitare il lavoro noioso di compilazione manuale delle classi di accesso ai dati.
Nota
Non esiste alcuna connessione essenziale tra ASP.NET MVC e Microsoft Entity Framework. Esistono diverse alternative a Entity Framework che è possibile usare con ASP.NET MVC. Ad esempio, è possibile compilare le classi del modello MVC usando altri strumenti O/RM, ad esempio Microsoft LINQ to SQL, NHibernate o SubSonic.
Per illustrare come usare Microsoft Entity Framework con ASP.NET MVC, verrà creata una semplice applicazione di esempio. Verrà creata un'applicazione Movie Database che consente di visualizzare e modificare i record del database dei film.
Questa esercitazione presuppone che si disponga di Visual Studio 2008 o Visual Web Developer 2008 con Service Pack 1. Per usare Entity Framework, è necessario Service Pack 1. È possibile scaricare Visual Studio 2008 Service Pack 1 o Visual Web Developer con Service Pack 1 dall'indirizzo seguente:
Creazione del database di esempio di film
L'applicazione Movie Database usa una tabella di database denominata Movies contenente le colonne seguenti:
| Nome colonna | Tipo di dati | Consenti valori Null? | La chiave primaria è? |
|---|---|---|---|
| ID | INT | False | True |
| Titolo | nvarchar(100) | False | Falso |
| Responsabile | nvarchar(100) | False | Falso |
È possibile aggiungere questa tabella a un progetto MVC ASP.NET seguendo questa procedura:
- Fare clic con il pulsante destro del mouse sulla cartella App_Data nella finestra Esplora soluzioni e scegliere l'opzione di menu Aggiungi, Nuovo elemento.
- Nella finestra di dialogo Aggiungi nuovo elemento selezionare SQL Server Database, assegnare al database il nome MoviesDB.mdf e fare clic sul pulsante Aggiungi.
- Fare doppio clic sul file MoviesDB.mdf per aprire la finestra Esplora server/Esplora database.
- Espandere la connessione al database MoviesDB.mdf, fare clic con il pulsante destro del mouse sulla cartella Tabelle e scegliere l'opzione di menu Aggiungi nuova tabella.
- Nella Designer Tabella aggiungere le colonne Id, Title e Director.
- Fare clic sul pulsante Salva (con l'icona del floppy) per salvare la nuova tabella con il nome Movies.
Dopo aver creato la tabella di database Movies, è necessario aggiungere alcuni dati di esempio alla tabella. Fare clic con il pulsante destro del mouse sulla tabella Movies e scegliere l'opzione di menu Mostra dati tabella. È possibile immettere dati falsi sui film nella griglia visualizzata.
Creazione del modello di dati di entità ADO.NET
Per usare Entity Framework, è necessario creare un modello di dati di entità. È possibile sfruttare la Creazione guidata modello di dati di entità di Visual Studio per generare automaticamente un modello di dati di entità da un database.
Seguire questa procedura:
- Fare clic con il pulsante destro del mouse sulla cartella Models nella finestra Esplora soluzioni e scegliere l'opzione di menu Aggiungi, Nuovo elemento.
- Nella finestra di dialogo Aggiungi nuovo elemento selezionare la categoria Dati (vedere la figura 1).
- Selezionare il modello Entity Data Model ADO.NET , assegnare a Entity Data Model il nome MoviesDBModel.edmx e fare clic sul pulsante Aggiungi . Facendo clic sul pulsante Aggiungi viene avviata la Creazione guidata modello di dati.
- Nel passaggio Scegli contenuto modello scegliere l'opzione Genera da un database e fare clic sul pulsante Avanti (vedere la figura 2).
- Nel passaggio Scegli connessione dati selezionare la connessione al database MoviesDB.mdf, immettere il nome delle impostazioni di connessione delle entità MoviesDBEntities e fare clic sul pulsante Avanti (vedere la figura 3).
- Nel passaggio Scegliere gli oggetti di database selezionare la tabella del database Movie e fare clic sul pulsante Fine (vedere la figura 4).
Dopo aver completato questi passaggi, viene aperto il Designer entity data model ADO.NET (Entity Designer).
Figura 1: Creazione di un nuovo modello di dati di entità
Figura 2- Scegliere il passaggio contenuto del modello
Figura 3: scegliere la connessione dati
Figura 4: scegliere gli oggetti di database
Modifica del modello di dati di entità ADO.NET
Dopo aver creato un modello di dati di entità, è possibile modificare il modello sfruttando l'Designer entità (vedere la figura 5). È possibile aprire Entity Designer in qualsiasi momento facendo doppio clic sul file MoviesDBModel.edmx contenuto nella cartella Models all'interno della finestra Esplora soluzioni.
Figura 5: Designer ADO.NET Entity Data Model
Ad esempio, è possibile usare entity Designer per modificare i nomi delle classi generate dalla Creazione guidata dati di Entity Model. La procedura guidata ha creato una nuova classe di accesso ai dati denominata Movies. In altre parole, la procedura guidata ha assegnato alla classe lo stesso nome della tabella di database. Poiché useremo questa classe per rappresentare una particolare istanza movie, è necessario rinominare la classe da Movies a Movie.
Per rinominare una classe di entità, è possibile fare doppio clic sul nome della classe in Entity Designer e immettere un nuovo nome (vedere la figura 6). In alternativa, è possibile modificare il nome di un'entità nel Finestra Proprietà dopo aver selezionato un'entità nel Designer entità.
Figura 6: Modifica del nome di un'entità
Ricordarsi di salvare Entity Data Model dopo aver apportato una modifica facendo clic sul pulsante Salva (icona del disco floppy). In background, Entity Designer genera un set di classi .NET di Visual Basic. È possibile visualizzare queste classi aprendo MoviesDBModel. file Designer.vb dalla finestra Esplora soluzioni.
Non modificare il codice nel file Designer.vb perché le modifiche verranno sovrascritte al successivo utilizzo del Designer entità. Se si desidera estendere la funzionalità delle classi di entità definite nel file Designer.vb, è possibile creare classi parziali in file separati.
Selezione di record di database con Entity Framework
Per iniziare a creare l'applicazione Movie Database, creare una pagina in cui è visualizzato un elenco di record di film. Il controller Home nell'elenco 1 espone un'azione denominata Index(). L'azione Index() restituisce tutti i record di film della tabella di database Movie sfruttando Entity Framework.
Elenco 1: Controllers\HomeController.vb
<HandleError()> _
Public Class HomeController
Inherits System.Web.Mvc.Controller
Private _db As MoviesDBEntities
Public Sub New()
_db = New MoviesDBEntities()
End Sub
Public Function Index()
ViewData.Model = _db.MovieSet.ToList()
Return View()
End Function
End Class
Si noti che il controller nell'elenco 1 include un costruttore. Il costruttore inizializza un campo a livello di classe denominato _db. Il campo _db rappresenta le entità di database generate da Microsoft Entity Framework. Il campo _db è un'istanza della classe MoviesDBEntities generata dal Designer Entity.
Il campo _db viene utilizzato all'interno dell'azione Index() per recuperare i record dalla tabella di database Movies. Espressione _db. MovieSet rappresenta tutti i record della tabella di database Movies. Il metodo ToList() viene usato per convertire il set di film in una raccolta generica di oggetti Movie: List( Of Movie).
I record del film vengono recuperati con l'aiuto di LINQ to Entities. L'azione Index() in List 1 usa la sintassi del metodo LINQ per recuperare il set di record di database. Se si preferisce, è possibile usare invece la sintassi della query LINQ. Le due istruzioni seguenti fanno la stessa cosa:
ViewData.Model = _db.MovieSet.ToList()
ViewData.Model = (from m in _db.MovieSet select m).ToList()
Usare la sintassi LINQ, sintassi del metodo o sintassi della query, che è più intuitiva. Non esiste alcuna differenza nelle prestazioni tra i due approcci: l'unica differenza è lo stile.
La visualizzazione nell'elenco 2 viene usata per visualizzare i record del film.
Presentazione 2 : Views\Home\Index.aspx
<%@ Page Language="VB"
Inherits="System.Web.Mvc.ViewPage(Of List(Of MvcApplication1.Movie))" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
<title>Index</title>
</head>
<body>
<div>
<% For Each m In Model%>
Title: <%= m.Title %>
<br />
Director: <%= m.Director %>
<br />
<%=Html.ActionLink("Edit", "Edit", New With {.id = m.Id})%>
<%=Html.ActionLink("Delete", "Delete", New With {.id = m.Id})%>
<hr />
<% Next%>
<%= Html.ActionLink("Add Movie", "Add") %>
</div>
</body>
</html>
La visualizzazione nell'elenco 2 contiene un ciclo For Each che esegue l'iterazione di ogni record di film e visualizza i valori delle proprietà Title e Director del record del film. Si noti che un collegamento Modifica ed Eliminazione viene visualizzato accanto a ogni record. Inoltre, un collegamento Aggiungi filmato viene visualizzato nella parte inferiore della visualizzazione (vedere la figura 7).
Figura 7 - Visualizzazione indice
La visualizzazione Indice è una visualizzazione tipizzata. La vista Indice include una direttiva %@ Page %> che include un <attributo Eredita. L'attributo Eredita esegue il cast della proprietà ViewData.Model in un insieme List generico fortemente tipizzato di oggetti Movie, ovvero List(Of Movie).
Inserimento di record di database con Entity Framework
È possibile usare Entity Framework per semplificare l'inserimento di nuovi record in una tabella di database. L'elenco 3 contiene due nuove azioni aggiunte alla classe controller Home che è possibile usare per inserire nuovi record nella tabella del database Movie.
Elenco 3 - Controller\HomeController.vb (Aggiungi metodi)
<HandleError()> _
Public Class HomeController
Inherits System.Web.Mvc.Controller
Public Function Add()
Return View()
End Function
<AcceptVerbs(HttpVerbs.Post)> _
Public Function Add(ByVal form As FormCollection)
Dim movieToAdd As New Movie()
' Deserialize (Include white list!)
TryUpdateModel(movieToAdd, New String() {"Title", "Director"}, form.ToValueProvider())
' Validate
If String.IsNullOrEmpty(movieToAdd.Title) Then
ModelState.AddModelError("Title", "Title is required!")
End If
If String.IsNullOrEmpty(movieToAdd.Director) Then
ModelState.AddModelError("Director", "Director is required!")
End If
' If valid, save movie to database
If (ModelState.IsValid) Then
_db.AddToMovieSet(movieToAdd)
_db.SaveChanges()
Return RedirectToAction("Index")
End If
' Otherwise, reshow form
Return View(movieToAdd)
End Function
End Class
La prima azione Add() restituisce semplicemente una visualizzazione. La vista contiene un modulo per l'aggiunta di un nuovo record di database del film (vedere la figura 8). Quando si invia il modulo, viene richiamata la seconda azione Add().
Si noti che la seconda azione Add() viene decorata con l'attributo AcceptVerbs. Questa azione può essere richiamata solo quando si esegue un'operazione HTTP POST. In altre parole, questa azione può essere richiamata solo quando si pubblica un modulo HTML.
La seconda azione Add() crea una nuova istanza della classe Entity Framework Movie con l'aiuto del metodo ASP.NET MVC TryUpdateModel(). Il metodo TryUpdateModel() accetta i campi nel metodo FormCollection passato al metodo Add() e assegna i valori di questi campi di modulo HTML alla classe Movie.
Quando si usa Entity Framework, è necessario specificare un "elenco sicuro" di proprietà quando si usano i metodi TryUpdateModel o UpdateModel per aggiornare le proprietà di una classe di entità.
Successivamente, l'azione Add() esegue una semplice convalida del modulo. L'azione verifica che le proprietà Title e Director abbiano valori. Se si verifica un errore di convalida, viene aggiunto un messaggio di errore di convalida a ModelState.
Se non sono presenti errori di convalida, viene aggiunto un nuovo record di film alla tabella di database Movies con l'aiuto di Entity Framework. Il nuovo record viene aggiunto al database con le due righe di codice seguenti:
_db.AddToMovieSet(movieToAdd)
_db.SaveChanges()
La prima riga di codice aggiunge la nuova entità Movie al set di film monitorati da Entity Framework. La seconda riga di codice salva le modifiche apportate ai film rilevati nel database sottostante.
Figura 8 - Aggiungi visualizzazione
Aggiornamento dei record di database con Entity Framework
È possibile seguire quasi lo stesso approccio per modificare un record di database con Entity Framework come approccio appena seguito per inserire un nuovo record di database. L'elenco 4 contiene due nuove azioni del controller denominate Edit(). La prima azione Edit() restituisce un modulo HTML per la modifica di un record di film. La seconda azione Edit() tenta di aggiornare il database.
Elenco 4 - Controller\HomeController.vb (Metodi di modifica)
<HandleError()> _
Public Class HomeController
Inherits System.Web.Mvc.Controller
Public Function Edit(ByVal id As Integer)
' Get movie to update
Dim movieToUpdate As Movie = _db.MovieSet.First(Function(m) m.Id = id)
ViewData.Model = movieToUpdate
Return View()
End Function
<AcceptVerbs(HttpVerbs.Post)> _
Public Function Edit(ByVal form As FormCollection)
' Get movie to update
Dim id As Integer = Integer.Parse(form("id"))
Dim movieToUpdate As Movie = _db.MovieSet.First(Function(m) m.Id = id)
' Deserialize (Include white list!)
TryUpdateModel(movieToUpdate, New String() {"Title", "Director"}, form.ToValueProvider)
' Validate
If String.IsNullOrEmpty(movieToUpdate.Title) Then
ModelState.AddModelError("Title", "Title is required!")
End If
If String.IsNullOrEmpty(movieToUpdate.Director) Then
ModelState.AddModelError("Director", "Director is required!")
End If
' If valid, save movie to database
If (ModelState.IsValid) Then
_db.SaveChanges()
Return RedirectToAction("Index")
End If
' Otherwise, reshow form
Return View(movieToUpdate)
End Function
End Class
La seconda azione Edit() inizia recuperando il record movie dal database che corrisponde all'ID del filmato modificato. L'istruzione LINQ to Entities seguente recupera il primo record di database corrispondente a un id specifico:
Dim movieToUpdate As Movie = _db.MovieSet.First(Function(m) m.Id = id)
Successivamente, il metodo TryUpdateModel() viene usato per assegnare i valori dei campi del modulo HTML alle proprietà dell'entità film. Si noti che viene fornito un elenco sicuro per specificare le proprietà esatte da aggiornare.
Successivamente, viene eseguita una semplice convalida per verificare che le proprietà Movie Title e Director abbiano valori. Se una proprietà manca un valore, viene aggiunto un messaggio di errore di convalida a ModelState e ModelState.IsValid restituisce il valore false.
Infine, se non sono presenti errori di convalida, la tabella di database Film sottostante viene aggiornata con eventuali modifiche chiamando il metodo SaveChanges().
Quando si modificano i record di database, è necessario passare l'ID del record modificato all'azione controller che esegue l'aggiornamento del database. In caso contrario, l'azione del controller non conosce il record da aggiornare nel database sottostante. La visualizzazione Modifica, contenuta nell'elenco 5, include un campo modulo nascosto che rappresenta l'ID del record di database da modificare.
Elenco 5 - Visualizzazioni\Home\Edit.aspx
<%@ Page Language="VB" Inherits="System.Web.Mvc.ViewPage(Of MvcApplication1.Movie)" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
<head id="Head1" runat="server">
<title>Edit</title>
<style type="text/css">
.input-validation-error
{
background-color:Yellow;
}
</style>
</head>
<body>
<div>
<h1>Edit Movie</h1>
<form method="post" action="/Home/Edit">
<!-- Include Hidden Id -->
<%= Html.Hidden("id") %>
Title:
<br />
<%= Html.TextBox("title") %>
<br /><br />
Director:
<br />
<%= Html.TextBox("director") %>
<br /><br />
<input type="submit" value="Edit Movie" />
</form>
</div>
</body>
</html>
Eliminazione di record di database con Entity Framework
L'operazione finale del database, che è necessario affrontare in questa esercitazione, elimina i record di database. È possibile usare l'azione del controller nell'elenco 6 per eliminare un record di database specifico.
Elenco 6 -- \Controller\HomeController.vb (azione Delete)
<HandleError()> _
Public Class HomeController
Inherits System.Web.Mvc.Controller
Public Function Delete(ByVal id As Integer)
' Get movie to delete
Dim movieToDelete As Movie = _db.MovieSet.First(Function(m) m.Id = id)
' Delete
_db.DeleteObject(movieToDelete)
_db.SaveChanges()
' Show Index view
Return RedirectToAction("Index")
End Function
End Class
L'azione Delete() recupera prima l'entità Movie che corrisponde all'ID passato all'azione. Successivamente, il filmato viene eliminato dal database chiamando il metodo DeleteObject() seguito dal metodo SaveChanges(). Infine, l'utente viene reindirizzato alla visualizzazione Indice.
Riepilogo
Lo scopo di questa esercitazione è stato illustrare come creare applicazioni Web basate sul database sfruttando ASP.NET MVC e Microsoft Entity Framework. Si è appreso come creare un'applicazione che consente di selezionare, inserire, aggiornare ed eliminare record di database.
Prima di tutto, è stato illustrato come usare la Creazione guidata modello di entità dati per generare un modello di dati di entità da Visual Studio. Si apprenderà quindi come usare LINQ to Entities per recuperare un set di record di database da una tabella di database. Infine, è stato usato Entity Framework per inserire, aggiornare ed eliminare i record di database.