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

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

Parametrar

Returer

En referens till ett gränssnitt som gör det möjligt för observatörer att sluta ta emot meddelanden innan leverantören har skickat dem.

Exempel

I följande exempel visas metoden Subscribe för ett program som rapporterar latitud- och longitudinformation. Den definierar ett IList<T> samlingsobjekt som lagrar referenser till alla observatörer. Den returnerar också en privat klass med namnet Unsubscriber som implementerar IDisposable gränssnittet och gör det möjligt för prenumeranter att sluta ta emot händelsemeddelanden. Se avsnittet Exempel i avsnittet IObservable<T> för det fullständiga exemplet.

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

Kommentarer

Metoden Subscribe måste anropas för att registrera en övervakare för push-baserade meddelanden. En typisk implementering av Subscribe metoden gör följande:

• Den lagrar en referens till observatören i ett samlingsobjekt, till exempel ett List<T> objekt.

• Den returnerar en referens till ett IDisposable gränssnitt. Detta gör det möjligt för observatörer att avbryta prenumerationen (det vill säga sluta ta emot meddelanden) innan leverantören har skickat dem och anropat prenumerantens OnCompleted metod.

Vid en viss tidpunkt ansvarar en viss instans av en IObservable<T> implementering för att hantera alla prenumerationer och meddela alla prenumeranter. Om inte dokumentationen för ett visst IObservable<T> genomförande anger något annat bör observatörer inte göra några antaganden om IObservable<T> genomförandet, till exempel ordningen på anmälningar som flera observatörer kommer att ta emot.

Se även

• IObserver<T>