Se modificó la colección; la operación de enumeración puede no ejecutarse

Lo que probablemente suceda es que SignalData está cambiando indirectamente el diccionario de los suscriptores bajo el capó durante el ciclo y conduce a ese mensaje. Puede verificar esto cambiando

foreach(Subscriber s in subscribers.Values)

A

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

Si tengo razón, el problema desaparecerá.

llamar subscribers.Values.ToList() copia los valores de subscribers.Values a una lista separada al comienzo de la foreach. Nada más tiene acceso a esta lista (¡ni siquiera tiene un nombre de variable!), Por lo que nada puede modificarlo dentro del ciclo.

Cuando un suscriptor se da de baja, está cambiando el contenido de la colección de suscriptores durante la enumeración.

Hay varias formas de solucionar este problema, una de las cuales es cambiar el bucle for para usar un código explícito. .ToList():

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

Una forma más eficiente, en mi opinión, es tener otra lista en la que declaras que pones todo lo que "se eliminará". Luego, después de terminar su ciclo principal (sin el .ToList ()), realiza otro ciclo sobre la lista "para ser eliminado", eliminando cada entrada a medida que sucede. Entonces en tu clase agregas:

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

Luego lo cambia a:

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

Esto no solo resolverá su problema, sino que evitará que tenga que seguir creando una lista desde su diccionario, lo cual es costoso si hay muchos suscriptores allí. Suponiendo que la lista de suscriptores que se eliminarán en cualquier iteración dada es menor que el número total de la lista, esto debería ser más rápido. Pero, por supuesto, no dude en perfilarlo para asegurarse de que ese sea el caso si hay alguna duda en su situación de uso específica.

También puede bloquear el diccionario de sus suscriptores para evitar que se modifique cada vez que se repita:

 lock (subscribers)
 {
         foreach (var subscriber in subscribers)
         {
               //do something
         }
 }

¿Por qué este error?

En general, las colecciones .Net no admiten que se enumeren y modifiquen al mismo tiempo. Si intenta modificar la lista de colecciones durante la enumeración, genera una excepción. Entonces, el problema detrás de este error es que no podemos modificar la lista / diccionario mientras recorremos el mismo.

Una de las soluciones

Si iteramos un diccionario usando una lista de sus claves, en paralelo podemos modificar el objeto diccionario, ya que estamos iterando a través de la colección de claves y no del diccionario (e iterando su colección de claves).

Ejemplo

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

Aquí hay una blog sobre esta solución.

Y para una inmersión profunda en StackOverflow: ¿Por qué ocurre este error?

Bien, lo que me ayudó fue iterar al revés. Estaba tratando de eliminar una entrada de una lista pero iterando hacia arriba y arruinó el ciclo porque la entrada ya no existía:

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

En realidad, el problema me parece que está eliminando elementos de la lista y espera continuar leyendo la lista como si nada hubiera pasado.

Lo que realmente necesitas hacer es empezar desde el final y volver al principio. Incluso si elimina elementos de la lista, podrá seguir leyendo.

Excepción de operación no válida- Se ha producido una InvalidOperationException. Informa que una "colección fue modificada" en un bucle foreach

Utilice la declaración de ruptura, una vez que se elimina el objeto.

ex:

ArrayList list = new ArrayList(); 

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

La respuesta aceptada es imprecisa e incorrecta en el peor de los casos. Si se realizan cambios durante ToList(), aún puede terminar con un error. además lock, cuyo rendimiento y seguridad de subprocesos deben tenerse en cuenta si tiene un miembro público, se puede usar una solución adecuada tipos inmutables.

En general, un tipo inmutable significa que no puede cambiar su estado una vez creado. Entonces su código debería verse así:

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
        }
    }
    //.........
}

Esto puede resultar especialmente útil si tiene un miembro público. Otras clases siempre pueden foreach en los tipos inmutables sin preocuparse de que se modifique la colección.

Tuve el mismo problema y se resolvió cuando usé un for bucle en lugar de 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);
}

He visto muchas opciones para esto, pero para mí esta fue la mejor.

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

Luego, simplemente recorre la colección.

Tenga en cuenta que ListItemCollection puede contener duplicados. De forma predeterminada, nada impide que se agreguen duplicados a la colección. Para evitar duplicados, puede hacer esto:

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

Aquí hay un escenario específico que justifica un enfoque especializado:

1. LA Dictionary se enumera con frecuencia.
2. LA Dictionary se modifica con poca frecuencia.

En este escenario, crear una copia del Dictionary (O la Dictionary.Values) antes de cada enumeración puede resultar bastante costoso. Mi idea para resolver este problema es reutilizar la misma copia en caché en múltiples enumeraciones y ver una IEnumerator del original Dictionary para excepciones. El enumerador se almacenará en caché junto con los datos copiados y se interrogará antes de comenzar una nueva enumeración. En caso de una excepción, la copia en caché se descartará y se creará una nueva. Aquí está mi implementación de esta 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);
}

Ejemplo de uso:

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)
{
    //...
}

Desafortunadamente, esta idea no se puede usar actualmente con la clase. Dictionary en .NET Core 3.0, porque esta clase no lanza un La colección fue modificada excepción cuando se enumeran y los métodos Remove y Clear se invocan. Todos los demás contenedores que verifiqué se comportan de manera consistente. Verifiqué sistemáticamente estas clases: List<T>, Collection<T>, ObservableCollection<T>, HashSet<T>, SortedSet<T>, Dictionary<T,V> y SortedDictionary<T,V>. Sólo los dos métodos antes mencionados de la Dictionary class en .NET Core no invalidan la enumeración.

Actualizar: Solucioné el problema anterior comparando también las longitudes de la colección en caché y la original. Esta corrección asume que el diccionario se pasará directamente como un argumento a la EnumerableSnapshot's constructor, y su identidad no estará oculta por (por ejemplo) una proyección como: dictionary.Select(e => e).ΤοEnumerableSnapshot().

Importante: La clase anterior es no a salvo de amenazas. Está destinado a ser utilizado a partir de código que se ejecuta exclusivamente en un solo hilo.

Quiero señalar otro caso que no se refleja en ninguna de las respuestas. tengo un Dictionary<Tkey,TValue> compartido en una aplicación de subprocesos múltiples, que utiliza un ReaderWriterLockSlim para proteger las operaciones de lectura y escritura. Este es un método de lectura que lanza la excepción:

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

En general, funciona bien, pero de vez en cuando obtengo la excepción. El problema es una sutileza de LINQ: este código devuelve un IEnumerable<Info>, que aún no se enumera después de salir de la sección protegida por el candado. Por lo tanto, otros subprocesos pueden cambiarlo antes de enumerarlo, lo que lleva a la excepción. La solución es forzar la enumeración, por ejemplo con .ToList() como se muestra en el comentario. De esta forma, el enumerable ya está enumerado antes de salir de la sección protegida.

Por lo tanto, si usa LINQ en una aplicación multiproceso, tenga en cuenta que debe materializar siempre las consultas antes de salir de las regiones protegidas.

Puede copiar el objeto de diccionario de los suscriptores a un mismo tipo de objeto de diccionario temporal y luego iterar el objeto de diccionario temporal usando el bucle foreach.

Entonces, una forma diferente de resolver este problema sería en lugar de eliminar los elementos, crear un nuevo diccionario y solo agregar los elementos que no desea eliminar y luego reemplazar el diccionario original con el nuevo. No creo que esto sea un problema de eficiencia demasiado grande porque no aumenta la cantidad de veces que se itera sobre la estructura.

Hay un enlace donde se elaboró ​​muy bien y también se da una solución. Pruébelo si tiene la solución adecuada, publique aquí para que otros puedan entender. Dada la solución está bien, entonces me gusta la publicación para que otros puedan probar esta solución.

para su referencia enlace original: - https://bensonxion.wordpress.com/2012/05/07/serializing-an-ienumerable-produces-collection-was-modified-enumeration-operation-may-not-execute/

Cuando usamos clases de serialización .Net para serializar un objeto donde su definición contiene un tipo Enumerable, es decir, colección, obtendrá fácilmente InvalidOperationException que dice "La colección fue modificada; la operación de enumeración puede no ejecutarse" donde su codificación está en escenarios de múltiples subprocesos. La causa final es que las clases de serialización iterarán a través de la colección a través del enumerador, como tal, el problema radica en intentar iterar a través de una colección mientras la modifica.

Primera solución, podemos simplemente usar el bloqueo como una solución de sincronización para asegurarnos de que la operación al objeto List solo se pueda ejecutar desde un hilo a la vez. Obviamente, obtendrá una penalización de rendimiento que si desea serializar una colección de ese objeto, se aplicará el bloqueo para cada uno de ellos.

Bueno, .Net 4.0, que hace que lidiar con escenarios de subprocesos múltiples sea útil. Para este problema de serialización del campo Colección, descubrí que podemos aprovechar la clase ConcurrentQueue (Check MSDN), que es una colección FIFO segura para subprocesos y hace que el código no se bloquee.

Usando esta clase, en su simplicidad, las cosas que necesita modificar para su código están reemplazando el tipo de colección con él, use Enqueue para agregar un elemento al final de ConcurrentQueue, elimine esos códigos de bloqueo. O, si el escenario en el que está trabajando requiere elementos de recopilación como List, necesitará un poco más de código para adaptar ConcurrentQueue a sus campos.

Por cierto, ConcurrentQueue no tiene un método Clear debido al algoritmo subyacente que no permite la limpieza atómica de la colección. por lo que debe hacerlo usted mismo, la forma más rápida es volver a crear una nueva ConcurrentQueue vacía para reemplazarla.

Esta forma debería cubrir una situación de simultaneidad cuando la función se vuelve a llamar mientras aún se está ejecutando (y los elementos deben usarse solo una vez):

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

Si se llama a la función mientras aún se está ejecutando, los elementos no se repetirán desde el primero de nuevo, ya que se eliminarán tan pronto como se usen. No debería afectar mucho al rendimiento para listas pequeñas.