MVVM Утечка памяти

BindingOperations.EnableCollectionSynchronization(Messages, ((ICollection)Messages).SyncRoot);

        public ObservableDictionary<Guid, CaptureFrameViewModel> CaptureFrameAreas { get; } = new ObservableDictionary<Guid, CaptureFrameViewModel>();
 
        private void OnCaptureFrameChanged(object? sender, Business.Common.EventArgs.CaptureFrameEventArgs e)
        {
            dispatcher.BeginInvoke(() =>
            {
                var area = CaptureFrameAreas[e.CaptureAreadGuid];
                area.Data = e.Bytes;
            });
        }

       public CaptureFramesViewModel(...)
        {
            BindingOperations.EnableCollectionSynchronization(CaptureFrameAreas, ((ICollection)CaptureFrameAreas).SyncRoot);
            // ... 
        }
 
        private void OnCaptureFrameChanged(object? sender, Business.Common.EventArgs.CaptureFrameEventArgs e)
        {
            lock (((ICollection)CaptureFrameAreas).SyncRoot)
            {
                var area = CaptureFrameAreas[e.CaptureAreadGuid];
                area.Data = e.Bytes;
            };
        }

        private void OnCaptureFrameChanged(object? sender, Business.Common.EventArgs.CaptureFrameEventArgs e)
        {
                var area = CaptureFrameAreas[e.CaptureAreadGuid];
                area.Data = e.Bytes;
        }

        private void OnCaptureFrameChanged(object? sender, Business.Common.EventArgs.CaptureFrameEventArgs e)
        {
                var area = CaptureFrameAreas[e.CaptureAreadGuid];
                area.Data = e.Bytes;
        }

        private void OnCaptureFrameChanged(object? sender, Business.Common.EventArgs.CaptureFrameEventArgs e)
        {
            dispatcher.BeginInvoke(() =>
            {
                var area = CaptureFrameAreas[e.CaptureAreadGuid];
                area.Data = e.Bytes;
            });
        }

using System.Collections;
using System.Threading;
using System.Windows;
using System.Windows.Data;
using System.Windows.Threading;
 
namespace CommonCore
{
    public static class CollectionHelper
    {
        public static void EnableCollectionSynchronization(this ICollection collection)
        {
            if (collection is null)
                return;
            if (SynchronizationContext.Current is DispatcherSynchronizationContext context)
            {
                BindingOperations.EnableCollectionSynchronization(collection, collection.SyncRoot);
            }
            else
            {
                Application.Current.Dispatcher.Invoke(collection.EnableCollectionSynchronization);
            }
        }
        public static void DisableCollectionSynchronization(this ICollection collection)
        {
            if (collection is null)
                return;
            if (SynchronizationContext.Current is DispatcherSynchronizationContext context)
            {
                BindingOperations.DisableCollectionSynchronization(collection);
            }
            else
            {
                Application.Current.Dispatcher.Invoke(collection.DisableCollectionSynchronization);
            }
        }
    }
}

Messages.EnableCollectionSynchronization();

        private async void OnCaptureFrameChangedAsync(object? sender, Business.Common.EventArgs.CaptureFrameEventArgs e)
        {
            await Task.Run(() =>
            {
                var area = CaptureFrameAreas[e.CaptureAreadGuid];
                area.Data = e.Bytes;
            });
        }

        private async void OnCaptureFrameChangedAsync(object? sender, Business.Common.EventArgs.CaptureFrameEventArgs e)
        {
            await Task.Run(() =>
            {
                var area = CaptureFrameAreas[e.CaptureAreadGuid];
                area.Data = e.Bytes;
            });
        }

        private async void OnCaptureFrameChangedAsync(object? sender, Business.Common.EventArgs.CaptureFrameEventArgs e)
        {
           var area = CaptureFrameAreas[e.CaptureAreadGuid];
 
            await Task.Run(() =>
            {
                area.Data = e.Bytes;
            });
        }

var area = CaptureFrameAreas[e.CaptureAreadGuid];
 
await Task.Run(() =>
{
    area.Data = e.Bytes;
});

var area = CaptureFrameAreas[e.CaptureAreadGuid];
 
