在 foreach 循环中编辑字典值

Question

我正在尝试从字典构建饼图。 在显示饼图之前，我想整理一下数据。 我将删除所有小于饼图 5% 的饼图切片，并将它们放入“其他”饼图切片中。 但是我收到一个 Collection was generated; 枚举操作在运行时可能会出现无法执行的异常。

我理解为什么在迭代字典时无法添加或删除字典中的项目。 但是我不明白为什么你不能简单地更改 foreach 循环中现有键的值。

任何关于修复我的代码的建议，将不胜感激。

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

除了其他答案之外，我想我会注意到，如果您获得 sortedDictionary.Keys 或 sortedDictionary.Values，然后使用 foreach 循环它们>，您也按排序顺序浏览。 这是因为这些方法返回 System.Collections.Generic.SortedDictionary.KeyCollection 或 SortedDictionary.ValueCollection 对象，它们维护原来的字典。

Answer 2

该答案用于比较两种解决方案，而不是建议的解决方案。

您可以使用 for 循环，使用字典 Count 作为循环停止条件，并使用 Keys.ElementAt(i)<，而不是像其他答案建议的那样创建另一个列表。 /code> 获取密钥。

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

起初我认为这会更有效，因为我们不需要创建密钥列表。 运行测试后，我发现 for 循环解决方案的效率低得多。 原因是因为 ElementAt 在 dictionary.Keys 属性上的复杂度为 O(n)，它从集合的开头搜索，直到找到第 n 个项目。

检测

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

结果：

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

Answer 3

让我添加我自己的方法。 我正在使用 Unity 并且肯定使用 Linq。

此代码将冷却时间值减一并清除任何为零的冷却时间，重建原始的 Dictionary

        // Decrement cooldowns 
        cooldowns = cooldowns
            .Select(x => new KeyValuePair<string, int>(x.Key, x.Value - 1))
            .Where(x => x.Value > 0)
            .ToDictionary(x => x.Key, x => x.Value);

Answer 4

在 .NET 5（可能仍然包括 .NET Framework）之前，在字典中设置值会更新其内部“版本号”，这会使迭代器以及与键或值集合关联的任何迭代器无效。

我确实明白你的观点，但同时如果值集合可以在迭代中改变，那就很奇怪了 - 为了简单起见，只有一个版本号。

修复此类问题的正常方法是预先复制键集合并迭代副本，或者迭代原始集合但维护一个更改集合，您将在完成迭代后应用这些更改。

例如：

首先复制密钥

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

或者...

创建修改列表

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 5

在 foreach 循环中调用 ToList()。 这样我们就不需要临时变量副本。 它依赖于从 .Net 3.5 起可用的 Linq。

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 6

您正在修改此行中的集合：

colStates[键] = 0;

通过这样做，您实际上是在此时删除并重新插入某些内容（无论如何，就 IEnumerable 而言）。

如果您编辑要存储的值的成员，那就没问题，但是您编辑值本身，而 IEnumberable 不喜欢这样。

我使用的解决方案是消除 foreach 循环，只使用 for 循环。
简单的 for 循环不会检查您知道不会影响集合的更改。

您可以这样做：

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 7

在 .NET 5 中，枚举字典时可以更改字典项。

拉取请求是：允许在枚举期间覆盖字典，问题是考虑从 Dictionary中的覆盖中删除 _version++。

现在你可以：

foreach (var pair in dict)
    dict[pair.Key] = pair.Value + 1;

Answer 8

您不能直接在 ForEach 中修改键或值，但可以修改它们的成员。 例如，这应该有效：

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 9

只对你的字典进行一些 linq 查询，然后将你的图表绑定到这些查询的结果怎么样？...

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 10

如果你觉得有创意，你可以做这样的事情。 向后循环字典以进行更改。

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

}

当然不完全相同，但无论如何你可能会感兴趣......

Answer 11

您需要从旧词典创建新词典，而不是就地修改。 类似的东西（也迭代 KeyValuePair<,> 而不是使用键查找：

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 12

从 .NET 4.5 开始，您可以使用 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);

但请注意，它的性能实际上比简单的 foreachdictionary.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>();
    }
}

结果：

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

Answer 13

您无法修改集合，甚至不能修改值。 您可以保存这些案例并稍后将其删除。 它最终会是这样的：

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 14

免责声明：我不做太多 C#

您正在尝试修改存储在 HashTable 中的 DictionaryEntry 对象。 Hashtable 只存储一个对象——DictionaryEntry 的实例。 更改 Key 或 Value 足以更改 HashTable 并导致枚举器变得无效。

您可以在循环之外执行此操作：

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

首先创建您希望更改的值的所有键的列表，然后迭代该列表。

Answer 15

您可以制作 dict.Values 的列表副本，然后可以使用 List.ForEach lambda 函数进行迭代（或 foreach循环，如之前建议的那样）。

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