ListBox как отключить автоматическую прокрутку вверх при добавлении в него элементов?

public ObservableCollection<MyType> MyCollection { get; } = new ObservableCollection<MyType>();
 
// .....
 
MyCollection.Add(MyTypeObject);

    public static class VisualTreeHelper
    {
        public static IEnumerable<DependencyObject> GetChildren(this DependencyObject reference)
        {
            ArgumentNullException.ThrowIfNull(reference);
            Queue<DependencyObject> queue = new Queue<DependencyObject>(16);
            queue.Enqueue(reference);
            while (queue.Count != 0)
            {
                DependencyObject current = queue.Dequeue();
                int count = GetChildrenCount(current);
                for (int i = 0; i < count; i++)
                {
                    queue.Enqueue(GetChild(current, i));
                }
                yield return current;
            }
        }
        public static IEnumerable<T> GetChildren<T>(this DependencyObject reference)
           where T : DependencyObject
            => reference.GetChildren().OfType<T>();
 
        public static T FindAncestor<T>(this DependencyObject dobj)
            where T : DependencyObject
        {
            while (dobj is not null)
            {
                if (dobj is T t)
                    return t;
 
                dobj = GetParent(dobj);
            }
            return null;
        }
 
        public static FrameworkElement FindDataAncestor<TData>(this DependencyObject dobj)
        {
            while (dobj is not null)
            {
                if (dobj is FrameworkElement element and { DataContext: TData })
                    return element;
 
                dobj = GetParent(dobj);
            }
            return null;
        }
 
        public static TData FindData<TData>(this DependencyObject dobj)
        {
            FrameworkElement element = dobj.FindDataAncestor<TData>();
            if (element == null)
                return default;
            return (TData)element.DataContext;
        }
 
    }

    public partial class NumsWindow : Window
    {
        public NumsWindow()
        {
            InitializeComponent();
            NumsVM vm = (NumsVM)DataContext;
            BindingOperations.EnableCollectionSynchronization(vm.Nums, ((ICollection)vm.Nums).SyncRoot);
            ((INotifyCollectionChanged)vm.Nums).CollectionChanged += OnNumsChanged;
            Loaded += async delegate
            {
                await vm.Start();
            };
        }
 
        private void OnNumsChanged(object? sender, NotifyCollectionChangedEventArgs e)
        {
            scroll?.Dispatcher.Invoke(() =>
            {
                double offset = scroll.ContentVerticalOffset;
                double offs = 0;
                if (e.NewStartingIndex <= offset)
                {
                    offs += e.NewItems?.Count ?? 0;
                }
                if (e.OldStartingIndex <= offset)
                {
                    offs -= e.OldItems?.Count ?? 0;
                }
                if (offs != 0)
                {
                    scroll.ScrollToVerticalOffset(offset + offs);
                }
                Debug.WriteLine(offset);
            });
        }
 
        private ScrollViewer? scroll = null;
 
        private void OnLayoutUpdate(object sender, EventArgs e)
        {
            scroll = lBox.GetChildren<ScrollViewer>().FirstOrDefault();
        }
    }

    public class NumsVM
    {
        public ReadOnlyObservableCollection<int> Nums { get; }
        private readonly ObservableCollection<int> ints;
 
        public NumsVM() => Nums = new(ints = new(Enumerable.Range(0,100).Reverse()));
 
        public async Task Start() => await Task.Run(async () =>
        {
            while (true)
            {
                ints.Insert(0, ints.Count);
                await Task.Delay(1000);
            }
        });
    }

    public class NumsVM
    {
        public ReadOnlyObservableCollection<string> Nums { get; }
        private readonly ObservableCollection<string> ints;
 
        public NumsVM() => Nums = new(ints = new(Enumerable.Range(0, 100).Reverse().Select(i => i.ToString())));
 
        private static readonly Random random = new Random();
        public async Task Start() => await Task.Run(async () =>
        {
            while (true)
            {
                ints.Insert(0, string.Join(Environment.NewLine, Enumerable.Range(0, random.Next(5)).Select(i => "\t" + i).Append(ints.Count.ToString())));
                await Task.Delay(1000);
            }
        });
    }

    public class NumsVM
    {
        public ReadOnlyObservableCollection<object> Nums { get; }
        private readonly ObservableCollection<object> ints;
 
        public NumsVM() => Nums = new(ints = new(Enumerable.Range(0, 100).Reverse().Select(i => (object)i)));
 
        private static readonly Random random = new Random();
        public async Task Start() => await Task.Run(async () =>
        {
            while (true)
            {
                ints.Insert(0, random.Next(2) == 0 ? ints.Count : ints.Count.ToString());
                await Task.Delay(1000);
            }
        });
    }