Le Design Pattern “Observer” : l’implémentation proposée par Microsoft en .NET 4.0

  class FBNotificationCenter : IObservable<FBNotificationInfo>
  {
    private List<IObserver<FBNotificationInfo>> _observers = new List<IObserver<FBNotificationInfo>>();
    private List<FBNotificationInfo> _notifications = new List<FBNotificationInfo>();

    public List<FBNotificationInfo> Notifications
    {
      get { return _notifications; }
    }

    public IDisposable Subscribe(IObserver<FBNotificationInfo> observer)
    {
      if (!_observers.Contains(observer))
        _observers.Add(observer);

      return new FBConnection<FBNotificationInfo>(_observers, observer);
    }

    public void AddNotification(string notificationInfo)
    {
        FBNotificationInfo info = new FBNotificationInfo(notificationInfo);
        _notifications.Add(info);
        NotifyObservers(info);
    }

    private void NotifyObservers(FBNotificationInfo info)
    {
      foreach (var observer in _observers)
      {
        if (string.IsNullOrEmpty(info.Info))
        {
          observer.OnError(new ArgumentNullException("info", "Le Paramètre ne peut pas être vide ou null"));
        }
        else observer.OnNext(info);
      }
    }
  }

L’Objet qui va transmettre la notification :

class FBNotificationInfo
{
    private DateTime dateTime;
    private string info;
    private bool viewed;

    public bool Viewed
    {
      get { return viewed; }
      set { viewed = value; }
    }

    public DateTime DateTime
    {
      get { return dateTime; }
    }

    public string Info
    {
      get { return info; }
    }

    public FBNotificationInfo(String info)
    {
      dateTime = DateTime.Now;
      this.info = info;
      viewed = false;
    }
}

Remarque :

Jusqu’ici, il n’y a pas vraiment de différences entre le Template du Design Pattern Observer et l’implémentation .NET, à part le type de retour de la méthode  “Subscribe(…) : IDisposable”. Et là, on aperçoit la première touche personnelle dans cette implémentation en .NET 4.0.

La classe FBConnection joue le rôle du “Unsubscriber” qui sert à désinscrire un observer pour ne plus recevoir les notifications. L’idée proposée dans le Framework .NET 4.0 donne la possibilité à chaque observer de se désinscrire lui-même, par opposition du Template qui propose une seule façon de se désinscrire : l’utilisation de la méthode removeObserver(…), qui est propre à l’observable seulement.

  class FBConnection : IDisposable
  {
    private List _observers;
    private IObserver _observer;

    public FBConnection(List observers, IObserver observer)
    {
      this._observers = observers;
      this._observer = observer;
    }

    public void Dispose()
    {
      if (_observers.Contains(_observer))
      {
        _observers.Remove(_observer);
      }
    }
  }

On verra par la suite l’utilisation de la méthode Dispose() par l’observer.

Observer

• System.IObserver :
  • OnNext : c’est la méthode équivalente de « update(…) » décrite dans le Template au début de cet article. La différence est seulement dans la nomenclature. Je ne sais d’ailleurs pas pourquoi Microsoft a choisi ce nom pour cette méthode ? (j’aurais aimé « OnUpdate » à la place)
  • OnError : Une nouvelle méthode ajoutée par rapport au Template,  pour faire communiquer l’erreur du sujet vers ses observateurs.
  • OnCompleted : Cette méthode peut être utilisée pour montrer qu’il n’y a plus de notification à transmettre. L’observateur pourra alors se désinscrire par exemple.
