Objet<classe T>

Article
06/28/2011

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.Subject.Subject<T>

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

Syntaxe

'Declaration
Public NotInheritable Class Subject(Of T) _
    Implements ISubject(Of T), ISubject(Of T, T),  _
    IObserver(Of T), IObservable(Of T), IDisposable

'Usage
Dim instance As Subject(Of T)

public sealed class Subject<T> : ISubject<T>, 
    ISubject<T, T>, IObserver<T>, IObservable<T>, IDisposable

generic<typename T>
public ref class Subject sealed : ISubject<T>, 
    ISubject<T, T>, IObserver<T>, IObservable<T>, IDisposable

[<SealedAttribute>]
type Subject<'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 objet<T> expose les membres suivants.

Constructeurs

	Nom	Description
	objet<T>	Initialise une nouvelle instance de la classe Subject<T>.

Retour au début

Méthode

	Nom	Description
	Supprimer	Libère toutes les ressources utilisées par l’instance actuelle de l’objet<classe T> et désinscrit tous les observateurs
	Equals	(Hérité de l’objet .)
méthode protégée	finaliser	(Hérité de l’objet .)
	GetHashCode	(Hérité de l’objet .)
	GetType	(Hérité de l’objet .)
méthode protégée	MemberwiseClone	(Hérité de l’objet .)
	onCompleted	Avertit tous les observateurs abonnés de la fin de la séquence.
	OnError	Notifie tous les observateurs abonnés à l’exception.
	OnNext	Notifie tous les observateurs abonnés avec la valeur.
	s’abonner	Abonne un observateur au sujet.
	ToString	(Hérité de l’objet .)

Retour au début

