Fix SelectionChanged not raised on collection Reset (#20942)

* fix: raise SelectionChanged event on collection Reset when items are deselected

When a collection bound to a SelectingItemsControl (e.g. ListBox) was
cleared via NotifyCollectionChangedAction.Reset, the SelectionChanged
event was not raised despite the selection being lost.

The root cause was in InternalSelectionModel.OnSourceReset: the base
SelectionModel.OnSourceReset() directly reset _selectedIndex to -1
before any Operation could capture the old selection state. The
subsequent SyncFromSelectedItems created an Operation that saw no
change (old and new both -1), so CommitOperation never fired
SelectionChanged.

The fix snapshots _writableSelectedItems before sync, diffs against
the post-sync state to find items that were actually lost (not merely
re-selected at a new index after reorder), and injects them as
DeselectedItems on the pending Operation — following the same pattern
used by OnSelectionRemoved for individual item removals.

Fixes #20897

* fix: use multiset diff to report lost duplicate selections on Reset

The Reset diff in InternalSelectionModel used a HashSet to detect
which previously-selected items were still present after sync. Selection
allows duplicates (same instance or equal items at multiple indices),
so set semantics collapsed duplicates into one entry and under-reported
deselections when only some occurrences were lost.

Track counts per item plus a null counter and decrement per match, so
RemovedItems reflects the actual number of lost selections.

Adds a duplicate-items Reset test covering the regression.

* fix: raise SelectionChanged for reset-lost selection

ListBox and other SelectingItemsControl callers did not receive SelectionChanged when a Reset cleared the selected items. The selection model reports this path through LostSelection, but the control only used that callback for AlwaysSelected recovery.

Track the last selected items at the control boundary, capture that snapshot for Reset notifications, and raise the routed SelectionChanged event when LostSelection commits during that reset. This avoids diffing reset contents while preserving the removed-items payload for clear/reset-to-empty cases.

* fix: address review feedback on SelectionChanged Reset snapshot

- Replace per-change ToArray() snapshot with persistent List<object?> to
  avoid allocations on every selection change (review: MrJul).
- Read snapshot in PreCollectionChanged instead of Selection.SelectedItems
  because the source is already empty by the time Reset fires.
- Align LostSelection event-raising with SelectionChanged path: use
  BuildEventRoute + HasHandlers guard to avoid allocating args when
  no handlers are attached (review: copilot).
- Harden existing Reset tests to Assert.Single to catch double-fire.

* fix: consolidate SelectionChanged raising and defend against stale snapshot

- Extract RaiseSelectionChanged helper so both the normal
  (SelectionChanged) and reset (LostSelection) paths share the same
  BuildEventRoute/HasHandlers guard and SelectionChangedEventArgs
  construction (review: copilot).
- Move _selectedItemsBeforeReset clear outside the conditional in
  OnSelectionModelLostSelection so the field is always nulled after
  LostSelection, preventing accidental reuse (review: copilot).
- Add comment documenting the snapshot lifecycle in
  OnItemsViewPreCollectionChanged.

* perf: defer SelectionChangedEventArgs allocations until handlers are confirmed

SelectionChangedEventArgs materialized arrays via ToArray() at the call site
before checking whether the routed event had any registered handlers. This
allocated needlessly in the common case of no external subscribers.

The event items (IReadOnlyList<object?>) already implement IList via
ReadOnlySelectionListBase. RaiseSelectionChanged now accepts
IReadOnlyList<object?> and casts to IList inside the HasHandlers gate,
falling back to ToArray() only for non-IList enumerables.

Author: NathanDrake2406

src/Avalonia.Controls/Primitives/SelectingItemsControl.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections;
+using System.Collections.Generic;
 using System.Collections.Specialized;
 using System.ComponentModel;
 using System.Diagnostics.CodeAnalysis;
@@ -145,6 +146,8 @@ public class SelectingItemsControl : ItemsControl
         private int _oldSelectedIndex;
         private WeakReference _oldSelectedItem = new(null);
         private WeakReference<IList?> _oldSelectedItems = new(null);
+        private readonly List<object?> _selectedItemsSnapshot = new();
+        private object?[]? _selectedItemsBeforeReset;
         private bool _ignoreContainerSelectionChanged;
         private UpdateState? _updateState;
         private bool _hasScrolledToSelectedItem;
@@ -153,7 +156,9 @@ public class SelectingItemsControl : ItemsControl
 
         public SelectingItemsControl()
         {
-            ((ItemCollection)ItemsView).SourceChanged += OnItemsViewSourceChanged;
+            var items = (ItemCollection)ItemsView;
+            items.SourceChanged += OnItemsViewSourceChanged;
+            items.PreCollectionChanged += OnItemsViewPreCollectionChanged;
         }
 
         /// <summary>
@@ -465,6 +470,14 @@ private protected override void OnItemsViewCollectionChanged(object? sender, Not
             }
         }
 
+        private void OnItemsViewPreCollectionChanged(object? sender, NotifyCollectionChangedEventArgs e)
+        {
+            if (e.Action == NotifyCollectionChangedAction.Reset && _selectedItemsSnapshot.Count > 0)
+            {
+                _selectedItemsBeforeReset = _selectedItemsSnapshot.ToArray();
+            }
+        }
+
         /// <inheritdoc />
         protected override void OnAttachedToVisualTree(VisualTreeAttachmentEventArgs e)
         {
@@ -1013,16 +1026,11 @@ void Mark(int index, bool selected)
                 UpdateSelectedValueFromItem();
             }
 
-            var route = BuildEventRoute(SelectionChangedEvent);
+            _selectedItemsSnapshot.Clear();
+            _selectedItemsSnapshot.AddRange(Selection.SelectedItems);
+            _selectedItemsBeforeReset = null;
 
