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

Reference

Definition

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.

Notifies the provider that an observer is to receive notifications.

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

Parameters

observer: IObserver<T>

The object that is to receive notifications.

Returns

IDisposable

A reference to an interface that allows observers to stop receiving notifications before the provider has finished sending them.

Examples

The following example illustrates the Subscribe method for an application that reports latitude and longitude information. It defines an IList<T> collection object that stores references to all observers. It also returns a private class named Unsubscriber that implements the IDisposable interface and enables subscribers to stop receiving event notifications. See the Example section of the IObservable<T> topic for the complete example.

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

Remarks

The Subscribe method must be called to register an observer for push-based notifications. A typical implementation of the Subscribe method does the following:

It stores a reference to the observer in a collection object, such as a List<T> object.
It returns a reference to an IDisposable interface. This enables observers to unsubscribe (that is, to stop receiving notifications) before the provider has finished sending them and called the subscriber's OnCompleted method.

At any given time, a particular instance of an IObservable<T> implementation is responsible for handling all subscriptions and notifying all subscribers. Unless the documentation for a particular IObservable<T> implementation indicates otherwise, observers should make no assumptions about the IObservable<T> implementation, such as the order of notifications that multiple observers will receive.

Applies to

Condividi tramite