• WebBrowser, Smartphone : Les observateurs qui seront notifiés par FBNotificationCenter.

  abstract class FacebookView : IObserver
  {
    private IDisposable _connection;
    protected List _myNotifications = new List();

    public void OnCompleted()
    {
      // Je n'ai pas utilisé cette méthode dans cet exemple.
      // Elle est utilisée quand l'Observable envoie un
      // ensemble d'informations en boucle, et après avoir fini,
      // il appellera cette méthode pour informer ses observateurs
      // de la fin d'envoi de notifications.
    }

    public void OnError(Exception error)
    {
      Console.WriteLine(string.Format("{0} > {1}",this.GetType().Name, "Oops !! Erreur : " + error.Message));
    }

    public void OnNext(FBNotificationInfo notification)
    {
      _myNotifications.Add(notification);
      ShowNewNotificationCount();
    }

    public void ConnectTo(FBNotificationCenter provider)
    {
      if (provider != null)
      {
        _connection = provider.Subscribe(this);
        // mettre à jour le nouvel inscrit
        foreach (var notification in provider.Notifications)
          _myNotifications.Add(notification);
      }
    }

    public void Disconnect()
    {
      if (_connection != null)
      {
        _myNotifications.Clear();
        _connection.Dispose();
      }
    }

    private void ShowNewNotificationCount()
    {
      Console.WriteLine(string.Format("{0} Notifié > Vous avez {1} nouvelle(s) notification(s) !", this.GetType().Name, GetNewNotificationCount()));
    }

    private int GetNewNotificationCount()
    {
      int count = 0;
      foreach (var info in _myNotifications)
        if (!info.Viewed) count++;

      return count;
    }

    public abstract void ShowNotifications();
  }

Chaque Observer affichera l’information avec sa propre manière en implémentant la méthode abstraite ShowNotifications()

le WebBrowser :

  class WebBrowser : FacebookView
  {
    public override void ShowNotifications()
    {
      Console.WriteLine(this.GetType().Name + "> Affichage des notifiations :");
      string newNotification = "Ancien";
      foreach (var notification in _myNotifications.Reverse() )
      {
        if (!notification.Viewed)
        {
          newNotification = "Nouveau";
          notification.Viewed = true;
        }
        else newNotification = "Ancien";
        Console.WriteLine(string.Format("\t {0}> {1} {2} {3}", newNotification, notification.DateTime.ToString("dd MMM"), notification.Info, notification.DateTime.ToString("hh:mm:ss")));
      }
    }
  }

et la SmartphoneApplication :

  class SmartphoneApplication : FacebookView
  {
    public override void ShowNotifications()
    {
      Console.WriteLine(this.GetType().Name + "> Showing notifications :");
      string newNotification = "Old";
      foreach (var notification in _myNotifications.Reverse())
      {
        if (!notification.Viewed)
        {
          newNotification = "New";
          notification.Viewed = true;
        }
        else newNotification = "Old";
        Console.WriteLine();
        Console.WriteLine("\t" + notification.DateTime.ToString("dd MMM"));
        Console.WriteLine("\t" + notification.DateTime.ToString("hh:mm:ss"));
        Console.WriteLine("\t" + string.Format("({0}) {1}", newNotification, notification.Info));
        Console.WriteLine();
      }
    }
  }

Le main :

 class Program
  {
    static void Main(string[] args)
    {
      FBNotificationCenter notificationCenter = new FBNotificationCenter();
      WebBrowser browser = new WebBrowser();
      SmartphoneApplication app = new SmartphoneApplication();
      browser.ConnectTo(notificationCenter);
      notificationCenter.AddNotification("Messi aime votre photo");//1
      notificationCenter.AddNotification("Xavi a commenté votre publication");//2
      app.ConnectTo(notificationCenter);
      browser.ShowNotifications();//3
      notificationCenter.AddNotification("Puyol vous invite à aimer sa page");//4
      browser.ShowNotifications();//5
      notificationCenter.AddNotification("Ronaldinho a accepté votre invitation");//6
      app.ShowNotifications();//7
      app.Disconnect();
      notificationCenter.AddNotification("");//8
      browser.ShowNotifications();//9
      Console.ReadKey();
    }
  }

Le Résultat :

Conclusion

Le but de cet article était d’une part de comprendre le design pattern observer, et d’autre part de montrer que l’implémentation concrète de n’importe quel design pattern est souvent différente du template (théorie). Et c’est là qu’apparaît la difficulté d’utilisation et du choix d’un design pattern pour un problème. Le facteur expérience a une grande importance pour prendre la bonne solution au bon problème d’architecture.