Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

IObservable<T>-Schnittstelle

.NET Framework (current version)
 

Veröffentlicht: Oktober 2016

Definiert einen Anbieter für Pushbenachrichtigungen.

Namespace:   System
Assembly:  mscorlib (in mscorlib.dll)

public interface IObservable<out T>

Typparameter

outT

Das Objekt, das Benachrichtigungsinformationen bereitstellt.

NameBeschreibung
System_CAPS_pubmethodSubscribe(IObserver<T>)

Benachrichtigt den Anbieter, dass ein Beobachter Benachrichtigungen zu empfangen hat.

Die IObserver<T> und IObservable<T> Schnittstellen bieten einen allgemeinen Mechanismus für Pushbenachrichtigungen, auch bekannt als das Beobachterentwurfsmuster. Die IObservable<T> -Schnittstelle stellt die Klasse, die Benachrichtigungen (Provider), sendet der IObserver<T> -Schnittstelle stellt die Klasse, die sie empfängt (der Beobachter). T Stellt die Klasse, die die Benachrichtigungsinformationen bereitstellt. In einigen Pushbenachrichtigungen der IObserver<T> Implementierung und T können denselben Typ darstellen.

Der Anbieter muss eine einzelne Methode implementieren Subscribe, das angibt, dass ein Beobachter Pushbenachrichtigungen empfangen möchte. Aufrufer der Methode übergeben Sie eine Instanz des Beobachters. Die Methode gibt ein IDisposable Implementierung, mit der Beobachter Benachrichtigungen vor der Anbieter beendet wurde, senden sie jederzeit abbrechen kann.

Zu jedem Zeitpunkt möglicherweise ein bestimmter Anbieter keinen, einen oder mehrere Beobachter. Der Anbieter ist verantwortlich für das Speichern von Verweise auf Beobachter und sicherstellen, dass sie gültig sind, bevor Benachrichtigungen gesendet. Die IObservable<T> Schnittstelle wird keine Annahmen über die Anzahl der Beobachter oder die Reihenfolge, in denen Benachrichtigungen gesendet werden.

Der Anbieter sendet die folgenden drei Arten von Benachrichtigungen an den Beobachter durch Aufrufen von IObserver<T> Methoden:

  • Die aktuellen Daten. Der Anbieter kann die IObserver<T>.OnNext Methode, um den Beobachter übergeben ein T -Objekt, das aktuelle Daten, geänderte Daten oder neue Daten enthält.

  • Ein Fehlerzustand. Der Anbieter kann die IObserver<T>.OnError -Methode den Beobachter benachrichtigt, die einen Fehlerzustand aufgetreten ist.

  • Keine weiteren Daten. Der Anbieter kann die IObserver<T>.OnCompleted -Methode dem Beobachter benachrichtigt, dass das Senden von Benachrichtigungen abgeschlossen hat.

Im folgende Beispiel wird das Beobachterentwurfsmuster veranschaulicht. Definiert eine Location Klasse, die Breiten- und Längengrad Informationen enthält.

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; } }
}

Die LocationTracker -Klasse stellt die IObservable<T> Implementierung. Die TrackLocation -Methode eine NULL-Werte zu übergeben Location -Objekt, das die Breiten- und Längengrad Daten enthält. Wenn der Location Wert ist nicht null, wird die TrackLocation -Methode ruft die OnNext -Methode jedes Beobachters.

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();
   }
}

Wenn die Location Wert null, wird die TrackLocation -Methode instanziiert ein LocationUnknownException -Objekt, das im folgenden Beispiel gezeigt wird. Es ruft dann jedes Beobachters OnError Methode und übergibt die LocationUnknownException Objekt. Beachten Sie, dass LocationUnknownException ableitet, Exception, aber keine neuen Member hinzufügt.

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

Beobachter registrieren sich zum Empfangen von Benachrichtigungen aus einer TrackLocation -Objekt durch Aufrufen der IObservable<T>.Subscribe -Methode, die einen Verweis auf das Observer-Objekt auf einen privaten generischen weist List<T> Objekt. Die Methode gibt ein Unsubscriber Objekt, das eine IDisposable -Implementierung, die Beobachter den Empfang von Benachrichtigungen beenden kann. Die LocationTracker -Klasse enthält zudem eine EndTransmission Methode. Wenn keine weiteren Positionsdaten verfügbar ist, ruft die-Methode jedes Beobachters OnCompleted Methode und löscht dann die interne Liste der Beobachter.

In diesem Beispiel die LocationReporter -Klasse stellt die IObserver<T> Implementierung. Es zeigt Informationen zu den aktuellen Speicherort in der Konsole. Der Konstruktor schließt einen name Parameter, wodurch die LocationReporter -Instanz, die sich in der Zeichenfolgenausgabe selbst identifiziert. Außerdem umfasst es eine Subscribe -Methode, die einen Aufruf an des Anbieters umschließt Subscribe Methode. Dadurch wird die Methode, die das zurückgegebene zuweisen IDisposable Verweis auf eine private Variable. Die LocationReporter -Klasse enthält zudem ein Unsubscribe aufruft der IDisposable.Dispose -Methode des Objekts, die von zurückgegeben wird die IObservable<T>.Subscribe Methode. Der folgende Code definiert die LocationReporter Klasse.

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();
   }
}

Dann instanziiert der folgende Code, der Anbieter und der Beobachter.

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.

Universelle Windows-Plattform
Verfügbar seit 8
.NET Framework
Verfügbar seit 4.0
Portierbare Klassenbibliothek
Unterstützt in: portierbare .NET-Plattformen
Windows Phone Silverlight
Verfügbar seit 7.0
Windows Phone
Verfügbar seit 8.1
Zurück zum Anfang
Anzeigen: