IObserver<T> Interfejs

Definicja

Przestrzeń nazw:

System

Zestaw:

System.Runtime.dll

Zestaw:

mscorlib.dll

Zestaw:

netstandard.dll

Zapewnia mechanizm odbierania powiadomień wypychanych.

C#

public interface IObserver<in T>

Parametry typu

T

Obiekt, który dostarcza informacje o powiadomieniach.

Ten parametr typu jest kontrawariantny. Oznacza to, że możesz użyć typu, który został przez Ciebie określony, lub dowolnego typu, który jest mniej pochodny. Aby uzyskać więcej informacji o kowariancji i kontrawariancji, zobacz Kowariancja i kontrawariancja w typach ogólnych.

Pochodne

Microsoft.Extensions.DiagnosticAdapter.DiagnosticSourceAdapter

System.Web.Hosting.LowPhysicalMemoryObserver

System.Web.Hosting.RecycleLimitObserver

Przykłady

Poniższy przykład ilustruje wzorzec projektowania obserwatora. Definiuje klasę zawierającą Location informacje o szerokości geograficznej i długości geograficznej.

C#

public struct Location
{
   double lat, lon;

   public Location(double latitude, double longitude)
   {
      this.lat = latitude;
      this.lon = longitude;
   }

   public double Latitude
   { get { return this.lat; } }

   public double Longitude
   { get { return this.lon; } }
}

Klasa LocationReporter udostępnia implementację IObserver<T> . Wyświetla informacje o bieżącej lokalizacji w konsoli programu . Jego konstruktor zawiera name parametr, który umożliwia wystąpieniu LocationReporter zidentyfikowanie się w danych wyjściowych ciągu. Zawiera również metodę Subscribe , która opakowuje wywołanie metody dostawcy Subscribe . Umożliwia to metodzie przypisanie zwróconego IDisposable odwołania do zmiennej prywatnej. Klasa LocationReporter zawiera również metodę, która wywołuje IDisposable.Dispose metodę Unsubscribe obiektu zwróconego przez metodęIObservable<T>.Subscribe. Poniższy kod definiuje klasę LocationReporter .

C#

using System;

public class LocationReporter : IObserver<Location>
{
   private IDisposable unsubscriber;
   private string instName;

   public LocationReporter(string name)
   {
      this.instName = name;
   }

   public string Name
   {  get{ return this.instName; } }

   public virtual void Subscribe(IObservable<Location> provider)
   {
      if (provider != null)
         unsubscriber = provider.Subscribe(this);
   }

   public virtual void OnCompleted()
   {
      Console.WriteLine("The Location Tracker has completed transmitting data to {0}.", this.Name);
      this.Unsubscribe();
   }

   public virtual void OnError(Exception e)
   {
      Console.WriteLine("{0}: The location cannot be determined.", this.Name);
   }

   public virtual void OnNext(Location value)
   {
      Console.WriteLine("{2}: The current location is {0}, {1}", value.Latitude, value.Longitude, this.Name);
   }

   public virtual void Unsubscribe()
   {
      unsubscriber.Dispose();
   }
}

Klasa LocationTracker udostępnia implementację IObservable<T> . Metoda jest TrackLocation przekazywana obiekt dopuszczający Location wartość null, który zawiera dane szerokości geograficznej i długości geograficznej. Location Jeśli wartość nie nulljest , TrackLocation metoda wywołuje metodę OnNext każdego obserwatora.

C#

public class LocationTracker : IObservable<Location>
{
   public LocationTracker()
   {
      observers = new List<IObserver<Location>>();
   }

   private List<IObserver<Location>> observers;

   public IDisposable Subscribe(IObserver<Location> observer)
   {
      if (! observers.Contains(observer))
         observers.Add(observer);
      return new Unsubscriber(observers, observer);
   }

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

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

      public void Dispose()
      {
         if (_observer != null && _observers.Contains(_observer))
            _observers.Remove(_observer);
      }
   }

   public void TrackLocation(Nullable<Location> loc)
   {
      foreach (var observer in observers) {
         if (! loc.HasValue)
            observer.OnError(new LocationUnknownException());
         else
            observer.OnNext(loc.Value);
      }
   }

   public void EndTransmission()
   {
      foreach (var observer in observers.ToArray())
         if (observers.Contains(observer))
            observer.OnCompleted();

      observers.Clear();
   }
}

