ISubject<TSource, TResult> 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 In TSource, Out TResult) _
    Inherits IObserver(Of TSource), IObservable(Of TResult)

'Usage
Dim instance As ISubject(Of In TSource, Out TResult)

public interface ISubject<in TSource, out TResult> : IObserver<TSource>, 
    IObservable<TResult>

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

type ISubject<'TSource, 'TResult> =  
    interface
        interface IObserver<'TSource>
        interface IObservable<'TResult>
    end

JScript does not support generic types and methods.

Parâmetros de tipo

• inTSource
  O tipo de origem.

  Esse parâmetro de tipo é contravariante. Ou seja, você pode usar o tipo especificado ou qualquer tipo menos derivado. Para obter mais informações sobre covariância e contravariância, consulte .

• outTResult
  O tipo de resultado.

  Esse parâmetro de tipo é covariante. Ou seja, você pode usar o tipo especificado ou qualquer tipo mais derivado. Para obter mais informações sobre covariância e contravariância, consulte .

O tipo<TSource, TResult> do ISubject expõe os membros a seguir.

Métodos

	Nome	Descrição
método público	OnCompleted	(Herdado de IObserver<TSource>.)
método público	OnError	(Herdado de IObserver<TSource>.)
método público	OnNext	(Herdado de IObserver<TSource>.)
método público	Assinar	(Herdado de IObservable<TResult>.)

Início

Métodos de extensão

	Nome	Descrição
