  .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
3 Développer avec WCF
Pour développer une application communicante avec un service et des
clients, nous allons devoir développer 3 parties :
- le Service
- l' Host
qui hébergera le service pour l'exposer en local ou à distance
- les Clients qui consommeront le service
3.1 Création du service La 1er chose à faire comme dit dans l'introduction, sera de créer classe service qui définira les objets communs échangés (DataContract), la liste des opérations (ServiceContract) ainsi que la classe métier de notre service qui implémentera notre contrat. Notre service se résume donc à une bibliothèque de classe (une simple DLL: assembly .net) faisant référence à System.ServiceModel.
3.1.1 Définition des DataContract Le DataContract définit le format des données qui sera échangé entre le client et le service. Cela peut être une structure ou classe marquée de l'attribut DataContract où les membres seront marqués de l'attribut DataMember.
Exemple:
[DataContract]
public struct Personne
{
string m_Nom;
string m_Prenom;
[DataMember]
public string Nom
{
get { return m_Nom; }
set { m_Nom = value; }
}
[DataMember]
public string Prenom
{
get { return m_Prenom; }
set { m_Prenom = value; }
}
}
Dans notre exemple, nous définissions la structure Personne qui contient deux membres en String : Nom et Prenom. Cette structure pourra être utilisée comme format de données dans notre communication.
Attention, n'oubliez pas de faire un using sur le namespace System.Runtime.Serialization
3.1.2 Création de l'interface ServiceContract Une fois les formats de données (objets communs) définis, nous allons pouvoir écrire l'interface qui sera marqué de l'attribut ServiceContract qui énumèrera la liste des méthodes de notre service. Chaque méthode sera marquée de l'attribut OperationContract.
L'exemple le plus simple est un service de calculette. Ce service exposera les méthodes Addition et Soustraction (pour faire court) à deux opérandes sur des floats.
Exemple:
[ServiceContract()]
public interface IMaCalculette
{
[OperationContract]
float Addition(float a, float b);
[OperationContract]
float Soustraction(float a, float b);
}
De cette façon, nous aurons un service qui exposera ces deux méthodes.
3.1.3 Développement de la logique métier du service Enfin, après avoir définit les objets communs et la liste des opérations, nous devons maintenant développer la logique métier de notre service, ce qui se résume à implémenter notre interface ServiceContract.
Pour reprendre l'exemple du service de calculette, la classe service ressemblerai à :
public class MaCalculette : IMaCalculette
{
public float Addition(float a, float b)
{
return a + b;
}
public float Soustraction(float a, float b)
{
return a - b;
}
}
Après cela, il ne vous reste plus qu'à compiler et votre classe service sera prête. Ensuite il faudra héberger votre service pour l'exposer grâce à une application Host.
3.2 Création de l'host (partie serveur) Nous avons deux possibilités d'héberger notre service :
- Soit
par Windows Activation Service (WAS) qui permet d'héberger des services
WCF un peu comme IIS le fait avec les Webservices ASMX
- Soit par un processus arbitraire que nous développerons (programme console, application ou service Windows, etc..)
Ici nous ne présenterons pas le WAS. Nous développerons une application Console pour héberger notre classe service.
3.2.1 Développement de classe Host Dans un projet de type console, la première chose à faire sera de rajouter la référence du System.ServiceModel ainsi que celle de notre classe service (dans notre exemple nommé MaCalculette).
Ensuite, dans le Main de votre application, il faudra créer une instance de la classe ServiceHost :
ServiceHost maHost = new ServiceHost(typeof(MaCalculette)); maHost.Open() // ... ...
maHost.Close();
De cette façon, nous avons créé maHost qui héberge et expose le service MaCalculette.
Seulement
voilà, à ce stade nous avons juste spécifié le contrat dans notre code,
mais il nous manque le A et le B : l'adresse et le binding.
3.2.2 Définition de l'Address et Binding dans l'App.config
Avec WCF ce n'est plus au développeur de configurer les adresses et le
binding. Tout cela est configuré très simplement dans le fichier de
configuration de l'Host par l'administrateur réseau par exemple.
Chaque service peut disposer d'un ou plusieurs EndPoint.
Ici pour notre service MaCalculette nous utilisons 2 EndPoint :
- 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/)
Voici notre fichier de configuration App.config de notre host :
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<system.serviceModel>
<services>
<service name="MaCalculetteNS.MaCalculette">
<endpoint
contract="MaCalculetteNS.IMaCalculette"
binding="wsHttpBinding"
address="http://localhost:8001/MaCalculette" />
<endpoint
contract="MaCaluletteNS.IMaCalculette"
binding="netTcpBinding"
address="net.tcp://localhost:8002" />
</service>
</services>
</system.serviceModel>
</configuration>
Vous remarquez bien que l'on retrouve dans notre fichier de configuration le trio ABC dans un EndPoint.
3.2.3 Démarrage du service Afin de compiler je vous propose d'ajouter le petit bout de code suivant :
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);
}
Enfin exécutez votre Host et votre service sera exposé aux EndPoint définies. Il ne vous reste plus qu'a le consommer par des clients.
3.3 Création du client Le client peut être tout type d'application .NET comme une application Winform, console ou Webform, etc...
Il suffira juste d'ajouter la référence du service puis d'utiliser le
service comme une simple classe .NET tout comme nous ne le faisons avec les
web services ASMX.
3.3.1 Ajouter la référence du service Un simple clic-droit sur votre projet client et cliquez sur "Add Service Reference" :
 Puis donnez l'URI de votre service (dans notre exemple : http://localhost:8001/MaCalculette ou net.tcp://localhost:8002/) ainsi qu'un 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).
Nous pourrons alors modifier très facilement le fichier app.config pour changer la manière dont se connecte notre client en modifiant l'address et le binding du EndPoint pour le service MaCalculette.
3.3.2 Consommer le service WCF
Visual Studio vous ayant maché tout le travail lors de l'ajout de la
référence du service, il vous reste plus qu'à instancier votre classe
'ServiceClient' généré par VS puis de l'ouvrir par la méthode Open(). Ensuite vous pourrez appeler les méthodes de votre contrat qui seront exécutées sur le serveur par votre classe Service (ici MaCalculette).
Exemple:
MaCalculetteClient m_service = new MaCalculetteClient();
m_service.Open(); float test = m_service.Addition(1.0f, 2.0f);
m_service.Close();
|
91 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é]