AsyncSubject<T>. Méthode Subscribe
Abonne un observateur à l’objet.
Namespace:System.Reactive.Subjects
Assemblée: System.Reactive (en System.Reactive.dll)
Syntaxe
'Declaration
Public Function Subscribe ( _
observer As IObserver(Of T) _
) As IDisposable
'Usage
Dim instance As AsyncSubject
Dim observer As IObserver(Of T)
Dim returnValue As IDisposable
returnValue = instance.Subscribe(observer)
public IDisposable Subscribe(
IObserver<T> observer
)
public:
virtual IDisposable^ Subscribe(
IObserver<T>^ observer
) sealed
abstract Subscribe :
observer:IObserver<'T> -> IDisposable
override Subscribe :
observer:IObserver<'T> -> IDisposable
public final function Subscribe(
observer : IObserver<T>
) : IDisposable
Paramètres
- Observateur
Type : System.IObserver<T>
Observateur pour s’abonner à l’objet.
Valeur de retour
Type : System.IDisposable
Objet IDisposable qui peut être utilisé pour désinscrire l’observateur de l’objet.
Implémente
IObservable<T>. Subscribe(IObserver<T>)
Notes
La méthode Subscribe d’un AsyncSubject est utilisée pour ajouter des abonnements d’observateur à la séquence observable d’AsyncSubject. Un objet AsyncSubject ne publie sur son interface IObservable qu’une fois que son IObserver a reçu un appel OnComplete à la fin de son abonnement. Une fois que cela s’est produit, tous les nouveaux abonnements à l’objet AsyncSubject ont également le résultat final publié dans cet abonnement.
Exemples
Dans cet exemple, un objet AsyncSubject est utilisé pour s’abonner à une séquence d’entiers générée avec l’opérateur Range. Un objet AsyncSubject retourne une valeur uniquement lorsque la séquence à laquelle elle est abonnée se termine. Une fois la séquence terminée, L’objet AsyncSubject publie l’élément final de la séquence. AsyncSubject met en cache l’élément final. Tous les nouveaux abonnements correspondant à ce AsyncSubject auront également l’élément final publié dans cet abonnement.
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();
}
}
}
La sortie suivante a été générée par l’exemple de code.
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...