Introduction à Windows Communication Foundation

Au court de cet article je vais vous présenter Windows Communication Foundation, ou WCF, qui est une des grandes nouveautés du Framework.Net 3.0. WCF fournit un modèle de programmation unifiée pour construire des applications distribuées, WCF va permettre de faire communiquer des composants applicatifs se trouvant sur une même machine, mais le plus souvent sur différentes machines reliées en réseau.

N'hésitez pas à commenter cet article ! Commentez Donner une note à l'article (5)

Article lu   fois.

L'auteur

Profil ProSite personnel

Liens sociaux

Viadeo Twitter Facebook Share on Google+   

Introduction

WCF, ou Windows Communication Foundation, est une des nouveautés majeures de la version 3.0 du Framework .Net. WCF fournit un modèle de programmation unifiée pour construire des applications distribuées, WCF va nous permettre de faire communiquer des composants applicatifs se trouvant sur une même machine, mais le plus souvent sur différentes machines reliées en réseau. Vous devez penser que cela n'a rien de révolutionnaire et que cela existe depuis très longtemps déjà, et vous avez raison (Remoting, Web Services, COM+, MSMQ et d'autres encore), ce qui change ici, c'est qu'avec WCF nous pouvons faire communiquer les applications que nous créons avec toutes ces technologies, sans pour autant devoir adapter nos développements de manière spécifique avec chacune. WCF va savoir interagir avec différentes technologies, et détail très important à mes yeux, le code n'aura pas à être adapté et modifié en fonction du moyen de communication que vous choisirez.

Microsoft .Net

Un exemple simple pour mieux comprendre, vous créez une application qui communique par HTTP et SOAP, et que pour une raison ou une autre vous souhaitez communiquer en TCP et binaire, avec WCF vous ne changerez pas la moindre ligne de code de votre application. C'est une grande force de WCF, le code de votre application, son fonctionnement, sont découplés du moyen de communication utilisé. Pour ceux qui ont déjà fait du Remoting par exemple, vous devez apprécier cette caractéristique.

Bien qu'issu de la plateforme .Net et donc de l'environnement Windows, WCF a une vision plus large, et grâce à l'implémentation de nombreux standards cette technologie peut être utilisée pour communiquer avec des plateformes autres que Windows.

Maintenant que vous voyez dans les très grandes lignes ce qu'est WCF, entrons un peu plus dans le détail.

1. L'ABC de WCF

L'élément central dans WCF est le service, voyons ce qui ce cache derrière ce terme qui est utilisé dans de nombreux contextes différents en informatique. Pour vous donner une idée simple de ce qu'est un service WCF je vous propose d'imaginer un composant logiciel autonome, qui est capable d'effectuer des opérations et des communications au travers d'un réseau.
Un service WCF est une entité logicielle implémentant un contrat, qui est une interface au sens objet du terme. Cette interface reprend la liste des opérations que va exposer un service. En fait plus précisément, on définit un contrat par trois lettres, A, B et C. A pour adresse, B pour Binding et C pour contrat.

Commençons par présenter l'adresse. Il s'agit simplement d'une URI qui définit où est joignable le service, cela peut être par exemple une URL http comme l'adresse d'une file d'attente MSMQ… La nature de l'adresse dépend du protocole choisit et de l'infrastructure réseau.

Le Binding est en fait la méthode, le protocole, utilisé pour communiquer avec le service WCF. Le Framework .Net 3.0 nous fournit la base 9 bindings que l'on peut utiliser directement. Comme nous le verrons plus tard, ces bindings présentent des caractéristiques différentes, offrent de nombreuses fonctionnalités avancées et couvrent ainsi de nombreux scénarios d'utilisation. Cependant, dans l'optique de généricité et d'ouverture de WCF il est tout à fait possible si nécessaire d'utiliser ses propres bindings personnalisés avec vos protocoles maison. Voici la liste des bindings inclus dans WCF :

  • BasicHttpBinding
  • WSHttpBinding
  • WSDualHttpBinding
  • WSFederationHttpBinding
  • NetTcpBinding
  • NetNamedPipeBinding
  • NetMsmqBinding
  • NetPeerTcpBinding
  • MsmqIntegrationBinding

