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 IObservable<T>

.NET Framework (current version)
 

Publicado: octubre de 2016

Define un proveedor de notificaciones basadas en inserción.

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

public interface IObservable<out T>

Parámetros de tipo

outT

Objeto que proporciona información de notificación.

NombreDescripción
System_CAPS_pubmethodSubscribe(IObserver<T>)

Notifica al proveedor que un observador recibirá las notificaciones.

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 (proveedor); el IObserver<T> interfaz representa la clase que recibe (el observador). T representa la clase que proporciona la información de notificación. En algunas notificaciones basadas en inserción, la IObserver<T> implementación y T puede representar el mismo tipo.

El proveedor debe implementar un único método, Subscribe, que indica que un observador desea recibir notificaciones basadas en inserción. Los autores de llamadas al método pasan una instancia del observador. El método devuelve un IDisposable implementación que permite a los observadores cancelar las notificaciones en cualquier momento antes de que el proveedor ha dejado de enviarlos.

En cualquier momento dado, un proveedor determinado puede tener cero, uno o varios observadores. El proveedor es responsable de almacenar las referencias a los observadores y asegurarse de que son válidos antes de enviar notificaciones. El IObservable<T> interfaz no hace ninguna suposición sobre el número de observadores o el orden en que se envían las notificaciones.

El proveedor envía los siguientes tres tipos de notificaciones al observador llamando IObserver<T> métodos:

  • Los datos actuales. El proveedor puede llamar el IObserver<T>.OnNext método para pasar al observador un T objeto que tiene datos actuales, datos cambiados o datos nuevos.

  • Una condición de error. El proveedor puede llamar el IObserver<T>.OnError método para notificar al observador que se ha producido una condición de error.

  • No hay más datos. El proveedor puede llamar el IObserver<T>.OnCompleted método para notificar al observador que ha terminado de enviar notificaciones.

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

La LocationTracker clase proporciona el IObservable<T> implementación. Su TrackLocation se pasa al método un nullable Location objeto que contiene los datos de latitud y longitud. Si el Location valor no es null, el 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, el TrackLocation método crea una instancia una LocationUnknownException objeto, que se muestra en el ejemplo siguiente. A continuación, llama a cada observador OnError método y pasa el LocationUnknownException objeto. Tenga en cuenta que LocationUnknownException se deriva de Exception, pero no aporta ningún miembro nuevo.

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

Los observadores se registran para recibir notificaciones desde un TrackLocation objeto llamando a su IObservable<T>.Subscribe método, que asigna una referencia al objeto observador a 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. La 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.

En este ejemplo, el LocationReporter clase proporciona el IObserver<T> implementación. Muestra información acerca de la ubicación actual a la consola. Su constructor incluye un name parámetro, que permite el LocationReporter instancia para identificarse en el resultado de cadena. También incluye un 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. La LocationReporter clase también incluye una Unsubscribe método, que llama el 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 código siguiente se crean instancias del proveedor y 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: