WPF / UWP DataGrid какое событие возникает после изменения кол-ва строк?

public interface IAdvancedSelectedItems 
{
    void SelectItems(IEnumerable<ProxyEntity> items);
    void SelectItem(ProxyEntity? item = null);
}

public class AdvancedDataGrid : DataGrid, IAdvancedSelectedItems
{
    public void SelectItems(IEnumerable<ProxyEntity> items)
    {
        SelectedIndex = -1;
        foreach (var item in items)
        {
            SelectItem(item);
        }
    }
 
    public void SelectItem(ProxyEntity? item = null)
    {
        if (item is null)
        {
            SelectedIndex = -1;
            return;
        }
        if (Items.Contains(item)) SelectedItems.Add(item);
    }
}

private void InOutGrid_MouseUp(object sender, MouseButtonEventArgs e)
{
    var grid = sender as AdvancedDataGrid ?? throw new Exception();
    foreach (var item in grid.Items)
    {
        if (item is not ProxyEntity proxy) return;
        if (grid.SelectedItems.Contains(proxy))
        {
            if (!_model.SelectedProxies.Contains(proxy))
                _model.SelectedProxies.Add(proxy);
        }
        else
        {
            if (_model.SelectedProxies.Contains(proxy))
                _model.SelectedProxies.Remove(proxy);
        }
    }
}

using System.Collections;
using System.Collections.Specialized;
using System.Windows;
using System.Windows.Controls;
 
using Microsoft.Xaml.Behaviors;
 
namespace DBClient
{
    public class DataGridMultiSelectionBehavior : Behavior<DataGrid>
    {
        public static readonly DependencyProperty SelectedItemsProperty =
            DependencyProperty.Register("SelectedItems", typeof(IList), typeof(DataGridMultiSelectionBehavior),
                new UIPropertyMetadata(null, SelectedItemsChanged));
 
        public IList SelectedItems
        {
            get => (IList)GetValue(SelectedItemsProperty);
            set => SetValue(SelectedItemsProperty, value);
        }
 
        private bool _isUpdatingTarget;
        private bool _isUpdatingSource;
 
        private static void SelectedItemsChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (!(d is DataGridMultiSelectionBehavior behavior))
            {
                return;
            }
 
            INotifyCollectionChanged newValue = e.NewValue as INotifyCollectionChanged;
 
            if (e.OldValue is INotifyCollectionChanged oldValue)
            {
                oldValue.CollectionChanged -= behavior.SourceCollectionChanged;
                behavior.AssociatedObject.SelectionChanged -= behavior.DataGridSelectionChanged;
            }
 
            if (newValue != null)
            {
                behavior.AssociatedObject.SelectedItems.Clear();
                foreach (object item in (IEnumerable)newValue)
                {
                    behavior.AssociatedObject.SelectedItems.Add(item);
                }
            }
 
            behavior.AssociatedObject.SelectionChanged += behavior.DataGridSelectionChanged;
            newValue.CollectionChanged += behavior.SourceCollectionChanged;
 
        }
        private void DataGridSelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (_isUpdatingTarget)
            {
                return;
            }
 
            IList selectedItems = SelectedItems;
 
            if (selectedItems == null)
            {
                return;
            }
 
