Introduction

Il y a quelques jours je suis tombé sur un code qui m’a fait m’interroger sur les connaissances qu’ont les gens des Services WCF et plus précisément sur la partie Call Back. Le code sur lequel je suis tombé était un code de surveillance d’une base de données. Chaque modification de données (Ajout, Suppression, Modification) devait envoyer un mail de notification aux personnes définies dans une liste. Mais la question ici est : comment cette base de données était surveillée ? Avec un simple « Timer » qui checke et compare les données de la base. Oui je sais on pourra dire qu’on est revenu à l’âge de pierre. Une autre façon de faire est d’utiliser un service WCF et ces fonctions de Call Back. Un petit Exemple.

Comment ca marche ?

Si vous ne savez pas ce qu'est un Service WCF je vous suggère de lire les articles référencés dans la partie Communication du menu Tutoriaux.

Comment marche le call back ?

Vous allez avoir des clients (Applications) qui vont s’enregistrer auprès de votre service. Votre service va alors vous mettre dans une liste et vous garder en mémoire afin de vous notifier en cas de besoin. Lorsque le code de notification est déclenché il reprend la liste de tous les clients enregistrés dans la liste et déclenche une méthode côté client. Pour revenir à l’exemple cité dans l’introduction, imaginons que nous ayons confié à notre service WCF la mise à jour de notre base de données. Une méthode exposée côté service nous autorise à ajouter des données en base. Dans cette méthode, qui est exécutée côté serveur, le service va déclencher un appel à tous les clients enregistrés. Ainsi, il n’y a pas de Timer et la communication ne se fait que quand il faut qu’il y ait communication.

Qu’est ce qu’il faut pour que ca marche ?

Pour qu’un service de Call Back fonctionne il faut trois choses :

1. Une première interface qui expose les méthodes aux clients
2. Une classe qui implémente l’interface de méthodes
3. Et une dernière interface qui représente les méthodes que vous allez implémenter quand vous en hériterez. Tous les clients voulant s'enregistrer à votre service CallBack devront implémenter cette interface.

Coté Serveur

Interface d'exposition des méthodes, ici rien d'exceptionnel si vous vous êtes habitués avec les autres tutoriaux. Rien ne doit vous être étranger si ce n'est le "CallBackContract". Ce "CallbackContract" précise que tous les clients qui vont s'abonner au service de callback devront implémenter l'interface ICallBackClient.

using System;
using System.ServiceModel;

namespace Proteus.Services.Vocabularies
{
    [ServiceContract(CallbackContract = typeof(ICallBackClient))]
    public interface ICallBackUpdater
    {
        [OperationContract]
        void UpdateSuscriber();

        [OperationContract]
        bool Subscribe();

        [OperationContract]
        bool Unsubscribe();

        [OperationContract]
        Int32 GetConnectedToWCFCount();
    }
}

Maintenant nous allons créer le service qui va implémenter cette interface. Là encore rien d'exceptionnel.

using System;
using System.Collections.Generic;
using System.ServiceModel;

namespace Proteus.Services.Vocabularies
{
    public class CallBackUpdate : ICallBackUpdater
    {
        #region Variables
        private static readonly List suscriberList = new List();

        #endregion

        #region Constructeurs
        public CallBackUpdate() { }

        #endregion

        #region Methodes
        public void UpdateSuscriber()
        {
            foreach (ICallBackClient client in suscriberList)
            {
                client.OnUpdateDemanded();
            }
        }
        public bool Subscribe()
        {
            try
            {
                ICallBackClient callback = OperationContext.Current.GetCallbackChannel();
                if (!suscriberList.Contains(callback))
                    suscriberList.Add(callback);

                return true;
            }
            catch
            {
                return false;
            }
        }
        public bool Unsubscribe()
        {
            try
            {
                ICallBackClient callback = OperationContext.Current.GetCallbackChannel();
                if (suscriberList.Contains(callback))
                    suscriberList.Remove(callback);

                return true;
            }
            catch
            {
                return false;
            }
        }
        public Int32 GetConnectedToWCFCount()
        {
            return suscriberList.Count;
        }

        #endregion
    }
}

Et maintenant l'interface que chaque client devra implémenter avant de s'enregistrer aupres du service WCF.

using System.ServiceModel;
using System;

namespace Proteus.Services.Vocabularies
{
    interface ICallBackClient
    {
        [OperationContract(IsOneWay = true)]
        void OnUpdateDemanded();
    }
}

Côté Client

Côté client, une fois que vous avez référencé votre Service WCF, il ne vous reste plus qu'à mettre quelques lignes de codes.

using System;
using System.ServiceModel;
using System.Windows;
using WpfApplication1.ServiceReference1;

namespace WpfApplication1
{
    [CallbackBehavior(ConcurrencyMode = ConcurrencyMode.Reentrant)]
    public partial class MainWindow : Window, ICallBackUpdaterCallback
    {
        #region Variables
        private CallBackUpdaterClient client;
        #endregion

        #region Constructeurs
        public MainWindow()
        {
            InitializeComponent();
            InstanceContext context = new InstanceContext(this);
            client = new CallBackUpdaterClient(context, "WSDualHttpBinding_ICallBackUpdater");
            client.Subscribe();
        }

        #endregion

        #region Methodes
        public void OnUpdateDemanded()
        {
            MessageBox.Show("Called from WCF");
        }

        #endregion
    }
}

Que se passe t-il ici ?

Quand la fenêtre s'ouvre elle s'enregistre aupres du service WCF en tant que client à avertir. Quand le service WCF appelera sa methode UpdateSuscriber, votre fenêtre sera notifiée et declenchera la méthode OnUpdateDemanded.

Conclusion

Utiliser le service de Call Back devrait vous ouvrir des possibilités plutôt larges. Pour ma part je l'utilise pour le projet autour de NAO. Quand NAO s'allume il s'abonne auprès du service comme étant un client à avertir. Quand une données sur mon site web est modifiée, Nao m'en informe. Si jamais vous avez des questions ou mieux encore si vous rencontrez des bugs, n'hésitez pas m'en faire part.