| 
              Amb<TSource> (IObservable<TSource>[])  | 
已重载。 传播首先使用指定源做出反应的可查询可观察序列。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              Amb<TSource> (IEnumerable<IObservable<TSource>>)  | 
已重载。 传播首先使用指定源做出反应的可查询可观察序列。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              捕获<TSource> (IObservable<TSource>[])  | 
已重载。 继续由异常终止的可查询可观察序列,该序列与下一个可查询可观测序列一起终止。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              捕获<TSource> (IEnumerable<IObservable<TSource>>)  | 
已重载。 继续由异常终止的可查询可观测序列,该序列与下一个可查询可观测序列一起终止。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              Concat<TSource> (IObservable<TSource>[])  | 
已重载。 连接可查询可观测序列的可查询可观察序列。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              Concat<TSource> (IEnumerable<IObservable<TSource>>)  | 
已重载。 连接所有可查询的可观测序列。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              创建<TSource> (表达式<Func<IObserver<TSource>、IDisposable>>)  | 
已重载。 从具有指定订阅的指定订阅方法实现创建可查询的可观察序列。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              创建<TSource> (表达式<Func<IObserver<TSource>,操作>>)  | 
已重载。 从具有指定订阅的指定订阅方法实现创建可查询的可观察序列。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              延迟<TValue> | 
返回一个可查询的可观察序列,每当新观察者订阅时,该序列都会调用可观察工厂。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              空<TResult> ()  | 
已重载。 返回具有指定提供程序的空可查询可观测序列。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              空<TResult> (IScheduler)  | 
已重载。 返回具有指定计划程序和提供程序的空可查询可观察序列。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromAsyncPattern (Expression<Func<AsyncCallback, Object, IAsyncResult>>, Expression<Action<IAsyncResult>>)  | 
已重载。 将 Begin/End 调用函数对转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromAsyncPattern<T1> (Expression<Func<T1、AsyncCallback、Object、IAsyncResult>>、Expression<Action<IAsyncResult>>)  | 
已重载。 将 Begin/End 调用函数对转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromAsyncPattern<TResult> (Expression<Func<AsyncCallback、Object、IAsyncResult>>、Expression<Func<IAsyncResult、TResult>>)  | 
已重载。 将 Begin/End 调用函数对转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> (Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, AsyncCallback, Object, IAsyncResult>>, Expression<Action<IAsyncResult>>)  | 
已重载。 将 Begin/End 调用函数对转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult> (Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, AsyncCallback, Object, IAsyncResult>>, Expression<Func<IAsyncResult, TResult>>)  | 
已重载。 将 Begin/End 调用函数对转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> (Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, AsyncCallback, Object, IAsyncResult>>, Expression<Action<IAsyncResult>>)  | 
已重载。 将 Begin/End 调用函数对转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromAsyncPattern<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、TResult> (Expression<Func<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、AsyncCallback、Object、IAsyncResult>>、Expression<Func<IAsyncResult、TResult>>)  | 
已重载。 将 Begin/End 调用函数对转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromAsyncPattern<T1, T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、T12> (表达式<Func<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、T12、AsyncCallback、Object、IAsyncResult>>、Expression<Action<IAsyncResult>>)  | 
已重载。 将 Begin/End 调用函数对转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromAsyncPattern<T1, T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、TResult> (表达式<Func<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、AsyncCallback、Object、IAsyncResult>>、Expression<Func<IAsyncResult、TResult>>)  | 
已重载。 将 Begin/End 调用函数对转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromAsyncPattern<T1、T2、T3、 T4、T5、T6、T7、T8、T9、T10、T11、T12、T13> (表达式<Func<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、T12、T13、AsyncCallback、Object、IAsyncResult>>、Expression<Action<IAsyncResult>>)  | 
已重载。 将 Begin/End 调用函数对转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromAsyncPattern<T1、T2、T3、T4、 T5、T6、T7、T8、T9、T10、T11、T12、TResult> (Expression<Func<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、T12、AsyncCallback、Object、IAsyncResult>>、Expression<Func<IAsyncResult、TResult>>)  | 
已重载。 将 Begin/End 调用函数对转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromAsyncPattern<T1、T2、T3、T4、T5、T6、 T7、T8、T9、T10、T11、T12、T13、T14> (表达式<Func<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、T12、T13、T14、AsyncCallback、Object、IAsyncResult>>、Expression<Action<IAsyncResult>>)  | 
已重载。 将 Begin/End 调用函数对转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromAsyncPattern<T1、T2、T3、T4、T5、T6、 T7、T8、T9、T10、T11、T12、T13、TResult> (Expression<Func<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、T12、T13、AsyncCallback、Object、IAsyncResult>>、Expression<Func<IAsyncResult、TResult>>)  | 
已重载。 将 Begin/End 调用函数对转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromAsyncPattern<T1、T2、T3、T4、T5、T6、T7、T8、T9、 T10、T11、T12、T13、T14、TResult> (Expression<Func<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、T12、T13、T14、AsyncCallback、Object、IAsyncResult>>、Expression<Func<IAsyncResult、TResult>>)  | 
已重载。 将 Begin/End 调用函数对转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromAsyncPattern<T1、T2> (Expression<Func<T1、T2、AsyncCallback、Object、IAsyncResult>>、Expression<Action<IAsyncResult>>)  | 
已重载。 将 Begin/End 调用函数对转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromAsyncPattern<T1、TResult> (Expression<Func<T1、AsyncCallback、Object、IAsyncResult>>、Expression<Func<IAsyncResult、TResult>>)  | 
已重载。 将 Begin/End 调用函数对转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromAsyncPattern<T1、T2、T3> (Expression<Func<T1、T2、T3、AsyncCallback、Object、IAsyncResult>>、Expression<Action<IAsyncResult>>)  | 
已重载。 将 Begin/End 调用函数对转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromAsyncPattern<T1、T2、TResult> (Expression<Func<T1、T2、AsyncCallback、Object、IAsyncResult>>、Expression<Func<IAsyncResult、TResult>>)  | 
已重载。 将 Begin/End 调用函数对转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromAsyncPattern<T1、T2、T3、T4> (Expression<Func<T1、T2、T3、T4、AsyncCallback、Object、IAsyncResult>>、Expression<Action<IAsyncResult>>)  | 
已重载。 将 Begin/End 调用函数对转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromAsyncPattern<T1、T2、T3、TResult> (Expression<Func<T1、T2、T3、AsyncCallback、Object、IAsyncResult>>、Expression<Func<IAsyncResult、TResult>>)  | 
已重载。 将 Begin/End 调用函数对转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromAsyncPattern<T1、T2、T3、T4、T5> (表达式<Func<T1、T2、T3、T4、T5、AsyncCallback、Object、IAsyncResult>>、Expression<Action<IAsyncResult>>)  | 
已重载。 将 Begin/End 调用函数对转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromAsyncPattern<T1、T2、T3、T4、TResult> (表达式<Func<T1、T2、T3、T4、AsyncCallback、Object、IAsyncResult>>、Expression<Func<IAsyncResult、TResult>>)  | 
已重载。 将 Begin/End 调用函数对转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromAsyncPattern<T1、T2、T3、T4、T5、T6> (表达式<Func<T1、T2、T3、T4、T5、T6、AsyncCallback、Object、IAsyncResult>>、Expression<Action<IAsyncResult>>)  | 
已重载。 将 Begin/End 调用函数对转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromAsyncPattern<T1、T2、T3、T4、T5、TResult> (Expression<Func<T1、T2、T3、T4、T5、AsyncCallback、Object、IAsyncResult>>、Expression<Func<IAsyncResult、TResult>>)  | 
已重载。 将 Begin/End 调用函数对转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromAsyncPattern<T1、T2、T3、T4、T5、T6、T7> (表达式<Func<T1、T2、T3、T4、T5、T6、T7、AsyncCallback、Object、IAsyncResult>>、Expression<Action<IAsyncResult>>)  | 
已重载。 将 Begin/End 调用函数对转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromAsyncPattern<T1、T2、T3、T4、T5、T6、TResult> (Expression<Func<T1、T2、T3、T4、T5、T6、AsyncCallback、Object、IAsyncResult>>、Expression<Func<IAsyncResult、TResult>>)  | 
已重载。 将 Begin/End 调用函数对转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8> (Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, AsyncCallback, Object, IAsyncResult>>, Expression<Action<IAsyncResult>>)  | 
已重载。 将 Begin/End 调用函数对转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, TResult> (Expression<Func<T1, T2, T3, T4, T5, T6, T7, AsyncCallback, Object, IAsyncResult>>, Expression<Func<IAsyncResult, TResult>>)  | 
已重载。 将 Begin/End 调用函数对转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, T9> (Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, AsyncCallback, Object, IAsyncResult>>, Expression<Action<IAsyncResult>>)  | 
已重载。 将 Begin/End 调用函数对转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromAsyncPattern<T1, T2, T3, T4, T5, T6, T7, T8, TResult> (Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, AsyncCallback, Object, IAsyncResult>>, Expression<Func<IAsyncResult, TResult>>)  | 
已重载。 将 Begin/End 调用函数对转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromEvent (表达式<操作<操作>>、表达式<操作<操作>>)  | 
已重载。 将 .NET 事件转换为可查询的可观察序列。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromEvent<TEventArgs> (Expression<Action<TEventArgs<>>>, Expression<Action<Action<TEventArgs>>>)  | 
已重载。 将 .NET 事件转换为可查询的可观察序列。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromEvent<TDelegate、TEventArgs> (Expression<Action<TDelegate>>、Expression<Action<TDelegate>>)  | 
已重载。 将 .NET 事件转换为可查询的可观察序列。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromEvent<TDelegate、TEventArgs> (Expression<Func<Action<TEventArgs>、TDelegate>>、Expression<Action<TDelegate>>、Expression<Action<TDelegate>>)  | 
已重载。 将 .NET 事件转换为可查询的可观察序列。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromEventPattern (Expression<Action<EventHandler>>、Expression<Action<EventHandler>>)  | 
已重载。 将符合标准 .NET 事件模式的 .NET 事件转换为具有指定添加处理程序和删除处理程序的可查询可观察序列。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromEventPattern (对象、字符串)  | 
已重载。 使用反射查找实例事件,将符合标准 .NET 事件模式的 .NET 事件转换为可查询的可观察序列。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromEventPattern (类型、字符串)  | 
已重载。 使用反射查找静态事件,将符合标准 .NET 事件模式的 .NET 事件转换为可查询的可观察序列。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromEventPattern<TEventArgs> (Expression<Action<EventHandler<TEventArgs>>>, Expression<Action<EventHandler<TEventArgs>>>)  | 
已重载。 将符合标准 .NET 事件模式的 .NET 事件转换为具有指定添加处理程序和删除处理程序的可查询可观察序列。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromEventPattern<TEventArgs> (对象、字符串)  | 
已重载。 使用反射查找实例事件,将符合标准 .NET 事件模式的 .NET 事件转换为可观察序列。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromEventPattern<TEventArgs> (Type、String)  | 
已重载。 使用反射查找静态事件,将符合标准 .NET 事件模式的 .NET 事件转换为可查询的可观察序列。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromEventPattern<TDelegate、TEventArgs> (Expression<Action<TDelegate>>、Expression<Action<TDelegate>>)  | 
已重载。 将符合标准 .NET 事件模式的 .NET 事件转换为具有指定添加处理程序和删除处理程序的可查询可观察序列。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              FromEventPattern<TDelegate、TEventArgs> (Expression<Func<EventHandler<TEventArgs>、TDelegate>>、Expression<Action<TDelegate>>、Expression<Action<TDelegate>>)  | 
已重载。 将符合标准 .NET 事件模式的 .NET 事件转换为具有指定转换、添加处理程序和删除处理程序的可查询可观察序列。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              生成<TState、TResult> (TState、Expression<Func<TState、Boolean>>、Expression<Func<TState、TState>>、Expression<Func<TState、TResult>>)  | 
已重载。 通过从初始状态循环访问状态,直到条件失败,生成可查询的可观察序列。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              生成<TState、TResult> (TState、Expression<Func<TState、Boolean>>、Expression<Func<TState、TState>>、Expression<Func<TState、TResult>>、Expression<Func<TState、TimeSpan>>)  | 
已重载。 通过从初始状态循环访问状态,直到条件失败,生成可查询的可观察序列。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              生成<TState、TResult> (TState、Expression<Func<TState、Boolean>>、Expression<Func<TState、TState>>、Expression<Func<TState、TResult>>、Expression<Func<TState、DateTimeOffset>>)  | 
已重载。 通过从初始状态循环访问状态,直到条件失败,生成可查询的可观察序列。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              生成<TState、TResult> (TState、Expression<Func<TState、Boolean>>、Expression<Func<TState、TState>>、Expression<Func<TState、TResult>>、IScheduler)  | 
已重载。 通过从初始状态循环访问状态,直到条件失败,生成可查询的可观察序列。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              生成<TState、TResult> (TState、Expression<Func<TState、Boolean>>、Expression<Func<TState、TState>>、Expression<Func<TState、TResult>>、Expression<Func<TState、TimeSpan>>、IScheduler)  | 
已重载。 通过从初始状态循环访问状态,直到条件失败,生成可查询的可观察序列。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              生成<TState、TResult> (TState、Expression<Func<TState、Boolean>>、Expression<Func<TState、TState>>、Expression<Func<TState、TResult>>、Expression<Func<TState、DateTimeOffset>>、IScheduler)  | 
已重载。 通过从初始状态循环访问状态,直到条件失败,生成可查询的可观察序列。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              Interval (TimeSpan)  | 
已重载。 返回一个可查询的可观察序列,该序列在每个时间段后生成一个值。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              Interval (TimeSpan、IScheduler)  | 
已重载。 返回一个可查询的可观察序列,该序列在每个时间段后生成一个值。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              将<TSource> (IEnumerable<IObservable<TSource>>)  | 
已重载。 将可查询可观测序列的可枚举序列合并到单个可查询可观测序列中。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              合并<TSource> (IObservable<TSource>[])  | 
已重载。 将所有可查询可观测序列合并到单个可查询可观测序列中。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              合并<TSource> (IEnumerable<IObservable<TSource>>、IScheduler)  | 
已重载。 将可查询可观测序列的可枚举序列合并到单个可查询可观测序列中。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              合并<TSource> (IEnumerable<IObservable<TSource>>、Int32)  | 
已重载。 将可查询可观察序列的可枚举序列合并到可查询可观察序列中,从而限制内部序列的并发订阅数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              合并<TSource> (IScheduler、IObservable<TSource>[])  | 
已重载。 将所有可查询可观测序列合并到单个可查询可观测序列中。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              合并<TSource> (IEnumerable<IObservable<TSource>>、Int32、IScheduler)  | 
已重载。 将可查询可观察序列的可枚举序列合并到可查询可观察序列中,从而限制内部序列的并发订阅数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              从不<TResult> | 
返回一个不可终止的可查询可观测序列。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              OnErrorResumeNext<TSource> (IObservable<TSource>[])  | 
已重载。 继续正常终止的可查询可观测序列,或者由下一个可查询可观测序列的异常终止。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              OnErrorResumeNext<TSource> (IEnumerable<IObservable<TSource>>)  | 
已重载。 继续正常终止的可查询可观测序列,或者由下一个可查询可观测序列的异常终止。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              Qux<T> | 
由 MyExt.) 定义的 ( | 
               
              
             | 
              范围 (Int32、Int32)  | 
已重载。 在指定范围内生成可查询的可观测整数序列。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              范围 (Int32、Int32、IScheduler)  | 
已重载。 在指定范围内生成可查询的可观测整数序列。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              RefCount<TSource> | 
返回一个可查询的可观察序列,只要至少有一个可查询可观察序列的订阅,该序列就与源保持连接。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              重复<TResult> (TResult)  | 
已重载。 生成无限重复给定元素的可查询可观察序列。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              重复<TResult> (TResult、IScheduler)  | 
已重载。 生成无限重复给定元素的可查询可观察序列。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              重复<TResult> (TResult、Int32)  | 
已重载。 生成一个可查询的可观察序列,该序列按指定次数重复给定元素。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              重复<TResult> (TResult、Int32、IScheduler)  | 
已重载。 生成可查询的可观察序列,该序列重复指定次数的给定元素。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              返回<TResult> (TResult)  | 
已重载。 返回一个可查询的可观察序列,该序列包含具有指定值的单个元素。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              返回<TResult> (TResult、IScheduler)  | 
已重载。 返回一个可查询的可观察序列,其中包含具有指定值和计划程序的单个值。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              启动 (表达式<操作>)  | 
已重载。 异步调用操作。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              启动 (表达式<操作>,IScheduler)  | 
已重载。 异步调用操作。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              启动<TSource> (表达式<Func<TSource>>)  | 
已重载。 异步调用 函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              启动<TSource> (表达式<Func<TSource>>、IScheduler)  | 
已重载。 异步调用 函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              引发<TResult> (异常)  | 
已重载。 返回以异常结尾的可查询可观察序列。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              引发<TResult> (异常,IScheduler)  | 
已重载。 返回一个可查询的可观察序列,该序列以指定的计划程序异常终止。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              计时器 (TimeSpan)  | 
已重载。 返回一个可查询的可观测序列,该序列在到期时间过后生成值。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              计时器 (DateTimeOffset)  | 
已重载。 返回在适当时间生成值的可查询可观察序列。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              计时器 (TimeSpan、TimeSpan)  | 
已重载。 返回一个可查询的可观察序列,该序列在到期时间过后生成值,然后在每个时间段后生成值。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              计时器 (DateTimeOffset、TimeSpan)  | 
已重载。 返回一个可查询的可观察序列,该序列在到期时间生成值,然后在每个周期后生成值。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              计时器 (TimeSpan、IScheduler)  | 
已重载。 返回一个可查询的可观测序列,该序列在到期时间过后生成值。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              计时器 (DateTimeOffset、IScheduler)  | 
已重载。 返回在适当时间生成值的可查询可观察序列。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              计时器 (TimeSpan、TimeSpan、IScheduler)  | 
已重载。 返回一个可查询的可观察序列,该序列在到期时间过后,然后每个时间段后生成一个值。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              计时器 (DateTimeOffset、TimeSpan、IScheduler)  | 
已重载。 返回一个可查询的可观察序列,该序列在到期时间生成值,然后在每个周期后生成值。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync (表达式<操作>)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync (表达式<操作>,IScheduler)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<TSource> (Expression<操作<TSource>>)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<TResult> (Expression<Func<TResult>>)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<TSource> (表达式<操作<TSource>>、IScheduler)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<TResult> (Expression<Func<TResult>>, IScheduler)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10> (表达式<操作<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10>>)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult> (Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>>)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10> (表达式<操作<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10>>、IScheduler)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、T5、T6、T7、T8、T9、TResult> (Expression<Func<T1、T2、T3、T4、T5、T6、T7、T8、T9、TResult>>、IScheduler)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11> (表达式<操作<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11>>)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、TResult> (Expression<Func<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、TResult>>)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11> (表达式<操作<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11>>、IScheduler)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、TResult> (Expression<Func<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、TResult>>、IScheduler)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、T12> (表达式<操作<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、T12>>)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、TResult> (Expression<Func<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、TResult>>)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、T12> (表达式<操作<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、T12>>、IScheduler)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、TResult> (Expression<Func<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、TResult>>、IScheduler)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、T12、T13> (表达式<操作<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、T12、T13>>)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、T12、TResult> (Expression<Func<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、T12、TResult>>)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、T12、T13> (表达式<操作<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、T12、T13>>、IScheduler)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、T12、TResult> (Expression<Func<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、T12、TResult>>、IScheduler)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、T12、T13、T14> (表达式<操作<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、T12、T13、T14>>)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult> (Expression<Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult>>)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1, T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、T12、T13、T14> (表达式<操作<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、T12、T13、T14>>、IScheduler)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1, T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、T12、T13、TResult> (Expression<Func<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、T12、T13、TResult>>、IScheduler)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1, T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、T12、T13、T14、T15> (表达式<操作<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、T12、T13、T14、T15>>)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、 T3、T4、T5、T6、T7、T8、T9、T10、T11、T12、T13、T14、TResult> (Expression<Func<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、T12、T13、T14、TResult>>)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、 T4、T5、T6、T7、T8、T9、T10、T11、T12、T13、T14、T15> (表达式<操作<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、T12、T13、T14、T15>>、IScheduler)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、 T4、T5、T6、T7、T8、T9、T10、T11、T12、T13、T14、TResult> (Expression<Func<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、T12、T13、T14、TResult>>、IScheduler)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、 T5、T6、T7、T8、T9、T10、T11、T12、T13、T14、T15、T16> (表达式<操作<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、T12、T13、T14、T15、T16>>)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、 T5、T6、T7、T8、T9、T10、T11、T12、T13、T14、T15、TResult> (Expression<Func<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、T12、T13、T14、T15、TResult>>)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、T5、 T6、T7、T8、T9、T10、T11、T12、T13、T14、T15、T16> (表达式<操作<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、T12、T13、T14、T15、T16>>、IScheduler)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、T5、 T6、T7、T8、T9、T10、T11、T12、T13、T14、T15、TResult> (Expression<Func<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、T12、T13、T14、T15、TResult>>、IScheduler)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、T5、T6、T7、 T8、T9、T10、T11、T12、T13、T14、T15、T16、TResult> (Expression<Func<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、T12、T13、T14、T15、T16、TResult>>)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、T5、T6、T7、T8、 T9、T10、T11、T12、T13、T14、T15、T16、TResult> (Expression<Func<T1、T2、T3、T4、T5、T6、T7、T8、T9、T10、T11、T12、T13、T14、T15、T16、TResult>>、IScheduler)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2> (表达式<操作<T1、T2>>)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<TSource、TResult> (Expression<Func<TSource、TResult>>)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2> (表达式<操作<T1、T2>>、IScheduler)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<TSource、TResult> (Expression<Func<TSource、TResult>>、IScheduler)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3> (表达式<操作<T1、T2、T3>>)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、TResult> (Expression<Func<T1、T2、TResult>>)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3> (表达式<操作<T1、T2、T3>>、IScheduler)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、TResult> (Expression<Func<T1、T2、TResult>>、IScheduler)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4> (表达式<操作<T1、T2、T3、T4>>)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、TResult> (表达式<Func<T1、T2、T3、TResult>>)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4> (表达式<操作<T1、T2、T3、T4>>、IScheduler)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、TResult> (Expression<Func<T1、T2、T3、TResult>>、IScheduler)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、T5> (表达式<操作<T1、T2、T3、T4、T5>>)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、TResult> (Expression<Func<T1、T2、T3、T4、TResult>>)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、T5> (表达式<操作<T1、T2、T3、T4、T5>>、IScheduler)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、TResult> (Expression<Func<T1、T2、T3、T4、TResult>>、IScheduler)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、T5、T6> (表达式<操作<T1、T2、T3、T4、T5、T6>>)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、T5、TResult> (表达式<Func<T1、T2、T3、T4、T5、TResult>>)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、T5、T6> (表达式<操作<T1、T2、T3、T4、T5、T6>>、IScheduler)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、T5、TResult> (Expression<Func<T1、T2、T3、T4、T5、TResult>>、IScheduler)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、T5、T6、T7> (表达式<操作<T1、T2、T3、T4、T5、T6、T7>>)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、T5、T6、TResult> (Expression<Func<T1、T2、T3、T4、T5、T6、TResult>>)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、T5、T6、T7> (表达式<操作<T1、T2、T3、T4、T5、T6、T7>>、IScheduler)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、T5、T6、TResult> (Expression<Func<T1、T2、T3、T4、T5、T6、TResult>>、IScheduler)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、T5、T6、T7、T8> (表达式<操作<T1、T2、T3、T4、T5、T6、T7、T8>>)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、T5、T6、T7、TResult> (Expression<Func<T1、T2、T3、T4、T5、T6、T7、TResult>>)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、T5、T6、T7、T8> (表达式<操作<T1、T2、T3、T4、T5、T6、T7、T8>>、IScheduler)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、T5、T6、T7、TResult> (Expression<Func<T1、T2、T3、T4、T5、T6、T7、TResult>>、IScheduler)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、T5、T6、T7、T8、T9> (表达式<操作<T1、T2、T3、T4、T5、T6、T7、T8、T9>>)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、T5、T6、T7、T8、TResult> (Expression<Func<T1、T2、T3、T4、T5、T6、T7、T8、TResult>>)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、T5、T6、T7、T8、T9> (表达式<操作<T1、T2、T3、T4、T5、T6、T7、T8、T9>>、IScheduler)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToAsync<T1、T2、T3、T4、T5、T6、T7、T8、TResult> (Expression<Func<T1、T2、T3、T4、T5、T6、T7、T8、TResult>>、IScheduler)  | 
已重载。 将函数转换为异步函数。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToObservable<TSource> (IEnumerable<TSource>)  | 
已重载。 将可枚举序列转换为具有指定源的可查询可观察序列。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              ToObservable<TSource> (IEnumerable<TSource>、IScheduler)  | 
已重载。 使用指定的源和计划程序将可枚举序列转换为可查询的可观察序列。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              使用<TSource、TResource> | 
构造依赖于资源对象的可查询可观察序列。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              当<TResult> (QueryablePlan<TResult>[])  | 
已重载。 将多个模式的结果联接在一起。 由 Qbservable.) 定义的 ( | 
               
              
             | 
              当<TResult> (IEnumerable<QueryablePlan<TResult>>)  | 
已重载。 将多个模式的结果联接在一起。 由 Qbservable.) 定义的 ( |