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

Definizione

Spazio dei nomi:

System

Assembly:

netstandard.dll, System.Runtime.dll

Origine:

IObservable.cs

Notifica al provider che un osservatore deve ricevere notifiche.

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

Parametri

observer

IObserver<T>

Oggetto che deve ricevere notifiche.

Valori restituiti

IDisposable

Riferimento a un'interfaccia che consente agli osservatori di interrompere la ricezione delle notifiche prima che il provider abbia terminato l'invio.

Esempio

Nell'esempio seguente viene illustrato il Subscribe metodo per un'applicazione che segnala informazioni sulla latitudine e la longitudine. Definisce un IList<T> oggetto raccolta che archivia i riferimenti a tutti gli osservatori. Restituisce anche una classe privata denominata Unsubscriber che implementa l'interfaccia IDisposable e consente ai sottoscrittori di interrompere la ricezione delle notifiche degli eventi. Vedere la sezione Esempio dell'argomento per l'esempio IObservable<T> completo.

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

Commenti

Il Subscribe metodo deve essere chiamato per registrare un osservatore per le notifiche basate su push. Un'implementazione tipica del Subscribe metodo esegue le operazioni seguenti:

• Archivia un riferimento all'osservatore in un oggetto raccolta, ad esempio un List<T> oggetto .

• Restituisce un riferimento a un'interfaccia IDisposable . In questo modo, gli osservatori possono annullare la sottoscrizione (ovvero interrompere la ricezione delle notifiche) prima che il provider abbia terminato l'invio e abbia chiamato il metodo del OnCompleted sottoscrittore.

In qualsiasi momento, una particolare istanza di un'implementazione IObservable<T> è responsabile della gestione di tutte le sottoscrizioni e della notifica a tutti i sottoscrittori. A meno che la documentazione per una particolare IObservable<T> implementazione non indichi diversamente, gli osservatori non devono fare ipotesi sull'implementazione IObservable<T> , ad esempio l'ordine delle notifiche ricevute da più osservatori.

Vedi anche

• IObserver<T>