  .NET 3.0 : Présentation du Windows Communication Foundation (WCF)
[40 mn de lecture - paru le 11/5/2006 6:45:43 PM - Public : Confirmé]
|
|
Auteur
4 Demo : Développer un mini service d'annuaire
Dans cette démo, nous allons développer un mini service d'annuaire qui nous permettra d'ajouter, mettre à jour et supprimer un contact matérialisé par un Nom, prénom, téléphone et une adresse email.
Le programme client ressemblera à cela :
Et le serveur :
4.1 Création du service MonPremierServiceWCF
Commençons donc par créer une solution nommée Demo_WCF et un projet nommé MonPremierServiceWCF de type Bibliothèque de classe en C#. Enfin avant de commencer l'écriture du code, ajoutez la référence à System.ServiceModel
4.1.1 Définition du DataContract "Contact"
Notre objet commun dans notre application sera le "Contact". Un contact est une structure contenant un ID (en Guid), un Nom, Prénom, Téléphone et une adresse email (en String).
Créez donc un fichier Contact.cs dont le code sera :
using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.Serialization;
namespace MonPremierServiceWCF
{
[DataContract]
public struct Contact
{
Guid m_ID;
string m_Nom;
string m_Prenom;
string m_Email;
string m_Telephone;
[DataMember]
public Guid ID
{
get { return m_ID; }
set { m_ID = value; }
}
[DataMember]
public string Nom
{
get { return m_Nom; }
set { m_Nom = value; }
}
[DataMember]
public string Prenom
{
get { return m_Prenom; }
set { m_Prenom = value; }
}
[DataMember]
public string Email
{
get { return m_Email; }
set { m_Email = value; }
}
[DataMember]
public string Telephone
{
get { return m_Telephone; }
set { m_Telephone = value; }
}
} }
4.1.2 Création de l'interface IMonPremierServiceWCF Une fois le DataContract définit, nous allons maintenant créer l'interface de notre service. Notre service devra exposer les méthodes suivantes :
- GetAllContacts() qui retourne le dictionnaire de contact.
- GetContactById(Guid) qui retourne le contact en fonction de son ID
- AddContact(Contact) qui ajoute le contact spécifié et retourne un booléen
- UpdateContact(Contact) qui met à jour le contact spécifié et retourne un booléen
- DeleteContact(Guid) qui supprime le contact à partir de son ID passé en paramètre et retourne un booléen
Notre interface sous le fichier IMonPremierServiceWCF.cs ressemblera à:
using System;
using System.Collections.Generic;
using System.Text;
using System.ServiceModel;
namespace MonPremierServiceWCF
{
[ServiceContract()]
public interface IMonPremierServiceWCF
{
[OperationContract]
Dictionary<Guid, Contact> GetAllContacts();
[OperationContract]
Contact GetContactByID(Guid id);
[OperationContract]
bool AddContact(Contact contact);
[OperationContract]
bool UpdateContact(Contact contact);
[OperationContract]
bool DeleteContact(Guid id);
} }
4.1.3 Développement du service Pour finir, il faut maintenant développer la logique de notre service. Créons donc une nouvelle classe nommé MonServiceCls dans le fichier MonServiceCls.cs qui implémente notre ServiceContract : IMonPremierServiceWCF.
Dans notre exemple, les contacts seront simplement enregistrés en mémoire dans un dictionnaire. Vous remarquerez l'ajout d'un Mutex afin de verrouiller le thread lors de la modification du dictionnaire partagé.
Notre classe service sera :
using System;
using System.Threading;
using System.Collections.Generic;
using System.Text;
using System.ServiceModel;
namespace MonPremierServiceWCF
{
public class MonServiceCls : IMonPremierServiceWCF
{
private static Dictionary<Guid, Contact> m_Annuaire = new Dictionary<Guid, Contact>();
private static Mutex m_Mutex = new Mutex();
public Dictionary GetAllContacts()
{
return m_Annuaire;
}
public Contact GetContactByID(Guid id)
{
return m_Annuaire[id];
}
public bool AddContact(Contact contact)
{
try
{
m_Mutex.WaitOne();
contact.ID = Guid.NewGuid();
m_Annuaire.Add(contact.ID, contact);
}
catch (Exception ex)
{
Console.WriteLine("Erreur lors de l'ajout du contact {0} : {1}", contact.Nom, ex.Message);
return false;
}
finally
{
m_Mutex.ReleaseMutex();
}
Console.WriteLine("Le contact {0} à été ajouté", contact.Nom);
return true;
}
public bool UpdateContact(Contact contact)
{
try
{
m_Mutex.WaitOne();
m_Annuaire[contact.ID] = contact;
}
catch (Exception ex)
{
Console.WriteLine("Erreur lors de la mise à jour du contact {0} : {1}", contact.Nom, ex.Message);
return false;
}
finally
{
m_Mutex.ReleaseMutex();
}
Console.WriteLine("Le contact {0} à été mis à jour", contact.Nom);
return true;
}
public bool DeleteContact(Guid id)
{
string nom = null;
try
{
nom = m_Annuaire[id].Nom;
m_Mutex.WaitOne();
m_Annuaire.Remove(id);
}
catch (Exception ex)
{
Console.WriteLine("Erreur lors de la suppression du contact {0} : {1}", id.ToString(), ex.Message);
return false;
}
finally
{
m_Mutex.ReleaseMutex();
}
Console.WriteLine("Le contact {0} à été supprimé", nom);
return true;
}
}
}
Pour ceux qui ne seraient pas familiarisé avec les Dictionnaires, je vous renvoie sur mon précédent article consacré aux collections sous .NET.
4.2 Création de l'host MaPremiereHostWCF Maintenant notre classe service terminée, nous allons donc rajouter un projet de type Application Console dans notre solution pour héberger notre service.
Notre projet se nommera MaPremiereHostWCF et référencera le System.ServiceModel ainsi que notre service MonPremierServiceWCF.
4.2.1 Developpement de classe Host Le code de notre host sera simple : on construit l'object ServiceHost avec le type de notre classe service MonServiceCls.
Notre fichier Program.cs :
using System;
using System.Collections.Generic;
using System.Text;
using System.ServiceModel;
using MonPremierServiceWCF;
namespace MaPremiereHostWCF
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Initialisation du service...");
try
{
ServiceHost maHost = new ServiceHost(typeof(MonServiceCls));
maHost.Open(); foreach(ServiceEndpoint ep in maHost.Description.Endpoints)
{
Console.WriteLine("Contract: {0}\n\tAddress: {1}\n\tBinding: {2}", ep.Contract.Name, ep.Address.ToString(), ep.Binding);
} Console.WriteLine("\nPressez [enter] pour terminer.\n");
Console.Read();
maHost.Close();
}
catch (Exception ex)
{
Console.WriteLine("Erreur: {0}", ex.Message);
Console.Read();
}
}
}
}
4.2.2 Définition du Binding et Address dans l'App.config Pour que notre application Host fonctionne nous allons devoir créer un fichier App.config pour y référencer le service et son EndPoint pour y définir son 'address' et son 'binding'.
Dans cette exemple nous utiliserons les même EndPoint que dans la page précedente à savoir :
- un utilisant le binding standard wsHttpBinding (qui n'est ni plus ni moins que l'équivalent des Webservices ASMX) sur l'adresse http://localhost:8001/MaCalculette
- un autre utilisant le binding standard netTcpBinding (qui protocole TCP) sur localhost port 8002 (adresse URI : net.tcp://localhost:8002/)
Fichier App.config:
<xml version="1.0" encoding="utf-8" ?>
<configuration>
<system.serviceModel>
<services>
<service name="MonPremierServiceWCF.MonServiceCls">
<endpoint
contract="MonPremierServiceWCF.IMonPremierServiceWCF"
binding="wsHttpBinding"
address="http://localhost:8001/MonPremierServiceWCF" />
<endpoint
contract="MonPremierServiceWCF.IMonPremierServiceWCF"
binding="netTcpBinding"
address="net.tcp://localhost:8002" />
</service>
</services>
</system.serviceModel>
</configuration>
4.2.3 Démarrage et vérification du service
Après compilation et execution de l'application Host, vous pourrez
aller sur l'URL de votre service dans votre navigateur et vérifier le
bon fonctionnement du service dans le cas du EndPoint avec le wsHttpBinding.
4.3 Création du client MonPremierClientWCF Votre service étant maintenant opérationnel, nous allons développer une application Winform cliente nommée MonPremierClientWCF.
4.3.1 Ajouter la référence du service
Ayant installé les extensions Orcas, vous trouverez un nouveau bouton dans le menu du clic-droit sur votre projet : "Add Service Reference" :
 En cliquant dessus vous serez amené à entrer l'URI du service (Address) ainsi que son nom :
 Visual Studio créera automatiquement les fichiers de référence du service (Contract) ainsi que le fichier App.config entièrement configuré (Binding, Address).
Le service se trouvera sous le namespace MonPremierClientWCF.MonPremierServiceWCF contenant notre structure Contact, l'interface IMonPremierServiceWCF ainsi que la classe MonPremierServiceWCFClient. Il ne nous reste plus qu'à l'exploiter !
4.3.2 Consommer le service WCF Une fois la référence du service ajoutée, cela devient un jeu d'enfant : on utilise notre service comme une simple classe. Exemple :
// Ouverture du service
MonPremierServiceWCFCLient m_service = new MonPremierServiceWCFClient();
m_service.Open();
// Ajout d'un contact
Contact newContact = new Contact();
newContact.Nom = "warin";
newContact.Prenom = "sebastien";
newContact.Telephone = "0600000000";
newContact.Email = "sebastien@xxxxxxx.xx";
m_service.AddContact(newContact);
// Exemple de parcours des contacts :
foreach(Contact contact in m_service.GetAllContacts().Values)
{
Debug.WriteLine("Bonjour je suis {0}", contact.Nom);
}
De la même manière, nous pouvons supprimer un contact, le mettre à jour, etc..
Pour reprendre la fenêtre de démo, placez sur votre form :
- 1 listview nommé lvContact
- 4 buttons (btNewContact, btAddContact, btDeleteContact et btUpdateContact)
- 4 textbox (txtNom, txtPrenom, txtTelephone et txtEmail)
Et copiez le code :
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using MonPremierClientWCF.MonPremierServiceWCF;
namespace MonPremierClientWCF
{
public partial class Form1 : Form
{ // Champs
public MonPremierServiceWCFClient m_service;
Guid contactSelected = Guid.Empty;
// Constructeur de la form
public Form1()
{
InitializeComponent();
try
{ // Initialisation et ouverture du service
m_service = new MonPremierServiceWCFClient();
m_service.Open();
RefreshList();
}
catch (Exception ex)
{
MessageBox.Show("Erreur: {0}", ex.Message);
this.Close();
}
}
// Fonction de rafraichissement de la listview
private void RefreshList()
{
lvContact.Items.Clear();
foreach (Contact contact in m_service.GetAllContacts().Values)
{
lvContact.Items.Add(new ListViewItem(new string[5] {contact.Nom, contact.Prenom, contact.Telephone, contact.Email, contact.ID.ToString()}));
}
}
// Bouton "Nouveau contact" (effacement des textbox(s))
private void btNewContact_Click(object sender, EventArgs e)
{
ClearFormContact();
}
// Fonction d'ajout d'un contact
private void btAddContact_Click(object sender, EventArgs e)
{
if (txtNom.Text != "")
{
Contact newContact = new Contact();
newContact.Nom = txtNom.Text;
newContact.Prenom = txtPrenom.Text;
newContact.Telephone = txtTel.Text;
newContact.Email = txtEmail.Text;
m_service.AddContact(newContact);
RefreshList();
ClearFormContact();
}
}
// Fonction de mise à jour d'un contact
private void btUpdateContact_Click(object sender, EventArgs e)
{
if (contactSelected != Guid.Empty)
{
Contact newContact = new Contact();
newContact.ID = contactSelected;
newContact.Nom = txtNom.Text;
newContact.Prenom = txtPrenom.Text;
newContact.Telephone = txtTel.Text;
newContact.Email = txtEmail.Text;
m_service.UpdateContact(newContact);
ClearFormContact();
RefreshList();
}
}
// Fonction de suppression d'un contact
private void btDeleteContact_Click(object sender, EventArgs e)
{
if (contactSelected != Guid.Empty)
{
m_service.DeleteContact(contactSelected);
RefreshList();
ClearFormContact();
}
}
// Au changement de l'item selectionné dans la listbox
private void lvContact_ItemSelectionChanged(object sender, System.Windows.Forms.ListViewItemSelectionChangedEventArgs e)
{ // Affichage du contact et effacement si aucun item selectionné
if (e.IsSelected)
DisplayFormContact(m_service.GetContactByID(new Guid(e.Item.SubItems[4].Text)));
else
ClearFormContact();
}
// Fonction d'affichage d'un contact dans les textbox(s)
private void DisplayFormContact(Contact contact)
{
txtNom.Text = contact.Nom;
txtPrenom.Text = contact.Prenom;
txtTel.Text = contact.Telephone;
txtEmail.Text = contact.Email;
contactSelected = contact.ID;
}
// Fonction d'effacement des textbox(s)
private void ClearFormContact()
{
txtNom.Text = "";
txtPrenom.Text = "";
txtTel.Text = "";
txtEmail.Text = "";
contactSelected = Guid.Empty;
}
}
}
Executez votre application cliente. Celle-ci se connectera à votre service et vous serez en mesure de gerer votre annuaire à distance.
4.4 Conclusion Notre démonstration est finie. Nous avons vu comment réaliser un simple service-client en utilisant le wsHttpBinding.
Mais notez qu'il est maintenant très simple de changer le binding de notre solution, en modifiant le fichier App.Config de notre Host puis en mettant à jour la référence coté client.
En conclusion, la création d'application client-serveur devient donc très facile et très rapide avec le WCF.
|
108 Visites
Sébastien WARIN
[30 mn de lecture - paru le 11/5/2006 6:13:45 PM - Public : Confirmé]
[20 mn de lecture - paru le 11/5/2006 5:54:29 PM - Public : Confirmé]