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

ReactiveUI.Primitives.Advanced

Namespace with 65 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.
 AsyncEnumerableSignal`1 Async-enumerable observable adapter.
 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 Sink that forwards the first occurrence of each value.
 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.
 IAsyncEnumerableBackedSignal`1 Observable adapter backed by an async enumerable.
 IInlineSignal`1 Represents the IInlineSignal interface.
 IRequireCurrentThread`1 Marks a sequencer that must run on the current thread.