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

ReactiveUI.Primitives.Advanced

Namespace with 89 public types

Classes

 AggregateWitness`3 Folds source values through an immutable accumulator and emits the result when the source completes.
 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 Sink that forwards source values and emits one trailing value before completing.
 BufferWitness`1 Sink that batches source values into windows of a fixed size, opening a new window every skip values.
 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.
 CurrentValueWitness`1 Delivers a value that is read again each time it changes to one observer, one delivery at a time and without a lock.
 DefaultIfEmptyWitness`1 Sink that forwards source values, emitting a single fallback value when the source completes empty.
 DisposedMarker No-op disposable used as the sentinel value for a released subscription slot.
 DisposedWitness`1 Observer that throws from every notification, standing in for a disposed subscription.
 DistinctByWitness`2 Sink that forwards the first value seen for each key the selector produces.
 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.
 GroupBySignal`3 Cold signal that splits a source into keyed groups.
 GroupByUntilSignal`4 Cold signal that splits a source into keyed groups that each end when a duration signal fires.
 GroupByUntilWitness`4 Sink that routes each source value to the group of its key and ends a group when its duration signal emits or completes.
 GroupByWitness`3 Sink that routes each source value to the group of its key, opening a group the first time a key appears.
 IgnoreValuesWitness`1 Sink that drops values and forwards only terminal notifications.
 ImmediateReturnSignal`1 Signal that emits one value and completes synchronously inside Subscribe.
 ImmediateThrowSignal`1 Signal that delivers a terminal error synchronously inside Subscribe.
 ImmutableEmptySignal`1 Signal that completes synchronously inside Subscribe without emitting a value.
 ImmutableNeverSignal`1 Signal that never emits a value and never terminates.
 ImmutableReturnFalseSignal Signal that emits and completes synchronously inside Subscribe.
 ImmutableReturnInt32Signal Signal that emits a single and completes synchronously inside Subscribe.
 ImmutableReturnTrueSignal Signal that emits and completes synchronously inside Subscribe.
 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 Signal that emits several integer ranges back to back, synchronously inside Subscribe.
 RangeSignal Signal that emits a contiguous run of integers, synchronously inside Subscribe.
 RangeZipSignal`1 Signal that pairs two integer ranges position by position, synchronously inside Subscribe.
 ReduceWitness`2 Sink that emits the final accumulation once the source completes.
 RepeatSignal`1 Signal that emits one value a fixed number of times, synchronously inside Subscribe.
 SerializedWitness`1 Wraps an observer so notifications from any number of threads reach it one at a time, without holding a lock while it runs.
 SerializeWitness`1 Forwards source notifications to one observer one at a time without holding a lock while it runs, and owns the upstream subscription.
 SharedSubscription Keeps one underlying subscription alive until its own handle and every lease taken from it have been disposed.
 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.
 SliceBoundarySignal`2 Cold signal that splits a source into windows delimited by a boundary signal.
 SliceBoundaryWitness`2 Sink that hands out a window signal and starts the next window each time a boundary signal emits.
 SliceClosingSignal`2 Cold signal that splits a source into consecutive windows, each ended by its own closing signal.
 SliceClosingWitness`2 Sink that hands out a window signal that ends when its own closing signal emits or completes.
 SliceCountSignal`1 Cold signal that splits a source into windows of a fixed number of values.
 SliceCountWitness`1 Sink that hands out a window signal holding a fixed number of values, opening a new window every skip values.
 SliceOpeningSignal`3 Cold signal that opens a window each time an opening signal emits and ends it with a closing signal.
 SliceOpeningWitness`3 Sink that hands out a window signal each time an opening signal emits, and ends each window when its closing signal fires.
 SliceRouter`2 Delivers the notifications of a sliced sequence to its outer observer and its windows in the order they were posted, without holding the caller's lock while any observer runs.
 SliceWindow`1 One window of a sliced sequence: values published to it reach every current subscriber.
 StatefulWitness`2 Observer that forwards notifications to stateful delegates.
 SynchronizeWitness`1 Serializes concurrent observer notifications so values precede a single terminal notification.
 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 Signal that walks a state machine synchronously, emitting one projected value per iteration.
 UniqueByWitness`2 Sink that suppresses adjacent values whose projected key matches the previous one.
 UniqueWitness`1 Sink that suppresses adjacent duplicate values.
 UseSignal`2 Creates a resource per subscription and disposes it when the sequence terminates or the subscription is disposed.

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 .
 CurrentValueDelivery`1 Serialized, non-blocking delivery of a value that is read again each time it changes, held as a mutable field by the subscription that observes it.
 DeliveryGateState The state of one , held as a mutable field by the type whose deliveries it serializes.
 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 .
 SerializedBroadcast`1 The witnesses a posted a notification to, delivered by .
 SerializedBroadcaster`1 The subscribers a subject fans its notifications out to, each delivering in the order the subject posted to it.
 SerializedDelivery`1 Serialized, non-blocking delivery to one downstream observer, held as a mutable field by the operator or subject that delivers through it.

Static Classes

 DeliveryGate Serializes deliveries to a downstream observer without holding a lock while the observer runs, so an observer that blocks on another producer's thread cannot deadlock it.
 SinkDelivery Forwards a non-terminal value to a downstream observer and tears the sink down when that observer throws.
 SinkSubscription Assigns and disposes a single upstream subscription held in a caller-owned field.
 SinkTerminal Forwards a terminal notification and disposes the sink, optionally preventing repeated terminal delivery.
 SubscriptionSlots Holds one subscription per slot and disposes assignments made after a slot is released.
 Witness Factory methods for allocation-conscious observers in the ReactiveUI.Primitives vocabulary.
 WitnessTeardown Shared run-once teardown for witness sinks.

Interfaces

 IAggregator`3 Accumulates values by returning a replacement state from Add and exposing the aggregate through Result.
 ICurrentValueReader`1 Reads the current value for a .
 IInlineSignal`1 A signal that accepts callbacks directly, so a subscriber needs no intermediate observer.
 IRequireCurrentThread`1 A signal that reports whether it has to be subscribed to from the calling thread.