IObservable<T>.Subscribe(IObserver<T>) Méthode

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

Paramètres

Retours

IDisposable

Référence à une interface qui permet aux observateurs de cesser de recevoir des notifications avant que le fournisseur ait fini de les envoyer.

Exemples

L’exemple suivant illustre la Subscribe méthode d’une application qui signale les informations de latitude et de longitude. Il définit un IList<T> objet de collection qui stocke les références à tous les observateurs. Elle retourne également une classe privée nommée Unsubscriber qui implémente l’interface IDisposable et permet aux abonnés d’arrêter de recevoir des notifications d’événements. Consultez la section Exemple de la IObservable<T> rubrique pour l’exemple complet.

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

Remarques

La Subscribe méthode doit être appelée pour inscrire un observateur pour les notifications push. Une implémentation classique de la Subscribe méthode effectue les opérations suivantes :

• Il stocke une référence à l’observateur dans un objet de collection, tel qu’un List<T> objet.

• Elle retourne une référence à une IDisposable interface. Cela permet aux observateurs de se désabonner (autrement dit, d’arrêter de recevoir des notifications) avant que le fournisseur ne les ait envoyés et appelé la méthode de l’abonné OnCompleted .

À tout moment, une instance particulière d’une IObservable<T> implémentation est chargée de gérer tous les abonnements et de notifier tous les abonnés. Sauf si la documentation d’une implémentation particulière IObservable<T> indique autrement, les observateurs ne doivent pas faire d’hypothèses sur l’implémentation, telles que l’ordre IObservable<T> des notifications reçues par plusieurs observateurs.

S’applique à

Voir aussi

• IObserver<T>