ReactiveUI.Primitives.Advanced
Namespace with 63 public types
Classes
AggregateWitness`3
Single-source sink that folds every observed value through an immutable value-type
and emits the aggregate result once the source completes. The accumulator is advanced functionally through a
constrained (devirtualized, allocation-free) call, so each concrete aggregate operator shares this one
implementation without a base class or per-value indirection.
AllPredicateWitness`1
Observer for detecting whether all values match a predicate.
AnyPredicateWitness`1
Observer for detecting whether any value matches a predicate.
AnyWitness`1
Observer for detecting whether any value is present.
AppendDelegateWitness`1
Delegate-backed observer for fused prepend/append inline subscriptions.
AppendWitness`1
Observer for append.
BufferWitness`1
Sink that batches source values into fixed-size windows.
CallbackWitness`1
Observer that forwards notifications to delegates.
CollectArrayWitness`1
Sink that buffers values and emits them as an array on completion.
CollectListWitness`1
Sink that buffers values and emits them as a list on completion.
ContainsWitness`1
Observer for detecting whether a value is contained in a sequence.
CopyOnWriteList`1
Immutable array-backed list optimized for copy-on-write observer storage.
DefaultIfEmptyWitness`1
Observer for default-if-empty.
DisposedMarker
Disposable marker for disposed sinks.
DisposedWitness`1
Observer that rejects every notification because the subscription has already been disposed.
DistinctByWitness`2
Observer for distinct-by.
DistinctWitness`1
EmptyWitness`1
Delegate-backed observer that defaults missing handlers to no-op behavior.
FoldWitness`2
Sink that emits a running accumulation for every source value.
ForwardingWitness`1
Observer that forwards notifications to a standard observer.
FromEnumerableSignal`1
Represents a finite signal backed by an enumerable sequence.
IgnoreValuesWitness`1
Sink that drops values and forwards only terminal notifications.
ImmediateReturnSignal`1
Represents the ImmediateReturnSignal class.
ImmediateThrowSignal`1
Represents the immediate Throw signal fast path.
ImmutableEmptySignal`1
Represents the ImmutableEmptySignal class.
ImmutableNeverSignal`1
Represents the ImmutableNeverSignal class.
ImmutableReturnFalseSignal
Represents the ImmutableReturnFalseSignal class.
ImmutableReturnInt32Signal
Represents the ImmutableReturnInt32Signal class.
ImmutableReturnTrueSignal
Represents the ImmutableReturnTrueSignal class.
KeepNotNullWitness`1
Sink that forwards only non-null values.
KeepTypeWitness`1
Sink that forwards only values assignable to .
ListWitness`1
Observer that forwards notifications to an immutable observer list.
RangeConcatSignal
Concatenates synchronous integer ranges without outer observable/coordinator overhead.
RangeSignal
Represents the RangeSignal class.
RangeZipSignal`1
Zips two synchronous integer ranges without coordinator queues.
ReduceWitness`2
Sink that emits the final accumulation once the source completes.
RepeatSignal`1
Represents the RepeatSignal class.
SkipWhileWitness`1
Sink that drops leading values while the predicate holds, then mirrors the source.
SkipWitness`1
Sink that drops the first count values, then forwards the rest.
StatefulWitness`2
Observer that forwards notifications to stateful delegates.
SynchronizeWitness`1
Observer that serializes notifications behind a gate so downstream operators always observe the
single-threaded OnNext* then OnError|OnCompleted grammar they depend on, even when the
upstream source delivers concurrently. Stateful sinks (counting, distinct, buffering) rely on that
grammar; placing one of these ahead of them is the supported way to consume a non-conformant source.
TakeWhileWitness`1
Sink that forwards values while the predicate holds, then completes and unsubscribes.
TakeWitness`1
Observer used by Take to dispose the upstream subscription as soon as the requested count is reached.
TapWitness`1
Sink that runs side-effects before forwarding each notification.
ThrowWitness`1
Observer that ignores values and completion and rethrows errors.
UnfoldSignal`2
Finite state expansion signal.
UniqueByWitness`2
Sink that suppresses adjacent values whose projected key matches the previous one.
UniqueWitness`1
Sink that suppresses adjacent duplicate values.
UseSignal`2
Resource-scoped signal.
Structures
CountAggregator`1
Immutable accumulator that counts every observed value as an .
CountPredicateAggregator`1
Immutable accumulator that counts the values matching a predicate as an .
DistinctByCountAggregator`2
Immutable accumulator that counts distinct selected keys as an .
DistinctByLongCountAggregator`2
Immutable accumulator that counts distinct selected keys as a .
LongCountAggregator`1
Immutable accumulator that counts every observed value as a .
LongCountPredicateAggregator`1
Immutable accumulator that counts the values matching a predicate as a .
Static Classes
SinkSubscription
Shared single-upstream-subscription management for sink observers. Operating on a caller-owned
field through a parameter lets each sink implement
directly — with no shared base class, and therefore no virtual-dispatch
overhead on the hot notification path — while still sharing the assign-once / dispose-once teardown.
SinkTerminal
Shared terminal-forwarding helpers for single-source sink observers. Each sink computes a
single result and forwards it downstream exactly once, disposing itself afterwards. Centralizing the
forward-then-dispose using scope — and the done latch that guards it — keeps the
individual sinks to their distinguishing accumulation logic and removes the otherwise-identical terminal boilerplate.
SubscriptionSlots
Helpers for the interlocked single-assignment subscription slots shared by the catch-style sinks
(RecoverSignal, ResumeSignal): a slot holds at most one live
subscription and, once the sink is disposed, swaps to a sentinel so a late assignment is disposed instead of
stored.
Witness
Factory methods for allocation-conscious observers in the ReactiveUI.Primitives vocabulary.
WitnessTeardown
Shared run-once teardown for witness sinks.
Interfaces
IAggregator`3
An immutable value-type accumulator for a single-source aggregate sink: each folds a value
into the running state and returns the next accumulator, while yields the terminal value.
Implemented as a so
can advance it through a constrained, devirtualized, allocation-free call rather than an interface or delegate dispatch.
IInlineSignal`1
Represents the IInlineSignal interface.
IRequireCurrentThread`1
Marks a sequencer that must run on the current thread.