可能发生的情况是，SignalData在循环过程中间接地更改了订阅者字典，并导致了该消息。您可以通过更改来验证这一点

foreach(Subscriber s in subscribers.Values)

To

foreach(Subscriber s in subscribers.Values.ToList())

如果我是对的，问题就会消失。

调用subscriber . values . tolist()复制订阅者的值。值赋给foreach开始时的单独列表。其他任何东西都不能访问这个列表(它甚至没有变量名!)，所以在循环中没有东西可以修改它。

订阅者取消订阅时，您正在枚举期间更改订阅者集合的内容。

有几种方法可以解决这个问题，其中一种是改变for循环，使用显式的.ToList():

public void NotifySubscribers(DataRecord sr)  
{
    foreach(Subscriber s in subscribers.Values.ToList())
    {
                                              ^^^^^^^^^  
        ...

在我看来，一个更有效的方法是另一个列表，你声明你把任何“要删除”的东西都放进去。然后，在完成主循环之后(不使用. tolist())，对“要删除的”列表执行另一个循环，删除每个条目。所以在你的课上你要加上:

private List<Guid> toBeRemoved = new List<Guid>();

然后你把它改成:

public void NotifySubscribers(DataRecord sr)
{
    toBeRemoved.Clear();

    ...your unchanged code skipped...

   foreach ( Guid clientId in toBeRemoved )
   {
        try
        {
            subscribers.Remove(clientId);
        }
        catch(Exception e)
        {
            System.Diagnostics.Debug.WriteLine("Unsubscribe Error " + 
                e.Message);
        }
   }
}

...your unchanged code skipped...

public void UnsubscribeEvent(Guid clientId)
{
    toBeRemoved.Add( clientId );
}

这不仅可以解决您的问题，还可以防止您从字典中创建一个列表，如果其中有很多订阅者，那么创建列表的代价非常昂贵。假设在任何给定迭代中要删除的订阅者列表低于列表中的总数，这样应该更快。当然，如果您在特定的使用情况中有任何疑问，请随意对其进行分析以确保情况属实。

实际上，在我看来，问题似乎是您正在从列表中删除元素，并期望继续读取列表，就像什么都没有发生一样。

你真正需要做的是从头开始，再回到起点。即使您从列表中删除了元素，也可以继续读取它。

可以将订阅者字典对象复制到相同类型的临时字典对象，然后使用foreach循环迭代该临时字典对象。

因此，解决这个问题的另一种方法是创建一个新的字典，而不是删除元素，只添加你不想删除的元素，然后用新的字典替换原来的字典。我不认为这是一个太大的效率问题，因为它不会增加你迭代结构的次数。

我也有同样的问题，当我使用for循环而不是foreach时，它得到了解决。

// foreach (var item in itemsToBeLast)
for (int i = 0; i < itemsToBeLast.Count; i++)
{
    var matchingItem = itemsToBeLast.FirstOrDefault(item => item.Detach);

   if (matchingItem != null)
   {
      itemsToBeLast.Remove(matchingItem);
      continue;
   }
   allItems.Add(itemsToBeLast[i]);// (attachDetachItem);
}

为什么会出现这个错误?

一般来说。net集合不支持同时被枚举和修改。如果在枚举期间试图修改集合列表，则会引发异常。所以这个错误背后的问题是，当我们循环遍历列表/字典时，我们不能修改它。

其中一个解决方案

如果使用字典的键列表迭代字典，则可以在遍历键集合和时同时修改字典对象 不是字典(以及迭代它的键集合)。

例子

//get key collection from dictionary into a list to loop through
List<int> keys = new List<int>(Dictionary.Keys);

// iterating key collection using a simple for-each loop
foreach (int key in keys)
{
  // Now we can perform any modification with values of the dictionary.
  Dictionary[key] = Dictionary[key] - 1;
}

这里有一篇关于这个解决方案的博客文章。

并深入研究StackOverflow:为什么会发生此错误?

我见过很多这样的选择，但对我来说，这是最好的。

ListItemCollection collection = new ListItemCollection();
        foreach (ListItem item in ListBox1.Items)
        {
            if (item.Selected)
                collection.Add(item);
        }

然后简单地遍历集合。

注意，ListItemCollection可以包含重复项。默认情况下，没有任何东西阻止将副本添加到集合中。为了避免重复，你可以这样做:

ListItemCollection collection = new ListItemCollection();
            foreach (ListItem item in ListBox1.Items)
            {
                if (item.Selected && !collection.Contains(item))
                    collection.Add(item);
            }

InvalidOperationException - 发生了InvalidOperationException。它报告foreach循环中的“集合被修改”

使用break语句，一旦对象被移除。

ex:

ArrayList list = new ArrayList(); 

foreach (var item in list)
{
    if(condition)
    {
        list.remove(item);
        break;
    }
}

好的，帮助我的是向后迭代。我试图从列表中删除一个条目，但向上迭代，它搞砸了循环，因为该条目不再存在了:

for (int x = myList.Count - 1; x > -1; x--)
{
    myList.RemoveAt(x);
}

其中有一个环节阐述得很好，并给出了解决方案。 尝试一下，如果你有合适的解决方案，请张贴在这里，这样其他人就能理解。 给出的解决方案是可以的，然后像帖子一样，所以其他人可以尝试这些解决方案。

供您参考原始链接:- https://bensonxion.wordpress.com/2012/05/07/serializing-an-ienumerable-produces-collection-was-modified-enumeration-operation-may-not-execute/

当我们使用. net Serialization类来序列化一个对象时，它的定义包含一个Enumerable类型，即。 集合时，你会很容易得到InvalidOperationException，上面写着“集合被修改了; 如果您的代码是在多线程场景下，则枚举操作可能无法执行。 最根本的原因是，序列化类将通过枚举器遍历集合，就像这样， 问题在于在修改集合时尝试遍历它。

第一种解决方案，我们可以简单地使用锁作为同步解决方案来确保这一点 对List对象的操作一次只能从一个线程执行。 显然，你会受到性能惩罚 如果您想序列化该对象的一个集合，那么对于它们中的每一个，都将应用锁。

net 4.0使处理多线程场景变得很方便。 对于这个序列化收集字段的问题，我发现我们可以从ConcurrentQueue(检查MSDN)类中获益， 这是一个线程安全的FIFO集合，并使代码无锁。

使用这个类，在它的简单性中，你需要为你的代码修改的东西是用它替换Collection类型， 使用Enqueue添加一个元素到ConcurrentQueue的末尾，删除那些锁代码。 或者，如果您正在处理的场景确实需要像List这样的集合，那么您将需要更多的代码来将ConcurrentQueue调整到字段中。

顺便说一句，ConcurrentQueue doesnât有一个清除方法，因为底层算法doesnât允许原子地清除集合。 所以你必须自己做，最快的方法是重新创建一个新的空的ConcurrentQueue来替换。

公认的答案在最坏的情况下是不精确和不正确的。如果在ToList()期间进行了更改，您仍然会得到一个错误。除了锁(如果您有一个公共成员，则需要考虑锁的性能和线程安全性)之外，一个合适的解决方案是使用不可变类型。

一般来说，不可变类型意味着一旦创建了它，就不能更改它的状态。 所以你的代码应该是这样的:

public class SubscriptionServer : ISubscriptionServer
{
    private static ImmutableDictionary<Guid, Subscriber> subscribers = ImmutableDictionary<Guid, Subscriber>.Empty;
    public void SubscribeEvent(string id)
    {
        subscribers = subscribers.Add(Guid.NewGuid(), new Subscriber());
    }
    public void NotifyEvent()
    {
        foreach(var sub in subscribers.Values)
        {
            //.....This is always safe
        }
    }
    //.........
}

如果您有一个公共成员，这可能特别有用。其他类总是可以对不可变类型进行foreach，而不用担心集合被修改。

下面是一个特定的场景，需要使用专门的方法:

字典经常被列举出来。 字典很少被修改。

In this scenario creating a copy of the Dictionary (or the Dictionary.Values) before every enumeration can be quite costly. My idea about solving this problem is to reuse the same cached copy in multiple enumerations, and watch an IEnumerator of the original Dictionary for exceptions. The enumerator will be cached along with the copied data, and interrogated before starting a new enumeration. In case of an exception the cached copy will be discarded, and a new one will be created. Here is my implementation of this idea:

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;

public class EnumerableSnapshot<T> : IEnumerable<T>, IDisposable
{
    private IEnumerable<T> _source;
    private IEnumerator<T> _enumerator;
    private ReadOnlyCollection<T> _cached;

    public EnumerableSnapshot(IEnumerable<T> source)
    {
        _source = source ?? throw new ArgumentNullException(nameof(source));
    }

    public IEnumerator<T> GetEnumerator()
    {
        if (_source == null) throw new ObjectDisposedException(this.GetType().Name);
        if (_enumerator == null)
        {
            _enumerator = _source.GetEnumerator();
            _cached = new ReadOnlyCollection<T>(_source.ToArray());
        }
        else
        {
            var modified = false;
            if (_source is ICollection collection) // C# 7 syntax
            {
                modified = _cached.Count != collection.Count;
            }
            if (!modified)
            {
                try
                {
                    _enumerator.MoveNext();
                }
                catch (InvalidOperationException)
                {
                    modified = true;
                }
            }
            if (modified)
            {
                _enumerator.Dispose();
                _enumerator = _source.GetEnumerator();
                _cached = new ReadOnlyCollection<T>(_source.ToArray());
            }
        }
        return _cached.GetEnumerator();
    }

    public void Dispose()
    {
        _enumerator?.Dispose();
        _enumerator = null;
        _cached = null;
        _source = null;
    }

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

public static class EnumerableSnapshotExtensions
{
    public static EnumerableSnapshot<T> ToEnumerableSnapshot<T>(
        this IEnumerable<T> source) => new EnumerableSnapshot<T>(source);
}

使用的例子:

private static IDictionary<Guid, Subscriber> _subscribers;
private static EnumerableSnapshot<Subscriber> _subscribersSnapshot;

//...(in the constructor)
_subscribers = new Dictionary<Guid, Subscriber>();
_subscribersSnapshot = _subscribers.Values.ToEnumerableSnapshot();

// ...(elsewere)
foreach (var subscriber in _subscribersSnapshot)
{
    //...
}

Unfortunately this idea cannot be used currently with the class Dictionary in .NET Core 3.0, because this class does not throw a Collection was modified exception when enumerated and the methods Remove and Clear are invoked. All other containers I checked are behaving consistently. I checked systematically these classes: List<T>, Collection<T>, ObservableCollection<T>, HashSet<T>, SortedSet<T>, Dictionary<T,V> and SortedDictionary<T,V>. Only the two aforementioned methods of the Dictionary class in .NET Core are not invalidating the enumeration.

更新:通过比较缓存和原始集合的长度，我修复了上述问题。这个修正假设字典将直接作为参数传递给EnumerableSnapshot的构造函数，并且它的标识不会被(例如)像:dictionary这样的投影隐藏。选择(e => e).ΤοEnumerableSnapshot()。

重要:上面的类不是线程安全的。它旨在从专门运行在单个线程中的代码中使用。

这种方法应该可以覆盖在函数仍在执行时再次调用(并且项只需要使用一次)的并发情况:

 while (list.Count > 0)
 {
    string Item = list[0];
    list.RemoveAt(0);
 
    // do here what you need to do with item
 
 } 
 

如果函数在仍在执行时被调用，则项目将不会从第一次再次重申，因为它们在使用时立即被删除。 对于小列表应该不会对性能产生太大影响。

我想指出另一个没有在答案中反映出来的例子。我有一个字典<Tkey,TValue>共享在一个多线程应用程序，它使用ReaderWriterLockSlim来保护读写操作。这是一个引发异常的读取方法:

public IEnumerable<Data> GetInfo()
{
    List<Data> info = null;
    _cacheLock.EnterReadLock();
    try
    {
        info = _cache.Values.SelectMany(ce => ce.Data); // Ad .Tolist() to avoid exc.
    }
    finally
    {
        _cacheLock.ExitReadLock();
    }
    return info;
}

一般来说，它工作得很好，但有时会出现异常。这个问题是LINQ的一个微妙之处:这段代码返回一个IEnumerable<Info>，它在离开锁保护的部分后仍然没有被枚举。因此，它可以在被枚举之前由其他线程更改，从而导致异常。解决方案是强制枚举，例如注释中显示的. tolist()。这样，可枚举对象在离开受保护的部分之前就已经被枚举了。

因此，如果在多线程应用程序中使用LINQ，请注意始终在离开受保护区域之前实现查询。