Création d'une application CRUD avec WebMatrix, Razor et Entity Framework

Hinault Romaric DONFACK

Cet article fournit une démarche pas à pas pour mettre sur pied une application Web CRUD robuste avec WebMatrix, Razor et Entity Framework.
Commentez

- Titre : Création d'une application CRUD avec WebMatrix, Razor et Entity Framework

- Auteur : Hinault Romaric DONFACK

- Parution : 2 mai 2012

- Licence : Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright ® 26 mars 2012 Hinault Romaric. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. Droits de diffusion permanents accordés à Developpez LLC.

Sommaire

- I. Introduction

- II. Description des outils utilisés

- II-A. WebMatrix

- II-B. Razor

- II-C. SQL Server Compact Edition

- II-D. Entity Framework

- II-E. NuGet

- III. Création de l'application

- IV. Installation d'Entity Framework

- V. Définition du modèle objet

- VI. Création du DBContext

- VII. Création du Repository

- VIII. Implémentation des fonctionnalités CRUD

- VIII-A. Fonctionnalités CRUD pour la table Personnes

- VIII-A-1. Implémentation de la grille des données

- VIII-A-2. Affichage détaillé

- VIII-A-3. Enregistrement des données

- VIII-A-4. Modification

- VIII-A-5. Suppression

- VIII-B. Fonctionnalités CRUD pour la table Organismes

- VIII-C. Fonctionnalités CRUD pour la table Affiliations

- VIII-C-1. Implémentation de la grille

- VIII-C-2. Affichage détaillé

- VIII-C-3. Enregistrement

- VIII-C-4. Modification

- VIII-C-5. Suppression

- IX. Conclusion

- X. Remerciements

- XI. Liens

- XII. Sources

I - Introduction

J'ai eu à développer récemment une application CRUD avec WebMatrix. Utilisant principalement la classe DataBase de l'espace de nom Microsoft.Data pour la manipulation des données, lorsque j'ai aperçu Entity Framework dans les packages NuGet avec WebMatrix 2 bêta, je me suis dit "génial" ! Ça veut dire que je peux l'utiliser dans ma solution.

J'ai donc opté pour l'utilisation de la bibliothèque au sein de mon application WebMatrix. Entity Framework est en passe de devenir un standard pour la manipulation des données et est recommandé par Microsoft.

Contrairement à Visual Studio et ASP.NET ou l'on dispose de plusieurs outils rendant facile la conception d'une application CRUD avec Entity Framework, sur WebMatrix, c'est un peu compliqué et l'on ne dispose pas des fonctionnalités comme l'échafaudage, et encore moins des ressources sur Internet.

C'est pourquoi j'ai décidé de fournir au travers de cet article une démarche pas à pas avec autant de détails que possible pour la conception d'une application CRUD avec WebMatrix, Razor et Entity Framework.

Le lecteur, tout au long de ce tutoriel, pourra se familiariser avec WebMatrix, Razor, Entity Framework, le gestionnaire de packages open source .NET NuGet pour WebMatrix et le gestionnaire de base de données SQL Server Compact Edition.

Cet article est essentiellement destiné aux débutants. Aucun prérequis n'est donc nécessaire pour sa bonne compréhension. Il est néanmoins préférable d'avoir des connaissances de base en programmation orientée objet avec C# et d'être familiarisé avec WebMatrix et Razor. Si ce n'est pas le cas, je vous conseille de lire dans un premier temps mon tutoriel de présentation de WebMatrix, ainsi que mon tutoriel sur Razor.

II - Description des outils utilisés

II-A - WebMatrix

Pour rappel, WebMatrix est un environnement de développement Web léger (15 Mo) développé par Microsoft, efficace et surtout gratuit. Il permet aux développeurs Web de créer et de gérer des applications Web sur la plate-forme Windows qui resteront compatibles avec les produits Microsoft Visual Studio, SQL Server ou encore PHP sur Windows.

On pourra lire à ce sujet mon tutoriel sur la présentation de WebMatrix.

Pour cet article, nous utiliserons la bêta de WebMatrix 2, qui est la version la plus récente de l'environnement de développement Web.

Son installation est assez simple et se fait via Windows Installer. L'outil installe automatiquement SQL Server Compact Edition et WebPages 2 Developer Preview, sur lequel reposent les pages Web ASP.NET écrites avec WebMatrix.

II-B - Razor

Razor a été conçu pour faciliter la conception des pages ASP.NET. Il introduit une syntaxe de programmation assez facilement compréhensible, qui vous permet d'insérer du code serveur dans une page Web qui peut également contenir du HTML, du CSS et des scripts JavaScript.

Le moteur Razor est fluide, compact, expressif et s'appuie sur la syntaxe des langages .NET C# et Visual Basic .NET. Il offre la puissance d'ASP.NET pour la création rapide d'applications Web fonctionnelles et sophistiquées.

On pourra lire à ce sujet mon tutoriel sur la présentation de Razor

WebMatrix 2 bêta installe la Developer Preview de WebPages 2, qui apporte plusieurs améliorations à la première version du moteur Razor.

II-C - SQL Server Compact Edition

SQL Server Compact Edition est un gestionnaire de base de données relationnelle gratuit, mis au point par Microsoft pour le développement des applications pouvant s'exécuter sur des ordinateurs de bureau et des dispositifs mobiles.

SQL Server Compact partage un modèle de programmation commun avec différentes éditions de SQL Server, qui permet aux développeurs de créer des applications natives et managées. SQL Server Compact fournit des fonctionnalités de base de données relationnelle : une source de données fiable, un processeur d'optimisation des requêtes et des possibilités de connectivité fiables et évolutives.

La prise en charge du développement pour SQL Server Compact est fournie par Visual Studio et également par WebMatrix. L'environnement intègre un éditeur graphique permettant de créer, modifier, exécuter des requêtes et administrer une base de données SQL Server Compact.

La version installée avec WebMatrix 2 bêta est la 4.0.

II-D - Entity Framework

De plus en plus, les développeurs préfèrent utiliser des données comme des objets, au lieu d'utiliser les requêtes SQL pour interroger directement la base de données. Entity Framework est un ORM (object-relational mapping ) permettant aux développeurs de créer des applications d'accès aux données en programmant par rapport à un modèle d'application conceptuel au lieu de programmer directement par rapport à un schéma de stockage relationnel. L'objectif est de diminuer la quantité de code et les besoins en maintenance pour les applications orientées objet.

Plusieurs approches peuvent être utilisées avec Entity Framework pour accéder aux données. Dans notre cas, c'est l'approche Code First qui sera utilisée.

Celle-ci permet de définir tout d'abord les objets dans le code, et ensuite d'utiliser EF pour créer la base de données correspondante.

