Creazione di classi di modelli con Entity Framework (C#)

di Microsoft

Questa esercitazione illustra come usare ASP.NET MVC con Microsoft Entity Framework. Imparerai a usare lo strumento Creazione guidata entità per creare un modello di dati entità ADO.NET. 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.

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 sia presente 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:

https://www.asp.net/downloads/

Creazione del database di esempio di film

L'applicazione Movie Database usa una tabella di database denominata Movies che contiene le colonne seguenti:

È possibile aggiungere questa tabella a un progetto MVC ASP.NET seguendo questa procedura:

1. 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.
2. Nella finestra di dialogo Aggiungi nuovo elemento selezionare Database DI SQL Server, assegnare al database il nome MoviesDB.mdf e fare clic sul pulsante Aggiungi .
3. Fare doppio clic sul file MoviesDB.mdf per aprire la finestra Esplora server/Esplora database.
4. 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.
5. In Progettazione tabelle aggiungere le colonne ID, Title e Director.
6. 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 Mostra dati tabella. È possibile immettere dati di film falsi 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.

Segui questi passaggi:

1. Fare clic con il pulsante destro del mouse sulla cartella Modelli nella finestra Esplora soluzioni e scegliere l'opzione di menu Aggiungi, Nuovo elemento.
2. Nella finestra di dialogo Aggiungi nuovo elemento selezionare la categoria Dati (vedere la figura 1).
3. Selezionare il modello di dati delle entità ADO.NET, assegnare al modello di dati delle entità il nome MoviesDBModel.edmx e fare clic sul pulsante Aggiungi. Facendo clic sul pulsante Aggiungi si avvia la creazione guidata del modello di dati.
4. Nel passaggio Scegli contenuto modello scegliere l'opzione Genera da un database e fare clic sul pulsante Avanti (vedere la figura 2).
5. 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).
6. Nel passaggio Choose Your Database Objects (Scegli oggetti di database ) selezionare la tabella di database Movie e fare clic sul pulsante Fine (vedere la figura 4).

Dopo aver completato questi passaggi, viene aperto Entity Data Model Designer (Entity Designer) di ADO.NET.

Figura 1: Creazione di un nuovo modello di dati di entità

