Edición de valores de diccionario en un bucle foreach

Question

Estoy intentando crear un gráfico circular de un diccionario. Antes de mostrar el gráfico circular, quiero ordenar los datos. Estoy eliminando los sectores de tarta que serían menos del 5% de la tarta y los coloco en un segmento de tarta "Otro". Sin embargo, recibo una excepción Collection was modified; enumeration operation may not execute en tiempo de ejecución.

Entiendo por qué no puede agregar o eliminar elementos de un diccionario mientras itera sobre ellos. Sin embargo, no entiendo por qué no puede simplemente cambiar un valor para una clave existente dentro del ciclo foreach.

Cualquier sugerencia re: arreglar mi código, sería apreciada.

Dictionary<string, int> colStates = new Dictionary<string,int>(); 
// ... 
// Some code to populate colStates dictionary 
// ... 

int OtherCount = 0; 

foreach(string key in colStates.Keys) 
{ 

    double Percent = colStates[key]/TotalCount; 

    if (Percent < 0.05) 
    { 
     OtherCount += colStates[key]; 
     colStates[key] = 0; 
    } 
} 

colStates.Add("Other", OtherCount); 

Answer 1

establecimiento de un valor en un diccionario actualiza su "número de versión" interno - que invalida el iterador, y cualquier iterador asociado con las claves o valores de la colección.

Veo su punto, pero al mismo tiempo sería extraño si la colección de valores pudiera cambiar a mitad de iteración, y para simplificar, solo hay un número de versión.

La forma normal de solucionar este tipo de cosas es copiar previamente la colección de claves e iterar sobre la copia, o iterar sobre la colección original, pero mantener una colección de cambios que aplicará después de que haya terminado iterando

Por ejemplo:

Copia de teclas primeros

List<string> keys = new List<string>(colStates.Keys); 
foreach(string key in keys) 
{ 
    double percent = colStates[key]/TotalCount;  
    if (percent < 0.05) 
    { 
     OtherCount += colStates[key]; 
     colStates[key] = 0; 
    } 
} 

O ...

Creación de una lista de modificaciones

List<string> keysToNuke = new List<string>(); 
foreach(string key in colStates.Keys) 
{ 
    double percent = colStates[key]/TotalCount;  
    if (percent < 0.05) 
    { 
     OtherCount += colStates[key]; 
     keysToNuke.Add(key); 
    } 
} 
foreach (string key in keysToNuke) 
{ 
    colStates[key] = 0; 
} 

Answer 2