-            if (route.HasHandlers)
-            {
-                var ev = new SelectionChangedEventArgs(
-                    SelectionChangedEvent,
-                    e.DeselectedItems.ToArray(),
-                    e.SelectedItems.ToArray());
-                RaiseEvent(ev);
-            }
+            RaiseSelectionChanged(e.DeselectedItems, e.SelectedItems);
         }
 
         /// <summary>
@@ -1033,12 +1041,37 @@ void Mark(int index, bool selected)
         /// <param name="e">The event args.</param>
         private void OnSelectionModelLostSelection(object? sender, EventArgs e)
         {
+            if (_selectedItemsBeforeReset?.Length > 0)
+            {
+                RaiseSelectionChanged(_selectedItemsBeforeReset, Array.Empty<object?>());
+            }
+
+            _selectedItemsBeforeReset = null;
+
             if (AlwaysSelected && ItemsView.Count > 0)
             {
                 SelectedIndex = 0;
             }
         }
 
+        /// <summary>
+        /// Raises the <see cref="SelectionChangedEvent"/> if there are registered handlers.
+        /// </summary>
+        /// <param name="removedItems">The items removed from the selection.</param>
+        /// <param name="addedItems">The items added to the selection.</param>
+        private void RaiseSelectionChanged(IReadOnlyList<object?> removedItems, IReadOnlyList<object?> addedItems)
+        {
+            var route = BuildEventRoute(SelectionChangedEvent);
+
+            if (route.HasHandlers)
+            {
+                RaiseEvent(new SelectionChangedEventArgs(
+                    SelectionChangedEvent,
+                    removedItems as IList ?? removedItems.ToArray(),
+                    addedItems as IList ?? addedItems.ToArray()));
+            }
+        }
+
         private void SelectItemWithValue(object? value)
         {
             if (ItemCount == 0 || _isSelectionChangeActive)
@@ -1248,6 +1281,8 @@ private void InitializeSelectionModel(ISelectionModel model)
 
             _oldSelectedIndex = model.SelectedIndex;
             _oldSelectedItem.Target = model.SelectedItem;
+            _selectedItemsSnapshot.Clear();
+            _selectedItemsSnapshot.AddRange(model.SelectedItems);
 
             if (_updateState is null && AlwaysSelected && model.Count == 0)
             {

tests/Avalonia.Controls.UnitTests/Primitives/SelectingItemsControlTests.cs

@@ -856,6 +856,101 @@ public void Resetting_Items_Collection_Should_Clear_Selection()
             Assert.Equal(-1, target.SelectedIndex);
         }
 
+        [Fact]
+        public void Resetting_Items_Collection_Should_Raise_SelectionChanged()
+        {
+            var items = new ObservableCollection<Item>
+            {
+                new Item(),
+                new Item(),
+                new Item(),
+            };
+
+            var target = new SelectingItemsControl
+            {
+                ItemsSource = items,
+                Template = Template(),
+            };
+
+            Prepare(target);
+            target.SelectedIndex = 1;
+
+            var selectedItem = items[1];
+
+            var receivedArgs = new List<SelectionChangedEventArgs>();
+            target.SelectionChanged += (_, args) => receivedArgs.Add(args);
+
+            items.Clear();
+
+            Assert.Null(target.SelectedItem);
+            Assert.Equal(-1, target.SelectedIndex);
+            Assert.Single(receivedArgs);
+            Assert.Empty(receivedArgs[0].AddedItems);
+            Assert.Equal(new[] { selectedItem }, receivedArgs[0].RemovedItems);
+        }
+
+        [Fact]
+        public void Resetting_Items_To_Empty_With_Multiple_Selection_Should_Raise_SelectionChanged()
+        {
+            var items = new ObservableCollection<Item>
+            {
+                new Item(),
+                new Item(),
+                new Item(),
+            };
+
+            var target = new TestSelector
+            {
+                ItemsSource = items,
+                Template = Template(),
+                SelectionMode = SelectionMode.Multiple,
+            };
+
+            Prepare(target);
+            target.SelectedIndex = 0;
+            target.Selection.Select(2);
+
+            var selected0 = items[0];
+            var selected2 = items[2];
+
+            var receivedArgs = new List<SelectionChangedEventArgs>();
+            target.SelectionChanged += (_, args) => receivedArgs.Add(args);
+
+            items.Clear();
+
+            Assert.Null(target.SelectedItem);
+            Assert.Equal(-1, target.SelectedIndex);
+            Assert.Single(receivedArgs);
+            Assert.Empty(receivedArgs[0].AddedItems);
+            Assert.Equal(2, receivedArgs[0].RemovedItems.Count);
+            Assert.Contains(selected0, receivedArgs[0].RemovedItems.Cast<object>());
+            Assert.Contains(selected2, receivedArgs[0].RemovedItems.Cast<object>());
+        }
+
+        [Fact]
+        public void Resetting_Items_With_Preserved_Selection_Should_Not_Report_Deselection()
+        {
+            var items = new ResettingCollection(3);
+
+            var target = new SelectingItemsControl
+            {
+                ItemsSource = items,
+                Template = Template(),
+            };
+
+            target.ApplyTemplate();
+            target.SelectedIndex = 1;
+
+            var receivedArgs = new List<SelectionChangedEventArgs>();
+            target.SelectionChanged += (_, args) => receivedArgs.Add(args);
+
+            items.Reset(new[] { "Item2", "Item0", "Item1" });
+
+            Assert.Equal("Item1", target.SelectedItem);
+            Assert.Single(receivedArgs);
+            Assert.Empty(receivedArgs[0].RemovedItems);
+        }
+
         [Fact]
         public void Raising_IsSelectedChanged_On_Item_Should_Update_Selection()
         {