Sébastien Pertus
Chapitre III : Sync Services for ADO.NET et WCF
Suite des deux premiers chapitres sur la synchronisation avec Sync Services for ADO.NET, voici un nouvel article impliquant WCF dans une synchronisation déconnectée.
Par Sébastien Pertus publié le 29/04/2008 à 09:14, lu 1894 fois, 5 pages
commentaire(s) 2 commentaire(s) tag(s)Tags: Microsoft Sync Framework, Visual Studio 2008, Windows Communication Foundation
 4 | Implémentation WCF
Implémentation WCF
Comme dirait l'ami Fred, la bonne façon de faire en WCF, ça reste une assembly contenant les contrats (interfaces)
Nous déplaçons donc l'interface IBewiseSyncSyncContract dans le projet WCFInterface, en n'oubliant pas de bien référencer ce projet au niveau de notre projet service et en rajoutant dans le fichier BewiseSync.Server.SyncContract.cs le using qui va bien :

namespace WCFInterfaces

{

 

    [ServiceContractAttribute()]

    public interface IBewiseSyncSyncContract

    {

 

        [OperationContract()]

        SyncContext ApplyChanges(SyncGroupMetadata groupMetadata, DataSet dataSet, SyncSession syncSession);

 

        [OperationContract()]

        SyncContext GetChanges(SyncGroupMetadata groupMetadata, SyncSession syncSession);

 

        [OperationContract()]

        SyncSchema GetSchema(Collection<string> tableNames, SyncSession syncSession);

 

        [OperationContract()]

        SyncServerInfo GetServerInfo(SyncSession syncSession);

    }

}

Vous pouvez prendre le code exemple généré et simplement le copier coller dans le fichier de configuration.
Notez cependant qu'il est nécessaire de bien changer le nom de l'assembly représentant nos contrats, pour refléter le changement de place de l'interface de l'assembly Service (WCFService) vers l'assembly Interface (WCFInterface)
Dans ce cas d'exemple, on arrive à ceci :

<system.serviceModel>

        <services>

            <service name="WCFService.BewiseSyncSyncService" behaviorConfiguration="WCFService.BewiseSyncSyncServiceBehavior">

                <host>

                    <baseAddresses>

                        <add baseAddress="http://localhost:8080/BewiseSyncService" />

                    </baseAddresses>

                </host>

                <endpoint address="/ws"

                        binding="wsHttpBinding"

                        contract="WCFInterfaces.IBewiseSyncSyncContract" >

 

                </endpoint>

                <endpoint address="/mex"

                        binding="mexHttpBinding"

                        contract="WCFInterfaces.IBewiseSyncSyncContract" />

            </service>

        </services>

 

        <behaviors>

            <serviceBehaviors>

                <behavior name="WCFService.BewiseSyncSyncServiceBehavior">

                    <serviceMetadata httpGetEnabled="True"/>

                    <serviceDebug includeExceptionDetailInFaults="True" />

                </behavior>

            </serviceBehaviors>

        </behaviors>

    </system.serviceModel>

Client WCF
Il ne nous reste plus qu'à implémenter notre proxy WCF coté client.
Nous allons donc rajouter un service reference à notre projet client.
Notez qu'il n'est pas nécessaire de lancer le projet service pour que visual studio puisse le « voir » Utiliser, lors de l'ajout de la référence, de l'outil « Discover Services in Solution »
 
/content/0d058078-eb89-46e3-938c-6dbb400c1479/DiscoverServices.jpg
 
Visual Studio va parser les différents projets et fichier de configuration à la recherche de services WCF.
Dans notre cas, il retrouve bien notre services WCF :
 
/content/0d058078-eb89-46e3-938c-6dbb400c1479/ReferenceService01.jpg
 
Note : Si vous essayez de déplier l'arbre de BewiseSyncService, VS.Net va automatiquement lancer WCFSvcHost pour lire le wsdl associé et rapatrier les méthodes du contrat d'interfaces ;)
 
/content/0d058078-eb89-46e3-938c-6dbb400c1479/ReferenceService02.jpg
 
