ISubject<T> Interface

Representa um objeto que é uma sequência observável, bem como um observador.

Namespace :System.Reactive.Subjects
assembly : System.Reactive (em System.Reactive.dll)

Sintaxe

'Declaration
Public Interface ISubject(Of T) _
    Inherits ISubject(Of T, T), IObserver(Of T),  _
    IObservable(Of T)

'Usage
Dim instance As ISubject(Of T)

public interface ISubject<T> : ISubject<T, T>, 
    IObserver<T>, IObservable<T>

generic<typename T>
public interface class ISubject : ISubject<T, T>, 
    IObserver<T>, IObservable<T>

type ISubject<'T> =  
    interface
        interface ISubject<'T, 'T>
        interface IObserver<'T>
        interface IObservable<'T>
    end

JScript does not support generic types and methods.

Parâmetros de tipo

• T
  O tipo do assunto.

O tipo de> T do ISubject<expõe os membros a seguir.

Métodos

	Nome	Descrição
método público	OnCompleted	(Herdado de IObserver<T>.)
método público	OnError	(Herdado de IObserver<T>.)
método público	OnNext	(Herdado de IObserver<T>.)
método público	Assinar	(Herdado de IObservável<T>.)

Início

Métodos de extensão

	Nome	Descrição
método de extensão pública	>T do<agregado (Func<T, T, T, T>)	Sobrecarregado. Aplica uma função de acumulador em uma sequência observável. (Definido por Observável .)
método de extensão pública	<T, TAccumulate>(TAccumulate, Func<TAccumulate, T, T, TAccumulate>)	Sobrecarregado. Aplica uma função de acumulador em uma sequência observável com o valor de semente especificado. (Definido por Observável .)
método de extensão pública	todos os> T<	Determina se todos os elementos de uma sequência observável atendem a uma condição. (Definido por Observável .)
método de extensão pública	Amb<T>	Propaga a sequência observável que reage primeiro com a primeira e a segunda sequência especificadas. (Definido por Observável .)
método de extensão pública	e<T, TRight>	Corresponde quando ambas as sequências observáveis têm um valor disponível. (Definido por Observável .)
método de extensão pública	qualquer>T<()	Sobrecarregado. Determina se uma sequência observável contém elementos. (Definido por Observável .)
método de extensão pública	<T>(Func<T, booliano>)	Sobrecarregado. Determina se todos os elementos de uma sequência observável atendem a uma condição. (Definido por Observável .)
método de extensão pública	> T AsObservable<	Oculta a identidade de uma sequência observável. (Definido por Observável .)
método de extensão pública	AsObserver<T>	Oculta a identidade de um observador. (Definido por Observer.)
método de extensão pública	> T asQbservable<	Converte uma sequência observável em uma sequência observável que pode ser consultada. (Definido por qbservable.)
método de extensão pública	T AssertEqual	(Definido por extensões .)
método de extensão pública	buffer<>T (Int32)	Sobrecarregado. Indica cada elemento de uma sequência observável em buffers não sobrepostos consecutivos que são produzidos com base nas informações de contagem de elementos. (Definido por Observável .)
método de extensão pública	do>T (<de Buffer<T)	Sobrecarregado. Indica cada elemento de uma sequência observável em buffers não sobrepostos consecutivos que são produzidos com base nas informações de tempo. (Definido por Observável .)
método de extensão pública	buffer<T>(Int32, Int32)	Sobrecarregado. Indica cada elemento de uma sequência observável em zero ou mais buffers que são produzidos com base nas informações de contagem de elementos. (Definido por Observável .)
método de extensão pública	buffer<>T (TimeSpan, IScheduler)	Sobrecarregado. Indica cada elemento de uma sequência observável em buffers não sobrepostos consecutivos que são produzidos com base nas informações de tempo. (Definido por Observável .)
método de extensão pública	buffer<>T (TimeSpan, TimeSpan)	Sobrecarregado. Indica cada elemento de uma sequência observável em zero ou mais buffers que são produzidos com base nas informações de tempo. (Definido por Observável .)
método de extensão pública	buffer<>T (TimeSpan, Int32)	Sobrecarregado. Indica cada elemento de uma sequência observável em um buffer enviado quando ele está cheio ou um determinado período de tempo decorrido. (Definido por Observável .)
método de extensão pública	buffer<T>(TimeSpan, TimeSpan, IScheduler)	Sobrecarregado. Indica cada elemento de uma sequência observável em zero ou mais buffers que são produzidos com base nas informações de tempo. (Definido por Observável .)
método de extensão pública	buffer<T>(TimeSpan, Int32, IScheduler)	Sobrecarregado. Indica cada elemento de uma sequência observável em um buffer enviado quando ele está cheio ou um determinado período de tempo decorrido. (Definido por Observável .)
método de extensão pública	BufferT,TBufferClosing (TBufferClosing )	Sobrecarregado. Indica cada elemento de uma sequência observável em buffers não sobrepostos consecutivos. (Definido por Observável .)
método de extensão pública	buffer<T, TBufferOpening, TBufferClosing>(<TBufferOpening>, Func<TBufferOpening, IObservable<TBufferClosing>>)	Sobrecarregado. Indica cada elemento de uma sequência observável que pode ser consultada em buffers não sobrepostos consecutivos. (Definido por Observável .)
método de extensão pública	T do Catch( TIObservável)	Sobrecarregado. Continua uma sequência observável que é encerrada por uma exceção com a próxima sequência observável. (Definido por Observável .)
método de extensão pública	Catch<T, TException>(Func<TException, IObservable<T>>)	Sobrecarregado. Continua uma sequência observável que é encerrada por uma exceção do tipo especificado com a sequência observável produzida pelo manipulador. (Definido por Observável .)
método de extensão pública	CombineLatest<T, TSecond, TResult>	Mescla duas sequências observáveis em uma sequência observável usando a função seletora sempre que uma das sequências observáveis produz um elemento. (Definido por Observável .)
método de extensão pública	Concat<T>	Concatena duas sequências observáveis. (Definido por Observável .)
método de extensão pública	contém T (>T)<	Sobrecarregado. Determina se uma sequência observável contém um elemento especificado usando o comparador de igualdade padrão. (Definido por Observável .)
método de extensão pública	contém<T>(T, IEqualityComparer<T>)	Sobrecarregado. Determina se uma sequência observável contém um elemento especificado usando um System.Collections.Generic.IEqualityComparer especificado< T>. (Definido por Observável .)
método de extensão pública	Contagem <T>	Retorna um int32 que representa o número total de elementos em uma sequência observável. (Definido por Observável .)
método de extensão pública	>T<DefaultIfEmpty ()	Sobrecarregado. Retorna os elementos da sequência especificada ou o valor padrão do parâmetro de tipo em uma sequência singleton se a sequência estiver vazia. (Definido por Observável .)
método de extensão pública	defaultIfEmpty<T>(T)	Sobrecarregado. Retorna os elementos da sequência especificada ou o valor padrão do parâmetro de tipo em uma sequência singleton se a sequência estiver vazia. (Definido por Observável .)
método de extensão pública	atraso>T<(TimeSpan)	Sobrecarregado. Indica a sequência observável pelo devido tempo com a origem e o dueTime especificados. (Definido por Observável .)
método de extensão pública	<T>de atraso de<(DateTimeOffset)	Sobrecarregado. Indica a sequência observável pelo devido tempo com a origem e o dueTime especificados. (Definido por Observável .)
método de extensão pública	atraso<>T (TimeSpan, IScheduler)	Sobrecarregado. Indica a sequência observável pelo devido tempo com a origem, o dueTime e o agendador especificados. (Definido por Observável .)
método de extensão pública	atraso<>T (DateTimeOffset, IScheduler)	Sobrecarregado. Indica a sequência observável pelo devido tempo com a origem, o dueTime e o agendador especificados. (Definido por Observável .)
método de extensão pública	>T<Distinto ()	Sobrecarregado. Retorna uma sequência observável que contém apenas elementos distintos com uma origem especificada. (Definido por Observável .)
método de extensão pública	>T<Distinto (IEqualityComparer<T>)	Sobrecarregado. Retorna uma sequência observável que contém apenas elementos distintos de acordo com o comparador. (Definido por Observável .)
método de extensão pública	<T, TKey>(Func<T, TKey>)	Sobrecarregado. Retorna uma sequência observável que contém apenas elementos distintos de acordo com o keySelector. (Definido por Observável .)
método de extensão pública	<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>)	Sobrecarregado. Retorna uma sequência observável que contém apenas elementos distintos de acordo com o keySelector. (Definido por Observável .)
método de extensão pública	distinctUntilChanged<T>()	Sobrecarregado. Retorna uma sequência observável que contém apenas elementos contíguos distintos com uma origem especificada. (Definido por Observável .)
método de extensão pública	DistinctUntilChanged<T>(IEqualityComparer<T>)	Sobrecarregado. Retorna uma sequência observável que contém apenas elementos contíguos distintos de acordo com o comparador. (Definido por Observável .)
método de extensão pública	DistinctUntilChanged<T, TKey>(Func<T, TKey>)	Sobrecarregado. Retorna uma sequência observável que contém apenas elementos contíguos distintos de acordo com o keySelector. (Definido por Observável .)
método de extensão pública	DistinctUntilChanged<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>)	Sobrecarregado. Retorna uma sequência observável que contém apenas elementos contíguos distintos de acordo com o keySelector e o comparador. (Definido por Observável .)
método de extensão pública	<T>(>T do<de Ação)	Sobrecarregado. Invoca uma ação para cada elemento na sequência observável. (Definido por Observável .)
método de extensão pública	>do<T (IObserver<T>)	Sobrecarregado. Invoca uma ação para cada elemento na sequência observável e invoca uma ação após o encerramento excepcional da sequência observável. (Definido por Observável .)
método de extensão pública	>T do<(Ação<T>, Ação)	Sobrecarregado. Invoca uma ação para cada elemento na sequência observável e invoca uma ação após o término normal da sequência observável. (Definido por Observável .)
método de extensão pública	<T>(>T<de ação,>de exceção de<de ação)	Sobrecarregado. Invoca uma ação para cada elemento na sequência observável e invoca uma ação após o encerramento excepcional da sequência observável. (Definido por Observável .)
método de extensão pública	Do<T>(Action<T>, Action<Exception>, Action)	Sobrecarregado. Invoca uma ação para cada elemento na sequência observável e invoca uma ação após terminação normal ou excepcional da sequência observável. (Definido por Observável .)
método de extensão pública	ElementAt<T>	Retorna o elemento em um índice especificado em uma sequência. (Definido por Observável .)
método de extensão pública	ElementAtOrDefault<T>	Retorna o elemento em um índice especificado em uma sequência ou um valor padrão se o índice estiver fora do intervalo. (Definido por Observável .)
método de extensão pública	finalmente<T>	Invoca uma ação especificada depois que a sequência observável de origem termina normalmente ou por uma exceção. (Definido por Observável .)
método de extensão pública	primeiro<>T ()	Sobrecarregado. Retorna o primeiro elemento de uma sequência observável com uma origem especificada. (Definido por Observável .)
método de extensão pública	primeiro<>T (Func<T, booliano>)	Sobrecarregado. Retorna o primeiro elemento de uma sequência observável que corresponde ao predicado. (Definido por Observável .)
método de extensão pública	>T<FirstOrDefault () ()	Sobrecarregado. Retorna o primeiro elemento de uma sequência observável ou um valor padrão se nenhum valor for encontrado. (Definido por Observável .)
método de extensão pública	FirstOrDefault<T>(Func<T, Boolean>)	Sobrecarregado. Retorna o primeiro elemento de uma sequência observável que corresponde ao predicado ou um valor padrão se nenhum valor for encontrado. (Definido por Observável .)
método de extensão pública	Foo<T, R>	(Definido por MyExt.)
método de extensão pública	ForEach<T>	Invoca uma ação para cada elemento na sequência observável e bloqueia até que a sequência seja encerrada. (Definido por Observável .)
método de extensão pública	GetEnumerator<T>	Retorna um enumerador que enumera todos os valores da sequência observável. (Definido por Observável .)
método de extensão pública	GroupBy<T, TKey>(Func<T, TKey>)	Sobrecarregado. Agrupa os elementos de uma sequência observável de acordo com uma função de seletor de chave especificada. (Definido por Observável .)
método de extensão pública	GroupBy<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>)	Sobrecarregado. Agrupa os elementos de uma sequência observável de acordo com uma função e um comparador de seletor de chave especificados. (Definido por Observável .)
método de extensão pública	GroupBy<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>)	Sobrecarregado. Agrupa os elementos de uma sequência observável e seleciona os elementos resultantes usando uma função especificada. (Definido por Observável .)
método de extensão pública	GroupBy<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>, IEqualityComparer<TKey>)	Sobrecarregado. Agrupa os elementos de uma sequência observável de acordo com uma função de seletor de chave especificada e o comparador e seleciona os elementos resultantes usando uma função especificada. (Definido por Observável .)
método de extensão pública	GroupByUntil<T, TKey, TDuration>(Func<T, TKey>, Func<IGroupedObservable<TKey, T>, IObservable<TDuration>>)	Sobrecarregado. Agrupa os elementos de uma sequência observável de acordo com uma função de seletor de chave especificada. (Definido por Observável .)
método de extensão pública	GroupByUntil<T, TKey, TDuration>(Func<T, TKey>, Func<IGroupedObservable<TKey, T>, IObservable<TDuration>>, IEqualityComparer<TKey>)	Sobrecarregado. Agrupa os elementos de uma sequência observável de acordo com uma função e um comparador de seletor de chave especificados. (Definido por Observável .)
método de extensão pública	GroupByUntil<T, TKey, TElement, TDuration>(Func<T, TKey>, Func<T, TElement>, Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>>)	Sobrecarregado. Agrupa os elementos de uma sequência observável de acordo com uma função de seletor de chave especificada e seleciona os elementos resultantes usando uma função especificada. (Definido por Observável .)
método de extensão pública	GroupByUntil<T, TKey, TElement, TDuration>(Func<T, TKey>, Func<T, TElement>, Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>>, IEqualityComparer<TKey>)	Sobrecarregado. Agrupa os elementos de uma sequência observável de acordo com uma função de seletor de chave especificada e o comparador e seleciona os elementos resultantes usando uma função especificada. (Definido por Observável .)
método de extensão pública	GroupJoin<T, TRight, TLeftDuration, TRightDuration, TResult>	Correlaciona os elementos de duas sequências com base em durações sobrepostas e agrupa os resultados. (Definido por Observável .)
método de extensão pública	IgnoreElements<T>	Ignora todos os valores em uma sequência observável deixando apenas as mensagens de terminação. (Definido por Observável .)
método de extensão pública	ingressar<T, TRight, TLeftDuration, TRightDuration, TResult>	Correlaciona os elementos de duas sequências com base em durações sobrepostas. (Definido por Observável .)
método de extensão pública	>T da última<()	Sobrecarregado. Retorna o último elemento de uma sequência observável com uma origem especificada. (Definido por Observável .)
método de extensão pública	>T da última<(Func<T,>booliano )	Sobrecarregado. Retorna o último elemento de uma sequência observável que corresponde ao predicado. (Definido por Observável .)
método de extensão pública	<T>()	Sobrecarregado. Retorna o último elemento na sequência observável ou um valor padrão se nenhum valor for encontrado. (Definido por Observável .)
método de extensão pública	LastOrDefault<T>(Func<T, Boolean>)	Sobrecarregado. Retorna o último elemento de uma sequência observável que corresponde ao predicado ou um valor padrão se nenhum valor for encontrado. (Definido por Observável .)
método de extensão pública	T domais recente do	Amostra o valor mais recente em uma sequência observável. (Definido por Observável .)
método de extensão pública	LongCount<T>	Retorna um int64 que representa o número total de elementos em uma sequência observável. (Definido por Observável .)
método de extensão pública	Materializar<T>	Materializa as notificações implícitas de uma sequência observável como valores de notificação explícitos. (Definido por Observável .)
método de extensão pública	>T máximo de<()	Sobrecarregado. Retorna o elemento máximo em uma sequência observável. (Definido por Observável .)
método de extensão pública	>T do Max<(IComparer<T>)	Sobrecarregado. Retorna o valor máximo em uma sequência observável de acordo com o comparador especificado. (Definido por Observável .)
método de extensão pública	MaxBy<T, TKey>(Func<T, TKey>)	Sobrecarregado. Retorna os elementos em uma sequência observável com o valor máximo da chave. (Definido por Observável .)
método de extensão pública	<T, TKey>(Func<T, TKey>, IComparer<TKey>)	Sobrecarregado. Retorna os elementos em uma sequência observável com o valor máximo da chave. (Definido por Observável .)
método de extensão pública	mesclagem<T>(IObservável<T>)	Sobrecarregado. Mescla uma sequência observável de sequências observáveis em uma sequência observável. (Definido por Observável .)
método de extensão pública	mesclagem<T>(IObservável<T>, IScheduler)	Sobrecarregado. Mescla duas sequências observáveis em uma única sequência observável. (Definido por Observável .)
método de extensão pública	min<T>()	Sobrecarregado. Retorna o elemento mínimo em uma sequência observável. (Definido por Observável .)
método de extensão pública	min<T>(IComparer<T>)	Sobrecarregado. Retorna o valor mínimo em uma sequência observável de acordo com o comparador especificado. (Definido por Observável .)
método de extensão pública	MinBy<T, TKey>(Func<T, TKey>)	Sobrecarregado. Retorna os elementos em uma sequência observável com o valor mínimo da chave. (Definido por Observável .)
método de extensão pública	MinBy<T, TKey>(Func<T, TKey>, IComparer<TKey>)	Sobrecarregado. Retorna os elementos em uma sequência observável com o valor mínimo da chave de acordo com o comparador especificado. (Definido por Observável .)
método de extensão pública	<T>	Amostra o valor mais recente em uma sequência observável. (Definido por Observável .)
método de extensão pública	multicast<T, TResult>(ISubject<T, TResult>)	Sobrecarregado. Retorna uma sequência observável conectável que, após a conexão, faz com que a sequência de origem envie resultados por push para o assunto especificado. (Definido por Observável .)
método de extensão pública	Multicast<T, TIntermediate, TResult>(Func<ISubject<T, TIntermediate>>, Func<IObservable<TIntermediate>, IObservable<TResult>>)	Sobrecarregado. Retorna uma sequência observável que contém os elementos de uma sequência produzida pela multicasting da sequência de origem dentro de uma função seletora. (Definido por Observável .)
método de extensão pública	próximo<T>	Amostra o próximo valor (bloqueio sem buffer) de uma sequência observável. (Definido por Observável .)
método de extensão pública	do ObserveOnT (SynchronizationContext)	Sobrecarregado. Notifique os observadores de forma assíncrona sobre o contexto de sincronização especificado. (Definido por Observável .)
método de extensão pública	>T (Controle) do ObserveOn<	Sobrecarregado. (Definido porControlObservable .)
método de extensão pública	<T>(Dispatcher) do ObserveOn (Dispatcher)	Sobrecarregado. (Definido pordispatcherObservable .)
método de extensão pública	ObserveOnT (DispatcherScheduler)	Sobrecarregado. (Definido pordispatcherObservable .)
método de extensão pública	ObserveOnT(IScheduler)	Sobrecarregado. Notifique os observadores de forma assíncrona sobre o agendador especificado. (Definido por Observável .)
método de extensão pública	ObserveOnDispatcher<T>	(Definido pordispatcherObservable .)
método de extensão pública	OnErrorResumeNext<T>	Continua uma sequência observável que é encerrada normalmente ou por uma exceção com a próxima sequência observável. (Definido por Observável .)
método de extensão pública	publicar<T>()	Sobrecarregado. Retorna uma sequência observável conectável que compartilha uma única assinatura para a sequência subjacente. (Definido por Observável .)
método de extensão pública	do>T<de Publicação<(T)	Sobrecarregado. Retorna uma sequência observável conectável que compartilha uma única assinatura para a sequência subjacente e começa com initialValue. (Definido por Observável .)
método de extensão pública	Publicar<T, TResult>(Func<IObservable<T>,<IObservable TResult>>)	Sobrecarregado. Retorna uma sequência observável que é o resultado da invocação do seletor em uma sequência observável conectável que compartilha uma única assinatura para a sequência subjacente. (Definido por Observável .)
método de extensão pública	Publicar<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, T)	Sobrecarregado. Retorna uma sequência observável conectável que compartilha uma única assinatura para a sequência subjacente e começa com initialValue. (Definido por Observável .)
método de extensão pública	TPublishLast ()	Sobrecarregado. Retorna uma sequência observável conectável que compartilha uma única assinatura para a sequência subjacente que contém apenas a última notificação. (Definido por Observável .)
método de extensão pública	PublishLast<T, TResult>(Func<IObservable<T>, IObservable<TResult>>)	Sobrecarregado. Retorna uma sequência observável que é o resultado da invocação do seletor em uma sequência observável conectável que compartilha uma única assinatura para a sequência subjacente que contém apenas a última notificação. (Definido por Observável .)
método de extensão pública	repetir>T<()	Sobrecarregado. Repete a sequência observável indefinidamente. (Definido por Observável .)
método de extensão pública	T dede repetição (Int32)	Sobrecarregado. Repete a sequência observável indefinidamente. (Definido por Observável .)
método de extensão pública	<T>()	Sobrecarregado. Retorna uma sequência observável conectável que compartilha uma única assinatura para a sequência subjacente reproduzindo todas as notificações. (Definido por Observável .)
método de extensão pública	<T>(TimeSpan)	Sobrecarregado. Retorna uma sequência observável conectável que compartilha uma única assinatura para a sequência subjacente reproduzindo todas as notificações dentro da janela. (Definido por Observável .)
método de extensão pública	Replay<T>(Int32)	Sobrecarregado. Retorna uma sequência observável conectável que compartilha uma única assinatura para a sequência subjacente reproduzindo notificações bufferSize. (Definido por Observável .)
método de extensão pública	Replay<T>(IScheduler)	Sobrecarregado. Retorna uma sequência observável conectável que compartilha uma única assinatura para a sequência subjacente reproduzindo todas as notificações. (Definido por Observável .)
método de extensão pública	Replay<T>(TimeSpan, IScheduler)	Sobrecarregado. Retorna uma sequência observável conectável que compartilha uma única assinatura para a sequência subjacente reproduzindo todas as notificações dentro da janela. (Definido por Observável .)
método de extensão pública	Replay<T>(Int32, IScheduler)	Sobrecarregado. Retorna uma sequência observável conectável que compartilha uma única assinatura para a sequência subjacente reproduzindo notificações bufferSize. (Definido por Observável .)
método de extensão pública	<T>Replay<(Int32, TimeSpan)	Sobrecarregado. Retorna uma sequência observável conectável que compartilha uma única assinatura para a sequência subjacente que reproduz notificações bufferSize dentro da janela. (Definido por Observável .)
método de extensão pública	Replay<T>(Int32, TimeSpan, IScheduler)	Sobrecarregado. Retorna uma sequência observável conectável que compartilha uma única assinatura para a sequência subjacente que reproduz notificações bufferSize dentro da janela. (Definido por Observável .)
método de extensão pública	Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>)	Sobrecarregado. Retorna uma sequência observável que é o resultado da invocação do seletor em uma sequência observável conectável que compartilha uma única assinatura para a sequência subjacente e começa com o valor inicial. (Definido por Observável .)
método de extensão pública	Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, IScheduler)	Sobrecarregado. Retorna uma sequência observável que é o resultado da invocação do seletor em uma sequência observável conectável que compartilha uma única assinatura para a sequência subjacente que repete todas as notificações. (Definido por Observável .)
método de extensão pública	Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, TimeSpan)	Sobrecarregado. Retorna uma sequência observável que é o resultado da invocação do seletor em uma sequência observável conectável que compartilha uma única assinatura para a sequência subjacente reproduzindo todas as notificações dentro da janela. (Definido por Observável .)
método de extensão pública	Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, Int32)	Sobrecarregado. Retorna uma sequência observável que é o resultado da invocação do seletor em uma sequência observável conectável que compartilha uma única assinatura para as notificações bufferSize de reprodução de sequência subjacente. (Definido por Observável .)
método de extensão pública	Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, TimeSpan, IScheduler)	Sobrecarregado. Retorna uma sequência observável que é o resultado da invocação do seletor em uma sequência observável conectável que compartilha uma única assinatura para a sequência subjacente reproduzindo todas as notificações dentro da janela. (Definido por Observável .)
método de extensão pública	Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, Int32, IScheduler)	Sobrecarregado. Retorna uma sequência observável que é o resultado da invocação do seletor em uma sequência observável conectável que compartilha uma única assinatura para as notificações bufferSize de reprodução de sequência subjacente. (Definido por Observável .)
método de extensão pública	Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, Int32, TimeSpan)	Sobrecarregado. Retorna uma sequência observável que é o resultado da invocação do seletor em uma sequência observável conectável que compartilha uma única assinatura para a sequência subjacente que repete notificações bufferSize dentro da janela. (Definido por Observável .)
método de extensão pública	Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, Int32, TimeSpan, IScheduler)	Sobrecarregado. Retorna uma sequência observável que é o resultado da invocação do seletor em uma sequência observável conectável que compartilha uma única assinatura para a sequência subjacente que repete notificações bufferSize dentro da janela. (Definido por Observável .)
método de extensão pública	<T>()	Sobrecarregado. Repete a sequência observável de origem até que ela seja encerrada com êxito. (Definido por Observável .)
método de extensão pública	<T>(Int32)	Sobrecarregado. Repete a sequência observável de origem até que ela seja encerrada com êxito. (Definido por Observável .)
método de extensão pública	< >T (TimeSpan)	Sobrecarregado. Amostra a sequência observável em cada intervalo. (Definido por Observável .)
método de extensão pública	exemplo<T>(TimeSpan, IScheduler)	Sobrecarregado. Amostra a sequência observável em cada intervalo com a origem, o intervalo e o agendador especificados. (Definido por Observável .)
método de extensão pública	<T,>de TSample (<>TSample IObservável)	Sobrecarregado. Amostra a sequência observável em tiques de amostragem com a origem e o sampler especificados. (Definido por Observável .)
método de extensão pública	verificação<T>(Func<T, T, T>)	Sobrecarregado. Aplica uma função de acumulador em uma sequência observável e retorna cada resultado intermediário com a origem e o acumulador especificados. (Definido por Observável .)
método de extensão pública	<T, TAccumulate>(TAccumulate, Func<TAccumulate, T, T, TAccumulate>)	Sobrecarregado. Aplica uma função de acumulador em uma sequência observável e retorna cada resultado intermediário com a origem, a semente e o acumulador especificados. (Definido por Observável .)
método de extensão pública	Selecione<T,>TResult (Func<T, TResult>)	Sobrecarregado. Projeta cada elemento de uma sequência observável em um novo formulário com a origem e o seletor especificados. (Definido por Observável .)
método de extensão pública	Selecione<T,>TResult (Func<T, Int32, TResult>)	Sobrecarregado. Projeta cada elemento de uma sequência observável em um novo formulário incorporando o índice do elemento com a origem e o seletor especificados. (Definido por Observável .)
método de extensão pública	SelectMany<T, TOther>(>TOther<IObservable )	Sobrecarregado. Projeta cada elemento de uma sequência observável em uma sequência observável e mescla as sequências observáveis resultantes em uma sequência observável. (Definido por Observável .)
método de extensão pública	SelectMany<T, TResult>(Func<T, IObservable<TResult>>)	Sobrecarregado. Projeta cada elemento de uma sequência observável em uma sequência observável e mescla as sequências observáveis resultantes em uma sequência observável. (Definido por Observável .)
método de extensão pública	SelectMany<T, TResult>(Func<T, IEnumerable<TResult>>)	Sobrecarregado. Projeta cada elemento de uma sequência observável em uma sequência observável e mescla as sequências observáveis resultantes em uma sequência observável. (Definido por Observável .)
método de extensão pública	SelectMany<T, TResult>(Func<T, IObservable<TResult>>, Func<Exception, IObservable<TResult>>, Func<IObservable<TResult>>)	Sobrecarregado. Projeta cada elemento de uma sequência observável em uma sequência observável e mescla as sequências observáveis resultantes em uma sequência observável. (Definido por Observável .)
método de extensão pública	SelectMany<T, TCollection, TResult>(Func<T, IEnumerable<TCollection>>, Func<T, TCollection, TResult>)	Sobrecarregado. Projeta cada elemento de uma sequência observável em uma sequência observável e mescla as sequências observáveis resultantes em uma sequência observável. (Definido por Observável .)
método de extensão pública	SelectMany<T, TCollection, TResult>(Func<T, IObservable<TCollection>>, Func<T, TCollection, TResult>)	Sobrecarregado. Projeta cada elemento de uma sequência observável em uma sequência observável e mescla as sequências observáveis resultantes em uma sequência observável. (Definido por Observável .)
método de extensão pública	sequenceEqual<T>(>T<IObservável )	Sobrecarregado. Determina se duas sequências são iguais comparando os elementos de forma emparelhada. (Definido por Observável .)
método de extensão pública	SequenceEqual<T>(IObservable<T>, IEqualityComparer<T>)	Sobrecarregado. Determina se duas sequências são iguais comparando os elementos de forma emparelhada usando um comparador de igualdade especificado. (Definido por Observável .)
método de extensão pública	>T de<único ()	Sobrecarregado. Retorna o único elemento de uma sequência observável e gera uma exceção se não houver exatamente um elemento na sequência observável. (Definido por Observável .)
método de extensão pública	>T do<Único (Func<T,>Booliano)	Sobrecarregado. Retorna o único elemento de uma sequência observável que corresponde ao predicado e gera uma exceção se não houver exatamente um elemento na sequência observável. (Definido por Observável .)
método de extensão pública	>T<SingleOrDefault ()	Sobrecarregado. Retorna o único elemento de uma sequência observável ou um valor padrão se a sequência observável estiver vazia. (Definido por Observável .)
método de extensão pública	singleOrDefault<T>(Func<T, Boolean>)	Sobrecarregado. Retorna o único elemento de uma sequência observável que corresponde ao predicado ou um valor padrão se nenhum valor for encontrado. (Definido por Observável .)
método de extensão pública	Ignorar<T>	Ignora um número especificado de valores em uma sequência observável e retorna os valores restantes. (Definido por Observável .)
método de extensão pública	> T<SkipLast	Ignora um número especificado de elementos no final de uma sequência observável. (Definido por Observável .)
método de extensão pública	SkipUntil<T, TOther>	Retorna os valores da sequência observável de origem somente após a outra sequência observável produzir um valor. (Definido por Observável .)
método de extensão pública	<T>(Func<T, booliano>)	Sobrecarregado. Ignora valores em uma sequência observável, desde que uma condição especificada seja verdadeira e, em seguida, retorna os valores restantes. (Definido por Observável .)
método de extensão pública	<T>(Func<T, Int32, Boolean>)	Sobrecarregado. Ignora valores em uma sequência observável, desde que uma condição especificada seja verdadeira e, em seguida, retorna os valores restantes. (Definido por Observável .)
método de extensão pública	StartWith<T>T[])	Sobrecarregado. Anexa uma sequência de valores a uma sequência observável com a origem e os valores especificados. (Definido por Observável .)
método de extensão pública	StartWith<T>(IScheduler, T[])	Sobrecarregado. Anexa uma sequência de valores a uma sequência observável com a origem, o agendador e os valores especificados. (Definido por Observável .)
método de extensão pública	assinar<T>()	Sobrecarregado. Avalia a sequência observável com uma origem especificada. (Definido por ObservableExtensions .)
método de extensão pública	assinar<T>(Action<T>)	Sobrecarregado. Assina um manipulador de elementos em uma sequência observável. (Definido por ObservableExtensions .)
método de extensão pública	Assinar<T>(Action<T>, Action<Exception>)	Sobrecarregado. Assina um manipulador de elementos e um manipulador de exceção em uma sequência observável. (Definido por ObservableExtensions .)
método de extensão pública	Assinar<T>(Ação<T>, Ação)	Sobrecarregado. Assina um manipulador de elementos e um manipulador de conclusão em uma sequência observável. (Definido por ObservableExtensions .)
método de extensão pública	Assinar<T>(Action<T>, Action<Exception>, Action)	Sobrecarregado. Assina um manipulador de elementos, um manipulador de exceção e um manipulador de conclusão em uma sequência observável. (Definido por ObservableExtensions .)
método de extensão pública	>SubscribeOn<T>(SynchronizationContext)	Sobrecarregado. Assina e cancela a assinatura de observadores de forma assíncrona no contexto de sincronização especificado. (Definido por Observável .)
método de extensão pública	<T>(Controle)	Sobrecarregado. (Definido porControlObservable .)
método de extensão pública	SubscribeOnT(Dispatcher)	Sobrecarregado. (Definido pordispatcherObservable .)
método de extensão pública	SubscribeOn<T>(DispatcherScheduler)	Sobrecarregado. (Definido pordispatcherObservable .)
método de extensão pública	SubscribeOn<T>(IScheduler)	Sobrecarregado. Assina e cancela a assinatura de observadores de forma assíncrona no agendador especificado. (Definido por Observável .)
método de extensão pública	SubscribeOnDispatcher<T>	(Definido pordispatcherObservable .)
método de extensão pública	Sincronizar>T<()	Sobrecarregado. Sincroniza a sequência observável. (Definido por Observável .)
método de extensão pública	sincronizar<>T (objeto)	Sobrecarregado. Sincroniza a sequência observável. (Definido por Observável .)
método de extensão pública	take<T>	Retorna um número especificado de valores contíguos desde o início de uma sequência observável. (Definido por Observável .)
método de extensão pública	<T><	Retorna um número especificado de elementos contíguos do final de uma sequência observável. (Definido por Observável .)
método de extensão pública	TakeUntil<T, TOther>	Retorna os valores da sequência observável de origem até que a outra sequência observável produza um valor. (Definido por Observável .)
método de extensão pública	<T>(Func<T, booliano>)	Sobrecarregado. Retorna valores de uma sequência observável, desde que uma condição especificada seja verdadeira e ignore os valores restantes. (Definido por Observável .)
método de extensão pública	<T>(Func<T, Int32, Boolean>)	Sobrecarregado. Retorna valores de uma sequência observável, desde que uma condição especificada seja verdadeira e ignore os valores restantes. (Definido por Observável .)
método de extensão pública	<T, TResult>	Corresponde quando a sequência observável tem um valor disponível e projeta o valor. (Definido por Observável .)
método de extensão pública	limitarT (TimeSpan)	Sobrecarregado. Ignora os valores de uma sequência observável que são seguidos por outro valor antes do devido tempo com a origem e o dueTime especificados. (Definido por Observável .)
método de extensão pública	limitar<>T (TimeSpan, IScheduler)	Sobrecarregado. Ignora os valores de uma sequência observável que são seguidos por outro valor antes do devido tempo com a origem, o dueTime e o agendador especificados. (Definido por Observável .)
método de extensão pública	>T do TimeInterval<()	Sobrecarregado. Registra o intervalo de tempo entre valores consecutivos em uma sequência observável com a origem especificada. (Definido por Observável .)
método de extensão pública	>T<T (IScheduler)	Sobrecarregado. Registra o intervalo de tempo entre valores consecutivos em uma sequência observável com a origem e o agendador especificados. (Definido por Observável .)
método de extensão pública	Timeout<T>(TimeSpan)	Sobrecarregado. Retorna a sequência observável ou um TimeoutException se dueTime decorrido. (Definido por Observável .)
método de extensão pública	tempo limite<>T (DateTimeOffset)	Sobrecarregado. Retorna a sequência observável ou um TimeoutException se dueTime decorrido. (Definido por Observável .)
método de extensão pública	tempo limite<T>(TimeSpan, IObservable<T>)	Sobrecarregado. Retorna a sequência observável de origem ou a outra sequência observável se dueTime decorrido. (Definido por Observável .)
método de extensão pública	<T>(DateTimeOffset, IObservable<T>)	Sobrecarregado. Retorna a sequência observável ou um TimeoutException se dueTime decorrido. (Definido por Observável .)
método de extensão pública	Timeout<T>(TimeSpan, IScheduler)	Sobrecarregado. Retorna a sequência observável ou um TimeoutException se dueTime decorrido. (Definido por Observável .)
método de extensão pública	Timeout<T>(DateTimeOffset, IScheduler)	Sobrecarregado. Retorna a sequência observável ou um TimeoutException se dueTime decorrido. (Definido por Observável .)
método de extensão pública	Timeout<T>(TimeSpan, IObservable<T>, IScheduler)	Sobrecarregado. Retorna a sequência observável de origem ou a outra sequência observável se dueTime decorrido. (Definido por Observável .)
método de extensão pública	<T>(DateTimeOffset, IObservable<T>, IScheduler)	Sobrecarregado. Retorna a sequência observável de origem ou a outra sequência observável se dueTime decorrido. (Definido por Observável .)
método de extensão pública	>T<de carimbo de data/hora ()	Sobrecarregado. Registra o carimbo de data/hora para cada valor em uma sequência observável com a origem especificada. (Definido por Observável .)
método de extensão pública	<T>(IScheduler)	Sobrecarregado. Registra o carimbo de data/hora para cada valor em uma sequência observável com a origem e o agendador especificados. (Definido por Observável .)
método de extensão pública	ToArray<T>	Cria uma matriz com base em uma sequência observável. (Definido por Observável .)
método de extensão pública	ToDictionary<T, TKey>(Func<T, TKey>)	Sobrecarregado. Cria um dicionário de uma sequência observável de acordo com uma função de seletor de chave especificada. (Definido por Observável .)
método de extensão pública	ToDictionary<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>)	Sobrecarregado. Cria um dicionário de uma sequência observável de acordo com uma função de seletor de chave especificada e um comparador. (Definido por Observável .)
método de extensão pública	ToDictionary<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>)	Sobrecarregado. Cria um dicionário de uma sequência observável de acordo com uma função de seletor de chave especificada e uma função de seletor de elemento. (Definido por Observável .)
método de extensão pública	ToDictionary<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>, IEqualityComparer<TKey>)	Sobrecarregado. Cria um dicionário de uma sequência observável de acordo com uma função de seletor de chave especificada, um comparador e uma função de seletor de elemento. (Definido por Observável .)
método de extensão pública	ToEnumerable<T>	Converte uma sequência observável em uma sequência enumerável. (Definido por Observável .)
método de extensão pública	ToEvent<T>	Expõe uma sequência observável como um objeto com um evento .NET com uma origem especificada. (Definido por Observável .)
método de extensão pública	ToList<T>	Cria uma lista de uma sequência observável. (Definido por Observável .)
método de extensão pública	ToLookup<T, TKey>(Func<T, TKey>)	Sobrecarregado. Cria uma pesquisa de uma sequência observável de acordo com uma função de seletor de chave especificada. (Definido por Observável .)
método de extensão pública	ToLookup<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>)	Sobrecarregado. Cria uma pesquisa de uma sequência observável de acordo com uma função de seletor de chave especificada e um comparador. (Definido por Observável .)
método de extensão pública	ToLookup<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>)	Sobrecarregado. Cria uma pesquisa de uma sequência observável de acordo com uma função de seletor de chave especificada e uma função de seletor de elemento. (Definido por Observável .)
método de extensão pública	ToLookup<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>, IEqualityComparer<TKey>)	Sobrecarregado. Cria uma pesquisa de uma sequência observável de acordo com uma função de seletor de chave especificada, um comparador e uma função de seletor de elemento. (Definido por Observável .)
método de extensão pública	ToNotifier<T>	Cria um retorno de chamada de notificação de um observador. (Definido por Observer.)
método de extensão pública	toTask<T>()	Sobrecarregado. Retorna uma tarefa que contém o último valor da sequência observável. (Definido por TaskObservableExtensions.)
método de extensão pública	toTask<T>(objeto)	Sobrecarregado. Retorna uma tarefa que contém o último valor da sequência observável. (Definido por TaskObservableExtensions.)
método de extensão pública	>T do ToTask<(CancellationToken)	Sobrecarregado. Retorna uma tarefa que contém o último valor da sequência observável. (Definido por TaskObservableExtensions.)
método de extensão pública	ToTask<T>(CancellationToken, Object)	Sobrecarregado. Retorna uma tarefa que contém o último valor da sequência observável. (Definido por TaskObservableExtensions.)
método de extensão pública	Where<T>(Func<T, Boolean>)	Sobrecarregado. Filtra os elementos de uma sequência observável com base em um predicado. (Definido por Observável .)
método de extensão pública	Where<T>(Func<T, Int32, Boolean>)	Sobrecarregado. Filtra os elementos de uma sequência observável com base em um predicado incorporando o índice do elemento. (Definido por Observável .)
método de extensão pública	<T>(Int32)	Sobrecarregado. Projeta cada elemento de uma sequência observável em janelas consecutivas não sobrepostas que são produzidas com base nas informações de contagem de elementos. (Definido por Observável .)
método de extensão pública	janela <>T (TimeSpan)	Sobrecarregado. Projeta cada elemento de uma sequência observável em janelas consecutivas não sobrepostas que são produzidas com base nas informações de tempo. (Definido por Observável .)
método de extensão pública	janela <T>(Int32, Int32)	Sobrecarregado. Projeta cada elemento de uma sequência observável em zero ou mais janelas que são produzidas com base nas informações de contagem de elementos. (Definido por Observável .)
método de extensão pública	>T<de Janela (TimeSpan, IScheduler)	Sobrecarregado. Projeta cada elemento de uma sequência observável em janelas consecutivas não sobrepostas que são produzidas com base nas informações de tempo. (Definido por Observável .)
método de extensão pública	janela >T<(TimeSpan, TimeSpan)	Sobrecarregado. Projeta cada elemento de uma sequência observável em zero ou mais janelas que são produzidas com base nas informações de tempo. (Definido por Observável .)
método de extensão pública	>T da janela<(TimeSpan, Int32)	Sobrecarregado. Projeta cada elemento de uma sequência observável em uma janela que é concluída quando ela está cheia ou um determinado período de tempo decorrido. (Definido por Observável .)
método de extensão pública	>T<de janela (TimeSpan, TimeSpan, IScheduler)	Sobrecarregado. Projeta cada elemento de uma sequência observável em zero ou mais janelas que são produzidas com base nas informações de tempo. (Definido por Observável .)
método de extensão pública	WindowT (TimeSpan, Int32, IScheduler)	Sobrecarregado. Projeta cada elemento de uma sequência observável em uma janela que é concluída quando ela está cheia ou um determinado período de tempo decorrido. (Definido por Observável .)
método de extensão pública	<T,>TWindowClosing (<>><IObservable do Fun<c<TWindowClosing )	Sobrecarregado. Projeta cada elemento de uma sequência observável em janelas consecutivas não sobrepostas. (Definido por Observável .)
método de extensão pública	<T, TWindowOpening, TWindowClosing>(<TWindowOpening>, Func<TWindowOpening, IObservable<TWindowClosing>>)	Sobrecarregado. Projeta cada elemento de uma sequência observável em zero ou mais janelas. (Definido por Observável .)
método de extensão pública	Zip<T, TSecond, TResult>(IObservable<TSecond>, Func<T, TSecond, TResult>)	Sobrecarregado. Mescla duas sequências observáveis em uma sequência observável combinando seus elementos de forma emparelhada. (Definido por Observável .)
método de extensão pública	Zip<T, TSecond, TResult>(IEnumerable<TSecond>, Func<T, TSecond, TResult>)	Sobrecarregado. Mescla uma sequência observável e uma sequência enumerável em uma sequência observável usando a função seletora. (Definido por Observável .)

Início

Observações

Implementar a interface ISubject permite que você crie seu próprio assunto com comportamentos personalizados.

Exemplos

O código de exemplo a seguir implementa um assunto de exemplo que apenas ecoa a execução do método na janela do console.

using System;
using System.Collections.Generic;
using System.Reactive.Linq;
using System.Reactive.Subjects;
using System.Reactive.Concurrency;
using System.Reactive.Disposables;

namespace Example
{
  class Program
  {
    static void Main()
    {
      //************************************************************************************//
      //*** The ConsoleEchoSubject will just echo it's method calls out to the console   ***//
      //*** window.                                                                      ***//
      //***                                                                              ***//
      //*** Create an instance of the ConsoleEchoSubject and subscribe to a sequence of  ***//
      //*** the first 5 integers returned by the Interval operator.                      ***//
      //***                                                                              ***//
      //************************************************************************************//

      ConsoleEchoSubject<long> mySubject = new ConsoleEchoSubject<long>();
      var obs = Observable.Interval(TimeSpan.FromSeconds(1), Scheduler.ThreadPool).Take(5);
      Console.WriteLine("Subscribing ConsoleEchoSubject to observable sequence.\n");
      obs.Subscribe(mySubject);


      //************************************************************************************//
      //*** Subscribe to the subject's observable interface. Each value will be written  ***//
      //*** to the console window.                                                       ***//
      //************************************************************************************//

      IDisposable subscription = mySubject.Subscribe(x => Console.WriteLine(x), () => 
      {
        Console.WriteLine("\nSequence Completed.\n");
        Console.WriteLine("Press ENTER to exit...");
      });

      Console.ReadLine();


      //***************************************//
      //*** Explicitly releasing resources. ***//
      //***************************************//

      subscription.Dispose();
      mySubject.Dispose();
    }
  }



  //************************************************************************************//
  //***                                                                              ***//
  //*** The ConsoleEchoSubject will just echo it's method calls out to the console   ***//
  //*** window.                                                                      ***//
  //***                                                                              ***//
  //************************************************************************************//

  class ConsoleEchoSubject<T> : ISubject<T>, IDisposable
  { 
    private List<IObserver<T>> observerList;     
    private bool isDisposed;
    private bool isStopped;
    object gate = new object();
    Exception exception;

    public ConsoleEchoSubject()
    {
      observerList = new List<IObserver<T>>();     
    }

    public void OnCompleted()
    {      
      //****************************************************************************************//
      //*** Make sure the OnCompleted operation is not preempted by another operation        ***//
      //*** which would break the expected behavior.  For example, don't allow an error from ***//
      //*** OnError preempt OnCompleted from anotther thread. Then OnCompleted would follow  ***//
      //*** an error.  That would be an incorrect behavior.                                  ***//
      //****************************************************************************************//

      lock (gate) 
      {
        CheckDisposed();

        if (!isStopped)
        {
          Console.WriteLine("\nConsoleEchoSubject : OnCompleted()");

          foreach (IObserver<T> observer in observerList)
          {
            observer.OnCompleted();
          }

          observerList.Clear();
          isStopped = true;
        }
      }
    }

