BehaviorSubject<T> 类

2011-06-28

表示一个随时间变化的值。

继承层次结构

System.Object
System.Reactive.Subjects.BehaviorSubject<T>

命名空间：System.Reactive.Subjects
程序集： System.Reactive（System.Reactive.dll）

语法

'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.

类型参数

T
类型。

BehaviorSubject<T> 类型公开以下成员。

构造函数

	名字	描述
	BehaviorSubject<T>	初始化 BehaviorSubject<T> 类的新实例，该类创建缓存其最后一个值且以指定值开头的主题。

返回页首

方法

	名字	描述
	Dispose	取消订阅所有观察程序并释放资源。
	equals	（继承自对象.）
	完成	（继承自对象.）
	GetHashCode	（继承自对象.）
	GetType	（继承自对象.）
	MemberwiseClone	（继承自对象.）
	OnCompleted	通知序列末尾的所有订阅观察者。
	onError	通知所有订阅的观察者，但例外。
	OnNext	向所有订阅的观察者通知该值。
	订阅	订阅主题的观察者。
	ToString	（继承自对象.）

返回页首

扩展方法

	名字	描述
	聚合<T>（Func<T， T， T>）	重载。对可观测序列应用累加器函数。（由可观测定义。
	聚合<T、TAccumulate>（TAccumulate、Func<TAccumulate、T、T、TAccumulate>）	重载。对具有指定种子值的可观测序列应用累加器函数。（由可观测定义。
	所有<T>	确定可观测序列的所有元素是否满足条件。（由可观测定义。
	Amb<T>	传播具有指定第一个和第二个序列的第一个和第二个序列的可观察序列。（由可观测定义。
	和<T、TRight>	当两个可观测序列都具有可用值时匹配。（由可观测定义。
	任何<T>（）	重载。确定可观测序列是否包含任何元素。（由可观测定义。
	任何<T>（Func<T， boolean>）	重载。确定可观测序列的所有元素是否满足条件。（由可观测定义。
	AsObservable<T>	隐藏可观测序列的标识。（由可观测定义。
	AsObserver<T>	隐藏观察者的标识。（由观察家定义。
	AsQbservable<T>	将可观测序列转换为可查询的可观察序列。（由 Qbservable定义。
	AssertEqual<T>	（由扩展定义）
	缓冲区<T>（Int32）	重载。指示可观测序列的每个元素成连续的非重叠缓冲区，这些缓冲区基于元素计数信息生成。（由可观测定义。
	缓冲区<T>（TimeSpan）	重载。指示可观测序列的每个元素成连续的非重叠缓冲区，这些缓冲区基于计时信息生成。（由可观测定义。
	缓冲区<T>（Int32， Int32）	重载。将可观测序列的每个元素指示为零个或多个缓冲区，这些缓冲区基于元素计数信息生成。（由可观测定义。
	缓冲区<T>（TimeSpan， IScheduler）	重载。指示可观测序列的每个元素成连续的非重叠缓冲区，这些缓冲区基于计时信息生成。（由可观测定义。
	缓冲区<T>（TimeSpan， TimeSpan）	重载。将可观测序列的每个元素指示为零个或多个缓冲区，这些缓冲区是根据计时信息生成的。（由可观测定义。
	缓冲区<T>（TimeSpan， Int32）	重载。将可观测序列的每个元素指示到缓冲区中，当缓冲区已满或给定的时间已过时发送。（由可观测定义。
	缓冲区<T>（TimeSpan、TimeSpan、IScheduler）	重载。将可观测序列的每个元素指示为零个或多个缓冲区，这些缓冲区是根据计时信息生成的。（由可观测定义。
	Buffer<T>（TimeSpan， Int32， IScheduler）	重载。将可观测序列的每个元素指示到缓冲区中，当缓冲区已满或给定的时间已过时发送。（由可观测定义。
	缓冲区<T、TBufferClosing>（Func<IObservable<TBufferClosing>>）	重载。指示可观测序列的每个元素进入连续的非重叠缓冲区。（由可观测定义。
	缓冲区<T、TBufferOpening、TBufferClosing>（IObservable<TBufferOpening>、Func<TBufferOpening、IObservable<TBufferClosing>>）	重载。指示可查询可观察序列的每个元素进入连续的非重叠缓冲区。（由可观测定义。
	Catch<T>（IObservable<T>）	重载。继续一个可观察序列，该序列由具有下一个可观察序列的异常终止。（由可观测定义。
	Catch<T、TException>（Func<TException、 IObservable<T>>）	重载。继续一个可观察序列，该序列由指定类型的异常终止，该序列由处理程序生成的可观测序列终止。（由可观测定义。
	CombineLatest<T、TSecond、TResult>	每当其中一个可观测序列生成元素时，使用选择器函数将两个可观测序列合并到一个可观察序列中。（由可观测定义。
	Concat<T>	连接两个可观测序列。（由可观测定义。
	包含<T>（T）	重载。使用默认相等比较器确定可观测序列是否包含指定的元素。（由可观测定义。
	包含<T>（T， IEqualityComparer<T>）	重载。确定可观测序列是否使用指定的 System.Collections.Generic.IEqualityComparer< 包含指定的元素;T>。（由可观测定义。
	计数<T>	返回一个 Int32，表示可观测序列中的元素总数。（由可观测定义。
	DefaultIfEmpty<T>（）	重载。如果序列为空，则返回指定序列的元素或类型参数在单一实例序列中的默认值。（由可观测定义。
	DefaultIfEmpty<T>（T）	重载。如果序列为空，则返回指定序列的元素或类型参数在单一实例序列中的默认值。（由可观测定义。
	延迟<T>（TimeSpan）	重载。通过指定的源和 dueTime 按到期时间指示可观测序列。（由可观测定义。
	延迟<T>（DateTimeOffset）	重载。通过指定的源和 dueTime 按到期时间指示可观测序列。（由可观测定义。
	延迟<T>（TimeSpan， IScheduler）	重载。通过指定的源、dueTime 和计划程序按到期时间指示可观测序列。（由可观测定义。
	延迟<T>（DateTimeOffset， IScheduler）	重载。通过指定的源、dueTime 和计划程序按到期时间指示可观测序列。（由可观测定义。
	不同<T>（）	重载。返回一个可观察序列，该序列仅包含具有指定源的不同元素。（由可观测定义。
	Distinct<T>（IEqualityComparer<T>）	重载。返回一个可观察序列，该序列仅包含根据比较器的不同元素。（由可观测定义。
	不同<T、TKey>（Func<T、TKey>）	重载。返回一个可观察序列，该序列仅包含根据 keySelector 的不同元素。（由可观测定义。
	不同的<T、TKey>（Func<T、TKey>、IEqualityComparer<TKey>）	重载。返回一个可观察序列，该序列仅包含根据 keySelector 的不同元素。（由可观测定义。
	DistinctUntilChanged<T>（）	重载。返回一个可观察序列，该序列仅包含具有指定源的不同连续元素。（由可观测定义。
	DistinctUntilChanged<T>（IEqualityComparer<T>）	重载。返回一个可观察序列，该序列仅包含根据比较器的不同连续元素。（由可观测定义。
	DistinctUntilChanged<T、TKey>（Func<T、TKey>）	重载。返回一个可观察序列，该序列仅包含根据 keySelector 的不同连续元素。（由可观测定义。
	DistinctUntilChanged<T、TKey>（Func<T、TKey>、IEqualityComparer<TKey>）	重载。返回一个可观察序列，该序列仅包含根据 keySelector 和比较器的不同连续元素。（由可观测定义。
	做<T>（操作<T>）	重载。调用可观察序列中每个元素的操作。（由可观测定义。
	做<T>（IObserver<T>）	重载。调用可观测序列中每个元素的操作，并在可观测序列异常终止时调用操作。（由可观测定义。
	做<T>（操作<T>，操作）	重载。调用可观测序列中每个元素的操作，并在可观测序列正常终止时调用操作。（由可观测定义。
	执行<T>（操作<T>、操作<异常>）	重载。调用可观测序列中每个元素的操作，并在可观测序列异常终止时调用操作。（由可观测定义。
	执行<T>（操作<T>、操作<异常>、操作）	重载。为可观测序列中的每个元素调用操作，并在可观测序列正常终止或异常终止时调用操作。（由可观测定义。
	ElementAt<T>	返回序列中指定索引处的元素。（由可观测定义。
	ElementAtOrDefault<T>	返回序列中指定索引处的元素;如果索引范围不足，则返回默认值。（由可观测定义。
	终于<T>	在源可观测序列正常终止或异常后调用指定的操作。（由可观测定义。
	第一<T>（）	重载。返回具有指定源的可观测序列的第一个元素。（由可观测定义。
	第一<T>（Func<T， boolean>）	重载。返回与谓词匹配的可观察序列的第一个元素。（由可观测定义。
	FirstOrDefault<T>（）	重载。返回可观测序列的第一个元素;如果未找到任何值，则返回默认值。（由可观测定义。
	FirstOrDefault<T>（Func<T， boolean>）	重载。返回与谓词匹配的可观察序列的第一个元素，如果未找到任何值，则返回默认值。（由可观测定义。
	Foo<T、R>	（由 MyExt定义。
	ForEach<T>	为可观察序列中的每个元素调用一个操作，并在序列终止之前阻止。（由可观测定义。
	GetEnumerator<T>	返回枚举器，该枚举器枚举可观测序列的所有值。（由可观测定义。
	GroupBy<T、TKey>（Func<T、TKey>）	重载。根据指定的键选择器函数对可观测序列的元素进行分组。（由可观测定义。
	GroupBy<T、TKey>（Func<T、TKey>、IEqualityComparer<TKey>）	重载。根据指定的键选择器函数和比较器对可观测序列的元素进行分组。（由可观测定义。
	GroupBy<T、TKey、TElement>（Func<T、TKey>、Func<T、TElement>）	重载。对可观测序列的元素进行分组，并使用指定的函数选择生成的元素。（由可观测定义。
	GroupBy<T、TKey、TElement>（Func<T、TKey>、Func<T、TElement>、IEqualityComparer<TKey>）	重载。根据指定的键选择器函数和比较器对可观测序列的元素进行分组，并使用指定的函数选择生成的元素。（由可观测定义。
	GroupByUntil<T、TKey、TDuration>（Func<T、TKey>、Func<IGroupedObservable<TKey、T>、IObservable<TDuration>>）	重载。根据指定的键选择器函数对可观测序列的元素进行分组。（由可观测定义。
	GroupByUntil<T、TKey、TDuration>（Func<T、TKey>、Func<IGroupedObservable<TKey、T>、IObservable<TDuration>>、IEqualityComparer<TKey>）	重载。根据指定的键选择器函数和比较器对可观测序列的元素进行分组。（由可观测定义。
	GroupByUntil<T、TKey、TElement、TDuration>（Func<T、TKey>、Func<T、TElement>、Func<IGroupedObservable<TKey、TElement>、IObservable<TDuration>>）	重载。根据指定的键选择器函数对可观测序列的元素进行分组，并使用指定的函数选择生成的元素。（由可观测定义。
	GroupByUntil<T， TKey、TElement、TDuration>（Func<T、TKey>、Func<T、TElement>、Func<IGroupedObservable<TKey、TElement>、IObservable<TDuration>>、IEqualityComparer<TKey>）	重载。根据指定的键选择器函数和比较器对可观测序列的元素进行分组，并使用指定的函数选择生成的元素。（由可观测定义。
	GroupJoin<T、TRight、TLeftDuration、TRightDuration、TResult>	根据重叠持续时间关联两个序列的元素，并对结果进行分组。（由可观测定义。
	IgnoreElements<T>	忽略可观察序列中的所有值，只保留终止消息。（由可观测定义。
	联接<T、TRight、TLeftDuration、TRightDuration、TResult>	根据重叠持续时间关联两个序列的元素。（由可观测定义。
	上次<T>（）	重载。返回具有指定源的可观察序列的最后一个元素。（由可观测定义。
	上次<T>（Func<T， boolean>）	重载。返回与谓词匹配的可观察序列的最后一个元素。（由可观测定义。
	LastOrDefault<T>（）	重载。返回可观测序列中的最后一个元素;如果未找到任何值，则返回默认值。（由可观测定义。
	LastOrDefault<T>（Func<T， boolean>）	重载。返回与谓词匹配的可观察序列的最后一个元素，如果未找到任何值，则返回默认值。（由可观测定义。
	最新<T>	对可观测序列中的最新值进行采样。（由可观测定义。
	LongCount<T>	返回一个 Int64，表示可观测序列中的元素总数。（由可观测定义。
	具体化<T>	具体化可观测序列的隐式通知作为显式通知值。（由可观测定义。
	最大<T>（）	重载。返回可观测序列中的最大元素。（由可观测定义。
	Max<T>（IComparer<T>）	重载。根据指定的比较器返回可观察序列中的最大值。（由可观测定义。
	MaxBy<T、TKey>（Func<T、TKey>）	重载。返回具有最大键值的可观察序列中的元素。（由可观测定义。
	MaxBy<T、TKey>（Func<T、TKey>、IComparer<TKey>）	重载。返回具有最大键值的可观察序列中的元素。（由可观测定义。
	合并<T>（IObservable<T>）	重载。将可观测序列的可观测序列合并到可观测序列中。（由可观测定义。
	合并<T>（IObservable<T>， IScheduler）	重载。将两个可观测序列合并为单个可观测序列。（由可观测定义。
	Min<T>（）	重载。返回可观测序列中的最小元素。（由可观测定义。
	Min<T>（IComparer<T>）	重载。根据指定的比较器返回可观测序列中的最小值。（由可观测定义。
	MinBy<T、TKey>（Func<T、TKey>）	重载。返回具有最小值的可观察序列中的元素。（由可观测定义。
	MinBy<T、TKey>（Func<T、TKey>、IComparer<TKey>）	重载。根据指定的比较器返回具有最小键值的可观测序列中的元素。（由可观测定义。
	MostRecent<T>	对可观测序列中的最新值进行采样。（由可观测定义。
	多播<T、TResult>（ISubject<T、TResult>）	重载。返回一个可连接的可观察序列，该序列在连接时会导致源序列将结果推送到指定的主题中。（由可观测定义。
	多播<T、TIntermediate、TResult>（Func<ISubject<T、TIntermediate>>、Func<IObservable<TIntermediate>、IObservable<TResult>>）	重载。返回一个可观察序列，该序列包含由多播源序列在选择器函数中生成的序列的元素。（由可观测定义。
	下一<T>	从可观测序列中采样下一个值（阻止而不缓冲）。（由可观测定义。
	ObserveOn<T>（SynchronizationContext）	重载。在指定的同步上下文中异步通知观察程序。（由可观测定义。
	ObserveOn<T>（控制）	重载。（由 ControlObservable定义。
	ObserveOn<T>（调度程序）	重载。（由 DispatcherObservable定义）
	ObserveOn<T>（DispatcherScheduler）	重载。（由 DispatcherObservable定义）
	ObserveOn<T>（IScheduler）	重载。在指定的计划程序上异步通知观察程序。（由可观测定义。
	ObserveOnDispatcher<T>	（由 DispatcherObservable定义）
	OnErrorResumeNext<T>	继续一个可观察序列，该序列以正常方式终止，或者由具有下一个可观察序列的异常终止。（由可观测定义。
	发布<T>（）	重载。返回一个可连接的可观察序列，该序列与基础序列共享单个订阅。（由可观测定义。
	发布<T>（T）	重载。返回一个可连接可观察序列，该序列与基础序列共享单个订阅并从 initialValue 开始。（由可观测定义。
	发布<T、TResult>（Func<IObservable<T>、IObservable<TResult>>）	重载。返回一个可观察序列，该序列是调用可连接可观测序列上的选择器的结果，该序列与基础序列共享单个订阅。（由可观测定义。
	发布<T、TResult>（Func<IObservable<T>、IObservable<TResult>>、T）	重载。返回一个可连接可观察序列，该序列与基础序列共享单个订阅并从 initialValue 开始。（由可观测定义。
	PublishLast<T>（）	重载。返回一个可连接可观察序列，该序列将单个订阅共享到仅包含最后一个通知的基础序列。（由可观测定义。
	PublishLast<T、TResult>（Func<IObservable<T>、IObservable<TResult>>）	重载。返回一个可观察序列，该序列是调用可连接可观测序列上的选择器的结果，该序列将单个订阅共享到仅包含最后一个通知的基础序列。（由可观测定义。
	重复<T>（）	重载。无限期重复可观测序列。（由可观测定义。
	重复<T>（Int32）	重载。无限期重复可观测序列。（由可观测定义。
	重播<T>（）	重载。返回一个可连接可观察序列，该序列与基础序列共享一个订阅，重播所有通知。（由可观测定义。
	重播 T<>（TimeSpan）	重载。返回一个可连接的可观察序列，该序列与基础序列共享一个订阅，重播窗口中的所有通知。（由可观测定义。
	重播<T>（Int32）	重载。返回一个可连接的可观察序列，该序列与基础序列重播 bufferSize 通知共享单个订阅。（由可观测定义。
	重播<T>（IScheduler）	重载。返回一个可连接可观察序列，该序列与基础序列共享一个订阅，重播所有通知。（由可观测定义。
	重播 T<>（TimeSpan， IScheduler）	重载。返回一个可连接的可观察序列，该序列与基础序列共享一个订阅，重播窗口中的所有通知。（由可观测定义。
	重播<T>（Int32， IScheduler）	重载。返回一个可连接的可观察序列，该序列与基础序列重播 bufferSize 通知共享单个订阅。（由可观测定义。
	重播<T>（Int32， TimeSpan）	重载。返回一个可连接的可观察序列，该序列将单个订阅共享到窗口内的基础序列重播 bufferSize 通知。（由可观测定义。
	重播<T>（Int32， TimeSpan， IScheduler）	重载。返回一个可连接的可观察序列，该序列将单个订阅共享到窗口内的基础序列重播 bufferSize 通知。（由可观测定义。
	重播<T、TResult>（Func<IObservable<T>、IObservable<TResult>>）	重载。返回一个可观测序列，该序列是调用可连接可观测序列上的选择器的结果，该序列与基础序列共享单个订阅并从初始值开始。（由可观测定义。
	重<播 T、TResult>（Func<IObservable<T>、IObservable<TResult>>、IScheduler）	重载。返回一个可观察序列，该序列是调用可连接可观测序列上的选择器的结果，该序列共享一个订阅，该序列将共享基础序列重播所有通知。（由可观测定义。
	重<播 T、TResult>（Func<IObservable<T>、IObservable<TResult>>、TimeSpan）	重载。返回一个可观察序列，该序列是调用可连接可观测序列上的选择器的结果，该序列与基础序列共享一个订阅，重播窗口中的所有通知。（由可观测定义。
	重播<T、TResult>（Func<IObservable<T>、IObservable<TResult>>、Int32）	重载。返回一个可观察序列，该序列是调用可连接可观测序列上的选择器的结果，该序列与基础序列重播 bufferSize 通知共享单个订阅。（由可观测定义。
	重播<T、TResult>（Func<IObservable<T>、IObservable<TResult>>、TimeSpan、IScheduler）	重载。返回一个可观察序列，该序列是调用可连接可观测序列上的选择器的结果，该序列与基础序列共享一个订阅，重播窗口中的所有通知。（由可观测定义。
	重<播 T、TResult>（Func<IObservable<T>、IObservable<TResult>>、Int32、IScheduler）	重载。返回一个可观察序列，该序列是调用可连接可观测序列上的选择器的结果，该序列与基础序列重播 bufferSize 通知共享单个订阅。（由可观测定义。
	重播<T、TResult>（Func<IObservable<T>、IObservable<TResult>>、Int32、TimeSpan）	重载。返回一个可观察序列，该序列是调用可连接可观测序列上的选择器的结果，该序列与窗口内的基础序列重播 bufferSize 通知共享单个订阅。（由可观测定义。
	重<播 T、TResult>（Func<IObservable<T>、IObservable<TResult>>、Int32、TimeSpan、IScheduler）	重载。返回一个可观察序列，该序列是调用可连接可观测序列上的选择器的结果，该序列与窗口内的基础序列重播 bufferSize 通知共享单个订阅。（由可观测定义。
	重试<T>（）	重载。重复源可观测序列，直到它成功终止。（由可观测定义。
	重试<T>（Int32）	重载。重复源可观测序列，直到它成功终止。（由可观测定义。
	示例<T>（TimeSpan）	重载。在每个间隔对可观测序列进行采样。（由可观测定义。
	示例<T>（TimeSpan， IScheduler）	重载。使用指定的源、间隔和计划程序对每个间隔的可观测序列采样。（由可观测定义。
	示例<T、TSample>（IObservable<TSample>）	重载。使用指定的源和采样器对采样时钟周期中的可观测序列采样。（由可观测定义。
	扫描<T>（Func<T， T， T>）	重载。对可观测序列应用累加器函数，并使用指定的源和累加器返回每个中间结果。（由可观测定义。
	扫描<T、TAccumulate>（TAccumulate、Func<TAccumulate、T、T、TAccumulate>）	重载。对可观测序列应用累加器函数，并使用指定的源、种子和累加器返回每个中间结果。（由可观测定义。
	选择<T、TResult>（Func<T、TResult>）	重载。将可观测序列的每个元素投影到具有指定源和选择器的新窗体中。（由可观测定义。
	选择<T、TResult>（Func<T、Int32、TResult>）	重载。通过将元素的索引与指定的源和选择器合并，将可观测序列的每个元素投影到一个新窗体中。（由可观测定义。
	SelectMany<T、TOther>（IObservable<TOther>）	重载。将可观测序列的每个元素投影到可观测序列，并将生成的可观测序列平展为一个可观测序列。（由可观测定义。
	SelectMany<T、TResult>（Func<T、IObservable<TResult>>）	重载。将可观测序列的每个元素投影到可观测序列，并将生成的可观测序列平展为一个可观测序列。（由可观测定义。
	SelectMany<T、TResult>（Func<T、IEnumerable<TResult>>）	重载。将可观测序列的每个元素投影到可观测序列，并将生成的可观测序列平展为一个可观测序列。（由可观测定义。
	SelectMany<T、TResult>（Func<T、IObservable<TResult>>、Func<Exception、IObservable<TResult>>、Func<IObservable<TResult>>）	重载。将可观测序列的每个元素投影到可观测序列，并将生成的可观测序列平展为一个可观测序列。（由可观测定义。
	SelectMany<T、TCollection、TResult>（Func<T、IEnumerable<TCollection>>、Func<T、TCollection、TResult>）	重载。将可观测序列的每个元素投影到可观测序列，并将生成的可观测序列平展为一个可观测序列。（由可观测定义。
	SelectMany<T、TCollection、TResult>（Func<T、IObservable<TCollection>>、Func<T、TCollection、TResult>）	重载。将可观测序列的每个元素投影到可观测序列，并将生成的可观测序列平展为一个可观测序列。（由可观测定义。
	SequenceEqual<T>（IObservable<T>）	重载。通过比较元素成对来确定两个序列是否相等。（由可观测定义。
	SequenceEqual<T>（IObservable<T>， IEqualityComparer<T>）	重载。通过使用指定的相等比较器比较元素，确定两个序列是否相等。（由可观测定义。
	单<T>（）	重载。返回可观测序列的唯一元素，如果在可观测序列中没有完全存在一个元素，则引发异常。（由可观测定义。
	单<T>（Func<T， boolean>）	重载。返回与谓词匹配的可观察序列的唯一元素，如果观测序列中没有完全一个元素，则引发异常。（由可观测定义。
	SingleOrDefault<T>（）	重载。返回可观测序列的唯一元素;如果可观测序列为空，则返回默认值。（由可观测定义。
	SingleOrDefault<T>（Func<T， boolean>）	重载。返回与谓词匹配的可观察序列的唯一元素;如果未找到任何值，则返回默认值。（由可观测定义。
	跳过 t<T>	绕过可观察序列中的指定数目的值，然后返回其余值。（由可观测定义。
	SkipLast<T>	绕过可观测序列末尾的指定数量的元素。（由可观测定义。
	SkipUntil<T、TOther>	仅在其他可观测序列生成值之后，才返回源可观测序列中的值。（由可观测定义。
	SkipWhile<T>（Func<T， boolean>）	重载。只要指定条件为 true，即可绕过可观察序列中的值，然后返回其余值。（由可观测定义。
	SkipWhile<T>（Func<T， Int32， boolean>）	重载。只要指定条件为 true，即可绕过可观察序列中的值，然后返回其余值。（由可观测定义。
	StartWith<T>T[]）	重载。将一系列值追加到具有指定源和值的可观察序列。（由可观测定义。
	StartWith<T>（IScheduler， T[]）	重载。将一系列值追加到具有指定源、计划程序和值的可观察序列。（由可观测定义。
	订阅<T>（）	重载。计算具有指定源的可观测序列。（由 ObservableExtensions定义）
	订阅<T>（操作<T>）	重载。将元素处理程序订阅到可观察序列。（由 ObservableExtensions定义）
	订阅<T>（操作<T>、操作<异常>）	重载。将元素处理程序和异常处理程序订阅到可观测序列。（由 ObservableExtensions定义）
	订阅<T>（操作<T>，操作）	重载。将元素处理程序和完成处理程序订阅到可观测序列。（由 ObservableExtensions定义）
	订阅<T>（操作<T>、操作<异常>、操作）	重载。将元素处理程序、异常处理程序和完成处理程序订阅到可观察序列。（由 ObservableExtensions定义）
	SubscribeOn<T>（SynchronizationContext）	重载。在指定的同步上下文上异步订阅和取消订阅观察程序。（由可观测定义。
	SubscribeOn<T>（控制）	重载。（由 ControlObservable定义。
	SubscribeOn<T>（Dispatcher）	重载。（由 DispatcherObservable定义）
	SubscribeOn<T>（DispatcherScheduler）	重载。（由 DispatcherObservable定义）
	SubscribeOn<T>（IScheduler）	重载。在指定的计划程序上异步订阅和取消订阅观察程序。（由可观测定义。
	SubscribeOnDispatcher<T>	（由 DispatcherObservable定义）
	同步<T>（）	重载。同步可观测序列。（由可观测定义。
	同步<T>（对象）	重载。同步可观测序列。（由可观测定义。
	<T>	从可观测序列的开头返回指定数量的连续值。（由可观测定义。
	TakeLast<T>	从可观测序列的末尾返回指定数量的连续元素。（由可观测定义。
	TakeUntil<T、TOther>	返回源可观测序列中的值，直到其他可观测序列生成值。（由可观测定义。
	TakeWhile<T>（Func<T， boolean>）	重载。只要指定的条件为 true，即可返回可观察序列中的值，然后跳过其余值。（由可观测定义。
	TakeWhile<T>（Func<T， Int32， boolean>）	重载。只要指定的条件为 true，即可返回可观察序列中的值，然后跳过其余值。（由可观测定义。
	然后<T、TResult>	当可观测序列具有可用值并投影该值时匹配。（由可观测定义。
	限制<T>（TimeSpan）	重载。忽略可观察序列中的值，这些值后跟另一个值，然后再使用指定的源和 dueTime。（由可观测定义。
	限制<T>（TimeSpan， IScheduler）	重载。忽略可观察序列中的值，这些值后跟另一个值，然后再使用指定的源、dueTime 和计划程序。（由可观测定义。
	TimeInterval<T>（）	重载。记录具有指定源的可观察序列中的连续值之间的时间间隔。（由可观测定义。
	TimeInterval<T>（IScheduler）	重载。使用指定的源和计划程序记录可观测序列中的连续值之间的时间间隔。（由可观测定义。
	超时<T>（TimeSpan）	重载。如果 dueTime 已用，则返回可观察序列或 TimeoutException。（由可观测定义。
	超时<T>（DateTimeOffset）	重载。如果 dueTime 已用，则返回可观察序列或 TimeoutException。（由可观测定义。
	超时<T>（TimeSpan， IObservable<T>）	重载。如果 dueTime 已用，则返回源可观测序列或其他可观测序列。（由可观测定义。
	超时<T>（DateTimeOffset， IObservable<T>）	重载。如果 dueTime 已用，则返回可观察序列或 TimeoutException。（由可观测定义。
	超时<T>（TimeSpan， IScheduler）	重载。如果 dueTime 已用，则返回可观察序列或 TimeoutException。（由可观测定义。
	超时<T>（DateTimeOffset， IScheduler）	重载。如果 dueTime 已用，则返回可观察序列或 TimeoutException。（由可观测定义。
	超时<T>（TimeSpan、IObservable<T>、IScheduler）	重载。如果 dueTime 已用，则返回源可观测序列或其他可观测序列。（由可观测定义。
	超时<T>（DateTimeOffset、IObservable<T>、IScheduler）	重载。如果 dueTime 已用，则返回源可观测序列或其他可观测序列。（由可观测定义。
	时间戳<T>（）	重载。使用指定的源记录可观测序列中每个值的时间戳。（由可观测定义。
	时间戳<T>（IScheduler）	重载。使用指定的源和计划程序记录可观测序列中每个值的时间戳。（由可观测定义。
	ToArray<T>	从可观测序列创建数组。（由可观测定义。
	ToDictionary<T、TKey>（Func<T、TKey>）	重载。根据指定的键选择器函数根据可观察序列创建字典。（由可观测定义。
	ToDictionary<T、TKey>（Func<T、TKey>、IEqualityComparer<TKey>）	重载。根据指定的键选择器函数和比较器根据可观察序列创建字典。（由可观测定义。
	ToDictionary<T、TKey、TElement>（Func<T、TKey>、Func<T、TElement>）	重载。根据指定的键选择器函数和元素选择器函数，根据可观察序列创建字典。（由可观测定义。
	ToDictionary<T、TKey、TElement>（Func<T、TKey>、Func<T、TElement>、IEqualityComparer<TKey>）	重载。根据指定的键选择器函数、比较器和元素选择器函数，根据可观察序列创建字典。（由可观测定义。
	ToEnumerable<T>	将可观测序列转换为可枚举序列。（由可观测定义。
	ToEvent<T>	将可观测序列公开为具有指定源的 .NET 事件的对象。（由可观测定义。
	ToList<T>	从可观测序列创建列表。（由可观测定义。
	ToLookup<T、TKey>（Func<T、TKey>）	重载。根据指定的键选择器函数根据可观察序列创建查找。（由可观测定义。
	ToLookup<T、TKey>（Func<T、TKey>、IEqualityComparer<TKey>）	重载。根据指定的键选择器函数和比较器根据可观察序列创建查找。（由可观测定义。
	ToLookup<T、TKey、TElement>（Func<T、TKey>、Func<T、TElement>）	重载。根据指定的键选择器函数和元素选择器函数，根据可观察序列创建查找。（由可观测定义。
	ToLookup<T、TKey、TElement>（Func<T、TKey>、Func<T、TElement>、IEqualityComparer<TKey>）	重载。根据指定的键选择器函数、比较器和元素选择器函数，根据可观察序列创建查找。（由可观测定义。
	ToNotifier<T>	从观察者创建通知回调。（由观察家定义。
	ToTask<T>（）	重载。返回一个任务，该任务包含可观测序列的最后一个值。（由 taskObservableExtensions定义）
	ToTask<T>（对象）	重载。返回一个任务，该任务包含可观测序列的最后一个值。（由 taskObservableExtensions定义）
	ToTask<T>（CancellationToken）	重载。返回一个任务，该任务包含可观测序列的最后一个值。（由 taskObservableExtensions定义）
	ToTask<T>（CancellationToken， Object）	重载。返回一个任务，该任务包含可观测序列的最后一个值。（由 taskObservableExtensions定义）
	<T>（Func<T， boolean>）	重载。基于谓词筛选可观测序列的元素。（由可观测定义。
	<T>（Func<T， Int32， boolean>）	重载。通过合并元素的索引来基于谓词筛选可观测序列的元素。（由可观测定义。
	窗口<T>（Int32）	重载。将可观测序列的每个元素投影到基于元素计数信息生成的连续非重叠窗口。（由可观测定义。
	窗口<T>（TimeSpan）	重载。将可观测序列的每个元素投影到基于计时信息生成的连续非重叠窗口。（由可观测定义。
	窗口<T>（Int32， Int32）	重载。将可观测序列的每个元素投影到零个或多个基于元素计数信息生成的窗口。（由可观测定义。
	窗口<T>（TimeSpan， IScheduler）	重载。将可观测序列的每个元素投影到基于计时信息生成的连续非重叠窗口。（由可观测定义。
	窗口<T>（TimeSpan， TimeSpan）	重载。将可观测序列的每个元素投影到零个或多个基于计时信息生成的窗口。（由可观测定义。
	窗口<T>（TimeSpan， Int32）	重载。将可观察序列的每个元素投影到一个窗口，当它已满或给定的时间已过时完成。（由可观测定义。
	窗口<T>（TimeSpan、TimeSpan、IScheduler）	重载。将可观测序列的每个元素投影到零个或多个基于计时信息生成的窗口。（由可观测定义。
	窗口<T>（TimeSpan、Int32、IScheduler）	重载。将可观察序列的每个元素投影到一个窗口，当它已满或给定的时间已过时完成。（由可观测定义。
	窗口<T、TWindowClosing>（Func<IObservable<TWindowClosing>>）	重载。将可观测序列的每个元素投影到连续的非重叠窗口。（由可观测定义。
	窗口<T、TWindowOpening、TWindowClosing>（IObservable<TWindowOpening>、Func<TWindowOpening、IObservable<TWindowClosing>>）	重载。将可观测序列的每个元素投影到零个或多个窗口。（由可观测定义。
	Zip<T、TSecond、TResult>（IObservable<TSecond>、Func<T、TSecond、TResult>）	重载。通过将两个可观测序列合并成一个可观察序列，以成对方式组合其元素。（由可观测定义。
	Zip<T、TSecond、TResult>（IEnumerable<TSecond>、Func<T、TSecond、TResult>）	重载。使用选择器函数将可观测序列和可枚举序列合并到一个可观测序列中。（由可观测定义。

