Observer

Fa parte della sezione Programmazione orientata agli oggetti del percorso Dart di Coddy. Lezione 92 di 110.

Il pattern Observer stabilisce una relazione uno-a-molti tra gli oggetti: quando un oggetto (il soggetto) cambia stato, tutti i suoi dipendenti (osservatori) vengono avvisati automaticamente. È perfetto per scenari come gli aggiornamenti dell'interfaccia utente, i sistemi di eventi o qualsiasi situazione in cui più parti della tua applicazione devono reagire ai cambiamenti.

Lo schema coinvolge due ruoli chiave: un soggetto che mantiene un elenco di osservatori e li informa dei cambiamenti, e degli osservatori che si registrano e reagiscono agli aggiornamenti:

abstract class Observer {
  void update(String message);
}

class NewsAgency {
  final List<Observer> _observers = [];
  String _latestNews = '';

  void subscribe(Observer observer) {
    _observers.add(observer);
  }

  void unsubscribe(Observer observer) {
    _observers.remove(observer);
  }

  void publishNews(String news) {
    _latestNews = news;
    for (var observer in _observers) {
      observer.update(_latestNews);
    }
  }
}

class NewsChannel implements Observer {
  final String name;
  NewsChannel(this.name);

  @override
  void update(String message) {
    print('$name received: $message');
  }
}

void main() {
  var agency = NewsAgency();
  var cnn = NewsChannel('CNN');
  var bbc = NewsChannel('BBC');

  agency.subscribe(cnn);
  agency.subscribe(bbc);

  agency.publishNews('Breaking news!');
  // CNN received: Breaking news!
  // BBC received: Breaking news!
}

Quando viene chiamato publishNews, l'agenzia scorre tutti gli osservatori iscritti e chiama il loro metodo update. Gli osservatori possono iscriversi o annullare l'iscrizione in qualsiasi momento, rendendo il sistema flessibile e debolmente accoppiato: il soggetto non deve conoscere i tipi specifici dei suoi osservatori.

Sfida

Facile

Costruiamo un sistema di avvisi sui prezzi delle azioni usando il pattern Observer! Creerai un sistema in cui un ticker azionario avvisa più investitori ogni volta che il prezzo cambia, consentendo a ciascun investitore di reagire agli aggiornamenti di mercato a modo suo.

Organizzerai il codice in due file:

stock_system.dart: crea qui il tuo sistema di observer:
- Una classe astratta Investor con un metodo void onPriceChange(String stockName, double price)
- Una classe DayTrader che implementa Investor. Ha un campo name e il suo metodo onPriceChange stampa: [name] sees [stockName] at $[price] - Making quick trade!
- Una classe LongTermInvestor che implementa Investor. Ha un campo name e il suo metodo onPriceChange stampa: [name] notes [stockName] at $[price] - Holding steady.
- Una classe StockTicker (il soggetto) con:
  - Un campo String stockName
  - Una lista privata in cui memorizzare gli investitori iscritti
  - Un metodo subscribe(Investor investor) per aggiungere un investitore
  - Un metodo unsubscribe(Investor investor) per rimuovere un investitore
  - Un metodo updatePrice(double newPrice) che notifica tutti gli investitori iscritti del nuovo prezzo
main.dart: importa il tuo sistema azionario e mostra il pattern Observer in azione:
- Crea un StockTicker per un'azione chiamata DART
- Crea un DayTrader chiamato Alice e un LongTermInvestor chiamato Bob
- Iscrivi entrambi gli investitori al ticker
- Aggiorna il prezzo a 150.50 (entrambi gli investitori dovrebbero ricevere una notifica)
- Stampa una riga vuota
- Annulla l'iscrizione di Alice al ticker
- Aggiorna il prezzo a 155.75 (ora solo Bob dovrebbe ricevere una notifica)

Questo dimostra come il pattern Observer crei un sistema debolmente accoppiato: StockTicker non deve sapere se sta notificando day trader o investitori a lungo termine, ma si limita a chiamare onPriceChange su chiunque sia iscritto!

Output previsto:

Alice sees DART at $150.5 - Making quick trade!
Bob notes DART at $150.5 - Holding steady.

Bob notes DART at $155.75 - Holding steady.

Provalo tu

import 'stock_system.dart';

void main() {
  // TODO: Crea uno StockTicker per un titolo chiamato 'DART'
  
  // TODO: Crea un DayTrader chiamato 'Alice'
  
  // TODO: Crea un LongTermInvestor chiamato 'Bob'
  
  // TODO: Iscrivi entrambi gli investitori al ticker
  
  // TODO: Aggiorna il prezzo a 150.50 (entrambi gli investitori devono ricevere una notifica)
  
  // TODO: Stampa una riga vuota
  
  // TODO: Annulla l'iscrizione di Alice al ticker
  
  // TODO: Aggiorna il prezzo a 155.75 (ora solo Bob deve ricevere una notifica)
}