    public void OnError(Exception error)
    {
      if (error == null)
        throw new ArgumentException("Exception error should not be null.");

      //****************************************************************************************//
      //*** Make sure the OnError operation is not preempted by another operation which      ***//
      //*** would break the expected behavior.  For example, don't allow unsubscribe or an   ***//
      //*** OnCompleted operation to preempt OnError from another thread. This would result  ***//
      //*** in an error following completion.  That would be an incorrect behavior.          ***//
      //****************************************************************************************//

      lock (gate) 
      {
        CheckDisposed();

        if (!isStopped)
        {
          Console.WriteLine("\nConsoleEchoSubject : OnError({0})", error.Message);

          exception = error;

          foreach (IObserver<T> observer in observerList)
          {
            observer.OnError(error);
          }

          observerList.Clear();
          isStopped = true;  
        }
      }
    }

    public void OnNext(T value)
    {
      //****************************************************************************************//
      //*** Make sure the OnNext operation is not preempted by another operation which       ***//
      //*** would break the expected behavior.  For example, don't allow unsubscribe, errors ***//
      //*** or an OnCompleted operation to preempt OnNext from another thread. This would    ***//
      //*** have the result of items in a sequence following completion, errors, or          ***//
      //*** unsubscribe.  That would be an incorrect behavior.                               ***//
      //****************************************************************************************//

      lock (gate)
      {
        CheckDisposed();

        if (!isStopped)
        {
          Console.WriteLine("\nConsoleEchoSubject : OnNext({0})", value.ToString());

          foreach (IObserver<T> observer in observerList)
          {
            observer.OnNext(value);
          }
        }
      }
    } 

