Modello di progettazione observer
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:
- IObserver<T>.OnNext, che fornisce all'osservatore informazioni nuove o correnti.
- IObserver<T>.OnError, che informa l'osservatore che si è verificato un errore.
- IObserver<T>.OnCompleted, che indica che il provider ha completato l'invio di notifiche.
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);
Public Class BaggageInfo
Private flightNo As Integer
Private origin As String
Private location As Integer
Friend Sub New(ByVal flight As Integer, ByVal from As String, ByVal carousel As Integer)
Me.flightNo = flight
Me.origin = from
Me.location = carousel
End Sub
Public ReadOnly Property FlightNumber As Integer
Get
Return Me.flightNo
End Get
End Property
Public ReadOnly Property From As String
Get
Return Me.origin
End Get
End Property
Public ReadOnly Property Carousel As Integer
Get
Return Me.location
End Get
End Property
End Class
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();
}
}
Public Class BaggageHandler : Implements IObservable(Of BaggageInfo)
Private observers As List(Of IObserver(Of BaggageInfo))
Private flights As List(Of BaggageInfo)
Public Sub New()
observers = New List(Of IObserver(Of BaggageInfo))
flights = New List(Of BaggageInfo)
End Sub
Public Function Subscribe(ByVal observer As IObserver(Of BaggageInfo)) As IDisposable _
Implements IObservable(Of BaggageInfo).Subscribe
' Check whether observer is already registered. If not, add it
If Not observers.Contains(observer) Then
observers.Add(observer)
' Provide observer with existing data.
For Each item In flights
observer.OnNext(item)
Next
End If
Return New Unsubscriber(Of BaggageInfo)(observers, observer)
End Function
' Called to indicate all baggage is now unloaded.
Public Sub BaggageStatus(ByVal flightNo As Integer)
BaggageStatus(flightNo, String.Empty, 0)
End Sub
Public Sub BaggageStatus(ByVal flightNo As Integer, ByVal from As String, ByVal carousel As Integer)
Dim info As New BaggageInfo(flightNo, from, carousel)
' Carousel is assigned, so add new info object to list.
If carousel > 0 And Not flights.Contains(info) Then
flights.Add(info)
For Each observer In observers
observer.OnNext(info)
Next
ElseIf carousel = 0 Then
' Baggage claim for flight is done
Dim flightsToRemove As New List(Of BaggageInfo)
For Each flight In flights
If info.FlightNumber = flight.FlightNumber Then
flightsToRemove.Add(flight)
For Each observer In observers
observer.OnNext(info)
Next
End If
Next
For Each flightToRemove In flightsToRemove
flights.Remove(flightToRemove)
Next
flightsToRemove.Clear()
End If
End Sub
Public Sub LastBaggageClaimed()
For Each observer In observers
observer.OnCompleted()
Next
observers.Clear()
End Sub
End Class
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);
}
Friend Class Unsubscriber(Of BaggageInfo) : Implements IDisposable
Private _observers As List(Of IObserver(Of BaggageInfo))
Private _observer As IObserver(Of BaggageInfo)
Friend Sub New(ByVal observers As List(Of IObserver(Of BaggageInfo)), ByVal observer As IObserver(Of BaggageInfo))
Me._observers = observers
Me._observer = observer
End Sub
Public Sub Dispose() Implements IDisposable.Dispose
If _observers.Contains(_observer) Then
_observers.Remove(_observer)
End If
End Sub
End Class
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();
}
}
}
Public Class ArrivalsMonitor : Implements IObserver(Of BaggageInfo)
Private name As String
Private flightInfos As New List(Of String)
Private cancellation As IDisposable
Private fmt As String = "{0,-20} {1,5} {2, 3}"
Public Sub New(ByVal name As String)
If String.IsNullOrEmpty(name) Then Throw New ArgumentNullException("The observer must be assigned a name.")
Me.name = name
End Sub
Public Overridable Sub Subscribe(ByVal provider As BaggageHandler)
cancellation = provider.Subscribe(Me)
End Sub
Public Overridable Sub Unsubscribe()
cancellation.Dispose()
flightInfos.Clear()
End Sub
Public Overridable Sub OnCompleted() Implements System.IObserver(Of BaggageInfo).OnCompleted
flightInfos.Clear()
End Sub
' No implementation needed: Method is not called by the BaggageHandler class.
Public Overridable Sub OnError(ByVal e As System.Exception) Implements System.IObserver(Of BaggageInfo).OnError
' No implementation.
End Sub
' Update information.
Public Overridable Sub OnNext(ByVal info As BaggageInfo) Implements System.IObserver(Of BaggageInfo).OnNext
Dim updated As Boolean = False
' Flight has unloaded its baggage; remove from the monitor.
If info.Carousel = 0 Then
Dim flightsToRemove As New List(Of String)
Dim flightNo As String = String.Format("{0,5}", info.FlightNumber)
For Each flightInfo In flightInfos
If flightInfo.Substring(21, 5).Equals(flightNo) Then
flightsToRemove.Add(flightInfo)
updated = True
End If
Next
For Each flightToRemove In flightsToRemove
flightInfos.Remove(flightToRemove)
Next
flightsToRemove.Clear()
Else
' Add flight if it does not exist in the collection.
Dim flightInfo As String = String.Format(fmt, info.From, info.FlightNumber, info.Carousel)
If Not flightInfos.Contains(flightInfo) Then
flightInfos.Add(flightInfo)
updated = True
End If
End If
If updated Then
flightInfos.Sort()
Console.WriteLine("Arrivals information from {0}", Me.name)
For Each flightInfo In flightInfos
Console.WriteLine(flightInfo)
Next
Console.WriteLine()
End If
End Sub
End Class
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
Module Example
Public Sub Main()
Dim provider As New BaggageHandler()
Dim observer1 As New ArrivalsMonitor("BaggageClaimMonitor1")
Dim observer2 As New ArrivalsMonitor("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()
End Sub
End Module
' The example displays the following 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
Articoli correlati
| 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. |
Commenti e suggerimenti
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedere https://aka.ms/ContentUserFeedback.
Invia e visualizza il feedback per