Observer pattern: differenze tra le versioni

Da Wikipedia, l'enciclopedia libera.
Vai alla navigazione Vai alla ricerca
Contenuto cancellato Contenuto aggiunto
Nessun oggetto della modifica
m Annullate le modifiche di 188.11.252.133 (discussione), riportata alla versione precedente di 5.90.212.162
Riga 1: Riga 1:
L''''Observer pattern''' è un [[design pattern]] che viene insegnato dal DIVINO.
L''''Observer pattern''' è un [[design pattern]].


È un [[Design pattern|pattern]] intuitivamente utilizzato come base architetturale di molti sistemi di gestione di eventi.
È un [[Design pattern|pattern]] intuitivamente utilizzato come base architetturale di molti sistemi di gestione di eventi.

Versione delle 07:51, 18 set 2017

L'Observer pattern è un design pattern.

È un pattern intuitivamente utilizzato come base architetturale di molti sistemi di gestione di eventi. Molti paradigmi di programmazione legati agli eventi, utilizzati anche quando ancora non era diffusa la programmazione ad oggetti, sono riconducibili a questo pattern. È possibile individuarlo in maniera rudimentale nella programmazione di sistema Windows, o in altri framework di sviluppo che richiedono la gestione di eventi provenienti da diversi oggetti, come ad esempio la funzione "OnMsgProc" per la gestione delle code di messaggi windows.

Sostanzialmente il pattern si basa su uno o più oggetti, chiamati osservatori o observer, che vengono registrati per gestire un evento che potrebbe essere generato dall'oggetto "osservato", che può essere chiamato soggetto.

Oltre all'observer esiste il concrete Observer che si differenzia dal primo perché implementa direttamente le azioni da compiere in risposta ad un messaggio; riepilogando il primo è una classe astratta, il secondo no.

Uno degli aspetti fondamentali è che tutto il funzionamento dell'observer si basa su meccanismi di callback, implementabili in diversi modi, o tramite funzioni virtuali o tramite puntatori a funzioni passati quali argomenti nel momento della registrazione dell'observer, e spesso a questa funzione vengono passati dei parametri in fase di generazione dell'evento.

Attori

In generale il pattern impiega le seguenti classi:

Soggetto

Una classe che fornisce interfacce per registrare o rimuovere gli observer e che implementa le seguenti funzioni:

  • Attach(observer)
  • Detach(observer)
  • Notify()

N.B. La funzione Notify() viene implementata con un loop su tutti i ConcreteObserver, dove ciascuno di essi chiama la funzione Update(). Notify() viene eseguita dal Soggetto Concreto per notificare un cambio del suo stato. (vedi sotto)

Soggetto Concreto

Questa classe contiene l'attributo

  • subjectState

il quale descrive lo stato del soggetto.

Inoltre, essa contiene le funzioni:

  • GetState() - che restituisce lo stato del soggetto.
  • SetState() - che setta lo stato del soggetto.

N.B. Entrambe le funzioni vengono chiamate da ogni ConcreteObserver dopo aver ricevuto un Update()

Questa classe:

  • fornisce lo stato del Soggetto agli observer
  • si occupa di notificare gli observers chiamando la funzione Notify() definita nella classe padre (Soggetto).

Observer

Questa classe definisce un'interfaccia per tutti gli observers, per ricevere le notifiche dal soggetto. È utilizzata come classe astratta per implementare i veri Observer, ossia i ConcreteObserver.

Funzioni:

  • Update() - una funzione astratta che deve essere implementata dai ConcreteObserver.

ConcreteObserver

Questa classe mantiene un riferimento

  • subject

al Soggetto Concreto, per ricevere lo stato quando avviene una notifica.

Alla classe appartiene inoltre l'attributo

  • observerState

il quale contiene lo stato del ConcreteObserver.

Il ConcreteObserver implementa la funzione astratta Update(): quando questa viene chiamata dal Soggetto Concreto, il ConcreteObserver chiama la funzione GetState() sul soggetto concreto per aggiornare il suo nuovo stato. Ciò viene così fatto:

  • observerState = subject->GetState()

L'Observer pattern in C#

In C# tipicamente, il pattern observer è implementato tramite

  • classe Object (classe base che implementa la gestione degli eventi)
  • classe da controllare (Concrete Subject) derivata da Object
  • dichiarazione di Evento (Observer o listener)
  • delegato (puntatore a funzione) che definisce il prototipo della funzione che sarà registrata quale Concrete Observer.

Bibliografia

  • (EN) Erich Gamma, Richard Helm, Ralph Johnson e John Vlissides, Design Patterns: Elements of Reusable Object-Oriented Software, Addison-Wesley, 1995, pp. 293-303, ISBN 0-201-63361-2.

Altri progetti

Template:Design Patterns Patterns