Figura 2 – Passaggio: Scegliere i contenuti 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 entity data, è possibile modificare il modello sfruttando Entity Designer (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 del Modello di Dati Entità ADO.NET

Ad esempio, è possibile usare Entity Designer per modificare i nomi delle classi generate dall'Entity Model Data Wizard. 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, dovremmo rinominare la classe da Movies a Movie.

Se si vuole 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à nella finestra Proprietà dopo aver selezionato un'entità in Entity Designer.

Figura 6 - Modifica del nome di un'entità

Ricordarsi di salvare Entity Data Model dopo aver apportato una modifica facendo clic sul pulsante Salva (l'icona del disco floppy). In background, Entity Designer genera un set di classi C#. È possibile visualizzare queste classi aprendo il file MoviesDBModel.Designer.cs dalla finestra Esplora soluzioni.

Non modificare il codice nel file Designer.cs perché le modifiche verranno sovrascritte alla successiva utilizzo di Entity Designer. Se si desidera estendere la funzionalità delle classi di entità definite nel file Designer.cs, è possibile creare classi parziali in file separati.

Selezione di record di database con Entity Framework

Iniziamo a creare l'applicazione Movie Database creando una pagina che visualizza un elenco di record cinematografici. Il controller Home nell'elenco 1 espone un'azione denominata Index(). L'azione Index() restituisce tutti i record dei film della tabella di database Movie sfruttando Entity Framework.

Elenco 1 - Controller\HomeController.cs

using System.Linq;
using System.Web.Mvc;
using MovieEntityApp.Models;

namespace MovieEntityApp.Controllers
{
    [HandleError]
    public class HomeController : Controller
    {
        MoviesDBEntities _db;

        public HomeController()
        {
            _db = new MoviesDBEntities();
        }

        public ActionResult Index()
        {
            ViewData.Model = _db.MovieSet.ToList();
            return View();
        }

    }
}

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 da Entity Designer.

Per usare la classeMoviesDBEntities nel controller Home, è necessario importare lo spazio dei nomi MovieEntityApp.Models (MVCProjectName. Modelli).

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 utilizzato per convertire il set di film in una raccolta generica di oggetti Movie (List<Movie>).

I record dei film vengono recuperati con l'aiuto di LINQ to Entities. L'azione Index() nell'elenco 1 usa la sintassi del metodo LINQ per recuperare il set di record di database. Se si preferisce, è invece possibile usare la sintassi delle query LINQ. Le due istruzioni seguenti eseguono la stessa operazione:

ViewData.Model = _db.MovieSet.ToList();
ViewData.Model = (from m in _db.MovieSet select m).ToList();

Usa la sintassi LINQ che trovi più intuitiva, sia essa la sintassi del metodo o quella di query. 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 dei film.

Elenco 2 – Views\Home\Index.aspx

<%@ Page Language="C#"  
  Inherits="System.Web.Mvc.ViewPage<List<MovieEntityApp.Models.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>
    
<% foreach (var m in ViewData.Model)
   { %>

    Title: <%= m.Title %>
    <br />
    Director: <%= m.Director %>
    <br />
    <%= Html.ActionLink("Edit", "Edit", new { id = m.Id })%>
    <%= Html.ActionLink("Delete", "Delete", new { id = m.Id })%>
       
        <hr />
<% } %>

<%= Html.ActionLink("Add Movie", "Add") %>
    
    </div>
</body>
</html>

La visualizzazione nell'elenco 2 contiene un ciclo foreach che scorre ogni record di film e visualizza i valori delle proprietà Title e Director del record cinematografico. Si noti che accanto a ogni record viene visualizzato un collegamento Modifica ed Eliminazione. Inoltre, un collegamento Aggiungi filmato viene visualizzato nella parte inferiore della visualizzazione (vedere la figura 7).

Figura 7 : visualizzazione Indice

La vista Indice è una vista tipizzata. La visualizzazione Indice include una direttiva <%@ Page %> con un attributo Inherits che esegue il cast della proprietà Model in una raccolta generica List tipizzata di oggetti Movie (List<Movie).

Inserimento di record nel 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 di database Movie.

Elenco 3 : Controller\HomeController.cs (aggiungi metodi)

public ActionResult Add()
{
    return View();
}

[AcceptVerbs(HttpVerbs.Post)]
public ActionResult Add(FormCollection form)
{
    var movieToAdd = new Movie();

    // Deserialize (Include white list!)
    TryUpdateModel(movieToAdd, new string[] { "Title", "Director" }, form.ToValueProvider());

    // Validate
    if (String.IsNullOrEmpty(movieToAdd.Title))
        ModelState.AddModelError("Title", "Title is required!");
    if (String.IsNullOrEmpty(movieToAdd.Director))
        ModelState.AddModelError("Director", "Director is required!");

    // If valid, save movie to database
    if (ModelState.IsValid)
    {
        _db.AddToMovieSet(movieToAdd);
        _db.SaveChanges();
        return RedirectToAction("Index");
    }

    // Otherwise, reshow form
    return View(movieToAdd);
}

La prima azione Add() restituisce semplicemente una visualizzazione. La vista contiene un modulo per l'aggiunta di un nuovo record del database dei film (vedere la figura 8). Quando si invia il modulo, viene richiamata la seconda azione Add().

Si noti che la seconda azione Add() è 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 in FormCollection passati al metodo Add() e assegna i valori di questi campi modulo HTML alla classe Movie.

Quando si usa Entity Framework, è necessario specificare un elenco "safelist" 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 dei 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, alla tabella di database Movies viene aggiunto un nuovo record film 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 tutte le modifiche apportate ai film rilevati nel database sottostante.

Figura 8 : La visualizzazione Aggiungi

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 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.cs (metodi di modifica)

public ActionResult Edit(int id)
{
    // Get movie to update
    var movieToUpdate = _db.MovieSet.First(m => m.Id == id);

    ViewData.Model = movieToUpdate;
    return View();
}

[AcceptVerbs(HttpVerbs.Post)]
public ActionResult Edit(FormCollection form)
{
    // Get movie to update
    var id = Int32.Parse(form["id"]);
    var movieToUpdate = _db.MovieSet.First(m => m.Id == id);

    // Deserialize (Include white list!)
    TryUpdateModel(movieToUpdate, new string[] { "Title", "Director" }, form.ToValueProvider());

    // Validate
    if (String.IsNullOrEmpty(movieToUpdate.Title))
        ModelState.AddModelError("Title", "Title is required!");
    if (String.IsNullOrEmpty(movieToUpdate.Director))
        ModelState.AddModelError("Director", "Director is required!");

    // If valid, save movie to database
    if (ModelState.IsValid)
    {
        _db.SaveChanges();
        return RedirectToAction("Index");
    }

    // Otherwise, reshow form
    return View(movieToUpdate);
}

La seconda azione Edit() inizia recuperando il record Movie dal database che corrisponde all'ID del film modificato. L'istruzione LINQ to Entities seguente recupera il primo record di database che corrisponde a un ID specifico:

var movieToUpdate = _db.MovieSet.First(m => m.Id == id);

Il metodo TryUpdateModel() viene quindi 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 delle 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 Movies sottostante viene aggiornata con eventuali modifiche chiamando il metodo SaveChanges().

Quando si modificano i record di database, è necessario passare l'ID del record da modificare all'azione del controller che esegue l'aggiornamento del database. In caso contrario, l'azione del controller non saprà quale record 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 – Views\Home\Edit.aspx

<%@ Page Language="C#" 
  Inherits="System.Web.Mvc.ViewPage<MovieEntityApp.Models.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>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, da affrontare in questa esercitazione, consiste nell'eliminare i record di database. È possibile usare l'azione del controller nell'elenco 6 per eliminare un record di database specifico.

Elenco del codice 6 -- \Controllers\HomeController.cs (azione di eliminazione)

public ActionResult Delete(int id)
{
    // Get movie to delete
    var movieToDelete = _db.MovieSet.First(m => m.Id == id);

    // Delete 
    _db.DeleteObject(movieToDelete);
    _db.SaveChanges();

    // Show Index view
    return RedirectToAction("Index");
}

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.

Sommario

Lo scopo di questa esercitazione è illustrare come creare applicazioni Web basate su database sfruttando ASP.NET MVC e Microsoft Entity Framework. Si è appreso come compilare un'applicazione che consente di selezionare, inserire, aggiornare ed eliminare record di database.

Per prima cosa, abbiamo discusso di come utilizzare la Creazione guidata del modello di dati di entità per generare un modello di dati di entità all'interno di 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 record di database.