Leggi in inglese

Condividi tramite

Modello di progettazione observer

  • Articolo

Lo schema progettuale osservatore consente a un sottoscrittore di effettuare la registrazione con e ricevere notifiche da un provider. È appropriato per qualsiasi scenario che richieda la notifica basata su push. Lo schema definisce un provider (anche noto come oggetto o osservabile) e zero, uno o più osservatori. Gli osservatori effettuano la registrazione con il provider e ogni volta che si verifica una condizione, un evento o un cambiamento di stato predefinito, il provider invia automaticamente una notifica a tutti gli osservatori richiamando un delegato. In questa chiamata al metodo, il provider può anche fornire informazioni sullo stato corrente degli osservatori. In .NET, lo schema progettuale osservatore viene applicato implementando le interfacce generiche System.IObservable<T> e System.IObserver<T>. Il parametro di tipo generico rappresenta il tipo che fornisce le informazioni di notifica.

Quando applicare il modello

Lo schema progettuale osservatore è appropriato per le notifiche distribuite basate su push, poiché supporta una netta separazione tra due diversi componenti o livelli dell'applicazione, ad esempio un livello di origine dati (logica di business) e un livello di interfaccia utente (visualizzazione). Lo schema può essere implementato ogni volta che un provider usa callback per fornire ai client informazioni aggiornate.

Per implementare lo schema è necessario fornire i dettagli seguenti:

  • Un provider o oggetto, che corrisponde all'oggetto che invia le notifiche agli osservatori. Un provider è una classe o una struttura che implementa l'interfaccia IObservable<T>. Il provider deve implementare un singolo metodo, IObservable<T>.Subscribe, che viene chiamato dagli osservatori che desiderano ricevere notifiche dal provider.

  • Un osservatore, che è un oggetto che riceve le notifiche da un provider. Un osservatore è una classe o una struttura che implementa l'interfaccia IObserver<T>. L'osservatore deve implementare tre metodi, che vengono tutti chiamati dal provider:

  • Un meccanismo che consenta al provider di tenere traccia degli osservatori. In genere, il provider usa un oggetto contenitore, ad esempio un oggetto System.Collections.Generic.List<T>, per contenere i riferimenti alle implementazioni di IObserver<T> che hanno sottoscritto le notifiche. Usando un contenitore di archiviazione a questo scopo, si consente al provider di gestire da zero a un numero illimitato di osservatori. L'ordine in cui gli osservatori ricevono le notifiche non è definito. Il provider può usare qualsiasi metodo per determinare l'ordine.

  • Un'implementazione di IDisposable che consenta al provider di rimuovere gli osservatori quando la notifica è completa. Gli osservatori ricevono un riferimento all'implementazione di IDisposable dal metodo Subscribe, pertanto possono anche chiamare il metodo IDisposable.Dispose per annullare la sottoscrizione prima che il provider abbia completato l'invio di notifiche.

  • Un oggetto contenente i dati che il provider invia agli osservatori. Il tipo di questo oggetto corrisponde al parametro di tipo generico delle interfacce IObservable<T> e IObserver<T>. Sebbene questo oggetto possa essere lo stesso dell'implementazione di IObservable<T>, in genere è un tipo distinto.

Nota

Oltre all'implementazione dello schema progettuale osservatore, potrebbe risultare interessante l'esplorazione delle librerie compilate usando le interfacce IObservable<T> e IObserver<T>. Ad esempio, le estensioni Rx (Reactive Extensions) per .NET sono costituite da un set di metodi di estensione e da operatori di sequenza standard LINQ per supportare la programmazione asincrona.

Implementare il criterio

Nell'esempio seguente, lo schema progettuale osservatore viene usato per implementare un sistema di informazioni per il ritiro dei bagagli in aeroporto. Una classe BaggageInfo fornisce informazioni sui voli in arrivo e sui nastri in cui possono essere ritirati i bagagli per ogni volo, È illustrato nell'esempio seguente.

namespace Observables.Example;

public readonly record struct BaggageInfo(
    int FlightNumber,
    string From,
    int Carousel);

Una classe BaggageHandler è responsabile della ricezione di informazioni sui voli in arrivo e sui nastri per il ritiro dei bagagli. Internamente, gestisce due raccolte:

  • _observers: una raccolta di client che osservano le informazioni aggiornate.
  • _flights: una raccolta di voli e dei nastri ad essi assegnati.

Il codice sorgente per la classe BaggageHandler è illustrato nell'esempio seguente.

namespace Observables.Example;

public sealed class BaggageHandler : IObservable<BaggageInfo>
{
    private readonly HashSet<IObserver<BaggageInfo>> _observers = new();
    private readonly HashSet<BaggageInfo> _flights = new();

    public IDisposable Subscribe(IObserver<BaggageInfo> observer)
    {
        // Check whether observer is already registered. If not, add it.
        if (_observers.Add(observer))
        {
            // Provide observer with existing data.
            foreach (BaggageInfo item in _flights)
            {
                observer.OnNext(item);
            }
        }

        return new Unsubscriber<BaggageInfo>(_observers, observer);
    }

