我想指出另一个没有在答案中反映出来的例子。我有一个字典<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，请注意始终在离开受保护区域之前实现查询。

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

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

ex:

ArrayList list = new ArrayList(); 

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

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

我想指出另一个没有在答案中反映出来的例子。我有一个字典<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，请注意始终在离开受保护区域之前实现查询。

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

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

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()。

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

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

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);
            }