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

Definizione

Spazio dei nomi:

System

Assembly:

System.Runtime.dll

Assembly:

mscorlib.dll

Assembly:

netstandard.dll

Notifica al provider che un osservatore sta per ricevere le 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 sta per ricevere le notifiche.

Restituisce

IDisposable

Riferimento a un'interfaccia che consente agli osservatori di smettere di ricevere notifiche prima che il provider abbia terminato di inviarle.

Esempio

Nell'esempio seguente viene illustrato il Subscribe metodo per un'applicazione che segnala informazioni sulla latitudine e sulla 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 e consente ai sottoscrittori di interrompere la IDisposable 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 sul push. Un'implementazione tipica del Subscribe metodo esegue le operazioni seguenti:

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

• Restituisce un riferimento a un'interfaccia IDisposable . Ciò consente agli osservatori di annullare la sottoscrizione ( ovvero di interrompere la ricezione delle notifiche) prima che il provider abbia completato l'invio e chiamato il metodo del OnCompleted sottoscrittore.

In qualsiasi momento, un'istanza specifica 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 un'implementazione specifica IObservable<T> indica in caso contrario, gli osservatori non devono prendere ipotesi sull'implementazione IObservable<T> , ad esempio l'ordine delle notifiche che riceveranno più osservatori.

Vedi anche

• IObserver<T>