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

Definición

Espacio de nombres:

System

Ensamblado:

System.Runtime.dll

Ensamblado:

mscorlib.dll

Ensamblado:

netstandard.dll

Notifica al proveedor que un observador recibirá las notificaciones.

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

Parámetros

observer

IObserver<T>

Objeto que recibirá las notificaciones.

Devoluciones

IDisposable

Referencia a una interfaz que permite a los observadores dejar de recibir notificaciones antes de que el proveedor haya terminado de enviarlas.

Ejemplos

En el ejemplo siguiente se muestra el Subscribe método de una aplicación que informa de la información de latitud y longitud. Define un IList<T> objeto de colección que almacena referencias a todos los observadores. También devuelve una clase privada denominada Unsubscriber que implementa la IDisposable interfaz y permite a los suscriptores dejar de recibir notificaciones de eventos. Consulte la sección Ejemplo del IObservable<T> tema para obtener el ejemplo 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

Comentarios

Se Subscribe debe llamar al método para registrar un observador para las notificaciones basadas en inserción. Una implementación típica del Subscribe método hace lo siguiente:

• Almacena una referencia al observador en un objeto de colección, como un List<T> objeto .

• Devuelve una referencia a una IDisposable interfaz. Esto permite a los observadores cancelar la suscripción (es decir, dejar de recibir notificaciones) antes de que el proveedor haya terminado de enviarlos y llamar al método del OnCompleted suscriptor.

En un momento dado, una instancia determinada de una IObservable<T> implementación es responsable de controlar todas las suscripciones y notificar a todos los suscriptores. A menos que la documentación de una implementación determinada IObservable<T> indique lo contrario, los observadores no deben realizar ninguna suposición sobre la IObservable<T> implementación, como el orden de las notificaciones que recibirán varios observadores.

Consulte también

• IObserver<T>