Se necesitan para conformar e un nuevo diccionario de la antigua en lugar de modificar en su lugar. Somethine como (también iterar sobre la KeyValuePair <,> en lugar de utilizar una búsqueda de claves:

int otherCount = 0; 
int totalCounts = colStates.Values.Sum(); 
var newDict = new Dictionary<string,int>(); 
foreach (var kv in colStates) { 
    if (kv.Value/(double)totalCounts < 0.05) { 
    otherCount += kv.Value; 
    } else { 
    newDict.Add(kv.Key, kv.Value); 
    } 
} 
if (otherCount > 0) { 
    newDict.Add("Other", otherCount); 
} 

colStates = newDict; 

Answer 3

Negación: no hago mucho C#

Usted está tratando de modificar el objeto DictionaryEntry que se almacena en la HashTable. La Hashtable solo almacena un objeto: su instancia de DictionaryEntry. Cambiar la clave o el valor es suficiente para cambiar la HashTable y hacer que el enumerador se vuelva inválido.

Puede hacerlo fuera del ciclo:

if(hashtable.Contains(key)) 
{ 
    hashtable[key] = value; 
} 

creando primero una lista de todas las claves de los valores que desea cambiar e iterar a través de esa lista.

Answer 4

No puede modificar la colección, ni siquiera los valores. Puede guardar estos casos y eliminarlos más tarde.Que terminaría de esta manera:

 Dictionary<string, int> colStates = new Dictionary<string, int>(); 
     // ... 
     // Some code to populate colStates dictionary 
     // ... 

     int OtherCount = 0; 
     List<string> notRelevantKeys = new List<string>(); 

     foreach (string key in colStates.Keys) 
     { 

      double Percent = colStates[key]/colStates.Count; 

      if (Percent < 0.05) 
      { 
       OtherCount += colStates[key]; 
       notRelevantKeys.Add(key); 
      } 
     } 

     foreach (string key in notRelevantKeys) 
     { 
      colStates[key] = 0; 
     } 

     colStates.Add("Other", OtherCount); 

Answer 5

Usted está modificando la colección en esta línea:

colStates [clave] = 0;

Al hacerlo, va a eliminar en esencia y volver a insertar algo en ese momento (por lo que IEnumerable se ocupa de todos modos.

Si edita un miembro del valor que está almacenando, que sería OK, pero está editando el valor en sí mismo y a IEnumberable no le gusta eso.

La solución que he usado es eliminar el bucle foreach y simplemente usar un ciclo for. Un bucle simple no verificará cambios que usted sabe que no afectarán a la colección.

Así es como podría hacerlo:

List<string> keys = new List<string>(colStates.Keys); 
for(int i = 0; i < keys.Count; i++) 
{ 
    string key = keys[i]; 
    double Percent = colStates[key]/TotalCount; 
    if (Percent < 0.05)  
    {   
     OtherCount += colStates[key]; 
     colStates[key] = 0;  
    } 
} 

Answer 6

no puede modificar las claves ni los valores directamente en un ParaCada, pero se puede modificar sus miembros. Por ejemplo, esto debería funcionar:

public class State { 
    public int Value; 
} 

... 

Dictionary<string, State> colStates = new Dictionary<string,State>(); 

int OtherCount = 0; 
foreach(string key in colStates.Keys) 
{ 
    double Percent = colStates[key].Value/TotalCount; 

    if (Percent < 0.05) 
    { 
     OtherCount += colStates[key].Value; 
     colStates[key].Value = 0; 
    } 
} 

colStates.Add("Other", new State { Value = OtherCount }); 

Answer 7

¿Qué tal hacer algunas consultas LINQ en contra de su diccionario, y luego ligar su gráfico con los resultados de los ...

var under = colStates.Where(c => (decimal)c.Value/(decimal)totalCount < .05M); 
var over = colStates.Where(c => (decimal)c.Value/(decimal)totalCount >= .05M); 
var newColStates = over.Union(new Dictionary<string, int>() { { "Other", under.Sum(c => c.Value) } }); 

foreach (var item in newColStates) 
{ 
    Console.WriteLine("{0}:{1}", item.Key, item.Value); 
} 

Answer 8

Si te sientes? creativo podrías hacer algo como esto. Regrese hacia atrás a través del diccionario para hacer sus cambios.

Dictionary<string, int> collection = new Dictionary<string, int>(); 
collection.Add("value1", 9); 
collection.Add("value2", 7); 
collection.Add("value3", 5); 
collection.Add("value4", 3); 
collection.Add("value5", 1); 

for (int i = collection.Keys.Count; i-- > 0;) { 
    if (collection.Values.ElementAt(i) < 5) { 
     collection.Remove(collection.Keys.ElementAt(i)); ; 
    } 

} 

Ciertamente no idéntica, pero que podría estar interesado de todos modos ...

Answer 9

Llame al ToList() en el bucle foreach. De esta forma, no necesitamos una copia variable temporal. Depende de Linq, que está disponible desde .Net 3.5.

using System.Linq; 

foreach(string key in colStates.Keys.ToList()) 
{ 
    double Percent = colStates[key]/TotalCount; 

    if (Percent < 0.05) 
    { 
     OtherCount += colStates[key]; 
     colStates[key] = 0; 
    } 
} 

Answer 10

se puede hacer una copia de la lista de dict.Values, a continuación, puede utilizar la función List.ForEach lambda para la iteración, (o un bucle foreach, según lo sugerido antes).

new List<string>(myDict.Values).ForEach(str => 
{ 
    //Use str in any other way you need here. 
    Console.WriteLine(str); 
}); 

Answer 11

A partir de .NET 4.5 Usted puede hacer esto con ConcurrentDictionary:

using System.Collections.Concurrent; 

var colStates = new ConcurrentDictionary<string,int>(); 
colStates["foo"] = 1; 
colStates["bar"] = 2; 
colStates["baz"] = 3; 

int OtherCount = 0; 
int TotalCount = 100; 

foreach(string key in colStates.Keys) 
{ 
    double Percent = (double)colStates[key]/TotalCount; 

    if (Percent < 0.05) 
    { 
     OtherCount += colStates[key]; 
     colStates[key] = 0; 
    } 
} 

colStates.TryAdd("Other", OtherCount); 

Nota sin embargo, que su rendimiento es en realidad mucho peor que un simple foreach dictionary.Kes.ToArray():

using System; 
using System.Collections.Concurrent; 
using System.Collections.Generic; 
using System.Linq; 
using BenchmarkDotNet.Attributes; 
using BenchmarkDotNet.Running; 

public class ConcurrentVsRegularDictionary 
{ 
    private readonly Random _rand; 
    private const int Count = 1_000; 

    public ConcurrentVsRegularDictionary() 
    { 
     _rand = new Random(); 
    } 

    [Benchmark] 
    public void ConcurrentDictionary() 
    { 
     var dict = new ConcurrentDictionary<int, int>(); 
     Populate(dict); 

     foreach (var key in dict.Keys) 
     { 
      dict[key] = _rand.Next(); 
     } 
    } 

    [Benchmark] 
    public void Dictionary() 
    { 
     var dict = new Dictionary<int, int>(); 
     Populate(dict); 

     foreach (var key in dict.Keys.ToArray()) 
     { 
      dict[key] = _rand.Next(); 
     } 
    } 

    private void Populate(IDictionary<int, int> dictionary) 
    { 
     for (int i = 0; i < Count; i++) 
     { 
      dictionary[i] = 0; 
     } 
    } 
} 

public class Program 
{ 
    public static void Main(string[] args) 
    { 
     BenchmarkRunner.Run<ConcurrentVsRegularDictionary>(); 
    } 
} 

Resultado:

   Method |  Mean |  Error | StdDev | 
--------------------- |----------:|----------:|----------:| 
ConcurrentDictionary | 182.24 us | 3.1507 us | 2.7930 us | 
      Dictionary | 47.01 us | 0.4824 us | 0.4512 us |