vendredi 15 juillet 2011

Tutoriel WCF

Dans ce tutoriel on va essayer d'introduire à travers un exemple illustratif la technologie WCF qui a pour but de faciliter la communication entre les processus locaux ou distants et permettant ainsi un développement souple et performant.
Le principe est très simple, on a un serveur exposant un ou plusieurs services à des clients distant, dans notre cas le serveur offre un service d'inversement de chaines de caractères.




En premier lieu nous avons besoins de définir les service que le client peut accéder, c-à-d les services exposés par le serveur. Cela est est réalisé à travers la définition de l'interface c# suivante:
using System;
using System.ServiceModel;

[ServiceContract]
public interface IStringReverser
{
  [OperationContract]
  string ReverseString(string value);
}

Comme on peut le constater, celle-ci est une interface simple qui définisse la méthode ReverseString qui prend comme argument une chaine de caractère nommée value et retourne un résultat du même type (String).
L'attribut [ServiceContract] indique que cette interface peut être exposée au client en tant que service, tandis que l'attribut [OperationContract] indique que la méthode ReverseString fait partie de ce service et peut etre ainsi utilisé par les clients.
 Notons bien que l'ajout de l'espace de nom System.ServiceModel au références du projet est requis.

Començons par implémenter notre serveur, en premier lieu on doit créer une classe qui implemente l'interface du service . le code de cette classe est illustré par le code suivant:
using System;
using System.ServiceModel;

[ServiceContract]
public interface IStringReverser
{
  [OperationContract]
  string ReverseString(string value);
}

public class StringReverser : IStringReverser
{
  public string ReverseString(string value)
  {
    char[] retVal = value.ToCharArray();
    int idx = 0;
    for (int i = value.Length - 1; i >= 0; i--)
      retVal[idx++] = value[i];

    return new string(retVal);
  }
}

maintenant on doit ajouter une autre classe permettant de rendre fonctionnel notre serveur à travers la creation d'un ServiceHost (hébergeur de service)qui est responsable sur l'exposition et la communication dans le service.
La nouvelle classe (Main) du serveur sera donc la suivante:


class Program
{
  static void Main(string[] args)
  {

     ServiceHost host=new ServiceHost(typeof(StringReverser), 
                                    newUri("http://localhost:8000"));

      host.AddServiceEndpoint(typeof(IStringReverser),
        new BasicHttpBinding(),
        "Reverse");

      host.Open();

      Console.WriteLine("Service is available. " +
        "Press to exit.");
      Console.ReadLine();

      host.Close();
  }
}
l'objet host représente notre service host ou hebergeur de notre service, ici on a utilisé comme adresse http://localhost:8000 pour indiqué que le service est hébergé sur le poste local.
 host.AddServiceEndpoint(...) permet de définir le point d'acces ("Reverse") de notre service et le protocole de communication (asicHttpBinding).

ensuite il ne reste que lancer le service avec la commande host.Open().

Le code complet de notre serveur sera dons le suivant:


using System;
using System.ServiceModel;

namespace WCFServer
{

[ServiceContract]
public interface IStringReverser
{
  [OperationContract]
  string ReverseString(string value);
}

public class StringReverser : IStringReverser
{
  public string ReverseString(string value)
  {
    char[] retVal = value.ToCharArray();
    int idx = 0;
    for (int i = value.Length - 1; i >= 0; i--)
      retVal[idx++] = value[i];

    return new string(retVal);
  }
}
 
class Program
{
  static void Main(string[] args)
  {

     ServiceHost host=new ServiceHost(typeof(StringReverser), 
                                    newUri("http://localhost:8000"));

      host.AddServiceEndpoint(typeof(IStringReverser),
        new BasicHttpBinding(),"Reverse");

      host.Open();

      Console.WriteLine("Service is available. " +
        "Press to exit.");
      Console.ReadLine();

      host.Close();
  }
}

}


Passons maintenant au client, en premier lieu, on doit définir la même interface du service offerte par le serveur.
En second lieu, on doit définir un proxy et un canal de communication entre le client et le serveur ce qui permettant ainsi l'echange des messages. Pour cela, on va utiliser la classe ChannelFactory offerte par WCF.
 Le code du client sera donc comme suit:

using System;
using System.ServiceModel;
using System.ServiceModel.Channels;

namespace WCFClient
{
  [ServiceContract]
  public interface IStringReverser
  {
    [OperationContract]
    string ReverseString(string value);
  }

  class Program
  {
    static void Main(string[] args)
    {
      ChannelFactory<IStringReverser> httpFactory =
        new ChannelFactory<IStringReverser>(
          new BasicHttpBinding(),
          new EndpointAddress("http://localhost:8000/Reverse"));

      IStringReverser httpProxy =
        httpFactory.CreateChannel();

      while (true)
      {
        string str = Console.ReadLine();
        Console.WriteLine("http: " +
          httpProxy.ReverseString(str));
      }
    }
  }
}


trop simple non ?, WCF facilite beaucoup le développement des applications distribuées par l'abstraction de la partie communication et les développeurs n'ont qu'a definir les services et leurs mode de communication.

Télécharger le code source de l'exemple ici


.

Aucun commentaire: