1. Accueil
  2. Tutoriels
  3. C# / .NET

Tutoriel détaillé de WSSF Modeling Edition avec base de données SQL 2005

Dernière mise à jour le par pijaku .

Tutoriel pour la création d'un service web (WCF) avec Service Factory Modeling Edition en relation avec une base de données SQL Serveur 2005

Préambule

Ce tutoriel présente, de façon détaillée, la conception d'un WEB SERVICE avec le Web Service Software Modeling Edition. Il part de la création d'une base de données avec SQL Server 2005 à la conception d'une application qui permet d'authentifier les clients qui veulent se connecter à l'application.
Si le client existe, on lui renvoie sa catégorie (admin, fournisseur,...), sinon on lui renvoie "aucun".
Ce tutoriel a pour but de vous faire découvrir (en français) ce logiciel (wssf) qui est un casse tête pour un débutant.

Introduction

Ce tutoriel propose une méthode simple et illustrée pour créer un service web qui fait une authentification des utilisateurs puis les redirige sur les pages appropriées. Ces démarches, que nous allons voir ensemble, sont issues des recherches en ligne et dans les documentations accompagnants chaque logiciel utilisé.

Pré requis

Pour mener notre projet à bien, nous aurons besoin de ces outils à disposition et déjà installés sur le poste :

Voilà tout. Pour les installations, rien de compliqué, suivez les assistants d'installation de vos logiciels (>_<) !

La création de la base de données

Ouvrez Microsoft SQL Server Manager Studio Express et connectez vous à votre base.

Nous allons faire simple. Pour cela, on va créer une nouvelle base de donnée qui va contenir une seule table.

Pour cela faire un clic droit sur Base de données et choisir nouvelle base de données.

Donnez un nom à votre base de données et appuyez sur le bouton OK. Laissez les autres champs comme tels

Sélectionnez le dossier Tables dans votre BDD (ici Utilisateurs) puis cliquez sur Nouvelle table...

Créez la table comme indiqué sur la figure ci-bas :

Définissez l'id comme une clé primaire en sélectionnant la ligne id puis dans la barre des outils en haut, appuyez sur la clé (petit dessin en dessous de Nouvelle requête).

En bas dans la Propriétés des colonnes, cherchez Spécification du compteur et double-cliquez sur (Est d'identité) pour mettre sa valeur à Oui.

Cette propriété définit l'auto incrémentation de la clé primaire en commençant par 1 et en sautant de 1.

Enregistrez la table en lui donnant le nom de votre choix : ici users.

Nous allons remplir la table avec quelques données que l'on pourra visualiser avec notre Web Service. Pour cela, cliquez sur Nouvelle requête dans la barre des outils et insérez des codes sql comme suit :

Vérifiez bien que vous êtres dans votre base de données :

Puis, tapez le code d'insertion dans une table.

Validez puis exécutez le code. Répétez cette méthode autant de fois que vous voulez insérer des données dans la table.

Je vous conseille d'insérer un fournisseur et un biologiste à titre d'exemple.

Les Procédures stockées
Rien de compliqué, nous allons créer des procédures dans notre BDD. Elles vont nous permettre d'exécuter des requêtes sur la BDD rien qu'en changeant les paramètres de la procédure.

Pour y arriver, déroulez l'arborescence de votre BDD puis cherchez le dossier Programmabilité. A l'intérieur se trouve aussi le dossier Procédures stockées.

Clic droit sur ce dossier et Nouvelle procédure Stockée.

Une fenêtre s'ouvre avec des commentaires. Effacez tout le contenu et remplissez par ce code :

Validez puis exécutez le code. Après, vous effacez tout le contenu puis vous réécrivez un nouveau code comme ceci :

Puis un autre pour obtenir les infos d'un utilisateur en donnant son nom en paramètre :

Puis un dernier code (le plus important de tous ^_^) pour obtenir la catégorie d'un utilisateur qui entre son nom et son mot de passe :

Faites un clic droit sur le dossier Procédures Stockées puis Actualiser pour voir vos procédures apparaître.

Un joli PDF expliquant les procédures stockées se trouve ici : ftp://www.ftp-developpez.com/sqlserver/SQLServer.pdf .

Pour ce qui concerne la base de données, tout est fini à son niveau. On entame l'application proprement dite dans Visual Studio 2005.

Création des 3 couches de contrats

Ouvrez Visual Studio 2005 puis choisissez nouveau projet :

Donnez un nom au projet puis validez. Ici Authentification.

Faire ensuite menu Tools Guidance Package Manager.

Appuyez sur le bouton Enable / Disable Packages... puis cochez la case de Repository Factory comme indiqué ci-dessous.

Créer un Data Contract (contrat de données)

Pour cela suivez la figure : clic droit sur la plaque blanche (^_^) Add New Model...

Donner un nom (n'importe quoi) et un namespace (n'importe quoi aussi ^_^)

Puis validez :

Créer un model correspondant à celui ci-dessous :

Login et Mot_de_passe sont de type String (par défaut) ainsi que NomEtPassIncorrects. Pour les créer, vous devez choisir après avoir fait un clic droit sur Members, Add new Primitive Data Type.

Pour le lien entre ListeDesUtilisateurs et Identité, choisissez le carreau représentant le Data Contract Collection (ListeDesUtilisateurs) puis dans la fenêtre propriété, choisissez Identité comme valeur pour le champs Data Contract.

Création du contrat de service

Pour cela, suivez les mêmes étapes que précédemment :

Puis ceci :

Construisez le model comme ce qui suit :

N'oubliez pas le sens des flèches de connexion. (La requête entre dans l'opération, puis la réponse sort de l'opération).

A prendre en compte :

Message RequeteLogin :
ValeursDentrée est de type Data Contract Message Part. Pour le créer il faut choisir ceci : Add new Data Contract Message Part.

Message ReponseLogin :
CategorieUtilisateur est de type Primitive Message Part. Pour le créer il faut faire ceci :

La variable créée est de type string :

Operation ValiderLogin :
Erreur est de type Data Contract Fault. Pour le créer, faites un clic droit sur Faults puis Add new Data Contract Fault.

Relation entre les deux models créés (Data contract et Service Contract)

Sélectionnez le model du service contract que l'on vient de créer. Cliquez dans l'espace blanc du model (pour qu'aucune autre fenêtre ne soit sélectionnée).

Dans la fenêtre propriété du model changez :

Implementation Technology >>> WCF Extension

Serializer Type >>> DataContractSerializer.

Puis sélectionnez Operation ValiderLogin. Cliquez sur Erreur (sous le mot Fault), puis, dans la partie Propriété : Type, cliquez sur le bouton (...) pour ouvrir cette fenêtre :

Déroulez les (+) jusqu'à choisir ErreurLogin (Fault Contract) puis OK.

Sélectionnez ValeursDentrée dans RequeteLogin puis dans Propriété : Type cliquez sur (...) puis dans la fenêtre, choisissez Identité (Data Contract Base) puis OK.

Sélectionnez la fenêtre de data contract que nous avions créée puis cliquez dans l'espace blanc pour désélectionner toutes les formes. Dans la fenêtre propriété du model changez :

Implementation Technology >>> WCF Extension

Toujours sur la fenêtre de Data Contract, sélectionnez Mot_de_passe dans la case Identité puis dans les Propriétés, changez l'ordre à 1.

Puis, sélectionnez le Data Contract Collection (ListeDesUtilisateurs) puis dans la partie Propriétés >> Collection Type : prendre List<T> comme valeur.

C'est tout pour cette étape. N'oubliez pas de tout sauvegarder de temps en temps.

Création du model d'hôte en technologie WCF

Implémenter la technologie WCF

Sélectionnez le nom de votre projet tout en haut puis un clic droit Add WCF Implementation Projects...

Donnez un nom au Service que vous aller créer. Ici LoginService.

Patientez pour que des milliers de dossiers se créent. (10 dossiers pour être exact) ^_^ !

Ouvrez la fenêtre de Service Contract (si ce n'est déjà fait), et cliquez dans l'espace blanc de la fenêtre pour désélectionner les autres carreaux. Puis, dans propriété Project Mapping Table, donnez lui comme valeur le nom du service WCF que nous venons de créer. ( ici LoginService)

Répétez la même manipulation pour la fenêtre de Data Contract.

Créer votre model d'hôte

Sur votre plaque blanche portant le nom de votre projet (il doit se trouver tout en bas maintenant), faites un clic droit puis Add New model. (on a l'habitude maintenant ^_^ !)

Choisissez dans la fenêtre qui s'ouvre Host Model, puis donnez un nom (ici hote) et un namespace (ici urn : test). Puis validez par Finish.

Vous obtenez une nouvelle fenêtre comme ceci :

Voici ce que vous allez construire à partir de la fenêtre Host Explorer :

Cliquez droit sur Host Model (tout en haut) puis Add New Host Application.

Dans la fenêtre propriété, changez le nom de l'hôte (ou gardez-le (>.<)) (ici HostLogin)
Puis dans la propriété Implementation Technology, donnez lui la valeur WCF Extensions.

Enfin dans la case Implementation Project, déroulez la liste jusqu'à sélectionner le dossier Host dans Tests qui à été généré, puis double cliquez dessus.

Maintenant, faites un clic droit sur le nom de l'hôte que vous avez créé précédemment (ici HostLogin), puis Add New Service Reference.

Dans la fenêtre de propriété, faites :

Donnez un nom à votre Service Reference (ici ServiceReferenceLogin)
Mettez la valeur de Enable MetaData Publishing à True (pour qu'il soit visible pour le client).

Puis dans la case Service Implementation Type, cliquez sur le (...) pour avoir une fenêtre dans laquelle vous allez choisir le nom du service que nous avions créé auparavant (ici ServiceLogin) puis validez par OK.

Faites un clic droit sur le nom du service de référence créé précédemment (ici ServiceReferenceLogin) puis choisissez Add New Endpoint
.

Dans la fenêtre de propriété, faites les manipulations suivantes :

Donnez un nom à votre Endpoint (ici EndpointLogin) ou laissez si ça vous chante (^_^).
Dans la case {red|Binding Type}}, en bas, choisissez la valeur wsHttpBinding.

C'est tout pour l'instant en ce qui concerne l'hôte. Nous allons faire le model du client aussi.

Pour cela, cliquez droit sur Host Model (tout en haut) puis Add New Client Application.

Dans la fenêtre de propriété :

Donnez un nom à votre Client Application (ici ClientLogin)
Dans Implementation Technology, choisissez WCF Extensions.

Puis dans Implementation Project, déroulez la liste jusqu'à choisir le dossier .Client dans Tests puis double cliquez dessus.

Sur le nom de l'application cliente construite précédemment, faites un clic droit puis choisir Add New Proxy.

Dans la fenêtre de propriété, donnez un nom à votre proxy (ici ProxyLogin).
Puis, dans la case Endpoint, déroulez la liste puis choisir le nom du Endpoint que nous avions créé pour l'hôte. (ici EndpointLogin)

Et sauvegardez tout (je ne le dirai plus (>_<) !)

La génération de code

Nous voici dans la dernière ligne droite pour cette deuxième partie.

Tout d'abord, nous allons générer les codes de Data Contract, puis ceux de Service Contract et enfin ceux de l'hôte et du client qui sont un peu spéciaux.

Ouvrez ou sélectionnez la fenêtre de Data Contract, puis cliquez droit dans l'espace blanc puis choisissez Validate All.

Si tout se passe bien, nous n'aurons pas d'erreurs ! (Prions ! ! (^_^) !)

Pas d'erreurs non plus si tout se passe bien. Juste des WARNING (avertissements).

Faites les mêmes manipulations pour la fenêtre de service contract :

Validez le model : clic droit Validate All.
Puis générez les codes : Generate Code.

Ne vous inquiétez pas ! Il n'y aura pas d'erreurs si vous avez tout suivi à la lettre ^_^ !

Pour le model hôte, nous allons patienter puis le faire dans la 3e session. C'est faisable maintenant mais patientez quand même ! (^_^) !

Intégration de la base de données avec Repository Factory

Connexion à la BDD

Dans la Solution Explorer, faites un clic droit sur votre dossier .Host (ici C:\...\ LoginService.Host) qui se trouve dans le dossier Tests, puis sélectionnez Repository Factory, puis Specify project responsibility.

Vous obtenez cette fenêtre.

Cochez la case Host Project puis Finish.

Faites la même chose sur le dossier LoginService.DataAccess dans le dossier Ressource Access.

Puis cochez la case Data Access Project et validez.

Répétez cela pour le dossier LoginService.BusinessEntities qui est dans le dossier Business Logic.

Puis cochez la case Business Entities Project et validez.

Revenons sur le premier dossier traité, celui de l'hôte. Faites un clic droit sur ce dernier, sélectionnez Repository Factory puis Add database connection.

Dans la fenêtre qui s'ouvre, donnez un nom à votre connexion (ici ConnectionString) puis cliquez sur les points (...) de la seconde zone grise.

Sélectionnez Microsoft SQL Serveur puis OK. Une nouvelle fenêtre apparaît.

Cliquez sur la liste déroulante pour choisir le nom de votre serveur (Server Name). Patientez un peu pour que la liste apparaisse. Puis choisissez le nom de votre serveur qui apparaît.

NB : Il se peut que ce nom n'apparaisse pas et que la lite soit vide : galère (>_<)

Pour y remédier, démarrer votre manager de BDD à savoir SQL Serveur Manager Studio Express, puis la fenêtre Se connecter au serveur, copier le champ Nom du serveur (ici JEAN-CFBCBE47EB\SQLEXPRESS).

Allez coller ce nom dans le champ de Serveur name dans votre fenêtre sous Visual Studio.

Remplissez les autres champs comme le nom (ici sa=super administrateur), le mot de passe (ici ************* (>_<)) et sélectionnez la base de données que vous avez créée dans la partie 1 de ce tutoriel.

Testez la connexion puis validez. Cliquez sur Finish pour la première fenêtre aussi.

Créer des procédures stockées (encore (>_<) !)

Pour cela, faites un clic droit sur le sous dossier LoginService.DataAccess dans le dossier Ressource Access puis sélectionnez Repository Factory puis Create CRUD stored procedures.

Dans la nouvelle fenêtre, choisir le chemin de l'hôte dans ServiceHost Project, puis dans le second champ, choisissez le nom de connexion que vous aviez donné lors de la connexion à la base. (Ici ConnectionString). Puis faites Next.

Dans le second onglet qui apparaît, déroulez l'arborescence puis cochez les cases des tables que vous voulez importer. (Ici une seule table : users).

Puis faites Next. (Ce bouton met plus de 3 secondes pour apparaître parfois (^_^)).

Dans le 3e onglet, on vous propose les procédures qui vont être créées. Choisissez selon votre humeur (>_<) mais cela ne sert pas à grand-chose car nous avons déjà créé personnellement ces procédures dans la partie 1 du tuto.

Ici nous les gardons toutes cochées. Puis Next.

Donnez enfin un nom à votre fichier qui va stocker ces procédures au niveau de l'application. (Ici monSP) puis Finish.

Créer les entités à partir de la base de données

Pour y arriver, cliquez droit sur le sous dossier ServiceLogin.BuinessEntities qui se trouve dans le dossier Business Logic. Choisissez Repository Factory puis Create business entities from database.

Un nouvel assistant s'ouvre.

Sur la première face de cette fenêtre, sélectionnez le nom de l'hôte puis le nom de la connexion (ConnectionString) puis Next.

Dans la seconde face de cette fenêtre, sélectionnez la (les) table(s) que vous voulez importer puis Next. Patientez si le bouton Next ne s'allume pas vite. (Décochez et recochez ces tables et le bouton apparaîtra ^_^).

La 3e face de la fenêtre vous donne la possibilité de changer les noms et types de vos entités.

Mais laissez tout comme tel et faites Finish.

Une classe portant le nom de votre entité (table de la BDD) est générée dans le dossier de BusinessEntities. (Ici users).

Créer un entrepôt de données à partir des entités

Pour cela, faites un clic droit sur le sous dossier LoginService.DataAccess dans le dossier Ressource Access puis sélectionnez Repository Factory puis Create data repository classes from business entities.

Une fenêtre d'assistance s'ouvre encore. Pour la première partie de la fenêtre (cela devient une habitude >_< !), choisissez le nom de l'hôte puis le nom de la connexion (ConnectionString), puis faites Next.

Dans la face deux, sélectionnez le chemin vers votre dossier BusinessEntities (D'habitude c'est automatique, mais vérifiez si c'est le bon nom quand même ^_^). Faites Next.

Sélectionnez votre (vos) entité(s) dans la 3e face de cette fenêtre puis Next.

Dans la dernière partie de la fenêtre, cliquez sur le bouton Add... puis sélectionnez Get One.

Vous obtenez une fenêtre pour le mapping.

Dans la liste déroulante de Stored procedure, sélectionnez la procédure qui s'appelle GetUtilisateurParId. C'est nous même qui l'avons créée dans la base.

Gardez le nom tel qu'il est (pour ne pas l'oublier), et faites Next.

Une nouvelle face de la fenêtre apparaît. Le mapping (correspondance des attributs de la table) est automatique. Si ce n'est pas le cas, arrangez vous à créer un mapping identique à celui de la figure ci-bas.

Puis faites Finish.

Vous revenez dans la fenêtre du premier assistant. Faites Add... puis Get One.

Et dans la nouvelle fenêtre, sélectionnez dans la liste déroulante de Stored procedure, le nom GetUtilisateurCategorieParNomEtPass puis faites Next.

Vous devez obtenir une fenêtre identique à celle sur la figure ci-bas.

Faites Finish, puis sur la première fenêtre, faites Finish aussi.

Pour notre exemple, nous allons nous contenter de ces deux procédures. Rien ne vous empêche d'en créer plus si vous le voulez ^_^.

On remarque qu'un nouveau dossier BusinessEntities.usersRepositoryArtifacts a été créé avec des codes générés pour chaque procédure.

Le plus intéressant de ces codes est celui portant le nom de votre entité ajouté du mot Repository. (Ici usersRepository.cs).

Nous le verrons plus tard.

Ajouter une classe de connexion de l'entrepôt à la BDD

Sur le dossier LoginService.BusinessLogic, faites un clic droit puis sur Add et sélectionnez Class...

Donnez lui exactement le nom de Repositories.cs (pour moi c'est un nom très significatif (>_<) !) puis validez avec Add.

Dans ce nouveau fichier, recopiez exactement ce bout de code. C'est un code qui ne change pas quelques soient les entités et quelque soit la BDD.

using System;
using System.Collections.Generic;
using System.Text;
using WCFServiceLogin.DataAccess.BusinessEntities.usersRepositoryArtifacts;

namespace WCFServiceLogin.BusinessLogic
{
    public static class Repositories
    {
        private const string databaseName = "ConnectionString";
        private static usersRepository usersRep = new usersRepository(databaseName);

        public static usersRepository Users
        {
            get { return usersRep; }
        }
    }
}

Enregistrez le fichier.

Nous allons ajouter des références à la couche de Business Logic.

(Une référence est comme une bibliothèque en langage C.)

Sur le dossier LoginService.BusinessLogic, faites un clic droit puis Add Reference...

Une fenêtre s'ouvre. Sous l'onglet Browse, collez cette adresse

(C:\Program Files\Microsoft Patterns & Practices\Data Access Guidance Package Setup\Microsoft.Practices.Repository.dll) dans le champ Nom du fichier puis appuyez sur OK.

Une référence Microsoft.Practices.Repository s'ajoute dans le dossier Reference de LoginService.BusinessLogic.

Réécriture de la méthode d'opération

La méthode d'opération est celle qui reçoit la requête du client pour lui renvoyer la réponse. Elle a été générée automatiquement par le WSSF lors de l'étape de génération de code du Service Contract. Cette méthode se trouve dans la classe ServiceLogin.cs dans le sous dossier GeneratedCode du bloc LoginService.ServiceImplementation.

Cette méthode s'appelle ValiderLogin et prend en paramètre la requête pour retourner une valeur de type réponse.

Faites un clic droit sur le dossier LoginService.ServiceImplementation puis dans le menu qui s'ouvre, sélectionnez Add puis New Item...

Donnez exactement le même nom que celui du fichier qui se trouve dans le dossier GenerateCode de ServiceImplementation. Il s'agit ici de ServiceLogin.cs.

Puis validez par OK.

Vous allez devoir ajouter de nouvelles références au bloc de LoginService.ServiceImplementation. Pour cela, un clic droit sur ce dossier puis dans le menu, cliquez sur Add Reference...

Dans la nouvelle fenêtre sous l'onglet Projects, choisissez LoginService.DataAccess. Faites OK pour accepter.

Recommencez la même manoeuvre pour ajouter une autre référence.

Sous l'onglet Recent, choisissez Microsoft.Practices.Repository.dll puis validez par OK.

Remarque : Si dans l'onglet Recent rien n'apparaît, effectuez alors les mêmes instructions décrites dans le paragraphe 3.5 mais sur le dossier de service implémentation (dossier actuellement traité par cette section du tuto).

Une fois terminé, on aura ceci :

Vous allez recopier intégralement ce morceau de code dans le nouveau fichier créé. J'y ai ajouté des commentaires rien que pour vous (^_^) !

using System;
using System.Collections.Generic;
using System.Text;
using LoginService.MessageContracts;
using LoginService.BusinessLogic;
using LoginService.BusinessEntities;

namespace LoginService.ServiceImplementation
{
    public partial class ServiceLogin
    {
        public override ReponseLogin ValiderLogin(RequeteLogin request)
        {
            // Déclaration d'une nouvelle instance de type réponse.
            // Il va contenir le message de sortie.
            ReponseLogin reponse = new ReponseLogin();

            //Bloc pour gerer l'opération et garder un oeil sur les erreurs
            try
            {
                // On va insérer la réponse de la requête dans une entité.
                // On utilise ici une procédure qui prend le nom et le pass pour renvoyer
                //la catégorie du client.
                users utilisateur = Repositories.Users.
                GetUtilisateurCategorieParNomEtPass(request.ValeursDentrée.Login,
                request.ValeursDentrée.Mot_de_passe);

                //On récupère la catégorie de l'utilisateur que l'on met ensuite dans la réponse
                reponse.CategorieUtilisateur = utilisateur.categorie;
            }
            catch (Exception)
            {
                //en cas d'échec, on renvoi le mot "aucun"
                reponse.CategorieUtilisateur = "aucun";
            }
            return reponse;
        }
    }
}

Génération de code pour l'hôte et le client

Nous allons maintenant générer les codes pour le model d'hôte que nous avons déjà créé.

Pour cela, ouvrir le model en double cliquant dessus (si ce n'est déjà fait).

Déroulez l'arborescence du model dans le Host Explorer puis sélectionnez le service de référence (ici ServiceReferenceLogin), puis cliquez sur le lien Generate Service dans la fenêtre de l'hôte.

Patientez juste un peu puis retournez dans l'onglet de Solution Explorer.

Faites un clic droit sur le nom de votre solution (tout en haut) puis sélectionnez Build Solution.

Tout le projet est compilé avec zéro erreur} (si vous avez suivi toutes mes instructions (^_^) !). La preuve ? La voici (>_<).

Sélectionnez le dossier de l'hôte dans la Solution Explorer puis faites un clic droit sur le dossier de l'hôte (C :\...\LoginService.Host) et sélectionnez ensuite View in Browser.

Un mini serveur est démarré dans votre barre de tâche.

Retournez dans le Host Explorer puis cette fois-ci, sélectionnez le proxy. (Ici ProxyLogin). Cliquez maintenant sur le lien Generate Proxy dans la fenêtre de l'hôte.

Un nouvel assistant s'ouvre pour vous laisser configurer le client

Faites Next pour aller à la seconde page de cet assistant. Patientez pendant que cet assistant charge les données du serveur...(>,<) !

Une fois faites, sélectionnez le Endpoint (c'est automatique, à moins d'en avoir plusieurs dans l'hôte) puis faites Next.

Choisissez un certificat valable pour votre connexion cliente.

Pour cela, cliquez sur le bouton à côté de la zone de description. Dans la petite fenêtre qui s'ouvre, choisissez les valeurs comme LocalMachine puis Root et cliquez sur le bouton Browse...

Sélectionnez un certificat (le premier fera l'affaire (^_^)) dans la petite nouvelle fenêtre puis faites OK.

Cliquez sur Accept puis Finish pour terminer cet assistant.

Patientez le temps que le code du Proxy (ProxyLogin.cs) soit généré. Si tout se passe bien on n'aura pas d'erreurs.

Tout est fini. Il ne nous reste qu'à écrire le code client pour qu'il puisse se connecter au serveur et s'identifier.

Consommation du service par le client

Pour cette dernière partie, nous allons créer une interface graphique pour le client afin qu'il puisse entrer son nom et son mot de passe. Le service de Login (Serveur) va lui renvoyer la catégorie d'utilisateur à laquelle il appartient.

Dans le cas où les données du client sont fausses le serveur lui envoie un message d'erreur.

Construire l'interface du client

Dans la Solution Explorer, sélectionnez le dossier du client (ici LoginService.Client) puis localisez le fichier MainForm.cs. Double cliquez dessus pour l'ouvrir

Reconstruisez cette interface pour l'adapter à vos besoins comme ceci :

Cette fenêtre contient des composants suivants :
label textBox maskedTextBox button.

Sélectionnez le maskedTextBox puis mettez la valeur * dans le champs PasswordChar pour que le mot de passe ne soit pas visible.

Codage du Client

Double cliquez sur le bouton Connexion de votre interface pour accéder au fichier de code.

Tout en haut de la page et en bas des « using » rajoutez cette ligne :

using LoginService.Client.ProxyLogin;

Puis dans la méthode de votre bouton, insérez le code suivant :

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using LoginService.Client.ProxyLogin;

namespace LoginService.Client
{
    public partial class MainForm : Form
    {
        public MainForm()
        {
            InitializeComponent();
        }

        private void ExecuteButton_Click(object sender, EventArgs e)
        {
            //TODO: Call proxy method
            // Instancier le service client. Cette classe se trouve dans le fichier de le code de proxy et varie selon le service. Jettez y un oeil.
            ServiceContractloginClient client = new ServiceContractloginClient();

            //Créer une requête à partir des données entrées par le client
            RequeteLogin requete = new RequeteLogin();

            //Initialiser les pointeurs des valeurs d'entrées
            requete.ValeursDentrée = new Identité();

            //on récupère les valeurs des champs de texte pour les insérer dans la reqûete
            requete.ValeursDentrée.Login = textBox1.Text;
            requete.ValeursDentrée.Mot_de_passe = maskedTextBox1.Text;

            //instanciation d'un objet de type réponse pour récupérer la réponse du serveur
            ReponseLogin reponse = new ReponseLogin();

            //appel de la méthode de validation du proxy. Il prend la requête en paramètre
            //et nous renvoie la réponse contenant la catégorie de l'utilisateur
            reponse.CategorieUtilisateur = client.ValiderLogin(requete.ValeursDentrée);

            //Afficher les résultats sous forme de boite de dialogue
            if (reponse.CategorieUtilisateur.Equals("aucun"))
            {
                MessageBox.Show("Erreur! vos informations sont fausses", "Validation de Login", MessageBoxButtons.OK,
                MessageBoxIcon.Error);
            }
            else
                MessageBox.Show("Votre identité est correcte! vous êtes '" + reponse.CategorieUtilisateur + "'", "Validation de Login", MessageBoxButtons.OK,MessageBoxIcon.Information);
            }
        }
    }
}

Il ne vous reste qu'à tout sauvegarder, puis tout compiler avant d'exécuter le client.

Pour exécuter le client, cliquez sur le dossier du client dans Solution Explorer (ici LoginService.Client) puis sélectionnez Debug et enfin Start new instance.

Voyons ce que cela donne :

Entrez le nom admin et le mot de passe admin (ce qui est correct au niveau de la BDD) et cliquez sur Connexion. Patientez un peu et voyez le résultat.

Entrez cette fois -ci des données fausses puis attentez le résultat :

C'est évident n'est ce pas ? (>_<)

Vous pouvez vous servir de ces informations pour rediriger les clients sur d'autres pages

Ce document intitulé « Tutoriel détaillé de WSSF Modeling Edition avec base de données SQL 2005 » issu de CodeS SourceS (codes-sources.commentcamarche.net) est mis à disposition sous les termes de la licence Creative Commons. Vous pouvez copier, modifier des copies de cette page, dans les conditions fixées par la licence, tant que cette note apparaît clairement.
3 Commentaires