Коллекция была изменена; операция перечисления может не выполняться

Когда подписчик отказывается от подписки, Вы изменяете содержание набора Подписчиков во время перечисления.

существует несколько способов зафиксировать это, при этом один изменяющийся, чтобы цикл использовал явное .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 );
}

Это не только решит Вашу проблему, она будет препятствовать тому, чтобы Вы имели, чтобы продолжать создавать список из Вашего словаря, который является дорогим, если существует много подписчиков там. Принятие списка подписчиков, которые будут удалены на любом данном повторении, ниже, чем общее количество в списке, это должно быть быстрее. Но, конечно, не стесняйтесь представлять его, чтобы быть уверенными, что это имеет место, если существует сомнение в Вашей определенной ситуации с использованием.

Принятый ответ является неточным и неправильным в худшем случае. , Если изменения внесены во время ToList() , можно все еще закончить с ошибкой. Кроме того lock, какая производительность и потокобезопасность должны быть учтены, если у Вас есть общедоступный участник, надлежащее решение может использовать неизменные типы .

В целом, неизменный тип означает, что Вы не можете изменить состояние его когда-то созданный. Таким образом, Ваш код должен быть похожим:

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 на неизменных типах, не вызывая беспокойство об изменяемом наборе.

Вот определенный сценарий, который гарантирует специализированный подход:

1. Эти Dictionary часто перечисляется.
2. Эти Dictionary нечасто изменяется.

В этом сценарии, создающем копию Dictionary (или Dictionary.Values), прежде чем, каждое перечисление может быть довольно дорогостоящим. Моя идея о решении этой проблемы состоит в том, чтобы снова использовать ту же кэшируемую копию в нескольких перечислениях и смотреть IEnumerator из оригинала Dictionary для исключений. Перечислитель будет кэшироваться наряду со скопированными данными и опрашиваться прежде, чем запустить новое перечисление. В случае исключения будет отброшена кэшируемая копия, и будет создан новый. Вот моя реализация этой идеи:

public class SafeEnumerable<T> : IEnumerable<T>, IDisposable
{
    private IEnumerable<T> _source;
    private IEnumerator<T> _enumerator;
    private T[] _cached;

    public SafeEnumerable(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 = _source.ToArray();
        }
        else
        {
            var modified = false;
            if (_source is ICollection collection) // C# 7 syntax
            {
                modified = _cached.Length != collection.Count;
            }
            if (!modified)
            {
                try
                {
                    _enumerator.MoveNext();
                }
                catch (InvalidOperationException)
                {
                    modified = true;
                }
            }
            if (modified)
            {
                _enumerator.Dispose();
                _enumerator = _source.GetEnumerator();
                _cached = _source.ToArray();
            }
        }
        foreach (var item in _cached)
        {
            yield return item;
        }
    }

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

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

public static SafeEnumerable<T> AsSafeEnumerable<T>(this IEnumerable<T> source)
    => new SafeEnumerable<T>(source);

пример Использования:

private static IDictionary<Guid, Subscriber> _subscribers;
private static SafeEnumerable<Subscriber> _safeSubscribers;

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

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

, К сожалению, эта идея не может в настоящее время использоваться с классом Dictionary в.NET Core 3.0, потому что этот класс не бросает , Набор был изменен исключение при перечислении и методы Remove и Clear вызываются. Все другие контейнеры, которые я проверил, ведут себя последовательно. Я систематически проверял эти классы: List<T>, Collection<T>, ObservableCollection<T>, HashSet<T>, SortedSet<T>, Dictionary<T,V> и SortedDictionary<T,V>. Только два вышеупомянутых метода Dictionary класс в.NET Core не делают недействительным перечисление.

Обновление: я решил вышеупомянутую проблему путем сравнения также длин кэшируемого и исходного набора. Эта фиксация предполагает, что словарь будет передан непосредственно как аргумент SafeEnumerable конструктор, и его идентификационные данные не будут скрыты (например), проекцией как: dictionary.Select(e => e).AsSafeEnumerable().

Я лично недавно натыкался на это в незнакомом коде, где это было в открытом dbcontext с.Remove Linq (объект). У меня было адское время, определяя местоположение ошибки при отладке, потому что объект (объекты) был удален, в первый раз выполнив итерации, и если я пытался отступить и повторно переступить, набор был пуст, так как я был в том же контексте!