Location Jeśli wartość to null, TrackLocation metoda tworzy wystąpienie LocationNotFoundException obiektu, który jest wyświetlany w poniższym przykładzie. Następnie wywołuje metodę każdego obserwatora OnError i przekazuje go do LocationNotFoundException obiektu. Należy pamiętać, że LocationNotFoundException pochodzi z elementu Exception , ale nie dodaje żadnych nowych elementów członkowskich.

C#

public class LocationUnknownException : Exception
{
   internal LocationUnknownException()
   { }
}

Obserwatorzy rejestrują się w celu odbierania powiadomień z TrackLocation obiektu przez wywołanie metody IObservable<T>.Subscribe , która przypisuje odwołanie do obiektu obserwatora do prywatnego obiektu ogólnego List<T> . Metoda zwraca obiekt, który jest implementacją Unsubscriber IDisposable , która umożliwia obserwatorom zatrzymywanie odbierania powiadomień. Klasa LocationTracker zawiera również metodę EndTransmission . Jeśli nie są dostępne żadne dalsze dane lokalizacji, metoda wywołuje metodę każdego obserwatora OnCompleted , a następnie czyści wewnętrzną listę obserwatorów.

Poniższy kod tworzy następnie wystąpienie dostawcy i obserwatora.

C#

using System;

class Program
{
   static void Main(string[] args)
   {
      // Define a provider and two observers.
      LocationTracker provider = new LocationTracker();
      LocationReporter reporter1 = new LocationReporter("FixedGPS");
      reporter1.Subscribe(provider);
      LocationReporter reporter2 = new LocationReporter("MobileGPS");
      reporter2.Subscribe(provider);

      provider.TrackLocation(new Location(47.6456, -122.1312));
      reporter1.Unsubscribe();
      provider.TrackLocation(new Location(47.6677, -122.1199));
      provider.TrackLocation(null);
      provider.EndTransmission();
   }
}
// The example displays output similar to the following:
//      FixedGPS: The current location is 47.6456, -122.1312
//      MobileGPS: The current location is 47.6456, -122.1312
//      MobileGPS: The current location is 47.6677, -122.1199
//      MobileGPS: The location cannot be determined.
//      The Location Tracker has completed transmitting data to MobileGPS.

Uwagi

Interfejsy IObserver<T> i IObservable<T> zapewniają uogólniony mechanizm powiadomień wypychanych, znany również jako wzorzec projektowania obserwatora. Interfejs IObservable<T> reprezentuje klasę, która wysyła powiadomienia (dostawca); IObserver<T> interfejs reprezentuje klasę, która je odbiera (obserwator). T reprezentuje klasę, która dostarcza informacje o powiadomieniach.

Implementacja IObserver<T> umożliwia odbieranie powiadomień od dostawcy ( IObservable<T> implementacji) przez przekazanie wystąpienia samego siebie do metody dostawcy IObservable<T>.Subscribe . Ta metoda zwraca IDisposable obiekt, którego można użyć do anulowania subskrypcji obserwatora przed zakończeniem wysyłania powiadomień przez dostawcę.

Interfejs IObserver<T> definiuje następujące trzy metody, które obserwator musi zaimplementować:

• Metoda OnNext , która jest zwykle wywoływana przez dostawcę w celu dostarczenia obserwatorowi nowych danych lub informacji o stanie.

• Metoda OnError , która jest zwykle wywoływana przez dostawcę, aby wskazać, że dane są niedostępne, niedostępne lub uszkodzone albo że dostawca napotkał inny warunek błędu.

• Metoda OnCompleted , która jest zwykle wywoływana przez dostawcę, aby wskazać, że zakończyła wysyłanie powiadomień do obserwatorów.

Metody

OnCompleted()	Powiadamia obserwatora, że dostawca zakończył wysyłanie powiadomień wypychanych.
OnError(Exception)	Powiadamia obserwatora, że dostawca napotkał warunek błędu.
OnNext(T)	Udostępnia obserwatorowi nowe dane.

Dotyczy

Zobacz też

• IObservable<T>