Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

IObserver<T> interface

.NET Framework (current version)
 

Date de publication : novembre 2016

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

Espace de noms:   System
Assembly:  mscorlib (dans mscorlib.dll)

public interface IObserver<in T>

Paramètres de type

inT

Objet qui fournit des informations de notification.

NomDescription
System_CAPS_pubmethodOnCompleted()

Signale à l’observateur que le fournisseur a terminé l’envoi des notifications de type push.

System_CAPS_pubmethodOnError(Exception)

Notifie l’observateur que le fournisseur a rencontré une condition d’erreur.

System_CAPS_pubmethodOnNext(T)

Fournit à l’observateur des nouvelles données.

Le IObserver<T> et IObservable<T> interfaces fournissent un mécanisme généralisé pour la notification de type push, également connu sous le modèle de design observateur. Le IObservable<T> interface représente la classe qui envoie des notifications (fournisseur) ; le IObserver<T> interface représente la classe qui les reçoit (Observateur). Treprésente la classe qui fournit les informations de notification.

Un IObserver<T> implémentation organise pour recevoir des notifications à partir d’un fournisseur (un IObservable<T> implémentation) en passant une instance d’elle-même à du fournisseur IObservable<T>.Subscribe (méthode). Cette méthode retourne un IDisposable fin de l’envoi de notifications de l’objet qui peut être utilisé pour annuler l’abonnement de l’Observateur avant que le fournisseur.

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

  • Le OnNext (méthode), qui est généralement appelée par le fournisseur pour fournir à l’Observateur avec de nouvelles informations d’état ou de données.

  • Le OnError (méthode), qui est généralement appelée par le fournisseur pour indiquer que les données sont indisponible, inaccessible ou endommagé, ou que le fournisseur a rencontré une autre condition d’erreur.

  • Le OnCompleted (méthode), qui est généralement appelée par le fournisseur pour indiquer qu’il a terminé l’envoi de notifications aux observateurs.

L’exemple suivant illustre le modèle de design observateur. Il définit un Location classe qui contient les informations de latitude et longitude.

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

Le LocationReporter classe fournit le IObserver<T> implémentation. Il affiche des informations sur l’emplacement actuel dans la console. Son constructeur inclut un name paramètre, ce qui permet la LocationReporter instance identifier dans sa sortie de chaîne. Il inclut également un Subscribe méthode qui encapsule un appel à du fournisseur Subscribe (méthode). Cela permet à la méthode attribuer le retourné IDisposable référence à une variable privée. Le LocationReporter classe inclut également un 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.

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 LocationTracker classe fournit le IObservable<T> implémentation. Son TrackLocation autorisant des valeurs NULL est passé à méthode Location objet qui contient les données de latitude et longitude. Si le Location valeur n’est pas null, le TrackLocation les appels de méthode le OnNext (méthode) de chaque observateur.

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 le Location valeur est null, le TrackLocation méthode instancie un LocationNotFoundException objet, qui est indiqué dans l’exemple suivant. Il appelle ensuite chaque observateur OnError (méthode) et lui passe la LocationNotFoundException objet. Notez que LocationNotFoundException dérive Exception , mais ne pas ajouter de nouveaux membres.

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

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

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

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.

Plateforme Windows universelle
Disponible depuis 8
.NET Framework
Disponible depuis 4.0
Bibliothèque de classes portable
Pris en charge dans : plateformes .NET portables
Silverlight pour Windows Phone
Disponible depuis 7.0
Windows Phone
Disponible depuis 8.1
Retour au début
Afficher: