Nota
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare ad accedere o modificare le directory.
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare a modificare le directory.
Il modello di progettazione observer consente a un sottoscrittore di registrarsi e ricevere notifiche da un provider. È adatto per qualsiasi scenario che richiede una notifica basata su push. Il modello definisce un provider (noto anche come oggetto o osservabile) e zero, uno o più osservatori. Gli osservatori si registrano con il provider e ogni volta che si verifica una condizione, un evento o una modifica dello stato predefinita, il provider invia automaticamente una notifica a tutti gli osservatori richiamando un delegato. In questa chiamata al metodo, il provider può anche trasmettere informazioni sullo stato corrente agli osservatori. In .NET, il modello di progettazione osservatore viene applicato implementando le interfacce generiche System.IObservable<T> e System.IObserver<T>. Il parametro di tipo generico rappresenta il tipo che fornisce informazioni di notifica.
Quando applicare il modello
Il modello di progettazione osservatore è adatto per le notifiche basate su push distribuite, perché supporta una separazione pulita tra due componenti o livelli dell'applicazione diversi, ad esempio un livello di origine dati (logica di business) e un livello di interfaccia utente (visualizzazione). Il modello può essere implementato ogni volta che un provider usa callback per fornire ai client informazioni correnti.
L'implementazione del modello richiede di fornire i dettagli seguenti:
Un provider o soggetto, che è l'entità che invia 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, chiamato dagli osservatori che desiderano ricevere notifiche dal provider.
Osservatore, che è un oggetto che riceve notifiche da un provider. Un osservatore è una classe o una struttura che implementa l'interfaccia IObserver<T> . L'osservatore deve implementare tre metodi, 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 terminato l'invio di notifiche.
Meccanismo che consente al provider di tenere traccia degli osservatori. In genere, il provider usa un oggetto contenitore, ad esempio un System.Collections.Generic.List<T> oggetto , per contenere riferimenti alle IObserver<T> implementazioni che hanno sottoscritto le notifiche. L'uso di un contenitore di archiviazione a questo scopo consente al provider di monitorare da zero a un numero illimitato di osservatori. L'ordine in cui gli osservatori ricevono le notifiche non è definito; il provider è libero di utilizzare qualsiasi metodo per determinare l'ordine.
Implementazione IDisposable che consente al provider di rimuovere gli osservatori al termine della notifica. Gli osservatori ricevono un riferimento all'implementazione IDisposable dal Subscribe metodo , quindi possono anche chiamare il metodo per annullare la IDisposable.Dispose sottoscrizione prima che il provider abbia terminato l'invio di notifiche.
Oggetto che contiene i dati inviati dal provider agli osservatori. Il tipo di questo oggetto corrisponde al parametro di tipo generico delle IObservable<T> interfacce e IObserver<T> . Anche se questo oggetto può essere uguale all'implementazione IObservable<T> , in genere si tratta di un tipo separato.
Annotazioni
Oltre a implementare il modello di progettazione osservatore, potresti essere interessato all'esplorazione delle librerie create usando le IObservable<T> interfacce e IObserver<T> . Ad esempio, le estensioni reattive per .NET (Rx) sono costituite da un set di metodi di estensione e da operatori di sequenza standard LINQ per supportare la programmazione asincrona.
Implementare il modello
Nell'esempio seguente viene utilizzato il modello di progettazione osservatore per implementare un sistema informativo di richiesta bagaglio aeroportuale. Una BaggageInfo classe fornisce informazioni sull'arrivo dei voli e sulle caroselle in cui il bagaglio da ogni volo è disponibile per il ritiro. È 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 BaggageHandler classe è responsabile della ricezione di informazioni sui voli in arrivo e sui nastri trasportatori dei bagagli. Internamente, gestisce due raccolte:
-
_observers: Una raccolta di client che osservano le informazioni aggiornate. -
_flights: una raccolta di voli e le loro caroselle assegnate.
Il codice sorgente per la BaggageHandler classe è 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 BaggageHandler.Subscribe metodo . Se il client non ha eseguito la sottoscrizione precedente alle notifiche, alla raccolta viene aggiunto un riferimento all'implementazione IObserver<T> del _observers client.
Il metodo sovraccarico BaggageHandler.BaggageStatus può essere chiamato per indicare che il bagaglio da un volo viene scaricato o non viene più scaricato. Nel primo caso, il metodo viene fornito un numero di volo, l'aeroporto da cui è partito il volo e il nastro trasportatore dove viene scaricato il bagaglio. Nel secondo caso, viene fornito al metodo solo un numero di volo. Per il bagaglio scaricato, il metodo controlla se le BaggageInfo informazioni passate al metodo esistono nella _flights raccolta. In caso contrario, il metodo aggiunge le informazioni e invoca il metodo OnNext di ciascun osservatore. Per i voli il cui bagaglio non viene più scaricato, il metodo controlla se le informazioni sul volo vengono archiviate nella _flights raccolta. In caso affermativo, il metodo chiama il metodo OnNext di ogni osservatore e rimuove l'oggetto BaggageInfo dalla collezione _flights.
Quando l'ultimo volo del giorno è atterrato e il suo bagaglio è stato processato, il metodo BaggageHandler.LastBaggageClaimed viene chiamato. Questo metodo chiama il metodo OnCompleted di ogni osservatore per indicare che tutte le notifiche sono state completate e quindi svuota la raccolta _observers.
Il metodo del Subscribe provider restituisce un'implementazione IDisposable che consente agli osservatori di interrompere la ricezione delle notifiche prima che il metodo OnCompleted venga chiamato. Il codice sorgente per questa Unsubscriber(Of BaggageInfo) classe è illustrato nell'esempio seguente. Quando la classe BaggageHandler.Subscribe viene istanziata nel metodo, viene passato un riferimento alla raccolta _observers e un riferimento all'osservatore che viene aggiunto alla raccolta. Questi riferimenti vengono assegnati alle variabili locali. Quando viene chiamato il metodo dell'oggetto Dispose , verifica se l'osservatore esiste ancora nella _observers raccolta e, in caso affermativo, rimuove l'osservatore.
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
L'esempio seguente fornisce un'implementazione IObserver<T> denominata ArrivalsMonitor, che è una classe di base che visualizza le informazioni di richiesta bagaglio. Le informazioni vengono visualizzate alfabeticamente, in base al nome della città di origine. I metodi di 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 Subscribe metodo consente alla classe di salvare l'implementazione IDisposable restituita dalla chiamata a a Subscribe una variabile privata. Il Unsubscribe metodo consente alla classe di annullare la sottoscrizione alle notifiche chiamando l'implementazione del Dispose provider.
ArrivalsMonitor fornisce anche implementazioni dei OnNextmetodi , OnErrore OnCompleted . Solo l'implementazione OnNext contiene una quantità significativa di codice. Il metodo funziona con un oggetto privato, ordinato e generico List<T> che mantiene informazioni sugli aeroporti di origine dei voli in arrivo e sui nastri trasportatori per bagagli su cui il loro bagaglio è disponibile. Se la classe BaggageHandler segnala un nuovo arrivo di volo, l'implementazione del metodo OnNext aggiunge informazioni su quel volo all'elenco. Se la BaggageHandler classe segnala che il bagaglio del volo è stato scaricato, il metodo rimuove tale OnNext 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 BaggageHandler classe e due istanze della ArrivalsMonitor classe e usa il BaggageHandler.BaggageStatus metodo per aggiungere e rimuovere informazioni sull'arrivo dei voli. In ogni caso, gli osservatori ricevono aggiornamenti e visualizzano correttamente le informazioni sul 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
| Titolo | Descrizione |
|---|---|
| Procedure consigliate per il modello di progettazione observer | Vengono descritte le procedure consigliate da adottare durante lo sviluppo di applicazioni che implementano il modello di progettazione osservatore. |
| Procedura: Implementare un provider | Fornisce un'implementazione dettagliata di un provider per un'applicazione di monitoraggio della temperatura. |
| Procedura: Implementare un osservatore | Fornisce un'implementazione dettagliata di un osservatore per un'applicazione di monitoraggio della temperatura. |
Collabora con noi su GitHub
L'origine di questo contenuto è disponibile in GitHub, in cui è anche possibile creare ed esaminare i problemi e le richieste pull. Per ulteriori informazioni, vedere la guida per i collaboratori.