返回页首

言论

主体的行为类似于代理，因为它既充当订阅服务器，又充当发布者。其 IObserver 接口可用于订阅多个流或数据序列。然后，数据通过 IObservable 接口发布。

BehaviorSubject 缓冲它通过其 IObservable 接口发布的最后一项。如果尚未通过其 IObservable 接口发布任何项，则构造函数中提供的初始项是当前缓冲的项。对 BehaviorSubject 的 IObservable 接口进行订阅时，发布的序列从当前缓冲的项开始。

IObserver 接口收到完成后，不会缓冲或从 BehaviorSubject 发布任何项。

例子

此示例演示 BehaviorSubject。此示例使用 Interval 运算符每秒将整数发布到整数序列。发布 10 个整数后，Take 运算符将完成序列。这是 BehaviorSubject 订阅的序列。

为 BehaviorSubject 的 IObservable 接口创建两个订阅，以显示其发布数据的方式。

订阅 #1：此订阅将从开头开始，并按顺序显示构造函数（-9）的初始缓冲值。
订阅 #2：此订阅将在 5 秒睡眠后启动。此订阅显示序列以当前缓冲的项开头。

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();
    }
  }
}

示例代码的以下输出显示了重叠的订阅。

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

线程安全

此类型的任何公共静态（在 Visual Basic 中共享）成员都是线程安全的。不保证任何实例成员都是线程安全的。

另请参阅

参考

System.Reactive.Subjects 命名空间

通过

BehaviorSubject<T> 类

继承层次结构

语法

类型参数

构造 函数

方法

扩展方法

言论

例子

线程安全

另请参阅

参考

其他资源

构造函数