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