Partager via


BehaviorSubject<T>, classe

Représente une valeur qui change au fil du temps.

Hiérarchie d’héritage

System.Object
  System.React.Subjects.BehaviorSubject<T>

espace de noms :System.React.Subjects
assembly : System.React (dans System.Reactive.dll)

Syntaxe

'Declaration
Public NotInheritable Class BehaviorSubject(Of T) _
    Implements ISubject(Of T), ISubject(Of T, T),  _
    IObserver(Of T), IObservable(Of T), IDisposable
'Usage
Dim instance As BehaviorSubject(Of T)
public sealed class BehaviorSubject<T> : ISubject<T>, 
    ISubject<T, T>, IObserver<T>, IObservable<T>, IDisposable
generic<typename T>
public ref class BehaviorSubject sealed : ISubject<T>, 
    ISubject<T, T>, IObserver<T>, IObservable<T>, IDisposable
[<SealedAttribute>]
type BehaviorSubject<'T> =  
    class
        interface ISubject<'T>
        interface ISubject<'T, 'T>
        interface IObserver<'T>
        interface IObservable<'T>
        interface IDisposable
    end
JScript does not support generic types and methods.

Paramètres de type

  • T
    Type.

Le type behaviorSubject<T> expose les membres suivants.

Constructeurs

  Nom Description
méthode publique BehaviorSubject<T> Initialise une nouvelle instance de la classe BehaviorSubject<T> qui crée un objet qui met en cache sa dernière valeur et commence par la valeur spécifiée.

Retour au début

Méthode

  Nom Description
méthode publique Supprimer Désinscrivez tous les observateurs et publiez les ressources.
méthode publique Equals (Hérité de l’objet .)
méthode protégée méthode protégée finaliser (Hérité de l’objet .)
méthode publique GetHashCode (Hérité de l’objet .)
méthode publique GetType (Hérité de l’objet .)
méthode protégée méthode protégée MemberwiseClone (Hérité de l’objet .)
méthode publique onCompleted Avertit tous les observateurs abonnés de la fin de la séquence.
méthode publique OnError Notifie tous les observateurs abonnés à l’exception.
méthode publique OnNext Notifie tous les observateurs abonnés avec la valeur.
méthode publique s’abonner Abonne un observateur au sujet.
méthode publique ToString (Hérité de l’objet .)

Retour au début

Méthodes d’extension

  Nom Description
méthode d’extension publique <T>(Func<T, T, T>) Comblé. Applique une fonction d’accumulation sur une séquence observable. (Défini par observable.)
méthode d’extension publique Agrégat<T, TAccumulate>(TAccumulate, Func<TAccumulate, T, TAccumulate>) Comblé. Applique une fonction d’accumulation sur une séquence observable avec la valeur initiale spécifiée. (Défini par observable.)
méthode d’extension publique Tous les> T< Détermine si tous les éléments d’une séquence observable répondent à une condition. (Défini par observable.)
méthode d’extension publique Amb<T> Propage la séquence observable qui réagit en premier avec la première et la deuxième séquence spécifiées. (Défini par observable.)
méthode d’extension publique Et<T, TRight> Correspond lorsque les deux séquences observables ont une valeur disponible. (Défini par observable.)
méthode d’extension publique tout<T>() Comblé. Détermine si une séquence observable contient des éléments. (Défini par observable.)
méthode d’extension publique Any<T>(Func<T, Boolean>) Comblé. Détermine si tous les éléments d’une séquence observable répondent à une condition. (Défini par observable.)
méthode d’extension publique AsObservable<T> Masque l’identité d’une séquence observable. (Défini par observable.)
méthode d’extension publique AsObserver<T> Masque l’identité d’un observateur. (Défini par Observer.)
méthode d’extension publique AsQbservable<T> Convertit une séquence observable en séquence observable interrogeable. (Défini par Qbservable.)
méthode d’extension publique AssertEqual<T> (Défini par les extensions .)
méthode d’extension publique mémoire tampon<T>(Int32) Comblé. Indique chaque élément d’une séquence observable en mémoires tampons consécutives qui ne se chevauchent pas, qui sont produites en fonction des informations de comptage d’éléments. (Défini par observable.)
méthode d’extension publique mémoire tampon<T>(TimeSpan) Comblé. Indique chaque élément d’une séquence observable en mémoires tampons consécutives qui ne se chevauchent pas, qui sont produites en fonction des informations de minutage. (Défini par observable.)
méthode d’extension publique mémoire tampon<T>(Int32, Int32) Comblé. Indique chaque élément d’une séquence observable en zéro ou plusieurs mémoires tampons produites en fonction des informations de nombre d’éléments. (Défini par observable.)
méthode d’extension publique tampon<T>(TimeSpan, IScheduler) Comblé. Indique chaque élément d’une séquence observable en mémoires tampons consécutives qui ne se chevauchent pas, qui sont produites en fonction des informations de minutage. (Défini par observable.)
méthode d’extension publique mémoire tampon<T>(TimeSpan, TimeSpan) Comblé. Indique chaque élément d’une séquence observable en zéro ou plusieurs mémoires tampons produites en fonction des informations de minutage. (Défini par observable.)
méthode d’extension publique mémoire tampon<T>(TimeSpan, Int32) Comblé. Indique chaque élément d’une séquence observable dans une mémoire tampon envoyée lorsqu’il est plein ou qu’un certain temps s’est écoulé. (Défini par observable.)
méthode d’extension publique mémoire tampon<T>(TimeSpan, TimeSpan, IScheduler) Comblé. Indique chaque élément d’une séquence observable en zéro ou plusieurs mémoires tampons produites en fonction des informations de minutage. (Défini par observable.)
méthode d’extension publique mémoire tampon<T>(TimeSpan, Int32, IScheduler) Comblé. Indique chaque élément d’une séquence observable dans une mémoire tampon envoyée lorsqu’il est plein ou qu’un certain temps s’est écoulé. (Défini par observable.)
méthode d’extension publique tampon<T, TBufferClosing>(Func<IObservable<TBufferClosing>>) Comblé. Indique chaque élément d’une séquence observable en mémoires tampons qui ne se chevauchent pas consécutivement. (Défini par observable.)
méthode d’extension publique tampon<T, TBufferOpening, TBufferClosing>(IObservable<TBufferOpening>, Func<TBufferOpening, IObservable<TBufferClosing>>) Comblé. Indique chaque élément d’une séquence observable interrogeable en mémoires tampons qui ne se chevauchent pas consécutivement. (Défini par observable.)
méthode d’extension publique catch<T>(IObservable<T>) Comblé. Poursuit une séquence observable qui est arrêtée par une exception avec la séquence observable suivante. (Défini par observable.)
méthode d’extension publique Catch<T, TException>(Func<TException, IObservable<T>>) Comblé. Poursuit une séquence observable qui est arrêtée par une exception du type spécifié avec la séquence observable produite par le gestionnaire. (Défini par observable.)
méthode d’extension publique CombineLatest<T, TSecond, TResult> Fusionne deux séquences observables en une séquence observable à l’aide de la fonction de sélecteur chaque fois qu’une des séquences observables produit un élément. (Défini par observable.)
méthode d’extension publique Concat<T> Concatène deux séquences observables. (Défini par observable.)
méthode d’extension publique Contient>T<T Comblé. Détermine si une séquence observable contient un élément spécifié à l’aide du comparateur d’égalité par défaut. (Défini par observable.)
méthode d’extension publique Contient<>T (T, IEqualityComparer<T>) Comblé. Détermine si une séquence observable contient un élément spécifié à l’aide d’un system.Collections.Generic.IEqualityComparer spécifié< ; T> ;. (Défini par observable.)
méthode d’extension publique Count<T> Retourne un Int32 qui représente le nombre total d’éléments d’une séquence observable. (Défini par observable.)
méthode d’extension publique defaultIfEmpty<T>() Comblé. Retourne les éléments de la séquence spécifiée ou la valeur par défaut du paramètre de type dans une séquence singleton si la séquence est vide. (Défini par observable.)
méthode d’extension publique DefaultIfEmpty<T>(T) Comblé. Retourne les éléments de la séquence spécifiée ou la valeur par défaut du paramètre de type dans une séquence singleton si la séquence est vide. (Défini par observable.)
méthode d’extension publique délai<T>(TimeSpan) Comblé. Indique la séquence observable par heure d’échéance avec la source et dueTime spécifiées. (Défini par observable.)
méthode d’extension publique Delay<T>(DateTimeOffset) Comblé. Indique la séquence observable par heure d’échéance avec la source et dueTime spécifiées. (Défini par observable.)
méthode d’extension publique délai<T>(TimeSpan, IScheduler) Comblé. Indique la séquence observable par heure d’échéance avec la source, dueTime et le planificateur spécifiés. (Défini par observable.)
méthode d’extension publique Delay<T>(DateTimeOffset, IScheduler) Comblé. Indique la séquence observable par heure d’échéance avec la source, dueTime et le planificateur spécifiés. (Défini par observable.)
méthode d’extension publique distinct<T>() Comblé. Retourne une séquence observable qui contient uniquement des éléments distincts avec une source spécifiée. (Défini par observable.)
méthode d’extension publique distinct<>T>(IEqualityComparer<T>) Comblé. Retourne une séquence observable qui contient uniquement des éléments distincts en fonction du comparateur. (Défini par observable.)
méthode d’extension publique Distinct<T, TKey>(Func<T, TKey>) Comblé. Retourne une séquence observable qui contient uniquement des éléments distincts en fonction du keySelector. (Défini par observable.)
méthode d’extension publique Distinct<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>) Comblé. Retourne une séquence observable qui contient uniquement des éléments distincts en fonction du keySelector. (Défini par observable.)
méthode d’extension publique DistinctUntilChanged<T>() Comblé. Retourne une séquence observable qui contient uniquement des éléments contigus distincts avec une source spécifiée. (Défini par observable.)
méthode d’extension publique DistinctUntilChanged<T>(IEqualityComparer<T>) Comblé. Retourne une séquence observable qui contient uniquement des éléments contigus distincts en fonction du comparateur. (Défini par observable.)
méthode d’extension publique DistinctUntilChanged<T, TKey>(Func<T, TKey>) Comblé. Retourne une séquence observable qui contient uniquement des éléments contigus distincts en fonction du keySelector. (Défini par observable.)
méthode d’extension publique DistinctUntilChanged<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>) Comblé. Retourne une séquence observable qui contient uniquement des éléments contigus distincts en fonction du keySelector et du comparateur. (Défini par observable.)
méthode d’extension publique > <T (action<T>) Comblé. Appelle une action pour chaque élément de la séquence observable. (Défini par observable.)
méthode d’extension publique >T<(IObserver<T>) Comblé. Appelle une action pour chaque élément de la séquence observable et appelle une action en cas d’arrêt exceptionnel de la séquence observable. (Défini par observable.)
méthode d’extension publique >T<(Action<T>, Action) Comblé. Appelle une action pour chaque élément de la séquence observable et appelle une action à la fin normale de la séquence observable. (Défini par observable.)
méthode d’extension publique >T<(Action<T>, Exception<action>) Comblé. Appelle une action pour chaque élément de la séquence observable et appelle une action en cas d’arrêt exceptionnel de la séquence observable. (Défini par observable.)
méthode d’extension publique >T<(Action<T>, Action<Exception>, Action) Comblé. Appelle une action pour chaque élément de la séquence observable et appelle une action en cas de fin normale ou exceptionnelle de la séquence observable. (Défini par observable.)
méthode d’extension publique ElementAt<T> Retourne l’élément à un index spécifié dans une séquence. (Défini par observable.)
méthode d’extension publique ElementAtOrDefault<T> Retourne l’élément à un index spécifié dans une séquence ou une valeur par défaut si l’index est hors plage. (Défini par observable.)
méthode d’extension publique Enfin<T> Appelle une action spécifiée après la fin de la séquence observable source normalement ou par une exception. (Défini par observable.)
méthode d’extension publique premier<T>() Comblé. Retourne le premier élément d’une séquence observable avec une source spécifiée. (Défini par observable.)
méthode d’extension publique premier<T>(Func<T,>booléen ) Comblé. Retourne le premier élément d’une séquence observable qui correspond au prédicat. (Défini par observable.)
méthode d’extension publique firstOrDefault<T>() Comblé. Retourne le premier élément d’une séquence observable ou une valeur par défaut si aucune valeur n’est trouvée. (Défini par observable.)
méthode d’extension publique FirstOrDefault<T>(Func<T, Boolean>) Comblé. Retourne le premier élément d’une séquence observable qui correspond au prédicat, ou une valeur par défaut si aucune valeur n’est trouvée. (Défini par observable.)
méthode d’extension publique Foo<T, R> (Défini par MyExt.)
méthode d’extension publique ForEach<T> Appelle une action pour chaque élément de la séquence observable et bloque jusqu’à ce que la séquence soit arrêtée. (Défini par observable.)
méthode d’extension publique GetEnumerator<T> Retourne un énumérateur qui énumère toutes les valeurs de la séquence observable. (Défini par observable.)
méthode d’extension publique GroupBy<T, TKey>(Func<T, TKey>) Comblé. Regroupe les éléments d’une séquence observable en fonction d’une fonction de sélecteur de clé spécifiée. (Défini par observable.)
méthode d’extension publique GroupBy<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>) Comblé. Regroupe les éléments d’une séquence observable en fonction d’une fonction de sélecteur de clé et d’un comparateur spécifiés. (Défini par observable.)
méthode d’extension publique GroupBy<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>) Comblé. Regroupe les éléments d’une séquence observable et sélectionne les éléments résultants à l’aide d’une fonction spécifiée. (Défini par observable.)
méthode d’extension publique GroupBy<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>, IEqualityComparer<TKey>) Comblé. Regroupe les éléments d’une séquence observable en fonction d’une fonction de sélecteur de clé spécifiée et comparateur et sélectionne les éléments résultants à l’aide d’une fonction spécifiée. (Défini par observable.)
méthode d’extension publique GroupByUntil<T, TKey, TDuration>(Func<T, TKey>, Func<IGroupedObservable<TKey, T>, IObservable<TDuration>>) Comblé. Regroupe les éléments d’une séquence observable en fonction d’une fonction de sélecteur de clé spécifiée. (Défini par observable.)
méthode d’extension publique GroupByUntil<T, TKey, TDuration>(Func<T, TKey>, Func<IGroupedObservable<TKey, T>, IObservable<TDuration>>, IEqualityComparer<TKey>) Comblé. Regroupe les éléments d’une séquence observable en fonction d’une fonction de sélecteur de clé et d’un comparateur spécifiés. (Défini par observable.)
méthode d’extension publique GroupByUntil<T, TKey, TElement, TDuration>(Func<T, TKey>, Func<T, TElement>, Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>>) Comblé. Regroupe les éléments d’une séquence observable en fonction d’une fonction de sélecteur de clé spécifiée et sélectionne les éléments résultants à l’aide d’une fonction spécifiée. (Défini par observable.)
méthode d’extension publique GroupByUntil<T, TKey, TElement, TDuration>(Func<T, TKey>, Func<T, TElement>, Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>>, IEqualityComparer<TKey>) Comblé. Regroupe les éléments d’une séquence observable en fonction d’une fonction de sélecteur de clé spécifiée et comparateur et sélectionne les éléments résultants à l’aide d’une fonction spécifiée. (Défini par observable.)
méthode d’extension publique GroupJoin<T, TRight, TLeftDuration, TRightDuration, TResult> Met en corrélation les éléments de deux séquences en fonction des durées qui se chevauchent et regroupe les résultats. (Défini par observable.)
méthode d’extension publique IgnoreElements<T> Ignore toutes les valeurs d’une séquence observable en laissant uniquement les messages d’arrêt. (Défini par observable.)
méthode d’extension publique Join<T, TRight, TLeftDuration, TRightDuration, TResult> Met en corrélation les éléments de deux séquences en fonction des durées qui se chevauchent. (Défini par observable.)
méthode d’extension publique dernier<T>() Comblé. Retourne le dernier élément d’une séquence observable avec une source spécifiée. (Défini par observable.)
méthode d’extension publique Dernier<T>(Func<T,>booléen ) Comblé. Retourne le dernier élément d’une séquence observable qui correspond au prédicat. (Défini par observable.)
méthode d’extension publique LastOrDefault<T>() Comblé. Retourne le dernier élément de la séquence observable ou une valeur par défaut si aucune valeur n’est trouvée. (Défini par observable.)
méthode d’extension publique LastOrDefault<T>(Func<T, Boolean>) Comblé. Retourne le dernier élément d’une séquence observable qui correspond au prédicat, ou une valeur par défaut si aucune valeur n’est trouvée. (Défini par observable.)
méthode d’extension publique dernière> T< Échantillonne la valeur la plus récente dans une séquence observable. (Défini par observable.)
méthode d’extension publique LongCount<T> Retourne un Int64 qui représente le nombre total d’éléments dans une séquence observable. (Défini par observable.)
méthode d’extension publique Matérialiser<T> Matérialise les notifications implicites d’une séquence observable en tant que valeurs de notification explicites. (Défini par observable.)
méthode d’extension publique < >() Comblé. Retourne l’élément maximal dans une séquence observable. (Défini par observable.)
méthode d’extension publique > > < < <T<>) Comblé. Retourne la valeur maximale dans une séquence observable en fonction du comparateur spécifié. (Défini par observable.)
méthode d’extension publique MaxBy<T, TKey>(Func<T, TKey>) Comblé. Retourne les éléments d’une séquence observable avec la valeur de clé maximale. (Défini par observable.)
méthode d’extension publique MaxBy<T, TKey>(Func<T, TKey>, IComparer<TKey>) Comblé. Retourne les éléments d’une séquence observable avec la valeur de clé maximale. (Défini par observable.)
méthode d’extension publique fusion<T>(IObservable<T>) Comblé. Fusionne une séquence observable de séquences observables en séquence observable. (Défini par observable.)
méthode d’extension publique fusion<T>(IObservable<T>, IScheduler) Comblé. Fusionne deux séquences observables en une seule séquence observable. (Défini par observable.)
méthode d’extension publique min<T>() Comblé. Retourne l’élément minimal dans une séquence observable. (Défini par observable.)
méthode d’extension publique min<T>(IComparer<T>) Comblé. Retourne la valeur minimale dans une séquence observable en fonction du comparateur spécifié. (Défini par observable.)
méthode d’extension publique MinBy<T, TKey>(Func<T, TKey>) Comblé. Retourne les éléments d’une séquence observable avec la valeur de clé minimale. (Défini par observable.)
méthode d’extension publique MinBy<T, TKey>(Func<T, TKey>, IComparer<TKey>) Comblé. Retourne les éléments d’une séquence observable avec la valeur de clé minimale en fonction du comparateur spécifié. (Défini par observable.)
méthode d’extension publique MostRecent<T> Échantillonne la valeur la plus récente dans une séquence observable. (Défini par observable.)
méthode d’extension publique multidiffusion<T, TResult>(ISubject<T, TResult>) Comblé. Retourne une séquence observable pouvant être connectable qui, lors de la connexion, provoque l’envoi de résultats dans l’objet spécifié. (Défini par observable.)
méthode d’extension publique multidiffusion<T, TIntermediate, TResult>(Func<ISubject<T, TIntermediate>>, Func<IObservable<TIntermediate>, IObservable<TResult>>) Comblé. Retourne une séquence observable qui contient les éléments d’une séquence produite par la multidiffusion de la séquence source dans une fonction de sélecteur. (Défini par observable.)
méthode d’extension publique <T> Échantillonne la valeur suivante (bloquant sans mise en mémoire tampon) dans une séquence observable. (Défini par observable.)
méthode d’extension publique ObserveOn<T>(SynchronizationContext) Comblé. Informez de façon asynchrone les observateurs sur le contexte de synchronisation spécifié. (Défini par observable.)
méthode d’extension publique ObserveOnT(Control) Comblé. (Défini par ControlObservable.)
méthode d’extension publique ObserveOnT(répartiteur) Comblé. (Défini par DispatcherObservable.)
méthode d’extension publique ObserveOnT(DispatcherScheduler) Comblé. (Défini par DispatcherObservable.)
méthode d’extension publique T Comblé. Informez de façon asynchrone les observateurs sur le planificateur spécifié. (Défini par observable.)
méthode d’extension publique ObserveOnDispatcher<T> (Défini par DispatcherObservable.)
méthode d’extension publique OnErrorResumeNext<T> Poursuit une séquence observable qui est terminée normalement ou par une exception avec la séquence observable suivante. (Défini par observable.)
méthode d’extension publique publier<T>() Comblé. Retourne une séquence observable pouvant être connectable qui partage un seul abonnement à la séquence sous-jacente. (Défini par observable.)
méthode d’extension publique publier<T>(T) Comblé. Retourne une séquence observable pouvant être connectable qui partage un seul abonnement à la séquence sous-jacente et commence par initialValue. (Défini par observable.)
méthode d’extension publique Publier<T, TResult>(Func<IObservable<T>, IObservable<TResult>>) Comblé. Retourne une séquence observable qui est le résultat de l’appel du sélecteur sur une séquence observable pouvant être connectable qui partage un seul abonnement à la séquence sous-jacente. (Défini par observable.)
méthode d’extension publique Publier<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, T) Comblé. Retourne une séquence observable pouvant être connectable qui partage un seul abonnement à la séquence sous-jacente et commence par initialValue. (Défini par observable.)
méthode d’extension publique publishLast<T>() Comblé. Retourne une séquence observable pouvant être connectable qui partage un seul abonnement à la séquence sous-jacente contenant uniquement la dernière notification. (Défini par observable.)
méthode d’extension publique PublishLast<T, TResult>(Func<IObservable<T>, IObservable<TResult>>) Comblé. Retourne une séquence observable qui est le résultat de l’appel du sélecteur sur une séquence observable pouvant être connectable qui partage un seul abonnement à la séquence sous-jacente contenant uniquement la dernière notification. (Défini par observable.)
méthode d’extension publique répéter<>() Comblé. Répète indéfiniment la séquence observable. (Défini par observable.)
méthode d’extension publique répéter<>(Int32) Comblé. Répète indéfiniment la séquence observable. (Défini par observable.)
méthode d’extension publique Replay<T>() Comblé. Retourne une séquence observable pouvant être connectable qui partage un seul abonnement à la séquence sous-jacente relecture de toutes les notifications. (Défini par observable.)
méthode d’extension publique ReplayT(TimeSpan) Comblé. Retourne une séquence observable pouvant être connectable qui partage un seul abonnement à la séquence sous-jacente relecture de toutes les notifications dans la fenêtre. (Défini par observable.)
méthode d’extension publique Replay<T>(Int32) Comblé. Retourne une séquence observable pouvant être connectable qui partage un seul abonnement aux notifications de relecture de séquence sous-jacentes bufferSize. (Défini par observable.)
méthode d’extension publique ReplayT(IScheduler) Comblé. Retourne une séquence observable pouvant être connectable qui partage un seul abonnement à la séquence sous-jacente relecture de toutes les notifications. (Défini par observable.)
méthode d’extension publique Replay<T>(TimeSpan, IScheduler) Comblé. Retourne une séquence observable pouvant être connectable qui partage un seul abonnement à la séquence sous-jacente relecture de toutes les notifications dans la fenêtre. (Défini par observable.)
méthode d’extension publique Replay<T>(Int32, IScheduler) Comblé. Retourne une séquence observable pouvant être connectable qui partage un seul abonnement aux notifications de relecture de séquence sous-jacentes bufferSize. (Défini par observable.)
méthode d’extension publique Replay<T>(Int32, TimeSpan) Comblé. Retourne une séquence observable pouvant être connectable qui partage un seul abonnement aux notifications de relecture de séquence sous-jacentes bufferSize dans la fenêtre. (Défini par observable.)
méthode d’extension publique Replay<T>(Int32, TimeSpan, IScheduler) Comblé. Retourne une séquence observable pouvant être connectable qui partage un seul abonnement aux notifications de relecture de séquence sous-jacentes bufferSize dans la fenêtre. (Défini par observable.)
méthode d’extension publique Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>) Comblé. Retourne une séquence observable qui est le résultat de l’appel du sélecteur sur une séquence observable pouvant être connectable qui partage un abonnement unique à la séquence sous-jacente et commence par la valeur initiale. (Défini par observable.)
méthode d’extension publique Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, IScheduler) Comblé. Retourne une séquence observable qui est le résultat de l’appel du sélecteur sur une séquence observable pouvant être connectable qui partage un seul abonnement à la séquence sous-jacente relecture de toutes les notifications. (Défini par observable.)
méthode d’extension publique Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, TimeSpan) Comblé. Retourne une séquence observable qui est le résultat de l’appel du sélecteur sur une séquence observable pouvant être connectable qui partage un seul abonnement à la séquence sous-jacente relecture de toutes les notifications dans la fenêtre. (Défini par observable.)
méthode d’extension publique Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, Int32) Comblé. Retourne une séquence observable qui est le résultat de l’appel du sélecteur sur une séquence observable connectable qui partage un abonnement unique aux notifications de relecture de séquence sous-jacentes. (Défini par observable.)
méthode d’extension publique Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, TimeSpan, IScheduler) Comblé. Retourne une séquence observable qui est le résultat de l’appel du sélecteur sur une séquence observable pouvant être connectable qui partage un seul abonnement à la séquence sous-jacente relecture de toutes les notifications dans la fenêtre. (Défini par observable.)
méthode d’extension publique Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, Int32, IScheduler) Comblé. Retourne une séquence observable qui est le résultat de l’appel du sélecteur sur une séquence observable connectable qui partage un abonnement unique aux notifications de relecture de séquence sous-jacentes. (Défini par observable.)
méthode d’extension publique Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, Int32, TimeSpan) Comblé. Retourne une séquence observable qui est le résultat de l’appel du sélecteur sur une séquence observable pouvant être connectable qui partage un seul abonnement aux notifications de relecture de séquence sous-jacentes bufferSize dans la fenêtre. (Défini par observable.)
méthode d’extension publique Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, Int32, TimeSpan, IScheduler) Comblé. Retourne une séquence observable qui est le résultat de l’appel du sélecteur sur une séquence observable pouvant être connectable qui partage un seul abonnement aux notifications de relecture de séquence sous-jacentes bufferSize dans la fenêtre. (Défini par observable.)
méthode d’extension publique réessayer<T>() Comblé. Répète la séquence observable source jusqu’à ce qu’elle se termine correctement. (Défini par observable.)
méthode d’extension publique réessayer<>(Int32) Comblé. Répète la séquence observable source jusqu’à ce qu’elle se termine correctement. (Défini par observable.)
méthode d’extension publique exemple de<T>(TimeSpan) Comblé. Échantillonne la séquence observable à chaque intervalle. (Défini par observable.)
méthode d’extension publique exemple<>T (TimeSpan, IScheduler) Comblé. Échantillonne la séquence observable à chaque intervalle avec la source, l’intervalle et le planificateur spécifiés. (Défini par observable.)
méthode d’extension publique exemple<T, TSample>(IObservable<TSample>) Comblé. Échantillonne la séquence observable aux cycles d’échantillonnage avec la source et l’échantillonneur spécifiés. (Défini par observable.)
méthode d’extension publique Scan<T>(Func<T, T, T>) Comblé. Applique une fonction d’accumulation sur une séquence observable et retourne chaque résultat intermédiaire avec la source et l’accumulation spécifiées. (Défini par observable.)
méthode d’extension publique Scan<T, TAccumulate>(TAccumulate, Func<TAccumulate, TAccumulate>) Comblé. Applique une fonction d’accumulation sur une séquence observable et retourne chaque résultat intermédiaire avec la source, la valeur initiale et l’accumulation spécifiées. (Défini par observable.)
méthode d’extension publique Sélectionner<T, TResult>(Func<T, TResult>) Comblé. Projette chaque élément d’une séquence observable dans un nouveau formulaire avec la source et le sélecteur spécifiés. (Défini par observable.)
méthode d’extension publique Sélectionner<T, TResult>(Func<T, Int32, TResult>) Comblé. Projette chaque élément d’une séquence observable dans un nouveau formulaire en incorporant l’index de l’élément avec la source et le sélecteur spécifiés. (Défini par observable.)
méthode d’extension publique SelectMany<T, TOther>(IObservable<TOther>) Comblé. Projette chaque élément d’une séquence observable vers une séquence observable et aplatit les séquences observables résultantes en une séquence observable. (Défini par observable.)
méthode d’extension publique SelectMany<T, TResult>(Func<T, IObservable<TResult>>) Comblé. Projette chaque élément d’une séquence observable vers une séquence observable et aplatit les séquences observables résultantes en une séquence observable. (Défini par observable.)
méthode d’extension publique SelectMany<T, TResult>(Func<T, IEnumerable<TResult>>) Comblé. Projette chaque élément d’une séquence observable vers une séquence observable et aplatit les séquences observables résultantes en une séquence observable. (Défini par observable.)
méthode d’extension publique SelectMany<T, TResult>(Func<T, IObservable<TResult>>, Exception Func<, IObservable<TResult>>, Func<IObservable<TResult>>) Comblé. Projette chaque élément d’une séquence observable vers une séquence observable et aplatit les séquences observables résultantes en une séquence observable. (Défini par observable.)
méthode d’extension publique SelectMany<T, TCollection, TResult>(Func<T, IEnumerable<TCollection>>, Func<T, TCollection, TResult>) Comblé. Projette chaque élément d’une séquence observable vers une séquence observable et aplatit les séquences observables résultantes en une séquence observable. (Défini par observable.)
méthode d’extension publique SelectMany<T, TCollection, TResult>(Func<T, IObservable<TCollection>>, Func<T, TCollection, TResult>) Comblé. Projette chaque élément d’une séquence observable vers une séquence observable et aplatit les séquences observables résultantes en une séquence observable. (Défini par observable.)
méthode d’extension publique SequenceEqual<T>(IObservable<T>) Comblé. Détermine si deux séquences sont égales en comparant les éléments par paire. (Défini par observable.)
méthode d’extension publique SequenceEqual<T>(IObservable<T>, IEqualityComparer<T>) Comblé. Détermine si deux séquences sont égales en comparant les éléments par paire à l’aide d’un comparateur d’égalité spécifié. (Défini par observable.)
méthode d’extension publique TT Comblé. Retourne le seul élément d’une séquence observable et lève une exception s’il n’y a pas exactement un élément dans la séquence observable. (Défini par observable.)
méthode d’extension publique >T<unique (Func<T,>booléen ) Comblé. Retourne le seul élément d’une séquence observable qui correspond au prédicat et lève une exception s’il n’y a pas exactement un élément dans la séquence observable. (Défini par observable.)
méthode d’extension publique singleOrDefault<T>() Comblé. Retourne le seul élément d’une séquence observable ou une valeur par défaut si la séquence observable est vide. (Défini par observable.)
méthode d’extension publique SingleOrDefault<T>(Func<T, Boolean>) Comblé. Retourne le seul élément d’une séquence observable qui correspond au prédicat, ou une valeur par défaut si aucune valeur n’est trouvée. (Défini par observable.)
méthode d’extension publique Ignorer<T> Contourne un nombre spécifié de valeurs dans une séquence observable, puis retourne les valeurs restantes. (Défini par observable.)
méthode d’extension publique SkipLast<T> Contourne un nombre spécifié d’éléments à la fin d’une séquence observable. (Défini par observable.)
méthode d’extension publique SkipUntil<T, TOther> Retourne les valeurs de la séquence observable source uniquement après que l’autre séquence observable produit une valeur. (Défini par observable.)
méthode d’extension publique SkipWhile<T>(Func<T, Boolean>) Comblé. Contourne les valeurs d’une séquence observable tant qu’une condition spécifiée est true, puis retourne les valeurs restantes. (Défini par observable.)
méthode d’extension publique SkipWhile<T>(Func<T, Int32, Boolean>) Comblé. Contourne les valeurs d’une séquence observable tant qu’une condition spécifiée est true, puis retourne les valeurs restantes. (Défini par observable.)
méthode d’extension publique startWith<T>T[]) Comblé. Ajoute une séquence de valeurs à une séquence observable avec la source et les valeurs spécifiées. (Défini par observable.)
méthode d’extension publique startWith<T>(IScheduler, T[]) Comblé. Ajoute une séquence de valeurs à une séquence observable avec la source, le planificateur et les valeurs spécifiés. (Défini par observable.)
méthode d’extension publique s’abonner<T>() Comblé. Évalue la séquence observable avec une source spécifiée. (Défini par ObservableExtensions.)
méthode d’extension publique s’abonner<T>(Action<T>) Comblé. Abonne un gestionnaire d’éléments à une séquence observable. (Défini par ObservableExtensions.)
méthode d’extension publique s’abonner<T>(action<T>, action<exception>) Comblé. Abonne un gestionnaire d’éléments et un gestionnaire d’exceptions à une séquence observable. (Défini par ObservableExtensions.)
méthode d’extension publique s’abonner<T>(Action<T>, Action) Comblé. Abonne un gestionnaire d’éléments et un gestionnaire d’achèvement à une séquence observable. (Défini par ObservableExtensions.)
méthode d’extension publique S’abonner<T>(action<T>,<exception d’action>, action) Comblé. Abonne un gestionnaire d’éléments, un gestionnaire d’exceptions et un gestionnaire d’achèvement à une séquence observable. (Défini par ObservableExtensions.)
méthode d’extension publique subscribeOn<T>(SynchronizationContext) Comblé. S’abonne de façon asynchrone et désactive les observateurs dans le contexte de synchronisation spécifié. (Défini par observable.)
méthode d’extension publique subscribeOn<T>(Contrôle) Comblé. (Défini par ControlObservable.)
méthode d’extension publique subscribeOn<T>(répartiteur) Comblé. (Défini par DispatcherObservable.)
méthode d’extension publique SubscribeOn<T>(DispatcherScheduler) Comblé. (Défini par DispatcherObservable.)
méthode d’extension publique SubscribeOn<T>(IScheduler) Comblé. S’abonne de façon asynchrone et désactive les observateurs sur le planificateur spécifié. (Défini par observable.)
méthode d’extension publique SubscribeOnDispatcher<T> (Défini par DispatcherObservable.)
méthode d’extension publique Synchroniser<>() Comblé. Synchronise la séquence observable. (Défini par observable.)
méthode d’extension publique synchroniser<>(objet) Comblé. Synchronise la séquence observable. (Défini par observable.)
méthode d’extension publique Prendre<T> Retourne un nombre spécifié de valeurs contiguës à partir du début d’une séquence observable. (Défini par observable.)
méthode d’extension publique TakeLast<T> Retourne un nombre spécifié d’éléments contigus à partir de la fin d’une séquence observable. (Défini par observable.)
méthode d’extension publique TakeUntil<T, TOther> Retourne les valeurs de la séquence observable source jusqu’à ce que l’autre séquence observable produise une valeur. (Défini par observable.)
méthode d’extension publique TakeWhile<T>(Func<T,>booléen ) Comblé. Retourne des valeurs d’une séquence observable tant qu’une condition spécifiée est vraie, puis ignore les valeurs restantes. (Défini par observable.)
méthode d’extension publique TakeWhile<T>(Func<T, Int32, Boolean>) Comblé. Retourne des valeurs d’une séquence observable tant qu’une condition spécifiée est vraie, puis ignore les valeurs restantes. (Défini par observable.)
méthode d’extension publique Ensuite<T, TResult> Correspond lorsque la séquence observable a une valeur disponible et projette la valeur. (Défini par observable.)
méthode d’extension publique limitation<T>(TimeSpan) Comblé. Ignore les valeurs d’une séquence observable qui sont suivies d’une autre valeur avant l’heure d’échéance avec la source spécifiée et dueTime. (Défini par observable.)
méthode d’extension publique Limitation<T>(TimeSpan, IScheduler) Comblé. Ignore les valeurs d’une séquence observable suivie d’une autre valeur avant l’heure d’échéance avec la source, dueTime et le planificateur spécifiés. (Défini par observable.)
méthode d’extension publique timeInterval<T>() Comblé. Enregistre l’intervalle de temps entre les valeurs consécutives dans une séquence observable avec la source spécifiée. (Défini par observable.)
méthode d’extension publique TimeIntervalT(IScheduler) Comblé. Enregistre l’intervalle de temps entre les valeurs consécutives dans une séquence observable avec la source et le planificateur spécifiés. (Défini par observable.)
méthode d’extension publique délai d’expiration<T>(TimeSpan) Comblé. Retourne la séquence observable ou une exception TimeoutException si dueTime s’est écoulé. (Défini par observable.)
méthode d’extension publique délai d’expiration<T>(DateTimeOffset) Comblé. Retourne la séquence observable ou une exception TimeoutException si dueTime s’est écoulé. (Défini par observable.)
méthode d’extension publique délai d’expiration<T>(TimeSpan, IObservable<T>) Comblé. Retourne la séquence observable source ou l’autre séquence observable si dueTime s’écoule. (Défini par observable.)
méthode d’extension publique délai d’expiration<T>(DateTimeOffset, IObservable<T>) Comblé. Retourne la séquence observable ou une exception TimeoutException si dueTime s’est écoulé. (Défini par observable.)
méthode d’extension publique délai d’expiration<T>(TimeSpan, IScheduler) Comblé. Retourne la séquence observable ou une exception TimeoutException si dueTime s’est écoulé. (Défini par observable.)
méthode d’extension publique timeout<T>(DateTimeOffset, IScheduler) Comblé. Retourne la séquence observable ou une exception TimeoutException si dueTime s’est écoulé. (Défini par observable.)
méthode d’extension publique délai d’expiration<T>(TimeSpan, IObservable<T>, IScheduler) Comblé. Retourne la séquence observable source ou l’autre séquence observable si dueTime s’écoule. (Défini par observable.)
méthode d’extension publique délai d’expiration<T>(DateTimeOffset, IObservable<T>, IScheduler) Comblé. Retourne la séquence observable source ou l’autre séquence observable si dueTime s’écoule. (Défini par observable.)
méthode d’extension publique timestamp<T>() Comblé. Enregistre l’horodatage pour chaque valeur dans une séquence observable avec la source spécifiée. (Défini par observable.)
méthode d’extension publique timestamp<T>(IScheduler) Comblé. Enregistre l’horodatage pour chaque valeur dans une séquence observable avec la source et le planificateur spécifiés. (Défini par observable.)
méthode d’extension publique ToArray<T> Crée un tableau à partir d’une séquence observable. (Défini par observable.)
méthode d’extension publique ToDictionary<T, TKey>(Func<T, TKey>) Comblé. Crée un dictionnaire à partir d’une séquence observable en fonction d’une fonction de sélecteur de clé spécifiée. (Défini par observable.)
méthode d’extension publique ToDictionary<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>) Comblé. Crée un dictionnaire à partir d’une séquence observable en fonction d’une fonction de sélecteur de clé spécifiée et d’un comparateur. (Défini par observable.)
méthode d’extension publique ToDictionary<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>) Comblé. Crée un dictionnaire à partir d’une séquence observable en fonction d’une fonction de sélecteur de clé spécifiée et d’une fonction de sélecteur d’élément. (Défini par observable.)
méthode d’extension publique ToDictionary<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>, IEqualityComparer<TKey>) Comblé. Crée un dictionnaire à partir d’une séquence observable en fonction d’une fonction de sélecteur de clé spécifiée, d’un comparateur et d’une fonction de sélecteur d’élément. (Défini par observable.)
méthode d’extension publique ToEnumerable<T> Convertit une séquence observable en séquence énumérable. (Défini par observable.)
méthode d’extension publique ToEvent<T> Expose une séquence observable en tant qu’objet avec un événement .NET avec une source spécifiée. (Défini par observable.)
méthode d’extension publique ToList<T> Crée une liste à partir d’une séquence observable. (Défini par observable.)
méthode d’extension publique ToLookup<T, TKey>(Func<T, TKey>) Comblé. Crée une recherche à partir d’une séquence observable en fonction d’une fonction de sélecteur de clé spécifiée. (Défini par observable.)
méthode d’extension publique ToLookup<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>) Comblé. Crée une recherche à partir d’une séquence observable en fonction d’une fonction de sélecteur de clé spécifiée et d’un comparateur. (Défini par observable.)
méthode d’extension publique ToLookup<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>) Comblé. Crée une recherche à partir d’une séquence observable en fonction d’une fonction de sélecteur de clé spécifiée et d’une fonction de sélecteur d’élément. (Défini par observable.)
méthode d’extension publique ToLookup<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>, IEqualityComparer<TKey>) Comblé. Crée une recherche à partir d’une séquence observable en fonction d’une fonction de sélecteur de clé spécifiée, d’un comparateur et d’une fonction de sélecteur d’élément. (Défini par observable.)
méthode d’extension publique ToNotifier<T> Crée un rappel de notification à partir d’un observateur. (Défini par Observer.)
méthode d’extension publique ToTask<T>() Comblé. Retourne une tâche qui contient la dernière valeur de la séquence observable. (Défini par TaskObservableExtensions.)
méthode d’extension publique ToTask<T>(Object) Comblé. Retourne une tâche qui contient la dernière valeur de la séquence observable. (Défini par TaskObservableExtensions.)
méthode d’extension publique ToTask<T>(CancellationToken) Comblé. Retourne une tâche qui contient la dernière valeur de la séquence observable. (Défini par TaskObservableExtensions.)
méthode d’extension publique ToTask<T>(CancellationToken, Object) Comblé. Retourne une tâche qui contient la dernière valeur de la séquence observable. (Défini par TaskObservableExtensions.)
méthode d’extension publique Where<T>(Func<T, Boolean>) Comblé. Filtre les éléments d’une séquence observable en fonction d’un prédicat. (Défini par observable.)
méthode d’extension publique Where<T>(Func<T, Int32, Boolean>) Comblé. Filtre les éléments d’une séquence observable en fonction d’un prédicat en incorporant l’index de l’élément. (Défini par observable.)
méthode d’extension publique fenêtre<T>(Int32) Comblé. Projette chaque élément d’une séquence observable dans des fenêtres qui ne se chevauchent pas consécutivement, qui sont produites en fonction des informations sur le nombre d’éléments. (Défini par observable.)
méthode d’extension publique fenêtre<T>(TimeSpan) Comblé. Projette chaque élément d’une séquence observable en fenêtres consécutives qui ne se chevauchent pas, qui sont produites en fonction des informations de minutage. (Défini par observable.)
méthode d’extension publique fenêtre<T>(Int32, Int32) Comblé. Projette chaque élément d’une séquence observable en zéro ou plusieurs fenêtres produites en fonction des informations de nombre d’éléments. (Défini par observable.)
méthode d’extension publique WindowT(TimeSpan, IScheduler) Comblé. Projette chaque élément d’une séquence observable en fenêtres consécutives qui ne se chevauchent pas, qui sont produites en fonction des informations de minutage. (Défini par observable.)
méthode d’extension publique < >T (TimeSpan, TimeSpan) Comblé. Projette chaque élément d’une séquence observable en zéro ou plusieurs fenêtres produites en fonction des informations de minutage. (Défini par observable.)
méthode d’extension publique fenêtreT (TimeSpan, Int32) Comblé. Projette chaque élément d’une séquence observable dans une fenêtre terminée lorsqu’il est plein ou qu’un certain temps s’est écoulé. (Défini par observable.)
méthode d’extension publique fenêtre<T>(TimeSpan, TimeSpan, IScheduler) Comblé. Projette chaque élément d’une séquence observable en zéro ou plusieurs fenêtres produites en fonction des informations de minutage. (Défini par observable.)
méthode d’extension publique >T<(TimeSpan, Int32, IScheduler) Comblé. Projette chaque élément d’une séquence observable dans une fenêtre terminée lorsqu’il est plein ou qu’un certain temps s’est écoulé. (Défini par observable.)
méthode d’extension publique Window<T, TWindowClosing>(Func<IObservable<TWindowClosing>>) Comblé. Projette chaque élément d’une séquence observable en fenêtres qui ne se chevauchent pas consécutivement. (Défini par observable.)
méthode d’extension publique Window<T, TWindowOpening, TWindowClosing>(IObservable<TWindowOpening>, Func<TWindowOpening, IObservable<TWindowClosing>>) Comblé. Projette chaque élément d’une séquence observable en zéro ou plusieurs fenêtres. (Défini par observable.)
méthode d’extension publique Zip<T, TSecond, TResult>(IObservable<TSecond>, Func<T, TSecond, TResult>) Comblé. Fusionne deux séquences observables en une séquence observable en combinant leurs éléments de manière pair. (Défini par observable.)
méthode d’extension publique Zip<T, TSecond, TResult>(IEnumerable<TSecond>, Func<T, TSecond, TResult>) Comblé. Fusionne une séquence observable et une séquence énumérable en une séquence observable à l’aide de la fonction sélecteur. (Défini par observable.)

