IObservable<T> Interface

Définition

Espace de noms:

System

Assembly:

System.Runtime.dll

Assembly:

mscorlib.dll

Assembly:

netstandard.dll

Définit un fournisseur pour la notification de type push.

C#

public interface IObservable<out T>

Paramètres de type

T

Objet qui fournit des informations de notification.

Ce paramètre de type est covariant. Cela signifie que vous pouvez utiliser le type spécifié ou tout type plus dérivé. Pour plus d’informations sur la covariance et la contravariance, consultez Covariance et contravariance dans les génériques.

Dérivé

System.Diagnostics.DiagnosticListener

System.Web.Hosting.AspNetMemoryMonitor

Exemples

L’exemple suivant illustre le modèle de conception de l’observateur. Il définit une Location classe qui contient des informations de latitude et de longitude.

C#

public struct Location
{
   double lat, lon;

   public Location(double latitude, double longitude)
   {
      this.lat = latitude;
      this.lon = longitude;
   }

   public double Latitude
   { get { return this.lat; } }

   public double Longitude
   { get { return this.lon; } }
}

La LocationTracker classe fournit l’implémentation IObservable<T> . Sa TrackLocation méthode est passée à un objet nullable Location qui contient les données de latitude et de longitude. Si la Location valeur n’est pas null, la TrackLocation méthode appelle la OnNext méthode de chaque observateur.

C#

public class LocationTracker : IObservable<Location>
{
   public LocationTracker()
   {
      observers = new List<IObserver<Location>>();
   }

   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);
      }
   }

   public void TrackLocation(Nullable<Location> loc)
   {
      foreach (var observer in observers) {
         if (! loc.HasValue)
            observer.OnError(new LocationUnknownException());
         else
            observer.OnNext(loc.Value);
      }
   }

   public void EndTransmission()
   {
      foreach (var observer in observers.ToArray())
         if (observers.Contains(observer))
            observer.OnCompleted();

      observers.Clear();
   }
}

Si la Location valeur est null, la TrackLocation méthode instancie un LocationUnknownException objet, qui est illustré dans l’exemple suivant. Il appelle ensuite la méthode de OnError chaque observateur et le transmet à l’objet LocationUnknownException . Notez que LocationUnknownException dérive de Exception, mais n’ajoute aucun nouveau membre.

C#

public class LocationUnknownException : Exception
{
   internal LocationUnknownException()
   { }
}

Les observateurs s’inscrivent pour recevoir des notifications d’un TrackLocation objet en appelant sa IObservable<T>.Subscribe méthode, qui affecte une référence à l’objet observateur à un objet générique List<T> privé. La méthode retourne un Unsubscriber objet, qui est une IDisposable implémentation qui permet aux observateurs d’arrêter de recevoir des notifications. La LocationTracker classe inclut également une EndTransmission méthode. Lorsqu’aucune autre donnée d’emplacement n’est disponible, la méthode appelle la méthode de OnCompleted chaque observateur, puis efface la liste interne des observateurs.

Dans cet exemple, la LocationReporter classe fournit l’implémentation IObserver<T> . Il affiche des informations sur l’emplacement actuel de la console. Son constructeur inclut un name paramètre, qui permet à l’instance LocationReporter de s’identifier dans sa sortie de chaîne. Il inclut également une Subscribe méthode, qui encapsule un appel à la méthode du Subscribe fournisseur. Cela permet à la méthode d’affecter la référence retournée IDisposable à une variable privée. La LocationReporter classe inclut également une Unsubscribe méthode qui appelle la IDisposable.Dispose méthode de l’objet retourné par la IObservable<T>.Subscribe méthode. Le code suivant définit la LocationReporter classe.

C#

using System;

public class LocationReporter : IObserver<Location>
{
   private IDisposable unsubscriber;
   private string instName;

   public LocationReporter(string name)
   {
      this.instName = name;
   }

   public string Name
   {  get{ return this.instName; } }

   public virtual void Subscribe(IObservable<Location> provider)
   {
      if (provider != null)
         unsubscriber = provider.Subscribe(this);
   }

   public virtual void OnCompleted()
   {
      Console.WriteLine("The Location Tracker has completed transmitting data to {0}.", this.Name);
      this.Unsubscribe();
   }

   public virtual void OnError(Exception e)
   {
      Console.WriteLine("{0}: The location cannot be determined.", this.Name);
   }

   public virtual void OnNext(Location value)
   {
      Console.WriteLine("{2}: The current location is {0}, {1}", value.Latitude, value.Longitude, this.Name);
   }

   public virtual void Unsubscribe()
   {
      unsubscriber.Dispose();
   }
}

Le code suivant instancie ensuite le fournisseur et l’observateur.

C#

using System;

class Program
{
   static void Main(string[] args)
   {
      // Define a provider and two observers.
      LocationTracker provider = new LocationTracker();
      LocationReporter reporter1 = new LocationReporter("FixedGPS");
      reporter1.Subscribe(provider);
      LocationReporter reporter2 = new LocationReporter("MobileGPS");
      reporter2.Subscribe(provider);

      provider.TrackLocation(new Location(47.6456, -122.1312));
      reporter1.Unsubscribe();
      provider.TrackLocation(new Location(47.6677, -122.1199));
      provider.TrackLocation(null);
      provider.EndTransmission();
   }
}
// The example displays output similar to the following:
//      FixedGPS: The current location is 47.6456, -122.1312
//      MobileGPS: The current location is 47.6456, -122.1312
//      MobileGPS: The current location is 47.6677, -122.1199
//      MobileGPS: The location cannot be determined.
//      The Location Tracker has completed transmitting data to MobileGPS.

Remarques

Les IObserver<T> interfaces et IObservable<T> les interfaces fournissent un mécanisme généralisé pour la notification push, également appelée modèle de conception d’observateur. L’interface IObservable<T> représente la classe qui envoie des notifications (le fournisseur) ; l’interface IObserver<T> représente la classe qui les reçoit (l’observateur). T représente la classe qui fournit les informations de notification. Dans certaines notifications push, l’implémentation IObserver<T> et T peut représenter le même type.

Le fournisseur doit implémenter une méthode unique, Subscribequi indique qu’un observateur souhaite recevoir des notifications push. Les appelants à la méthode passent une instance de l’observateur. La méthode retourne une IDisposable implémentation qui permet aux observateurs d’annuler les notifications à tout moment avant que le fournisseur ne les envoie.

À tout moment donné, un fournisseur donné peut avoir zéro, un ou plusieurs observateurs. Le fournisseur est chargé de stocker des références aux observateurs et de s’assurer qu’ils sont valides avant d’envoyer des notifications. L’interface IObservable<T> ne fait aucune hypothèse sur le nombre d’observateurs ou l’ordre dans lequel les notifications sont envoyées.

Le fournisseur envoie les trois types de notifications suivants à l’observateur en appelant IObserver<T> des méthodes :

• Données actuelles. Le fournisseur peut appeler la IObserver<T>.OnNext méthode pour transmettre à l’observateur un T objet qui a des données actuelles, des données modifiées ou des données fraîches.

• Condition d’erreur. Le fournisseur peut appeler la IObserver<T>.OnError méthode pour avertir l’observateur que certaines conditions d’erreur se sont produites.

• Aucune autre donnée. Le fournisseur peut appeler la IObserver<T>.OnCompleted méthode pour avertir l’observateur qu’il a terminé d’envoyer des notifications.

Méthodes

Subscribe(IObserver<T>)

Notifie le fournisseur qu’un observateur doit recevoir des notifications.

S’applique à

Voir aussi

• IObserver<T>
• Modèle de conception d’observateur