Il faut dire que pour cette version, Microsoft n’a pas fait les choses à moitié.

WebMatrix 2 apporte un nombre important de nouveautés dont les fonctionnalités phares sont :

– une galerie d’extensions et un modèle d’extensibilité pour permettre d’écrire rapidement ses propres plugins et étendre les fonctionnalités de l’EDI ;
– une rapidité améliorée pour installer, modifier et publier les applications open source comme Joomla, WordPress, Drupal, DotNetNuke et Umbraco ;
– l’intégration de nouveaux modèles de projets pour PHP, Node.js, HTML5 et pour le mobile ;
– le support amélioré pour les langages Razor, C#, VB, PHP, Node.js, HTML5, CSS3 et Jquery, avec notamment l’ajout de l’IntelliSense et l’accès à la documentation pour PHP ;
– la possibilité de prévisualiser son site mobile avant publication grâce à des émulateurs pour iPhone, iPad et Windows Phone ;
– une interface simple pour installer les composants externes nécessaires pour votre application via NuGet ;
une intégration plus étroite avec la plateforme Cloud Windows Azure ;
– la possibilité de télécharger et modifier un fichier depuis le serveur.

J’ai deja redigé un nombre intéressant d’articles sur les nouveautés de cette mouture :

– WebMatrix 2 : utiliser l’extension OrangeBits pour améliorer le temps de chargement des pages Web

– WebMatrix 2 beta : intégration du gestionnaire de packages NuGet et la galerie d’extensions

– WebMatrix 2 bêta : validation des données utilisateur

– WebMatrix 2 bêta : intégrer l’authentification Twitter à son site Web

– WebMatrix 2 bêta : support amélioré pour PHP avec l’IntelliSense

A bientôt pour de nouveaux articles sur l’EDI, qui est l’un de mes environnements de développement phare.

Pour améliorer le temps de chargement d’une page, les développeurs ont recours à plusieurs techniques d’optimisation coté client ou coté serveur dont la mise en cache, l’utilisation d’un CDN ou encore la compression et la minification du CSS et JavaScript.

Dans ce billet de blog, je vais montrer comment vous pouvez grandement améliorer le temps de chargement des pages de votre site Web en minifiant vos fichiers JavaScript et CSS, et en optimisant les images grâce à l’extension OrangeBits.

La minification du CSS et JavaScript est un procédé qui permet de réduire la taille des fichiers en supprimant les caractères inutiles à l’instar des commentaires, les espaces, les sauts de lignes, etc.

Pour cet exemple, je vais utiliser le modèle de projet Startet Site. Créez une nouvelle application avec WebMatrix 2. Mon application utilise le fichier JavaScript « jquery-1.6.2.js ». Lorsque j’exécute mon application avec un outil de mesure de performance comme Yslow, je peux avoir la taille et le nombre de fichiers JavaScript qui sont chargés.

Ici, j’ai 3 fichiers JavaScript d’une taille totale de 315.0k, la taille de mon fichier « jquery-1.6.2.js » est de 233Ko. Il est temps pour nous d’installer OrangeBits et l’utiliser pour réduire la taille de ce fichier.

Pour rappel, WebMatrix 2 dispose d’une galerie d’extension qui contient à nos jours plusieurs outils assez intéressants, permettant d’étendre les fonctionnalités de l’EDI. Parmi ces extensions, figure en bonne place OrangeBits pour l’optimisation.

Pour installer l’extension, cliquez sur le bouton Extensions dans la barre d’outils de WebMatrix. La fenêtre de téléchargement, d’installation et de gestion des extensions pour votre EDI s’affiche. Pour son utilisation, vous pouvez vous référer à mon précédent billet de blog sur l’intégration du gestionnaire de packages .NET NuGet et de la galerie d’extension à WebMatrix 2.

Dans la liste des extensions qui vont s’afficher, recherchez OrangeBits Compiler et cliquez sur Installer. Une fenêtre va s’afficher avec les termes de licences concernant l’add-on. Cliquez sur j’accepte pour lancer l’installation de celui-ci.

Vous voilà prêt pour minifier votre fichier. Il suffit juste de le sélectionner, dérouler le menu contextuel et sélectionner minify.

Vous constaterez qu’un fichier « xxxx.min.js » est créé dans le dossier contenant vos fichiers JavaScript ou CSS. Dans votre code, vous allez référencer ce fichier avant de publier votre site ou de mettre celui-ci en production. Pour mon cas, un fichier « « jquery-1.6.2.min.js » a été créé dans mon dossier script. Ce fichier à une taille de 101 Ko (contre 233Ko au début), soit une réduction de plus de 50%.

Il est également possible dans les options, de personnaliser OrangeBits de telle sorte qu’à chaque modification du fichier CSS ou JavaScript, le fichier minifié soit régénéré automatiquement. Vous avez même le choix du dossier dans lequel ce fichier pourra être enregistré.

Pour personnaliser les options d’OrangeBits, il suffit de faire un clic droit au niveau de l’explorateur de fichier et sélectionner la ligne OrangeBits Options.

Optimisation des images

En plus de la minification du JavaScript et CSS, vous pouvez également utiliser OrangeBits pour optimiser les images. Cette option peut être utilisée pour réduire considérablement la taille d’une image. Elle peut permettre de réduire par un facteur de deux la taille d’une image.

Avec cet outil, vous avez de quoi réduire le temps de chargement des pages de votre application. WebMatrix 2 apporte une quantité importante de nouvelles fonctionnalités et celui-ci est facilement extensible. Les développeurs indépendants peuvent repousser les limites de l’EDI qui devient de plus en plus un outil vraiment Pro, permettant de faire des choses assez complexes.

En plus de la minification du JavaScript, CSS et l’optimisation des images, OrangeBits peut également être utilisé pour compiler les fichiers CofeeScript, Scss, Sass au sein de WebMatrix.

Sur le même sujet :

WebMatrix 2 : améliorer le temps de chargement des pages Web en utilisant le regroupement et la minification du CSS et JavaScript

optimisation du temps de chargement d’une page ASP.NET MVC Part 2 : La mise en cache

Microsoft.Web.Optimisation : ou comment optimiser une application ASP.NET en utilisant le regroupement et la minification à la volée du JavaScript et CSS

Pour optimiser le temps le chargement d’une page, on peut avoir recours à plusieurs techniques côté client et côté serveur dont la mise en cache, l’utilisation d’un CDN ou encore la compression et la minification du CSS et JavaScript.

Dans ce billet de blog, je vais montrer comment vous pouvez grandement améliorer le temps de chargement des pages de votre site Web en minifiant et en regroupant vos fichiers JavaScript et CSS grâce à la bibliothèque ASP. NET Optimization – Bundling.

Le regroupement et la minification sont des procédés de réduction de la taille des fichiers en les combinant, et en supprimant les espaces et autres caractères inutiles. Ces méthodes permettent de rendre l’exécution d’une page Web plus rapide avec le moins de demandes de chargement des fichiers.

Pour commencer, vous allez créer une nouvelle application ASP.NET WebPages avec WebMatrix en utilisant le modèle de projet Starter Site.

Comme l’illustre l’image ci-dessous, vous constatez que votre application contient par défaut un nombre déjà assez important de fichiers JavaScript et CSS.

Si vous exécutez votre application et que vous analysez les performances de votre page d’index avec un outil comme Yslow, vous obtenez le résultat suivant :

Ajout de la bibliothèque ASP.NET Optimization – Bundling

WebMatrix 2 apporte comme nouveauté phare l’intégration du gestionnaire de packages open source .NET NuGet. Dans la boite à outil de l’EDI, une nouvelle icone NuGet est disponible, permettant d’accéder à l’interface des gestions des packages de votre application. Cliquez sur ce bouton.

