Partager via


ReplaySubject<classe T>

Représente un objet qui est à la fois une séquence observable ainsi qu’un observateur.

Hiérarchie d’héritage

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

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

Syntaxe

'Declaration
Public NotInheritable Class ReplaySubject(Of T) _
    Implements ISubject(Of T), ISubject(Of T, T),  _
    IObserver(Of T), IObservable(Of T), IDisposable
'Usage
Dim instance As ReplaySubject(Of T)
public sealed class ReplaySubject<T> : ISubject<T>, 
    ISubject<T, T>, IObserver<T>, IObservable<T>, IDisposable
generic<typename T>
public ref class ReplaySubject sealed : ISubject<T>, 
    ISubject<T, T>, IObserver<T>, IObservable<T>, IDisposable
[<SealedAttribute>]
type ReplaySubject<'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 replaySubject<T> expose les membres suivants.

Constructeurs

  Nom Description
méthode publique ReplaySubject<T>() Crée un objet relecture.
méthode publique ReplaySubject<T>(Int32) Initialise une nouvelle instance de la classe ReplaySubject<T> avec la taille de mémoire tampon spécifiée.
méthode publique ReplaySubject<T>(TimeSpan) Initialise une nouvelle instance de la classe ReplaySubject<T> avec la fenêtre spécifiée.
méthode publique ReplaySubject<T>(IScheduler) Initialise une nouvelle instance de la classe ReplaySubject<T> avec le planificateur spécifié.
méthode publique ReplaySubject<T>(Int32, IScheduler) Initialise une nouvelle instance de la classe ReplaySubject<T> avec la taille de mémoire tampon et le planificateur spécifiés.
méthode publique ReplaySubject<T>(Int32, TimeSpan) Initialise une nouvelle instance de la classe ReplaySubject<T> avec la taille et la fenêtre de mémoire tampon spécifiées.
méthode publique ReplaySubject<T>(TimeSpan, IScheduler) Initialise une nouvelle instance de la classe ReplaySubject<T> avec la fenêtre et le planificateur spécifiés.
méthode publique ReplaySubject<T>(Int32, TimeSpan, IScheduler) Initialise une nouvelle instance de la classe ReplaySubject<T> avec la taille de mémoire tampon, la fenêtre et le planificateur spécifiés.

Retour au début

Méthode

  Nom Description
méthode publique Supprimer Libère toutes les ressources utilisées par l’instance actuelle de ReplaySubject<T> classe et désinscrit tous les observateurs.
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 séquences observables de données. Les données sont ensuite publiées via l’interface IObservable de l’objet.

Un tampon ReplaySubject met en mémoire tampon les éléments qu’il reçoit. Par conséquent, un abonnement créé ultérieurement peut accéder à des éléments à partir de la séquence mise en mémoire tampon, même s’ils ont déjà été publiés. Le nombre d’éléments qu’un replaySubject met en mémoire tampon dépend des paramètres passés au constructeur.

Les sujets réguliers synchronisent les appels sortants aux observateurs sous-récriés à l’aide d’un planificateur.

Exemples

Dans cet exemple, nous avons créé une classe NewsHeadlineFeed qui n’est qu’un flux d’actualités fictif sous la forme d’une séquence observable de chaînes. Il utilise l’opérateur Generate pour générer en continu un titre d’actualité aléatoire en trois secondes.

Un ReplaySubject est créé pour s’abonner à deux flux d’actualités de la classe NewsHeadlineFeed. Avant que l’objet soit abonné aux flux, l’opérateur Timestamp est utilisé pour horodatage chaque titre. Ainsi, la séquence à laquelle replaySubject s’abonne réellement est de type IObservable<timestamped<chaîne>>. Avec l’horodatage de la séquence de titres, les abonnés peuvent s’abonner à l’interface observable du sujet pour observer le ou les flux de données ou un sous-ensemble du ou des flux en fonction de l’horodatage.

Un tampon ReplaySubject met en mémoire tampon les éléments qu’il reçoit. Ainsi, un abonnement créé ultérieurement peut accéder aux éléments de la séquence qui ont déjà été mis en mémoire tampon et publiées. Un abonnement est créé à l’objet ReplaySubject qui reçoit uniquement les titres d’actualités locales qui se sont produits 10 secondes avant la création de l’abonnement aux actualités locales. Nous avons donc essentiellement la relecture « relecture » de ReplaySubject ce qui s’est passé 10 secondes plus tôt.

Un titre d’actualité local contient simplement la sous-chaîne newsLocation (« dans votre région »).

