CodeS-SourceS
Rechercher un code, un tuto, une réponse

[.Net3/WCF] 1ère approche - construction d'un service WCF

Juin 2017


Windows Communication Fundation - Première approche



Introduction


Ce tutoriel explique pas à pas les différentes étapes de constructions d'un service WCF hébergé pas IIS.

Un second tutoriel est à disposition, ainsi que la source complète (service WCF + client) prise pour cette démo:


Bon service :)

Construction du service WCF


Le service fournira les opérations suivantes pour notre application cliente que nous verrons dans le second tutoriel:
  • Obtenir des informations sur un membre de Codes-Sources.
  • Lister les membres de Codes-Sources .
  • Supprimer un membre.
  • Créer un nouveau membre.
  • Simple addition entre deux nombres.

A présent, passons à la création de notre service WCF. Créer un nouveau projet de type « WCF Service Library ».

Définir les contrats


La structure d'un service WCF s'appuie sur deux types de contrats, un contrat de données et un contrat de service:
  • Un contrat de données : Il définit le format des données d'un objet métier (classe) / structure / énumération qui sera échangé entre le service et le client. Il est définit par l'attribut [ DataContract ] et ses membres marqués de l'attribut [ DataMember ] . (Si un membre n'est pas balisé [ DataMember ] il ne sera pas sérialisé dans le flux XML qui sera échangé entre le service et le client).
  • Un contrat de service : Interface qui définit les méthodes ( = opérations) que le service WCF va exposer aux clients . Il est définit par l'attribut [ ServiceContract ] et ses membres marqués de l'attribut [ OperationContract ] .

Maintenant que les présentations sont faîtes, nous allons définir notre seul contrat de données pour un objet MembreCS. Créons une classe MembreCS avec les membres le caractérisant comme ci-dessous.

// Objet représentant un membre de CodeS-SourceS
[DataContract]
public class MembreCS
{
    //ID du membre
    [DataMember]
    public uint ID;
    
    //Nom du membre
    [DataMember]
    public string Nom;
    
    //Prénom du membre
    [DataMember]
    public string Prenom;
    
    //Pseudo du membre
    [DataMember]
    public string Pseudo;
    
    //Age du membre
    [DataMember]
    public uint Age;
    
    //URL du profil sur CodeS-SourceS
    [DataMember]
    public string Profile;
    
    //Membre normal ou admin
    [DataMember]
    public bool EstAdmin;
}


Une fois le contrat de données définit sur notre objet MembreCS nous allons pouvoir écrire le contrat de service de notre service WCF. Créez une interface que vous appellerez IDemoWCFService avec les signatures des méthodes comme ci-dessous.

// Décrit les opérations exposées par le service
[ServiceContract]
public class IDemoWCFService
{
    //Lister les membres
    [OperationContract]
    List<MembreCS> ListeMembres();
    
    //Obtenir des informations sur un membre
    [OperationContract]
    MembreCS DetailsMembre(uint ID);
    
    //Supprimer un membre
    [OperationContract]
    bool SupprimerMembre(uint ID);
    
    //Pseudo du membre
    [OperationContract]
    public string Pseudo;
    
    //Créer un nouveau membre
    [OperationContract]
    bool NouveauMembre(uint ID, string nom, string prenom, string pseudo, uint age, string profile, bool admin);
    
    //Simple addition entre 2 nombres
    [OperationContract]
    int Addition(int nombre1, int nombre2);
}

Mise en oeuvre du service WCF


Après avoir spécifié la structure des données à notre service avec un Contrat de Données et définit les opérations qui seront exposées par le service à l'aide d'un Contrat de Service , la prochaine étape va être tout simplement d'écrire le code de nos méthodes exposées (opérations) en mettant en oeuvre le Contrat de Service (implémentation de l'interface IDemoWCFService).

Pour cela créons une nouvelle classe DemoService sous le contrat de service IDemoWCFService comme ci-dessous.

// Classe implémentant le contrat de service IDemoWCFService
class DemoService : IDemoWCFService
{
    public List<MembreCS> ListeMembres()
    {
        //Récupère la liste des membresCS
        return LibSerializer.DeserializeObjectFromXML<List<MembreCS>>(FICHIER_MEMBRES_CS);
    }
    
    public MembreCS DetailsMembre(uint ID)
    {
        MembreCS mCS = new MembreCS();
        try
        {
            //Liste des membresCS
            List<MembreCS> lmCS = LibSerializer.DeserializeObjectFromXML<List<MembreCS>>(FICHIER_MEMBRES_CS);
            
            //Recherche le membreCS
            mCS = lmCS.Find(delegate(MembreCS m) {return m.ID == ID; });
        }
        catch (Exception e)
        {
            throw new FaultException(ex.Message, new FaultCode("DetailsMembre"));
        }
    }
}


Je passe sur les autres méthodes que vous retrouvez bien évidement dans la source associée à ce tutoriel...

Hébergement du service


Pour pouvoir exécuter le service WCF et le rendre accessible aux clients nous devons l'héberger soit dans une application dîtes Hôte, service Windows soit par IIS. Pour cette démonstration le service sera hébergé par IIS.

Ajouter un fichier de définition de service (. svc) qui va spécifier le nom de la classe que va exécuter IIS ainsi que le nom de l'assemblage qui renferme cette classe.
Créer un fichier « Web.config » en y ajoutant des informations dit de liaisons nécessaire à IIS. En effet ces informations vont indiquer comment un client doit communiquer avec le service WCF.
Déployer le service WCF vers IIS.
Et c'est parti, ajouter un nouvel élément de type Fichier texte portant le même nom que le service WCF « DemoWCFService »


Comme décrit dans la définition de la première étape nous allons spécifier le nom de la classe et de l'assemblage qui la renferme. Ajouter les lignes suivantes dans le fichier DemoWCFService.svc.

<%@ServiceHost Service="DemoWCFService.DemoService" %>
<%@Assembly Name="DemoWCFService" %>


Passons maintenant à la seconde étape, le fichier Web.config.

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <system.serviceModel>
        <services>
            <service name="DemoWCFService.DemoService" behaviorConfiguration="DemoServiceBahavior">
                <endpoint address=" " binding="basicHttpBinding" contract="DemoWCFService.IDemoWCFService" />
            </service>
        <services>
        <behavior>
            <serviceBehaviors>
                <behavior name="DemoServiceBehavior">
                    <serviceMetadata httpGetEnabled="true"/>
                </behavior>
            </serviceBehaviors>
        </behavior>
    </system.serviceModel>
</configuration>


Examinons ensemble la section <system.serviceModel> :

<!--Contient les informations de configuration d'un service WCF.-->
<system.serviceModel>
<!--Contient les détails de chaque service mis en oeuvre.-->
<services>
    <!--Détail sur notre unique service.-->
    <!--Elément name: Spécifie l'espace de noms et la classe mettant en oeuvre notre unique service.-->
    < service name ="DemoWCFService.DemoService" behaviorConfiguration ="DemoServiceBehavior">
        <!--Elément endpoint: Sans entrer dans les détails, il s'agit de l'élément qui fournit
        aux applis. clientes les infos dont elles ont besoin pour communiquer avec
        notre service DemoService.-->
        < endpoint address ="" binding ="basicHttpBinding" contract ="DemoWCFService.IDemoWCFService" />
    </service>
</services>


Dans la section <behavior > je vais activer la publication des métadonnées (du Contrat de Service) ce qui va permettre par la suite aux utilisateurs d'obtenir ces métadonnées en émettant une requête au service WCF de type HttpGet et ainsi retrouver un wsdl classique de WebService .

Il nous reste plus qu'à présent à déployer vers IIS notre service WCF (Je pars du principe que IIS est déjà activé et configuré) . Dans IIS ajouter un nouveau répertoire virtuel dans « Site Web par Défaut » et pointer le vers la racine de la solution du service WCF (Voir ci-dessous).


Le service est maintenant hébergé par IIS est prêt à être consommer par des applications clientes.

Test du déploiement du service WCF


Dernière partie de ce tutoriel, le test de notre service WCF. Pour ce faire rien de plus simple, ouvrez votre navigateur Internet et saisissez l'adresse du service. http://localhost/DemoWCFService/DemoWCFService.svc



PS: http://localhost/DemoWCFService/DemoWCFService.svc?wsdl pour voir afficher les métadonnées du Contrat de Service.

A voir également

Publié par cs_Willi.
Ce document intitulé «  [.Net3/WCF] 1ère approche - construction d'un service WCF  » issu de CodeS-SourceS (codes-sources.commentcamarche.net) est mis à disposition sous les termes de la licence Creative Commons. Vous pouvez copier, modifier des copies de cette page, dans les conditions fixées par la licence, tant que cette note apparaît clairement.
Créer un Add-in Automation pour Excel
[.Net3/WCF] 1ère approche - construction d'un client WCF