Et enfin, le contrat. Comme nous l'avons vu précédemment c'est un élément majeur du service WCF, c'est lui qui définit les opérations exposées par le service. Ce contrat indique quels sont les types et les paramètres employés par le service. Un contrat est en fait une Interface, au sens objet du terme, décorée de quelques attributs spécifiant qu'il s'agit d'un contrat WCF.

Si vous avez compris l'ABC de WCF vous pouvez alors créer votre premier service sans difficulté. C'est d'ailleurs ce que nous allons faire dans cet article, mais avant, nous allons examiner ce dont nous avons besoin pour créer des services WCF.

  • Le Framework .Net en version 3.0 minimum
  • Visual Studio 2005 ou version ultérieure (rien ne vous empêche d'utiliser Notepad pour coder, mais restons raisonnables un instant s'il vous plait…)
  • Les extensions WCF pour Visual Studio 2005 si vous l'utilisez évidemment

Apres avoir installé ces trois éléments, vous êtes prêt à créer votre premier service WCF. Les liens pour télécharger ces différents composants sont disponibles a la fin de cet article dans la section "Ressources".

Créons sans plus tarder notre premier service WCF.

2. Notre premier service WCF

Pour cela il suffit de préparer un minimum Visual Studio et suivre l'ABC. Nous allons utiliser le namespace System.ServiceModel pour créer nos services WCF, il faut donc commencer par ajouter une référence vers l'assembly System.ServiceModel.dll. Ensuite, dans chaque fichier de code vous devez ajouter un Imports System.ServiceModel ou un using System.ServiceModel ; si vous utilisez VB.Net ou C#.

Remarque : je pense que ce n'est pas forcement nécessaire de le préciser, mais dans le doute, comme tous les éléments de la technologie .Net, WCF est utilisable avec n'importe quel langage compatible .Net, il en existe plus d'une trentaine. Je me borne à fournir mon code dans les deux principaux langages, mais si vous faites du Delphi .Net, du J#, du Cobol .Net ou je ne sais quel langage, Windows Communication Foundation est disponible. C'est une des grandes forces de la technologie .Net.

Visual Studio est désormais prêt. Je ne l'ai pas précisé, mais votre service WCF peut être créé dans n'importe quel type d'application (Console, WinForms, Web…). En disant cela je ne suis pas totalement précis, car en fait, lorsque nous créons un service WCF nous le faisons dans une DLL, c'est par la suite que l'on choisira de l'intégrer dans un type d'application donné. Il sera hébergé (on dit "hosté") par une autre application. En effet, un service WCF en tant que tel (une DLL) n'est pas autonome et nécessite un hôte pour s'exécuter. Pour permettre un découpage et une maintenance facile de notre service nous allons stocker notre interface dans une DLL, il faut donc pour cela créer un projet de type "Bibliothèque de classes".

Comme vu précédemment, l'élément central d'un service est son contrat. Conceptuellement parlant, il est très important de commencer par définir ce contrat, préalablement à tout autre élément. Une fois le contrat établit nous pouvons alors définir le reste.

Info : au cours de cet article, nous allons créer un service qui sera capable d'effectuer des conversions monétaires avec l'Euro et le Dollars. Par exemple en donnant un montant en Euros, le service nous renverra le montant équivalent en Dollars US, et inversement. Je vous l'accorde ce service ne révolutionnera pas le monde du logiciel, mais ce n'est pas l'objet de cet article.

Notre service exposera donc deux méthodes principales qui sont EurosToUsDollars() et UsDollarsToEuros(), ces deux fonctions renverrons le montant stocké dans une variable de type Decimal. Voici sans plus tarder a quoi va ressembler notre contrat :

Le contrat du service WCF, une interface
Sélectionnez

Imports System.ServiceModel

<ServiceContract()> _
Public Interface IServiceDev

    <OperationContract()> _
    Function EuroToUsDollars(ByVal amount As Decimal) As Decimal

    <OperationContract()> _
    Function UsDollarsToEuros(ByVal amount As Decimal) As Decimal

End Interface
Le contrat du service WCF, une interface
Sélectionnez

using System.ServiceModel;

[ServiceContract()]
public interface IServiceDev
{

	[OperationContract()]
	decimal EuroToUsDollars(decimal amount);

	[OperationContract()]
	decimal UsDollarsToEuros(decimal amount);

}

Vous voyez qu'en plus du code normal que l'on retrouve dans une interface .Net, il y a quelques attributs propres à WCF que je vais vous présenter.

ServiceContract : cet attribut comme son nom l'indique, permet de définir cette interface en tant que contrat de service WCF, c'est-à-dire qu'un service WCF pourra exposer les opérations définies dans l'interface, à condition que ces méthodes arborent l'attribut suivant.

OperationContract : cet attribut que l'on positionne au dessus de la signature de la méthode spécifie que la méthode concernée sera exposée par le service. Une méthode peut très bien ne pas avoir cet attribut positionné, mais dans ce cas elle ne sera pas exposée par le service.

Notre contrat, l'interface, est maintenant définit. Il faut l'implémenter, pour cela nous allons ajouter un nouveau projet de type "Bibliothèque de classes" à notre solution Visual Studio. Ce projet doit comporter une référence vers le projet contenant l'interface, il faut donc l'ajouter. Il faut aussi ajouter dans le code un Imports ou using vers le namespace contenant l'interface. C'est ici que nous allons réellement coder notre service.

Puisque cette classe implémente le contrat du service, l'interface, celle-ci doit en reprendre tous les membres. Voici ce que pourrait être le code de notre service de conversion monétaire :

Implémentation du service en VB.Net
Sélectionnez

Option Explicit On
Option Strict On

Public Class CurrencyService
    Implements DevInterface.IServiceDev


    Public Function EuroToUsDollars(ByVal amount As Decimal) As Decimal Implements DevInterface.IServiceDev.EuroToUsDollars
        Return amount * CDec(1.3812)
    End Function

    Public Function UsDollarsToEuros(ByVal amount As Decimal) As Decimal Implements DevInterface.IServiceDev.UsDollarsToEuros
        Return amount * CDec(0.724)
    End Function

End Class
Implémentation du service en VB.Net
Sélectionnez

public class CurrencyService : DevInterface.IServiceDev
{


	public decimal DevInterface.IServiceDev.EuroToUsDollars(decimal amount)
	{
		return amount * (decimal)1.3812;
	}

	public decimal DevInterface.IServiceDev.UsDollarsToEuros(decimal amount)
	{
		return amount * (decimal)0.724;
	}

}

Remarque : cette application n'étant la que pour illustrer la technologie il n'est pas idéal, en effet, les taux de conversion sont en dur dans le code, ce qui vous le savez n'est absolument pas réaliste puisque ces taux sont variables et changent en permanence… Ce qui serait par exemple possible de faire, c'est de relier notre service WCF à un Web Service boursier qui nous permette de récupérer à intervalle régulier le taux de conversion actualisé. WCF sait parfaitement faire cela, et se connecter à un Web Service est très simple.

A ce stade, notre service est terminé, enfin presque, en effet celui-ci n'est pas autonome, il a besoin pour cela d'un hôte sur lequel il pourra être exécuté. Cet hôte peut être n'importe quel type d'application .Net, un service Windows ou même IIS 7.0 et le nouveau Windows Activation Service (WAS) ce qui permet de bénéficier de la robustesse, de la tolérance aux pannes et des capacités de montée en charge du serveur d'applications (en effet, cela fait bien longtemps que IIS n'est plus un simple serveur Web) de Microsoft.

Remarque : IIS 5.1 et 6.0 (c'est-à-dire respectivement IIS de Windows XP et 2003) peuvent héberger des services WCF mais avec une restriction; en effet ils devront utiliser HTTP pour les bindings, seul IIS 7.0 sait héberger des services WCF autres que HTTP (TCP, MSQM…).

Pour ma démonstration je vais employer une application Windows Forms, car c'est la méthode la plus appropriée a mon avis pour ce genre de démonstration. Voyons maintenant comment créer notre hôte de service WCF. Ce projet Windows Forms doit posséder une référence vers System.ServiceModel et vers le projet contenant le service lui même.

Hôte ne notre service WCF en VB.Net
Sélectionnez

Option Explicit On
Option Strict On

Imports System.ServiceModel

Public Class Form1

    Private host As ServiceHost

    Private Sub btServiceStart_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btServiceStart.Click

        host = New ServiceHost(GetType(DevService.CurrencyService))

        Try
            host.Open()
            Me.btServiceStart.Enabled = False
            Me.lblServiceState.Text = "Service is started"
        Catch ex As Exception
            Me.btServiceStart.Enabled = True
            Me.lblServiceState.Text = "Service can't be started"
        End Try
        
    End Sub

    Private Sub btServiceStop_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btServiceStop.Click

        If host.State = CommunicationState.Opened Or _
           host.State = CommunicationState.Faulted Or _
           host.State = CommunicationState.Opening Then

            host.Close()
            Me.btServiceStart.Enabled = True
            Me.lblServiceState.Text = "Service is stopped"

        End If

    End Sub

End Class
Hôte de notre service WCF en C#
Sélectionnez

using System.ServiceModel;

public class Form1
{

	private ServiceHost host;

	private void btServiceStart_Click(object sender, System.EventArgs e)
	{

		host = new ServiceHost(typeof(DevService.CurrencyService));

		try {
			host.Open();
			this.btServiceStart.Enabled = false;
			this.lblServiceState.Text = "Service is started";
		}
		catch (Exception ex) {
			this.btServiceStart.Enabled = true;
			this.lblServiceState.Text = "Service can't be started";
		}

	}

	private void btServiceStop_Click(object sender, System.EventArgs e)
	{

		if (host.State == CommunicationState.Opened | host.State == CommunicationState.Faulted | host.State == CommunicationState.Opening)
		{

			host.Close();
			this.btServiceStart.Enabled = true;
			this.lblServiceState.Text = "Service is stopped";

		}

	}

}

Ce code introduit un nouvel objet, il s'agit du ServiceHost, qui comme sont nom l'indique est un hôte de service. Mais attention à force d'employer le mot service à toutes les sauces l'on s'y perd un peu. Il ne s'agit pas d'un Web Service, ni d'un service Windows mais bel et bien d'un hôte de service WCF. Nous voyons que cet objet ServiceHost est générique, on spécifie son type lors de son instanciation. ServiceHost est du type de notre service que nous avons codé à l'étape précédente. On voit ici une autre utilisation des Generics, qui est un élément indispensable dans l'architecture WCF.

Maintenant que notre hôte est instancié, il ne reste plus qu'à le laisser communiquer, pour cela il suffit d'appeler la méthode Open(), la méthode Close() quand à elle vous l'aurez compris, sert à fermer les communications de notre service dans son hôte.

A cet instant le code de notre service est terminé, vous pouvez fermer le débogueur il ne sera plus utile:-)). Mais il nous reste cependant une dernière étape à réaliser avant la mise en route de notre service WCF, il faut définir le A et le B, soit l'adresse et le binding. Pour cela il y a deux manières de procéder, depuis le code de l'hôte ou depuis un fichier de configuration, c'est cette dernière solution que nous allons voir en détail. L'une des forces de WCF c'est de séparer, de découpler, l'implémentation du service des protocoles et moyens de communications employés, donc définir le A et le B dans le code serait d'une certaine manière, aller contre la philosophie de WCF, mais sachez quand même que c'est tout à fait réalisable.

Pour ajouter un fichier de configuration app.config il suffit d'ajouter un nouvel élément à votre projet hôte de service, Visual Studio possède un Template de tel fichier, mais vous pouvez très bien l'éditer vous-même, il ne s'agit en effet ni plus ni moins que d'un simple fichier XML. Voici à quoi ressemble un fichier de configuration pour un service WCF utilisant HTTP/SOAP sur le port 8018.

Exemple de fichier de configuration utilisant HTTP et SOAP
Sélectionnez

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.serviceModel>
    <services>
      <service name="DevService.CurrencyService">
        <endpoint
            address="http://localhost:8018/CurrencyService"
            binding="basicHttpBinding"
            contract="DevInterface.IServiceDev" />
      </service>
    </services>
  </system.serviceModel>
</configuration>

Vous voyez apparaitre une nouvelle balise, inconnue jusqu'ici, ce qui est normale puisqu'elle est spécifique a WCF, il s'agit de la balise <system.serviceModel>, qui contient une balise <services> qui elle-même contient une balise <service>, c'est à ce niveau que nous allons définir le binding et l'adresse de notre service WCF. Le nom du service est le nom complet (namespace + classe) de notre service, et le nom de l'endpoint est le nom complet du contrat de notre service, c'est-à-dire l'interface.

