시간에 따라 변경되는 값을 나타냅니다.
상속 계층 구조
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> 형식은 다음 멤버를 노출합니다.
생성자
| 이름 | 묘사 | |
|---|---|---|
| public 메서드 |
BehaviorSubject<T> | 마지막 값을 캐시하고 지정된 값으로 시작하는 제목을 만드는 BehaviorSubject<T> 클래스의 새 인스턴스를 초기화합니다. |
맨 위로
방법
| 이름 | 묘사 | |
|---|---|---|
| public 메서드 |
삭제 | 모든 관찰자 구독을 취소하고 리소스를 해제합니다. |
| public 메서드 |
같음 | (Object상속됩니다.) |
| protected 메서드 |
완료 | (Object상속됩니다.) |
| public 메서드 |
GetHashCode |
(Object상속됩니다.) |
| public 메서드 |
GetType |
(Object상속됩니다.) |
| protected 메서드 |
MemberwiseClone | (Object상속됩니다.) |
| public 메서드 |
onCompleted |
모든 구독된 관찰자에게 시퀀스의 끝을 알립니다. |
| public 메서드 |
onError |
모든 구독된 관찰자에게 예외를 알 수 있습니다. |
| public 메서드 |
OnNext |
모든 구독된 관찰자에게 값을 알 수 있습니다. |
| public 메서드 |
구독 | 관찰자를 제목에 구독합니다. |
| public 메서드 |
ToString | (Object상속됩니다.) |
맨 위로
확장 메서드
| 이름 | 묘사 | |
|---|---|---|
| 공용 확장 메서드 |
집계<T>(Func<T, T, T>) | 오버 로드. 관찰 가능한 시퀀스에 누적기 함수를 적용합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
집계<T, TAccumulate>(TAccumulate, Func<TAccumulate, T, TAccumulate>) | 오버 로드. 지정된 시드 값을 사용하여 관찰 가능한 시퀀스에 누적기 함수를 적용합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
모든 |
관찰 가능한 시퀀스의 모든 요소가 조건을 충족하는지 여부를 결정합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
Amb<T> | 지정된 첫 번째 및 두 번째 시퀀스를 사용하여 먼저 반응하는 관찰 가능한 시퀀스를 전파합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
및<T, TRight> | 관찰 가능한 두 시퀀스에 사용 가능한 값이 있는 경우 일치합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
모든<T>() | 오버 로드. 관찰 가능한 시퀀스에 요소가 포함되어 있는지 여부를 확인합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
모든<T>(Func<T, 부울>) | 오버 로드. 관찰 가능한 시퀀스의 모든 요소가 조건을 충족하는지 여부를 결정합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
asObservable |
관찰 가능한 시퀀스의 ID를 숨깁니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
AsObserver<T> | 관찰자의 ID를 숨깁니다. (Observer정의) |
| 공용 확장 메서드 |
asQbservable |
관찰 가능한 시퀀스를 쿼리 가능한 관찰 가능한 시퀀스로 변환합니다. (Qbservable의해 정의됩니다.) |
| 공용 확장 메서드 |
AssertEqual<T> | (확장의해 정의됩니다.) |
| 공용 확장 메서드 |
버퍼<T>(Int32) | 오버 로드. 관찰 가능한 시퀀스의 각 요소를 요소 수 정보에 따라 생성되는 연속된 겹치지 않는 버퍼로 나타냅니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
버퍼<T>(TimeSpan) | 오버 로드. 타이밍 정보를 기반으로 생성되는 연속된 겹치지 않는 버퍼로 관찰 가능한 시퀀스의 각 요소를 나타냅니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
버퍼<T>(Int32, Int32) | 오버 로드. 요소 개수 정보를 기반으로 생성되는 0개 이상의 버퍼로 관찰 가능한 시퀀스의 각 요소를 나타냅니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
버퍼<T>(TimeSpan, IScheduler) | 오버 로드. 타이밍 정보를 기반으로 생성되는 연속된 겹치지 않는 버퍼로 관찰 가능한 시퀀스의 각 요소를 나타냅니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
버퍼<T>(TimeSpan, TimeSpan) | 오버 로드. 타이밍 정보를 기반으로 생성되는 0개 이상의 버퍼로 관찰 가능한 시퀀스의 각 요소를 나타냅니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
버퍼<T>(TimeSpan, Int32) | 오버 로드. 관찰 가능한 시퀀스의 각 요소를 버퍼로 나타내며, 버퍼가 가득 차거나 지정된 시간이 경과할 때 전송됩니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
버퍼<T>(TimeSpan, TimeSpan, IScheduler) | 오버 로드. 타이밍 정보를 기반으로 생성되는 0개 이상의 버퍼로 관찰 가능한 시퀀스의 각 요소를 나타냅니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
버퍼<T>(TimeSpan, Int32, IScheduler) | 오버 로드. 관찰 가능한 시퀀스의 각 요소를 버퍼로 나타내며, 버퍼가 가득 차거나 지정된 시간이 경과할 때 전송됩니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
버퍼<T, TBufferClosing>(Func<IObservable<TBufferClosing>>) | 오버 로드. 연속된 겹치지 않는 버퍼로 관찰 가능한 시퀀스의 각 요소를 나타냅니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
버퍼<T, TBufferOpening, TBufferClosing>(IObservable<TBufferOpening>, Func<TBufferOpening, IObservable<TBufferClosing>>) | 오버 로드. 쿼리 가능한 관찰 가능한 시퀀스의 각 요소를 연속된 겹치지 않는 버퍼로 나타냅니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
catch<T>(IObservable<T>) | 오버 로드. 다음 관찰 가능한 시퀀스를 사용하여 예외에 의해 종료되는 관찰 가능한 시퀀스를 계속합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
Catch<T, TException>(Func<TException, IObservable<T>>) | 오버 로드. 처리기에서 생성된 관찰 가능한 시퀀스를 사용하여 지정된 형식의 예외에 의해 종료되는 관찰 가능한 시퀀스를 계속합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
CombineLatest<T, TSecond, TResult> | 관찰 가능한 시퀀스 중 하나가 요소를 생성할 때마다 선택기 함수를 사용하여 관찰 가능한 두 시퀀스를 하나의 관찰 가능한 시퀀스로 병합합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
Concat<T> | 두 개의 관찰 가능한 시퀀스를 연결합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
<T(T)> 포함 | 오버 로드. 기본 같음 비교자를 사용하여 관찰 가능한 시퀀스에 지정된 요소가 포함되어 있는지 여부를 확인합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
<T>포함(T, IEqualityComparer<T>) | 오버 로드. 지정된 System.Collections.Generic.IEqualityComparer<를 사용하여 관찰 가능한 시퀀스에 지정된 요소가 포함되어 있는지 여부를 확인합니다. T&;. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
개수<T> | 관찰 가능한 시퀀스의 총 요소 수를 나타내는 Int32 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
DefaultIfEmpty<T>() | 오버 로드. 시퀀스가 비어 있는 경우 지정된 시퀀스의 요소 또는 형식 매개 변수의 기본값을 싱글톤 시퀀스로 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
DefaultIfEmpty<T(T)> | 오버 로드. 시퀀스가 비어 있는 경우 지정된 시퀀스의 요소 또는 형식 매개 변수의 기본값을 싱글톤 시퀀스로 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
지연<T>(TimeSpan) | 오버 로드. 지정된 원본 및 dueTime을 사용하여 적절한 시간별 관찰 가능한 시퀀스를 나타냅니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
지연<T>(DateTimeOffset) | 오버 로드. 지정된 원본 및 dueTime을 사용하여 적절한 시간별 관찰 가능한 시퀀스를 나타냅니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
지연<T>(TimeSpan, IScheduler) | 오버 로드. 지정된 원본 dueTime 및 스케줄러를 사용하여 적절한 시간별 관찰 가능한 시퀀스를 나타냅니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
지연<T>(DateTimeOffset, IScheduler) | 오버 로드. 지정된 원본 dueTime 및 스케줄러를 사용하여 적절한 시간별 관찰 가능한 시퀀스를 나타냅니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
Distinct<T>() | 오버 로드. 지정된 소스가 있는 고유 요소만 포함하는 관찰 가능한 시퀀스를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
Distinct<T>(IEqualityComparer<T>) | 오버 로드. 비교자에 따라 고유 요소만 포함하는 관찰 가능한 시퀀스를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
Distinct<T, TKey>(Func<T, TKey>) | 오버 로드. keySelector에 따라 고유 요소만 포함하는 관찰 가능한 시퀀스를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
Distinct<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>) | 오버 로드. keySelector에 따라 고유 요소만 포함하는 관찰 가능한 시퀀스를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
DistinctUntilChanged<T>() | 오버 로드. 지정된 소스와 고유한 연속 요소만 포함하는 관찰 가능한 시퀀스를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
DistinctUntilChanged<T>(IEqualityComparer<T>) | 오버 로드. 비교자에 따라 고유한 연속 요소만 포함하는 관찰 가능한 시퀀스를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
DistinctUntilChanged<T, TKey>(Func<T, TKey>) | 오버 로드. keySelector에 따라 고유한 연속 요소만 포함하는 관찰 가능한 시퀀스를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
DistinctUntilChanged<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>) | 오버 로드. keySelector 및 비교자에 따라 고유한 연속 요소만 포함하는 관찰 가능한 시퀀스를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
<T>(작업<T>) | 오버 로드. 관찰 가능한 시퀀스의 각 요소에 대한 작업을 호출합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
T><(IObserver<T>) | 오버 로드. 관찰 가능한 시퀀스의 각 요소에 대한 작업을 호출하고 관찰 가능한 시퀀스가 예외적으로 종료될 때 작업을 호출합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
T><(작업<T>, 작업) | 오버 로드. 관찰 가능한 시퀀스의 각 요소에 대한 작업을 호출하고 관찰 가능한 시퀀스가 정상적으로 종료될 때 작업을 호출합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
<T>(작업<T>, 작업<예외>) | 오버 로드. 관찰 가능한 시퀀스의 각 요소에 대한 작업을 호출하고 관찰 가능한 시퀀스가 예외적으로 종료될 때 작업을 호출합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
<T>(작업<T>, 작업<예외>, 작업) | 오버 로드. 관찰 가능한 시퀀스의 각 요소에 대한 작업을 호출하고 관찰 가능한 시퀀스의 정상 또는 예외적 종료 시 작업을 호출합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
ElementAt<T> | 시퀀스의 지정된 인덱스에 있는 요소를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
ElementAtOrDefault<T> | 시퀀스의 지정된 인덱스에 있는 요소를 반환하거나 인덱스가 범위를 벗어나면 기본값을 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
마지막으로<T> | 원본 관찰 가능한 시퀀스가 정상적으로 종료되거나 예외에 의해 종료된 후 지정된 작업을 호출합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
First<T>() | 오버 로드. 지정된 원본을 사용하여 관찰 가능한 시퀀스의 첫 번째 요소를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
First<T>(Func<T, Boolean>) | 오버 로드. 조건자와 일치하는 관찰 가능한 시퀀스의 첫 번째 요소를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
FirstOrDefault<T>() | 오버 로드. 관찰 가능한 시퀀스의 첫 번째 요소를 반환하거나 값을 찾을 수 없는 경우 기본값을 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
FirstOrDefault<T>(Func<T, Boolean>) | 오버 로드. 조건자와 일치하는 관찰 가능한 시퀀스의 첫 번째 요소를 반환하거나 값을 찾을 수 없는 경우 기본값을 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
Foo<T, R> | (MyExt정의) |
| 공용 확장 메서드 |
ForEach<T> | 관찰 가능한 시퀀스의 각 요소에 대한 작업을 호출하고 시퀀스가 종료될 때까지 차단합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
GetEnumerator |
관찰 가능한 시퀀스의 모든 값을 열거하는 열거자를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
GroupBy<T, TKey>(Func<T, TKey>) | 오버 로드. 지정된 키 선택기 함수에 따라 관찰 가능한 시퀀스의 요소를 그룹화합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
GroupBy<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>) | 오버 로드. 지정된 키 선택기 함수 및 비교자에 따라 관찰 가능한 시퀀스의 요소를 그룹화합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
GroupBy<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>) | 오버 로드. 관찰 가능한 시퀀스의 요소를 그룹화하고 지정된 함수를 사용하여 결과 요소를 선택합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
GroupBy<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>, IEqualityComparer<TKey>) | 오버 로드. 지정된 키 선택기 함수 및 비교자에 따라 관찰 가능한 시퀀스의 요소를 그룹화하고 지정된 함수를 사용하여 결과 요소를 선택합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
GroupByUntil<T, TKey, TDuration>(Func<T, TKey>, Func<IGroupedObservable<TKey, T>, IObservable<TDuration>>) | 오버 로드. 지정된 키 선택기 함수에 따라 관찰 가능한 시퀀스의 요소를 그룹화합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
GroupByUntil<T, TKey, TDuration>(Func<T, TKey>, Func<IGroupedObservable<TKey, T>, IObservable<TDuration>>, IEqualityComparer<TKey>) | 오버 로드. 지정된 키 선택기 함수 및 비교자에 따라 관찰 가능한 시퀀스의 요소를 그룹화합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
GroupByUntil<T, TKey, TElement, TDuration>(Func<T, TKey>, Func<T, TElement>, Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>>) | 오버 로드. 지정된 키 선택기 함수에 따라 관찰 가능한 시퀀스의 요소를 그룹화하고 지정된 함수를 사용하여 결과 요소를 선택합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
GroupByUntil<T, TKey, TElement, TDuration>(Func<T, TKey>, Func<T, TElement>, Func<IGroupedObservable<TKey, TElement>, IObservable<TDuration>>, IEqualityComparer<TKey>) | 오버 로드. 지정된 키 선택기 함수 및 비교자에 따라 관찰 가능한 시퀀스의 요소를 그룹화하고 지정된 함수를 사용하여 결과 요소를 선택합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
GroupJoin<T, TRight, TLeftDuration, TRightDuration, TResult> | 겹치는 기간을 기준으로 두 시퀀스의 요소 상관 관계를 지정하고 결과를 그룹화합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
IgnoreElements |
종료 메시지만 남기고 관찰 가능한 시퀀스의 모든 값을 무시합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
조인<T, TRight, TLeftDuration, TRightDuration, TResult> | 겹치는 기간을 기준으로 두 시퀀스의 요소 상관 관계를 지정합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
마지막<T>() | 오버 로드. 지정된 소스를 사용하여 관찰 가능한 시퀀스의 마지막 요소를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
마지막<T>(Func<T, 부울>) | 오버 로드. 조건자와 일치하는 관찰 가능한 시퀀스의 마지막 요소를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
LastOrDefault<T>() | 오버 로드. 관찰 가능한 시퀀스에서 마지막 요소를 반환하거나 값을 찾을 수 없는 경우 기본값을 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
LastOrDefault<T>(Func<T, Boolean>) | 오버 로드. 조건자와 일치하는 관찰 가능한 시퀀스의 마지막 요소를 반환하거나 값을 찾을 수 없는 경우 기본값을 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
최신 |
관찰 가능한 시퀀스에서 가장 최근 값을 샘플링합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
LongCount<T> | 관찰 가능한 시퀀스의 총 요소 수를 나타내는 Int64 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
구체화<T> | 관찰 가능한 시퀀스의 암시적 알림을 명시적 알림 값으로 구체화합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
최대 |
오버 로드. 관찰 가능한 시퀀스의 최대 요소를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
최대<T>(IComparer<T>) | 오버 로드. 지정된 비교자에 따라 관찰 가능한 시퀀스의 최대값을 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
MaxBy<T, TKey>(Func<T, TKey>) | 오버 로드. 최대 키 값을 사용하여 관찰 가능한 시퀀스의 요소를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
MaxBy<T, TKey>(Func<T, TKey>, IComparer<TKey>) | 오버 로드. 최대 키 값을 사용하여 관찰 가능한 시퀀스의 요소를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
병합<T>(IObservable<T>) | 오버 로드. 관찰 가능한 시퀀스의 관찰 가능한 시퀀스를 관찰 가능한 시퀀스로 병합합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
병합<T>(IObservable<T>, IScheduler) | 오버 로드. 관찰 가능한 두 시퀀스를 관찰 가능한 단일 시퀀스로 병합합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
최소<T>() | 오버 로드. 관찰 가능한 시퀀스에서 최소 요소를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
최소<T>(IComparer<T>) | 오버 로드. 지정된 비교자에 따라 관찰 가능한 시퀀스의 최소값을 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
MinBy<T, TKey>(Func<T, TKey>) | 오버 로드. 최소 키 값을 사용하여 관찰 가능한 시퀀스의 요소를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
MinBy<T, TKey>(Func<T, TKey>, IComparer<TKey>) | 오버 로드. 지정된 비교자에 따라 최소 키 값을 사용하여 관찰 가능한 시퀀스의 요소를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
MostRecent<T> | 관찰 가능한 시퀀스에서 가장 최근 값을 샘플링합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
멀티캐스트<T, TResult>(ISubject<T, TResult>) | 오버 로드. 연결 시 원본 시퀀스가 지정된 주체에 결과를 푸시하도록 하는 연결 가능한 관찰 가능한 시퀀스를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
멀티캐스트<T, TIntermediate, TResult>(Func<ISubject<T, TIntermediate>>, Func<IObservable<TIntermediate>, IObservable<TResult>>) | 오버 로드. 선택기 함수 내에서 소스 시퀀스를 멀티캐스트하여 생성된 시퀀스의 요소를 포함하는 관찰 가능한 시퀀스를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
다음<T> | 관찰 가능한 시퀀스에서 다음 값(버퍼링 없이 차단)을 샘플링합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
ObserveOn<T>(SynchronizationContext) | 오버 로드. 지정된 동기화 컨텍스트에 대해 관찰자에게 비동기적으로 알립니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
ObserveOn<T>(제어) | 오버 로드. (ControlObservable의해 정의됩니다.) |
| 공용 확장 메서드 |
ObserveOn<T>(Dispatcher) | 오버 로드. (DispatcherObservable의해 정의됩니다.) |
| 공용 확장 메서드 |
ObserveOn<T>(DispatcherScheduler) | 오버 로드. (DispatcherObservable의해 정의됩니다.) |
| 공용 확장 메서드 |
ObserveOn<T>(IScheduler) | 오버 로드. 지정된 스케줄러에 대해 관찰자에게 비동기적으로 알립니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
ObserveOnDispatcher<T> | (DispatcherObservable의해 정의됩니다.) |
| 공용 확장 메서드 |
OnErrorResumeNext<T> | 관찰 가능한 다음 시퀀스를 사용하여 정상적으로 또는 예외에 의해 종료되는 관찰 가능한 시퀀스를 계속합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
게시<T>() | 오버 로드. 기본 시퀀스에 단일 구독을 공유하는 연결 가능한 관찰 가능한 시퀀스를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
오버 로드. 단일 구독을 기본 시퀀스에 공유하고 initialValue로 시작하는 연결 가능한 관찰 가능한 시퀀스를 반환합니다. (Observable의해 정의됩니다.) | |
| 공용 확장 메서드 |
게시<T, TResult>(Func<IObservable<T>, IObservable<TResult>>) | 오버 로드. 단일 구독을 기본 시퀀스에 공유하는 연결 가능한 관찰 가능한 시퀀스에서 선택기를 호출한 결과인 관찰 가능한 시퀀스를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
게시<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, T) | 오버 로드. 단일 구독을 기본 시퀀스에 공유하고 initialValue로 시작하는 연결 가능한 관찰 가능한 시퀀스를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
PublishLast<T>() | 오버 로드. 마지막 알림만 포함하는 기본 시퀀스에 단일 구독을 공유하는 연결 가능한 관찰 가능한 시퀀스를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
PublishLast<T, TResult>(Func<IObservable<T>, IObservable<TResult>>) | 오버 로드. 마지막 알림만 포함하는 기본 시퀀스에 단일 구독을 공유하는 연결 가능한 관찰 가능한 시퀀스에서 선택기를 호출한 결과인 관찰 가능한 시퀀스를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
반복<T>() | 오버 로드. 관찰 가능한 시퀀스를 무기한 반복합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
반복<T>(Int32) | 오버 로드. 관찰 가능한 시퀀스를 무기한 반복합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
재생<T>() | 오버 로드. 모든 알림을 재생하는 기본 시퀀스에 단일 구독을 공유하는 연결 가능한 관찰 가능한 시퀀스를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
재생<T>(TimeSpan) | 오버 로드. 창 내의 모든 알림을 재생하는 기본 시퀀스에 단일 구독을 공유하는 연결 가능한 관찰 가능한 시퀀스를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
재생<T>(Int32) | 오버 로드. 기본 시퀀스 재생 bufferSize 알림에 단일 구독을 공유하는 연결 가능한 관찰 가능한 시퀀스를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
재생<T>(IScheduler) | 오버 로드. 모든 알림을 재생하는 기본 시퀀스에 단일 구독을 공유하는 연결 가능한 관찰 가능한 시퀀스를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
재생<T>(TimeSpan, IScheduler) | 오버 로드. 창 내의 모든 알림을 재생하는 기본 시퀀스에 단일 구독을 공유하는 연결 가능한 관찰 가능한 시퀀스를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
재생<T>(Int32, IScheduler) | 오버 로드. 기본 시퀀스 재생 bufferSize 알림에 단일 구독을 공유하는 연결 가능한 관찰 가능한 시퀀스를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
재생<T>(Int32, TimeSpan) | 오버 로드. 창 내의 기본 시퀀스 재생 bufferSize 알림에 단일 구독을 공유하는 연결 가능한 관찰 가능한 시퀀스를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
재생<T>(Int32, TimeSpan, IScheduler) | 오버 로드. 창 내의 기본 시퀀스 재생 bufferSize 알림에 단일 구독을 공유하는 연결 가능한 관찰 가능한 시퀀스를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>) | 오버 로드. 기본 시퀀스에 대한 단일 구독을 공유하고 초기 값으로 시작하는 연결 가능한 관찰 가능한 시퀀스에서 선택기를 호출한 결과인 관찰 가능한 시퀀스를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, IScheduler) | 오버 로드. 모든 알림을 재생하는 기본 시퀀스에 단일 구독을 공유하는 연결 가능한 관찰 가능한 시퀀스에서 선택기를 호출한 결과인 관찰 가능한 시퀀스를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, TimeSpan) | 오버 로드. 창 내의 모든 알림을 재생하는 기본 시퀀스에 대한 단일 구독을 공유하는 연결 가능한 관찰 가능한 시퀀스에서 선택기를 호출한 결과인 관찰 가능한 시퀀스를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, Int32) | 오버 로드. 기본 시퀀스 재생 bufferSize 알림에 단일 구독을 공유하는 연결 가능한 관찰 가능한 시퀀스에서 선택기를 호출한 결과인 관찰 가능한 시퀀스를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, TimeSpan, IScheduler) | 오버 로드. 창 내의 모든 알림을 재생하는 기본 시퀀스에 대한 단일 구독을 공유하는 연결 가능한 관찰 가능한 시퀀스에서 선택기를 호출한 결과인 관찰 가능한 시퀀스를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
재생<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, Int32, IScheduler) | 오버 로드. 기본 시퀀스 재생 bufferSize 알림에 단일 구독을 공유하는 연결 가능한 관찰 가능한 시퀀스에서 선택기를 호출한 결과인 관찰 가능한 시퀀스를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
재생<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, Int32, TimeSpan) | 오버 로드. 단일 구독을 공유하는 연결 가능한 관찰 가능한 시퀀스에서 선택기를 호출하여 창 내의 기본 시퀀스 재생 bufferSize 알림을 반환하는 관찰 가능한 시퀀스를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
Replay<T, TResult>(Func<IObservable<T>, IObservable<TResult>>, Int32, TimeSpan, IScheduler) | 오버 로드. 단일 구독을 공유하는 연결 가능한 관찰 가능한 시퀀스에서 선택기를 호출하여 창 내의 기본 시퀀스 재생 bufferSize 알림을 반환하는 관찰 가능한 시퀀스를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
다시 시도<T>() | 오버 로드. 원본 관찰 가능한 시퀀스가 성공적으로 종료될 때까지 반복합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
다시 시도<T>(Int32) | 오버 로드. 원본 관찰 가능한 시퀀스가 성공적으로 종료될 때까지 반복합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
샘플<T>(TimeSpan) | 오버 로드. 각 간격에서 관찰 가능한 시퀀스를 샘플링합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
샘플<T>(TimeSpan, IScheduler) | 오버 로드. 지정된 원본, 간격 및 스케줄러를 사용하여 각 간격에서 관찰 가능한 시퀀스를 샘플링합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
샘플<T, TSample>(IObservable<TSample>) | 오버 로드. 지정된 소스 및 샘플러를 사용하여 샘플링 틱에서 관찰 가능한 시퀀스를 샘플링합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
스캔<T>(Func<T, T, T>) | 오버 로드. 관찰 가능한 시퀀스에 누적기 함수를 적용하고 지정된 원본 및 누적기를 사용하여 각 중간 결과를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
Scan<T, TAccumulate>(TAccumulate, Func<TAccumulate, T, TAccumulate>) | 오버 로드. 관찰 가능한 시퀀스에 누적기 함수를 적용하고 지정된 소스, 시드 및 누적기를 사용하여 각 중간 결과를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
<T, TResult>(Func<T, TResult>) | 오버 로드. 관찰 가능한 시퀀스의 각 요소를 지정된 원본 및 선택기를 사용하여 새 양식으로 투영합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
<T, TResult>(Func<T, Int32, TResult>) | 오버 로드. 요소의 인덱스를 지정된 원본 및 선택기와 통합하여 관찰 가능한 시퀀스의 각 요소를 새 형식으로 투영합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
SelectMany<T, TOther>(IObservable<TOther>) | 오버 로드. 관찰 가능한 시퀀스의 각 요소를 관찰 가능한 시퀀스에 투영하고 결과 관찰 가능한 시퀀스를 하나의 관찰 가능한 시퀀스로 평면화합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
SelectMany<T, TResult>(Func<T, IObservable<TResult>>) | 오버 로드. 관찰 가능한 시퀀스의 각 요소를 관찰 가능한 시퀀스에 투영하고 결과 관찰 가능한 시퀀스를 하나의 관찰 가능한 시퀀스로 평면화합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
SelectMany<T, TResult>(Func<T, IEnumerable<TResult>>) | 오버 로드. 관찰 가능한 시퀀스의 각 요소를 관찰 가능한 시퀀스에 투영하고 결과 관찰 가능한 시퀀스를 하나의 관찰 가능한 시퀀스로 평면화합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
SelectMany<T, TResult>(Func<T, IObservable<TResult>>, Func<Exception, IObservable<TResult>>, Func<IObservable<TResult>>) | 오버 로드. 관찰 가능한 시퀀스의 각 요소를 관찰 가능한 시퀀스에 투영하고 결과 관찰 가능한 시퀀스를 하나의 관찰 가능한 시퀀스로 평면화합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
SelectMany<T, TCollection, TResult>(Func<T, IEnumerable<TCollection>>, Func<T, TCollection, TResult>) | 오버 로드. 관찰 가능한 시퀀스의 각 요소를 관찰 가능한 시퀀스에 투영하고 결과 관찰 가능한 시퀀스를 하나의 관찰 가능한 시퀀스로 평면화합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
SelectMany<T, TCollection, TResult>(Func<T, IObservable<TCollection>>, Func<T, TCollection, TResult>) | 오버 로드. 관찰 가능한 시퀀스의 각 요소를 관찰 가능한 시퀀스에 투영하고 결과 관찰 가능한 시퀀스를 하나의 관찰 가능한 시퀀스로 평면화합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
SequenceEqual<T>(IObservable<T>) | 오버 로드. 요소를 쌍으로 비교하여 두 시퀀스가 같은지 여부를 결정합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
SequenceEqual<T>(IObservable<T>, IEqualityComparer<T>) | 오버 로드. 지정된 같음 비교자를 사용하여 요소를 쌍으로 비교하여 두 시퀀스가 같은지 여부를 결정합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
단일<T>() | 오버 로드. 관찰 가능한 시퀀스의 유일한 요소를 반환하고 관찰 가능한 시퀀스에 요소가 하나도 없는 경우 예외를 throw합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
Single<T>(Func<T, 부울>) | 오버 로드. 조건자와 일치하는 관찰 가능한 시퀀스의 유일한 요소를 반환하고 관찰 가능한 시퀀스에 정확히 하나의 요소가 없는 경우 예외를 throw합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
SingleOrDefault<T>() | 오버 로드. 관찰 가능한 시퀀스의 유일한 요소를 반환하거나 관찰 가능한 시퀀스가 비어 있는 경우 기본값을 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
SingleOrDefault<T>(Func<T, Boolean>) | 오버 로드. 조건자와 일치하는 관찰 가능한 시퀀스의 유일한 요소 또는 값을 찾을 수 없는 경우 기본값을 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
건너뛰기<T> | 관찰 가능한 시퀀스에서 지정된 수의 값을 바이패스한 다음 나머지 값을 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
SkipLast<T> | 관찰 가능한 시퀀스의 끝에 지정된 개수의 요소를 바이패스합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
SkipUntil<T, TOther> | 관찰 가능한 다른 시퀀스가 값을 생성한 후에만 원본 관찰 가능한 시퀀스의 값을 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
SkipWhile<T>(Func<T, Boolean>) | 오버 로드. 지정된 조건이 true인 경우 관찰 가능한 시퀀스의 값을 무시한 다음 나머지 값을 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
SkipWhile<T>(Func<T, Int32, Boolean>) | 오버 로드. 지정된 조건이 true인 경우 관찰 가능한 시퀀스의 값을 무시한 다음 나머지 값을 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
StartWith<T>T[]) | 오버 로드. 지정된 원본 및 값이 있는 관찰 가능한 시퀀스에 값 시퀀스를 앞에 추가합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
StartWith<T>(IScheduler, T[]) | 오버 로드. 지정된 원본, 스케줄러 및 값을 사용하여 관찰 가능한 시퀀스에 값 시퀀스를 앞에 추가합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
구독<T>() | 오버 로드. 지정된 원본을 사용하여 관찰 가능한 시퀀스를 평가합니다. (ObservableExtensions의해 정의됩니다.) |
| 공용 확장 메서드 |
구독<T>(작업<T>) | 오버 로드. 요소 처리기를 관찰 가능한 시퀀스에 구독합니다. (ObservableExtensions의해 정의됩니다.) |
| 공용 확장 메서드 |
구독<T>(작업<T>, 작업<예외>) | 오버 로드. 요소 처리기 및 예외 처리기를 관찰 가능한 시퀀스에 구독합니다. (ObservableExtensions의해 정의됩니다.) |
| 공용 확장 메서드 |
구독<T>(작업<T>, 작업) | 오버 로드. 요소 처리기 및 완료 처리기를 관찰 가능한 시퀀스에 구독합니다. (ObservableExtensions의해 정의됩니다.) |
| 공용 확장 메서드 |
구독<T>(작업<T>, 작업<예외>, 작업) | 오버 로드. 요소 처리기, 예외 처리기 및 완료 처리기를 관찰 가능한 시퀀스에 구독합니다. (ObservableExtensions의해 정의됩니다.) |
| 공용 확장 메서드 |
SubscribeOn<T>(SynchronizationContext) | 오버 로드. 지정된 동기화 컨텍스트에서 관찰자를 비동기적으로 구독하고 구독을 취소합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
SubscribeOn<T>(제어) | 오버 로드. (ControlObservable의해 정의됩니다.) |
| 공용 확장 메서드 |
SubscribeOn<T>(Dispatcher) | 오버 로드. (DispatcherObservable의해 정의됩니다.) |
| 공용 확장 메서드 |
SubscribeOn<T>(DispatcherScheduler) | 오버 로드. (DispatcherObservable의해 정의됩니다.) |
| 공용 확장 메서드 |
SubscribeOn<T>(IScheduler) | 오버 로드. 지정된 스케줄러에서 관찰자를 비동기적으로 구독하고 구독을 취소합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
SubscribeOnDispatcher<T> | (DispatcherObservable의해 정의됩니다.) |
| 공용 확장 메서드 |
동기화<T>() | 오버 로드. 관찰 가능한 시퀀스를 동기화합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
오버 로드. 관찰 가능한 시퀀스를 동기화합니다. (Observable의해 정의됩니다.) | |
| 공용 확장 메서드 |
<T> | 관찰 가능한 시퀀스의 시작부터 지정된 수의 연속 값을 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
takeLast |
관찰 가능한 시퀀스의 끝에서 지정된 수의 연속 요소를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
TakeUntil<T, TOther> | 관찰 가능한 다른 시퀀스가 값을 생성할 때까지 원본 관찰 가능한 시퀀스의 값을 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
TakeWhile<T>(Func<T, Boolean>) | 오버 로드. 지정된 조건이 true이면 관찰 가능한 시퀀스에서 값을 반환한 다음 나머지 값을 건너뜁니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
TakeWhile<T>(Func<T, Int32, Boolean>) | 오버 로드. 지정된 조건이 true이면 관찰 가능한 시퀀스에서 값을 반환한 다음 나머지 값을 건너뜁니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
다음<T, TResult> | 관찰 가능한 시퀀스에 사용 가능한 값이 있고 값을 투영할 때 일치합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
제한<T>(TimeSpan) | 오버 로드. 지정된 원본 및 dueTime을 사용하여 기한 전에 다른 값이 뒤에 잇는 관찰 가능한 시퀀스의 값을 무시합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
제한<T>(TimeSpan, IScheduler) | 오버 로드. 지정된 원본 dueTime 및 스케줄러를 사용하여 적절한 시간 전에 다른 값이 뒤에 오는 관찰 가능한 시퀀스의 값을 무시합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
TimeInterval<T>() | 오버 로드. 지정된 원본을 사용하여 관찰 가능한 시퀀스에서 연속 값 사이의 시간 간격을 기록합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
TimeInterval<T>(IScheduler) | 오버 로드. 지정된 원본 및 스케줄러를 사용하여 관찰 가능한 시퀀스에서 연속 값 사이의 시간 간격을 기록합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
시간 제한<T>(TimeSpan) | 오버 로드. dueTime이 경과하면 관찰 가능한 시퀀스 또는 TimeoutException을 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
시간 제한<T>(DateTimeOffset) | 오버 로드. dueTime이 경과하면 관찰 가능한 시퀀스 또는 TimeoutException을 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
시간 제한<T>(TimeSpan, IObservable<T>) | 오버 로드. dueTime이 경과하면 관찰 가능한 원본 시퀀스 또는 관찰 가능한 다른 시퀀스를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
시간 제한<T>(DateTimeOffset, IObservable<T>) | 오버 로드. dueTime이 경과하면 관찰 가능한 시퀀스 또는 TimeoutException을 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
시간 제한<T>(TimeSpan, IScheduler) | 오버 로드. dueTime이 경과하면 관찰 가능한 시퀀스 또는 TimeoutException을 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
시간 제한<T>(DateTimeOffset, IScheduler) | 오버 로드. dueTime이 경과하면 관찰 가능한 시퀀스 또는 TimeoutException을 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
제한 시간<T>(TimeSpan, IObservable<T>, IScheduler) | 오버 로드. dueTime이 경과하면 관찰 가능한 원본 시퀀스 또는 관찰 가능한 다른 시퀀스를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
시간 제한<T>(DateTimeOffset, IObservable<T>, IScheduler) | 오버 로드. dueTime이 경과하면 관찰 가능한 원본 시퀀스 또는 관찰 가능한 다른 시퀀스를 반환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
타임스탬프<T>() | 오버 로드. 지정된 원본을 사용하여 관찰 가능한 시퀀스에서 각 값에 대한 타임스탬프를 기록합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
타임스탬프<T>(IScheduler) | 오버 로드. 지정된 원본 및 스케줄러를 사용하여 관찰 가능한 시퀀스에서 각 값에 대한 타임스탬프를 기록합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
toArray |
관찰 가능한 시퀀스에서 배열을 만듭니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
ToDictionary<T, TKey>(Func<T, TKey>) | 오버 로드. 지정된 키 선택기 함수에 따라 관찰 가능한 시퀀스에서 사전을 만듭니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
ToDictionary<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>) | 오버 로드. 지정된 키 선택기 함수 및 비교자에 따라 관찰 가능한 시퀀스에서 사전을 만듭니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
ToDictionary<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>) | 오버 로드. 지정된 키 선택기 함수 및 요소 선택기 함수에 따라 관찰 가능한 시퀀스에서 사전을 만듭니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
ToDictionary<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>, IEqualityComparer<TKey>) | 오버 로드. 지정된 키 선택기 함수, 비교자 및 요소 선택기 함수에 따라 관찰 가능한 시퀀스에서 사전을 만듭니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
ToEnumerable<T> | 관찰 가능한 시퀀스를 열거 가능한 시퀀스로 변환합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
ToEvent<T> | 지정된 소스가 있는 .NET 이벤트가 있는 개체로 관찰 가능한 시퀀스를 노출합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
ToList<T> | 관찰 가능한 시퀀스에서 목록을 만듭니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
ToLookup<T, TKey>(Func<T, TKey>) | 오버 로드. 지정된 키 선택기 함수에 따라 관찰 가능한 시퀀스에서 조회를 만듭니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
ToLookup<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>) | 오버 로드. 지정된 키 선택기 함수 및 비교자에 따라 관찰 가능한 시퀀스에서 조회를 만듭니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
ToLookup<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>) | 오버 로드. 지정된 키 선택기 함수 및 요소 선택기 함수에 따라 관찰 가능한 시퀀스에서 조회를 만듭니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
ToLookup<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>, IEqualityComparer<TKey>) | 오버 로드. 지정된 키 선택기 함수, 비교자 및 요소 선택기 함수에 따라 관찰 가능한 시퀀스에서 조회를 만듭니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
ToNotifier<T> | 관찰자로부터 알림 콜백을 만듭니다. (Observer정의) |
| 공용 확장 메서드 |
ToTask<T>() | 오버 로드. 관찰 가능한 시퀀스의 마지막 값을 포함하는 작업을 반환합니다. (TaskObservableExtensions정의됨) |
| 공용 확장 메서드 |
ToTask<T>(개체) | 오버 로드. 관찰 가능한 시퀀스의 마지막 값을 포함하는 작업을 반환합니다. (TaskObservableExtensions정의됨) |
| 공용 확장 메서드 |
ToTask<T>(CancellationToken) | 오버 로드. 관찰 가능한 시퀀스의 마지막 값을 포함하는 작업을 반환합니다. (TaskObservableExtensions정의됨) |
| 공용 확장 메서드 |
ToTask<T>(CancellationToken, Object) | 오버 로드. 관찰 가능한 시퀀스의 마지막 값을 포함하는 작업을 반환합니다. (TaskObservableExtensions정의됨) |
| 공용 확장 메서드 |
<T>위치(Func<T, 부울>) | 오버 로드. 조건자를 기반으로 관찰 가능한 시퀀스의 요소를 필터링합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
여기서<T>(Func<T, Int32, Boolean>) | 오버 로드. 요소의 인덱스를 통합하여 조건자를 기반으로 관찰 가능한 시퀀스의 요소를 필터링합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
창<T>(Int32) | 오버 로드. 관찰 가능한 시퀀스의 각 요소를 요소 개수 정보를 기반으로 생성되는 연속된 겹치지 않는 창으로 프로젝션합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
창<T>(TimeSpan) | 오버 로드. 관찰 가능한 시퀀스의 각 요소를 타이밍 정보를 기반으로 생성되는 연속된 겹치지 않는 창으로 프로젝션합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
창<T>(Int32, Int32) | 오버 로드. 관찰 가능한 시퀀스의 각 요소를 요소 수 정보에 따라 생성되는 0개 이상의 창으로 프로젝션합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
창<T>(TimeSpan, IScheduler) | 오버 로드. 관찰 가능한 시퀀스의 각 요소를 타이밍 정보를 기반으로 생성되는 연속된 겹치지 않는 창으로 프로젝션합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
창<T>(TimeSpan, TimeSpan) | 오버 로드. 관찰 가능한 시퀀스의 각 요소를 타이밍 정보를 기반으로 생성되는 0개 이상의 창으로 프로젝션합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
창<T>(TimeSpan, Int32) | 오버 로드. 관찰 가능한 시퀀스의 각 요소를 가득 차거나 지정된 시간이 경과할 때 완료되는 창으로 투영합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
Window<T>(TimeSpan, TimeSpan, IScheduler) | 오버 로드. 관찰 가능한 시퀀스의 각 요소를 타이밍 정보를 기반으로 생성되는 0개 이상의 창으로 프로젝션합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
창<T>(TimeSpan, Int32, IScheduler) | 오버 로드. 관찰 가능한 시퀀스의 각 요소를 가득 차거나 지정된 시간이 경과할 때 완료되는 창으로 투영합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
Window<T, TWindowClosing>(Func<IObservable<TWindowClosing>>) | 오버 로드. 관찰 가능한 시퀀스의 각 요소를 연속된 겹치지 않는 창으로 투영합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
Window<T, TWindowOpening, TWindowClosing>(IObservable<TWindowOpening>, Func<TWindowOpening, IObservable<TWindowClosing>>) | 오버 로드. 관찰 가능한 시퀀스의 각 요소를 0개 이상의 창으로 투영합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
Zip<T, TSecond, TResult>(IObservable<TSecond>, Func<T, TSecond, TResult>) | 오버 로드. 해당 요소를 쌍으로 결합하여 관찰 가능한 두 시퀀스를 하나의 관찰 가능한 시퀀스로 병합합니다. (Observable의해 정의됩니다.) |
| 공용 확장 메서드 |
Zip<T, TSecond, TResult>(IEnumerable<TSecond>, Func<T, TSecond, TResult>) | 오버 로드. 선택기 함수를 사용하여 관찰 가능한 시퀀스와 열거 가능한 시퀀스를 하나의 관찰 가능한 시퀀스로 병합합니다. (Observable의해 정의됩니다.) |
맨 위로
발언
주체는 구독자 및 게시자 역할을 한다는 측면에서 프록시와 유사하게 작동합니다. 해당 IObserver 인터페이스를 사용하여 여러 스트림 또는 데이터 시퀀스를 구독할 수 있습니다. 그런 다음 데이터는 IObservable 인터페이스를 통해 게시됩니다.
BehaviorSubject는 IObservable 인터페이스를 통해 게시된 마지막 항목을 버퍼링합니다. IObservable 인터페이스를 통해 게시된 항목이 없는 경우 생성자에 제공된 초기 항목은 현재 버퍼링된 항목입니다. BehaviorSubject의 IObservable 인터페이스에 대한 구독을 만들면 게시된 시퀀스가 현재 버퍼링된 항목으로 시작됩니다.
IObserver 인터페이스가 완료를 받으면 BehaviorSubject에서 항목이 버퍼링되거나 게시되지 않습니다.
예제
이 예제에서는 BehaviorSubject를 보여 줍니다. 이 예제에서는 Interval 연산자를 사용하여 1초마다 정수 시퀀스에 정수를 게시합니다. 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 네임스페이스