System.InvalidOperationException: Collection was modified; enumeration operation may not execute.
我正在对一个不在UI线程上的ObservableCollection进行添加/删除操作。
我有一个名为EnqueueReport的方法用于添加到集合中，以及一个名为DequeueReport的方法用于从集合中删除。
步骤如下：
我在C#库方面了解不多。请问有人能够指导我吗?
从 .net framework 4.5 开始，您可以使用本地集合同步。
BindingOperations.EnableCollectionSynchronization(YourCollection, YourLockObject);
YourLockObject 是任何对象的实例，例如 new Object();。每个集合使用一个锁对象。
这样可以省去某些特殊类或其他东西的需要。只需启用并享受它 ;)
[编辑] 正如 Mark 和 Ed 在评论中所述（感谢澄清！），这并不意味着在更新时可以免除锁定集合，因为它只同步集合视图绑定，而不能使集合本身神奇地变成线程安全。 [/编辑]
PS：BindingOperations 位于命名空间 System.Windows.Data 中。
lock(YourLockObject){...}。也就是说，即使您“只从一个线程调用”，请明确UI线程已经参与其中，因此如果您在其他线程上（或可能在其他线程上），则需要进行锁定。 - ToolmakerSteve在这里发布的Franck解决方案适用于一个线程添加内容的情况，但ObservableCollection本身（以及它基于的List）并不是线程安全的。如果有多个线程同时写入集合中，可能会引入难以跟踪的错误。我编写了一个版本的ObservableCollection，使用ReaderWriteLockSlim来确保真正的线程安全。
不幸的是，由于达到了StackOverflow字符限制，所以在PasteBin上发布了代码。 这个版本可以完美地处理多个读取器/写入器。与常规的ObservableCollection一样，在从其回调的线程（接收到回调的线程）中修改集合是无效的。
你可以创建一个简单的线程友好版本的可观察集合，如下所示：
public class MTObservableCollection<T> : ObservableCollection<T>
{
public override event NotifyCollectionChangedEventHandler CollectionChanged;
protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
{
NotifyCollectionChangedEventHandler CollectionChanged = this.CollectionChanged;
if (CollectionChanged != null)
foreach (NotifyCollectionChangedEventHandler nh in CollectionChanged.GetInvocationList())
{
DispatcherObject dispObj = nh.Target as DispatcherObject;
if (dispObj != null)
{
Dispatcher dispatcher = dispObj.Dispatcher;
if (dispatcher != null && !dispatcher.CheckAccess())
{
dispatcher.BeginInvoke(
(Action)(() => nh.Invoke(this,
new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset))),
DispatcherPriority.DataBind);
continue;
}
}
nh.Invoke(this, e);
}
}
}
现在进行大规模的查找和替换，将所有ObservableCollection更改为MTObservableCollection，就可以继续了。
public class ObservableCollectionThreadSafe<T>
: ObservableCollection<T>, IDisposable
{
#region Data
private Dispatcher _dispatcher;
private ReaderWriterLockSlim _lock;
#endregion
#region Constructor
public ObservableCollectionThreadSafe()
{
_dispatcher = Dispatcher.CurrentDispatcher;
_lock = new ReaderWriterLockSlim();
}
#endregion
#region Overrides
/// <summary>
/// Clear all items
/// </summary>
protected override void ClearItems()
{
_dispatcher.InvokeIfRequired(() =>
{
_lock.EnterWriteLock();
try
{
base.ClearItems();
}
finally
{
_lock.ExitWriteLock();
}
}, DispatcherPriority.DataBind);
}
/// <summary>
/// Inserts an item
/// </summary>
protected override void InsertItem(int index, T item)
{
_dispatcher.InvokeIfRequired(() =>
{
if (index > this.Count)
return;
_lock.EnterWriteLock();
try
{
base.InsertItem(index, item);
}
finally
{
_lock.ExitWriteLock();
}
}, DispatcherPriority.DataBind);
}
/// <summary>
/// Moves an item
/// </summary>
protected override void MoveItem(int oldIndex, int newIndex)
{
_dispatcher.InvokeIfRequired(() =>
{
_lock.EnterReadLock();
int itemCount = this.Count;
_lock.ExitReadLock();
if (oldIndex >= itemCount |
newIndex >= itemCount |
oldIndex == newIndex)
return;
_lock.EnterWriteLock();
try
{
base.MoveItem(oldIndex, newIndex);
}
finally
{
_lock.ExitWriteLock();
}
}, DispatcherPriority.DataBind);
}
/// <summary>
/// Removes an item
/// </summary>
protected override void RemoveItem(int index)
{
_dispatcher.InvokeIfRequired(() =>
{
if (index >= this.Count)
return;
_lock.EnterWriteLock();
try
{
base.RemoveItem(index);
}
finally
{
_lock.ExitWriteLock();
}
}, DispatcherPriority.DataBind);
}
/// <summary>
/// Sets an item
/// </summary>
protected override void SetItem(int index, T item)
{
_dispatcher.InvokeIfRequired(() =>
{
_lock.EnterWriteLock();
try
{
base.SetItem(index, item);
}
finally
{
_lock.ExitWriteLock();
}
}, DispatcherPriority.DataBind);
}
#endregion
#region Public Methods
/// <summary>
/// Return as a cloned copy of this Collection
/// </summary>
public T[] ToSyncArray()
{
_lock.EnterReadLock();
try
{
T[] _sync = new T[this.Count];
this.CopyTo(_sync, 0);
return _sync;
}
finally
{
_lock.ExitReadLock();
}
}
#region IDisposable Support
private bool disposedValue = false; // To detect redundant calls
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
if (_lock != null)
_lock.Dispose();
}
// TODO: free unmanaged resources (unmanaged objects) and override a finalizer below.
// TODO: set large fields to null.
disposedValue = true;
}
}
// TODO: override a finalize only if Dispose(bool disposing) above has code to free unmanaged resources.
// ~ObservableCollectionThreadSafe() {
// // Do not change this code. Put cleanup code in Dispose(bool disposing) above.
// Dispose(false);
// }
// This code added to correctly implement the disposable pattern.
public void Dispose()
{
// Do not change this code. Put cleanup code in Dispose(bool disposing) above.
Dispose(true);
// TODO: uncomment the following line if the finalize is overridden above.
// GC.SuppressFinalize(this);
}
#endregion
#endregion
}
/// <summary>
/// WPF Threading extension methods
/// </summary>
public static class WPFControlThreadingExtensions
{
#region Public Methods
/// <summary>
/// A simple WPF threading extension method, to invoke a delegate
/// on the correct thread if it is not currently on the correct thread
/// Which can be used with DispatcherObject types
/// </summary>
/// <param name="disp">The Dispatcher object on which to do the Invoke</param>
/// <param name="performAction">The delegate to run</param>
/// <param name="priority">The DispatcherPriority</param>
public static void InvokeIfRequired(this Dispatcher disp,
Action performAction, DispatcherPriority priority)
{
if (disp.Thread != Thread.CurrentThread)
{
disp.Invoke(priority, performAction);
}
else
performAction();
}
#endregion
}
这是一个非常简短的解决方案。
在集合被初始化之后，加入以下内容：
Xamarin.Forms.BindingBase.EnableCollectionSynchronization(MyCollection, null, ObservableCollectionCallback);
void ObservableCollectionCallback(IEnumerable collection, object context, Action accessMethod, bool writeAccess)
{
// `lock` ensures that only one thread access the collection at a time
lock (collection)
{
accessMethod?.Invoke();
}
}