Comme il n’est pas exclu que je tombe encore sur le même type de problème à l’avenir, je vais partager sur mon blog – qui est avant tout mon rappel mémoire favori – les causes de cette erreur et comment contourner cela.

Ce que j’essayais de faire dans mon application.

Pour une facture, je voulais récupérer la liste des produits, et pour chaque produit, avoir la fiche produit correspondante, y effectuer des modifications, ensuite appliquer la mise à jour à la base de données.

Le code source de cette partie est le suivant :

var lp = from l in db.Liste_produit.Include(l => l.Article)
         where l.Id_facture == facture.Id_facture
         select l;
foreach(Liste_produit liste_produit in lp)
     {
       article = liste_produit.Article;
       //bla bla bla
       //bla bla bla
       db.Entry(article).State = EntityState.Modified;
       db.SaveChanges();
                        
     }

À l’exécution de ce code, au moment de l’enregistrement des modifications dans la base de données (db.SaveChanges()), l’exception ci-dessous est levée.

Les causes :

Après avoir observé le problème de près et effectué quelques recherches, je me suis rendu compte que le souci était au niveau du foreach.

Il semblerait que pour la lecture de chaque élément dans « lp », la bouche ait recours à une transaction pour le Context en cours. Hor, lorsque j’appelle la procédure SaveChanges(), une nouvelle transaction veut être créée pour le même Context. Ce qui n’est pas autorisé par Entity Famework.

Solutions

De prime abord, j’ai opté pour la sauvegarde de mes données dans une IList. Ainsi, lors de la lecture de celles-ci, je n’aurais plus besoin d’avoir recours à une transaction.
Le code que j’ai utilisé est le suivant :

var lp = from l in db.Liste_produit.Include(l => l.Article)
         where l.Id_facture == fa.Id_facture
         select l;
IList<Liste_produit> ListeP = lp.ToList();
foreach(Liste_produit liste_produit in ListeP)
   {
      article = liste_produit.Article;
      //bla bla bla
      //bla bla bla
      db.Entry(article).State = EntityState.Modified;
      db.SaveChanges();
                        
  }

Cette solution marche. Mais, côté performance, elle n’est pas du tout satisfaisante. Si la quantité de données est importante, imaginez un peu la consommation de la mémoire en chargeant toutes ces données dans une liste.

En tout cas, elle ne m’arrange pas. J’ai donc opté pour une solution beaucoup plus simple et performante. J’ai simplement appelé la procédure SaveChanges() en dehors de la boucle et le problème a été résolu avec de meilleures performances.

var lp = from l in db.Liste_produit.Include(l => l.Article)
         where l.Id_facture == facture.Id_facture
         select l;
foreach(Liste_produit liste_produit in lp)
   {
      article = liste_produit.Article;
      //bla bla bla
      //bla bla bla
      db.Entry(article).State = EntityState.Modified;
   }
db.SaveChanges();

En procédant ainsi, j’apporte des modifications à l’entité dans le foreach, et c’est à la suite de cette instruction (lorsque la transaction a été bouclée) que j’appelle la procédure SaveChanges().

Voila le problème est résolu, et la prochaine fois que je serais face à ce problème (ce qui est fort probable), et que je ne me souviendrais plus de comment j’avais procédé (ce qui est également fort probable), je saurais ou chercher e premier ;).

Scott Guthrie, Vice-président de la division serveur et Business Tools chez Microsoft, a annoncé que l’outil sera désormais disponible sous les termes de la licence Apache 2.0, et son code source sera disponible sur CodePlex, la plateforme d’hébergement des projets .NET Open Source.

Le passage en open source d’Entity Framework se situe dans le plan d’ouverture adopté par Microsoft depuis un certain moment avec la création de sa filiale Microsoft Open Technology.

L’ouverture d’Entity Framework permettra une plus grande transparence de développement avec un modèle ouvert où toute la communauté sera en mesure de fournir une rétroaction, des correctifs de bugs, de nouvelles fonctionnalités, etc.

Entity Framework sera toujours pris en charge comme un produit Microsoft et son équipe restera inchangée. Le produit disposera également des mêmes mécanismes de support technique, et sera publié de façon automne ou comme partie de Visual Studio.

Entity Framework est actuellement disponible en version 4.3, et apporte comme nouveauté phare Code First Migrations. La version 5 actuellement au stade de Release Candidate, sera publiée au même moment que le Framework .NET 4.5, et introduira comme nouveauté le support pour enum, des types de données spatiales, etc.

– Entity Framework sur CodePlex

Pendant le développement ou le cycle de vie d’une application, le développeur est très souvent confronté à des situations pouvant entrainer des modifications de son modèle objet ainsi que de sa base de données. Avec Entity Framework, cette tâche peut s’avérer assez complexe, voire frustrante pour certains.

Si vous voulez par exemple apporter une modification (ajout d’une colonne) à une table de votre base de données, si vous vous limitez à définir uniquement la nouvelle colonne dans votre modèle, lors de l’exécution de l’application vous allez obtenir un message d’erreur puisque le modèle ne correspond plus aux objets de la BD.

Il était cependant possible d’ajouter quelques lignes de code dans le fichier Global.asax, permettant lors de la modification du modèle, de détruire et recréer automatiquement la base de données lors de la prochaine exécution de l’application, avec comme conséquence directe la perte des données. Ce qui est inacceptable pour une base de données déjà en production.

Heureusement, Entity Framework 4.3 élimine ces contraintes avec la nouvelle fonctionnalité Code First Migrations, qui permet d’appliquer avec souplesse les modifications du modèle sur la base de données, en réduisant les risques de pertes de données.

L’article complet est disponible ici.

Pour les commentaires, ça se passe ici

Bonne lecture

En dehors d’un foutu message “Unable to load one or more of the requested types. Retrieve the LoaderExceptions property for more information”, rien ne permet d’identifier clairement la source de cette erreur.

Après plusieurs recherches, il semblerait que l’erreur soit générée par Entity Framework. En effet, lorsque vous utilisez Entity Framework, celui-ci est configuré par défaut pour charger tous les types des assemblys référencées, afin d’identifier les différents types des entités pour votre modèle objet. Si l’un des types ne peut être chargé, alors Entity Framework va générer cette erreur.

Il existe plusieurs solutions pour fixer ce problème :

– vous pouvez marquer la copie locale de toutes les assemblys référencées dans votre application à True ;

– dans une autre mesure, il suffit de supprimer toutes les DLL dans le dossier bin et procéder à une nouvelle génération de votre application.

– il est également possible que les bibliothèques System.Data.Entity et System.Web.Entity soient corrompues. Pour mon cas par exemple, lors du déploiement de mon application, après investigation, je me suis rendu compte que les fichiers System.Data.Entity.dll et System.Web.Entity.dll avaient respectivement pour tailles 1640 Ko et 63 ko, pourtant dans le framework .NET, ces fichiers avaient pour tailles 4360 Ko et 135 Ko. En les remplaçant simplement avant le déploiement de l’application, cela a résolu ce bug.

Mais, le véritable problème ici, c’est d’identifier réellement l’assemblys qui pose problème. Pour cela, vous pouvez simplement utiliser le code suivant :

try
{
    //Le code qui pose problème.
}
catch (ReflectionTypeLoadException ex)
{
    StringBuilder sb = new StringBuilder();
    foreach (Exception exSub in ex.LoaderExceptions)
    {
        sb.AppendLine(exSub.Message);
        if (exSub is FileNotFoundException)
        {
            FileNotFoundException exFileNotFound = exSub as FileNotFoundException;
            if(!string.IsNullOrEmpty(exFileNotFound.FusionLog))
            {
                sb.AppendLine("Fusion Log:");
                sb.AppendLine(exFileNotFound.FusionLog);
            }
        }
        sb.AppendLine();
    }
    string errorMessage = sb.ToString();
   }

N’oubliez pas d’ajouter une référence à System.IO et System.Reflection;

Et voilà. Dorénavant, lorsque vous allez exécuter votre application et qu’il y’aura un problème avec le chargement d’un composant, vous aurez un message clair et les détails sur l’assembly qui pose problème.

À noter que ce bug n’existe plus lorsque l’on utilise Entity Framework avec le framework .NET 4.5, il ne scanne plus toutes les assemblys de l’application lors de son exécution.

