WPF跨线程操作ObservableCollection报错，求实时日志更新方案

方案一：正确集成BindingOperations.EnableCollectionSynchronization #

EnableCollectionSynchronization必须在UI线程调用，你可以通过以下方式优雅集成到单例Logger中：

1. 修改Logger单例，添加同步锁对象，并提供启用同步的方法：

public class Logger
{
    private static readonly Logger _instance = new Logger();
    public static Logger Instance => _instance;

    private readonly ObservableCollection<LogEntry> _logEntries = new ObservableCollection<LogEntry>();
    private readonly object _syncLock = new object();
    private bool _isSyncEnabled;

    public ObservableCollection<LogEntry> LogEntries => _logEntries;

    private Logger() { }

    // 必须在UI线程调用此方法启用集合同步
    public void EnableUiCollectionSync()
    {
        if (!_isSyncEnabled)
        {
            BindingOperations.EnableCollectionSynchronization(_logEntries, _syncLock);
            _isSyncEnabled = true;
        }
    }

    public void Add(LogEntry entry)
    {
        lock (_syncLock)
        {
            _logEntries.Add(entry);
        }
    }
}

2. 在WPF页面的构造函数（UI线程环境）中初始化同步：

public MainWindow()
{
    InitializeComponent();
    Logger.Instance.EnableUiCollectionSync();
    DataContext = Logger.Instance;
}

后续后台线程调用Logger.Add时，会通过同步锁安全修改集合，UI可实时更新且无卡顿。

方案二：封装线程安全的ObservableCollection子类 #

实现一个自动处理线程切换的集合，Logger直接使用该集合，调用方无需关心线程问题：

public class ThreadSafeObservableCollection<T> : ObservableCollection<T>
{
    private readonly object _lock = new object();
    private readonly Dispatcher _uiDispatcher;

    public ThreadSafeObservableCollection()
    {
        _uiDispatcher = Application.Current.Dispatcher;
    }

    protected override void InsertItem(int index, T item)
    {
        ExecuteOnUiThread(() => base.InsertItem(index, item));
    }

    protected override void RemoveItem(int index)
    {
        ExecuteOnUiThread(() => base.RemoveItem(index));
    }

    protected override void SetItem(int index, T item)
    {
        ExecuteOnUiThread(() => base.SetItem(index, item));
    }

    protected override void ClearItems()
    {
        ExecuteOnUiThread(base.ClearItems);
    }

    private void ExecuteOnUiThread(Action action)
    {
        if (_uiDispatcher.CheckAccess())
        {
            action();
        }
        else
        {
            // 高频调用场景可改用BeginInvoke异步执行
            _uiDispatcher.Invoke(action);
        }
    }
}

修改Logger的集合类型：

public class Logger
{
    private static readonly Logger _instance = new Logger();
    public static Logger Instance => _instance;

    private readonly ThreadSafeObservableCollection<LogEntry> _logEntries = new ThreadSafeObservableCollection<LogEntry>();

    public ThreadSafeObservableCollection<LogEntry> LogEntries => _logEntries;

    private Logger() { }

    public void Add(LogEntry entry)
    {
        _logEntries.Add(entry);
    }
}

这种方式对现有代码入侵最小，后台线程直接调用Logger.Add即可。

方案三：Logger内部自动切换到Dispatcher线程更新 #

如果不想修改集合类型，可在Add方法内部判断线程并切换：

public class Logger
{
    private static readonly Logger _instance = new Logger();
    public static Logger Instance => _instance;

    private readonly ObservableCollection<LogEntry> _logEntries = new ObservableCollection<LogEntry>();
    private readonly Dispatcher _uiDispatcher = Application.Current.Dispatcher;

    public ObservableCollection<LogEntry> LogEntries => _logEntries;

    private Logger() { }

    public void Add(LogEntry entry)
    {
        if (_uiDispatcher.CheckAccess())
        {
            _logEntries.Add(entry);
        }
        else
        {
            // 批量日志场景可缓存后一次性提交，减少Dispatcher调用
            _uiDispatcher.Invoke(() => _logEntries.Add(entry));
        }
    }
}

内容的提问来源于stack exchange，提问作者K.S.