L’interface de gestion des packages de NuGet s’affiche. Pour plus de détail sur son utilisation, lire mon article sur l’intégration du gestionnaire d’extensions et de NuGet dans WebMatrix 2.

Dans la zone de recherche, tapez le nom de la bibliothèque « Microsoft.Web.Optimization », sélectionnez le package ASP.NET Optimization – Bundling, et cliquez sur Installer.

La fenêtre contenant les termes de la licence va s’afficher. Cliquez sur j’accepte pour lancer l’installation du package dans votre application. A la fin de l’installation, si vous ouvrez le dossier Bin de votre application, vous verrez la présence d’un nouveau fichier Microsoft.Web.Optimization.dll.

Activation du Bundling

Grâce à NuGet, nous avons intégré sans difficulté la bibliothèque dont nous avons besoins dans notre application. Voyons maintenant comment nous pouvons activer le regroupement et la minification du CSS et JavaScript.

Pour cela, ouvrez le fichier _AppStart.cshtml et inserez la ligne de code suivant :

BundleTable.Bundles.EnableDefaultBundles();

N’oubliez pas d’ajouter une référence à Microsoft.Web.Optimization.

@using Microsoft.Web.Optimization

Tous les fichiers JavaScript contenus dans le répertoire Scripts (les sous dossiers ne sont pas pris en compte) de votre application seront regroupés, compressés et traités comme un seul fichier. Ces fichiers seront regroupés par défaut dans un dossier Scripts. Ils seront désormais référencés en utilisant la ligne de code suivante :

<script src="~/Scripts/js" type="text/javascript"></script>

De même, les fichiers CSS contenus dans le répertoire Content seront également compactés par défaut dans un dossier Content. Ils seront référencés en utilisant la ligne de code suivante :

<link href="/Content/css" rel="stylesheet" type="text/css" />

Après avoir appliqué ces modifications, exécutez à nouveau votre application. Vous allez obtenir le résultat suivant :

En comparant les deux images, vous vous rendez compte que le nombre de requêtes HTTP sur votre page est passé de 30 à 10. Les cinq fichiers JavaScript ont été regroupés en 1 fichier et les 16 feuilles de styles ont été combinés en 1 fichier.

De même, la taille des fichiers JavaScript est passée de 558,9 Ko à 375,1 Ko. C’est déjà pas mal. Mais, on aurait pu faire mieux, car plusieurs fichiers dans le dossier Scripts qui ont été regroupés n’ont pas été utilisés. C’est à ce niveau qu’intervient le Bundle personnalisé.

Bundle personnalisé

Avec cette option, vous avez la liberté dans le choix des fichiers qui seront dans un regroupement, ainsi que l’URL qu’aura le regroupement. À ce stade, le choix des dossiers de regroupement doit être fonction de la récurrence des fichiers JavaScript et CSS dans les pages de votre application.
Vous pouvez définir vos regroupements personnalisés en procédant comme suit dans le fichier_çAppStart.cshtml.

BundleTable.Bundles.EnableDefaultBundles();
 
    var jsBundle = new Bundle("~/Scripts", typeof(JsMinify));
    
    jsBundle.AddFile("~/Scripts/jquery-1.6.2.min.js");
    jsBundle.AddFile("~/Scripts/jquery-ui-1.8.11.js");
    jsBundle.AddFile("~/Scripts/modernizr-2.0.6-development-only.js");
   
 
    BundleTable.Bundles.Add(jsBundle);
 
    Bundle cssBundle = new Bundle("~/Styles", typeof(CssMinify));
    cssBundle.AddFile("~/content/site.css");
    cssBundle.AddFile("~/content/themes/base/jquery.ui.all.css");
 
    BundleTable.Bundles.Add(cssBundle); 

Vous allez désormais référencer ces regroupements dans votre page comme suit :

<link href="~/Styles" rel="stylesheet" type="text/css" />
<script src="~/Scripts" type="text/javascript"></script>  

En exécutant la page précédente de votre application, vous obtenez le résultat suivant :

Et voilà, la taille de vos fichiers JavaScript passe de 558,9K à 5,7K, soit un taux de compression de près de 98 %.
Vous pouvez également ajouter à votre regroupement tous les fichiers JavaScript d’un répertoire précis en procédant comme suit :

Et voilà, vous pouvez désormais améliorer assez simplement le temps de chargement des pages de votre application JavaScript grâce à la bibliothèque ASP. NET Optimization – Bundling.

Pour rappel, WebMatrix est un environnement de développement Web léger « tout-en-un », robuste et surtout gratuit, développé par Microsoft.

Cette mouture qui marque une étape importante dans le cycle de développement de l’EDI s’aligne avec la vision de Microsoft : fédérer l’ensemble de la pile Web et des outils dont les développeurs ont besoin pour créer des applications Web au sein d’un outil.

WebMatrix 2 RC s’arrime au développement mobile en proposant des outils permettant de mettre sur pied facilement des applications Web Mobiles. Les modèles pour ASP.NET, Node.js et PHP ont été mis à jour pour être plus mieux adaptés pour un affichage sur les terminaux mobiles. Le rendu des vus spécifiques en fonction des dispositifs (Tablette, iPhone, Windows Phone, etc..) est désormais possible.

L’EDI dispose par défaut des émulateurs allégés pour Windows Phone, iPad et iPhone, permettant d’avoir un aperçu rapide du fonctionnement de son site Web sur ces dispositifs. Des travaux sont en cours pour intégrer encore plus d’émulateurs.

Le support de JQuery Mobile est également au rendez-vous (auto-complexion, etc.). Plusieurs modèles de projets mobiles reposent sur la bibliothèque JavaScript.

La complexion de code pour HTML5, CSS3, JQuery est au menu. L’EDI repose sur la version 2 de WebPages qui dispose d’un nombre assez intéressant d’améliorations par rapport à la version 1. Le support de Node.js est également au centre de la RC de WebMatrix 2, qui propose de nouveaux modèles de projets, l’IntelliSense pour Node.js et la coloration de code pour Jade/EJS.

WebMatrix 2 RC offre un support encore plus étroit de Windows Azure, la plateforme Cloud de Microsoft.

WebMatrix 2 RC dispose d’un nombre assez impressionnant de nouvelles fonctionnalités par rapport à la bêta. Je viens à peine de commencer à jouer avec ces nouveautés, et je peux dire que je suis déjà assez impressionné et captivé par cet EDI que j’ai adopté depuis la sortie de la première version.
Je reviendrais sur certains de mes billets de blog sur les nouveautés qui auront le plus attiré mon attention au fur et à mesure que je découvrir cette RC de WebMatrix 2.

– Télécharger WebMatrix 2 RC

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.

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 avec 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 donc décidé de fournir au travers de cet article une démarche pas à pas avec autant que possible des détails 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. Mais, il est néanmoins conseillé que vous vous soyez 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.

Description des outils de travail

WebMatrix

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

Lire le 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. L’EDI est téléchargeable sur cette page.

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 repose les pages Web ASP.NET écrites avec WebMatrix.

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 des applications Web fonctionnelles et sophistiquées.

Lire mon tutoriel sur la présentation de Razor.

SQL Server Compact Edition

SQL Server Compact Edition. Est un gestionnaire de base de données relationnelle compact, gratuit, mis au point par Microsoft pour le développement des applications pouvant s’exécuter sur des ordinateurs de bureau et les 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 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.

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

Cette approche permet de définir tout d’abord les objets dans le code, ensuite utiliser EF pour créer la base de données correspondante.

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.

Lire mon tutoriel sur la présentation de NuGet.

Dans la seconde partie, nous allons créer l’application, installer Entity Framework à partir de NuGet et créer le modèle objet pour nos entités.