IObserver<T> Interfaz

Definición

Espacio de nombres:

System

Ensamblado:

System.Runtime.dll

Ensamblado:

mscorlib.dll

Ensamblado:

netstandard.dll

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

C#

public interface IObserver<in T>

Parámetros de tipo

T

Objeto que proporciona información de notificación.

Este parámetro de tipo es contravariante, es decir, puede usar el tipo que haya especificado o cualquier tipo menos derivado. Si desea obtener más información sobre la covarianza y la contravarianza, consulte Covarianza y contravarianza en genéricos.

Derivado

Microsoft.Extensions.DiagnosticAdapter.DiagnosticSourceAdapter

System.Web.Hosting.LowPhysicalMemoryObserver

System.Web.Hosting.RecycleLimitObserver

Ejemplos

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

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

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 clase proporciona la IObservable<T> implementación. Su TrackLocation método se pasa a un objeto que acepta Location valores NULL que contiene los datos de latitud y longitud. Si el Location valor no nulles , el TrackLocation método llama al OnNext método de cada observador.

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 el Location valor es null, el TrackLocation método crea una instancia de un LocationNotFoundException objeto , que se muestra en el ejemplo siguiente. A continuación, llama al método de OnError cada observador y lo pasa al LocationNotFoundException objeto . Tenga en cuenta que LocationNotFoundException se deriva de Exception pero no agrega ningún miembro nuevo.

C#

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

Los observadores se registran para recibir notificaciones de un TrackLocation objeto llamando a su IObservable<T>.Subscribe método , que asigna una referencia al objeto observer a un objeto genérico List<T> privado. El método devuelve un Unsubscriber objeto , que es una 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 disponibles, el método llama al método de OnCompleted cada observador y, a continuación, borra la lista interna de observadores.

A continuación, el código siguiente crea una instancia del proveedor y del observador.

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.

Comentarios

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

Una IObserver<T> implementación se organiza para recibir notificaciones de un proveedor (una IObservable<T> implementación) pasando una instancia de sí misma al método del IObservable<T>.Subscribe proveedor. Este método devuelve un IDisposable objeto que se puede usar para cancelar la suscripción del observador antes de que el proveedor termine de enviar notificaciones.

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

• El OnNext método, al que normalmente llama el proveedor para proporcionar al observador información de nuevos datos o estado.

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

• El OnCompleted método, al que normalmente llama el proveedor para indicar que ha terminado de enviar notificaciones a observadores.

Métodos

OnCompleted()	Informa al observador de que el proveedor ha terminado de enviar notificaciones basadas en inserción.
OnError(Exception)	Notifica al observador que el proveedor experimentó una condición de error.
OnNext(T)	Proporciona el observador con nuevos datos.

Se aplica a

Consulte también

• IObservable<T>