            try
            {
                _isUpdatingSource = true;
 
                foreach (object item in e.RemovedItems)
                {
                    selectedItems.Remove(item);
                }
 
                foreach (object item in e.AddedItems)
                {
                    selectedItems.Add(item);
                }
            }
            finally
            {
                _isUpdatingSource = false;
            }
        }
        private void SourceCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
        {
            if (_isUpdatingSource)
            {
                return;
            }
 
            try
            {
                _isUpdatingTarget = true;
 
                if (e.OldItems != null)
                {
                    foreach (object item in e.OldItems)
                    {
                        AssociatedObject.SelectedItems.Remove(item);
                    }
                }
 
                if (e.NewItems != null)
                {
                    foreach (object item in e.NewItems)
                    {
                        AssociatedObject.SelectedItems.Add(item);
                    }
                }
 
                if (e.Action == NotifyCollectionChangedAction.Reset)
                {
                    AssociatedObject.SelectedItems.Clear();
                }
            }
            finally
            {
                _isUpdatingTarget = false;
            }
        }
        protected override void OnAttached()
        {
            base.OnAttached();
            if (SelectedItems != null)
            {
                AssociatedObject.SelectedItems.Clear();
                foreach (object item in SelectedItems)
                {
                    AssociatedObject.SelectedItems.Add(item);
                }
            }
        }
    }
}

public ObservableCollection<WorkDrawData> SelectedWorks { get; } = new ObservableCollection<WorkDrawData>();

internal class SelectedComparer<TProxyEntity> : IComparer<Guid> 
    where TProxyEntity : ProxyEntity
{
    private readonly IList<TProxyEntity> _entities;
 
    public SelectedComparer(IList<TProxyEntity> entities) =>
        _entities = entities;
 
 
    public int Compare(Guid x, Guid y)
    {
        var hasX = _entities.Any(e => e.Id == x);
        var hasY = _entities.Any(e => e.Id == y);
        return hasX switch
        {
            true when !hasY => -1,
            false when hasY => 1,
            _ => 0
        };
    }
}

public interface IAsyncCommand<in T> : ICommand
{
    Task ExecuteAsync(T parameter);
    bool CanExecute(T? parameter);
}

public abstract class AsyncCommandBase : IDisposable
{
    public event EventHandler? CanExecuteChanged;
 
    protected bool IsExecuting { get; set; }
    protected readonly IErrorHandler? ErrorCancelHandler;
    protected CancellationToken InnerCancellationToken { get; set; } = CancellationToken.None;
    protected CancellationTokenSource? ProxyCancellationTokenSource;
 
    protected AsyncCommandBase(IErrorHandler? errorCancelHandler,
         bool cancellationSupport, CancellationToken cancelToken)
    {
        if (cancellationSupport)
        {
            if (cancelToken == CancellationToken.None)
            {
                ProxyCancellationTokenSource = new CancellationTokenSource();
                InnerCancellationToken = ProxyCancellationTokenSource.Token;
            }
            else InnerCancellationToken = cancelToken;
        }
        ErrorCancelHandler = errorCancelHandler;
    }
 
    public void RaiseCanExecuteChanged() =>
        CanExecuteChanged?.Invoke(this, EventArgs.Empty);
 
    public bool IsNotCancelled 
    {
        get
        {
            CancelException();
            return !InnerCancellationToken.IsCancellationRequested;
        }
    }
 
    protected void CancelException()
    {
        if (InnerCancellationToken == CancellationToken.None)
            throw new NotSupportedException("Данная команда не поддерживает отмену.");
    }
 
    public void Cancel()
    {
        CancelException();
        if (ProxyCancellationTokenSource is null)
            throw new TaskCanceledException("Управляйте отменой внешним ресурсом (CancellationTokenSource).");
        if (ProxyCancellationTokenSource is { IsCancellationRequested: false })
            ProxyCancellationTokenSource.Cancel();
    }
 
    public void ResetCancel()
    {
        CancelException();
        switch (ProxyCancellationTokenSource)
        {
            case null:
                throw new TaskCanceledException(
                    "Управляйте отменой внешним ресурсом (CancellationTokenSource).");
            case { IsCancellationRequested: true }:
                ProxyCancellationTokenSource.Dispose();
                ProxyCancellationTokenSource = new();
                break;
        }
 
        InnerCancellationToken = ProxyCancellationTokenSource.Token;
    }
 
