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

Referenz

Definition

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

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

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.

Gibt zurück

IDisposable

Ein Verweis auf eine Schnittstelle, über die Beobachter den Empfang von Benachrichtigungen beenden können, bevor der Anbieter deren Versand einstellt.

Beispiele

Im folgenden Beispiel wird die Methode für eine Anwendung veranschaulicht, die Subscribe Breiten- und Längengradinformationen meldet. Es definiert ein IList<T> Auflistungsobjekt, das Verweise auf alle Beobachter speichert. Es gibt auch eine private Klasse zurück Unsubscriber , die die IDisposable Schnittstelle implementiert und es Abonnenten ermöglicht, den Empfang von Ereignisbenachrichtigungen zu beenden. Siehe den Abschnitt "Beispiel" des IObservable<T> Themas für das vollständige Beispiel.

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

let observers = ResizeArray<IObserver<Location>>()

interface IObservable<Location> with
    member _.Subscribe(observer) =
        if observers.Contains observer |> not then
            observers.Add observer
        new Unsubscriber(observers, 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 Push-basierte Benachrichtigungen zu registrieren. Eine typische Implementierung der Subscribe Methode führt folgendes aus:

Es speichert einen Verweis auf den Beobachter in einem Auflistungsobjekt, z. B. ein List<T> Objekt.
Es gibt einen Verweis auf eine IDisposable Schnittstelle zurück. Dadurch können Sich Beobachter abmelden (d. h. den Empfang von Benachrichtigungen beenden), bevor der Anbieter sie gesendet hat und die Methode des Abonnents OnCompleted aufgerufen hat.

Jederzeit ist eine bestimmte Instanz einer IObservable<T> Implementierung für die Behandlung aller Abonnements verantwortlich und benachrichtigt alle Abonnenten. Sofern die Dokumentation für eine bestimmte IObservable<T> Implementierung andernfalls angibt, sollten Beobachter keine Annahmen über die IObservable<T> Implementierung vornehmen, z. B. die Reihenfolge der Benachrichtigungen, die mehrere Beobachter erhalten werden.

Gilt für

Siehe auch

IObserver<T>