Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Interfaccia IObservable<T>

.NET Framework (current version)
 

Data di pubblicazione: ottobre 2016

Definisce un provider per la notifica basata su push.

Spazio dei nomi:   System
Assembly:  mscorlib (in mscorlib.dll)

public interface IObservable<out T>

Parametri tipo

outT

Oggetto che fornisce informazioni di notifica.

NomeDescrizione
System_CAPS_pubmethodSubscribe(IObserver<T>)

Notifica al provider che un osservatore sta per ricevere le notifiche.

Il IObserver<T> e IObservable<T> interfacce forniscono un meccanismo generalizzato per le notifiche basate su push, noto anche come modello di progettazione osservatore. Il IObservable<T> interfaccia rappresenta la classe che invia le notifiche (provider); la IObserver<T> interfaccia rappresenta la classe che riceve tali (l'osservatore). T rappresenta la classe che fornisce le informazioni di notifica. In alcune notifiche basate su push, il IObserver<T> implementazione e T possono rappresentare lo stesso tipo.

Il provider deve implementare un singolo metodo, Subscribe, che indica che un osservatore desidera ricevere notifiche basate su push. I chiamanti del metodo passano un'istanza dell'osservatore. Il metodo restituisce un IDisposable implementazione che consente agli osservatori di annullare le notifiche in qualsiasi momento prima che il provider ha interrotto inviarli.

In qualsiasi momento, un provider specifico può disporre di zero, uno o più osservatori. Il provider è responsabile per l'archiviazione di riferimenti agli osservatori e garantendo che siano validi prima dell'invio di notifiche. Il IObservable<T> interfaccia supposizioni sul numero di osservatori o l'ordine in cui vengono inviate le notifiche.

Il provider invia i seguenti tre tipi di notifiche all'osservatore chiamando IObserver<T> metodi:

  • I dati correnti. Il provider può chiamare il IObserver<T>.OnNext metodo per passare all'osservatore un T oggetto contenente dati correnti, i dati modificati o nuovi dati.

  • Una condizione di errore. Il provider può chiamare il IObserver<T>.OnError metodo per notificare all'osservatore che si è verificata una condizione di errore.

  • Nessun altro dato. Il provider può chiamare il IObserver<T>.OnCompleted metodo per notificare all'osservatore che ha terminato l'invio di notifiche.

Nell'esempio seguente viene illustrato il pattern observer. Definisce un Location classe che contiene informazioni di latitudine e longitudine.

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 classe fornisce il IObservable<T> implementazione. Il TrackLocation viene passato un valore nullable Location oggetto che contiene i dati di latitudine e longitudine. Se il Location valore non è null, TrackLocation chiamate al metodo di OnNext metodo di ogni osservatore.

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

Se il Location è null, TrackLocation Crea un'istanza di metodo un LocationUnknownException oggetto, come illustrato nell'esempio seguente. Chiama quindi ogni osservatore OnError metodo e passa il LocationUnknownException oggetto. Si noti che LocationUnknownException deriva da Exception, ma non aggiunge nuovi membri.

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

Gli osservatori registrarsi per ricevere notifiche da un TrackLocation oggetto chiamando il relativo IObservable<T>.Subscribe metodo, che assegna un riferimento all'oggetto dell'osservatore a un privato generico List<T> oggetto. Il metodo restituisce un Unsubscriber oggetto, ovvero un IDisposable implementazione che consente agli osservatori di interrompere la ricezione di notifiche. La LocationTracker classe include anche un EndTransmission metodo. Quando non è disponibili alcun altri dati di posizione, il metodo chiama ogni osservatore OnCompleted (metodo), quindi Cancella l'elenco interno di osservatori.

In questo esempio, la LocationReporter classe fornisce il IObserver<T> implementazione. Visualizza informazioni sulla posizione corrente nella console. Il costruttore include un name parametro, che consente di LocationReporter istanza per identificarsi nella stringa restituita. Include inoltre un Subscribe (metodo), che include una chiamata al provider Subscribe metodo. In questo modo il metodo assegnare l'oggetto restituito IDisposable riferimento a una variabile privata. Il LocationReporter include anche un Unsubscribe metodo che chiama il IDisposable.Dispose dell'oggetto restituito dal metodo di IObservable<T>.Subscribe (metodo). Il codice seguente definisce 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();
   }
}

Il codice seguente crea quindi il provider e l'osservatore.

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.

Universal Windows Platform
Disponibile da 8
.NET Framework
Disponibile da 4.0
Libreria di classi portabile
Supportato in: piattaforme .NET portabili
Windows Phone Silverlight
Disponibile da 7.0
Windows Phone
Disponibile da 8.1
Torna all'inizio
Mostra: