Windows Communication Foundation (WCF) est un framwork extensible développé par Microsoft pour concevoir et déployer des applications orientées services (SOA). Il unifie diverses technologies de communication distribuées de l'écosystème .NET, telles que les services Web ASP.NET, .NET Remoting, MSMQ et Enterprise Services, en un modèle de programmation unique et cohérent.

Structure d'une solution WCF

Une architecture WCF classique est généralement décomposée en quatre couches logiques :

• Contrats (Contracts) : Bibliothèques de classes définissant les interfaces de service. Elles utilisent l'espace de noms System.ServiceModel pour décrire les opérations disponibles.
• Services : Implémentation concrète des contrats définis précédemment. Cette couche contient la logique métier du service.
• Hébergement (Hosting) : Application (Console, Service Windows, IIS) chargée d'exécuter le servicee et de le rendre accessible sur le réseau.
• Client : Application consommatrice qui invoque les méthodes du service via un proxy.

Types de contrats dans WCF

Le fonctionnement de WCF repose sur plusieurs types de contrats essentiels :

• Service Contract : Définit les opérations que le service expose au monde extérieur.
• Data Contract : Définit les structures de données complexes échangées.
• Message Contract : Permet un contrôle précis sur le format des messages SOAP.
• Fault Contract : Définit les erreurs personnalisées retournées par le service.

Avantages de l'approche unifiée

Avant l'arrivée de WCF, le choix d'une technologie dépendait de besoins spécifiques (interopérabilité vs performance). WCF résout ce problème en offrant une API commune capable de gérer différents protocoles de transport, modèles de sécurité et topologies réseau par simple configuration, réduisant ainsi la complexité de maintenance des systèmes distribués.

Exemple d'implémentation

1. Définition du Contrat et du Service

Voici comment définir une interface de service et son implémentation associée :

// Interface du contrat
[ServiceContract]
public interface IAnalyseurData
{
   [OperationContract]
   string ExecuterDiagnostic();
}

// Implémentation du service
public class ServiceAnalyse : IAnalyseurData
{
   public string ExecuterDiagnostic()
   {
       return "Analyse terminée avec succès à " + DateTime.Now.ToString();
   }
}
   

2. Configuration de l'Hébergement

Le fichier de configuration (App.config) définit l'adresse, la liaison (binding) et le contrat (le fameux ABC : Address, Binding, Contract) :

<system.serviceModel>
 <services>
   <service name="MonApp.ServiceAnalyse" behaviorConfiguration="ComportementDebug">
     <host>
       <baseAddresses>
         <add baseAddress="http://localhost:9000/Analyseur/" />
       </baseAddresses>
     </host>
     <endpoint address="v1" binding="basicHttpBinding" contract="MonApp.IAnalyseurData" />
   </service>
 </services>
 <behaviors>
   <serviceBehaviors>
     <behavior name="ComportementDebug">
       <serviceMetadata httpGetEnabled="true" />
     </behavior>
   </serviceBehaviors>
 </behaviors>
</system.serviceModel>
   

3. Lancement du Serveur

Le code suivant permet d'instancier et d'ouvrir l'hôte du service :

using System.ServiceModel;

class Program
{
   static void Main(string[] args)
   {
       using (ServiceHost monHote = new ServiceHost(typeof(ServiceAnalyse)))
       {
           monHote.Open();
           Console.WriteLine("Le service WCF est actif...");
           Console.ReadLine();
           monHote.Close();
       }
   }
}
   

4. Consommation par le Client

Une fois le service en ligne, le client peut l'appeler via une classe proxy générée :

namespace ClientFinal
{
   class Program
   {
       static void Main(string[] args)
       {
           using (AnalyseurClient proxy = new AnalyseurClient())
           {
               string reponse = proxy.ExecuterDiagnostic();
               Console.WriteLine("Réponse du serveur : " + reponse);
               Console.ReadKey();
           }
       }
   }
}