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
Questa documentazione è stata archiviata e non viene gestita.

Interfaccia IObserver<T>

Fornisce un meccanismo per ricevere notifiche basate su push.

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

public interface IObserver<in T>

Parametri di tipo

in T

Oggetto che fornisce informazioni di notifica.

Il parametro di questo tipo è controvariante. Ciò significa che è possibile utilizzare il tipo specificato o qualsiasi tipo meno derivato. Per ulteriori informazioni sulla covarianza e la controvarianza, vedere Covarianza e controvarianza nei generics.

Il tipo IObserver<T> espone i seguenti membri.

  NomeDescrizione
Metodo pubblicoOnCompletedNotifica all'osservatore che il provider ha completato l'invio di notifiche basate su push.
Metodo pubblicoOnErrorNotifica all'osservatore che il provider ha riscontrato una condizione di errore.
Metodo pubblicoOnNextFornisce all'osservatore nuovi dati.
In alto

Le interfacce IObserver<T> e IObservable<T> forniscono un meccanismo generalizzato per la notifica push, noto anche come modello di progettazione dell'osservatore. L'interfaccia IObservable<T> rappresenta la classe che invia notifiche (il provider); l'interfaccia IObserver<T> rappresenta la classe che li riceve (l'osservatore). T rappresenta la classe che fornisce le informazioni di notifica.

Un'implementazione IObserver<T> dispone la ricezione di notifiche da un provider (un'implementazione di IObservable<T>) passando un'istanza di se stessa al metodo IObservable<T>.Subscribe del provider. Questo metodo restituisce un oggetto IDisposable che può essere utilizzato per annullare l'osservatore prima che il provider completi l'invio delle notifiche.

L'interfaccia IObserver<T> definisce i tre metodi seguenti che l'osservatore deve implementare:

  • Il metodo OnNext, che viene in genere chiamato dal provider per fornire all'osservatore nuovi dati o informazioni sullo stato.

  • Il metodo OnError, che in genere viene chiamato dal provider per indicare che i dati non sono disponibili, accessibili o che sono danneggiati, o che il provider ha riscontrato un'altra condizione di errore.

  • Il metodo OnCompleted, che in genere viene chiamato dal provider per indicare che ha completato l'invio delle notifiche agli osservatori.

Nell'esempio seguente viene illustrato il modello di progettazione osservatore. Definisce una classe Location che contiene informazioni sulla latitudine e la 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 classe LocationReporter fornisce l'implementazione IObserver<T>. Visualizza informazioni sul percorso corrente della console. Il costruttore include il parametro name che consente all'istanza di LocationReporter di identificarsi nella stringa restituita. Include inoltre un metodo Subscribe che esegue il wrapping di una chiamata al metodo Subscribe del provider. Consente al metodo di assegnare il riferimento IDisposable restituito a una variabile privata. La classe LocationReporter include anche un metodo Unsubscribe che chiama il metodo IDisposable.Dispose dell'oggetto restituito dal metodo IObservable<T>.Subscribe. Nel codice seguente viene definita 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 fornisce l'implementazione IObservable<T>. Al relativo metodo TrackLocation viene passato un oggetto Location nullable che contiene i dati relativi a latitudine e longitudine. Se il valore di Location non è null, il metodo TrackLocation chiama il metodo OnNext 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 valore di Location è null, il metodo TrackLocation crea un'istanza di un oggetto LocationNotFoundException, mostrato nell'esempio seguente. Successivamente chiama il metodo OnError di ciascun osservatore e lo passa all'oggetto LocationNotFoundException. Si noti che LocationNotFoundException deriva da Exception, ma non aggiunge alcun nuovo membro.


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


Gli osservatori effettuano la registrazione per ricevere notifiche da un oggetto TrackLocation chiamando il metodo IObservable<T>.Subscribe che assegna un riferimento all'oggetto dell'osservatore a un oggetto List<T> generico privato. Il metodo restituisce un oggetto Unsubscriber che è un'implementazione di IDisposable che consente agli osservatori di arrestare la ricezione delle notifiche prima che il metodo venga chiamato. La classe LocationTracker include anche un metodo EndTransmission. Quando non sono disponibili ulteriori dati del percorso, il metodo chiama il metodo OnCompleted di ogni osservatore, quindi cancella l'elenco interno di osservatori.

Nel codice seguente viene quindi creata un'istanza del provider e dell'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.


.NET Framework

Supportato in: 4

.NET Framework Client Profile

Supportato in: 4

Windows 7, Windows Vista SP1 o versione successiva, Windows XP SP3, Windows Server 2008 (componenti di base del server non supportati), Windows Server 2008 R2 (componenti di base del server supportati con SP1 o versione successiva), Windows Server 2003 SP2

.NET Framework non supporta tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema di .NET Framework.
Mostra: