Exporter (0) Imprimer
Développer tout
Cet article a fait l'objet d'une traduction automatique. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte. Informations supplémentaires.
Traduction
Source

IObserver<T>, interface

Fournit un mécanisme permettant de recevoir des notifications basées sur des transmissions de type push.

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

public interface IObserver<in T>

Paramètres de type

in T

Objet qui fournit des informations de notification.

Ce paramètre de type est contravariant. Autrement dit, vous pouvez utiliser le type que vous avez 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.

Le type IObserver<T> expose les membres suivants.

  NomDescription
Méthode publiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreOnCompletedNotifie l'observateur que le fournisseur a terminé d'envoyer des notifications basées sur des transmissions de type push.
Méthode publiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreOnErrorNotifie l'observateur que le fournisseur a rencontré une condition d'erreur.
Méthode publiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreOnNextFournit de nouvelles données à l'observateur.
Début

Les interfaces IObserver<T> et IObservable<T> fournissent un mécanisme généralisé pour la notification basée sur la transmission de type push, également appelée modèle de design observateur. L'interface IObservable<T> représente la classe qui envoie des notifications (fournisseur) ; l'interface IObserver<T> représente la classe qui les reçoit (observateur). T représente la classe qui fournit les informations de notification.

Une implémentation IObserver<T> s'organise pour recevoir des notifications d'un fournisseur (implémentation IObservable<T> ) en passant une instance d'elle-même à la méthode IObservable<T>.Subscribe du fournisseur. Cette méthode retourne un objet IDisposable qui peut être utilisé pour désabonner l'observateur avant que le fournisseur n'ait terminé d'envoyer les notifications.

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

  • Méthode OnNext, appelée en général par le fournisseur pour fournir de nouvelles données ou des informations d'état à l'observateur.

  • La méthode OnError, appelée en général par le fournisseur pour indiquer que les données ne sont pas disponibles, sont inaccessibles ou endommagées, ou que le fournisseur a rencontré quelque autre condition d'erreur.

  • La méthode OnCompleted, appelée en général par le fournisseur pour indiquer qu'elle a terminé d'envoyer des notifications aux observateurs.

L'exemple suivant illustre le modèle de design d'observateur. Il définit une classe Location qui contient les informations de latitude et de 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; } }
}


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


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 classe LocationTracker fournit l'implémentation de IObservable<T>. Un objet Location nullable qui contient les données de latitude et de longitude est passé à sa méthode TrackLocation. Si la valeur Location n'est pas null, la méthode TrackLocation appelle la méthode OnNext 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 la valeur Location est null, la méthode TrackLocation instancie un objet LocationNotFoundException, affiché dans l'exemple suivant. Elle appelle alors la méthode OnError de chaque observateur et la passe à l'objet LocationNotFoundException. Notez que LocationNotFoundException dérive de Exception, mais n'ajoute pas de nouveaux membres.


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


Les observateurs s'enregistrent pour recevoir des notifications d'un objet TrackLocation en appelant sa méthode IObservable<T>.Subscribe, qui assigne une référence à l'objet d'observateur pour un objet List<T> générique privé. La méthode retourne un objet Unsubscriber qui est une implémentation IDisposable qui permet aux observateurs d'arrêter de recevoir des notifications. La classe LocationTracker inclut aussi une méthode EndTransmission. Si aucune donnée d'emplacement supplémentaire n'est disponible, la méthode appelle la méthode OnCompleted de chaque observateur, puis efface la liste interne d'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.


.NET Framework

Pris en charge dans : 4.5.2, 4.5.1, 4.5, 4

.NET Framework Client Profile

Pris en charge dans : 4

Bibliothèque de classes portable

Pris en charge dans : Bibliothèque de classes portable

.NET pour les applications du Windows Store

Pris en charge dans : Windows 8

.NET pour les applications Windows Phone

Pris en charge dans : Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (rôle principal du serveur non pris en charge), Windows Server 2008 R2 (rôle principal du serveur pris en charge avec SP1 ou version ultérieure ; Itanium non pris en charge)

Le .NET Framework ne prend pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.

Ajouts de la communauté

AJOUTER
Afficher:
© 2014 Microsoft