    // Called to indicate all baggage is now unloaded.
    public void BaggageStatus(int flightNumber) =>
        BaggageStatus(flightNumber, string.Empty, 0);

    public void BaggageStatus(int flightNumber, string from, int carousel)
    {
        var info = new BaggageInfo(flightNumber, from, carousel);

        // Carousel is assigned, so add new info object to list.
        if (carousel > 0 && _flights.Add(info))
        {
            foreach (IObserver<BaggageInfo> observer in _observers)
            {
                observer.OnNext(info);
            }
        }
        else if (carousel is 0)
        {
            // Baggage claim for flight is done.
            if (_flights.RemoveWhere(
                flight => flight.FlightNumber == info.FlightNumber) > 0)
            {
                foreach (IObserver<BaggageInfo> observer in _observers)
                {
                    observer.OnNext(info);
                }
            }
        }
    }

    public void LastBaggageClaimed()
    {
        foreach (IObserver<BaggageInfo> observer in _observers)
        {
            observer.OnCompleted();
        }

        _observers.Clear();
    }
}

I client che desiderano ricevere informazioni aggiornate chiamano il metodo BaggageHandler.Subscribe. Se il client in precedenza non ha sottoscritto le notifiche, un riferimento all'implementazione di IObserver<T> del client viene aggiunto alla raccolta _observers.

Il metodo di overload BaggageHandler.BaggageStatus può essere chiamato per indicare che i bagagli di un volo stanno per essere scaricati o che lo scaricamento è terminato. Nel primo caso, al metodo vengono passati un numero di volo, l'aeroporto di provenienza e il nastro in cui vengono scaricati i bagagli. Nel secondo caso, al metodo viene passato solo un numero di volo. Per i bagagli scaricati, il metodo verifica se le informazioni di BaggageInfo passate al metodo sono presenti nella raccolta _flights. In caso contrario, il metodo aggiunge le informazioni e chiama il metodo OnNext di ogni osservatore. Per i voli per cui è terminato lo scaricamento dei bagagli, il metodo controlla se le informazioni su tale volo sono archiviate nella raccolta _flights. In caso affermativo, il metodo chiama il metodo OnNext di ogni osservatore e rimuove l'oggetto BaggageInfo dalla raccolta _flights.

Quando l'ultimo volo del giorno è atterrato e i relativi bagagli sono stati gestiti, viene chiamato il metodo BaggageHandler.LastBaggageClaimed. Questo metodo chiama il metodo OnCompleted di ogni osservatore per indicare che tutte le notifiche sono state completate, quindi cancella la raccolta _observers.

Il metodo Subscribe del provider restituisce un'implementazione di IDisposable che consente agli osservatori di interrompere la ricezione delle notifiche prima che venga chiamato il metodo OnCompleted. Il codice sorgente per la classe Unsubscriber(Of BaggageInfo) è illustrato nell'esempio seguente. Quando viene creata un'istanza della classe nel metodo BaggageHandler.Subscribe, viene passato un riferimento alla raccolta _observers e un riferimento all'osservatore che viene aggiunto alla raccolta. Questi riferimenti sono assegnati a variabili locali. Quando il metodo Dispose dell'oggetto viene chiamato, controlla se l'osservatore è ancora presente nella raccolta _observers e, in caso affermativo, lo rimuove.

namespace Observables.Example;

internal sealed class Unsubscriber<BaggageInfo> : IDisposable
{
    private readonly ISet<IObserver<BaggageInfo>> _observers;
    private readonly IObserver<BaggageInfo> _observer;

    internal Unsubscriber(
        ISet<IObserver<BaggageInfo>> observers,
        IObserver<BaggageInfo> observer) => (_observers, _observer) = (observers, observer);

    public void Dispose() => _observers.Remove(_observer);
}