    public IDisposable Subscribe(IObserver<T> observer)
    {
      if (observer == null)
        throw new ArgumentException("observer should not BehaviorSubject null.");

      //****************************************************************************************//
      //*** Make sure Subscribe occurs in sync with the other operations so we keep the      ***//
      //*** correct behavior depending on whether an error has occurred or the observable    ***//
      //*** sequence has completed.                                                          ***//
      //****************************************************************************************//

      lock (gate)
      {
        CheckDisposed();

        if (!isStopped)
        {
          Console.WriteLine("\nConsoleEchoSubject : Creating new subscription.");
          observerList.Add(observer);
          return new Subscription(observer, this);
        }
        else if(exception != null)
        {
          observer.OnError(exception);
          return Disposable.Empty;
        }
        else
        {
          observer.OnCompleted();
          return Disposable.Empty;
        }
      }
    }

    private void Unsubscribe(IObserver<T> observer)
    {
      //****************************************************************************************//
      //*** Make sure Unsubscribe occurs in sync with the other operations so we keep the    ***//
      //*** correct behavior.                                                                ***//
      //****************************************************************************************//

      lock (gate)
      {
        Console.WriteLine("\nConsoleEchoSubject : Unsubscribing subscription.");
        observerList.Remove(observer);
      }
    }