La version d'Entity Framework utilisée pour cet article est la 4.2.

II-E - NuGet

NuGet est un gestionnaire de packages .NET open source. Il est disponible comme une extension pour les environnements de développement .NET Visual Studio, SharpDevelop, et est intégré par défaut dans la version 2 de WebMatrix. Il fournit au développeur une meilleure expérience pour la gestion des packages et dépendances, et élimine presque tous les défis d'intégration d'une bibliothèque tierce open source ou gratuite dans un projet .NET.

On pourra lire à ce sujet mon article sur la présentation de NuGet.

III - Création de l'application

Maintenant que nous nous sommes familiarisés avec les différents outils que nous allons utiliser, nous pouvons procéder à la création de notre application.

Pour cela, vous allez d'abord lancer WebMatrix. Dans la fenêtre de démariage rapide, vous allez sélectionner Modèles (Templates) parmi les différentes options qui sont proposées.

Dans la fenêtre qui va s'afficher, sélectionnez le modèle de projet Site de démarrage (Starter Site), renseignez le nom du site (WebMatrixCRUDApp) et cliquez enfin pour le bouton OK.

Le modèle Site de démarrage contient par défaut une interface à onglet et des fonctionnalités d'authentification.

Une fois le projet créé, vous pouvez voir les éléments suivants dans la fenêtre d'exploration, en sélectionnant l'espace de travail Files dans la zone de sélection d'espace de travail.

IV - Installation d'Entity Framework

Dans la boite d'outils, vous allez cliquer sur le bouton "Gallery" ayant le logo de NuGet. Dans la fenêtre des packages qui s'affichent par défaut, sélectionnez "Entity Framework" comme l'illustre l'image ci-dessous :

La fenêtre du gestionnaire de packages NuGet s'affiche avec les détails sur le package que vous souhaitez installer.

Cliquez sur le bouton "Install" et acceptez les termes d'utilisation pour que NuGet procède au téléchargement et à l'installation d'Entity Framework dans votre application :

Le fichier EntityFramework.dll sera alors ajouté dans le dossier bin de votre application et une référence à l'espace de nom System.Data.Entity sera automatiquement ajoutée au fichier Web.config.

V - Définition du modèle objet

Notre exemple simple portera sur une petite application pour la gestion du carnet d'adresses d'une entreprise. Celle-ci est composée de plusieurs organismes et un employé peut travailler dans un ou plusieurs organismes.

Le schéma de la base de données que nous allons utiliser est donc le suivant :

De ce schéma, vous allez créer les différentes entités correspondantes. Chaque entité doit être définie comme une classe C# afin d'être compréhensible par Entity Framework.

Vous allez créer un nouveau dossier "App_code" en faisant un clic droit sur votre projet dans l'explorateur de solution et en cliquant sur "New Folder".

Sélectionnez ce dossier et ajoutez-y un nouveau fichier C# en cliquant sur le bouton "New" de la boite d'outils et ensuite sur la commande "New File".

Dans la fenêtre qui va s'afficher, sélectionnez le type de fichier Class(C#), renseignez le nom du fichier (Personne.cs) et validez sur OK.

Ajoutez par la suite les lignes de code suivantes dans ce fichier pour définir la classe Personne :

public partial class Personne
{

public int PersonneId { get; set;}
public string Nom {get; set;}
public string Prenom {get; set;}

}

Procédez de même pour le fichier Organisme.cs, dont la classe aura la définition suivante :

public partial class Organisme
{

public int OrganismeId { get; set;}
public string Nom {get; set;}
public string Adresse {get; set;}
public string Telephone {get; set;}
}

Créez également la classe Affiliation qui aura la définition suivante :

public partial class Affiliation
{
public int PersonneId { get; set;}
public int OrganismeId { get; set;}
public string Fonction {get; set;}
public string Email {get; set;}
public string Telephone {get; set;}
}

À ce stade, vous avez simplement défini des entités correspondant au schéma de votre base de données. Cependant, Entity Framework est incapable de définir les relations entre les tables Personne et Affiliation, ainsi qu'entre les tables Organisme et Affiliation.

Pour matérialiser cela, vous allez ajouter une propriété Personne et une propriété Organisme dans la classe Affiliation. La nouvelle définition de cette classe est la suivante :

public partial class Affiliation
{
public int PersonneId { get; set;}
public int OrganismeId { get; set;}
public string Fonction {get; set;}
public string Email {get; set;}
public string Telephone {get; set;}

public virtual Personne Personne {get; set;}
public virtual Organisme Organisme {get; set;}
}

De même, pour matérialiser le fait qu'une Personne peut avoir plusieurs affiliations dans divers organismes et le fait qu'un organisme dispose de plusieurs personnes affiliées, vous allez également ajouter une propriété supplémentaire dans chacune de ces deux tables.

La nouvelle définition de la classe Personne sera donc la suivante :

public partial class Personne
{

public int PersonneId { get; set;}
public string Nom {get; set;}
public string Prenom {get; set;}

public virtual ICollection<Affiliation> Affiliation {get; set;}
}

Et celle de la classe Organisme sera la suivante :

public partial class Organisme
{

public int OrganismeId { get; set;}
public string Nom {get; set;}
public string Adresse {get; set;}
public string Telephone {get; set;}

public virtual ICollection<Affiliation> Affiliation {get; set;}

}

Par défaut, lors de la génération de la base de données correspondant à votre modèle objet, les champs string seront définis par Entity Framework Code First comme des colonnes nvarchar(4000). Pour limiter cette taille, vous allez utiliser l'attribut [MaxLengthAttribute()] de la classe DataAnnotation.

L'attribut [RequiredAttribute] de cette classe sera également utilisé pour définir les propriétés dont les valeurs sont obligatoires. [ScaffoldColumnAttribute] sera utilisé pour spécifier que la clé primaire doit être auto-increment. Enfin, vous allez définir l'attribut [KeyAttribute] pour spécifier les clés étrangères et les tables auxquelles ces clés sont liées.

Le code complet du fichier Personne.cs sera donc le suivant :

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Web;

/// <summary>
/// Summary description for ClassName
/// </summary>
public partial class Personne
{
[ScaffoldColumnAttribute(false)]
public int PersonneId { get; set;}
[MaxLengthAttribute(50)]
[RequiredAttribute]
public string Nom {get; set;}
[MaxLengthAttribute(50)]
[RequiredAttribute]
public string Prenom {get; set;}

public virtual ICollection<Affiliation> Affiliation {get; set;}

}

Celui du fichier Organisme.cs est le suivant :

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Web;

/// <summary>
/// Summary description for ClassName
/// </summary>
public partial class Organisme
{
[ScaffoldColumnAttribute(false)]
public int OrganismeId { get; set;}
[MaxLengthAttribute(50)]
[RequiredAttribute]
public string Nom {get; set;}
[MaxLengthAttribute(50)]
[RequiredAttribute]
public string Adresse {get; set;}
[MaxLengthAttribute(50)]
public string Telephone {get; set;}

public virtual ICollection<Affiliation> Affiliation {get; set;}
}

Et enfin, la nouvelle définition du fichier Affiliation.cs est la suivante :

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Web;

/// <summary>
/// Summary description for ClassName
/// </summary>
public partial class Affiliation
{
[KeyAttribute, ForeignKey("Personne"), Column(Order = 0)]
public int PersonneId { get; set;}
[KeyAttribute, ForeignKey("Organisme"), Column(Order = 1)]
public int OrganismeId { get; set;}
[MaxLengthAttribute(50)]
[RequiredAttribute]
public string Fonction {get; set;}
[MaxLengthAttribute(50)]
public string Email {get; set;}
[MaxLengthAttribute(50)]
public string Telephone {get; set;}

public virtual Personne Personne {get; set;}
public virtual Organisme Organisme {get; set;}
}

VI - Création du DBContext

Nous allons maintenant créer la classe qui va s'occuper de gérer la communication entre les classes entités et la base de données. Cette classe va hériter de la classe DbContext.

La classe DbContext expose les fonctionnalités les plus couramment utilisées pour interroger et puis utiliser les données d'entités en tant qu'objets.

Vous allez ajouter au dossier App_Code un nouveau fichier de classe ayant pour nom "WebMatrixCrudApp.Context.cs".

Dans ce fichier, vous allez ajouter une nouvelle classe "WebMatrixCrudAppContext" qui hérite de DbContext.

Cette classe doit contenir trois attributs DbSet fortement typés correspondants à vos différentes entités. Les attributs DbSet vont permettre de gérer la correspondance avec les tables de la base de données.

Dans ce fichier, vous aurez le code suivant :

using System;
using System.Data.Entity;

/// <summary>
/// Summary description for ClassName
/// </summary>
public class WebMatrixCrudAppContext : DbContext
{
public DbSet<Personne> Personnes { get; set; }
public DbSet<Organisme> Organismes {get; set; }
public DbSet<Affiliation> Affiliations {get; set; }

}

La prochaine étape sera l'ajout de la chaine de connexion pour le mode Code First d'Entity Framework dans le fichier Web.config.

Pour cela, double-cliquez sur le fichier Web.config dans l'explorateur de solution et ajoutez les lignes de code suivantes à celui-ci :

connectionStrings>
<add name="WebMatrixCrudAppContext" connectionString="Data Source=|DataDirectory|WebMatrixCrudApp.sdf"
providerName="System.Data.SqlServerCe.4.0" />
</connectionStrings>

Le nom de la chaine de connexion doit être celui de votre classe DbContext (WebMatrixCrudAppContext)

Le fichier XML de configuration de votre application doit ressembler à ceci :

<?xml version="1.0" encoding="utf-8"?>
<configuration>
<system.web>
<compilation>
<assemblies>
<add assembly="System.Data.Entity, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
<add assembly="System.ComponentModel.DataAnnotations, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
</assemblies>
</compilation>
</system.web>
<connectionStrings>
<add name="WebMatrixCrudAppContext" connectionString="Data Source=|DataDirectory|WebMatrixCrudApp.sdf"
providerName="System.Data.SqlServerCe.4.0" />
</connectionStrings>
</configuration>

Procédez à l'exécution de votre application en cliquant sur le bouton "Run" et sélectionnez le navigateur de votre choix dans la boite d'outils.

La base de données SQL Server Compact "WebMatrixCrudApp.sdf" sera automatiquement créée dans le dossier App_data de votre application. En sélectionnant l'espace de données Databases, vous pouvez constater qu'une nouvelle base de données a été ajoutée à votre application.

En observant cette base de données, vous vous rendez compte que les tables qui ont été créées correspondent aux propriétés DbSet de la classe WebMatrixCrudAppContext.

On remarque également que la taille des colonnes Nom et Prenom, par exemple, de la table Personnes est la même que celle que vous avez défini dans la classe Personne avec l'attribut [MaxLengthAttribute(50)].

En sélectionnant la table Affiliations et en cliquant sur la commande View de la zone Relationships, vous constatez également que les relations de clés étrangères qui ont été définies pour la classe Affiliation ont été créées.

En cliquant sur la relation Affiliation_Organisme, par exemple, vous obtenez le résultat suivant :

Une table supplémentaire EdmMataData a été ajoutée dans votre base de données. Cette table permet à Entity Framework Code First de savoir si le modèle utilisé pour créer une base de données est le même que celui qui est utilisé pour accéder à cette base de données (avec la version 4.3 d'EF cette table n'est plus créée).

Dans le cas où vous apportez des modifications à votre modèle objet, lors de l'exécution de l'application, une exception sera levée.

Pour corriger cela, vous allez ajouter les lignes de code suivantes dans le fichier _AppStart qui se trouve à la racine de votre application :

@using DB = System.Data.Entity;
@{

DB.Database.SetInitializer(new DB.DropCreateDatabaseIfModelChanges<WebMatrixCrudAppContext>());
}

En cas de modification du modèle objet lors de l'exécution de l'application, ces lignes de code vont permettre de régénérer la base de données qui correspondra au nouveau modèle.

Attention, la base de données sera créée à nouveau. Toutes les données présentes dans celle-ci seront donc perdues !

VII - Création du Repository

Les bonnes pratiques de développement avec Entity Framework recommandent l'utilisation d'un Repository pour les opérations CRUD. Le Repository permet de créer une couche d'abstraction entre la couche d'accès aux données et la logique métier de l'application, et éviter ainsi une dépendance entre la base de données et la logique métier.

Le code du Repository permettant d'effectuer des opérations CRUD sur l'entité Personne est le suivant :

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Entity;
using System.Web;

/// <summary>
/// Summary description for ClassName
/// </summary>
public class PersonneRepository
{
private WebMatrixCrudAppContext _context = new WebMatrixCrudAppContext();

public Personne Find(int id)
{
return _context.Personnes.Find(id);
}

public List<Personne> GetAll()
{
return _context.Personnes.ToList();

}

public void Add(Personne personne)

{
_context.Personnes.Add(personne);
_context.SaveChanges();
}

public void Update(Personne personne)
{
_context.Entry(personne).State = EntityState.Modified;
_context.SaveChanges();

}

public void Remove(Personne personne)
{
_context.Personnes.Remove(personne);
_context.SaveChanges();
}
}

Ce code doit être ajouté dans un fichier PersonneRepository.cs dans le dossier App_Code. Créez de même les Repository pour les entités Organisme et Affiliation respectivement dans les fichiers OrganismeRepository.cs et AffiliationRepository.cs.

La fonction Find() pour AffiliationRepository doit prendre deux valeurs en paramètre. Le code doit ressembler à ceci :

public Affiliation Find(int personneId, int organismeId)
{
return _context.Affiliations.Find(personneId, organismeId);
}

VIII - Implémentation des fonctionnalités CRUD

Maintenant que vous avez achevé, avec l'installation d'Entity Framework, la création de votre modèle objet, la génération de la base de données et la définition du DataContext permettant de gérer la communication entre votre modèle objet et votre base de données : vous pouvez vous concentrer sur l'implémentation des interfaces Web pour la lecture, la modification, la suppression et l'enregistrement des données dans votre base de données.

Vous allez commencer par la table Personnes.

VIII-A - Fonctionnalités CRUD pour la table Personnes

Vous allez dans un premier temps créer un nouveau dossier Personne qui contiendra tous les fichiers pour la gestion des personnes.

VIII-A-1 - Implémentation de la grille des données

Dans le dossier Personne, ajoutez un nouveau fichier Index.cshtml.

Vous allez ensuite ajouter en début de ce fichier les lignes de code permettant de retourner la liste des personnes qui sont enregistrées dans la base de données. Cette liste sera par la suite affichée grâce au Helper Razor WebGrid, qui va être instancié en passant en paramètre la collection des données qui doivent être affichées et le nombre d'éléments sur une page.

var pr = new PersonneRepository();
var grid = new WebGrid(pr.GetAll(),rowsPerPage : 10);

Avant d'afficher la grille, vous allez procéder au formatage de celle-ci en définissant les colonnes qui seront affichées et en ajoutant notamment de nouvelles colonnes pour l'édition, la consultation et la suppression d'une ligne de la grille.

Le code pour effectuer cela est le suivant :

@grid.GetHtml(tableStyle:"grid",
headerStyle:"head",
alternatingRowStyle: "altrow",
columns: grid.Columns(
grid.Column("Nom","Nom"),
grid.Column("Prenom", "Prénom"),
grid.Column("", "", format: @<text><a href="Edit/@item.PersonneId")>Editer</a>
| <a href="Details/@item.PersonneId")>Détails</a>
| <a href="Delete/@item.PersonneId")>Supprimer</a></text>)
)

)

Le code complet de la page Index.cshtml est le suivant :

@{
// Set the layout page and page title
Layout = "~/_SiteLayout.cshtml";
Page.Title = "Register an Account";

var pr = new PersonneRepository();
var grid = new WebGrid(pr.GetAll(),rowsPerPage : 10);

}
<hgroup class="title">
<h1>Personnes.</h1>
</hgroup>

<p><a href="Create">Ajouter un nouvel enregistrement</a></p>

@grid.GetHtml(tableStyle:"grid",
headerStyle:"head",
alternatingRowStyle: "altrow",
columns: grid.Columns(
grid.Column("Nom","Nom"),
grid.Column("Prenom", "Prénom"),
grid.Column("", "", format: @<text><a href="Edit/@item.PersonneId")>Editer</a>
| <a href="Details/@item.PersonneId")>Détails</a>
| <a href="Delete/@item.PersonneId")>Supprimer</a></text>)
)

)

La ligne de code :

<p><a href="Create">Ajouter un nouvel enregistrement</a></p>

va permettre d'ajouter les nouvelles informations sur une personne dans la BD. À l'exécution, vous obtenez le résultat suivant :

le code CSS que j'ai utilisé pour le WebGrid et qui a été défini dans le fichier Site.css pour être appliqué à toutes les grilles de l'application est le suivant :

.grid { margin: 4px; border-collapse: collapse; width: 600px; }
.head { background-color: #E8E8E8; font-weight: bold; color: #FFF; }
.grid th, .grid td { border: 1px solid #C0C0C0; padding: 5px; }
.altrow { background-color: #E8E8E8; color: #000; }

VIII-A-2 - Affichage détaillé

Compte tenu du fait que dans certains cas, il vous sera impossible de présenter toutes les informations concernant une entité sur une ligne de la grille, un lien qui pointe sur une page "Details" a été introduit pour afficher des informations détaillées sur une personne.

Nous verrons ici comment implémenter l'interface Web de cette page. Pour cela, vous allez ajouter un nouveau fichier Edit.cshtml dans le dossier Personne.

Au début de ce fichier, vous allez déclarer une variable pour récupérer l'id qui est passé comme paramètre HTTP. La méthode Find() sera utilisée pour retourner l'élément dans la base de données dont l'identifiant est égal à celui qui est passé en paramètre.

Le code pour effectuer cela est le suivant :

int id = Request["id"].AsInt();
var pr = new PersonneRepository();
var personne = new Personne();
personne = pr.Find(id);

Il ne vous reste plus qu'à afficher les informations contenues dans la variable personne dans votre code html.

Le code complet de la page Details.cshtml est le suivant :

@{
// Set the layout page and page title
Layout = "~/_SiteLayout.cshtml";
Page.Title = "Détails";

int id = Request["id"].AsInt();
var pr = new PersonneRepository();
var personne = new Personne();
personne = pr.Find(id);

}
<hgroup class="title">
<h1>Détails.</h1>
</hgroup>
<fieldset>
<legend></legend>
<ol>
<li class="nom">
<label>Nom:</label>
<label>@personne.Nom</label>
</li>
<li class="prenom">
<label>Prénom:</label>
<label>@personne.Prenom</label>
</li>
</ol>
</fieldset>

<p><a href="Edit?id=@id">Editer</a> |
<a href="Index">Retour à la liste</a>
</p>

Ce qui permet d'obtenir le résultat suivant à l'exécution, après un clic sur le lien Détails d'une ligne de la grille contenant la liste des personnes :

VIII-A-3 - Enregistrement des données

Dans la page affichant la liste des personnes, vous avez ajouté un lien permettant d'accéder à la page d'ajout d'un nouvel enregistrement. Penchons-nous maintenant sur l'implémentation de cette page. Vous allez ajouter une nouvelle page dans le dossier Personne. Il suffit pour cela de faire un clic droit sur le dossier Personne, sélectionner "New Files" et créer un nouveau fichier "create.cshtml" dans la fenêtre qui va s'afficher.

Le code source du formulaire d'enregistrement d'une personne est le suivant :

<form method="post" action="">
@* Notification en cas d'erreur de validation *@
@Html.ValidationSummary("Veuillez corriger les erreurs suivantes:")

<fieldset>
<legend>Registration Form</legend>
<ol>
<li class="nom">
<label for="nom" @if(!ModelState.IsValidField("nom")){<text>class="error-label"</text>}>Nom:</label>
<input type="text" id="nom" name="nom" title="Nom" value="@nom" @Validation.GetHtml("nom") />
@Html.ValidationMessage("nom")
</li>
<li class="prenom">
<label for="prenom" @if(!ModelState.IsValidField("prenom")){<text>class="error-label"</text>}>Prénom:</label>
<input type="text" id="prenom" name="prenom" title="Prénom" value="@prenom" @Validation.GetHtml("prenom") />
@Html.ValidationMessage("prenom")
</li>
</ol>
<input type="submit" value="Enregistrer" title="Enregistrer" />

</fieldset>
</form>

Afin d'envoyer des données correctes vers votre classe entité, pour laquelle vous avez défini certains champs comme obligatoires, vous devez procéder à la validation des données utilisateur.

Les méthodes @Html.ValidationSummary() et @Html.ValidationMessage() sont utilisées pour afficher les messages d'erreurs de validation à l'utilisateur.

Vous allez utiliser JQuery et les nouvelles classes de validation System.Web.WebPages.ValidationHelper et System.Web.WebPages.Validator qui ont été introduites par WebPages 2 pour effectuer en seulement quelques lignes de code, des tâches de validation de données puissantes.

Le code pour effectuer cela est le suivant :

// Ajout des scripts de validation
Scripts.Add("~/Scripts/jquery-1.6.2.min.js");
Scripts.Add("~/Scripts/jquery.validate.min.js");
Scripts.Add("~/Scripts/jquery.validate.unobtrusive.min.js");

// Validation du nom
Validation.RequireField("nom", "Le nom est obligatoire.");
// Validation du prénom
Validation.RequireField("prenom", "Le prénom est obligatoire.");

Il ne vous reste plus qu'à écrire le code permettant d'ajouter les données postées par un utilisateur dans la base de données :

var pr = new PersonneRepository();
var personne = new Personne{
Nom = nom, Prenom = prenom};
//Ajout des données sur la personne
pr.Add(personne);

Le code complet de la page Create.cshtml est le suivant :

@{
// Définition du layout et du titre de la page
Layout = "~/_SiteLayout.cshtml";
Page.Title = "Register an Account";

// initialisation des variables
var nom = "";
var prenom = "";

// Ajout des scripts de validation
Scripts.Add("~/Scripts/jquery-1.6.2.min.js");
Scripts.Add("~/Scripts/jquery.validate.min.js");
Scripts.Add("~/Scripts/jquery.validate.unobtrusive.min.js");

// Validation du nom
Validation.RequireField("nom", "Le nom est obligatoire.");
// Validation du prénom
Validation.RequireField("prenom", "Le prénom est obligatoire.");
//Traitement des données si c'est une requête POST
if (IsPost) {
nom = Request.Form["nom"];
prenom= Request.Form["prenom"];

if (Validation.IsValid()) {
var pr = new PersonneRepository();
var personne = new Personne{
Nom = nom, Prenom = prenom};
//Ajout des données sur la personne
pr.Add(personne);
Response.Redirect("Index");
}
};

}

<hgroup class="title">
<h1>Ajout d'un nouvel enregistrement.</h1>
>
</hgroup>

<form method="post" action="">
@* Notification en cas d'erreur de validation *@
@Html.ValidationSummary("Veuillez corriger les erreurs suivantes:")

<fieldset>
<legend>Registration Form</legend>
<ol>
<li class="nom">
<label for="nom" @if(!ModelState.IsValidField("nom")){<text>class="error-label"</text>}>Nom:</label>
<input type="text" id="nom" name="nom" title="Nom" value="@nom" @Validation.GetHtml("nom") />
@Html.ValidationMessage("nom")
</li>
<li class="prenom">
<label for="prenom" @if(!ModelState.IsValidField("prenom")){<text>class="error-label"</text>}>Prénom:</label>
<input type="text" id="prenom" name="prenom" title="Prénom" value="@prenom" @Validation.GetHtml("prenom") />
@Html.ValidationMessage("prenom")
</li>
</ol>
<input type="submit" value="Enregistrer" title="Enregistrer" />

</fieldset>
</form>
<a href="Index">Retour à la liste</a>

À l'exécution de cette page, vous obtenez le résultat suivant :

En cas d'erreur de validation, vous aurez le résultat suivant :

VIII-A-4 - Modification

Après l'enregistrement des données sur une personne, voyons maintenant comment nous allons implémenter une nouvelle page permettant de procéder à la mise à jour des informations sur une personne.

Comme vous avez ajouté un lien "Editer" dans le tableau des personnes qui pointe sur la page "Edit", vous allez créer un nouveau fichier cshtml ayant ce nom.

La page doit afficher par défaut les informations qui doivent être modifiées dans des zones éditables. Vous allez donc dans un premier temps récupérer ces informations. Le code pour effectuer cela est le suivant :

int id = Request["id"].AsInt();

var db = new WebMatrixCrudAppContext();
var personne = new Personne();
personne = db.Personnes.Find(id);
// initialisation des variables
var nom = personne.Nom;
var prenom = personne.Prenom;

Le code du formulaire de modification est le suivant :

<form method="post" action="">
@* If at least one validation error exists, notify the user *@
@Html.ValidationSummary("Veuillez corriger les erreurs suivantes:")

<fieldset>
<legend>Formulaire de modification</legend>
<ol>
<li class="nom">
<label for="nom" @if(!ModelState.IsValidField("nom")){<text>class="error-label"</text>}>Nom:</label>
<input type="text" id="nom" name="nom" title="Nom" value="@nom" @Validation.GetHtml("nom") />
@Html.ValidationMessage("nom")
</li>
<li class="prenom">
<label for="prenom" @if(!ModelState.IsValidField("prenom")){<text>class="error-label"</text>}>Prénom:</label>
<input type="text" id="prenom" name="prenom" title="Prénom" value="@prenom" @Validation.GetHtml("prenom") />
@Html.ValidationMessage("prenom")
</li>
</ol>
<input type="submit" value="Modifier" title="Modifier" />

</fieldset>
</form>

Le code permettant de prendre en compte les modifications dans la base de données est le suivant

personne.Nom = nom;
personne.Prenom = prenom;
//Modification des données sur la personne
pr.Update(personne);

Le code complet de la page Edit.cshtml est le suivant :

@using System.Data
@{
// Définition du layout et du titre de la page
Layout = "~/_SiteLayout.cshtml";
Page.Title = "Modification d'une personne";

int id = Request["id"].AsInt();

var pr = new PersonneRepository();
var personne = new Personne();
personne = pr.Find(id);
// initialisation des variables
var nom = personne.Nom;
var prenom = personne.Prenom;

// Ajout des scripts de validation
Scripts.Add("~/Scripts/jquery-1.6.2.min.js");
Scripts.Add("~/Scripts/jquery.validate.min.js");
Scripts.Add("~/Scripts/jquery.validate.unobtrusive.min.js");

// Validation du nom
Validation.RequireField("nom", "Le nom est obligatoire.");
// Validation du prénom
Validation.RequireField("prenom", "Le prénom est obligatoire.");
//Traitement des données si c'est une requête POST
if (IsPost) {
nom = Request.Form["nom"];
prenom= Request.Form["prenom"];

if (Validation.IsValid()) {

personne.Nom = nom;
personne.Prenom = prenom;
//Modification des données sur la personne
pr.Update(personne);

Response.Redirect("Index");

}
};

}

<hgroup class="title">
<h1>Mise à jour des données.</h1>
</hgroup>

<form method="post" action="">
@* If at least one validation error exists, notify the user *@
@Html.ValidationSummary("Veuillez corriger les erreurs suivantes:")

<fieldset>
<legend>Formulaire de modification</legend>
<ol>
<li class="nom">
<label for="nom" @if(!ModelState.IsValidField("nom")){<text>class="error-label"</text>}>Nom:</label>
<input type="text" id="nom" name="nom" title="Nom" value="@nom" @Validation.GetHtml("nom") />
@Html.ValidationMessage("nom")
</li>
<li class="prenom">
<label for="prenom" @if(!ModelState.IsValidField("prenom")){<text>class="error-label"</text>}>Prénom:</label>
<input type="text" id="prenom" name="prenom" title="Prénom" value="@prenom" @Validation.GetHtml("prenom") />
@Html.ValidationMessage("prenom")
</li>
</ol>
<input type="submit" value="Modifier" title="Modifier" />

</fieldset>
</form>

<p>
<a href="Index">Retour à la liste</a>
</p>

À l'exécution de la page, vous obtenez le résultat suivant :

VIII-A-5 - Suppression

Pour finir avec la table Personnes, vous allez maintenant écrire le code permettant de supprimer un enregistrement dans la base de données. Créez pour cela une nouvelle page Delete.cshtml.

Afin d'éviter les suppressions accidentelles, vous allez dans un premier temps afficher dans cette page le récapitulatif des informations sur une personne avec un message de confirmation de suppression.

Le code pour la page Delete reprend celui de la page Edit, à la différence que vous allez ajouter dans un formulaire un bouton permettant de procéder à la suppression d'un enregistrement :

<form method="post" action="">
<p>
<input type="submit" value="Supprimer" title="Supprimer" />
<a href="Index">Retour à la liste</a>
</p>
</form>

Vous allez également ajouter dans ce fichier le code permettant de supprimer les données dans la base de données en cas de clic sur le bouton supprimer :

if(IsPost)
{
pr.Remove(personne);
Response.Redirect("Index");
}

Le code complet de la page Delete.cshtml est le suivant :

@{
// Définition du layout et du titre de la page
Layout = "~/_SiteLayout.cshtml";
Page.Title = "Détails";

//Lecture des données sur une personne
int id = Request["id"].AsInt();
var pr = new PersonneRepository();
var personne = new Personne();
personne = pr.Find(id);
//Traitement des données si c'est une requête POST
if(IsPost)
{
//Supression de l'enregistrement
pr.Remove(personne);
Response.Redirect("Index");
}

}
<hgroup class="title">
<h1>Suppression.</h1>
<h3>Êtes-vous sûr de vouloir supprimer cet enregistrement ?</h3>
</hgroup>
<fieldset>
<legend></legend>
<ol>
<li class="nom">
<label>Nom:</label>
<label>@personne.Nom</label>
</li>
<li class="prenom">
<label>Prénom:</label>
<label>@personne.Prenom</label>
</li>
</ol>

</fieldset>

<form method="post" action="">
<p>
<input type="submit" value="Supprimer" title="Supprimer" />
<a href="Index">Retour à la liste</a>
</p>
</form>

Ce qui donne le résultat suivant à l'exécution :

VIII-B - Fonctionnalités CRUD pour la table Organismes

Compte tenu du fait que l'implémentation des fonctionnalités pour la table Organismes reprend plusieurs des principes et méthodes qui ont été utilisés pour la table Personnes, nous n'allons plus revenir sur la création des pages d'affichage, d'enregistrement, de mise à jour ou de suppression d'un organisme.

Pour écrire le code de ces pages, veuillez vous référer à celui pour la table Personnes ou à défaut, regarder le code source pour ces pages dans les fichiers du projet qui sont disponibles en téléchargement à la fin de l'article.

VIII-C - Fonctionnalités CRUD pour la table Affiliations

La table Affiliations étant une table association, quelques modifications seront nécessaires au code utilisé pour Personne et Organisme.

VIII-C-1 - Implémentation de la grille

Dans le dossier Affiliations, ajoutez un nouveau fichier Index.cshtml.

Dans ce fichier, ajoutez les lignes de code suivantes, qui vont permettre d'afficher dans cette page la liste des affiliations qui ont été enregistrées dans la base de données :

@{
/// Définition du layout et du titre de la page
Layout = "~/_SiteLayout.cshtml";
Page.Title = "Gestion des organismes";
//déclaration des variables
var af = new AffiliationRepository();
//déclaration de la grille
var grid = new WebGrid(af.GetAll(),rowsPerPage : 10);

}
<hgroup class="title">
<h1>Affiliations.</h1>
</hgroup>

<p><a href="Create">Ajouter un nouvel enregistrement</a></p>
@* formatage et affichage de la grille *@
@grid.GetHtml(tableStyle:"grid",
headerStyle:"head",
alternatingRowStyle: "altrow",
columns: grid.Columns(
grid.Column("Personne.Nom","Employé"),
grid.Column("Organisme.Nom","Organisme"),
grid.Column("Fonction", "Fonction"),
grid.Column("Telephone", "Téléphone"),

grid.Column("", "", format: @<text><a href="Edit?organismeId=@item.OrganismeId&personneId=@item.PersonneId")>Editer</a>
| <a href="Details?organismeId=@item.OrganismeId&personneId=@item.PersonneId")>Détails</a>
| <a href="Delete?organismeId=@item.OrganismeId&personneId=@item.PersonneId")>Supprimer</a></text>)
)

)

Vous remarquez certainement pour les colonnes Employé et Organisme, l'affichage des propriétés Personne.Nom et Organisme.Nom. En effet, lors de la définition de l'entité Affiliation, vous avez défini les classes Personne et Organisme comme propriétés de l'entité. Cela permet à Entity Framework de charger automatiquement dans ces propriétés les données correspondant aux clés étrangères dans la table Affiliations.

À l'exécution de cette page, vous obtenez le résultat suivant :

VIII-C-2 - Affichage détaillé

Dans la page précédente, certaines informations, comme l'adresse e-mail n'ont pas été affichées dans la grille. Pour visualiser ces données, une page d'affichage détaillé doit être ajoutée à l'application.

Pour ajouter cette page, faites un clic droit sur le dossier Affiliation, sélectionnez l'option New File et créez un nouveau fichier Detail.cshtml.

Dans ce fichier, vous allez ajouter les lignes de code suivantes :

@{

Layout = "~/_SiteLayout.cshtml";
Page.Title = "Détails";
//Recupération des Id
int personneId = Request["personneId"].AsInt();
int organismeId = Request["organismeId"].AsInt();
//Déclaration des variables
var af = new AffiliationRepository();
var affiliation = new Affiliation();
//Selection de l'élément correspondant aux Id
affiliation = af.Find(personneId, organismeId);

}
<hgroup class="title">
<h1>Détails.</h1>
</hgroup>
<fieldset>
<legend></legend>
<ol>
<li class="employe">
<label>Employé:</label>
<label>@affiliation.Personne.Prenom @affiliation.Personne.Nom</label>
</li>

<li class="organisme">
<label>Organisme:</label>
<label>@affiliation.Organisme.Nom</label>
</li>
<li class="fonction">
<label>Fonction:</label>
<label>@affiliation.Fonction</label>
</li>
<li class="email">
<label>Adresse mail:</label>
<label>@affiliation.Email</label>
</li>
<li class="telephone">
<label>Téléphone:</label>
<label>@affiliation.Telephone</label>
</li>
</ol>
</fieldset>

<p><a href="Edit?organismeId=@affiliation.OrganismeId&personneId=@affiliation.PersonneId">Editer</a> |
<a href="Index">Retour à la liste</a>
</p>

À l'exécution, vous obtiendrez le résultat suivant :

VIII-C-3 - Enregistrement

Compte tenu du fait que Affiliations est une table association, vous allez dans un premier temps charger dans des listes déroulantes les noms des personnes et des organismes.

Pour cela, dans le fichier Create.cshtml que vous avez ajouté au dossier Affiliation, vous allez insérer les lignes de code suivantes :

var pr = new PersonneRepository();
var og = new OrganismeRepository();

var personnes = new List<Personne>();
var organismes = new List<Organisme>();

personnes = pr.GetAll();
organismes = og.GetAll();

Une boucle foreach sera utilisée pour charger les données dans une liste déroulante HTML. Le code pour effectuer cela est le suivant :

<select id="personneId" name="personneId">
@foreach(var p in personnes){
<option value="@p.PersonneId">@p.Nom</option>
}
</select>

En plus de la validation des champs, une vérification doit être effectuée pour éviter les contraintes de validation des clés. Le code pour cela est le suivant :

if (db.Affiliations.Find(personneId, organismeId) != null)
{

//Ajout d'un message d'erreur si les Id existent déjà dans la table affiliations
ModelState.AddError("personneId","Cet enregistrement existe déjà dans la base de données");
}

Le code complet de la page Create.cshtml est le suivant :

@{
// Définition du layout et du titre de la page
Layout = "~/_SiteLayout.cshtml";
Page.Title = "Enregistrement d'un organisme";

// initialisation des variables
var fonction = "";
var email = "";
var telephone = "";
//Lecture des données sur les personnes et les organismes
var pr = new PersonneRepository();
var og = new OrganismeRepository();
var af = new AffiliationRepository();

var personnes = new List<Personne>();
var organismes = new List<Organisme>();

personnes = pr.GetAll();
organismes = og.GetAll();

// Ajout des scripts de validation
Scripts.Add("~/Scripts/jquery-1.6.2.min.js");
Scripts.Add("~/Scripts/jquery.validate.min.js");
Scripts.Add("~/Scripts/jquery.validate.unobtrusive.min.js");

// Validation de la fonction
Validation.RequireField("fonction", "La fonction est obligatoire.");

if (IsPost) {
int personneId = Request.Form["personneId"].AsInt();
int organismeId = Request.Form["organismeId"].AsInt();
fonction = Request.Form["fonction"];
email = Request.Form["email"];
telephone = Request.Form["telephone"];

if (af.Find(personneId, organismeId) != null)
{

//Ajout d'un message d'erreur si les Id existent déjà dans la table Affiliations
ModelState.AddError("personneId","Cet enregistrement existe déjà dans la base de données");
}

if (Validation.IsValid()) {

if(ModelState.IsValid) {
var affiliation = new Affiliation{
PersonneId = personneId, OrganismeId = organismeId, Fonction = fonction, Email = email, Telephone = telephone };

af.Add(affiliation);

Response.Redirect("Index");
}
}

};

}

<hgroup class="title">
<h2>Enregistrement d'une affiliation</h2>
</hgroup>

<form method="post" action="">
@* Notification en cas d'erreur de validation *@
@Html.ValidationSummary("Veuillez corriger les erreurs suivantes:")

<fieldset>
<legend>Formlaire </legend>
<ol>
<li class="personneId">
<label for="personneId" >Employé:</label>
<select id="personneId" name="personneId">
@foreach(var p in personnes){
<option value="@p.PersonneId">@p.Nom</option>
}
</select>
</li>

<li class="organismeId">
<label for="organismeId" >Organisme:</label>
<select id="organismeId" name="organismeId">
@foreach(var o in organismes){
<option value="@o.OrganismeId">@o.Nom</option>
}
</select>
</li>

<li class="fonction">
<label for="fonction" @if(!ModelState.IsValidField("fonction")){<text>class="error-label"</text>}>Fonction:</label>
<input type="text" id="fonction" name="fonction" title="Fonction" value="@fonction" @Validation.GetHtml("fonction") />
@Html.ValidationMessage("fonction")
</li>
<li class="email">
<label for="email">Adresse mail:</label>
<input type="text" id="email" name="email" title="Email" value="@email" />

</li>
<li class="telephone">
<label for="telephone">Numéro de téléphone:</label>
<input type="text" id="telephone" name="telephone" title="Téléphone" value="@telephone" />

</li>
</ol>
<input type="submit" value="Enregistrer" title="Enregistrer" />

</fieldset>
</form>
<a href="Index">Retour à la liste</a>

A l'exécution, vous obtenez le résultat suivant :

VIII-C-4 - Modification

Penchons-nous maintenant sur la page permettant de modifier les informations d'une affiliation. Une nouvelle page Edit.cshtml doit être ajoutée dans le dossier Affiliation.

Dans cette page, vous allez dans un premier temps, écrire le code permettant de retourner les informations sur la ligne qui doit être modifiée :

int personneId = Request["personneId"].AsInt();
int organismeId = Request["organismeId"].AsInt();

// initialisation des variables
var af = new AffiliationRepository();
var affiliation = new Affiliation();
affiliation = af.Find(personneId, organismeId);

var fonction = affiliation.Fonction;
var email = affiliation.Email;
var telephone = affiliation.Telephone;

Le code permettant de prendre en compte les modifications dans la base de données avec Entity Framework est le suivant :

affiliation.Fonction = fonction;
affiliation.Email = email;
affiliation.Telephone = telephone;
//Modification de l'affiliation
af.Update(affiliation);

Le code complet pour cette page est le suivant :

@using System.Data
@{
// Définition du layout et du titre de la page
Layout = "~/_SiteLayout.cshtml";
Page.Title = "Modification";

int personneId = Request["personneId"].AsInt();
int organismeId = Request["organismeId"].AsInt();

// initialisation des variables
var af = new AffiliationRepository();
var affiliation = new Affiliation();

affiliation = af.Find(personneId, organismeId);

var fonction = affiliation.Fonction;
var email = affiliation.Email;
var telephone = affiliation.Telephone;

// Ajout des scripts de validation
Scripts.Add("~/Scripts/jquery-1.6.2.min.js");
Scripts.Add("~/Scripts/jquery.validate.min.js");
Scripts.Add("~/Scripts/jquery.validate.unobtrusive.min.js");

// Validation de la fonction
Validation.RequireField("fonction", "La fonction est obligatoire.");

if (IsPost) {
fonction = Request.Form["fonction"];
email = Request.Form["email"];
telephone = Request.Form["telephone"];

if (Validation.IsValid()) {

affiliation.Fonction = fonction;
affiliation.Email = email;
affiliation.Telephone = telephone;
//Modification de l'affiliation
af.Update(affiliation);

Response.Redirect("Index");

}
};

}

<hgroup class="title">
<h2>Modification.</h2>
</hgroup>

<form method="post" action="">
@* Notification en cas d'erreur de validation *@
@Html.ValidationSummary("Veuillez corriger les erreurs suivantes:")

<fieldset>
<legend></legend>
<ol>
<li class="employe">
<label>Employé:</label>
<label>@affiliation.Personne.Prenom @affiliation.Personne.Nom</label>
</li>

<li class="organisme">
<label>Organisme:</label>
<label>@affiliation.Organisme.Nom</label>
</li>

<li class="fonction">
<label for="fonction" @if(!ModelState.IsValidField("fonction")){<text>class="error-label"</text>}>Fonction:</label>
<input type="text" id="fonction" name="fonction" title="Fonction" value="@fonction" @Validation.GetHtml("fonction") />
@* Write any email validation errors to the page *@
@Html.ValidationMessage("fonction")
</li>
<li class="email">
<label for="email">Adresse mail:</label>
<input type="text" id="email" name="email" title="Email" value="@email" />

</li>
<li class="telephone">
<label for="telephone">Numéro de téléphone:</label>
<input type="text" id="telephone" name="telephone" title="Téléphone" value="@telephone" />

</li>
</ol>
<input type="submit" value="Modifier" title="Edit" />

</fieldset>
</form>
<a href="Index">Retour à la liste</a>

qui produit le résultat suivant à l'exécution :

VIII-C-5 - Suppression

Enfin, pour finir avec cette table, vous allez créer la page Delete.cshtml dans le dossier Affiliation.

Le code source de cette page n'a rien de particulier et reprend les principes qui ont été utilisés pour implémenter la page de suppression pour la table Personnes.

Le code complet pour cette page est le suivant :

@{
// Définition du layout et du titre de la page
Layout = "~/_SiteLayout.cshtml";
Page.Title = "Suppression";

int personneId = Request["personneId"].AsInt();
int organismeId = Request["organismeId"].AsInt();

var af = new AffiliationRepository();
var affiliation = new Affiliation();
//Recherche de l'affiliation à supprimerf
affiliation = af.Find(personneId, organismeId);

if(IsPost)
{
//Supression de l'enregistrement
af.Remove(affiliation);
Response.Redirect("Index");
}

}
<hgroup class="title">
<h1>Suppression.</h1>
<h3>Êtes-vous sûr de vouloir supprimer cet enregistrement ?</h3>
</hgroup>
<fieldset>
<legend></legend>
<ol>
<li class="employe">
<label>Employé:</label>
<label>@affiliation.Personne.Prenom @affiliation.Personne.Nom</label>
</li>

<li class="organisme">
<label>Organisme:</label>
<label>@affiliation.Organisme.Nom</label>
</li>
<li class="fonction">
<label>Fonction:</label>
<label>@affiliation.Fonction</label>
</li>
<li class="email">
<label>Adresse mail:</label>
<label>@affiliation.Email</label>
</li>
<li class="telephone">
<label>Téléphone:</label>
<label>@affiliation.Telephone</label>
</li>
</ol>

</fieldset>

<form method="post" action="">
<p>
<input type="submit" value="Supprimer" title="Supprimer" />
<a href="Index">Retour à la liste</a>
</p>
</form>

Il permet d'obtenir le résultat suivant à l'exécution :

IX - Conclusion

Entity Framework, la technologie d'accès aux données qui est en passe de devenir un standard dans l'écosystème .NET peut être assez facilement exploitée avec WebMatrix pour la création d'applications Web robustes. Bien que l'éditeur WebMatrix manque beaucoup de fonctionnalités et d'extensions qui sont disponibles dans Visual Studio, comme l'échafaudage pour développer rapidement et facilement des applications utilisant Entity Framework, il permet néanmoins au développeur d'exploiter quasiment toutes les fonctionnalités de la bibliothèque et supporte l'IntelliSence pour celle-ci.

Ce tutoriel nous a permis de concevoir bout-à-bout une petite solution complète de gestion des affiliations en utilisant Entity Framework, WebMatrix, Razor, NuGet et SQL Server Compact Edition, et de nous familiariser avec tous ces outils qui sont assez utilisés dans l'environnement .NET.

Vous pouvez donc vous baser sur cet exemple ou en modifier le code à votre guise pour développer votre propre application répondant à vos besoins fonctionnels avec WebMatrix.

X - Remerciements

Je tiens à remercier bifconsult et jacques_jean pour leurs relectures et corrections orthographiques.

XI - Liens

Présentation de NuGet, le gestionnaire de package pour Visual studio

Présentation du moteur de vue Razor

WebMatrix : utilisation des Helpers Razor et de la galerie d'applications

WebMatrix : découverte et prise en main d'un outil de développement Web "tout-en-un"

Télécharger WebMatrix 2 Bêta

XII - Sources

Vous pouvez télécharger et modifier les sources ci-dessous à votre convenance.

Version RAR

Version ZIP