<PackageReference Include="ReactiveUI.Primitives.Core" Version="7.4.0" />

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.