Classe T> BehaviorSubject<
Representa um valor que muda ao longo do tempo.
Hierarquia de herança
System.Object
System.Reactive.Subjects.BehaviorSubject<T>
Namespace:System.Reactive.Subjects
Assembly: System.Reactive (em System.Reactive.dll)
Sintaxe
'Declaration
Public NotInheritable Class BehaviorSubject(Of T) _
Implements ISubject(Of T), ISubject(Of T, T), _
IObserver(Of T), IObservable(Of T), IDisposable
'Usage
Dim instance As BehaviorSubject(Of T)
public sealed class BehaviorSubject<T> : ISubject<T>,
ISubject<T, T>, IObserver<T>, IObservable<T>, IDisposable
generic<typename T>
public ref class BehaviorSubject sealed : ISubject<T>,
ISubject<T, T>, IObserver<T>, IObservable<T>, IDisposable
[<SealedAttribute>]
type BehaviorSubject<'T> =
class
interface ISubject<'T>
interface ISubject<'T, 'T>
interface IObserver<'T>
interface IObservable<'T>
interface IDisposable
end
JScript does not support generic types and methods.
Parâmetros de tipo
- T
O tipo.
O tipo T> BehaviorSubject<expõe os membros a seguir.
Construtores
| Nome | Descrição | |
|---|---|---|
.gif "Método público")
|
BehaviorSubject<T> | Inicializa uma nova instância da classe T> BehaviorSubject<que cria um assunto que armazena em cache seu último valor e começa com o valor especificado. |
Parte superior
Métodos
| Nome | Descrição | |
|---|---|---|
|
|
Dispose | Cancele a assinatura de todos os observadores e libere recursos. |
|
|
Igual a | (Herdado do objeto.) |
.gif "Método protegido")
|
Finalizar | (Herdado do objeto.) |
|
|
GetHashCode | (Herdado do objeto.) |
|
|
GetType | (Herdado do objeto.) |
|
|
Memberwiseclone | (Herdado do objeto.) |
|
|
OnCompleted | Notifica todos os observadores inscritos do final da sequência. |
|
|
OnError | Notifica todos os observadores inscritos com a exceção. |
|
|
Onnext | Notifica todos os observadores inscritos com o valor . |
|
|
Assinar | Assina um observador para o assunto. |
|
|
ToString | (Herdado do objeto.) |
Parte superior
Métodos de Extensão
| Nome | Descrição | |
|---|---|---|
.gif)
|
Agregar<T>(Func<T, T, T>) | Sobrecarregado. Aplica uma função de acumulador em uma sequência observável. (Definido por Observável.) |
|
|
Aggregate<T, TAccumulate>(TAccumulate, Func<TAccumulate, 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.) |
|
|
Todos os<T> | Determina se todos os elementos de uma sequência observável atendem a uma condição. (Definido por Observável.) |
|
|
Amb<T> | Propaga a sequência observável que reage primeiro com a primeira e a segunda sequência especificadas. (Definido por Observável.) |
|
|
E<T, TRight> | Corresponde quando ambas as sequências observáveis têm um valor disponível. (Definido por Observável.) |
|
|
Qualquer<T>() | Sobrecarregado. Determina se uma sequência observável contém elementos. (Definido por Observável.) |
|
|
Any<T>(Func<T, Boolean>) | Sobrecarregado. Determina se todos os elementos de uma sequência observável atendem a uma condição. (Definido por Observável.) |
|
|
AsObservable<T> | Oculta a identidade de uma sequência observável. (Definido por Observável.) |
|
|
AsObserver<T> | Oculta a identidade de um observador. (Definido pelo Observer.) |
|
Método |
AsQbservable<T> | Converte uma sequência observável em uma sequência observável que pode ser consultada. (Definido por Qbservable.) |
|
Método |
AssertEqual<T> | (Definido por Extensões.) |
|
Método |
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 |
Buffer<T>(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 |
Buffer<T>(Int32, Int32) | Sobrecarregado. Indica cada elemento de uma sequência observável em zero ou mais buffers produzidos com base nas informações de contagem de elementos. (Definido por Observável.) |
|
Método |
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 |
Buffer<T>(TimeSpan, TimeSpan) | Sobrecarregado. Indica cada elemento de uma sequência observável em zero ou mais buffers produzidos com base nas informações de tempo. (Definido por Observável.) |
|
Método |
Buffer<T>(TimeSpan, Int32) | Sobrecarregado. Indica cada elemento de uma sequência observável em um buffer que é enviado quando ele está cheio ou um determinado período de tempo decorrido. (Definido por Observável.) |
|
Método |
Buffer<T>(TimeSpan, TimeSpan, IScheduler) | Sobrecarregado. Indica cada elemento de uma sequência observável em zero ou mais buffers produzidos com base nas informações de tempo. (Definido por Observável.) |
|
Método |
Buffer<T>(TimeSpan, Int32, IScheduler) | Sobrecarregado. Indica cada elemento de uma sequência observável em um buffer que é enviado quando ele está cheio ou um determinado período de tempo decorrido. (Definido por Observável.) |
|
Método |
Buffer<T, TBufferClosing>(Func<IObservable<TBufferClosing>>) | Sobrecarregado. Indica cada elemento de uma sequência observável em buffers não sobrepostos consecutivos. (Definido por Observável.) |
|
Método |
Buffer<T, TBufferOpening, TBufferClosing>(IObservable<TBufferOpening>, Func<TBufferOpening, IObservable<TBufferClosing>>) | Sobrecarregado. Indica cada elemento de uma sequência observável consultável em buffers consecutivos não sobrepostos. (Definido por Observável.) |
|
Método |
Catch<T>(IObservable<T>) | 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 |
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 |
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 |
Concat<T> | Concatena duas sequências observáveis. (Definido por Observável.) |
|
Método |
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 |
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 |
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 |
DefaultIfEmpty<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 |
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 |
Delay<T>(TimeSpan) | Sobrecarregado. Indica a sequência observável por tempo de conclusão com a origem especificada e dueTime. (Definido por Observável.) |
|
Método |
Delay<T>(DateTimeOffset) | Sobrecarregado. Indica a sequência observável por tempo de conclusão com a origem especificada e dueTime. (Definido por Observável.) |
|
Método |
Delay<T>(TimeSpan, IScheduler) | Sobrecarregado. Indica a sequência observável por tempo de conclusão com a origem, dueTime e agendador especificados. (Definido por Observável.) |
|
Método |
Delay<T>(DateTimeOffset, IScheduler) | Sobrecarregado. Indica a sequência observável por tempo de conclusão com a origem, dueTime e agendador especificados. (Definido por Observável.) |
|
Método |
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 |
Distinct<T>(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 |
Distinct<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 |
Distinct<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 |
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 |
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 |
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 |
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 |
Do<T>(Action<T>) | Sobrecarregado. Invoca uma ação para cada elemento na sequência observável. (Definido por Observável.) |
|
Método |
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 |
Do<T>(Action<T>, Action) | Sobrecarregado. Invoca uma ação para cada elemento na sequência observável e invoca uma ação após o encerramento normal da sequência observável. (Definido por Observável.) |
|
Método |
Do<T>(Action<T>, Action<Exception>) | 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 |
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 no encerramento normal ou excepcional da sequência observável. (Definido por Observável.) |
|
Método |
ElementAt<T> | Retorna o elemento de um índice especificado em uma sequência. (Definido por Observável.) |
|
Método |
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 |
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 |
Primeiro<T>() | Sobrecarregado. Retorna o primeiro elemento de uma sequência observável com uma origem especificada. (Definido por Observável.) |
|
Método |
Primeiro<T>(Func<T, Boolean>) | Sobrecarregado. Retorna o primeiro elemento de uma sequência observável que corresponde ao predicado. (Definido por Observável.) |
|
Método |
FirstOrDefault<T>() | 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 |
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 |
Foo<T, R> | (Definido por MyExt.) |
|
Método |
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 |
GetEnumerator<T> | Retorna um enumerador que enumera todos os valores da sequência observável. (Definido por Observável.) |
|
Método |
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 |
GroupBy<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>) | Sobrecarregado. Agrupa os elementos de uma sequência observável de acordo com uma função de seletor de chave e um comparador especificados. (Definido por Observável.) |
|
Método |
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 |
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 |
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 |
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 de seletor de chave e um comparador especificados. (Definido por Observável.) |
|
Método |
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 |
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 |
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 |
IgnoreElements<T> | Ignora todos os valores em uma sequência observável, deixando apenas as mensagens de encerramento. (Definido por Observável.) |
|
Método |
Ingressar em<T, TRight, TLeftDuration, TRightDuration, TResult> | Correlaciona os elementos de duas sequências com base em durações sobrepostas. (Definido por Observável.) |
|
Método |
Último<T>() | Sobrecarregado. Retorna o último elemento de uma sequência observável com uma origem especificada. (Definido por Observável.) |
|
Método |
Último<T>(Func<T, Boolean>) | Sobrecarregado. Retorna o último elemento de uma sequência observável que corresponde ao predicado. (Definido por Observável.) |
|
Método |
LastOrDefault<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 |
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 |
T mais recente<> | Amostra o valor mais recente em uma sequência observável. (Definido por Observável.) |
|
Método |
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 |
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 |
Max<T>() | Sobrecarregado. Retorna o elemento máximo em uma sequência observável. (Definido por Observável.) |
|
Método |
Max<T>(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 |
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 |
MaxBy<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 |
Mesclar<T>(IObservable<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 |
Mesclar<T>(IObservable<T>, IScheduler) | Sobrecarregado. Mescla duas sequências observáveis em uma única sequência observável. (Definido por Observável.) |
|
Método |
Min<T>() | Sobrecarregado. Retorna o elemento mínimo em uma sequência observável. (Definido por Observável.) |
|
Método |
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 |
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 |
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 |
MostRecent<T> | Amostra o valor mais recente em uma sequência observável. (Definido por Observável.) |
|
Método |
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 |
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 por multicasting da sequência de origem dentro de uma função seletora. (Definido por Observável.) |
|
Método |
Próximo<T> | Amostra o próximo valor (bloqueio sem buffer) de em uma sequência observável. (Definido por Observável.) |
|
Método |
ObserveOn<T>(SynchronizationContext) | Sobrecarregado. Notifique observadores de forma assíncrona sobre o contexto de sincronização especificado. (Definido por Observável.) |
|
Método |
ObserveOn<T>(Control) | Sobrecarregado. (Definido por ControlObservable.) |
|
Método |
ObserveOn<T>(Dispatcher) | Sobrecarregado. (Definido por DispatcherObservable.) |
|
Método |
ObserveOn<T>(DispatcherScheduler) | Sobrecarregado. (Definido por DispatcherObservable.) |
|
Método |
ObserveOn<T>(IScheduler) | Sobrecarregado. Notifique observadores de forma assíncrona sobre o agendador especificado. (Definido por Observável.) |
|
Método |
ObserveOnDispatcher<T> | (Definido por DispatcherObservable.) |
|
Método |
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 |
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 |
Publicar<T>(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 |
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 |
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 |
PublishLast<T>() | 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 |
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 |
Repetir<T>() | Sobrecarregado. Repete a sequência observável indefinidamente. (Definido por Observável.) |
|
Método |
Repita<T>(Int32) | Sobrecarregado. Repete a sequência observável indefinidamente. (Definido por Observável.) |
|
Método |
Reproduzir<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 |
Reproduzir<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 |
Replay<T>(Int32) | Sobrecarregado. Retorna uma sequência observável conectável que compartilha uma única assinatura para a sequência subjacente que reproduz bufferSize notificações. (Definido por Observável.) |
|
Método |
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 |
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 |
Replay<T>(Int32, IScheduler) | Sobrecarregado. Retorna uma sequência observável conectável que compartilha uma única assinatura para a sequência subjacente que reproduz bufferSize notificações. (Definido por Observável.) |
|
Método |
Reproduzir<T>(Int32, TimeSpan) | Sobrecarregado. Retorna uma sequência observável conectável que compartilha uma única assinatura para a sequência subjacente que reproduz bufferSize notificações dentro da janela. (Definido por Observável.) |
|
Método |
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 bufferSize notificações dentro da janela. (Definido por Observável.) |
|
Método |
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 |
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 |
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 que reproduz todas as notificações dentro da janela. (Definido por Observável.) |
|
Método |
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 a sequência subjacente que reproduz notificações bufferSize. (Definido por Observável.) |
|
Método |
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 que reproduz todas as notificações dentro da janela. (Definido por Observável.) |
|
Método |
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 a sequência subjacente que reproduz notificações bufferSize. (Definido por Observável.) |
|
Método |
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 reproduz notificações bufferSize dentro da janela. (Definido por Observável.) |
|
Método |
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 reproduz notificações bufferSize dentro da janela. (Definido por Observável.) |
|
Método |
<Repetir T>() | Sobrecarregado. Repete a sequência observável de origem até que ela seja encerrada com êxito. (Definido por Observável.) |
|
Método |
<Repetir T>(Int32) | Sobrecarregado. Repete a sequência observável de origem até que ela seja encerrada com êxito. (Definido por Observável.) |
|
Método |
Exemplo<de T>(TimeSpan) | Sobrecarregado. Amostra a sequência observável em cada intervalo. (Definido por Observável.) |
|
Método |
Exemplo<de 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 |
Exemplo<de T, TSample>(IObservable<TSample>) | Sobrecarregado. Amostra a sequência observável em tiques de amostragem com a origem e o sampler especificados. (Definido por Observável.) |
|
Método |
Digitalizar<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 |
Scan<T, TAccumulate>(TAccumulate, Func<TAccumulate, 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 |
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 |
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 |
SelectMany<T, TOther>(IObservable<TOther>) | Sobrecarregado. Projeta cada elemento de uma sequência observável para uma sequência observável e nivela as sequências observáveis resultantes em uma sequência observável. (Definido por Observável.) |
|
Método |
SelectMany<T, TResult>(Func<T, IObservable<TResult>>) | Sobrecarregado. Projeta cada elemento de uma sequência observável para uma sequência observável e nivela as sequências observáveis resultantes em uma sequência observável. (Definido por Observável.) |
|
Método |
SelectMany<T, TResult>(Func<T, IEnumerable<TResult>>) | Sobrecarregado. Projeta cada elemento de uma sequência observável para uma sequência observável e nivela as sequências observáveis resultantes em uma sequência observável. (Definido por Observável.) |
|
Método |
SelectMany<T, TResult>(Func<T, IObservable<TResult>>, Func<Exception, IObservable<TResult>>, Func<IObservable<TResult>>) | Sobrecarregado. Projeta cada elemento de uma sequência observável para uma sequência observável e nivela as sequências observáveis resultantes em uma sequência observável. (Definido por Observável.) |
|
Método |
SelectMany<T, TCollection, TResult>(Func<T, IEnumerable<TCollection>>, Func<T, TCollection, TResult>) | Sobrecarregado. Projeta cada elemento de uma sequência observável para uma sequência observável e nivela as sequências observáveis resultantes em uma sequência observável. (Definido por Observável.) |
|
Método |
SelectMany<T, TCollection, TResult>(Func<T, IObservable<TCollection>>, Func<T, TCollection, TResult>) | Sobrecarregado. Projeta cada elemento de uma sequência observável para uma sequência observável e nivela as sequências observáveis resultantes em uma sequência observável. (Definido por Observável.) |
|
|
SequenceEqual<T>(IObservable<T>) | Sobrecarregado. Determina se duas sequências são iguais comparando os elementos em par. (Definido por Observável.) |
|
|
SequenceEqual<T>(IObservable<T>, IEqualityComparer<T>) | Sobrecarregado. Determina se duas sequências são iguais comparando os elementos em par usando um comparador de igualdade especificado. (Definido por Observável.) |
|
|
T>() ú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.) |
|
|
Single<T>(Func<T, Boolean>) | 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.) |
|
|
SingleOrDefault<T>() | 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.) |
|
|
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.) |
|
|
Ignorar<T> | Ignora um número especificado de valores em uma sequência observável e retorna os valores restantes. (Definido por Observável.) |
|
|
SkipLast<T> | Ignora um número especificado de elementos no final de uma sequência observável. (Definido por Observável.) |
|
|
SkipUntil<T, TOther> | Retorna os valores da sequência observável de origem somente depois que a outra sequência observável produz um valor. (Definido por Observável.) |
|
|
SkipWhile<T>(Func<T, 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.) |
|
|
SkipWhile<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.) |
|
|
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.) |
|
|
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.) |
|
|
<Assinar T>() | Sobrecarregado. Avalia a sequência observável com uma origem especificada. (Definido por ObservableExtensions.) |
|
|
Assinar<T>(Ação<T>) | Sobrecarregado. Assina um manipulador de elementos para uma sequência observável. (Definido por ObservableExtensions.) |
|
|
Assinar<T>(Ação<T>, Exceção> de Ação<) | Sobrecarregado. Assina um manipulador de elementos e um manipulador de exceção para uma sequência observável. (Definido por ObservableExtensions.) |
|
|
Assinar<T>(Ação<T>, Ação) | Sobrecarregado. Assina um manipulador de elementos e um manipulador de conclusão para uma sequência observável. (Definido por ObservableExtensions.) |
|
|
<Assinar T>(Ação<T>, Exceção> de Ação<, Ação) | Sobrecarregado. Assina um manipulador de elementos, um manipulador de exceção e um manipulador de conclusão para uma sequência observável. (Definido por ObservableExtensions.) |
|
|
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.) |
|
|
SubscribeOn<T>(Control) | Sobrecarregado. (Definido por ControlObservable.) |
|
|
SubscribeOn<T>(Dispatcher) | Sobrecarregado. (Definido por DispatcherObservable.) |
|
|
SubscribeOn<T>(DispatcherScheduler) | Sobrecarregado. (Definido por DispatcherObservable.) |
|
|
SubscribeOn<T>(IScheduler) | Sobrecarregado. Assina e cancela a assinatura de observadores de forma assíncrona no agendador especificado. (Definido por Observável.) |
|
|
SubscribeOnDispatcher<T> | (Definido por DispatcherObservable.) |
|
|
Sincronizar<T>() | Sobrecarregado. Sincroniza a sequência observável. (Definido por Observável.) |
|
|
Sincronizar<T>(Object) | Sobrecarregado. Sincroniza a sequência observável. (Definido por Observável.) |
|
|
Tome<T> | Retorna um número especificado de valores contíguos desde o início de uma sequência observável. (Definido por Observável.) |
|
|
TakeLast<T> | Retorna um número especificado de elementos contíguos do final de uma sequência observável. (Definido por Observável.) |
|
|
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.) |
|
|
TakeWhile<T>(Func<T, 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.) |
|
|
TakeWhile<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.) |
|
|
Em seguida<, T, TResult> | Corresponde quando a sequência observável tem um valor disponível e projeta o valor. (Definido por Observável.) |
|
|
Throttle<T>(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 especificada e dueTime. (Definido por Observável.) |
|
|
Throttle<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, dueTime e agendador especificados. (Definido por Observável.) |
|
|
TimeInterval<T>() | Sobrecarregado. Registra o intervalo de tempo entre valores consecutivos em uma sequência observável com a origem especificada. (Definido por Observável.) |
|
|
TimeInterval<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.) |
|
|
Tempo limite<T>(TimeSpan) | Sobrecarregado. Retorna a sequência observável ou um TimeoutException se dueTime decorrer. (Definido por Observável.) |
|
|
Tempo limite<T>(DateTimeOffset) | Sobrecarregado. Retorna a sequência observável ou uma TimeoutException se dueTime decorrer. (Definido por Observável.) |
|
|
Tempo limite<T>(TimeSpan, IObservable<T>) | Sobrecarregado. Retorna a sequência observável de origem ou a outra sequência observável se dueTime decorrer. (Definido por Observável.) |
|
|
Tempo limite<T>(DateTimeOffset, IObservable<T>) | Sobrecarregado. Retorna a sequência observável ou um TimeoutException se dueTime decorrer. (Definido por Observável.) |
|
|
Tempo limite<T>(TimeSpan, IScheduler) | Sobrecarregado. Retorna a sequência observável ou um TimeoutException se dueTime decorrer. (Definido por Observável.) |
|
|
Tempo limite<T>(DateTimeOffset, IScheduler) | Sobrecarregado. Retorna a sequência observável ou um TimeoutException se dueTime decorrer. (Definido por Observável.) |
|
|
Tempo limite<T>(TimeSpan, IObservable<T>, IScheduler) | Sobrecarregado. Retorna a sequência observável de origem ou a outra sequência observável se dueTime decorrer. (Definido por Observável.) |
|
|
Tempo limite<T>(DateTimeOffset, IObservable<T>, IScheduler) | Sobrecarregado. Retorna a sequência observável de origem ou a outra sequência observável se dueTime decorrer. (Definido por Observável.) |
|
|
Carimbo de<data/hora T>() | Sobrecarregado. Registra o carimbo de data/hora de cada valor em uma sequência observável com a origem especificada. (Definido por Observável.) |
|
|
Carimbo de data/hora<T>(IScheduler) | Sobrecarregado. Registra o carimbo de data/hora de cada valor em uma sequência observável com a origem e o agendador especificados. (Definido por Observável.) |
|
|
ToArray<T> | Cria uma matriz com base em uma sequência observável. (Definido por Observável.) |
|
|
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.) |
|
|
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.) |
|
|
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 seletora de elemento. (Definido por Observável.) |
|
|
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 seletora de elemento. (Definido por Observável.) |
|
|
ToEnumerable<T> | Converte uma sequência observável em uma sequência enumerável. (Definido por Observável.) |
|
|
ToEvent<T> | Expõe uma sequência observável como um objeto com um evento .NET com uma origem especificada. (Definido por Observável.) |
|
|
ToList<T> | Cria uma lista com base em uma sequência observável. (Definido por Observável.) |
|
|
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.) |
|
|
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.) |
|
|
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 seletora de elemento. (Definido por Observável.) |
|
|
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 seletora de elemento. (Definido por Observável.) |
|
|
ToNotifier<T> | Cria um retorno de chamada de notificação de um observador. (Definido pelo Observer.) |
|
|
ToTask<T>() | Sobrecarregado. Retorna uma tarefa que contém o último valor da sequência observável. (Definido por TaskObservableExtensions.) |
|
|
ToTask<T>(Object) | Sobrecarregado. Retorna uma tarefa que contém o último valor da sequência observável. (Definido por TaskObservableExtensions.) |
|
|
ToTask<T>(CancellationToken) | Sobrecarregado. Retorna uma tarefa que contém o último valor da sequência observável. (Definido por TaskObservableExtensions.) |
|
|
ToTask<T>(CancellationToken, Object) | Sobrecarregado. Retorna uma tarefa que contém o último valor da sequência observável. (Definido por TaskObservableExtensions.) |
|
Método |
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 |
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 |
Janela<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 |
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 |
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 |
Janela<T>(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 |
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 |
Janela<T>(TimeSpan, Int32) | Sobrecarregado. Projeta cada elemento de uma sequência observável em uma janela que é concluída quando está cheia ou um determinado período de tempo decorrido. (Definido por Observável.) |
|
Método |
Janela<T>(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 |
Janela<T>(TimeSpan, Int32, IScheduler) | Sobrecarregado. Projeta cada elemento de uma sequência observável em uma janela que é concluída quando está cheia ou um determinado período de tempo decorrido. (Definido por Observável.) |
|
Método |
Janela<T, TWindowClosing>(Func<IObservable<TWindowClosing>>) | Sobrecarregado. Projeta cada elemento de uma sequência observável em janelas consecutivas não sobrepostas. (Definido por Observável.) |
|
Método |
Window<T, TWindowOpening, TWindowClosing>(IObservable<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 |
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 |
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.) |
Parte superior
Comentários
Um assunto atua de forma semelhante a um proxy, pois atua como um assinante e um editor. Sua interface IObserver pode ser usada para assinar vários fluxos ou sequências de dados. Em seguida, os dados são publicados por meio da interface IObservable.
Um BehaviorSubject armazena em buffer o último item publicado por meio de sua interface IObservable. Se nenhum item tiver sido publicado por meio de sua interface IObservable, o item inicial fornecido no construtor será o item armazenado em buffer no momento. Quando uma assinatura é feita na interface IObservable do BehaviorSubject, a sequência publicada começa com o item armazenado em buffer no momento.
Nenhum item é armazenado em buffer ou publicado de um BehaviorSubject depois que sua interface IObserver recebe uma conclusão.
Exemplos
Este exemplo demonstra o BehaviorSubject. O exemplo usa o operador Interval para publicar um inteiro em uma sequência de inteiros a cada segundo. A sequência será concluída pelo operador Take depois que 10 inteiros forem publicados. Essa é a sequência na qual o BehaviorSubject assina.
Duas assinaturas são criadas para a interface IObservable do BehaviorSubject para mostrar como ela publica seus dados.
Assinatura nº 1 : essa assinatura começará no início e mostrará o valor inicial armazenado em buffer do construtor (-9) na sequência.
Assinatura nº 2 : essa assinatura será iniciada após uma suspensão de 5 segundos. Esta assinatura mostra que a sequência começa com o item armazenado em buffer no momento.
using System;
using System.Reactive.Linq;
using System.Reactive.Subjects;
using System.Reactive.Concurrency;
using System.Threading;
namespace Example
{
class Program
{
static void Main()
{
//********************************************************************************************************//
//*** A subject acts similar to a proxy in that it acts as both a subscriber and a publisher ***//
//*** It's IObserver interface can be used to subscribe to multiple streams or sequences of data. ***//
//*** The data is then published through it's IObservable interface. ***//
//*** ***//
//*** A BehaviorSubject buffers the last item it published through its IObservable interface. If no ***//
//*** item has been published through its IObservable interface then the initial item provided in the ***//
//*** constructor is the current buffered item. When a subscription is made to the BehaviorSubject's ***//
//*** IObservable interface, the sequence published begins with the currently buffered item. ***//
//*** ***//
//*** No items are buffered or published from a BehaviorSubject once its IObserver interface receives ***//
//*** a completion. ***//
//*** ***//
//*** In this example, we use the Interval operator to publish an integer to a integer sequence every ***//
//*** second. The sequence will be completed by the Take operator after 10 integers are published. ***//
//*** This will be the sequence that the BehaviorSubject subscribes to. ***//
//*** ***//
//*** We will create 2 subscriptions to the BehaviorSubject's IObservable interface to show how it ***//
//*** publishes it's data. ***//
//*** ***//
//*** Subscription #1 : This subscription will start at the very beginning and will show the initial ***//
//*** buffered value from the constructor (-9) in the sequence. ***//
//*** ***//
//*** Subscription #2 : This subscription will start after a 5 sec. sleep showing the sequence starts ***//
//*** with the currently buffered item. ***//
//********************************************************************************************************//
BehaviorSubject<long> myBehaviorSubject = new BehaviorSubject<long>((-9));
Observable.Interval(TimeSpan.FromSeconds(1), Scheduler.ThreadPool).Take(10).Subscribe(myBehaviorSubject);
//********************************************************************************************************//
//*** Subscription #1 : This subscription will start at the very beginning and will show the initial ***//
//*** buffered value from the constructor (-9) in the sequence. ***//
//********************************************************************************************************//
EventWaitHandle wait1 = new EventWaitHandle(false, EventResetMode.ManualReset);
myBehaviorSubject.Subscribe(x => Console.WriteLine("Subscription #1 observes : " + x),
() =>
{
Console.WriteLine("Subscription #1 completed.");
wait1.Set();
});
//********************************************************************************************************//
//*** Subscription #2 : This subscription will start after a 5 sec. sleep showing the sequence starts ***//
//*** with the currently buffered item. ***//
//********************************************************************************************************//
Thread.Sleep(5000);
EventWaitHandle wait2 = new EventWaitHandle(false, EventResetMode.ManualReset);
myBehaviorSubject.Subscribe(x => Console.WriteLine("{0,30}Subscription #2 observes : {1}", " ", x),
() =>
{
Console.WriteLine("{0,30}Subscription #2 completed.", " ");
wait2.Set();
});
//**************************************************//
// *** Wait for completion on both subscriptions ***//
//**************************************************//
WaitHandle.WaitAll(new WaitHandle[] { wait1, wait2 });
myBehaviorSubject.Dispose();
Console.WriteLine("\nPress ENTER to exit...");
Console.ReadLine();
}
}
}
A saída a seguir do código de exemplo mostra as assinaturas sobrepostas.
Subscription #1 observes : -9
Subscription #1 observes : 0
Subscription #1 observes : 1
Subscription #1 observes : 2
Subscription #1 observes : 3
Subscription #1 observes : 4
Subscription #2 observes : 4
Subscription #1 observes : 5
Subscription #2 observes : 5
Subscription #1 observes : 6
Subscription #2 observes : 6
Subscription #1 observes : 7
Subscription #2 observes : 7
Subscription #1 observes : 8
Subscription #2 observes : 8
Subscription #1 observes : 9
Subscription #2 observes : 9
Subscription #1 completed.
Subscription #2 completed.
Press ENTER to exit...
Acesso thread-safe
Qualquer membro estático público (Shared no Visual Basic) desse tipo é seguro para threads. Não há garantia de que qualquer membro de instância seja seguro para threads.