IObservable<T>.Subscribe(IObserver<T>) Methode

Definition

Benachrichtigt den Anbieter, dass ein Beobachter Benachrichtigungen zu empfangen hat.Notifies the provider that an observer is to receive notifications.

public:
 IDisposable ^ Subscribe(IObserver<T> ^ observer);
public IDisposable Subscribe (IObserver<out T> observer);
abstract member Subscribe : IObserver<'T> -> IDisposable
Public Function Subscribe (observer As IObserver(Of Out T)) As IDisposable

Parameter

observer
IObserver<T>

Das Objekt, das Benachrichtigungen zu empfangen hat.The object that is to receive notifications.

Gibt zurück

Ein Verweis auf eine Schnittstelle, über die Beobachter den Empfang von Benachrichtigungen beenden können, bevor der Anbieter deren Versand einstellt.A reference to an interface that allows observers to stop receiving notifications before the provider has finished sending them.

Beispiele

Im folgenden Beispiel wird die Subscribe-Methode für eine Anwendung veranschaulicht, die Informationen zu breiten-und Längengrad meldet.The following example illustrates the Subscribe method for an application that reports latitude and longitude information. Es definiert ein IList<T> Auflistungs Objekt, das Verweise auf alle Beobachter speichert.It defines an IList<T> collection object that stores references to all observers. Außerdem wird eine private Klasse mit dem Namen Unsubscriber zurückgegeben, die die IDisposable-Schnittstelle implementiert und es Abonnenten ermöglicht, den Empfang von Ereignis Benachrichtigungen anzuhaltenIt also returns a private class named Unsubscriber that implements the IDisposable interface and enables subscribers to stop receiving event notifications. Das komplette Beispiel finden Sie im Beispiel Abschnitt des IObservable<T> Themas.See the Example section of the IObservable<T> topic for the complete example.

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);
   }
}
Private observers As List(Of IObserver(Of Location))

Public Function Subscribe(ByVal observer As System.IObserver(Of Location)) As System.IDisposable _
                         Implements System.IObservable(Of Location).Subscribe
   If Not observers.Contains(observer) Then
      observers.Add(observer)
   End If
   Return New Unsubscriber(observers, observer)
End Function

Private Class Unsubscriber : Implements IDisposable
   Private _observers As List(Of IObserver(Of Location))
   Private _observer As IObserver(Of Location)

   Public Sub New(ByVal observers As List(Of IObserver(Of Location)), ByVal observer As IObserver(Of Location))
      Me._observers = observers
      Me._observer = observer
   End Sub

   Public Sub Dispose() Implements IDisposable.Dispose
      If _observer IsNot Nothing AndAlso _observers.Contains(_observer) Then
         _observers.Remove(_observer)
      End If
   End Sub
End Class

Hinweise

Die Subscribe-Methode muss aufgerufen werden, um einen Beobachter für Pushbenachrichtigungen zu registrieren.The Subscribe method must be called to register an observer for push-based notifications. Eine typische Implementierung der Subscribe-Methode führt Folgendes aus:A typical implementation of the Subscribe method does the following:

  • Es speichert einen Verweis auf den Observer in einem Auflistungs Objekt, z. b. ein List<T> Objekt.It stores a reference to the observer in a collection object, such as a List<T> object.

  • Es gibt einen Verweis auf eine IDisposable-Schnittstelle zurück.It returns a reference to an IDisposable interface. Dies ermöglicht es Observer, das Abonnement zu kündigen (d. h., den Empfang von Benachrichtigungen zu beenden), bevor der Anbieter das Senden der Benachrichtigungen abgeschlossen und die OnCompleted Methode des Abonnenten aufgerufen hatThis enables observers to unsubscribe (that is, to stop receiving notifications) before the provider has finished sending them and called the subscriber's OnCompleted method.

Eine bestimmte Instanz einer IObservable<T>-Implementierung ist jeweils für die Verarbeitung aller Abonnements und die Benachrichtigung aller Abonnenten zuständig.At any given time, a particular instance of an IObservable<T> implementation is responsible for handling all subscriptions and notifying all subscribers. Wenn die Dokumentation für eine bestimmte IObservable<T> Implementierung nicht anders anzeigt, sollten Beobachter keine Annahmen über die IObservable<T> Implementierung treffen, wie z. b. die Reihenfolge der Benachrichtigungen, die von mehreren Beobachtern empfangen werden.Unless the documentation for a particular IObservable<T> implementation indicates otherwise, observers should make no assumptions about the IObservable<T> implementation, such as the order of notifications that multiple observers will receive.

Gilt für:

Siehe auch