feat: upstream parity sync — DynamicData 9.4.x / ReactiveUI 23.x (Nov 2025 → Mar 2026)

[michaelstonis]

Overview

Full upstream parity sync covering changes in DynamicData (9.0.x → 9.4.x) and ReactiveUI (22.2.x → 23.1.x) from the project's founding in November 2025 through March 2026. All 🔴 high-priority and 🟡 medium-priority items from docs/UpstreamChangesReview.md are resolved.

---

Bug Fixes

Issue	Fix
List Filter.HandleRefresh emitted Replace instead of Refresh	ChangeAwareList.Refresh(int) added; HandleRefresh now calls it
ToObservableChangeSet race condition (timer thread vs. subscriber)	Added gate lock; OnNext called outside lock
SourceList.Refresh(int) missing from interface + implementation	Added to ISourceList and both public/internal editors
RxCommand concurrent execution cleared IsExecuting too early	Interlocked counter (_executingCount) — only clears when last execution completes
List AutoRefresh per-item subscription leak	Per-item subscriptions now tracked and disposed on operator teardown

New Operators

Operator	Surfaces	Notes
TransformOnObservable<TObject, TKey, TDestination>	Cache	Per-item observable transform; first emission → Add, subsequent → Update, source Remove → Remove (DD #941)
AsyncDisposeMany<TObject, TKey> / AsyncDisposeMany<T>	Cache + List	Fire-and-forget IAsyncDisposable disposal, mirroring DisposeMany (DD #1011)
Filter<TObject, TKey, TState> / Filter<T, TState>	Cache + List	Predicate with external state stream — avoids delegate allocation on state change (DD #1008)

Behavior Improvements

• SortAndBind Move optimization — Applied changeset Moved reason maps to a single CollectionChanged(Move) notification instead of RemoveAt + Insert (DD #935)
• SortAndBindOptions.ResetOnFirstTimeLoad — New option (default true) that always performs a full reset on the very first changeset, fixing the ignored-on-initial-load regression

Documentation

• docs/LibraryParity.md (new) — Durable upstream tracking document with version table, component mapping, sync workflow, and sync history
• README.md — Added "Library Parity" section with status table
• docs/UpstreamChangesReview.md — All items annotated; 🔴 0 / 🟡 2 remaining (low-priority platform features)
• docs/MigrationMatrix.md — Updated: 3 new operators, 311 tests, last-updated date

Tests

• R3.DynamicData: 311 passing ✅ (+26 new tests for new operators and fixed behaviors)
• R3Ext: 459 passing ✅
• Net-new test files: AsyncDisposeManyTests (Cache + List), TransformOnObservableTests, FilterWithStateTests (Cache + List), additions to FilterOperatorTests

Audited — Not Affected

The following upstream issues were reviewed and confirmed to not require changes in this codebase:

• DD #1013/#1048 — Cache Filter bogus overload (no such overload exists here)
• DD #968 — Switch inner-source error propagation (correct)
• DD #938 — GroupOn OnCompleted propagation (correct)
• DD #940 — MergeChangeSets value type equality (uses EqualityComparer<T>.Default)
• DD #945 — Join initialization race (RecomputeAndEmit guards empty overlap)
• DD #1012 — Join foreign-key re-grouping (Update replaces dict entry + RecomputeAndEmit)
• DD #1064–1069 — OnItemAdded/Removed/Refreshed bulk operations (AddRange/RemoveRange/Clear handled)
• DD #1059 — WhenValueChanged null fallback (explicit selectors used throughout)

Remaining Low-Priority Items

Intentionally deferred to a future sprint:

• ReactiveUI platform features: Blazor ReactiveOwningComponentBase, MAUI platform schedulers, RxAppBuilder
• Closure elimination carry-forward: 32+ operators awaiting struct-state refactor
• Missing niche operators: DynamicCombiner, InvokeEvaluate/IEvaluateAware

---

Tracked via docs/LibraryParity.md and docs/UpstreamChangesReview.md.

[Copilot]

Pull request overview

This PR performs an upstream parity sync for R3.DynamicData (to DynamicData 9.4.31) and reviews/ports relevant ReactiveUI patterns (to 23.1.8), adding new operators, fixing correctness and race issues, and updating parity tracking documentation.

Changes:

• Fixes and parity updates across existing operators (e.g., ToObservableChangeSet thread-safety work, list Filter refresh semantics, SortAndBind move/reset behavior, RxCommand concurrent execution state).
• Adds new DynamicData-parity operators: TransformOnObservable (Cache), AsyncDisposeMany (Cache + List), and Filter overloads taking a predicate + state stream (Cache + List).
• Adds/updates parity tracking docs (LibraryParity, UpstreamChangesReview, MigrationMatrix) and expands test coverage for new behaviors/operators.

Reviewed changes

Copilot reviewed 36 out of 36 changed files in this pull request and generated 7 comments.

Show a summary per file

File	Description
README.md	Adds a “Library Parity” section linking to the new tracking docs.
R3Ext/Commands/RxCommand.cs	Fixes IsExecuting concurrency race using an Interlocked counter.
R3.DynamicData/List/SourceList.cs	Adds Refresh(int index) support and emits refresh changes.
R3.DynamicData/List/ObservableListEx.MergeChangeSets.cs	Adds audit notes re: value-type equality semantics.
R3.DynamicData/List/ObservableListEx.cs	Adds list Filter<T,TState> and AsyncDisposeMany APIs plus audit notes.
R3.DynamicData/List/ISourceList.cs	Extends interface with Refresh(int index).
R3.DynamicData/List/Internal/ToObservableChangeSet.cs	Adds gating/locking changes and moves OnNext out of lock.
R3.DynamicData/List/Internal/Switch.cs	Adds audit notes about error propagation behavior.
R3.DynamicData/List/Internal/StatefulFilter.cs	New list “filter with external state stream” operator implementation.
R3.DynamicData/List/Internal/Filter.cs	Emits Refresh instead of “refresh as replace” downstream.
R3.DynamicData/List/Internal/AutoRefresh.cs	Fixes per-item subscription disposal by adding explicit teardown.
R3.DynamicData/List/Internal/AsyncDisposeMany.cs	New list async-dispose operator (fire-and-forget).
R3.DynamicData/List/ChangeAwareList.cs	Adds Refresh(int index) to emit refresh changes.
R3.DynamicData/Cache/SortAndBindOptions.cs	Adds ResetOnFirstTimeLoad option (default true).
R3.DynamicData/Cache/ObservableCacheEx.WhenValueChanged.cs	Adds audit notes about null-fallback behavior.
R3.DynamicData/Cache/ObservableCacheEx.TransformOnObservable.cs	Public extension method for the new cache operator.
R3.DynamicData/Cache/ObservableCacheEx.SortAndBind.cs	Uses Move and honors ResetOnFirstTimeLoad on first emission.
R3.DynamicData/Cache/ObservableCacheEx.Joins.cs	Adds audit notes about join initialization / regrouping behavior.
R3.DynamicData/Cache/ObservableCacheEx.Grouping.cs	Adds audit notes about OnCompleted propagation.
R3.DynamicData/Cache/ObservableCacheEx.Filter.cs	Adds cache Filter<TObject,TKey,TState> overload.
R3.DynamicData/Cache/ObservableCacheEx.cs	Adds cache AsyncDisposeMany<TObject,TKey> extension.
R3.DynamicData/Cache/ObservableCacheEx.Batch.cs	Adds audit notes about timer disposal.
R3.DynamicData/Cache/Internal/TransformOnObservable.cs	New internal implementation for per-item observable transform.
R3.DynamicData/Cache/Internal/ExpireAfter.cs	Adds audit notes about timer cleanup and lifetimes.
R3.DynamicData/Cache/Internal/AutoRefresh.cs	Adds audit notes about subscription ownership/cleanup.
R3.DynamicData/Cache/Internal/AsyncDisposeMany.cs	New internal cache async-dispose operator implementation.
R3.DynamicData/Binding/BindingOptions.cs	Extends IObservableCollection<T> with Move(oldIndex,newIndex) for binding optimizations.
R3.DynamicData.Tests/List/FilterWithStateTests.cs	New tests for list filter-with-state behavior.
R3.DynamicData.Tests/List/FilterOperatorTests.cs	Adds tests verifying refresh semantics in list filtering.
R3.DynamicData.Tests/List/AsyncDisposeManyTests.cs	New list async-dispose operator tests.
R3.DynamicData.Tests/Cache/TransformOnObservableTests.cs	New tests for cache TransformOnObservable.
R3.DynamicData.Tests/Cache/FilterWithStateTests.cs	New tests for cache filter-with-state overload.
R3.DynamicData.Tests/Cache/AsyncDisposeManyTests.cs	New cache async-dispose operator tests.
docs/UpstreamChangesReview.md	Adds/records the upstream audit checklist and outcomes.
docs/MigrationMatrix.md	Updates matrix for new operators and updated test totals/status.
docs/LibraryParity.md	Adds durable parity tracking doc, workflow, and sync history.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

disp (the subscription to source) is created but never disposed when the downstream subscription is disposed. The returned Disposable.Create(current, ...) only disposes the tracked items, so the operator continues to receive source changes after unsubscription, leaking the subscription and potentially calling observers after disposal. Combine disp with the cleanup disposable so disposing the operator tears down the upstream subscription as well.

[michaelstonis]

@copilot apply changes based on this feedback

[Copilot]

This was already fixed in commit 916808d — List/AsyncDisposeMany.cs now returns Disposable.Combine(disp, Disposable.Create(...)) so the upstream subscription is torn down on operator disposal, mirroring the Cache variant.

[Copilot]

The teardown disposable returned here does not include the upstream disp subscription created above, so disposing the operator won't unsubscribe from the source stream. Return a combined disposable (e.g., include disp plus the current-item async disposal cleanup) so operator disposal is complete and deterministic.

[michaelstonis]

@copilot apply changes based on this feedback

[Copilot]

Fixed in commit 916808d — the returned disposable is now Disposable.Combine(disp, Disposable.Create(current, ...)), so both the upstream subscription and the tracked-items cleanup are included in teardown.

[Copilot]

EnforceLimit() can remove items that were just added in this batch, but pendingTimers was populated before the limit enforcement and is processed after the lock. That can schedule timers for items that are no longer in list, leaving entries in expirations that will never be cleaned up until operator disposal (and can keep items alive). Filter pendingTimers after EnforceLimit() (e.g., only schedule if the item is still present / not removed) or remove pending timer entries for evicted items.

[Copilot]

Timer subscriptions are created and subscribed while holding gate. If Observable.Timer can invoke the callback synchronously (e.g., zero/near-zero due time or inline scheduling), RemoveExpired will try to re-enter gate and deadlock. Create/subscribe timers outside the lock, and only lock briefly to check/update expirations (also consider disposing the removed timer in RemoveExpired when you remove it from expirations).

Suggested change

	foreach (var (item, expiry) in pendingTimers)
	{
	lock (gate)
	{
	if (!expirations.ContainsKey(item))
	{
	var capturedItem = item;
	var timer = Observable.Timer(expiry).Subscribe(_ => RemoveExpired(capturedItem));
	expirations[item] = timer;
	}
	}
	}
	// Determine which items still need timers while holding the gate,
	// but create and subscribe timers outside the lock to avoid deadlocks
	// if Observable.Timer can invoke callbacks synchronously.
	List<(TObject item, TimeSpan expiry)> timersToStart;
	lock (gate)
	{
	timersToStart = new List<(TObject, TimeSpan)>();
	foreach (var (item, expiry) in pendingTimers)
	{
	if (!expirations.ContainsKey(item))
	{
	timersToStart.Add((item, expiry));
	}
	}
	}
	foreach (var (item, expiry) in timersToStart)
	{
	var capturedItem = item;
	var timerSubscription = Observable.Timer(expiry).Subscribe(_ => RemoveExpired(capturedItem));
	lock (gate)
	{
	if (expirations.ContainsKey(item))
	{
	// Another timer was registered for this item while we were subscribing;
	// dispose this one and keep the existing registration.
	timerSubscription.Dispose();
	}
	else
	{
	expirations[item] = timerSubscription;
	}
	}
	}

[Copilot]

This removal pass uses newFiltered.Contains(oldFiltered[i]), which relies on EqualityComparer<T>.Default and does not account for duplicates / multiple equal items. If the list can contain distinct items that compare equal, this can fail to remove the right instances (or fail to remove extras), producing incorrect downstream change sets. Consider reconciling by slot/index identity rather than value equality (e.g., track passing indices and apply removes/inserts based on index transitions).

Suggested change

	for (int i = oldFiltered.Count - 1; i >= 0; i--)
	{
	if (!newFiltered.Contains(oldFiltered[i]))
	{
	// Build a multiset of the new filtered items to reconcile counts correctly,
	// even when multiple distinct items compare equal.
	var counts = new System.Collections.Generic.Dictionary<T, int>(EqualityComparer<T>.Default);
	for (int i = 0; i < newFiltered.Count; i++)
	{
	var item = newFiltered[i];
	if (counts.TryGetValue(item, out var count))
	{
	counts[item] = count + 1;
	}
	else
	{
	counts[item] = 1;
	}
	}
	// Remove any surplus items from the existing filtered list, respecting multiplicities.
	for (int i = oldFiltered.Count - 1; i >= 0; i--)
	{
	var item = oldFiltered[i];
	if (counts.TryGetValue(item, out var remaining) && remaining > 0)
	{
	counts[item] = remaining - 1;
	}
	else
	{

[Copilot]

This insertion/move logic uses filtered.IndexOf(newFiltered[i]), which again matches by EqualityComparer<T>.Default. With duplicates or multiple equal items, IndexOf can return the wrong instance and cause incorrect Move/Insert operations (identity changes and ordering glitches). A safer approach is to compute the filtered list directly from slots and update filtered based on per-slot pass transitions (or otherwise reconcile using indices rather than IndexOf/Contains).

Suggested change

	for (int i = oldFiltered.Count - 1; i >= 0; i--)
	{
	if (!newFiltered.Contains(oldFiltered[i]))
	{
	filtered.RemoveAt(i);
	}
	}
	for (int i = 0; i < newFiltered.Count; i++)
	{
	if (i >= filtered.Count || !EqualityComparer<T>.Default.Equals(filtered[i], newFiltered[i]))
	{
	int existingIndex = filtered.IndexOf(newFiltered[i]);
	if (existingIndex >= 0)
	{
	filtered.Move(existingIndex, i);
	}
	else
	{
	filtered.Insert(i, newFiltered[i]);
	}
	}
	}
	// First, ensure that "filtered" contains exactly the required multiplicities
	// of each item in "newFiltered", even when duplicates are present.
	var requiredCounts = new Dictionary<T, int>(EqualityComparer<T>.Default);
	foreach (var item in newFiltered)
	{
	if (requiredCounts.TryGetValue(item, out var count))
	{
	requiredCounts[item] = count + 1;
	}
	else
	{
	requiredCounts[item] = 1;
	}
	}
	// Remove surplus items from the end based on requiredCounts.
	for (int i = filtered.Count - 1; i >= 0; i--)
	{
	var item = filtered[i];
	if (requiredCounts.TryGetValue(item, out var remaining) && remaining > 0)
	{
	requiredCounts[item] = remaining - 1;
	}
	else
	{
	filtered.RemoveAt(i);
	}
	}
	// Next, reorder and insert so that "filtered" exactly matches "newFiltered" by index.
	for (int i = 0; i < newFiltered.Count; i++)
	{
	var desired = newFiltered[i];
	if (i < filtered.Count && EqualityComparer<T>.Default.Equals(filtered[i], desired))
	{
	continue;
	}
	filtered.Insert(i, desired);
	}
	// Finally, trim any extra items that may remain at the end.
	while (filtered.Count > newFiltered.Count)
	{
	filtered.RemoveAt(filtered.Count - 1);
	}

[Copilot]

The "ReactiveUI Gaps" section still lists the RxCommand cancellation/concurrent execution race (RxUI #4196) as "pending audit", but this PR updates RxCommand.Execute() to use an Interlocked counter and documents it as fixed. Update this list to avoid implying the issue is still unresolved.

[michaelstonis]

@copilot apply changes based on this feedback

[michaelstonis]

@copilot apply changes based on the comments in this thread

[Copilot]

@copilot apply changes based on the comments in this thread

Applied all changes from the review thread in commit 916808d:

• List/AsyncDisposeMany.cs: Returns Disposable.Combine(disp, ...) so the upstream subscription is disposed on teardown — mirrors the Cache variant.
• List/ToObservableChangeSet.cs: (1) Filters pendingTimers via a HashSet after EnforceLimit() so evicted items never get a timer scheduled. (2) Subscribes timers outside gate to eliminate the lock-reentrance deadlock; acquires gate only briefly afterward to register (or dispose if a duplicate raced in).
• List/StatefulFilter.cs: Rewrote ReconcileFiltered to use multiset counting (Dictionary<T,int>) — removes surplus items by count, then inserts to align positions, then trims excess — so duplicate-equal values are reconciled correctly.
• docs/LibraryParity.md: Moved RxCommand #4196 from "pending audit" to a "Fixed (this sprint)" section.