    public void ResetCancel(ref CancellationTokenSource newCancellationTokenSource)
    {
        CancelException();
        if (ProxyCancellationTokenSource is not null)
        {
            ProxyCancellationTokenSource.Dispose();
            ProxyCancellationTokenSource = null;
        }
 
        if (newCancellationTokenSource is { IsCancellationRequested: true })
        {
            newCancellationTokenSource.Dispose();
            newCancellationTokenSource = new();
        }
        InnerCancellationToken = newCancellationTokenSource.Token;
    }
 
    private bool _disposedValue;
    protected virtual void Dispose(bool disposing)
    {
        if (!_disposedValue)
        {
            if (disposing)
            {
                ProxyCancellationTokenSource?.Dispose();
            }
 
            // TODO: освободить неуправляемые ресурсы (неуправляемые объекты) и переопределить метод завершения
            // TODO: установить значение NULL для больших полей
            _disposedValue = true;
        }
    }
 
    // // TODO: переопределить метод завершения, только если "Dispose(bool disposing)" содержит код для освобождения неуправляемых ресурсов
    // ~AsyncCommandBase()
    // {
    //     // Не изменяйте этот код. Разместите код очистки в методе "Dispose(bool disposing)".
    //     Dispose(disposing: false);
    // }
 
    public void Dispose()
    {
        // Не изменяйте этот код. Разместите код очистки в методе "Dispose(bool disposing)".
        Dispose(disposing: true);
        GC.SuppressFinalize(this);
    }
}

public class AsyncCommand<T> : AsyncCommandBase, IAsyncCommand<T>
{
    private readonly Func<T?, CancellationToken, Task> _execute;
    private readonly Func<T?, bool>? _canExecute;
 
    public AsyncCommand(
        Func<T?, CancellationToken, Task> execute,
        Func<T?, bool>? canExecute = null,
        IErrorHandler? errorHandler = null,
        CancellationToken cancel = default)
        : base(errorHandler, true, cancel)
    {
        _execute = execute;
        _canExecute = canExecute;
    }
 
    public AsyncCommand(Func<T?, Task> execute,
        Func<T?, bool>? canExecute = null,
        IErrorHandler? errorHandler = null)
        : base(errorHandler, false, CancellationToken.None)
    {
        _execute = (p, _) => execute.Invoke(p);
        _canExecute = canExecute;
    }
 
    public bool CanExecute(T? parameter) =>
        !IsExecuting &&
        (_canExecute?.Invoke(parameter) ?? true) &&
        !InnerCancellationToken.IsCancellationRequested;
 
    public async Task ExecuteAsync(T? parameter)
    {
        if (CanExecute(parameter))
        {
            try
            {
                IsExecuting = true;
                await _execute.Invoke(parameter, InnerCancellationToken);
            }
            finally
            {
                IsExecuting = false;
            }
        }
        RaiseCanExecuteChanged();
    }
 
    #region Explicit implementations
    bool ICommand.CanExecute(object? parameter) => CanExecute((T?)parameter);
 
    void ICommand.Execute(object? parameter) =>
        ExecuteAsync((T?) parameter).FireAndForgetSafeAsync(ErrorCancelHandler);
    #endregion
}

public static async void FireAndForgetSafeAsync(this Task task, IErrorHandler? handler)
    {
        try
        {
            await task;
        }
        catch (OperationCanceledException ex)
        {
            if (handler is IErrorCancelHandler handlerWithCancel)
                handlerWithCancel.HandleCancel(ex);
            else handler?.HandleError(ex);
        }
        catch (ResultNotFoundException ex)
        {
            if (handler is IErrorNotFoundHandler handlerWithNotFound)
                handlerWithNotFound.HandleResultNotFound(ex);
            else handler?.HandleError(ex);
        }
        catch (Exception ex)
        {
            handler?.HandleError(ex);
        }
    }

private void DataGrid_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
    if (e.AddedItems.Count > 0 && sender is DataGrid grid)
        grid.ScrollIntoView(e.AddedItems[^1]!);
}