Xamarin.Forms中ObservableCollection性能优化及List联动方案问询

一、性能优化方案 #

针对大量元素时ObservableCollection.Add()耗时过长的问题，核心原因是每次增删操作都会触发CollectionChanged事件，导致UI频繁更新。可以通过以下方式优化：

1. 批量操作替代单次添加 #

自定义支持批量添加的ObservableCollection子类，一次性添加多个元素后仅触发一次UI刷新，避免多次事件通知：

public class ObservableCollectionEx<T> : ObservableCollection<T>
{
    private bool _suppressNotifications;

    protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
    {
        if (!_suppressNotifications)
            base.OnCollectionChanged(e);
    }

    // 批量添加方法
    public void AddRange(IEnumerable<T> items)
    {
        _suppressNotifications = true;
        foreach (var item in items)
        {
            Add(item);
        }
        _suppressNotifications = false;
        // 手动触发一次重置通知，让UI一次性更新
        OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
    }
}

使用时直接调用AddRange批量添加元素，而非循环调用Add。

2. 开启UI虚拟化 #

如果使用ListView，必须设置CachingStrategy为RecycleElement或RecycleElementAndDataTemplate，复用已创建的ViewCell，避免重复创建大量控件：

<ListView ItemsSource="{Binding ItemDetails}" CachingStrategy="RecycleElement">
    <!-- 你的ItemTemplate -->
</ListView>

推荐直接替换为CollectionView，它默认支持更高效的虚拟化，在大量数据场景下性能表现优于ListView。

3. 后台线程处理数据，UI线程批量更新 #

不要在UI线程直接做大量数据的增删操作，先在后台线程准备好数据，再回到UI线程批量添加：

// 后台线程获取/处理新数据
var newRoomItems = await Task.Run(() => FetchNewRoomItems());

// UI线程批量更新集合
Device.BeginInvokeOnMainThread(() =>
{
    ((ObservableCollectionEx<RoomItem>)ItemDetails).AddRange(newRoomItems);
});

4. 简化数据模板 #

检查你的ItemTemplate，避免嵌套过多布局控件、不必要的数据绑定或复杂视图逻辑。尽量用轻量级控件（比如直接用Label代替嵌套ContentView），减少UI渲染的开销。

二、List与ObservableCollection 联动更新实现 #

要实现List增删操作同步更新ObservableCollection且不创建新实例，可以通过以下两种方式：

1. 封装同步集合类 #

创建一个同时持有List和ObservableCollection的类，封装增删方法确保两者数据同步：

public class SyncedCollection<T>
{
    private readonly List<T> _innerList;
    private readonly ObservableCollectionEx<T> _observableCollection;

    // 暴露List供直接操作
    public List<T> List => _innerList;
    // 暴露ObservableCollection给UI绑定
    public ObservableCollection<T> ObservableCollection => _observableCollection;

    public SyncedCollection()
    {
        _innerList = new List<T>();
        _observableCollection = new ObservableCollectionEx<T>();
    }

    // 同步添加单个元素
    public void Add(T item)
    {
        _innerList.Add(item);
        _observableCollection.Add(item);
    }

    // 同步批量添加
    public void AddRange(IEnumerable<T> items)
    {
        _innerList.AddRange(items);
        _observableCollection.AddRange(items);
    }

    // 同步移除元素
    public bool Remove(T item)
    {
        var removed = _innerList.Remove(item);
        if (removed)
            _observableCollection.Remove(item);
        return removed;
    }

    // 其他需要的同步方法（如Clear、RemoveAt等）
    public void Clear()
    {
        _innerList.Clear();
        _observableCollection.Clear();
    }
}

使用时，直接操作SyncedCollection.List的增删方法，内部会自动同步到ObservableCollection，UI也会实时更新。

2. 基于List实现可通知集合 #

直接实现一个以List为内部存储的集合类，同时实现INotifyCollectionChanged接口，既保留List的性能，又能触发UI更新：

public class ListBackedObservableCollection<T> : IList<T>, INotifyCollectionChanged, INotifyPropertyChanged
{
    private readonly List<T> _innerList = new List<T>();

    public event NotifyCollectionChangedEventHandler CollectionChanged;
    public event PropertyChangedEventHandler PropertyChanged;

    public int Count => _innerList.Count;
    public bool IsReadOnly => false;

    public T this[int index]
    {
        get => _innerList[index];
        set
        {
            var oldItem = _innerList[index];
            _innerList[index] = value;
            OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Replace, value, oldItem, index));
            OnPropertyChanged(nameof(Count));
        }
    }

    public void Add(T item)
    {
        _innerList.Add(item);
        OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, item, _innerList.Count - 1));
        OnPropertyChanged(nameof(Count));
    }

    public void AddRange(IEnumerable<T> items)
    {
        var startIndex = _innerList.Count;
        _innerList.AddRange(items);
        OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, items.ToList(), startIndex));
        OnPropertyChanged(nameof(Count));
    }

    public void Clear()
    {
        _innerList.Clear();
        OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
        OnPropertyChanged(nameof(Count));
    }

    public bool Remove(T item)
    {
        var index = _innerList.IndexOf(item);
        if (index >= 0)
        {
            RemoveAt(index);
            return true;
        }
        return false;
    }

    public void RemoveAt(int index)
    {
        var item = _innerList[index];
        _innerList.RemoveAt(index);
        OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, item, index));
        OnPropertyChanged(nameof(Count));
    }

    // 实现IList的其他方法（Contains、IndexOf、Insert等）
    public bool Contains(T item) => _innerList.Contains(item);
    public void CopyTo(T[] array, int arrayIndex) => _innerList.CopyTo(array, arrayIndex);
    public IEnumerator<T> GetEnumerator() => _innerList.GetEnumerator();
    public int IndexOf(T item) => _innerList.IndexOf(item);
    public void Insert(int index, T item)
    {
        _innerList.Insert(index, item);
        OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, item, index));
        OnPropertyChanged(nameof(Count));
    }

    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();

    protected virtual void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
    {
        CollectionChanged?.Invoke(this, e);
    }

    protected virtual void OnPropertyChanged(string propertyName)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

这个类可以直接作为ItemsSource绑定到UI，内部用List存储数据，增删操作性能和List一致，同时会自动触发UI更新。

内容的提问来源于stack exchange，提问作者RMR