Retour au début

Remarques

Un objet agit comme un proxy dans lequel il agit à la fois en tant qu’abonné et éditeur. Son interface IObserver peut être utilisée pour s’abonner à plusieurs flux ou séquences de données. Les données sont ensuite publiées via l’interface IObservable.

Un BehaviorSubject met en mémoire tampon le dernier élément qu’il a publié via son interface IObservable. Si aucun élément n’a été publié via son interface IObservable, l’élément initial fourni dans le constructeur est l’élément actuellement mis en mémoire tampon. Lorsqu’un abonnement est effectué à l’interface IObservable de BehaviorSubject, la séquence publiée commence par l’élément actuellement mis en mémoire tampon.

Aucun élément n’est mis en mémoire tampon ou publié à partir d’un BehaviorSubject une fois que son interface IObserver reçoit une fin.

Exemples

Cet exemple illustre l’objet BehaviorSubject. L’exemple utilise l’opérateur Interval pour publier un entier dans une séquence d’entiers toutes les secondes. La séquence est terminée par l’opérateur Take après la publication de 10 entiers. Il s’agit de la séquence à laquelle l’objet BehaviorSubject s’abonne.

Deux abonnements sont créés pour l’interface IObservable de BehaviorSubject pour montrer comment il publie ses données.

  • Abonnement #1 : cet abonnement démarre au début et affiche la valeur initiale mise en mémoire tampon du constructeur (-9) dans la séquence.

  • Abonnement #2 : cet abonnement démarre après une veille de 5 secondes. Cet abonnement indique que la séquence commence par l’élément actuellement mis en mémoire tampon.

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.                                   ***//
      //***                                                                                                  ***//
      //*** A BehaviorSubject buffers the last item it published through its IObservable interface. If no    ***//
      //*** item has been published through its IObservable interface then the initial item provided in the  ***//
      //*** constructor is the current buffered item. When a subscription is made to the BehaviorSubject's   ***//
      //*** IObservable interface, the sequence published begins with the currently buffered item.           ***//
      //***                                                                                                  ***//
      //*** No items are buffered or published from a BehaviorSubject once its IObserver interface receives  ***//
      //*** a completion.                                                                                    ***//
      //***                                                                                                  ***//
      //*** In this example, we use the Interval operator to publish an integer to a integer sequence every  ***//
      //*** second. The sequence will be completed by the Take operator after 10 integers are published.     ***//
      //*** This will be the sequence that the BehaviorSubject subscribes to.                                ***//
      //***                                                                                                  ***//
      //*** We will create 2 subscriptions to the BehaviorSubject's IObservable interface to show how it     ***//
      //*** publishes it's data.                                                                             ***//
      //***                                                                                                  ***//
      //*** Subscription #1 : This subscription will start at the very beginning and will show the initial   ***//
      //***                   buffered value from the constructor (-9) in the sequence.                      ***//
      //***                                                                                                  ***//
      //*** Subscription #2 : This subscription will start after a 5 sec. sleep showing the sequence starts  ***//
      //***                   with the currently buffered item.                                              ***//
      //********************************************************************************************************//

      BehaviorSubject<long> myBehaviorSubject = new BehaviorSubject<long>((-9));
      Observable.Interval(TimeSpan.FromSeconds(1), Scheduler.ThreadPool).Take(10).Subscribe(myBehaviorSubject);

      
      //********************************************************************************************************//
      //*** Subscription #1 : This subscription will start at the very beginning and will show the initial   ***//
      //***                   buffered value from the constructor (-9) in the sequence.                      ***//
      //********************************************************************************************************//

      EventWaitHandle wait1 = new EventWaitHandle(false, EventResetMode.ManualReset);
      myBehaviorSubject.Subscribe(x => Console.WriteLine("Subscription #1 observes : " + x),
                                  () => 
                                  {
                                    Console.WriteLine("Subscription #1 completed.");
                                    wait1.Set();
                                  });


      //********************************************************************************************************//
      //*** Subscription #2 : This subscription will start after a 5 sec. sleep showing the sequence starts  ***//
      //***                   with the currently buffered item.                                              ***//
      //********************************************************************************************************//
    
      Thread.Sleep(5000);
      EventWaitHandle wait2 = new EventWaitHandle(false, EventResetMode.ManualReset);
      myBehaviorSubject.Subscribe(x => Console.WriteLine("{0,30}Subscription #2 observes : {1}", " ", x), 
                                  () => 
                                  {
                                    Console.WriteLine("{0,30}Subscription #2 completed.", " ");
                                    wait2.Set();
                                  });


      //**************************************************//
      // *** Wait for completion on both subscriptions ***//
      //**************************************************//

      WaitHandle.WaitAll(new WaitHandle[] { wait1, wait2 });
      myBehaviorSubject.Dispose();

      Console.WriteLine("\nPress ENTER to exit...");
      Console.ReadLine();
    }
  }
}

La sortie suivante de l’exemple de code montre les abonnements qui se chevauchent.

Subscription #1 observes : -9
Subscription #1 observes : 0
Subscription #1 observes : 1
Subscription #1 observes : 2
Subscription #1 observes : 3
Subscription #1 observes : 4
                              Subscription #2 observes : 4
Subscription #1 observes : 5
                              Subscription #2 observes : 5
Subscription #1 observes : 6
                              Subscription #2 observes : 6
Subscription #1 observes : 7
                              Subscription #2 observes : 7
Subscription #1 observes : 8
                              Subscription #2 observes : 8
Subscription #1 observes : 9
                              Subscription #2 observes : 9
Subscription #1 completed.
                              Subscription #2 completed.

Press ENTER to exit...

Sécurité des threads

Tous les membres statiques publics (partagés en Visual Basic) de ce type sont thread-safe. Tous les membres d’instance ne sont pas garantis pour être thread-safe.

Voir aussi

Référence

espace de noms System.React.Subjects