Une des nouveautés les plus intéressantes qu’apporte Entity Framework 4.3 est la migration pour les mises à jour de la base de données.

Cette fonctionnalité offre aux développeurs des outils permettant d’appliquer avec souplesse et facilité des mises à jour à la base de données à partir des modifications apportées à l’application.

Dans un précédent billet de blog, j’ai présenté cette fonctionnalité et comment l’on pouvait l’utiliser pour effectuer des mises à jour de la base de données.

Cet article présentait uniquement l’un des modes de mises à jour qu’offre Entity Framework : le mode basé sur le code.

Supposons que vous disposez déjà d’une application utilisant Entity Framework Code First. Procédez à la mise à jour de celle-ci pour utiliser la version 4.3 d’Entity Framework si ce n’est pas encore le cas.

Vous pouvez utiliser la commande :

PM> install-package EntityFramework

Activer la migration

La première étape est d’activer la migration pour votre DbContext, en utilisant la console du gestionnaire de packages (menu Outils/Gestionnaire de package/Package Manager Console de Visual Studio). Vous allez exécuter la commande « Enabled-Migrations ».

L’activation de la migration crée un nouveau dossier Migrations dans votre application contenant un fichier Configurations.cs permettant de définir le comportement de la migration pour le DbContext qui est utilisé.

namespace DatabaseMigration.Migrations
{
    using System;
    using System.Data.Entity;
    using System.Data.Entity.Migrations;
    using System.Linq;

    internal sealed class Configuration : DbMigrationsConfiguration<DatabaseMigration.DatabaseMigrationContext>
    {
        public Configuration()
        {
            AutomaticMigrationsEnabled = false;
        }

        protected override void Seed(DatabaseMigration.DatabaseMigrationContext context)
        {
            
        }
    }
}

Si vous avez défini plusieurs «DbContext » dans votre application, il suffira juste de modifier DbMigrationsConfiguration(T), en remplaçant T par le nom du DbContext que vous voulez utiliser.

Configurer la migration automatique

Par défaut, la propriété AutomaticMigrationsEnabled est définie à false. Pour utiliser la migration automatique, vous devez affecter la valeur « true » à cette propriété.

Il également possible de définir cette propriété à true lors de l’activation de la migration. Pour cela, vous devez ajouter le paramètre EnableAutomaticMigrations à la commande permettant d’activer la migration :

PM> Enable-Migrations -EnableAutomaticMigrations

Par défaut, la migration automatique n’autorise pas les mises à jour pouvant entrainer des pertes de données. Pour activer cette option, vous devez éditer le fichier Configuration.cs en y ajoutant la propriété « AutomaticMigrationDataLossAllowed » qui sera définie à true.

public Configuration()
        {
            AutomaticMigrationsEnabled = true;
            AutomaticMigrationDataLossAllowed = true;
        }

Editez ensuite votre DbContext et ajoutez-y la procédure onModelCreating :

protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            Database.SetInitializer(new MigrateDatabaseToLatestVersion<DatabaseMigrationContext, Configuration>());
        }

Et voilà, c’est tout ;). Toute modification de votre modèle objet (nouvelle entité, ajout d’une propriété, suppression d’une propriété, etc.) sera automatiquement appliquée à la base de données à l’exécution de votre application.

Inconvénients de la migration automatique

La migration automatique permet d’apporter assez rapidement et simplement des mises à jour à une base de données en utilisant Entity Framework Code First. Cette option présente cependant des inconvénients, et personnellement, je ne recommanderais pas son utilise en environnement de production ou sur un système critique.

L’utilisation du mode automatique en environnement de production peut s’avérer assez dangereuse, avec un risque de perte de données, car les modifications apportées à la base de données sont imprévisibles par le développeur, et celui-ci n’a aucune visibilité sur ces changements.

Néanmoins, vous pouvez limiter ces risques en environnement de production en désactivant l’autorisation des mises à jour pouvant entrainer des pertes de données.

Les cinq articles de blog qui présentaient pas à pas comment créer une application CRUD avec WebMatrix, Razor et Entity Framework ont été regroupés en un seul tutoriel qui vient d’être publié sur Developpez.com.

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.

– Consulter le tutoriel complet

– Télécharger la version PDF

– Télécharger la version hors-ligne

– Télécharger la version eBook

– Télécharger le code source de l’application d’exemple :

. Version RAR

. Version ZIP

– Pour les commentaires c’est par ici

Bonne lecture

– Part 1 : introduction et présentation des outils

– Part 2 : création de l’application et définition du modèle objet

Dans les parties précédentes, nous nous sommes familiarisés avec les outils que nous allons utiliser, et nous avons par la suite procédé à la création de l’application et à la définition du modèle objet qui sera utilisé.

Cette partie portera sur la création du DbContext, la définition de la chaine de connexion dans le fichier Web.Config, la création de la base de données à partir du modèle objet et afin la définition du Repository qui sera utilisé.

Création du DBContex

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é en tant qu’objet.

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, doublez 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 chaîne 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 par exemple sur la relation Affiliation_Organisme, 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 au 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 recréée à nouveau, donc toutes les données présentes dans celle-ci seront perdues.

Création d’un 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 Delette(Personne  personne)
    {
       _context.Personnes.Remove(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);
    }

La partie suivante portera sur l’implémentation des fonctionnalités CRUD pour nos différentes tables.

– Part 1 : introduction et présentation des outils

– Part 2 : création de l’application et définition du modèle objet

– Part 3 : création du DBContex et du Repository

– Part 4 : implémentation des fonctionnalités CRUD

Dans cette cinquième et dernière partie de notre tutoriel sur la création d’une application CRUD avec WebMatrix, Razor et Entity Framework, nous verrons comment implémenter les interfaces Web pour la lecture, la modification, la suppression et l’enregistrement des données pour une table associative.

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

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 correspondantes aux clés étrangères dans la table Affiliations.

A l’exécution de cette page, vous obtenez le résultat suivant :

2 – Affichage détaillé

Dans la page précédente, certaines informations comme l’adresse email 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>

A l’exécution, vous obtiendrez le résultat suivant :

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 exitent 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 :

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 :

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 sur 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 :

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 librairie 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 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.

Sources

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

Version RAR

Version ZIP

– Part 1 : introduction et présentation des outils

– Part 2 : création de l’application et définition du modèle objet

– Part 3 : création du DBContex et du Repository

Dans les parties précédentes, nous nous sommes familiarisés avec outils utilisés, nous avons procédé à la création de l’application, à la définition du modèle objet qui sera utilisé ainsi qu’à la création du DBContex et du Repository.

Dans cette partie, nous allons nous plonger dans le vif du sujet en implémentant les interfaces Web pour la lecture, la modification, la suppression et l’enregistrement des données dans votre base de données.

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

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

2 – Affichage détaillé

mpte tenu du fait que dans certains cas, il vous sera impossible de présenter toutes les informations sur une entité sur une ligne de la grille, un lien qui pointe sur une page  » Details  » a été introduit donc 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 :

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 varaiables
    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.");
    //Triatement des données si s'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 :

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 s'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 :

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 s'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 sur 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 :

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.

La prochaine et dernière partie portera donc sur l’implémentation des fonctionnalités CRUD pour la table Affiliations, qui sera un peu différente puisque c’est table association.

Dans la première partie introductive, nous avons présenté le but de cet article et les différents outils qui seront utilisés pour l’implémentation de notre application CRUD.

Cette seconde partie portera essentiellement sur la création de l’application avec WebMatrix, l’installation d’Entity Framework à partir de NuGet et la définition du modèle objet.

Création de l’application

Maintenant que nous nous sommes familiarisés avec les différents outils que nous allons utiliser, nous pouvons maintenant procéder à la création de notre application.
Pour cela, vous allez 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.

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 le package 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.

Définition du modèle objet

Notre exemple simple portera sur une petite application pour la gestion du carnet d’adresses d’une entreprise. L’entreprise contient 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, nous allons 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 correspondantes au schéma de votre base de données. Cependant, Entity Framework est incapable de définir les relations entre les tables Presonne et Affilialtion, ainsi qu’entre les tables Organisme et Affiliation.

Pour matérialiser cela, vous allez donc 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 ajouter également 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 correspondante à 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 autoincrément. 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;}
}

La troisième partie portera sur la création du DbContext, de la base de données à partir du modèle objet avec EF Code First et enfin la définition des différentes classes Repository qui seront utilisées.