ReactiveUI.Primitives.Extensions.Operators
Namespace with 39 public types
Classes
BinaryMinMaxObservable`1
Fast path for the common two-source min/max case.
BooleanReduceObservable
Combines the latest boolean values from multiple sources and emits true iff every latest
value equals . Backs both AllTrue (target=true) and AllFalse
(target=false) without the array allocations a generic CombineLatest(...).Select(xs => xs.All(...))
pipeline would incur.
BufferUntilObservable
Operator that buffers characters until a start and end delimiter are found.
CatchAndReturnWithFactoryObservable`2
Catches the configured exception type, emits a fallback built from the exception, and completes.
Other exception types propagate downstream.
CatchIgnoreEmptyObservable`1
Forwards source values; on any source error, swallows it and completes silently.
CatchIgnoreObservable`2
Operator that catches exceptions of a specific type and completes.
CatchReturnObservable`1
Forwards source values; on any source error, emits the stored fallback then completes.
DoOnDisposeObservable`1
Executes an action when the subscription is disposed.
DoOnSubscribeObservable`1
Executes an action at subscription time.
DropIfBusyObservable`1
Operator that drops source elements while an asynchronous action is in progress.
Replaces the closure-based implementation in ReactiveExtensions.DropIfBusy.
FilterRegexObservable
Operator that filters string elements using a . Replaces the closure-based implementation in ReactiveExtensions.Filter.
FirstMatchFromCandidatesObservable`3
Walks a list of candidate keys sequentially, projects each into a one-shot
, transforms the raw value into
, and emits the first transformed value that
satisfies a predicate. Errors from individual projections are swallowed (the
candidate is skipped and the next one is tried). If no candidate matches,
completes with a single emission of .
LatestOrDefaultObservable`1
Emits the latest value from the source sequence or a default value if no value has been emitted.
LogErrorsObservable`1
Forwards source values verbatim, invokes the logger on error, then propagates the error downstream.
MinMaxObservable`1
Combines the latest values from multiple sources and emits either the maximum or minimum on each
tick. Backs both the Max (=true) and Min
(=false) operators without the array allocations a generic
CombineLatest(...).Select(xs => xs.Max()) pipeline would incur.
NotObservable
Boolean negation operator. Replaces the source.Select(b => !b)
pattern with a dedicated forwarding observer, avoiding the per-subscription
closure allocation that the projection lambda would otherwise capture.
PairwiseObservable`1
Emits (previous, current) pairs from a sequence.
PartitionObservable`1
Partitions a sequence into two observables based on a predicate.
PropertyChangedObservable`2
Fused replacement for
Observable.FromEventPattern(...).Where(name match).Select(getter).StartWith(getter).
Subscribes directly to , holds the
compiled getter once at construction (the original chain compiled it twice per
subscription), and emits the current value on subscribe followed by the getter
result for each matching property change — all through a single sink.
ReplayLastOnSubscribeObservable`1
Emits a stored initial value to every new subscriber, then forwards subsequent emissions from the
shared source. Each subscriber gets its own independent subscription to the source; the per-subscriber
replay is the fixed initialValue supplied at construction (matching the legacy BehaviorSubject
semantics — late subscribers do NOT see the latest value emitted to earlier subscribers).
RetryForeverObservable`1
Re-subscribes to the source indefinitely on error. Forwards values verbatim and completes when
the source completes. Per-subscription state is held in a single sink; resubscription swaps the
inner disposable rather than allocating a new wrapper chain.
SampleLatestObservable`1
Samples the latest value from the source observable whenever a trigger observable emits.
SelectAsyncConcurrentObservable`2
Projects each element to an asynchronous operation with limited concurrency.
SelectAsyncSequentialObservable`2
Projects each element to an asynchronous operation, preserving order and handling sequential execution.
SelectConstantObservable`2
Projection operator that ignores every source element and emits a stored constant
instead. Replaces the common .Select(_ => value) pattern, avoiding the
per-subscription closure allocation that the lambda _ => value would
capture.
SelectLatestAsyncObservable`2
Projects each element to an asynchronous operation, but only the result of the latest operation is emitted.
SelectManyThenObservable`3
Fused .SelectMany(first).SelectMany(second) operator that chains two one-shot
async projections in a single operator allocation. The source emits a value, it's
projected through producing an intermediate observable, whose
single emission is then projected through producing the
final result. Errors at any stage propagate to the downstream observer.
ShuffleObservable`1
Operator that randomly shuffles arrays emitted by the source.
SkipWhileNullObservable`1
Filtering operator that drops leading values, then forwards every value
(including subsequent s) once the latch has opened. Replaces the previous
source.SkipWhile(x => x == null) composition that delegated to System.Reactive's
SkipWhile, eliminating the per-subscription closure allocation and the extra observer
layer the chain introduced.
SubscribeAsyncObservable`1
Subscribes to an observable sequence and executes an asynchronous handler for each element.
SwitchIfEmptyObservable`1
Provides a fallback observable if the source sequence completes without emitting any elements.
SynchronizeAsyncObservable`1
Wraps elements in a synchronization context that waits for a disposal signal before proceeding to the next element.
TakeUntilInclusiveObservable`1
Takes elements from the source sequence until a predicate returns true for an element.
The element that satisfies the predicate is included in the sequence.
TrySelectObservable`2
Fused .Select(selector).Where(x => x is not null).Select(x => x!) operator
that applies a transform and emits only non-null results. Replaces the 3-operator
null-filtering chain with a single operator + observer allocation.
WaitUntilObservable`1
Fused Where(predicate).Take(1). Subscribes a single observer to the source,
emits the first value satisfying followed by
, then disposes the source subscription —
avoiding the two intermediate observer wrappers that the equivalent Rx chain would
allocate per subscription.
WhereFalseObservable
Filtering operator that forwards only false values from a boolean source.
Replaces the source.Where(b => !b) pattern with a dedicated forwarding
observer, avoiding the per-subscription closure allocation that the predicate
lambda would otherwise capture.
WhereIsNotNullObservable`1
Filtering operator that forwards only the non-null values of the source
sequence. Replaces the source.Where(x => x is not null) pattern,
avoiding the per-subscription closure allocation that the predicate lambda
would otherwise capture.
WhereSelectObservable`2
Fused Where(predicate).Select(selector) operator. Replaces the two-operator
Rx chain with a single observable + observer pair, saving the intermediate
Select operator allocation (and its ) per
subscription on hot paths.
WhereTrueObservable
Filtering operator that forwards only true values from a boolean source.
Replaces the source.Where(b => b) pattern with a dedicated forwarding
observer, avoiding the per-subscription closure allocation that the predicate
lambda would otherwise capture.