IObserver<T> Interface

Définition

Espace de noms:

System

Assembly:

System.Runtime.dll

Assembly:

mscorlib.dll

Assembly:

netstandard.dll

Fournit un mécanisme pour recevoir des notifications de type push.

C#

public interface IObserver<in T>

Paramètres de type

T

Objet qui fournit des informations de notification.

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

Dérivé

Microsoft.Extensions.DiagnosticAdapter.DiagnosticSourceAdapter

System.Web.Hosting.LowPhysicalMemoryObserver

System.Web.Hosting.RecycleLimitObserver

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

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 LocationNotFoundException objet, qui est illustré dans l’exemple suivant. Il appelle ensuite la méthode de OnError chaque observateur et le transmet à l’objet LocationNotFoundException . Notez que LocationNotFoundException cela dérive mais Exception 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.

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.

Une IObserver<T> implémentation organise la réception de notifications d’un fournisseur (implémentation IObservable<T> ) en passant une instance de lui-même à la méthode du IObservable<T>.Subscribe fournisseur. Cette méthode retourne un IDisposable objet qui peut être utilisé pour désabonner l’observateur avant que le fournisseur ne termine l’envoi de notifications.

L’interface IObserver<T> définit les trois méthodes suivantes que l’observateur doit implémenter :

• Méthode OnNext , qui est généralement appelée par le fournisseur pour fournir à l’observateur de nouvelles données ou informations d’état.

• La OnError méthode, qui est généralement appelée par le fournisseur pour indiquer que les données ne sont pas disponibles, inaccessibles ou endommagées, ou que le fournisseur a rencontré une autre condition d’erreur.

• La OnCompleted méthode, qui est généralement appelée par le fournisseur pour indiquer qu’elle a terminé d’envoyer des notifications aux observateurs.

Méthodes

OnCompleted()	Signale à l’observateur que le fournisseur a terminé l’envoi des notifications de type push.
OnError(Exception)	Notifie l’observateur que le fournisseur a rencontré une condition d’erreur.
OnNext(T)	Fournit à l’observateur des nouvelles données.

S’applique à

Voir aussi

• IObservable<T>