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

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

IDisposable

Odwołanie do interfejsu, który umożliwia obserwatorom zaprzestanie odbierania powiadomień przed zakończeniem ich wysyłania przez dostawcę.

Poniższy przykład ilustruje metodę Subscribe aplikacji, która zgłasza informacje o szerokości geograficznej i długości geograficznej. Definiuje IList<T> obiekt kolekcji, który przechowuje odwołania do wszystkich obserwatorów. Zwraca również klasę prywatną o nazwie Unsubscriber , która implementuje IDisposable interfejs i umożliwia subskrybentom zaprzestanie odbierania powiadomień o zdarzeniach. Zobacz sekcję Przykład tematu, IObservable<T> aby zapoznać się z kompletnym przykładem.

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

Metoda Subscribe musi zostać wywołana w celu zarejestrowania obserwatora na potrzeby powiadomień wypychanych. Typowa implementacja Subscribe metody wykonuje następujące czynności:

• Przechowuje odwołanie do obserwatora w obiekcie kolekcji, takim jak List<T> obiekt.

• Zwraca odwołanie do interfejsu IDisposable . Dzięki temu obserwatorzy mogą anulować subskrypcję (czyli przestać otrzymywać powiadomienia) przed zakończeniem wysyłania ich przez dostawcę i wywołaniu metody subskrybenta OnCompleted .

W dowolnym momencie określone wystąpienie implementacji IObservable<T> jest odpowiedzialne za obsługę wszystkich subskrypcji i powiadamianie wszystkich subskrybentów. O ile dokumentacja dla określonej IObservable<T> implementacji nie wskazuje inaczej, obserwatorzy nie powinni przyjmować żadnych założeń dotyczących IObservable<T> implementacji, takich jak kolejność powiadomień otrzymywanych przez wielu obserwatorów.

• IObserver<T>