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

da Microsoft

Questa esercitazione descrive come usare ASP.NET MVC con Microsoft Entity Framework. Si apprenderà come usare la Creazione guidata entità per creare un modello di dati di 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. Questa esercitazione presuppone che non siano disponibili conoscenze precedenti di Microsoft Entity Framework. Alla fine di questa esercitazione si apprenderà come usare Entity Framework per selezionare, inserire, aggiornare ed eliminare i record di database.

Microsoft Entity Framework è uno strumento di mapping relazionale a oggetti (O/RM) che consente di generare automaticamente un livello di accesso ai dati da un database. Entity Framework consente di evitare il lavoro noioso della creazione delle classi di accesso ai dati in base alla mano.

Per illustrare come usare Microsoft Entity Framework con ASP.NET MVC, si creerà un'applicazione di esempio semplice. Verrà creata un'applicazione Database film che consente di visualizzare e modificare i record di database del film.

Questa esercitazione presuppone che Visual Studio 2008 o Visual Web Developer 2008 con Service Pack 1. È necessario Service Pack 1 per usare Entity Framework. È possibile scaricare Visual Studio 2008 Service Pack 1 o Visual Web Developer con Service Pack 1 dall'indirizzo seguente:

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

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 creare le classi del modello MVC usando altri strumenti O/RM, ad esempio Microsoft LINQ to SQL, NHibernate o SubSonic.

Creazione del database di esempio di film

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

Nome colonna	Tipo di dati	Consenti valori Null?	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:

1. Fare clic con il pulsante destro del mouse sulla cartella App_Data nella finestra Esplora soluzioni e selezionare l'opzione di menu Aggiungi, Nuovo elemento.
2. Nella finestra di dialogo Aggiungi nuovo elemento selezionare SQL Server Database, 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 del database MoviesDB.mdf, fare clic con il pulsante destro del mouse sulla cartella Tabelle e selezionare l'opzione di menu Aggiungi nuova tabella.
5. Nella tabella Designer aggiungere le colonne Id, Title e Director.
6. Fare clic sul pulsante Salva (ha l'icona del floppy) per salvare la nuova tabella con il nome Film.

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 Film e selezionare l'opzione di menu 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 procedura guidata di Visual Studio Entity Data Model per generare automaticamente un modello di dati di entità da un database.

Seguire questa procedura:

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

Dopo aver completato questi passaggi, viene aperto Designer ADO.NET Entity Data Model (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 l'entità Designer in qualsiasi momento facendo doppio clic sul file MoviesDBModel.edmx contenuto nella cartella Modelli all'interno della finestra Esplora soluzioni.

Figura 5: ADO.NET modello di dati di entità Designer

Ad esempio, è possibile usare entity Designer per modificare i nomi delle classi generate dalla Creazione guidata dati del modello di entità. 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é verrà usata questa classe per rappresentare un'istanza particolare di Movie, è necessario rinominare la classe da Movies a Movie.

Se si vuole rinominare una classe di entità, è possibile fare doppio clic sul nome della classe nella Designer entity 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à nella Designer entità.

Figura 6 - Modifica di un nome di entità

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

Non modificare il codice nel file Designer.cs perché le modifiche verranno sovrascritte al successivo utilizzo dell'Designer entity. 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 Database film creando una pagina che visualizza un elenco di record di film. Il controller Home in List 1 espone un'azione denominata Index(). L'azione Index() restituisce tutti i record di film della tabella del 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 dall'Designer Entity.

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

Il campo _db viene usato 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, è possibile usare invece 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();

Usare la sintassi LINQ, ovvero la sintassi del metodo o la sintassi di query, 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 dei film.

Listato 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 del film. Si noti che accanto a ogni record viene visualizzato un collegamento Modifica ed Elimina. Inoltre, nella parte inferiore della visualizzazione viene visualizzato un collegamento Aggiungi filmato (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 un insieme List generico fortemente tipizzato di oggetti Movie (List<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 di database Movie.

Listato 3 : Controllers\HomeController.cs (Add methods)

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 di database 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 fornire un elenco di proprietà "safelist" 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 dei moduli. 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, alla tabella di database Movies viene aggiunto un nuovo record filmato 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 rilevati 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 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 : Controllers\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 da modificare. L'istruzione LINQ to Entities seguente recupera il primo record di database corrispondente a un ID specifico:

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

Viene quindi usato il metodo TryUpdateModel() per assegnare i valori dei campi modulo HTML alle proprietà dell'entità movie. Si noti che viene fornito un elenco di elementi attendibili 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 due 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 del 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 del 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, che è necessario affrontare in questa esercitazione, consiste nell'eliminare i record del database. È possibile usare l'azione del controller nell'elenco 6 per eliminare un determinato record di database.

Elenco 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 innanzitutto 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 è illustrare come creare applicazioni Web basate su 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.

In primo luogo, è stato illustrato come usare la Creazione guidata modello di dati di entità 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, Entity Framework è stato usato per inserire, aggiornare ed eliminare record di database.

Avanti