Wzorzec projektowy obserwatora

Wzorzec projektowy obserwatora umożliwia subskrybentowi zarejestrowanie się i odbieranie powiadomień od dostawcy. Jest odpowiednia w każdym scenariuszu, który wymaga powiadomień wypychanych. Wzorzec definiuje dostawcę (znanego także jako podmiot lub obserwowalny ) oraz zero, co najmniej jednego obserwatora. Obserwatorzy rejestrują się u dostawcy i za każdym razem, gdy wystąpi wstępnie zdefiniowany warunek, zdarzenie lub zmiana stanu, dostawca automatycznie powiadamia wszystkich obserwatorów, wywołując jedną z ich metod. W tym wywołaniu metody dostawca może również udostępnić obserwatorom informacje o bieżącym stanie. Na .NET wzorzec projektowy obserwatora jest stosowany przez implementację interfejsów System.IObservable<T> System.IObserver<T> ogólnych i . Parametr typu ogólnego reprezentuje typ, który dostarcza informacje o powiadomieniach.

Stosowanie wzorca

Wzorzec projektowy obserwatora jest odpowiedni w przypadku rozproszonych powiadomień wypychanych, ponieważ obsługuje czystą separację między dwoma różnymi składnikami lub warstwami aplikacji, takimi jak warstwa źródła danych (logika biznesowa) i warstwa interfejsu użytkownika (ekranu). Wzorzec można zaimplementować za każdym razem, gdy dostawca używa wywołań zwrotnych w celu dostarczania klientom bieżących informacji.

Implementacja wzorca wymaga podania następujących informacji:

  • Dostawca lub podmiot, który jest obiektem, który wysyła powiadomienia do obserwatorów. Dostawca to klasa lub struktura, która implementuje IObservable<T> interfejs. Dostawca musi zaimplementować pojedynczą metodę , wywoływaną przez obserwatorów, którzy IObservable<T>.Subscribe chcą otrzymywać powiadomienia od dostawcy.

  • Obserwator, który jest obiektem, który odbiera powiadomienia od dostawcy. Obserwator to klasa lub struktura, która implementuje IObserver<T> interfejs. Obserwator musi zaimplementować trzy metody, z których wszystkie są wywoływane przez dostawcę:

  • Mechanizm, który umożliwia dostawcy śledzenie obserwatorów. Zazwyczaj dostawca używa obiektu kontenera, takiego jak obiekt , do przechowywania odwołań do implementacji, które System.Collections.Generic.List<T> IObserver<T> subskrybują powiadomienia. Użycie kontenera magazynu w tym celu umożliwia dostawcy obsługę od zera do nieograniczonej liczby obserwatorów. Kolejność, w jakiej obserwatorzy odbierają powiadomienia, nie jest zdefiniowana; Dostawca może użyć dowolnej metody do ustalenia zamówienia.

  • IDisposableImplementacja, która umożliwia dostawcy usuwanie obserwatorów po zakończeniu powiadamiania. Obserwatorzy otrzymują odwołanie do implementacji z metody , dzięki czemu mogą również wywołać metodę anulowania subskrypcji, zanim dostawca IDisposable Subscribe zakończy wysyłanie IDisposable.Dispose powiadomień.

  • Obiekt zawierający dane wysyłane przez dostawcę do obserwatorów. Typ tego obiektu odpowiada parametrowi typu ogólnego IObservable<T> IObserver<T> interfejsów i . Chociaż ten obiekt może być taki sam IObservable<T> jak implementacja, najczęściej jest to oddzielny typ.

Uwaga

Oprócz implementacji wzorca projektowego obserwatora warto eksplorować biblioteki, które są budowy przy użyciu IObservable<T> IObserver<T> interfejsów i . Na przykład rozszerzenia reaktywne dla programu .NET (Rx) składają się z zestawu metod rozszerzeń i standardowych operatorów sekwencji LINQ do obsługi programowania asynchronicznego.

Implementowanie wzorca

W poniższym przykładzie użyto wzorca projektowego obserwatora w celu zaimplementowania systemu informacji o oświadczeniach dotyczących lotniska. Klasa BaggageInfo zawiera informacje o lotach przylotów i karuzelach, w których są dostępne miejsca, w których każdy lot jest dostępny do odbioru. Przedstawiono to w poniższym przykładzie.

using System;
using System.Collections.Generic;

public class BaggageInfo
{
   private int flightNo;
   private string origin;
   private int location;

   internal BaggageInfo(int flight, string from, int carousel)
   {
      this.flightNo = flight;
      this.origin = from;
      this.location = carousel;
   }

   public int FlightNumber {
      get { return this.flightNo; }
   }

   public string From {
      get { return this.origin; }
   }

   public int Carousel {
      get { return this.location; }
   }
}
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

Klasa BaggageHandler jest odpowiedzialna za odbieranie informacji o odbieranych lotach i karuzelach chcień. Wewnętrznie utrzymuje dwie kolekcje:

  • observers — kolekcja klientów, którzy będą otrzymywać zaktualizowane informacje.

  • flights — Kolekcja lotów i przypisanych do nich karuzeli.

Obie kolekcje są reprezentowane przez obiekty List<T> ogólne, które są wystąpieniami w BaggageHandler konstruktorze klasy. Kod źródłowy klasy BaggageHandler został przedstawiony w poniższym przykładzie.

public class BaggageHandler : IObservable<BaggageInfo>
{
   private List<IObserver<BaggageInfo>> observers;
   private List<BaggageInfo> flights;

   public BaggageHandler()
   {
      observers = new List<IObserver<BaggageInfo>>();
      flights = new List<BaggageInfo>();
   }

   public IDisposable Subscribe(IObserver<BaggageInfo> observer)
   {
      // Check whether observer is already registered. If not, add it
      if (! observers.Contains(observer)) {
         observers.Add(observer);
         // Provide observer with existing data.
         foreach (var item in flights)
            observer.OnNext(item);
      }
      return new Unsubscriber<BaggageInfo>(observers, observer);
   }

   // Called to indicate all baggage is now unloaded.
   public void BaggageStatus(int flightNo)
   {
      BaggageStatus(flightNo, String.Empty, 0);
   }

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

      // Carousel is assigned, so add new info object to list.
      if (carousel > 0 && ! flights.Contains(info)) {
         flights.Add(info);
         foreach (var observer in observers)
            observer.OnNext(info);
      }
      else if (carousel == 0) {
         // Baggage claim for flight is done
         var flightsToRemove = new List<BaggageInfo>();
         foreach (var flight in flights) {
            if (info.FlightNumber == flight.FlightNumber) {
               flightsToRemove.Add(flight);
               foreach (var observer in observers)
                  observer.OnNext(info);
            }
         }
         foreach (var flightToRemove in flightsToRemove)
            flights.Remove(flightToRemove);

         flightsToRemove.Clear();
      }
   }

   public void LastBaggageClaimed()
   {
      foreach (var 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

Klienci, którzy chcą otrzymywać zaktualizowane informacje, wywołują BaggageHandler.Subscribe metodę . Jeśli klient nie subskrybował wcześniej powiadomień, odwołanie do implementacji klienta IObserver<T> jest dodawane do observers kolekcji.

Przeciążona metoda może być wywoływana, aby wskazać, że ładunek z lotu jest zwalniany lub nie BaggageHandler.BaggageStatus jest już zwalniany. W pierwszym przypadku do metody jest przekazywany numer lotu, lotnisko, z którego pochodzi lot, oraz karuzela, z której jest zwalniany transfer. W drugim przypadku do metody jest przekazywany tylko numer lotu. W przypadku zwalniania odłogowanego metoda sprawdza, czy informacje przekazane do BaggageInfo metody istnieją w flights kolekcji. Jeśli tak nie jest, metoda dodaje informacje i wywołuje metodę każdego OnNext obserwatora. W przypadku lotów, których skład nie jest już zwalniany, metoda sprawdza, czy informacje dotyczące tego lotu są przechowywane w flights kolekcji. Jeśli tak jest, metoda wywołuje metodę każdego obserwatora i OnNext usuwa BaggageInfo obiekt z flights kolekcji.

Po locie ostatniego dnia i przetworzeniu jego chłoniaka BaggageHandler.LastBaggageClaimed wywoływana jest metoda . Ta metoda wywołuje metodę każdego obserwatora, aby wskazać, że wszystkie OnCompleted powiadomienia zostały zakończone, a następnie wyczyści observers kolekcję.

Metoda dostawcy zwraca implementację, która umożliwia obserwatorom zatrzymanie odbierania powiadomień Subscribe IDisposable przed OnCompleted wywołaną metodą. Kod źródłowy tej klasy Unsubscriber(Of BaggageInfo) przedstawiono w poniższym przykładzie. Gdy klasa jest dawana w metodzie , jest przekazywana do kolekcji i odwołanie do obserwatora BaggageHandler.Subscribe observers dodanego do kolekcji. Te odwołania są przypisywane do zmiennych lokalnych. Gdy wywoływana jest metoda obiektu, sprawdza, czy obserwator nadal istnieje w kolekcji, a jeśli tak, Dispose observers usuwa obserwatora.

internal class Unsubscriber<BaggageInfo> : IDisposable
{
   private List<IObserver<BaggageInfo>> _observers;
   private IObserver<BaggageInfo> _observer;

   internal Unsubscriber(List<IObserver<BaggageInfo>> observers, IObserver<BaggageInfo> observer)
   {
      this._observers = observers;
      this._observer = observer;
   }

   public void Dispose()
   {
      if (_observers.Contains(_observer))
         _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

Poniższy przykład zawiera IObserver<T> implementację o nazwie ArrivalsMonitor , która jest klasą bazową, która wyświetla informacje o oświadczeniach następująco: Informacje są wyświetlane alfabetycznie według nazwy miasta, z którego pochodzi. Metody są oznaczone jako (w języku Visual Basic) lub ArrivalsMonitor (w języku C#), więc wszystkie mogą zostać zastąpione przez overridable virtual klasę pochodną.

using System;
using System.Collections.Generic;

public class ArrivalsMonitor : IObserver<BaggageInfo>
{
   private string name;
   private List<string> flightInfos = new List<string>();
   private IDisposable cancellation;
   private string fmt = "{0,-20} {1,5}  {2, 3}";

   public ArrivalsMonitor(string name)
   {
      if (String.IsNullOrEmpty(name))
         throw new ArgumentNullException("The observer must be assigned a name.");

      this.name = name;
   }

   public virtual void Subscribe(BaggageHandler provider)
   {
      cancellation = provider.Subscribe(this);
   }

   public virtual void Unsubscribe()
   {
      cancellation.Dispose();
      flightInfos.Clear();
   }

   public virtual void OnCompleted()
   {
      flightInfos.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 == 0) {
         var flightsToRemove = new List<string>();
         string flightNo = String.Format("{0,5}", info.FlightNumber);

         foreach (var flightInfo in flightInfos) {
            if (flightInfo.Substring(21, 5).Equals(flightNo)) {
               flightsToRemove.Add(flightInfo);
               updated = true;
            }
         }
         foreach (var flightToRemove in flightsToRemove)
            flightInfos.Remove(flightToRemove);

         flightsToRemove.Clear();
      }
      else {
         // Add flight if it does not exist in the collection.
         string flightInfo = String.Format(fmt, info.From, info.FlightNumber, info.Carousel);
         if (! flightInfos.Contains(flightInfo)) {
            flightInfos.Add(flightInfo);
            updated = true;
         }
      }
      if (updated) {
         flightInfos.Sort();
         Console.WriteLine("Arrivals information from {0}", this.name);
         foreach (var flightInfo in flightInfos)
            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

Klasa ArrivalsMonitor zawiera metody i Subscribe Unsubscribe . Metoda Subscribe umożliwia klasie zapisanie implementacji zwróconej przez IDisposable wywołanie do zmiennej Subscribe prywatnej. Metoda Unsubscribe umożliwia klasie anulowanie subskrypcji powiadomień przez wywołanie implementacji Dispose dostawcy. ArrivalsMonitor Udostępnia również implementacje OnNext metod , i OnError OnCompleted . Tylko OnNext implementacja zawiera znaczną ilość kodu. Metoda współpracuje z prywatnym, sortowanym obiektem ogólnym, który przechowuje informacje o lotniskach pochodzenia dla lotów dolotowych i karuzelach, na których są List<T> dostępne ich zdjęcia. Jeśli klasa zgłasza nowy przylot, implementacja metody dodaje informacje o tym BaggageHandler OnNext locie do listy. Jeśli klasa zgłasza, że lot został zwolniony, metoda BaggageHandler usuwa ten lot z OnNext listy. Przy każdej zmianie lista jest sortowana i wyświetlana w konsoli.

Poniższy przykład zawiera punkt wejścia aplikacji, który instancji klasy, a także dwa wystąpienia klasy, i używa metody w celu dodania i usunięcia informacji o BaggageHandler ArrivalsMonitor olatujących BaggageHandler.BaggageStatus lotach. W każdym przypadku obserwatorzy odbierają aktualizacje i poprawnie wyświetlają informacje o oświadczeniach poszczególnych osób.

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      BaggageHandler provider = new BaggageHandler();
      ArrivalsMonitor observer1 = new ArrivalsMonitor("BaggageClaimMonitor1");
      ArrivalsMonitor observer2 = 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();
   }
}
// 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
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
Tytuł Opis
Wzorzec projektowy obserwatora — Najlepsze praktyki Opisuje najlepsze rozwiązania do zastosowania podczas opracowywania aplikacji, które implementują wzorzec projektowy obserwatora.
How to: Implement a Provider Zawiera implementację dostawcy krok po kroku dla aplikacji do monitorowania temperatury.
Jak zaimplementować obserwatora Zapewnia implementację obserwatora krok po kroku dla aplikacji do monitorowania temperatury.