using System;
using System.Reactive;
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 a simple ReplaySubject is used to subscribe to multiple news feeds            ***//
      //*** that provide random news headlines. Before the subject is subscribed to the feeds, we use     ***//
      //*** Timestamp operator to timestamp each headline. Subscribers can then subscribe to the subject  ***//
      //*** observable interface to observe the data stream(s) or a subset of the stream(s) based on      ***//
      //*** time.                                                                                         ***//
      //***                                                                                               ***//
      //*** A ReplaySubject buffers items it receives. So a subscription created at a later time can      ***//
      //*** access items from the sequence which have already been published.                             ***//
      //***                                                                                               ***//
      //*** A subscriptions is created to the ReplaySubject that receives only local news headlines which ***//
      //*** occurred 10 seconds before the local news subscription was created. So we basically have the  ***//
      //*** ReplaySubject "replay" what happened 10 seconds earlier.                                      ***//
      //***                                                                                               ***//
      //*** A local news headline just contains the newsLocation substring ("in your area.").             ***//
      //***                                                                                               ***//
      //*****************************************************************************************************//

      ReplaySubject<Timestamped<string>> myReplaySubject = new ReplaySubject<Timestamped<String>>();


      //*****************************************************************//
      //*** Create news feed #1 and subscribe the ReplaySubject to it ***//
      //*****************************************************************//

      NewsHeadlineFeed NewsFeed1 = new NewsHeadlineFeed("Headline News Feed #1");
      NewsFeed1.HeadlineFeed.Timestamp().Subscribe(myReplaySubject);


      //*****************************************************************//
      //*** Create news feed #2 and subscribe the ReplaySubject to it ***//
      //*****************************************************************//

      NewsHeadlineFeed NewsFeed2 = new NewsHeadlineFeed("Headline News Feed #2");
      NewsFeed2.HeadlineFeed.Timestamp().Subscribe(myReplaySubject);


      //*****************************************************************************************************//
      //*** Create a subscription to the subject's observable sequence. This subscription will filter for ***//
      //*** only local headlines that occurred 10 seconds before the subscription was created.            ***//
      //***                                                                                               ***//
      //*** Since we are using a ReplaySubject with timestamped headlines, we can subscribe to the        ***//
      //*** headlines already past. The ReplaySubject will "replay" them for the localNewSubscription     ***//
      //*** from its buffered sequence of headlines.                                                      ***//
      //*****************************************************************************************************//

      Console.WriteLine("Waiting for 10 seconds before subscribing to local news headline feed.\n");
      Thread.Sleep(10000);

      Console.WriteLine("\n*** Creating local news headline subscription at {0} ***\n", DateTime.Now.ToString());
      Console.WriteLine("This subscription asks the ReplaySubject for the buffered headlines that\n" +
                        "occurred within the last 10 seconds.\n\nPress ENTER to exit.", DateTime.Now.ToString());

      DateTime lastestHeadlineTime = DateTime.Now;
      DateTime earliestHeadlineTime = lastestHeadlineTime - TimeSpan.FromSeconds(10);     
      
      IDisposable localNewsSubscription = myReplaySubject.Where(x => x.Value.Contains("in your area.") &&
                                                               (x.Timestamp >= earliestHeadlineTime) &&
                                                               (x.Timestamp < lastestHeadlineTime)).Subscribe(x =>
      {
        Console.WriteLine("\n************************************\n" +
                          "***[ Local news headline report ]***\n" +
                          "************************************\n" + 
                          "Time         : {0}\n{1}\n\n", x.Timestamp.ToString(), x.Value);
      });

      Console.ReadLine();


      //*******************************//
      //*** Cancel the subscription ***//
      //*******************************//

      localNewsSubscription.Dispose();
      

      //*************************************************************************//
      //*** Unsubscribe all the ReplaySubject's observers and free resources. ***//
      //*************************************************************************//

      myReplaySubject.Dispose();    
    }
  }



  //*********************************************************************************//
  //***                                                                           ***//
  //*** The NewsHeadlineFeed class is just a mock news feed in the form of an     ***//
  //*** observable sequence in Reactive Extensions.                               ***//
  //***                                                                           ***//
  //*********************************************************************************//
  class NewsHeadlineFeed
  {
    private string feedName;                     // Feedname used to label the stream
    private IObservable<string> headlineFeed;    // The actual data stream
    private readonly Random rand = new Random(); // Used to stream random headlines.


    //*** A list of predefined news events to combine with a simple location string ***//
    static readonly string[] newsEvents = { "A tornado occurred ",
                                            "Weather watch for snow storm issued ",
                                            "A robbery occurred ",
                                            "We have a lottery winner ",
                                            "An earthquake occurred ",
                                            "Severe automobile accident "};

    //*** A list of predefined location strings to combine with a news event. ***//
    static readonly string[] newsLocations = { "in your area.",
                                               "in Dallas, Texas.",
                                               "somewhere in Iraq.",
                                               "Lincolnton, North Carolina",
                                               "Redmond, Washington"};

    public IObservable<string> HeadlineFeed
    {
      get { return headlineFeed; }
    }

    public NewsHeadlineFeed(string name)
    {
      feedName = name;

      //*****************************************************************************************//
      //*** Using the Generate operator to generate a continous stream of headline that occur ***//
      //*** randomly within 5 seconds.                                                        ***//
      //*****************************************************************************************//
      headlineFeed = Observable.Generate(RandNewsEvent(),
                                         evt => true,
                                         evt => RandNewsEvent(),
                                         evt => { Thread.Sleep(rand.Next(3000)); return evt; },
                                         Scheduler.ThreadPool);
    }


    //****************************************************************//
    //*** Some very simple formatting of the headline event string ***//
    //****************************************************************//
    private string RandNewsEvent()
    {
      return "Feedname     : " + feedName + "\nHeadline     : " + newsEvents[rand.Next(newsEvents.Length)] +
             newsLocations[rand.Next(newsLocations.Length)];
    }
  }
}

La sortie suivante a été générée avec l’exemple de code. Les nouveaux flux sont aléatoires, il est donc possible que vous deviez l’exécuter plusieurs fois pour voir un titre d’actualité local.

Waiting for 10 seconds before subscribing to local news headline feed.

** Création d’un abonnement aux actualités locales au 9/09/2011 4:07:48 **

This subscription asks the ReplaySubject for the buffered headlines that
occurred within the last 10 seconds.

Press ENTER to exit.

********************************** [ Rapport des actualités locales ]********************************** Heure : 5/9/2011 4:07:42 AM -04:00 Feedname : Flux d’actualités du titre #2 Titre : Nous avons un gagnant de loterie dans votre région.

********************************** [ Rapport des actualités locales ]********************************** Heure : 5/9/2011 4:07:47:47 -04:00 Feedname : Flux d’actualités du titre #1 Titre : Veille météorologique pour la tempête de neige émise dans votre région.

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