Endpoint, vous avez dis Endpoint ? Voila encore un nouveau terme, un endpoint est tout simplement un point de terminaison de notre service, c'est-à-dire une voie par laquelle il peut communiquer, un endpoint est en fait définit par une adresse, éventuellement un port et un protocole. Pour un même service il est possible d'en définir plusieurs, ce qui implique que par exemple, un service WCF pourra communiquer en même temps grâce à HTTP/SOAP, MSMQ et par TCP. Le endpoint est l'élément stratégique du service WCF, c'est lui qui définit par quel biais va interagir notre service avec le monde extérieur, on voit d'ailleurs qu'il centralise par le biais d'un simple fichier de configuration son propre ABC.

A ce stade, nous avons réalisé un service WCF, nous l'avons hébergé et rendu opérationnel. Voici le code complet du service WCF pour vous montrer à quel point le code d'un service WCF est simple et court. Je vous rappelle que pour les besoins de la démonstration j'ai utilisé une application Windows Forms pour "hoster" le service, mais cela pourrait être n'importe quel type d'application Windows ou encore IIS 7.0 et le WAS.

Notre premier service WCF en VB.Net
Sélectionnez

Imports System.ServiceModel

<ServiceContract()> _
Public Interface IServiceDev

    <OperationContract()> _
    Function EuroToUsDollars(ByVal amount As Decimal) As Decimal

    <OperationContract()> _
    Function UsDollarsToEuros(ByVal amount As Decimal) As Decimal

End Interface




Option Explicit On
Option Strict On

Public Class CurrencyService
    Implements DevInterface.IServiceDev


    Public Function EuroToUsDollars(ByVal amount As Decimal) As Decimal Implements DevInterface.IServiceDev.EuroToUsDollars
        Return amount * CDec(1.3812)
    End Function

    Public Function UsDollarsToEuros(ByVal amount As Decimal) As Decimal Implements DevInterface.IServiceDev.UsDollarsToEuros
        Return amount * CDec(0.724)
    End Function

End Class




Option Explicit On
Option Strict On

Imports System.ServiceModel

Public Class Form1

    Private host As ServiceHost

    Private Sub btServiceStart_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btServiceStart.Click

        host = New ServiceHost(GetType(DevService.CurrencyService))

        Try
            host.Open()
            Me.btServiceStart.Enabled = False
            Me.lblServiceState.Text = "Service is started"
        Catch ex As Exception
            Me.btServiceStart.Enabled = True
            Me.lblServiceState.Text = "Service can't be started"
        End Try
        
    End Sub

    Private Sub btServiceStop_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btServiceStop.Click

        If host.State = CommunicationState.Opened Or _
           host.State = CommunicationState.Faulted Or _
           host.State = CommunicationState.Opening Then

            host.Close()
            Me.btServiceStart.Enabled = True
            Me.lblServiceState.Text = "Service is stopped"

        End If

    End Sub

End Class
Notre premier service WCF en C#
Sélectionnez

using System.ServiceModel;

[ServiceContract()]
public interface IServiceDev
{

	[OperationContract()]
	decimal EuroToUsDollars(decimal amount);

	[OperationContract()]
	decimal UsDollarsToEuros(decimal amount);

}




public class CurrencyService : DevInterface.IServiceDev
{


	public decimal DevInterface.IServiceDev.EuroToUsDollars(decimal amount)
	{
		return amount * (decimal)1.3812;
	}

	public decimal DevInterface.IServiceDev.UsDollarsToEuros(decimal amount)
	{
		return amount * (decimal)0.724;
	}

}





using System.ServiceModel;

public class Form1
{

	private ServiceHost host;

	private void btServiceStart_Click(object sender, System.EventArgs e)
	{

		host = new ServiceHost(typeof(DevService.CurrencyService));

		try {
			host.Open();
			this.btServiceStart.Enabled = false;
			this.lblServiceState.Text = "Service is started";
		}
		catch (Exception ex) {
			this.btServiceStart.Enabled = true;
			this.lblServiceState.Text = "Service can't be started";
		}

	}

	private void btServiceStop_Click(object sender, System.EventArgs e)
	{

		if (host.State == CommunicationState.Opened | host.State == CommunicationState.Faulted | host.State == CommunicationState.Opening)
		{

			host.Close();
			this.btServiceStart.Enabled = true;
			this.lblServiceState.Text = "Service is stopped";

		}

	}

}

Nous avons découpé notre service WCF en trois projets différents, l'interface, le service et son hôte. Cela pourrait être regroupé dans un seul et même projet, mais pour des raisons de clarté, de sécurité, de facilité et de maintenance je vous recommande de découper un service WCF en au moins trois projets (cela peut être plus si vous utilisez d'autres objets métiers), de plus, vous verrez bientôt que cela prend tout son sens vis-à-vis du client de votre service, en terme de sécurité et confidentialité de l'implémentation réelle du service.

3. Créons un client pour notre service WCF

Il est certes intéressant d'avoir un service WCF, mais faut il encore que celui-ci soit utilisé. Pour cela nous allons créer un client en .Net, mais souvenez vous qu'il pourrait très bien être en Java, en C++ ou Python. Un des intérêts des services WCF est qu'ils supportent de nombreux protocoles standards et ouverts et peuvent être interopérables et donc fonctionner avec des clients ou d'autres services sur des plateformes différentes. Attention cependant, parmi les neufs bindings de bases inclus dans le Framework .Net 3.0, quatre (BasicHttpBinding, WSHttpBinding, WSDualHttpBinding, WSFederationHttpBinding) sont interopérables, les autres sont basés sur des technologies .Net et/ou Microsoft.

Une fois de plus le client peut être une application .Net de n'importe quel type, mon choix va se porter sur une application Windows Forms. Ajoutons donc un nouveau projet de ce type a notre solution. Ce projet doit avoir une référence vers l'interface, le contrat de notre service WCF, et une référence vers System.ServiceModel.

Remarque : vous comprenez ici l'intérêt de découper notre service en plusieurs projets ; en effet, le client devra avoir connaissance de l'interface, donc si celle ci se trouve dans la même DLL que le service lui-même cela pose de sérieux problèmes de sécurité, l'implémentation même du service n'étant alors plus secrète, puisque distribuée avec chaque client. De plus, sachez que potentiellement il est possible de ne pas fournir l'interface (le contrat) au client, celui-ci pourra générer le code nécessaire en récupérant des métadonnées relatives au service auprès de ce dernier.

Pensez à jouter les Imports et using nécessaires dans vos fichiers de code. L'objet central de notre client va être le ChannelFactory, qui va permettre de créer un canal de communication pour communiquer avec le service. ChannelFactory est une fabrique de classe, c'est-à-dire un générateur de classe, une classe qui autorisera un client à envoyer et/ou recevoir vers et depuis un service. Voici le code qui nous permettra de créer ce canal de communication entre le client et le serveur, notez que cet objet est du type de notre interface, le contrat de notre service.

Instanciation d'une ChannelFactory en VB.Net
Sélectionnez

Dim myChannelFactory As ServiceModel.ChannelFactory(Of DevInterface.IServiceDev) = Nothing
Dim myService As DevInterface.IServiceDev

myChannelFactory = New ServiceModel.ChannelFactory(Of DevInterface.IServiceDev)("ConfigurationHttpCurrency")
myService = myChannelFactory.CreateChannel()
Instanciation d'une ChannelFactory en C#
Sélectionnez

ServiceModel.ChannelFactory<DevInterface.IServiceDev> myChannelFactory = null;
DevInterface.IServiceDev myService;

myChannelFactory = new ServiceModel.ChannelFactory<DevInterface.IServiceDev>("ConfigurationHttpCurrency");
myService = myChannelFactory.CreateChannel();

Comme pour un service WCF, un client WCF utilise un fichier de configuration (qui comme pour le service peut être remplacé par un codage en dur dans l'application) qui va contenir l'ABC du service WCF, plus un nom que l'on donnera à cette connexion. Voici a quoi va ressembler le fichier de configuration de notre client.

Exemple de fichier de configuration pour notre client WCF
Sélectionnez

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.serviceModel>
    <client>
      <endpoint
        address="http://localhost:8018/CurrencyService"
        binding="basicHttpBinding"
        contract="DevInterface.IServiceDev"
        name="ConfigurationHttpCurrency" />
    </client>
  </system.serviceModel>
</configuration>

Comme nous l'avons vu un petit peu plus haut dans le code de création du canal de communication, le nom de la connexion est employé en dur dans le code, ce nom peut être utilisé pour différencier les connexions du client, cela veut dire que par exemple chaque client pourra posséder plusieurs connexions et utilisera l'une ou l'autre en fonction du contexte (connexion au réseau local, à Internet…).

Voyons maintenant comment utiliser les méthodes exposées par le service. Grâce à la fabrique de classes que nous avons instanciée, nous allons générer un proxy fortement typé, qui nous permettra d'accéder aux méthodes exposées par le service. Regardons un exemple nous montrant comment accéder aux deux méthodes de notre service de conversion monétaire.

Accès aux methodes du service par le proxy en VB.Net
Sélectionnez

Option Explicit On
Option Strict On

Imports System.ServiceModel

Public Class Form1


    Private Sub btConvert_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btConvert.Click

        Dim myChannelFactory As ServiceModel.ChannelFactory(Of DevInterface.IServiceDev) = Nothing
        Dim myService As DevInterface.IServiceDev

        Try

            myChannelFactory = New ServiceModel.ChannelFactory(Of DevInterface.IServiceDev)("ConfigurationHttpCurrency")
            myService = myChannelFactory.CreateChannel()

            If Me.rbEurosToUsd.Checked Then
                Me.lblResult.Text = Math.Round(myService.EuroToUsDollars(CDec(Me.tbAmount.Text)), 2).ToString & " US Dollars"
            Else
                Me.lblResult.Text = Math.Round(myService.UsDollarsToEuros(CDec(Me.tbAmount.Text)), 2).ToString & " Euros"
            End If

        Catch ex As Exception

            myChannelFactory.Abort()
            Me.lblResult.Text = "An error occured..."

        End Try

    End Sub

End Class
Accès aux methodes du service par le proxy en C#
Sélectionnez

using System.ServiceModel;

public class Form1
{


	private void btConvert_Click(object sender, System.EventArgs e)
	{

		ServiceModel.ChannelFactory<DevInterface.IServiceDev> myChannelFactory = null;
		DevInterface.IServiceDev myService;

		try {

			myChannelFactory = new ServiceModel.ChannelFactory<DevInterface.IServiceDev>("ConfigurationHttpCurrency");
			myService = myChannelFactory.CreateChannel();

			if (this.rbEurosToUsd.Checked)
			{
				this.lblResult.Text = Math.Round(myService.EuroToUsDollars((decimal)this.tbAmount.Text), 2).ToString + " US Dollars";
			}
			else
			{
				this.lblResult.Text = Math.Round(myService.UsDollarsToEuros((decimal)this.tbAmount.Text), 2).ToString + " Euros";
			}
		}

		catch (Exception ex) {

			myChannelFactory.Abort();
			this.lblResult.Text = "An error occured...";

		}

	}

}

Voila, vous pouvez consommer votre service WCF depuis votre client. Tout ceci est relativement simple, et sachez que la technologie WCF est très ouverte et hautement personnalisable. Les possibilités sont extrêmement nombreuses. Pour finir, voici le code complet du client, vous voyez a quel point WCF nous mâche le travail, accéder à un service au travers d'un réseau, ne prend que quelques lignes et cela quelque soit le protocole utilisé…

Conclusion

J'espère qu'au travers de cet article, je vous aurai montré ce qu'est WCF, du moins dans les grandes lignes. Personnellement, j'aime beaucoup cette technologie, elle est, et de loin, ma nouveauté préférée du Framework .Net 3.0. WCF vient à point nommé, au moment ou les technologies d'applications distribuées étaient trop nombreuses et variées, et aussi au moment où les besoins en interopérabilités sont croissants. Cet article constitue une introduction à WCF, et il faut le prendre en tant que tel. WCF est une technologie très large et qui peut être complexe, c'est pour cette raison que cet article n'est que le premier d'une série. Je vous invite donc à consulter le site fréquemment, d'autres articles sur WCF suivront dans les semaines à venir.

Un grand merci à AGM26 pour la relecture de cet article, ainsi qu'à l'équipe Dotnet pour son aide.

Ressources

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

  

Copyright © 2007 Ronald Vasseur. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.