表示既是可观察序列，又是观察者的对象。
命名空间：System.Reactive.Subjects
程序集： System.Reactive（System.Reactive.dll）
语法
'Declaration
Public Interface ISubject(Of T) _
Inherits ISubject(Of T, T), IObserver(Of T), _
IObservable(Of T)
'Usage
Dim instance As ISubject(Of T)
public interface ISubject<T> : ISubject<T, T>,
IObserver<T>, IObservable<T>
generic<typename T>
public interface class ISubject : ISubject<T, T>,
IObserver<T>, IObservable<T>
type ISubject<'T> =
interface
interface ISubject<'T, 'T>
interface IObserver<'T>
interface IObservable<'T>
end
JScript does not support generic types and methods.
类型参数
- T
主题的类型。
ISubject<T> 类型公开以下成员。
方法
| 名字 | 描述 | |
|---|---|---|
.gif "公共方法")
|
OnCompleted | （继承自 IObserver<T>. |
|
|
onError |
（继承自 IObserver<T>. |
|
|
OnNext | （继承自 IObserver<T>. |
|
|
订阅 | （继承自 IObservable<T>. |
返回页首
扩展方法
| 名字 | 描述 | |
|---|---|---|
.gif "公共扩展方法")
|
聚合<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>） | 重载。 使用选择器函数将可观测序列和可枚举序列合并到一个可观测序列中。 （由 可观测定义。 |
返回页首
言论
通过实现 ISubject 接口，可以使用自定义行为创建自己的主题。
例子
以下示例代码实现一个示例主题，该主题仅将方法执行回显到控制台窗口。
using System;
using System.Collections.Generic;
using System.Reactive.Linq;
using System.Reactive.Subjects;
using System.Reactive.Concurrency;
using System.Reactive.Disposables;
namespace Example
{
class Program
{
static void Main()
{
//************************************************************************************//
//*** The ConsoleEchoSubject will just echo it's method calls out to the console ***//
//*** window. ***//
//*** ***//
//*** Create an instance of the ConsoleEchoSubject and subscribe to a sequence of ***//
//*** the first 5 integers returned by the Interval operator. ***//
//*** ***//
//************************************************************************************//
ConsoleEchoSubject<long> mySubject = new ConsoleEchoSubject<long>();
var obs = Observable.Interval(TimeSpan.FromSeconds(1), Scheduler.ThreadPool).Take(5);
Console.WriteLine("Subscribing ConsoleEchoSubject to observable sequence.\n");
obs.Subscribe(mySubject);
//************************************************************************************//
//*** Subscribe to the subject's observable interface. Each value will be written ***//
//*** to the console window. ***//
//************************************************************************************//
IDisposable subscription = mySubject.Subscribe(x => Console.WriteLine(x), () =>
{
Console.WriteLine("\nSequence Completed.\n");
Console.WriteLine("Press ENTER to exit...");
});
Console.ReadLine();
//***************************************//
//*** Explicitly releasing resources. ***//
//***************************************//
subscription.Dispose();
mySubject.Dispose();
}
}
//************************************************************************************//
//*** ***//
//*** The ConsoleEchoSubject will just echo it's method calls out to the console ***//
//*** window. ***//
//*** ***//
//************************************************************************************//
class ConsoleEchoSubject<T> : ISubject<T>, IDisposable
{
private List<IObserver<T>> observerList;
private bool isDisposed;
private bool isStopped;
object gate = new object();
Exception exception;
public ConsoleEchoSubject()
{
observerList = new List<IObserver<T>>();
}
public void OnCompleted()
{
//****************************************************************************************//
//*** Make sure the OnCompleted operation is not preempted by another operation ***//
//*** which would break the expected behavior. For example, don't allow an error from ***//
//*** OnError preempt OnCompleted from anotther thread. Then OnCompleted would follow ***//
//*** an error. That would be an incorrect behavior. ***//
//****************************************************************************************//
lock (gate)
{
CheckDisposed();
if (!isStopped)
{
Console.WriteLine("\nConsoleEchoSubject : OnCompleted()");
foreach (IObserver<T> observer in observerList)
{
observer.OnCompleted();
}
observerList.Clear();
isStopped = true;
}
}
}
public void OnError(Exception error)
{
if (error == null)
throw new ArgumentException("Exception error should not be null.");
//****************************************************************************************//
//*** Make sure the OnError operation is not preempted by another operation which ***//
//*** would break the expected behavior. For example, don't allow unsubscribe or an ***//
//*** OnCompleted operation to preempt OnError from another thread. This would result ***//
//*** in an error following completion. That would be an incorrect behavior. ***//
//****************************************************************************************//
lock (gate)
{
CheckDisposed();
if (!isStopped)
{
Console.WriteLine("\nConsoleEchoSubject : OnError({0})", error.Message);
exception = error;
foreach (IObserver<T> observer in observerList)
{
observer.OnError(error);
}
observerList.Clear();
isStopped = true;
}
}
}
public void OnNext(T value)
{
//****************************************************************************************//
//*** Make sure the OnNext operation is not preempted by another operation which ***//
//*** would break the expected behavior. For example, don't allow unsubscribe, errors ***//
//*** or an OnCompleted operation to preempt OnNext from another thread. This would ***//
//*** have the result of items in a sequence following completion, errors, or ***//
//*** unsubscribe. That would be an incorrect behavior. ***//
//****************************************************************************************//
lock (gate)
{
CheckDisposed();
if (!isStopped)
{
Console.WriteLine("\nConsoleEchoSubject : OnNext({0})", value.ToString());
foreach (IObserver<T> observer in observerList)
{
observer.OnNext(value);
}
}
}
}
public IDisposable Subscribe(IObserver<T> observer)
{
if (observer == null)
throw new ArgumentException("observer should not BehaviorSubject null.");
//****************************************************************************************//
//*** Make sure Subscribe occurs in sync with the other operations so we keep the ***//
//*** correct behavior depending on whether an error has occurred or the observable ***//
//*** sequence has completed. ***//
//****************************************************************************************//
lock (gate)
{
CheckDisposed();
if (!isStopped)
{
Console.WriteLine("\nConsoleEchoSubject : Creating new subscription.");
observerList.Add(observer);
return new Subscription(observer, this);
}
else if(exception != null)
{
observer.OnError(exception);
return Disposable.Empty;
}
else
{
observer.OnCompleted();
return Disposable.Empty;
}
}
}
private void Unsubscribe(IObserver<T> observer)
{
//****************************************************************************************//
//*** Make sure Unsubscribe occurs in sync with the other operations so we keep the ***//
//*** correct behavior. ***//
//****************************************************************************************//
lock (gate)
{
Console.WriteLine("\nConsoleEchoSubject : Unsubscribing subscription.");
observerList.Remove(observer);
}
}
public void Dispose()
{
//****************************************************************************************//
//*** Make sure Dispose occurs in sync with the other operations so we keep the ***//
//*** correct behavior. For example, Dispose shouldn't preempt the other operations ***//
//*** changing state variables after they have been checked. ***//
//****************************************************************************************//
lock (gate)
{
Console.WriteLine("\nConsoleEchoSubject : Disposing resources.");
observerList.Clear();
isStopped = true;
isDisposed = true;
}
}
private void CheckDisposed()
{
if (isDisposed)
throw new ObjectDisposedException("Subject has been disposed.");
}
//************************************************************************************//
//*** ***//
//*** The Subscription class wraps each observer that creates a subscription. This ***//
//*** is needed to expose an IDisposable interface through which a observer can ***//
//*** cancel the subscription. ***//
//*** ***//
//************************************************************************************//
class Subscription : IDisposable
{
private ConsoleEchoSubject<T> subject;
private IObserver<T> observer;
public Subscription(IObserver<T> obs, ConsoleEchoSubject<T> sub)
{
subject = sub;
observer = obs;
}
public void Dispose()
{
subject.Unsubscribe(observer);
}
}
}
}
示例代码生成了以下输出。
Subscribing ConsoleEchoSubject to observable sequence.
ConsoleEchoSubject : Creating new subscription.
ConsoleEchoSubject : OnNext(0)
0
ConsoleEchoSubject : OnNext(1)
1
ConsoleEchoSubject : OnNext(2)
2
ConsoleEchoSubject : OnNext(3)
3
ConsoleEchoSubject : OnNext(4)
4
ConsoleEchoSubject : OnCompleted()
Sequence Completed.
Press ENTER to exit...
ConsoleEchoSubject : Unsubscribing subscription.
ConsoleEchoSubject : Disposing resources.
C:\