Bearbeiten von Wörterbuchwerten in einer foreach-Schleife

Ich versuche, ein Kreisdiagramm aus einem Wörterbuch zu erstellen. Bevor ich das Kreisdiagramm anzeige, möchte ich die Daten aufräumen. Ich entferne alle Kuchenstücke, die weniger als 5% des Kuchens ausmachen, und lege sie in ein "anderes" Kuchenstück. Allerdings bekomme ich Collection was modified; enumeration operation may not executezur Laufzeit eine Ausnahme.

Ich verstehe, warum Sie keine Elemente zu einem Wörterbuch hinzufügen oder daraus entfernen können, während Sie darüber iterieren. Ich verstehe jedoch nicht, warum Sie einen Wert für einen vorhandenen Schlüssel in der foreach-Schleife nicht einfach ändern können.

Vorschläge zur Korrektur meines Codes sind willkommen.

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

Durch das Festlegen eines Werts in einem Wörterbuch wird die interne "Versionsnummer" aktualisiert, wodurch der Iterator und alle mit der Schlüssel- oder Wertsammlung verknüpften Iteratoren ungültig werden.

Ich verstehe Ihren Standpunkt, aber gleichzeitig wäre es seltsam, wenn sich die Wertsammlung während der Iteration ändern könnte - und der Einfachheit halber gibt es nur eine Versionsnummer.

Die normale Methode zur Behebung dieser Probleme besteht darin, entweder die Schlüsselsammlung im Voraus zu kopieren und über die Kopie zu iterieren oder die ursprüngliche Sammlung zu durchlaufen, aber eine Sammlung von Änderungen beizubehalten, die Sie nach Abschluss der Iteration anwenden.

Beispielsweise:

Schlüssel zuerst kopieren

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

Oder...

Erstellen einer Liste mit Änderungen

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

Rufen Sie die ToList()in derforeach Schleife. Auf diese Weise benötigen wir keine temporäre Variablenkopie. Dies hängt von Linq ab, das seit .Net 3.5 verfügbar ist.

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

Sie ändern die Sammlung in dieser Zeile:

colStates [Schlüssel] = 0;

Auf diese Weise löschen Sie an dieser Stelle im Wesentlichen etwas und fügen es wieder ein (soweit es IEnumerable betrifft.

Wenn Sie ein Mitglied bearbeiten des Wertes den Sie speichern, wäre das in Ordnung, aber Sie bearbeiten den Wert selbst und IEnumberable gefällt das nicht.

Die Lösung, die ich verwendet habe, besteht darin, die foreach-Schleife zu entfernen und nur eine for-Schleife zu verwenden. Eine einfache for-Schleife sucht nicht nach Änderungen, von denen Sie wissen, dass sie die Sammlung nicht beeinflussen.

So könnten Sie es machen:

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

Sie können weder die Schlüssel noch die Werte direkt in einem ForEach ändern, aber Sie können deren Mitglieder ändern. ZB sollte das funktionieren:

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

Wie wäre es, wenn Sie nur einige Linq-Abfragen für Ihr Wörterbuch durchführen und dann Ihr Diagramm an die Ergebnisse dieser Wörter binden? ...

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

Wenn Sie sich kreativ fühlen, können Sie so etwas tun. Durchlaufen Sie das Wörterbuch rückwärts, um Ihre Änderungen vorzunehmen.

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

}

Sicher nicht identisch, aber Sie könnten trotzdem interessiert sein ...

Sie müssen ein neues Wörterbuch aus dem alten erstellen, anstatt es zu ändern. Etwas wie (iterieren Sie auch über das KeyValuePair <,> anstatt eine Schlüsselsuche zu verwenden:

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;

Beginnend mit .NET 4.5 Mit ConcurrentDictionary können Sie dies tun :

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

Beachten Sie jedoch, dass seine Leistung tatsächlich viel schlechter ist als eine einfache 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>();
    }
}

Ergebnis:

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

Sie können die Sammlung nicht ändern, nicht einmal die Werte. Sie können diese Fälle speichern und später entfernen. Es würde so enden:

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

Haftungsausschluss: Ich mache nicht viel C #

Sie versuchen, das DictionaryEntry-Objekt zu ändern, das in der HashTable gespeichert ist. In der Hashtabelle wird nur ein Objekt gespeichert - Ihre Instanz von DictionaryEntry. Das Ändern des Schlüssels oder des Werts reicht aus, um die HashTable zu ändern und den Enumerator ungültig zu machen.

Sie können dies außerhalb der Schleife tun:

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

Erstellen Sie zunächst eine Liste aller Schlüssel der Werte, die Sie ändern möchten, und durchlaufen Sie stattdessen diese Liste.

Sie können eine Listenkopie von erstellen dict.Valuesund dann die List.ForEachLambda-Funktion für die Iteration verwenden (oder eine foreachSchleife, wie zuvor vorgeschlagen).

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

Zusammen mit den anderen Antworten dachte ich, ich würde beachten, dass Sie, wenn Sie sie erhalten sortedDictionary.Keysoder sortedDictionary.Valuesdann foreachdurchlaufen, sie auch in sortierter Reihenfolge durchlaufen. Dies liegt daran, dass diese Methoden System.Collections.Generic.SortedDictionary<TKey,TValue>.KeyCollectionoder SortedDictionary<TKey,TValue>.ValueCollectionObjekte zurückgeben, die die Art des ursprünglichen Wörterbuchs beibehalten.

Diese Antwort dient zum Vergleich zweier Lösungen, nicht als Lösungsvorschlag.

Anstatt eine andere Liste zu erstellen, wie in anderen Antworten vorgeschlagen, können Sie eine forSchleife verwenden, die das Wörterbuch Countfür die Schleifenstoppbedingung und Keys.ElementAt(i)zum Abrufen des Schlüssels verwendet.

for (int i = 0; i < dictionary.Count; i++)
{
    dictionary[dictionary.Keys.ElementAt(i)] = 0;
}

Bei firs dachte ich, das wäre effizienter, weil wir keine Schlüsselliste erstellen müssen. Nach einem Test stellte ich fest, dass die forSchleifenlösung viel weniger ist effizient ist. Bei Liste auf meinem PC.

Prüfung:

int iterations = 10;
int dictionarySize = 10000;
Stopwatch sw = new Stopwatch();

Console.WriteLine("Creating dictionary...");
Dictionary<string, int> dictionary = new Dictionary<string, int>(dictionarySize);
for (int i = 0; i < dictionarySize; i++)
{
    dictionary.Add(i.ToString(), i);
}
Console.WriteLine("Done");

Console.WriteLine("Starting tests...");

// for loop test
sw.Restart();
for (int i = 0; i < iterations; i++)
{
    for (int j = 0; j < dictionary.Count; j++)
    {
        dictionary[dictionary.Keys.ElementAt(j)] = 3;
    }
}
sw.Stop();
Console.WriteLine($"for loop Test:     {sw.ElapsedMilliseconds} ms");

// foreach loop test
sw.Restart();
for (int i = 0; i < iterations; i++)
{
    foreach (string key in dictionary.Keys.ToList())
    {
        dictionary[key] = 3;
    }
}
sw.Stop();
Console.WriteLine($"foreach loop Test: {sw.ElapsedMilliseconds} ms");

Console.WriteLine("Done");

Ergebnisse:

Creating dictionary...
Done
Starting tests...
for loop Test:     2367 ms
foreach loop Test: 3 ms
Done