Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Interfaz IObserver<T>

.NET Framework (current version)
 

Publicado: octubre de 2016

Proporciona un mecanismo para recibir notificaciones basadas en inserción.

Espacio de nombres:   System
Ensamblado:  mscorlib (en mscorlib.dll)

public interface IObserver<in T>

Parámetros de tipo

inT

Objeto que proporciona información de notificación.

NombreDescripción
System_CAPS_pubmethodOnCompleted()

Informa al observador de que el proveedor ha terminado de enviar notificaciones basadas en inserción.

System_CAPS_pubmethodOnError(Exception)

Notifica al observador que el proveedor experimentó una condición de error.

System_CAPS_pubmethodOnNext(T)

Proporciona el observador con nuevos datos.

El IObserver<T> y IObservable<T> interfaces proporcionan un mecanismo generalizado para recibir notificaciones basadas en inserción, también conocido como el modelo de diseño de observador. El IObservable<T> interfaz representa la clase que envía notificaciones (el proveedor); el IObserver<T> interfaz representa la clase que recibe de ellos (el observador). Trepresenta la clase que proporciona la información de notificación.

Un IObserver<T> implementación organiza recibir notificaciones de un proveedor (una IObservable<T> implementación) pasando una instancia de sí mismo para el proveedor IObservable<T>.Subscribe método. Este método devuelve un IDisposable objeto que puede utilizarse para cancelar la suscripción al observador antes el proveedor finaliza el envío de notificaciones.

El IObserver<T> interfaz define los siguientes tres métodos que el observador debe implementar:

  • El OnNext método, que normalmente es llamado por el proveedor para proporcionar al observador con nueva información de estado o de datos.

  • El OnError método, que normalmente se llama por el proveedor para indicar que los datos están inaccesible, están dañados o no está disponible, o que el proveedor ha experimentado alguna otra condición de error.

  • El OnCompleted método, que normalmente es llamado por el proveedor para indicar que ha terminado de enviar notificaciones a los observadores.

En el ejemplo siguiente se muestra el patrón de diseño de observador. Define un Location clase que contiene información de latitud y longitud.

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

El LocationReporter clase proporciona el IObserver<T> implementación. Muestra información acerca de la ubicación actual en la consola. Su constructor incluye un name parámetro, que permite el LocationReporter instancia para identificarse en la salida de cadena. También incluye una Subscribe método, que contiene una llamada al proveedor Subscribe método. Esto permite que el método asignar el valor devuelto IDisposable referencia a una variable privada. El LocationReporter clase también incluye una Unsubscribe método, que llama a la IDisposable.Dispose método del objeto devuelto por la IObservable<T>.Subscribe método. El código siguiente define el LocationReporter clase.

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

El LocationTracker clase proporciona el IObservable<T> implementación. Su TrackLocation método se pasa un que aceptan valores NULL Location objeto que contiene los datos de latitud y longitud. Si el Location valor no es null, TrackLocation llamadas al método el OnNext método de cada observador.

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 el Location valor es null, TrackLocation crea una instancia de método un LocationNotFoundException objeto, que se muestra en el ejemplo siguiente. A continuación, llama a cada observador OnError método y le pasa el LocationNotFoundException objeto. Tenga en cuenta que LocationNotFoundException deriva Exception pero no se agregan los nuevos miembros.

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

Los observadores se registran para recibir notificaciones desde un TrackLocation objeto mediante una llamada a su IObservable<T>.Subscribe método, que asigna una referencia al objeto observador a una interfaz privada genérica List<T> objeto. El método devuelve un Unsubscriber objeto, que es un IDisposable implementación que permite a los observadores dejar de recibir notificaciones. El LocationTracker clase también incluye un EndTransmission método. Cuando no hay más datos de ubicación están disponibles, el método llama a cada observador OnCompleted método y, a continuación, borra la lista interna de observadores.

El código siguiente se crean instancias del proveedor y el observador.

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.

Plataforma universal de Windows
Disponible desde 8
.NET Framework
Disponible desde 4.0
Biblioteca de clases portable
Se admite en: plataformas portátiles de .NET
Windows Phone Silverlight
Disponible desde 7.0
Windows Phone
Disponible desde 8.1
Volver al principio
Mostrar: