ASP.Net e Pattern Observer in Pratica – Terza Parte

Nel post ASP.Net e Pattern Observer in Pratica – Seconda Parte abbiamo visto la teoria alla base del Pattern Observer e precedentemente in ASP.Net e Pattern Observer in Pratica – Prima Parte le motivazioni che mi hanno spinto ad affrontare la questione. Adesso vedremo un’implementazione didattica d’esempio per chiarire un po’ le idee prima di addentrarci nell’implementazione finale dello scenario presentato in principio.

Implementazione del Pattern Observer

Prima di iniziare ci tengo a ripetere che questa sarà un’implementazione ridotta al minimo, ovvero scritta al solo scopo di farti comprendere il disegno della soluzione proposta dal pattern, mentre nel prossimo post vedremo un’implementazione reale che, seppur semplice, potrebbe risultarti utile nel lavoro di tutti i giorni 😉

Iniziamo con la definizione dell’interfaccia che identifica il pubblicatore (ISubject)

    /// <summary>
    /// Interfaccia da implementare sul pubblicatore.
    /// </summary>
    interface ISubject
    {
        /// <summary>
        /// Registra un sottoscrittore all'evento di notifica.
        /// </summary>
        /// <param name="o">Interfaccia che identifica un Sottoscrittore.</param>
        void Attach(IObserver o);

        /// <summary>
        /// Rimuove un sottoscrittore dall'evento di notifica.
        /// </summary>
        /// <param name="o">Interfaccia che identifica un Sottoscrittore.</param>
        void Detach(IObserver o);

        /// <summary>
        /// Notifica a tutti i sottoscrittori il cambio di stato.
        /// </summary>
        void Notify();
    }

e poi quella che identifica gli eventuali sottoscrittori (IObserver)

    /// <summary>
    /// Interfaccia da implementare in tutti i sottoscrittori.
    /// </summary>
    public interface IObserver
    {
        /// <summary>
        /// Aggiorna lo stato interno del sottoscrittore quando riceve
        /// l'evento di notifica dal pubblicatore.
        /// </summary>
        void Update();
    }

ora veniamo all’implementazione dell’interfaccia ISubject

    /// <summary>
    /// Implementazione di esempio per il pubblicatore.
    /// </summary>
    public class Subject : ISubject
    {
        /// <summary>
        /// Lista interna degli oggetti sottoscritti all'evento di notifica.
        /// </summary>
        private List<IObserver> _observers = new List<IObserver>();

        /// <summary>
        /// Sottoscrive un sottoscrittore.
        /// </summary>
        /// <param name="o">Interfaccia che identifica un Sottoscrittore.</param>
        public void Attach(IObserver o)
        {
            if (!(o == null || _observers.Contains(o)))
                _observers.Add(o);
        }

        /// <summary>
        /// Rimuove un sottoscrittore.
        /// </summary>
        /// <param name="o">Interfaccia che identifica un Sottoscrittore.</param>
        public void Detach(IObserver o)
        {
            if(o != null)
                _observers.Remove(o);
        }

        /// <summary>
        /// Notifica a tutti i sottoscrittori il cambio di stato.
        /// </summary>
        public void Notify()
        {
            // Cicla tutti i sottoscrittori registrati e ne invoca il metodo Update.
            foreach (IObserver o in _observers)
            {
                o.Update();
            }
        }

        /// <summary>
        /// Metodo di esempio che muta lo stato interno dell'oggetto.
        /// </summary>
        public void ChangeInternalStatusMethod()
        {
            // Operazioni varie...
            // this.Operation1();
            // this.Operation2();
            // ecc..

            // Notifica
            this.Notify();
        }
    }

e poi l’implementazione dell’interfaccia IObserver

    /// <summary>
    /// Implementazione di esempio per il sottoscrittore.
    /// </summary>
    public class Observer : IObserver
    {
        /// <summary>
        /// Aggiorna lo stato interno del sottoscrittore quando riceve
        /// l'evento di notifica dal pubblicatore.
        /// </summary>
        public void Update()
        {
            // La scrittura nella finestra di debug serve solo per darti
            // la possibilità di verificare che la notifica è avvenuta.
            Debug.WriteLine(string.Format("Notifica avvenuta alla: {0}", DateTime.Now.ToString()));
        }
    }

Bene il codice relativo al pattern è completo, non ci resta che verificare come gira il tutto all’interno di un programma che per semplicità sarà una Console Application

class Program
    {
        static void Main(string[] args)
        {
            // Istanzia il pubblicatore.
            Subject subject = new Subject();

            // Istanzia e registra i sottoscrittori alla notifiche.
            IObserver observer1 = new Observer();
            subject.Attach(observer1);

            IObserver observer2 = new Observer();
            subject.Attach(observer2);

            // Il metodo "ChangeInternalStatusMethod" identifica un metodo di
            // esempio che dopo alcune elaborazioni cambia lo stato interno
            // del pubblicatore, al suo interno viene invocato il metodo Notify()
            // in modo che i sottoscrittori ricevano le nodifiche di avvenuto
            // cambio di stato.
            subject.ChangeInternalStatusMethod();

            Console.Read();
        }
    }

Come ho già detto questa è un’implementazione didattica al solo scopo di capire come gira il tutto ma così fatta è poco utile, in quanto nella maggior parte delle implementazioni reali al momento della notifica risulta necessario che ai sottoscrittori venga notificato non solo che c’è stato cambimento di stato ma anche cosa è cambiato nel contesto del pubblicatore in modo da poter reagire di conseguenza…

Bene nel prossimo post ne parleremo diffusamente con un esempio reale.

Un pensiero su “ASP.Net e Pattern Observer in Pratica – Terza Parte

Rispondi

Inserisci i tuoi dati qui sotto o clicca su un'icona per effettuare l'accesso:

Logo WordPress.com

Stai commentando usando il tuo account WordPress.com. Chiudi sessione / Modifica )

Foto Twitter

Stai commentando usando il tuo account Twitter. Chiudi sessione / Modifica )

Foto di Facebook

Stai commentando usando il tuo account Facebook. Chiudi sessione / Modifica )

Google+ photo

Stai commentando usando il tuo account Google+. Chiudi sessione / Modifica )

Connessione a %s...