Pour notre exemple, nous nommons le proxy : BewiseProxyService.
Notre service est bien référencé, il est bien présent dans « Service References » :
 
/content/0d058078-eb89-46e3-938c-6dbb400c1479/ReferenceService03.jpg
 
Si nous regardons le code implémenté, nous avons maintenant à notre disposition, notamment, la classe BewiseSyncContractClient :
 
/content/0d058078-eb89-46e3-938c-6dbb400c1479/BewiseSyncContractClient.jpg
 
Cette classe représente notre proxy, elle hérite de la classe générique ClientBase, ce qui nous abstraira de l'implémentation de notre ChannelFactory<T>.
Proxy WCF, Synchronisation
Il ne reste plus qu'à faire joujou avec tout ça !
Nous construisons une interface utilisateur qui sera chargée de récupérer les clients, leur employé attitré et leur type. On note juste le rajout du bouton Synchroniser qui permettra de synchroniser l'application lorsque le réseau est disponible :
 
/content/0d058078-eb89-46e3-938c-6dbb400c1479/InterfaceUtilisateur.jpg
 
Les EndPoints WCF :
Les endpoints WCF sont déjà implémentés dans le fichier XML, il n'y a rien à modifier de particulier, si ce n'est bien vérifier leurs présences :
 
/content/0d058078-eb89-46e3-938c-6dbb400c1479/EndPointWCFClient.jpg
 
Récupération du proxy :
Nous allons avoir besoin d'un proxy de service, celui là même renvoyé par WCF.
Il va donc être de bon ton d'en créer une instance.
Notez que nous allons faire cela une fois pour toute au chargement du formulaire. C'est plus efficace en terme de performance, mais un cas pratique, il vous sera peut être utile de ne le faire que lors de la phase de synchronisation proprement dite.

BewiseProxyService.BewiseSyncSyncContractClient serviceProxy;

 

private void Form1_Load(object sender, EventArgs e)

{

    serviceProxy = new 

        WCFClient.BewiseProxyService.BewiseSyncSyncContractClient("WSHttpBinding_IBewiseSyncSyncContract");

    Bind();

}

 

private void Bind()

{

 

    this.employeTableAdapter.Fill(this.bewisDataSet.Employe);

    this.clientTypeTableAdapter.Fill(this.bewisDataSet.ClientType);

    this.clientTableAdapter.Fill(this.bewisDataSet.Client);

}

Note : J'ai implémenter une méthode Bind(), chargée de lier les données de ma base de données locale SQL CE, que j'appelle au Form_Load et lors de la synchronisation.
Synchronize()
Le code de synchronisation reste finalement assez similaire à ce que vous connaissez déjà :
  1. Nous déclarons un SyncAgent.
  2. Le constructeur de notre syncagent nous réclame notre service proxy, que nous avons instancié auparavant.
  3. On lui demande de synchroniser via l'appel de la méthode Synchronize()
  4. On demande à rebinder les données provenant de la base SDF synchronisée.

private void btnSynchronize_Click(object sender, EventArgs e)

{

    this.Cursor = Cursors.WaitCursor;

 

    BewiseSyncSyncAgent myAgent = new BewiseSyncSyncAgent(serviceProxy);

    myAgent.Synchronize();

    Bind();

 

    this.Cursor = Cursors.Default;

}

Lors du lancement de l'application, on va pouvoir synchroniser notre application cliente avec la base de données, via un Service WCF exposé.
N'oubliez pas d'implémenter, si nécessaire le code de synchronisation Bi-Directionnel, code non implémenté de base lors de la génération du code par le Designer Sync (voir le chapitre I pour plus de détail)
 
/content/0d058078-eb89-46e3-938c-6dbb400c1479/ViewCode.jpg
 

public partial class BewiseSyncSyncAgent {

 

    partial void OnInitialized(){

 

        this.Client.SyncDirection = SyncDirection.Bidirectional;

        this.Employe.SyncDirection = SyncDirection.Bidirectional;

    }

}

 
» Démarrer une discussion
 
Discussion démarée par sebastien.boury le 30/10/2008 à 15:27, 2 commentaire(s).