Nell'esempio seguente viene fornita un'implementazione di IObserver<T> denominata ArrivalsMonitor, una classe base che fornisce informazioni relative al ritiro dei bagagli. Le informazioni vengono visualizzate in ordine alfabetico, in base al nome della città di provenienza. I metodi ArrivalsMonitor sono contrassegnati come overridable (in Visual Basic) o virtual (in C#), in modo che possano essere sottoposti a override in una classe derivata.

namespace Observables.Example;

public class ArrivalsMonitor : IObserver<BaggageInfo>
{
    private readonly string _name;
    private readonly List<string> _flights = new();
    private readonly string _format = "{0,-20} {1,5}  {2, 3}";
    private IDisposable? _cancellation;    

    public ArrivalsMonitor(string name)
    {
        ArgumentException.ThrowIfNullOrEmpty(name);
        _name = name;
    }

    public virtual void Subscribe(BaggageHandler provider) =>
        _cancellation = provider.Subscribe(this);

    public virtual void Unsubscribe()
    {
        _cancellation?.Dispose();
        _flights.Clear();
    }

    public virtual void OnCompleted() => _flights.Clear();

    // No implementation needed: Method is not called by the BaggageHandler class.
    public virtual void OnError(Exception e)
    {
        // No implementation.
    }

    // Update information.
    public virtual void OnNext(BaggageInfo info)
    {
        bool updated = false;

        // Flight has unloaded its baggage; remove from the monitor.
        if (info.Carousel is 0)
        {
            string flightNumber = string.Format("{0,5}", info.FlightNumber);
            for (int index = _flights.Count - 1; index >= 0; index--)
            {
                string flightInfo = _flights[index];
                if (flightInfo.Substring(21, 5).Equals(flightNumber))
                {
                    updated = true;
                    _flights.RemoveAt(index);
                }
            }
        }
        else
        {
            // Add flight if it doesn't exist in the collection.
            string flightInfo = string.Format(_format, info.From, info.FlightNumber, info.Carousel);
            if (_flights.Contains(flightInfo) is false)
            {
                _flights.Add(flightInfo);
                updated = true;
            }
        }

        if (updated)
        {
            _flights.Sort();
            Console.WriteLine($"Arrivals information from {_name}");
            foreach (string flightInfo in _flights)
            {
                Console.WriteLine(flightInfo);
            }

            Console.WriteLine();
        }
    }
}

La classe ArrivalsMonitor include i metodi Subscribe e Unsubscribe. Il metodo Subscribe consente alla classe di salvare l'implementazione di IDisposable restituita dalla chiamata a Subscribe in una variabile privata. Il metodo Unsubscribe consente alla classe di annullare la sottoscrizione delle notifiche chiamando l'implementazione di Dispose del provider. ArrivalsMonitor fornisce anche le implementazioni dei metodi OnNext, OnError e OnCompleted. Solo l'implementazione di OnNext contiene una quantità significativa di codice. Il metodo opera con un oggetto List<T> privato, ordinato e generico che gestisce le informazioni sugli aeroporti di origine per i voli in arrivo e sui nastri su cui sono disponibili i bagagli. Se la classe BaggageHandler segnala un nuovo volo in arrivo, l'implementazione del metodo OnNext aggiunge le informazioni relative al volo all'elenco. Se la classe BaggageHandler segnala che i bagagli del volo sono stati scaricati, il metodo OnNext rimuove il volo dall'elenco. Ogni volta che viene apportata una modifica, l'elenco viene ordinato e visualizzato nella console.

L'esempio seguente contiene il punto di ingresso dell'applicazione che crea un'istanza della classe BaggageHandler e due istanze della classe ArrivalsMonitor e usa il metodo BaggageHandler.BaggageStatus per aggiungere e rimuovere informazioni sui voli in arrivo. In ognuno dei casi, gli osservatori ricevono gli aggiornamenti e visualizzano correttamente le informazioni relative al ritiro dei bagagli.

using Observables.Example;

BaggageHandler provider = new();
ArrivalsMonitor observer1 = new("BaggageClaimMonitor1");
ArrivalsMonitor observer2 = new("SecurityExit");

provider.BaggageStatus(712, "Detroit", 3);
observer1.Subscribe(provider);

provider.BaggageStatus(712, "Kalamazoo", 3);
provider.BaggageStatus(400, "New York-Kennedy", 1);
provider.BaggageStatus(712, "Detroit", 3);
observer2.Subscribe(provider);

provider.BaggageStatus(511, "San Francisco", 2);
provider.BaggageStatus(712);
observer2.Unsubscribe();

provider.BaggageStatus(400);
provider.LastBaggageClaimed();

// Sample output:
//   Arrivals information from BaggageClaimMonitor1
//   Detroit                712    3
//   
//   Arrivals information from BaggageClaimMonitor1
//   Detroit                712    3
//   Kalamazoo              712    3
//   
//   Arrivals information from BaggageClaimMonitor1
//   Detroit                712    3
//   Kalamazoo              712    3
//   New York-Kennedy       400    1
//   
//   Arrivals information from SecurityExit
//   Detroit                712    3
//   
//   Arrivals information from SecurityExit
//   Detroit                712    3
//   Kalamazoo              712    3
//   
//   Arrivals information from SecurityExit
//   Detroit                712    3
//   Kalamazoo              712    3
//   New York-Kennedy       400    1
//   
//   Arrivals information from BaggageClaimMonitor1
//   Detroit                712    3
//   Kalamazoo              712    3
//   New York-Kennedy       400    1
//   San Francisco          511    2
//   
//   Arrivals information from SecurityExit
//   Detroit                712    3
//   Kalamazoo              712    3
//   New York-Kennedy       400    1
//   San Francisco          511    2
//   
//   Arrivals information from BaggageClaimMonitor1
//   New York-Kennedy       400    1
//   San Francisco          511    2
//   
//   Arrivals information from SecurityExit
//   New York-Kennedy       400    1
//   San Francisco          511    2
//   
//   Arrivals information from BaggageClaimMonitor1
//   San Francisco          511    2
Posizione Descrizione
Procedure consigliate per un modello di progettazione observer Descrive le procedure consigliate per lo sviluppo di applicazioni che implementano lo schema progettuale observer.
Procedura: Implementare un provider Fornisce un'implementazione dettagliata di un provider per un'applicazione di monitoraggio della temperatura.
Procedura: Implementare un elemento Observer Fornisce un'implementazione dettagliata di un osservatore per un'applicazione di monitoraggio della temperatura.