主题<T> 类

2011-06-28

表示既是可观察序列，又是观察者的对象。

继承层次结构

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

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

语法

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

'Usage
Dim instance As Subject(Of T)

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

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

[<SealedAttribute>]
type Subject<'T> =  
    class
        interface ISubject<'T>
        interface ISubject<'T, 'T>
        interface IObserver<'T>
        interface IObservable<'T>
        interface IDisposable
    end

JScript does not support generic types and methods.

类型参数

T
类型。

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

构造函数

	名字	描述
	主题<T>	初始化 Subject<T> 类的新实例。

返回页首

方法

	名字	描述
	Dispose	释放 Subject<T> 类的当前实例使用的所有资源，并取消订阅所有观察程序
	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 接口来实现。 IObserver 接口可用于订阅多个流或数据序列的主题。然后，数据通过 IObservable 接口发布到所有订阅的观察程序。常规使用者使用计划程序将传出调用同步到子加密观察程序。

例子

此示例演示如何使用主题类。字符串类型的 Subject 实例用于订阅两个示例新闻源。这些源只是以不超过 5 秒的间隔发布随机新闻头条新闻。然后创建针对主题可观察接口的两个订阅，以接收合并的数据流。一个订阅将数据流中的每个项报告为“所有新闻”。另一个订阅将流中的每个标题筛选为仅报告本地标题。订阅都写入控制台窗口收到的每个标题。当用户按下 Enter 键并调用 Dispose 以取消这两个订阅时，处理将终止。

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

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

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


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

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


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

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


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

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

      Console.ReadLine();


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

      allNewsSubscription.Dispose();
      localNewsSubscription.Dispose();
    }
  }



  //*********************************************************************************//
  //*** The NewsHeadlineFeed class is just a mock news feed in the form of an     ***//
  //*** observable sequence in Reactive Extensions.                               ***//
  //*********************************************************************************//
  class NewsHeadlineFeed
  {
    private string feedName;                     // Feedname used to label the stream
    private IObservable<string> headlineFeed;    // The actual data stream
    private readonly Random rand = new Random(); // Used to stream random headlines.


    //*** A list of predefined news events to combine with a simple location string ***//
    static readonly string[] newsEvents = { "A tornado occurred ",
                                            "Weather watch for snow storm issued ",
                                            "A robbery occurred ",
                                            "We have a lottery winner ",
                                            "An earthquake occurred ",
                                            "Severe automobile accident "};

    //*** A list of predefined location strings to combine with a news event. ***//
    static readonly string[] newsLocations = { "in your area.",
                                               "in Dallas, Texas.",
                                               "somewhere in Iraq.",
                                               "Lincolnton, North Carolina",
                                               "Redmond, Washington"};

    public IObservable<string> HeadlineFeed
    {
      get { return headlineFeed; }
    }

    public NewsHeadlineFeed(string name)
    {
      feedName = name;

      //*****************************************************************************************//
      //*** Using the Generate operator to generate a continous stream of headline that occur ***//
      //*** randomly within 5 seconds.                                                        ***//
      //*****************************************************************************************//
      headlineFeed = Observable.Generate(RandNewsEvent(),
                                         evt => true,
                                         evt => RandNewsEvent(),
                                         evt => { Thread.Sleep(rand.Next(5000)); return evt; },
                                         Scheduler.ThreadPool);
    }


    //****************************************************************//
    //*** Some very simple formatting of the headline event string ***//
    //****************************************************************//
    private string RandNewsEvent()
    {
      return "Feedname     : " + feedName + "\nHeadline     : " + newsEvents[rand.Next(newsEvents.Length)] + 
             newsLocations[rand.Next(newsLocations.Length)];
    }
  }
}

以下输出是使用示例代码生成的。

Subscribing to news headline feeds.

Press ENTER to exit.

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

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

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

********************************** [当地新闻头条报道]********************************** 源名称：头条新闻源 #1 头条新闻：我们有彩票赢家在你的地区。

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

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

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

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

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

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

********************************** [当地新闻头条报道]********************************** 源名称：头条新闻源 #2 头条新闻：你的地区发生了地震。

线程安全

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

另请参阅

参考

System.Reactive.Subjects 命名空间

通过

主题<T> 类

继承层次结构

语法

类型参数

构造 函数

方法

扩展方法

言论

例子

线程安全

另请参阅

参考

其他资源

构造函数