Méthodes d’extension

	Nom	Description
	<T>(Func<T, T, T>)	Comblé. Applique une fonction d’accumulation sur une séquence observable. (Défini par observable.)
	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.)
	Tous les> T<	Détermine si tous les éléments d’une séquence observable répondent à une condition. (Défini par observable.)
	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.)
	Et<T, TRight>	Correspond lorsque les deux séquences observables ont une valeur disponible. (Défini par observable.)
	tout<T>()	Comblé. Détermine si une séquence observable contient des éléments. (Défini par observable.)
	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.)
	AsObservable<T>	Masque l’identité d’une séquence observable. (Défini par observable.)
	AsObserver<T>	Masque l’identité d’un observateur. (Défini par Observer.)
	AsQbservable<T>	Convertit une séquence observable en séquence observable interrogeable. (Défini par Qbservable.)
	AssertEqual<T>	(Défini par les extensions .)
	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é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é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.)
	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é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é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é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é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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	Concat<T>	Concatène deux séquences observables. (Défini par observable.)
	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.)
	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.)
	Count<T>	Retourne un Int32 qui représente le nombre total d’éléments d’une séquence observable. (Défini par observable.)
	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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	> <T (action<T>)	Comblé. Appelle une action pour chaque élément de la séquence observable. (Défini par observable.)
	>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.)
	>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.)
	>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.)
	>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.)
	ElementAt<T>	Retourne l’élément à un index spécifié dans une séquence. (Défini par observable.)
	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.)
	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.)
	premier<T>()	Comblé. Retourne le premier élément d’une séquence observable avec une source spécifiée. (Défini par observable.)
	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.)
	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.)
	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.)
	Foo<T, R>	(Défini par MyExt.)
	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.)
	GetEnumerator<T>	Retourne un énumérateur qui énumère toutes les valeurs de la séquence observable. (Défini par observable.)
	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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	IgnoreElements<T>	Ignore toutes les valeurs d’une séquence observable en laissant uniquement les messages d’arrêt. (Défini par observable.)
	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.)
	dernier<T>()	Comblé. Retourne le dernier élément d’une séquence observable avec une source spécifiée. (Défini par observable.)
	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.)
	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.)
	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.)
	dernière> T<	Échantillonne la valeur la plus récente dans une séquence observable. (Défini par observable.)
	LongCount<T>	Retourne un Int64 qui représente le nombre total d’éléments dans une séquence observable. (Défini par observable.)
	Matérialiser<T>	Matérialise les notifications implicites d’une séquence observable en tant que valeurs de notification explicites. (Défini par observable.)
	< >()	Comblé. Retourne l’élément maximal dans une séquence observable. (Défini par observable.)
	> > < < <T<>)	Comblé. Retourne la valeur maximale dans une séquence observable en fonction du comparateur spécifié. (Défini par observable.)
	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.)
	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.)
	fusion<T>(IObservable<T>)	Comblé. Fusionne une séquence observable de séquences observables en séquence observable. (Défini par observable.)
	fusion<T>(IObservable<T>, IScheduler)	Comblé. Fusionne deux séquences observables en une seule séquence observable. (Défini par observable.)
	min<T>()	Comblé. Retourne l’élément minimal dans une séquence observable. (Défini par observable.)
	min<T>(IComparer<T>)	Comblé. Retourne la valeur minimale dans une séquence observable en fonction du comparateur spécifié. (Défini par observable.)
	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.)
	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.)
	MostRecent<T>	Échantillonne la valeur la plus récente dans une séquence observable. (Défini par observable.)
	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.)
	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.)
	<T>	Échantillonne la valeur suivante (bloquant sans mise en mémoire tampon) dans une séquence observable. (Défini par observable.)
	ObserveOn<T>(SynchronizationContext)	Comblé. Informez de façon asynchrone les observateurs sur le contexte de synchronisation spécifié. (Défini par observable.)
	ObserveOnT(Control)	Comblé. (Défini par ControlObservable.)
	ObserveOnT(répartiteur)	Comblé. (Défini par DispatcherObservable.)
	ObserveOnT(DispatcherScheduler)	Comblé. (Défini par DispatcherObservable.)
	T	Comblé. Informez de façon asynchrone les observateurs sur le planificateur spécifié. (Défini par observable.)
	ObserveOnDispatcher<T>	(Défini par DispatcherObservable.)
	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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	répéter<>()	Comblé. Répète indéfiniment la séquence observable. (Défini par observable.)
	répéter<>(Int32)	Comblé. Répète indéfiniment la séquence observable. (Défini par observable.)
	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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	réessayer<T>()	Comblé. Répète la séquence observable source jusqu’à ce qu’elle se termine correctement. (Défini par observable.)
	réessayer<>(Int32)	Comblé. Répète la séquence observable source jusqu’à ce qu’elle se termine correctement. (Défini par observable.)
	exemple de<T>(TimeSpan)	Comblé. Échantillonne la séquence observable à chaque intervalle. (Défini par observable.)
	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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	SequenceEqual<T>(IObservable<T>)	Comblé. Détermine si deux séquences sont égales en comparant les éléments par paire. (Défini par observable.)
	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.)
	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.)
	>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.)
	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.)
	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.)
	Ignorer<T>	Contourne un nombre spécifié de valeurs dans une séquence observable, puis retourne les valeurs restantes. (Défini par observable.)
	SkipLast<T>	Contourne un nombre spécifié d’éléments à la fin d’une séquence observable. (Défini par observable.)
	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.)
	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.)
	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.)
	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.)
	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.)
	s’abonner<T>()	Comblé. Évalue la séquence observable avec une source spécifiée. (Défini par ObservableExtensions.)
	s’abonner<T>(Action<T>)	Comblé. Abonne un gestionnaire d’éléments à une séquence observable. (Défini par ObservableExtensions.)
	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.)
	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.)
	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.)
	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.)
	subscribeOn<T>(Contrôle)	Comblé. (Défini par ControlObservable.)
	subscribeOn<T>(répartiteur)	Comblé. (Défini par DispatcherObservable.)
	SubscribeOn<T>(DispatcherScheduler)	Comblé. (Défini par DispatcherObservable.)
	SubscribeOn<T>(IScheduler)	Comblé. S’abonne de façon asynchrone et désactive les observateurs sur le planificateur spécifié. (Défini par observable.)
	SubscribeOnDispatcher<T>	(Défini par DispatcherObservable.)
	Synchroniser<>()	Comblé. Synchronise la séquence observable. (Défini par observable.)
	synchroniser<>(objet)	Comblé. Synchronise la séquence observable. (Défini par observable.)
	Prendre<T>	Retourne un nombre spécifié de valeurs contiguës à partir du début d’une séquence observable. (Défini par observable.)
	TakeLast<T>	Retourne un nombre spécifié d’éléments contigus à partir de la fin d’une séquence observable. (Défini par observable.)
	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.)
	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.)
	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.)
	Ensuite<T, TResult>	Correspond lorsque la séquence observable a une valeur disponible et projette la valeur. (Défini par observable.)
	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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	timeout<T>(DateTimeOffset, IScheduler)	Comblé. Retourne la séquence observable ou une exception TimeoutException si dueTime s’est écoulé. (Défini par observable.)
	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.)
	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.)
	timestamp<T>()	Comblé. Enregistre l’horodatage pour chaque valeur dans une séquence observable avec la source spécifiée. (Défini par observable.)
	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.)
	ToArray<T>	Crée un tableau à partir d’une séquence observable. (Défini par observable.)
	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.)
	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.)
	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.)
	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.)
	ToEnumerable<T>	Convertit une séquence observable en séquence énumérable. (Défini par observable.)
	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.)
	ToList<T>	Crée une liste à partir d’une séquence observable. (Défini par observable.)
	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.)
	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.)
	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.)
	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.)
	ToNotifier<T>	Crée un rappel de notification à partir d’un observateur. (Défini par Observer.)
	ToTask<T>()	Comblé. Retourne une tâche qui contient la dernière valeur de la séquence observable. (Défini par TaskObservableExtensions.)
	ToTask<T>(Object)	Comblé. Retourne une tâche qui contient la dernière valeur de la séquence observable. (Défini par TaskObservableExtensions.)
	ToTask<T>(CancellationToken)	Comblé. Retourne une tâche qui contient la dernière valeur de la séquence observable. (Défini par TaskObservableExtensions.)
	ToTask<T>(CancellationToken, Object)	Comblé. Retourne une tâche qui contient la dernière valeur de la séquence observable. (Défini par TaskObservableExtensions.)
	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.)
	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.)
	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.)
	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.)
	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.)
	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.)
	< >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.)
	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.)
	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.)
	>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.)
	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.)
	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.)
	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.)
	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. Il s’exécute en tant qu’abonné et éditeur. Pour ce faire, vous devez prendre en charge les interfaces IObserver et IObservable. L’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 son interface IObservable pour tous les observateurs abonnés. Les sujets réguliers synchronisent les appels sortants aux observateurs sous-récriés à l’aide d’un planificateur.