    public void  Dispose()
    {
      //****************************************************************************************//
      //*** Make sure Dispose occurs in sync with the other operations so we keep the        ***//
      //*** correct behavior. For example, Dispose shouldn't preempt the other operations    ***//
      //*** changing state variables after they have been checked.                           ***//
      //****************************************************************************************//

      lock (gate)
      {
        Console.WriteLine("\nConsoleEchoSubject : Disposing resources.");
        observerList.Clear();
        isStopped = true;
        isDisposed = true;
      }
    }

    private void CheckDisposed()
    {
      if (isDisposed)
        throw new ObjectDisposedException("Subject has been disposed.");
    }


    //************************************************************************************//
    //***                                                                              ***//
    //*** The Subscription class wraps each observer that creates a subscription. This ***//
    //*** is needed to expose an IDisposable interface through which a observer can    ***//
    //*** cancel the subscription.                                                     ***//
    //***                                                                              ***//
    //************************************************************************************//

    class Subscription : IDisposable
    {
      private ConsoleEchoSubject<T> subject;
      private IObserver<T> observer;

      public Subscription(IObserver<T> obs, ConsoleEchoSubject<T> sub)
      {
        subject = sub;
        observer = obs;
      }

      public void Dispose()
      {
        subject.Unsubscribe(observer);  
      }
    }
  }
}

A saída a seguir foi gerada pelo código de exemplo.

Subscribing ConsoleEchoSubject to observable sequence.


ConsoleEchoSubject : Creating new subscription.

ConsoleEchoSubject : OnNext(0)
0

ConsoleEchoSubject : OnNext(1)
1

ConsoleEchoSubject : OnNext(2)
2

ConsoleEchoSubject : OnNext(3)
3

ConsoleEchoSubject : OnNext(4)
4

ConsoleEchoSubject : OnCompleted()

Sequence Completed.

Press ENTER to exit...


ConsoleEchoSubject : Unsubscribing subscription.

ConsoleEchoSubject : Disposing resources.

C:\

Consulte Também

Referência

namespace System.Reactive.Subjects