Implémentation du modèle de conception Observer en C #

Le modèle de conception Observer appartient à la catégorie Modèle de conception comportementale et est utilisé lorsque vous souhaitez notifier la modification d'un certain nombre de classes. Les modèles de conception comportementale sont ceux qui sont utilisés pour gérer la collaboration d'objets et la délégation de responsabilités.

Essentiellement, le modèle de conception Observer est utilisé pour définir comment la communication entre les composants d'une application interagit les uns avec les autres ou se notifie mutuellement en envoyant des messages. Dans ce modèle, le sujet maintient une liste des observateurs et informe ensuite ces observateurs ou les personnes à charge au fur et à mesure qu'un changement d'état se produit. Vous pouvez également ajouter ou supprimer des observateurs au moment de l'exécution.

Applicabilité

Quand devriez-vous utiliser ce modèle de conception? C'est un bon choix lorsque vous souhaitez avoir un sujet qui doit être observé par un ou plusieurs observateurs. Il s'agit d'un modèle de conception populaire qui vous aide à implémenter un scénario d'éditeur / abonné dans lequel les modifications apportées à l'état d'un objet peuvent être notifiées à tous les objets dépendants ou abonnés (dans une implémentation typique du scénario d'éditeur / abonné). Dans le modèle de conception Observer, les changements d'état d'un objet sont communiqués à un autre objet sans qu'il soit nécessaire que les objets soient étroitement couplés les uns aux autres.

Le modèle architectural MVC (Model View Component) est un exemple classique d'implémentation du modèle de conception Observer. Le modèle architectural MVC est utilisé pour créer des applications faiblement couplées, plus faciles à tester et à maintenir. Dans une implémentation MVC typique, la vue et le modèle sont découplés l'un de l'autre. Alors que la vue représente l'observateur, le modèle représente votre objet observable.

Implémentation du modèle de conception Observer

Nous en avons assez des concepts - comprenons maintenant ce modèle de conception avec une implémentation. Tout d'abord, nous devons connaître les classes ou types participants.

  • Sujet: Ceci est représenté par un type qui est utilisé pour définir une interface pour attacher ou détacher un ou plusieurs observateurs
  • ConcreteSubject: Ceci est utilisé pour notifier les observateurs lorsqu'il y a un changement d'état
  • Observateur: Ceci représente le type qui doit être notifié en cas de changement
  • ConcreteObserver: Ceci représente l'implémentation concrète du type observateur

Dans une implémentation typique du modèle de conception Observer, vous souhaiterez peut-être avoir un type Subject et un type Observer. Voici un extrait de code qui illustre cela.

    public abstract class Subject

    {

        protected List lstObservers = new List();

        protected void Register(Observer observer)

        {

            lstObservers.Add(observer);

        }

        protected void UnRegister(Observer observer)

        {

            lstObservers.Remove(observer);

        }

        protected void UnRegisterAll()

        {

            foreach (Observer observer in lstObservers)

            {

                lstObservers.Remove(observer);

            }

        }

        public abstract void Notify();

    }

public abstract class Observer

    {

        public abstract void Update();

    }

Maintenant, reportez-vous à l'extrait de code ci-dessus. La classe Subject contient une liste d'instances d'Observer et quelques méthodes pour ajouter ou supprimer les abonnés, c'est-à-dire des instances de la classe Observer. Notez que la méthode Notify a été déclarée abstraite - la classe qui étendrait la classe Subject doit fournir l'implémentation respective de cette méthode. La classe Observer contient une seule méthode - la méthode Update. J'ai rendu cette implémentation aussi simple que possible.

La classe BlogPost étend la classe Subject et implémente la méthode Notify qui a été déclarée comme abstraite dans la classe Subject.

public class BlogPost: Subject

    {

        public void Attach(Observer observer)

        {

            //You can write your own implementation here or call the base version

            base.Register(observer);

        }

        public void Detach(Observer observer)

        {

            //You can write your own implementation here or call the base version

            base.UnRegister(observer);

        }

        public void DetachAll()

        {

            //You can write your own implementation here or call the base version

            base.UnRegisterAll();

        }

        public override void Notify()

        {

            foreach (Observer observer in lstObservers)

            {

                observer.Update();

            }

        }

    }

La classe ConcreteObserver est donnée ci-dessous. Je laisse aux lecteurs le soin d'écrire leur propre code dans la méthode Update pour envoyer un email notifiant qu'un article a été posté, ou, etc.

public class ConcreteObserver : Observer

    {

        public string Email

        {

            get; set;

        }

        public override void Update()

        {

            Console.WriteLine("Inside the Update method...");

        }

    }

Vous pouvez en savoir plus sur le modèle de conception Observer à partir de ce lien.