Créer un modèle de classe avec Entity Framework (C #)

Cet article est la traduction la plus fidèle possible de l'article original : Creating Model Classes with the Entity Framework (C#)

Le but de ce tutoriel est d'expliquer comment vous pouvez créer des classes d'accès aux données en utilisant Microsoft Entity Framework lors du développement d'une application ASP.NET MVC. Ce tutoriel ne nécessite aucune connaissance du Microsoft Entity Framework. A la fin de ce tutorial, vous serez capable d'utiliser l'Entity Framework pour la sélection, création, mise à jour et suppression de données en base de données.

Le Microsoft Entity Framework est un outil de Mapping Objet Relationnel (OR/M) qui vous permet la génération automatique d'une couche d'accès aux données à partir d'une base de données. L'Entity Framework vous permet ainsi d'éviter le travail fastidieux de création à la main de vos classes d'accès aux données.

Afin d'illustrer comment vous pouvez utiliser le Microsoft Entity Framework avec ASP.NET MVC, nous construirons une simple application d'exemple. Nous créerons une application de gestion de films qui permet d'afficher et éditer les films de votre base de données

Ce tutorial suppose que vous avez Visual Studio 2008 ou Visual Web Developer 2008 avec le Service Pack 1. Le Service Pack 1 est nécessaire pour pouvoir utiliser l'Entity Framework. Vous pouvez télécharger le Service Pack 1 de Visual Studio 2008 or de Visual Web Developper 2008 à partir de l'adresse suivante :

http://www.asp.net/downloads/

Il n'y a aucun lien fondamental entre ASP.NET MVC et le Microsoft Entity Framework. Il existe de nombreuses alternatives pour utiliser l'Entity Framework avec ASP.NET MVC. Par exemple, vous pouvez construire votre modèle de classes MVC en utilisant d'autres outils d'OR/M comme Microsoft LINQ to SQL, NHibernate ou SubSonic.

L'application de gestion de films utilise une table de base de données nommée Movies qui contient les colonnes suivantes :

Vous pouvez ajouter cette table à un projet ASP.NET MVC en suivant les étapes ci-dessous :

1. Cliquez-droit sur le répertoire App_Data dans la fenêtre de l'explorateur de solution et sélectionnez Add, NewItem.
2. Dans la boite de dialogue Add New Item, sélectionnez SQL Server Database, donnez comme nom de base de données MoviesDB.mdf et cliquez sur le bouton Add.
3. Double-cliquez sur le fichier MoviesDB.mdf pour ouvrir la fenêtre Server Explorer/Database Explorer.
4. Etendez la connexion à la base de données MoviesDB.mdf, cliquez-droit sur le répertoire Tables et sélectionnez Add New Table.
5. Dans le designer de la table, ajoutez les colonnes Id, Title et Director.
6. Cliquez sur le bouton Save (Il a un icône de disquette) pour sauvegarder la nouvelle table et donnez comme nom Movies.

Après que vous ayez créé la table Movies dans la base de données, vous devez ajouter quelques données bidon à cette même table. Cliquez-droit sur la table Movies and sélectionnez l'option Show Table Data. Vous pourrez ainsi entrer des faux films via le grille qui apparait.

Afin d'utiliser l'Entity Framework, vous avez besoin de créer un Entity Data Model. Vous pouvez tirer profit de Visual Studio Entity Data Model Wizard pour générer automatiquement un Entity Data Model à partir d'une base de données.

Suivez les étapes suivantes :

1. Cliquez-droit sur le répertoire Models dans la fenêtre de l'explorateur de solution et sélectionnez l'option Add, New Item.
2. Dans la boite de dialogue Add New Item, sélectionnez le catégorie Data (voir Figure 1).
3. Sélectionnez le template ADO.NET Entity Data Model, donnez comme nom MoviesDBModel.edmx et cliquez sur le bouton Add. Le clique sur le bouton Add lance le Data Model Wizard.
4. A l'étape Choose Model Contents, choisissez l'option Generate from a database et cliquez sur le bouton Next (voir Figure 2).
5. A l'étape Choose Your Data Connection, sélectionnez la connexion à la base de données MoviesDB.mdf, entrez MoviesDBEntities comme nom de settings pour la connexion aux entités et cliquez sur le bouton Next (voir Figure 3).
6. A l'étape Choose Your Database Objects, sélectionnez la table Movie de la base de données et cliquez sur le bouton Finish (voir Figure 4).

Après avoir complété ces étapes, le designer de ADO.NET Entity Data Model (Entity Designer) s'ouvre.

Après que vous ayez créé un Entity Data Model, vous pouvez modifier le modèle en tirant profit de l'Entity Designer (voir Figure 5). Vous pouvez ouvrir l'Entiry Designer à n'importe quel moment en double cliquant sur le fichier MoviesDBModel.edmx contenu dans le répertoire Models via la fenêtre de l'explorateur de solution.

Par exemple, vous pouvez utiliser l'Entity Designer pour changer les noms de classes que l'Entity Data Model Wizard génère. Le Wizard a créé une nouvelle classe d'accès aux données nommée Movies. En d'autres mots, le Wizard a donné comme nom le même nom que celui de la table en base de données. Etant donné que nous utiliserons cette classe pour représenter une instance précise d'un Movie, nous devons renommer la classe de Movies en Movie.

Si vous voulez renommer une classe d'entité, vous pouvez double-cliquer sur le nom de la classe dans l'Entity Designer et entrer un nouveau nom (voir Figure 6). Sinon, vous pouvez changer le nom de l'entité via la fenêtre des propriétés après avoir sélectionner une entité dans l'Entity Designer.

N'oubliez pas de sauvegarder votre Entity Data Model après avoir effectué une modification en cliquant sur le boutton Save (Il a un icône de disquette). Derrière tout ça, l'Entity Designer génère a ensemble de classes en C#. Vous pouvez visualisez ces classes en ouvrant le fichier MoviesDBModel.Designer.cs à partir de la fenêtre de l'explorateur de solution.

Par contre, ne modifiez pas le code dans le fichier Designer.cs car il sera la prochaine fois que vous utiliserez l'Entity Designer. Si vous voulez étendre les fonctionnalités des classes d'entités définie dans le fichier Designer.cs, vous pouvez créer des classes partielless (partial class) dans des fichiers séparés.

Commençons par construire notre application de gestion de films en créant une page qui affiche une liste de films. Le controlleur Home du listing 1 expose une action nommée Index(). L'action Index() retourne l'ensemble des films depuis la table Movies de la base de données en tirant profit de l'Entity Framework.

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();
        }

    }
}

Notez que le contrôleur du Listing 1 inclut une constructeur. Le constructeur initialise un champ de classe nommé _db. Ce champ _db représente les entités de base de données générées par le Microsoft Entity Framework. Le champ _db est une instance de la classe MoviesDBEntities qui a été générée par l'Entity Designer.

Pour utiliser la classe theMoviesDBEntities au sein du contrôleur Home, vous devez importer l'espace de nom MovieEntityApp.Models (MVCProjectName.Models).

Le champ _db est utilise dans la éethode Index() pour récupérer les enregistrements de la table Movies de la base de données. L'expression _db.MovieSet représente tous les enregistrements de la table Movies de la base de données. La méthode ToList() est utilisée pour convertir l'ensemble des films en une collection générique d'objets Movie (List<Movie>).

Les enregistrements de films sont récupérés avec l'aide de LINQ to Entities. L'action Index() du Listing 1 utilise la method syntax de LINQ pour récupérer l'ensemble des enregistrements de la base de données. Si vous préférez, vous pouvez utiliser la query syntax de LINQ à la place. Les deux instructions suivantes font exactement la même chose :

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

Utilisez la syntaxe LINQ - method syntax ou query syntax - que vous trouvez la plus intuitive. Il n'y a aucune différence de performance entre les deux approches - La seule différence est le style.

La vue du Listing 2 est utilisé pour afficher les enregistrements de films.

<%@ 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 vue du Listing 2 contient une boucle foreach qui itère chaque enregistrement de film et afficher les valeurs des propriétés Title et Director de l'enregistrement film. Notez que les liens Edit et Delete sont affichés après chaque enregistrement. En outre, un lien Add Movie apparait au bas de la page (voir Figure 7).

La vue Index est une vue typée (typed view). La page Index inclut une directive <%@ Page %> avec un attribut Inherits qui convertit la propriété Model en un type générique fortement type, c'est-à-dire une collection List d'objets Movie (List<Movie>).

Vous pouvez utiliser l'Entity Framework pour render plus facile l'insertion de nouveaux enregistrements dans une table de base de données. Listing 3 contient deux nouvelles actions à la classe contrôleur Home que vous pouvez utiliser pour insérer des nouveaux enregistrements dans la table Movie de la base de données.

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

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

    // Désérialisation (Inclus une simple vide !)
    TryUpdateModel(movieToAdd, new string[] { "Title", "Director" }, form.ToValueProvider());

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

    // Si valide, sauvegarde le film dans la base de données
    if (ModelState.IsValid)
    {
        _db.AddToMovieSet(movieToAdd);
        _db.SaveChanges();
        return RedirectToAction("Index");
    }

    // Sinon, réaffiche la page
    return View(movieToAdd);
}

La première action Add() retourne simplement une vue. La vue contient une page pour l'ajout d'un nouveau film dans la base de données (voir Figure 8). Losque vous envoyez la page, la seconde action Add() est invoquée.

Notez que la seconde action Add() est décorée avec un attribute AcceptVerbs. Cette action peut être invoquée uniquement lors d'une opération http POST. En d'autres mots, cette action peut seulement être invoquée quand une page HTML est postée.

La seconde action Add() crée une nouvelle instance de la classe Movie de l'Entity Framework avec l'aide de la méthode TryUpdateModel() de ASP.NET MVC. La méthode TryUpdateModel() prend les champs dans FormCollection passé à la méthode Add() et assigne les valeurs des champs de la page HTML à la classe Movie.

En utilisant l'Entity Framework, vous devez fournir une simple liste de propriétés lorsque vous utilisez les méthodes TryUpdateModel ou UpdateModel pour mettre à jour les propriétés d'une classe d'entité.

Ensuite, l'action Add() realize quelques validation au niveau de la page. L'action vérifie les deux prorpriétés Title et Director ont des valeurs. Si il y a une erreur de validation, un message d'erreur de validation est ajouté au ModelState.

Si il n'y a aucune erreur de validation, un nouvel enregistrement de film est ajouté à la table Movies en base de données avec l'aide de l'Entity Framework. Le nouvel enregistrement est ajouté à la base de données les deux lignes de codes suivantes :

_db.AddToMovieSet(movieToAdd);
_db.SaveChanges();

La première ligne de code ajoute la nouvelle entité Movie à l'ensemble des films qui sont tracés par l'Entity Framework. La seconde ligne de code sauvegarde tous les changements qui ont été fait sur les objets films tracés.

Vous pouvez suivre presque la même approche pour mettre à jour les enregistrements d'une base de données avec l'Entity Framework comme l'approche que nous venons juste de suivre pour la création d'enregistrement en base de données. Listing 4 contient deux nouvelles actions de contrôleur nommée Edit(). La première action Edit() retourne une page HTML pour éditer un enregistrement de film. La seconde action Edit() tente de mettre à jour la base de données.

public ActionResult Edit(int id)
{
    // Obtient le film à mettre à jour
    var movieToUpdate = _db.MovieSet.First(m => m.Id == id);

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

[AcceptVerbs(HttpVerbs.Post)]
public ActionResult Edit(FormCollection form)
{
    // Obtient le film à mettre à jour
    var id = Int32.Parse(form["id"]);
    var movieToUpdate = _db.MovieSet.First(m => m.Id == id);

    // Désérialise (inclus simple liste !)
    TryUpdateModel(movieToUpdate, new string[] { "Title", "Director" }, form.ToValueProvider());

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

    // Si valide, sauvegarde le film en base de données
    if (ModelState.IsValid)
    {
        _db.SaveChanges();
        return RedirectToAction("Index");
    }

    // Sinon, réaffiche la page
    return View(movieToUpdate);
}

La seconde action Edit() commence par retrouver l'enregistrement Movie en base de données qui correspond à l'Id du film édité. L'instructoion LINQ to Entities suivantes s'empare du premier enregistrement en base de données qui correspond à un Id spécifié :

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

Ensuite, la méthode TryUpdateModel() est utilisé pour assigner les valeurs des champs de la page HTML aux valeurs des propriétés de l'entité film. Notez qu'une simple liste est soumise pour spécifier les propriétés exactes à mettre à jour.

Next, the TryUpdateModel() method is used to assign the values of the HTML form fields to the properties of the movie entity. Notice that a white list is supplied to specify the exact properties to update.

Au final, si il n'y a aucune erreur de validation, la table sous-jacente Movies de la base de données est mise à jour avec tous les changements en appelant la méthode SaveChanges().

Lors de l'édition d'enregistrements de la base de données, vous avez besoin de passer à l'action contrôleur (qui exécute la mise à jour de la base de données) l'Id de l'enregistrement qui est en train d'être édité.

<%@ 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>

La dernière opération de base de données, dont nous avons besoin d'entreprendre dans ce tutoriel, est la suppression d'enregistrements en base de données.

public ActionResult Delete(int id)
{
    // Obtenir le film à supprimer
    var movieToDelete = _db.MovieSet.First(m => m.Id == id);

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

    // Affiche la vue Index
    return RedirectToAction("Index");
}

L'action Delete() récupère en premier lieu l'entité Movie qui correspond à l'Id passé à l'action. Ensuite, le film est supprimé de la base de données en appelant la méthode DeleteObject(). Au final, l'utilisateur est redirigé vers la page Index.

Le but de ce tutorial est de démontrer comment vous pouvez construire une application web de gestion de base de données en tirant profit de ASP.NET MVC et du Microsoft Entity Framework. Vous avez découvert comment construire une application qui permet la selection, creation, mise à jour et suppression d'enregistrement de base de données.

Dans un premier temps, nous avons abordé l'utilisation de l'Entity Data Model Wizard pour générer un Entity Data Model à partir de Visual Studio. Ensuite, nous avons vu comment utiliser LINQ to Entities pour récupérer l'ensemble des enregistrements de la table Movies de la base de données. Au final, nous avons utilisé l'Entity Framework pour créer, mettre à jour et supprimer des enregistrements de base de données.