método de extensão pública	< >TResult (Func<TResult, TResult, TResult>)	Sobrecarregado. Aplica uma função de acumulador em uma sequência observável. (Definido por Observável .)
método de extensão pública	<TResult, TAccumulate>(TAccumulate, Func<TAccumulate, TResult, 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<> TResult	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	> TResult do Amb<	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<TResult, 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>TResult<()	Sobrecarregado. Determina se uma sequência observável contém elementos. (Definido por Observável .)
método de extensão pública	>TResult<(Func<TResult, 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	AsObservable	Oculta a identidade de uma sequência observável. (Definido por Observável .)
método de extensão pública	doAsObserver	Oculta a identidade de um observador. (Definido por Observer.)
método de extensão pública	AsQbservable TResult	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	< > do AssertEqual	(Definido por extensões .)
método de extensão pública	buffer<>TResult (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	buffer<>TResult (TimeSpan)	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	bufferTResult (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<>TResult (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<>TResult (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<>TResult (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<>TResult (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<>TResult (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	buffer<TResult,>TBufferClosing (<>>do<IObservável do Fun<c<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<TResult, TBufferOpening, TBufferClosing>(>TBufferOpening<IObservable>, 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	>TResult do Catch<(>TResult<IObservá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	<TResult, TException>(Func<TException, IObservable<TResult>>)	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<TResult, 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	> TResult<Concat	Concatena duas sequências observáveis. (Definido por Observável .)
método de extensão pública	contém<>TResult (TResult)	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<>TResult (TResult, IEqualityComparer<TResult>)	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 <> TResult	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	>TResult<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	<TResult>(TResult)	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	TResult(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	atraso<>TResult (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<>TResult (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<>TResult (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	>TResult<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	>TResult<Distinto (<TResult>do IEqualityComparer )	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	<Distinto TResult,>TKey (Func<TResult, 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	<Distinto TResult, TKey>(Func<TResult, 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>()	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<>TResult (>TResult do IEqualityComparer<)	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<TResult, TKey>(Func<TResult, 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<TResult, TKey>(Func<TResult, 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	doTResultTResult	Sobrecarregado. Invoca uma ação para cada elemento na sequência observável. (Definido por Observável .)
método de extensão pública	< >TResult (>TResult do IObserver<)	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	< >TResult (Ação<TResult>, 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	< >TResult (>TResult<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<TResult>(Action<TResult>, 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<> TResult	Retorna o elemento em um índice especificado em uma sequência. (Definido por Observável .)
método de extensão pública	ElementAtOrDefault<> TResult	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<> TResult	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<>TResult ()	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<>TResult (Func<TResult, 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	<TResult><TResult ()	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	TResultTResult (FuncTResult, booliano)	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<TResult, R>	(Definido por MyExt.)
método de extensão pública	TResult ForEach	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<TResult	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<TResult, TKey>(Func<TResult, 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<TResult, TKey>(Func<TResult, 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<TResult, TKey, TElement>(Func<TResult, TKey>, Func<TResult, 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<TResult, TKey, TElement>(Func<TResult, TKey>, Func<TResult, 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<TResult, TKey, TDuration>(Func<TResult, TKey>, Func<IGroupedObservable<TKey, TResult>, 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<TResult, TKey, TDuration>(Func<TResult, TKey>, Func<IGroupedObservable<TKey, TResult>, 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<TResult, TKey, TElement, TDuration>(Func<TResult, TKey>, Func<TResult, 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<TResult, TKey, TElement, TDuration>(Func<TResult, TKey>, Func<TResult, 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<TResult, 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<> TResult	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<TResult, 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	TResult>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	>TResult da última<(Func<TResult, 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	LastOrDefaultTResult	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	<TResult>(Func<TResult, 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	TResultmais recente do	Amostra o valor mais recente em uma sequência observável. (Definido por Observável .)
método de extensão pública	> < <TResult	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<> TResult	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	máximo de>TResult<()	Sobrecarregado. Retorna o elemento máximo em uma sequência observável. (Definido por Observável .)
método de extensão pública	>TResult do Max<(IComparer<TResult>)	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<TResult, TKey>(Func<TResult, 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	MaxBy<TResult, TKey>(Func<TResult, 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<>TResult (>TResult<IObservável )	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<>TResult (<>TResult , 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<>TResult ()	Sobrecarregado. Retorna o elemento mínimo em uma sequência observável. (Definido por Observável .)
método de extensão pública	>TResult do Min<(IComparer<TResult>)	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	<TResult, TKey>(Func<TResult, 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	<TResult, TKey>(Func<TResult, 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	> do MostRecent<TResult	Amostra o valor mais recente em uma sequência observável. (Definido por Observável .)
método de extensão pública	<Multicast TResult, TResult>(ISubject<TResult, 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<TResult, TIntermediate, TResult>(Func<ISubject<TResult, 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<> TResult	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	<TResult>do ObserveOn (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	ObserveOnTResult (Control)	Sobrecarregado. (Definido porControlObservable .)
método de extensão pública	>do<TResult (Dispatcher)	Sobrecarregado. (Definido pordispatcherObservable .)
método de extensão pública	< <TResult> (DispatcherScheduler)	Sobrecarregado. (Definido pordispatcherObservable .)
método de extensão pública	< >TResult (IScheduler) do ObserveOn	Sobrecarregado. Notifique os observadores de forma assíncrona sobre o agendador especificado. (Definido por Observável .)
método de extensão pública	< > do ObserveOnDispatcher	(Definido pordispatcherObservable .)
método de extensão pública	OnErrorResumeNext<TResult>	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>TResult<()	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	dedede PublicaçãoTResult (TResult)	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<TResult, TResult>(Func<IObservable<TResult>, 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<TResult, TResult>(Func<IObservable<TResult>, IObservable<TResult>>, TResult)	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	PublishLastTResult ()	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<TResult, TResult>(Func<IObservable<TResult>, 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>TResult<()	Sobrecarregado. Repete a sequência observável indefinidamente. (Definido por Observável .)
método de extensão pública	>TResult<de Repetição de<(Int32)	Sobrecarregado. Repete a sequência observável indefinidamente. (Definido por Observável .)
método de extensão pública	>TResult<replay ()	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<>TResult (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	doTResult(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< de>TResult (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<>TResult (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<>TResult (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	doTResult (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<>TResult (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<TResult, TResult>(Func<IObservable<TResult>, 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<TResult, TResult>(Func<IObservable<TResult>, 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<TResult, TResult>(Func<IObservable<TResult>, 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<TResult, TResult>(Func<IObservable<TResult>, 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<TResult, TResult>(Func<IObservable<TResult>, 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<TResult, TResult>(Func<IObservable<TResult>, 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	<TResult, TResult>(Func<IObservable<TResult>, 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<TResult, TResult>(Func<IObservable<TResult>, 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	< >TResult ()	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	repetir< de>TResult (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	> < >TResult (TimeSpan)	Sobrecarregado. Amostra a sequência observável em cada intervalo. (Definido por Observável .)
método de extensão pública	exemplo<>TResult (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	<TResult, 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<>TResult (Func<TResult, TResult, TResult>)	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	<TResult, TAccumulate>(TAccumulate, Func<TAccumulate, TResult, 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<TResult, TResult>(Func<TResult, 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<TResult, TResult>(Func<TResult, 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	<TResult, 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	<TResult, TResult>(Func<TResult, 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<TResult, TResult>(Func<TResult, 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<TResult, TResult>(Func<TResult, 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<TResult, TCollection, TResult>(Func<TResult, IEnumerable<TCollection>>, Func<TResult, 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<TResult, TCollection, TResult>(Func<TResult, IObservable<TCollection>>, Func<TResult, 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	< >TResult (<>TResult 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	< >TResult de SequenceEqual (>TResult<IObservable, IEqualityComparer<TResult>)	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	>TResult 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	>TResult<único (Func<TResult, 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	< <TRes>ult ()	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	>TResult<SingleOrDefault (Func<TResult, 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<> TResult	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	> TResult<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<TResult, 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	< >TResult (Func<TResult, 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	< >TResult (Func<TResult, 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<TResult>TResult[])	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<TResult>(IScheduler, TResult[])	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	< >TResult ()	Sobrecarregado. Avalia a sequência observável com uma origem especificada. (Definido por ObservableExtensions .)
método de extensão pública	< >TResult (<>TResult da Ação)	Sobrecarregado. Assina um manipulador de elementos em uma sequência observável. (Definido por ObservableExtensions .)
método de extensão pública	assinar<>TResult (<>TResult da Ação,>de Exceção de<de Ação)	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<>TResult (Action<TResult>, Action)	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<>TResult (Action<TResult>, 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<>TResult (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	SubscribeOn<>TResult (Controle)	Sobrecarregado. (Definido porControlObservable .)
método de extensão pública	< >TResult (Dispatcher)	Sobrecarregado. (Definido pordispatcherObservable .)
método de extensão pública	SubscribeOn<>TResult (DispatcherScheduler)	Sobrecarregado. (Definido pordispatcherObservable .)
método de extensão pública	SubscribeOn<>TResult (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<TResult>	(Definido pordispatcherObservable .)
método de extensão pública	Sincronizar<>TResult ()	Sobrecarregado. Sincroniza a sequência observável. (Definido por Observável .)
método de extensão pública	sincronizar<>TResult (objeto)	Sobrecarregado. Sincroniza a sequência observável. (Definido por Observável .)
método de extensão pública	levar<> TResult	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	TakeLastTResult	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<TResult, 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	<TResult>(Func<TResult, 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	< >TResult (Func<TResult, 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	<TResult, 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	limitar<>TResult (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<>TResult (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	> <TResult<()	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	<TResult>(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	> <TResult>(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	<TResult>(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	<TResult>(TimeSpan, IObservable<TResult>)	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	<TResult>(DateTimeOffset,<TResult>)	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<>TResult (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	<TResult>(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	> > <TResult (TimeSpan, IObservable<TResult>, 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	< >TResult (DateTimeOffset, IObservable<TResult>, 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	<TResult>() 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	<TResult>(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	> TResult<ToArray	Cria uma matriz com base em uma sequência observável. (Definido por Observável .)
método de extensão pública	ToDictionary<TResult, TKey>(Func<TResult, 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<TResult, TKey>(Func<TResult, 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<TResult, TKey, TElement>(Func<TResult, TKey>, Func<TResult, 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<TResult, TKey, TElement>(Func<TResult, TKey>, Func<TResult, 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	<TResult do ToEnumerable><	Converte uma sequência observável em uma sequência enumerável. (Definido por Observável .)
método de extensão pública	> TResult<ToEvent	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	doTResult do ToList	Cria uma lista de uma sequência observável. (Definido por Observável .)
método de extensão pública	ToLookup<TResult, TKey>(Func<TResult, 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<TResult, TKey>(Func<TResult, 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<TResult, TKey, TElement>(Func<TResult, TKey>, Func<TResult, 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<TResult, TKey, TElement>(Func<TResult, TKey>, Func<TResult, 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	doTSource ToNotifier	Cria um retorno de chamada de notificação de um observador. (Definido por Observer.)
método de extensão pública	>do ToTask<TResult ()	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	de>TResult (Objeto) do ToTask<	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	>TResult>do ToTas<k (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	ToTaskTResult (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	onde<>TResult (Func<TResult, booliano>)	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	Onde<>TResult (Func<TResult, 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	< >TResult (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	>TResult<de janela (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	>TResult<de Janela (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	< >TResult (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 <>TResult (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	< >TResult (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	< >TResult (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	< >TResult (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	<TResult, TWindowClosing>(Func<<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	>de janela<TResult, 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	<TResult, TSecond, TResult>(IObservable<TSecond>, Func<TResult, 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	<TResult, TSecond, TResult>(IEnumerable<TSecond>, Func<TResult, 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

Essa interface de assunto fornece a flexibilidade a um sujeito para observar uma sequência observável de um tipo durante a publicação de uma sequência observável de outro tipo.

Exemplos

Este exemplo demonstra a implementação de um ISubject<TSource, TResult> que observa uma sequência observável de um tipo durante a publicação de uma sequência observável de outro tipo. O AsciiConverterSubject neste exemplo demonstra a implementação observando sequências do tipo char e publicando uma sequência observável de int. A sequência observável publicada de int é o código ASCII para cada valor char observado.

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

namespace Example
{
  class Program
  {
    static void Main()
    {
      //****************************************************************************************//
      //*** Create an observable sequence of char from console input until enter is pressed. ***//
      //****************************************************************************************//
      IObservable<char> keySequence = Observable.Create<char>(observer =>
      {
        bool bContinue = true;

        while (bContinue)
        {
          ConsoleKeyInfo keyInfo = Console.ReadKey(true);

          if (keyInfo.Key != ConsoleKey.Enter)
          {
            observer.OnNext(keyInfo.KeyChar);
          }
          else
          {
            observer.OnCompleted();
            bContinue = false;
          }
        }

        return (() => { });
      });


      //****************************************************************************************//
      //*** Create an AsciiConverterSubject which takes a source type of char and returns an ***//
      //*** observable sequence of int which is the ASCII code for source items of char.     ***//
      //****************************************************************************************//

      AsciiConverterSubject myConverterSubject = new AsciiConverterSubject();


      //****************************************************************************************//
      //*** Subscribe to the keySequence on the .NET threadpool so the main thread can       ***//
      //*** create subscriptions to the AsciiConverterSubject                                ***//
      //****************************************************************************************//

      IDisposable subscription = keySequence.SubscribeOn(Scheduler.ThreadPool).Subscribe(myConverterSubject);


      Console.WriteLine("\nEnter a sequence of keys to have the AsciiConverterSubject\nconvert the keys to their ASCII code values.\n"); 
      Console.WriteLine("Press ENTER to terminate the observable sequence...\n");


      //****************************************************************************************//
      //*** Subscribe to the AsciiConverterSubject and write the ASCII code values to the    ***//
      //*** console window.                                                                  ***//
      //***                                                                                  ***//
      //*** The main thread will wait on the completion of the keySequence. It completes     ***//
      //*** when ENTER is pressed.                                                           ***//
      //****************************************************************************************//

      EventWaitHandle waitHandle = new EventWaitHandle(false, EventResetMode.ManualReset);
      myConverterSubject.Subscribe(c => Console.WriteLine("Ascii Char code {0} entered.",c), () => waitHandle.Set());
      waitHandle.WaitOne();


      //***************************************//
      //*** Explicitly releasing resources. ***//
      //***************************************//
      
      subscription.Dispose();
      myConverterSubject.Dispose();
    }
  }



  //***********************************************************************************************//
  //***                                                                                         ***//
  //*** The AsciiConverterSubject demonstrates an implementation of ISubject<TSource, TResult>. ***//
  //*** It is used to subscribe to an observable sequence of char. It publishes an observable   ***//
  //*** sequence of int which should be the ASCII code for each char value it observes.         ***//
  //***                                                                                         ***//
  //***********************************************************************************************//

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

    public AsciiConverterSubject()
    {
      observerList = new List<IObserver<int>>();
    }

    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)
        {
          foreach (IObserver<int> 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)
        {
          exception = error;

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

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

    public void OnNext(char 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)
        {
          foreach (IObserver<int> observer in observerList)
          {
            observer.OnNext(Convert.ToInt32(value));
          }
        }
      }
    }

    public IDisposable Subscribe(IObserver<int> 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)
        {
          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<int> observer)
    {
      //****************************************************************************************//
      //*** Make sure Unsubscribe occurs in sync with the other operations so we keep the    ***//
      //*** correct behavior.                                                                ***//
      //****************************************************************************************//

      lock (gate)
      {
        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)
      {
        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 AsciiConverterSubject subject;
      private IObserver<int> observer;

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

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

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

Enter a sequence of keys to have the AsciiConverterSubject
convert the keys to their ASCII code values.

Press ENTER to terminate the observable sequence...

Ascii Char code 59 entered.
Ascii Char code 108 entered.
Ascii Char code 115 entered.
Ascii Char code 100 entered.
Ascii Char code 107 entered.
Ascii Char code 102 entered.
Ascii Char code 59 entered.
Ascii Char code 108 entered.
Ascii Char code 115 entered.
Ascii Char code 100 entered.
Ascii Char code 107 entered.
Ascii Char code 102 entered.
Ascii Char code 59 entered.
Ascii Char code 108 entered.
Ascii Char code 115 entered.
Ascii Char code 107 entered.
Ascii Char code 100 entered.
Ascii Char code 59 entered.
Ascii Char code 102 entered.
Ascii Char code 108 entered.
Ascii Char code 115 entered.
Ascii Char code 107 entered.
Ascii Char code 100 entered.

Consulte Também

Referência

namespace System.Reactive.Subjects