Costruttore AsyncSubject<T>

Inizializza una nuova istanza della classe T> AsyncSubject<.

Namespace:System.Reactive.Subjects
Assemblea: System.Reactive (in System.Reactive.dll)

Sintassi

'Declaration
Public Sub New

'Usage

Dim instance As New AsyncSubject()

public AsyncSubject()

public:
AsyncSubject()

new : unit -> AsyncSubject

public function AsyncSubject()

Esempio

In questo esempio viene usato un oggetto AsyncSubject per sottoscrivere una sequenza integer generata con l'operatore Range. Un oggetto AsyncSubject restituisce un valore solo quando viene completata la sequenza a cui viene sottoscritta. Al termine della sequenza, AsyncSubject pubblicherà l'elemento finale nella sequenza. AsyncSubject memorizza nella cache l'elemento finale. Tutte le nuove sottoscrizioni rispetto a tale oggetto AsyncSubject avranno anche l'elemento finale pubblicato in tale sottoscrizione.

using System;
using System.Reactive.Linq;
using System.Reactive.Subjects;
using System.Reactive.Concurrency;
using System.Threading;

namespace Example
{
  class Program
  {
    static void Main()
    {
      //*******************************************************************************************************//
      //*** A subject acts similar to a proxy in that it acts as both a subscriber and a publisher          ***//
      //*** It's IObserver interface can be used to subscribe to multiple streams or sequences of data.     ***//
      //*** The data is then published through it's IObservable interface.                                  ***//
      //***                                                                                                 ***//
      //*** In this example an AsyncSubject is used to subscribe to an integer sequence from the Range      ***//
      //*** operator. An AsyncSubject only returns a value when the sequence it is subscribed to completes. ***//
      //*** Once the sequence has completed, the AsyncSubject will publish the final item in the sequence.  ***//
      //*** The AsyncSubject caches the final item. Any new subscriptions against that AsyncSubject will    ***//
      //*** also have the final item published to that subscription as well.                                ***//
      //*******************************************************************************************************//

      var intSequence = Observable.Range(0, 10, Scheduler.ThreadPool);

      AsyncSubject<int> myAsyncSubject = new AsyncSubject<int>();
      intSequence.Subscribe(myAsyncSubject);

      Thread.Sleep(1000);
      myAsyncSubject.Subscribe(i => Console.WriteLine("Final integer for subscription #1 is {0}\n", i),
                               () => Console.WriteLine("subscription #1 completed.\n"));
                                
      
      Console.WriteLine("Sleeping for 5 seconds before subscription2\n");
      Thread.Sleep(5000);

      myAsyncSubject.Subscribe(i => Console.WriteLine("Final integer for subscription #2 after 5 seconds is {0}\n", i),
                               () => Console.WriteLine("subscription #2 completed.\n"));


      Console.WriteLine("Press ENTER to exit...");
      Console.ReadLine();

      myAsyncSubject.Dispose();
    }
  }
}

L'output seguente è stato generato dal codice di esempio.

Final integer for subscription #1 is 9

subscription #1 completed.

Sleeping for 5 seconds before subscription2

Final integer for subscription #2 after 5 seconds is 9

subscription #2 completed.

Press ENTER to exit...

Vedere anche

Riferimento

Classe AsyncSubject<T>

Spazio dei nomi System.Reactive.Subjects