dispatcher.BeginInvoke(() =>
{
    area.Data = e.Bytes;
});

        private void OnCaptureFrameChanged(object? sender, Business.Common.EventArgs.CaptureFrameEventArgs e)
        {
            CaptureFrameViewModel? area = CaptureFrameAreas[e.CaptureAreadGuid];
            area.Data = e.Bytes;
        }

        // Публичное свойство для привязки.
        public ObservableCollection<SomeType> Items { get; } = new ObservableCollection<SomeType>();
        // Внутренний словарь для быстрого поиска.
        private readonly Dictionary<int, SomeType> itemsDictionary = new Dictionary<int, SomeType>();
 
        // Метод обновления. Получает действие обновления и данные для обновления.
        private void OnUpdate(UpdateAction action, SomeData data)
        {
            switch (action)
            {
                // Если "Добавить", то создаётся новая сущность
                // и она добавляется в ObservableCollection и в словарь.
                case UpdateAction.Add:
                    {
                        SomeType item = new SomeType(data);
                        Items.Add(item);
                        itemsDictionary.Add(item.Id, item);
                    }
                    break;
 
                // Если "Удалить", то сущность извлекается из словаря и
                // потом удаляется в  ObservableCollection и в словаре.
                // и она добавляется в ObservableCollection и в словарь.
                case UpdateAction.Remove:
                    {
                        if (itemsDictionary.TryGetValue(data.Id, out SomeType item))
                        {
                            Items.Remove(item);
                            itemsDictionary.Remove(item.Id);
                        }
                    }
                    break;
 
                // Если "Обновить", то сущность извлекается из словаря и
                // потом обновляется актуальными данными.
                case UpdateAction.Update:
                    {
                        if (itemsDictionary.TryGetValue(data.Id, out SomeType item))
                        {
                            item.Update(data);
                        }
                    }
                    break;
 
                default:
                    throw new ArgumentException($"Неожиданное значение^ {(int)action}", nameof(action));
            }
        }

                    CaptureFrameViewModel? captureFrameArea = CaptureFrameAreas.FirstOrDefault(x => x.AreaGuid == e.CaptureAreadGuid);
                    int index = captureFrameArea is null ? -1 : CaptureFrameAreas.IndexOf(captureFrameArea);
                    if (index > -1)
                    {
                        CaptureFrameAreas[index].Data = null;
                    }
                    else
                    {
                        user = _meetingUsers.Users.Users[e.OwnerGuid];
                        CaptureFrameAreas.Add(new CaptureFrameViewModel(e.OwnerGuid, e.CaptureAreadGuid, user.UserName, null));
                    }

        private async void OnCaptureFrameChanged(object? sender, Business.Common.EventArgs.CaptureFrameEventArgs e)
        {
            await Task.Run(() =>
            {
                CaptureFrameViewModel? captureFrameArea = CaptureFrameAreas.FirstOrDefault(x => x.AreaGuid == e.CaptureAreadGuid);
                int index = captureFrameArea is null ? -1 : CaptureFrameAreas.IndexOf(captureFrameArea);
                if (index > -1)
                {
                    if (e.Bytes is not null)
                        CaptureFrameAreas[index].Data = e.Bytes.ConvertByteArrayToBitmapImage();
                }
                else
                {
                    System.Diagnostics.Debug.WriteLine($"FrameArea not exitst {e}");
                }
            });
        }

        private void OnCaptureFrameChanged(object? sender, Business.Common.EventArgs.CaptureFrameEventArgs e)
        {
            dispatcher.BeginInvoke(() =>
            {
                CaptureFrameViewModel? captureFrameArea = CaptureFrameAreas.FirstOrDefault(x => x.AreaGuid == e.CaptureAreadGuid);
                int index = captureFrameArea is null ? -1 : CaptureFrameAreas.IndexOf(captureFrameArea);
                if (index > -1)
                {
                    if (e.Bytes is not null)
                        CaptureFrameAreas[index].Data = e.Bytes.ConvertByteArrayToBitmapImage();
                }
                else
                {
                    System.Diagnostics.Debug.WriteLine($"FrameArea not exitst {e}");
                }
            });
        }

    public abstract partial class BaseInpc : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler? PropertyChanged;
 
        protected void RaisePropertyChanged([CallerMemberName] string? propertyName = null)
        {
#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
            DispatchAsync(() => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName)));
#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
        }
 
        protected bool Set<T>(ref T propertyField, T newValue, Equality<T>? equality = null, [CallerMemberName] string? propertyName = null)
        {
            bool isEquals = propertyField == null || newValue == null
                ? propertyField == null && newValue == null
                : ReferenceEquals(propertyField, newValue) ||
                    (
                        equality != null
                        ? equality(propertyField, newValue)
                        : propertyField is IEquatable<T> equatable
                            ? equatable.Equals(newValue)
                            : propertyField.Equals(newValue)
                    );
            if (!isEquals)
            {
                T oldValue = propertyField;
                propertyField = newValue;
                RaisePropertyChanged(propertyName);
 
                ProtectedPropertyChanged?.Invoke(propertyName, oldValue, newValue);
            }
 
            return !isEquals;
        }
 
        protected async Task DispatchAsync(Action callback)
        {
            if (SynchronizationContext.Current is DispatcherSynchronizationContext context)
            {
                callback.Invoke();
            }
            else
            {
                await Application.Current.Dispatcher.InvokeAsync(callback, DispatcherPriority.Normal);
            }
        }
 
        protected static event PropertyChangedHandler? ProtectedPropertyChanged;
    }

        public static BitmapImage? ConvertByteArrayToBitmapImage(this byte[] bytes)
        {
            if (bytes.Length <= 0)
                return null;
 
            var stream = new MemoryStream(bytes);
            stream.Seek(0, SeekOrigin.Begin);
            var image = new BitmapImage();
            image.BeginInit();
            image.StreamSource = stream;
            image.EndInit();
            return image;
        }

            image.EndInit();
 
            image.Freeze(); // ОБЯЗАТЕЛЬНО!
 
            return image;
        }