ReactiveUI.Primitives.Advanced namespace¶

Part of the ReactiveUI.Primitives package.

Type	Kind	Summary
AfterSignal	class	Emits timer ticks for the `After` factory overloads.
AfterSubscription	class	Subscription handle for an [AfterSignal](# timer.
AsyncCreateSignal	class	Creates an observable from an asynchronous subscription function.
AsyncDeferSignal	class	Creates a signal whose source is produced asynchronously for each subscription.
AsyncSubscriptionLifetime	class	Owns cancellation and the eventual inner disposable for asynchronous signal subscriptions.
AutoConnectSignal	class	Tracks auto-connect subscription state.
AutoShareSignal	class	Tracks reference-counted connection state.
AutoShareSubscription	class	Reference-counted subscription handle.
BlendSignal	class	Merges inner observable sources from an outer observable concurrently.
BlendWitness	class	Mediates concurrent merging for [BlendSignal](# and [EnumerableBlendSignal](#
BufferEachWitness	class	Witness that emits each source value as a single-item buffer.
BufferSignal	class	Concrete signal for time-windowed buffer operators.
CastSignal	class	Observable sink that casts object values to the requested result type.
CastWitness	class	Observer wrapper for object casts.
ChainSignal	class	Concatenates observable sources in source order.
ChainWitness	class	Mediates sequential concatenation for [ChainSignal](#
CollectSignal	class	Collects source values into time-windowed batches.
CollectWitness	class	Observer that collects source values into batches.
CreateSink	class	The observer handed to create-style subscription factories: forwards until terminated, owns the factory's cancel resource, and optionally releases it when a downstream `OnNext` throws (the safe-create contract). The shared sink behind `CreateSignal` and `CreateSafeSignal`, usable by any implementation that hands an observer to a caller-supplied subscribe delegate.
CreateWitness	class	Observer wrapper used by create-style signals.
DispatchSequencerState	struct	Coalescing engine shared by UI-thread sequencers: it batches dispatcher posts and shares delayed scheduling. A sealed sequencer holds one inline and injects its platform `post` (and optionally `scheduleDelayed`) delegates plus the cached drain callback; immediate work is queued and drained one batch per post.
EmitIfQuietSignal	class	Emits only the latest value after a quiet period.
EmitIfQuietWitness	class	Observer that emits only the latest value after a quiet period.
EnumerableBlendSignal	class	Merges enumerable observable sources concurrently.
ExpireCoordinator	class	Coordinates timeout delivery with one active timer.
ExpireSignal	class	Timeout signal with a direct subscription path.
ForkJoinSignal	class	Emits one result from the final values of two completed sources.
ForkJoinWitness	class	Mediates two-source fork-join completion for [ForkJoinSignal](#
FromAsyncExternalCancellationSignal	class	Cold task-backed signal that forwards an external cancellation token as an observer error.
FromAsyncSignal	class	Cold task-backed signal that gives each subscription its own cancellable token.
FromAsyncSubscription	class	Subscription that invokes a cold task factory and forwards its terminal result.
FromEventPatternSignal	class	Converts an event add/remove pair into event-pattern notifications.
GuardedWitness	class	Forwarding observer that releases its upstream cancel resource when the sequence terminates or a downstream `OnNext` throws. The shared guard behind the scheduled factory signals (Empty, Return, Throw, Defer), usable by any signal implementation that needs terminate-and-release semantics around a downstream observer.
IgnoreValuesSignal	class	Signal that ignores source values and forwards terminal notifications.
ImmutableReturnRxVoidSignal	class	An allocation-free observable that emits a single value and then completes; the concrete singleton backing for the RxVoid emit path.
IsEmptySignal	class	Signal that emits whether the source completed without values.
IsEmptyWitness	class	Observer wrapper for detecting whether a source completes without values.
LeadSignal	class	Signal that emits one leading value before subscribing to the source.
MapIndexedSignal	class	Indexed map signal.
MapIndexedWitness	class	Applies an indexed selector to source values.
MaxConcurrentBlendCoordinator	class	Coordinates bounded-concurrency merging of enumerable observable sources.
MaxConcurrentEnumerableBlendSignal	class	Enumerable `Blend` signal with bounded concurrency.
MergeCoordinator	class	Coordinates concurrent merge subscriptions.
MergeSignal	class	Concrete signal for Rx-named merge overloads.
PairSignal	class	Combines paired values from two sources by index.
PairWitness	class	Mediates pair-by-index combination for [PairSignal](#
PublishSelectorSignal	class	Connects a published source around a selector subscription.
RaceSignal	class	Mirrors the first source that produces any notification.
RaceWitness	class	Mediates candidate subscriptions for [RaceSignal](#
RangeCombineLatestSignal	class	Combines two synchronous integer ranges using System.Reactive `CombineLatest` semantics.
RangeForkJoinSignal	class	Fork-joins two synchronous integer ranges by projecting their final values.
RangeSyncLatestSignal	class	Combines two synchronous integer ranges using latest-value semantics.
RangeWithLatestSignal	class	Combines each left range value with the final value from the right range.
ReturnSignal	class	An observable that emits a single value then completes on the supplied scheduler; the concrete backing for the scheduled emit path.
ScheduledEnumerableSignal	class	Scheduled enumerable-backed signal used by observable conversion overloads.
SelectManyCoordinator	class	Coordinates concurrent observable `SelectMany` subscriptions.
SelectManyEnumerableSignal	class	Signal that projects each value to an enumerable sequence and emits the enumerable values.
SelectManyEnumerableWitness	class	Observer for enumerable `SelectMany`.
SelectManyResultCoordinator	class	Coordinates concurrent observable `SelectMany` subscriptions with a result selector.
SelectManyResultSignal	class	Concrete signal for concurrent observable `SelectMany` with a result selector.
SelectManySignal	class	Concrete signal for concurrent observable `SelectMany`.
SequenceSignal	class	Emits a scheduled integer sequence.
SignalSubscription	class	Shared subscription routing for signal implementations.
SparkSignal	class	Signal that materializes source notifications into [Spark](# values.
SparkWitness	class	Sink that materializes notifications into [Spark](# values.
StartSignal	class	Runs an action on a scheduler and emits an [RxVoid](# value when it completes.
StartSignal	class	Runs a function on a scheduler and emits its result.
SubscribeSafeWitness	class	Observer that turns downstream `OnNext` exceptions into a terminal error and upstream disposal.
SwitchSignal	class	Mirrors only the latest inner observable from an outer source.
SwitchWitness	class	Mediates latest-inner subscription switching for [SwitchSignal](#
SyncLatestSignal	class	Combines the latest values from two sources after both have produced a value.
SyncLatestWitness	class	Mediates latest-value combination for [SyncLatestSignal](#
SynchronizeGateSignal	class	Signal that serializes source notifications behind a shared gate.
SynchronizeObjectSignal	class	Object-gated `Synchronize` compatibility signal.
SynchronizeObjectWitness	class	Observer that serializes notifications using an object gate.
SynchronizeSignal	class	Signal that serializes source notifications behind a private per-subscription gate.
TapSignal	class	Pass-through signal that invokes side effects for forwarded notifications.
TaskAnyWitness	class	Task-producing terminal sink that completes with whether a source produced a matching value.
TaskChainCoordinator	class	Coordinates sequential task-source concatenation without a map adapter.
TaskChainSignal	class	Task-source `Chain`/`Concat` signal.
TaskCountWitness	class	Task-producing terminal sink that completes with the number of matching source values.
TaskInstanceSignal	class	Signal that emits the result of an existing task instance.
TaskInstanceSubscription	class	Subscription handle for an existing task-instance signal.
TimeIntervalSignal	class	Signal that measures elapsed time between source values.
TimeIntervalWitness	class	Sink that annotates each value with the elapsed interval since the previous value.
UnsparkSignal	class	Signal that dematerializes [Spark](# values into ordinary notifications.
UnsparkWitness	class	Sink that dematerializes [Spark](# values into notifications.