관찰 가능한 시퀀스인 개체와 관찰자를 나타냅니다.
상속 계층 구조
System.Object
System.Reactive.Subjects.subject<T>
네임스페이스:System.Reactive.Subjects
어셈블리: System.Reactive(System.Reactive.dll)
통사론
'Declaration
Public NotInheritable Class Subject(Of T) _
Implements ISubject(Of T), ISubject(Of T, T), _
IObserver(Of T), IObservable(Of T), IDisposable
'Usage
Dim instance As Subject(Of T)
public sealed class Subject<T> : ISubject<T>,
ISubject<T, T>, IObserver<T>, IObservable<T>, IDisposable
generic<typename T>
public ref class Subject sealed : ISubject<T>,
ISubject<T, T>, IObserver<T>, IObservable<T>, IDisposable
[<SealedAttribute>]
type Subject<'T> =
class
interface ISubject<'T>
interface ISubject<'T, 'T>
interface IObserver<'T>
interface IObservable<'T>
interface IDisposable
end
JScript does not support generic types and methods.
형식 매개 변수
- T
형식입니다.
제목<T> 형식은 다음 멤버를 노출합니다.
생성자
| 이름 | 묘사 | |
|---|---|---|
| public 메서드 |
제목<T> | Subject<T> 클래스의 새 인스턴스를 초기화합니다. |
맨 위로
방법
| 이름 | 묘사 | |
|---|---|---|
| public 메서드 |
삭제 | Subject<T> 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제하고 모든 관찰자 구독을 취소합니다. |
| 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 인터페이스를 지원하여 수행됩니다. IObserver 인터페이스를 사용하여 주체를 여러 스트림 또는 데이터 시퀀스를 구독할 수 있습니다. 그런 다음 데이터는 구독된 모든 관찰자에게 IObservable 인터페이스를 통해 게시됩니다. 일반 주체는 스케줄러를 사용하여 구독된 관찰자에게 나가는 호출을 동기화합니다.
예제
이 예제에서는 주체 클래스를 사용하는 방법을 보여 줍니다. 문자열 형식의 제목 인스턴스는 두 개의 예제 뉴스 피드를 구독하는 데 사용됩니다. 이러한 피드는 5초 간격으로 임의의 뉴스 헤드라인을 게시합니다. 그런 다음, 주체의 관찰 가능한 인터페이스에 대한 두 개의 구독이 만들어져 결합된 데이터 스트림을 받습니다. 한 구독은 데이터 스트림의 각 항목을 "모든 뉴스"로 보고합니다. 다른 구독은 스트림의 각 헤드라인을 필터링하여 로컬 헤드라인만 보고합니다. 구독은 모두 받은 각 헤드라인을 콘솔 창에 씁니다. 사용자가 Enter 키를 누르고 Dispose가 호출되어 두 구독을 모두 취소하면 처리가 종료됩니다.
using System;
using System.Reactive.Linq;
using System.Reactive.Subjects;
using System.Reactive.Concurrency;
using System.Threading;
namespace Example
{
class Program
{
static void Main()
{
//*****************************************************************************************************//
//*** ***//
//*** A subject acts similar to a proxy in that it acts as both a subscriber and a publisher ***//
//*** It's IObserver interface can be used to subscribe to multiple streams or sequences of data. ***//
//*** The data is then published through it's IObservable interface. ***//
//*** ***//
//*** In this example a simple string based subject is used to subscribe to multiple news feeds ***//
//*** that provide random news headlines. Subscribers can then subscribe to the subject's ***//
//*** observable interface to observe the data stream(s) or a subset ofthe stream(s). Below we ***//
//*** subscribe the subject to two different news headline feeds. Then two subscriptions are ***//
//*** created: one for delivery of all news headlines, the other receives only local news headlines ***//
//*** ***//
//*** A local news headline just contains the newsLocation substring ("in your area."). ***//
//*** ***//
//*****************************************************************************************************//
Subject<string> mySubject = new Subject<string>();
//*********************************************************//
//*** Create news feed #1 and subscribe mySubject to it ***//
//*********************************************************//
NewsHeadlineFeed NewsFeed1 = new NewsHeadlineFeed("Headline News Feed #1");
NewsFeed1.HeadlineFeed.Subscribe(mySubject);
//*********************************************************//
//*** Create news feed #2 and subscribe mySubject to it ***//
//*********************************************************//
NewsHeadlineFeed NewsFeed2 = new NewsHeadlineFeed("Headline News Feed #2");
NewsFeed2.HeadlineFeed.Subscribe(mySubject);
Console.WriteLine("Subscribing to news headline feeds.\n\nPress ENTER to exit.\n");
//*****************************************************************************************************//
//*** Create a subscription to the subject's observable sequence. This subscription will receive ***//
//*** all headlines. ***//
//*****************************************************************************************************//
IDisposable allNewsSubscription = mySubject.Subscribe(x =>
{
Console.WriteLine("Subscription : All news subscription\n{0}\n", x);
});
//*****************************************************************************************************//
//*** Create a subscription to the subject's observable sequence. This subscription will filter for ***//
//*** only local headlines. ***//
//*****************************************************************************************************//
IDisposable localNewsSubscription = mySubject.Where(x => x.Contains("in your area.")).Subscribe(x =>
{
Console.WriteLine("\n************************************\n" +
"***[ Local news headline report ]***\n" +
"************************************\n{0}\n\n", x);
});
Console.ReadLine();
//*********************************//
//*** Cancel both subscriptions ***//
//*********************************//
allNewsSubscription.Dispose();
localNewsSubscription.Dispose();
}
}
//*********************************************************************************//
//*** The NewsHeadlineFeed class is just a mock news feed in the form of an ***//
//*** observable sequence in Reactive Extensions. ***//
//*********************************************************************************//
class NewsHeadlineFeed
{
private string feedName; // Feedname used to label the stream
private IObservable<string> headlineFeed; // The actual data stream
private readonly Random rand = new Random(); // Used to stream random headlines.
//*** A list of predefined news events to combine with a simple location string ***//
static readonly string[] newsEvents = { "A tornado occurred ",
"Weather watch for snow storm issued ",
"A robbery occurred ",
"We have a lottery winner ",
"An earthquake occurred ",
"Severe automobile accident "};
//*** A list of predefined location strings to combine with a news event. ***//
static readonly string[] newsLocations = { "in your area.",
"in Dallas, Texas.",
"somewhere in Iraq.",
"Lincolnton, North Carolina",
"Redmond, Washington"};
public IObservable<string> HeadlineFeed
{
get { return headlineFeed; }
}
public NewsHeadlineFeed(string name)
{
feedName = name;
//*****************************************************************************************//
//*** Using the Generate operator to generate a continous stream of headline that occur ***//
//*** randomly within 5 seconds. ***//
//*****************************************************************************************//
headlineFeed = Observable.Generate(RandNewsEvent(),
evt => true,
evt => RandNewsEvent(),
evt => { Thread.Sleep(rand.Next(5000)); return evt; },
Scheduler.ThreadPool);
}
//****************************************************************//
//*** Some very simple formatting of the headline event string ***//
//****************************************************************//
private string RandNewsEvent()
{
return "Feedname : " + feedName + "\nHeadline : " + newsEvents[rand.Next(newsEvents.Length)] +
newsLocations[rand.Next(newsLocations.Length)];
}
}
}
다음 출력은 예제 코드와 함께 생성되었습니다.
Subscribing to news headline feeds.
Press ENTER to exit.
Subscription : All news subscription
Feedname : Headline News Feed #2
Headline : A robbery occurred somewhere in Iraq.
Subscription : All news subscription
Feedname : Headline News Feed #2
Headline : An earthquake occurred in Dallas, Texas.
Subscription : All news subscription
Feedname : Headline News Feed #1
Headline : We have a lottery winner in your area.
********************************** [ 지역 뉴스 헤드 라인 보고서]********************************** 피드 이름 : 헤드 라인 뉴스 피드 #1 헤드 라인 : 우리는 당신의 지역에서 복권 당첨자를 가지고있다.
Subscription : All news subscription
Feedname : Headline News Feed #2
Headline : Severe automobile accident Redmond, Washington
Subscription : All news subscription
Feedname : Headline News Feed #2
Headline : We have a lottery winner in Dallas, Texas.
Subscription : All news subscription
Feedname : Headline News Feed #2
Headline : An earthquake occurred in Dallas, Texas.
Subscription : All news subscription
Feedname : Headline News Feed #1
Headline : We have a lottery winner somewhere in Iraq.
Subscription : All news subscription
Feedname : Headline News Feed #2
Headline : Severe automobile accident somewhere in Iraq.
Subscription : All news subscription
Feedname : Headline News Feed #2
Headline : An earthquake occurred in your area.
********************************** [ 지역 뉴스 헤드 라인 보고서]********************************** 피드 이름 : 헤드 라인 뉴스 피드 #2 헤드 라인 : 지진이 귀하의 지역에서 발생했습니다.
스레드 안전성
이 형식의 모든 공용 정적(Visual Basic에서 공유) 멤버는 스레드로부터 안전합니다. 모든 인스턴스 멤버는 스레드로부터 안전하게 보호되지 않습니다.
참고 항목
참조
system.Reactive.Subjects 네임스페이스