Exemples

Cet exemple illustre l’utilisation de la classe d’objet. Une instance d’un objet du type de chaîne est utilisée pour s’abonner à deux exemples de flux d’actualités. Ces flux publient simplement des titres d’actualités aléatoires à un intervalle inférieur à cinq secondes. Deux abonnements par rapport à l’interface observable de l’objet sont ensuite créés pour recevoir le flux de données combiné. Un abonnement signale chaque élément du flux de données en tant que « toutes les actualités ». L’autre abonnement filtre chaque titre dans le flux pour signaler uniquement les titres locaux. Les abonnements écrivent chaque titre reçu dans la fenêtre de console. Le traitement se termine lorsque l’utilisateur appuie sur la touche Entrée et dispose est appelé pour annuler les deux abonnements.

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

namespace Example
{
  class Program
  {
    static void Main()
    {
      //*****************************************************************************************************//
      //***                                                                                               ***//
      //*** A subject acts similar to a proxy in that it acts as both a subscriber and a publisher        ***//
      //*** It's IObserver interface can be used to subscribe to multiple streams or sequences of data.   ***//
      //*** The data is then published through it's IObservable interface.                                ***//
      //***                                                                                               ***//
      //*** In this example a simple string based subject is used to subscribe to multiple news feeds     ***//
      //*** that provide random news headlines. Subscribers can then subscribe to the subject's           ***//
      //*** observable interface to observe the data stream(s) or a subset ofthe stream(s). Below we      ***//
      //*** subscribe the subject to two different news headline feeds. Then two subscriptions are        ***//
      //*** created: one for delivery of all news headlines, the other receives only local news headlines ***//
      //***                                                                                               ***//
      //*** A local news headline just contains the newsLocation substring ("in your area.").             ***//
      //***                                                                                               ***//
      //*****************************************************************************************************//

      Subject<string> mySubject = new Subject<string>();


      //*********************************************************//
      //*** Create news feed #1 and subscribe mySubject to it ***//
      //*********************************************************//
      NewsHeadlineFeed NewsFeed1 = new NewsHeadlineFeed("Headline News Feed #1");
      NewsFeed1.HeadlineFeed.Subscribe(mySubject);

      //*********************************************************//
      //*** Create news feed #2 and subscribe mySubject to it ***//
      //*********************************************************//
      NewsHeadlineFeed NewsFeed2 = new NewsHeadlineFeed("Headline News Feed #2");
      NewsFeed2.HeadlineFeed.Subscribe(mySubject);


      Console.WriteLine("Subscribing to news headline feeds.\n\nPress ENTER to exit.\n");

      //*****************************************************************************************************//
      //*** Create a subscription to the subject's observable sequence. This subscription will receive    ***//
      //*** all headlines.                                                                                ***//
      //*****************************************************************************************************//
      IDisposable allNewsSubscription = mySubject.Subscribe(x => 
      {
        Console.WriteLine("Subscription : All news subscription\n{0}\n", x);
      });


      //*****************************************************************************************************//
      //*** Create a subscription to the subject's observable sequence. This subscription will filter for ***//
      //*** only local headlines.                                                                         ***//
      //*****************************************************************************************************//

      IDisposable localNewsSubscription = mySubject.Where(x => x.Contains("in your area.")).Subscribe(x => 
      {
        Console.WriteLine("\n************************************\n" +
                          "***[ Local news headline report ]***\n" +
                          "************************************\n{0}\n\n", x);
      });

      Console.ReadLine();


      //*********************************//
      //*** Cancel both subscriptions ***//
      //*********************************//

      allNewsSubscription.Dispose();
      localNewsSubscription.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(5000)); 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.

Subscribing to news headline feeds.

Press ENTER to exit.

Subscription : All news subscription
Feedname     : Headline News Feed #2
Headline     : A robbery occurred somewhere in Iraq.

Subscription : All news subscription
Feedname     : Headline News Feed #2
Headline     : An earthquake occurred in Dallas, Texas.

Subscription : All news subscription
Feedname     : Headline News Feed #1
Headline     : We have a lottery winner in your area.

********************************** [ Rapport des actualités locales ]********************************** Feedname : Flux d’actualités du titre #1 Titre : Nous avons un gagnant de loterie dans votre région.

Subscription : All news subscription
Feedname     : Headline News Feed #2
Headline     : Severe automobile accident Redmond, Washington

Subscription : All news subscription
Feedname     : Headline News Feed #2
Headline     : We have a lottery winner in Dallas, Texas.

Subscription : All news subscription
Feedname     : Headline News Feed #2
Headline     : An earthquake occurred in Dallas, Texas.

Subscription : All news subscription
Feedname     : Headline News Feed #1
Headline     : We have a lottery winner somewhere in Iraq.

Subscription : All news subscription
Feedname     : Headline News Feed #2
Headline     : Severe automobile accident somewhere in Iraq.

Subscription : All news subscription
Feedname     : Headline News Feed #2
Headline     : An earthquake occurred in your area.

********************************** [ Rapport sur les actualités locales ]********************************** Feedname : Titre du flux d’actualités #2 Titre : Un tremblement de terre s’est produit 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

Partager via

Objet<classe T>

Hiérarchie d’héritage

Syntaxe

Paramètres de type

Constructeurs

Méthode

Méthodes d’extension

Remarques

Exemples

Sécurité des threads

Voir aussi

Référence

Ressources supplémentaires