Introduction à Windows Communication Foundation

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.

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.

L'élément central dans WCF est le service, voyons ce qui se 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 choisi 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.

Après 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 à la fin de cet article dans la section « Ressources ».

Créons sans plus tarder 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#.

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 établi nous pouvons alors définir le reste.

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

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

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éfini. 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 :

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

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;
    }

}

À 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.

Pour ma démonstration je vais employer une application Windows Forms, car c'est la méthode la plus appropriée à 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.

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

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 son 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() quant à elle vous l'aurez compris, sert à fermer les communications de notre service dans son hôte.

À 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 communication 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.

<?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 normal puisqu'elle est spécifique à 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 dit Endpoint ? Voilà 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éfini 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.

À 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.

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

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étier), de plus, vous verrez bientôt que cela prend tout son sens vis-à-vis du client de votre service, en termes de sécurité et confidentialité de l'implémentation réelle du service.

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 base 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 à 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.

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 classes, c'est-à-dire un générateur de classes, 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.

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()

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 à quoi va ressembler le fichier de configuration de notre client.

<?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.

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

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...";

        }

    }

}

Voilà, 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 à 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 quel que soit le protocole utilisé…

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 où 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.