如何判断ObservableCollection是否正处于CollectionChanged事件执行中？

我之前开发WPF应用时也踩过这个坑——ObservableCollection在CollectionChanged事件执行期间修改集合，百分百会抛出那个「Cannot change ObservableCollection during a CollectionChanged event」异常，尤其是连续触发添加/移除操作时特别容易中招。给你分享几个经过实践验证的解决思路：

这是最直接、易上手的方案，适合大多数普通场景。你可以在集合所在的ViewModel或类中添加一个私有布尔变量，用来标记CollectionChanged事件是否正在执行：

private bool _isCollectionChanging;
public ObservableCollection<YourItemType> TargetCollection { get; }

public YourViewModel()
{
    TargetCollection = new ObservableCollection<YourItemType>();
    TargetCollection.CollectionChanged += OnCollectionChanged;
}

private void OnCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
    _isCollectionChanging = true;
    try
    {
        // 这里写你的事件处理逻辑，比如同步UI状态、计算统计数据等
    }
    finally
    {
        // 必须用finally重置标志位，哪怕逻辑出错也不会锁死后续修改
        _isCollectionChanging = false;
    }
}

之后在所有需要修改集合的方法里，先判断这个标志位：

public void AddNewItem(YourItemType item)
{
    if (!_isCollectionChanging)
    {
        TargetCollection.Add(item);
    }
    // 如果不能丢弃操作，也可以把修改逻辑暂存，等事件完成后再执行
}

如果你的业务场景不允许丢弃任何修改操作，而是需要确保所有变更都能被执行，可以把要做的修改操作放到一个队列里，等CollectionChanged事件完成后批量处理：

private readonly Queue<Action> _pendingChangesQueue = new Queue<Action>();
private bool _isCollectionChanging;

private void OnCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
    _isCollectionChanging = true;
    try
    {
        // 你的事件处理逻辑
    }
    finally
    {
        _isCollectionChanging = false;
        // 事件结束后处理队列里的待执行操作
        ProcessPendingChanges();
    }
}

private void ProcessPendingChanges()
{
    // 加锁避免多线程下的队列操作冲突
    lock (_pendingChangesQueue)
    {
        while (_pendingChangesQueue.Count > 0)
        {
            var pendingAction = _pendingChangesQueue.Dequeue();
            pendingAction.Invoke();
        }
    }
}

// 修改集合的方法调整为：
public void RemoveItem(YourItemType item)
{
    if (_isCollectionChanging)
    {
        lock (_pendingChangesQueue)
        {
            _pendingChangesQueue.Enqueue(() => TargetCollection.Remove(item));
        }
    }
    else
    {
        TargetCollection.Remove(item);
    }
}

如果你的应用频繁遇到这类问题，或者需要在多线程环境下操作集合，可以封装一个自己的ObservableCollection变体，把重入处理逻辑内置进去，上层调用无需关心细节：

public class SafeObservableCollection<T> : ObservableCollection<T>
{
    private bool _isCollectionChanging;

    protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
    {
        if (!_isCollectionChanging)
        {
            _isCollectionChanging = true;
            try
            {
                base.OnCollectionChanged(e);
            }
            finally
            {
                _isCollectionChanging = false;
            }
        }
    }

    protected override void InsertItem(int index, T item)
    {
        if (!_isCollectionChanging)
        {
            base.InsertItem(index, item);
        }
        else
        {
            // 用Dispatcher延迟执行，确保在事件完成后再修改
            Application.Current.Dispatcher.BeginInvoke(new Action(() => InsertItem(index, item)));
        }
    }

    // 同理重写RemoveItem、SetItem、ClearItem等核心修改方法
}

额外提示 #

如果你的CollectionChanged事件处理逻辑包含异步操作，布尔标志位的方案可能失效（因为异步方法会提前结束，标志位提前重置，但异步逻辑还在执行）。这种情况下可以用SemaphoreSlim或异步锁来跟踪异步操作的状态，确保异步逻辑完成前不修改集合。

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