我正在使用字典类，如下所示
Dictionary<string, string> dict = new Dictionary<string, string>()
{
{"1", "One"}
{"2", "Two"}
{"3", "three"}
{"4", "four"}
};
现在我正在尝试获取每个键的值，并将它们作为参数传递给函数。像这样：
myFunction(<get the first key and pass its value as parameter>);
myFunction(<get the second key and pass its value as parameter>);
myFunction(<get the third key and pass its value as parameter>);
myFunction(<get the fourth key and pass its value as parameter>);
所以这是对该函数的四个调用。
显然，我不能在这里使用 for 循环，因为如果我这样做，例如我从 1 开始循环，那么循环第一次运行的值将是 1，它将在我不想要的函数的这四个调用中拾取第一个键。我想在函数的第一次调用中得到 1，在第二次调用中得到第二个值，依此类推。
我无法找到一种方法来做到这一点。任何建议都会有很大帮助。
四个调用的相同键？
或者如何不做循环。
显然，我不能在这里使用 for 循环，因为如果我这样做，例如我从 1 开始循环，那么循环第一次运行的值将是 1，它将在我不想要的函数的这四个调用中拾取第一个键。我想在函数的第一次调用中得到 1，在第二次调用中得到第二个值，依此类推。
不要将四个调用放在循环中。
如果执行以下任一操作：
var keys = new List<string>(dict.Keys);
for (var index = 0; index < keys.Count; index++)
{
myFunction(dict[keys[index]]);
myFunction(dict[keys[index]]);
myFunction(dict[keys[index]]);
myFunction(dict[keys[index]]);
}
或者这个：
var values = new List<string>(dict.Values);
for (var index = 0; index < values.Count; index++)
{
myFunction(values[index]);
myFunction(values[index]);
myFunction(values[index]);
myFunction(values[index]);
}
或者这个：
foreach (var key in dict.Keys)
{
myFunction(dict[key]);
myFunction(dict[key]);
myFunction(dict[key]);
myFunction(dict[key]);
}
或者这个：
foreach (var pair in dict)
{
myFunction(pair.Value);
myFunction(pair.Value);
myFunction(pair.Value);
myFunction(pair.Value);
}
或者这个：
foreach (var value in dict.Values)
{
myFunction(value);
myFunction(value);
myFunction(value);
myFunction(value);
}
对于每个值，您将得到myFunction使用相同的值调用该函数四次。
如何为 for 或 foreach 循环执行操作
相反，将单个调用放入循环中。请记住，循环用于重复某些内容，因此将其放置在循环中将重复。
所以这样做：
var keys = new List<string>(dict.Keys);
for (var index = 0; index < keys.Count; index++)
{
myFunction(dict[keys[index]]);
}
所以这样做：
var values = new List<string>(dict.Values);
for (var index = 0; index < values.Count; index++)
{
myFunction(values[index]);
}
或者这个：
foreach (var key in dict.Keys)
{
myFunction(dict[key]);
}
或者这个：
foreach (var pair in dict)
{
myFunction(pair.Value);
}
或者这个：
foreach (var value in dict.Values)
{
myFunction(value);
}
您也可以这样做：
var keys = new List<string>(dict.Keys);
keys.ForEach(key => myFunction(dict[key]));
或者这个：
var values = new List<string>(dict.Values);
values.ForEach(value => myFunction(value));
或者，如果您更喜欢在混合中加入一些 Linq(我认为，因为您添加了Linq标签)，您可以这样做：
dict.Keys.ToList().ForEach(key => myFunction(dict[key]));
这也适用于：
dict.Values.ToList().ForEach(value => myFunction(value));
循环时如何做
假设您根本不想执行 for 或 foreach 循环。好吧，让我们看看...
像这样的 for 循环：
var keys = new List<string>(dict.Keys);
for (var index = 0; index < keys.Count; index++)
{
myFunction(dict[keys[index]]);
}
可以这样做：
var keys = new List<string>(dict.Keys);
var index = 0;
while (index < keys.Count)
{
myFunction(dict[keys[index]]);
index++
}
还有一个像这样的 foreach 循环：
foreach (var key in dict.Keys)
{
myFunction(dict[key]);
}
可以这样做：
var enumerator = dict.Keys.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
var key = enumerator.Current;
myFunction(dict[key]);
}
}
finally
{
enumerator.Dispose();
}
当然，你也可以这样做：
var enumerator = dict.Values.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
var value = enumerator.Current;
myFunction(value);
}
}
finally
{
enumerator.Dispose();
}
或者像这样：
var enumerator = dict.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
var pair = enumerator.Current;
myFunction(pair.Value);
}
}
finally
{
enumerator.Dispose();
}
此转换类似于编译器在内部执行的转换。通过这样做，在某些情况下您可能会有更大的灵活性......然而，它也更容易出错。
如何不做循环
让我们假装你根本不想循环。如果您在编译时知道元素的数量是多少，这是可能的。我们可以通过展开一个 for 来到达那里，例如我们之前while：
var keys = new List<string>(dict.Keys);
var index = 0;
while (index < keys.Count)
{
myFunction(dict[keys[index]]);
index++
}
将while变成if并重复。结果如下所示：
var keys = new List<string>(dict.Keys);
var index = 0;
if (index < keys.Count)
{
myFunction(dict[keys[index]]);
index++
}
if (index < keys.Count)
{
myFunction(dict[keys[index]]);
index++
}
if (index < keys.Count)
{
myFunction(dict[keys[index]]);
index++
}
if (index < keys.Count)
{
myFunction(dict[keys[index]]);
index++
}
好吧，如果知道index的值和字典中的项目数，我们就知道index < keys.Count何时为真。因此，我们可以删除这些if语句，并用它们的内部代码废除它们(因为它们是真的)。我们最终得到这个：
var keys = new List<string>(dict.Keys);
var index = 0;
myFunction(dict[keys[index]]);
index = 1;
myFunction(dict[keys[index]]);
index = 2;
myFunction(dict[keys[index]]);
index = 3;
myFunction(dict[keys[index]]);
index = 4;
最后，我们内联索引变量：
var keys = new List<string>(dict.Keys);
myFunction(dict[keys[0]]);
myFunction(dict[keys[1]]);
myFunction(dict[keys[2]]);
myFunction(dict[keys[3]]);
哒��
当然，你也可以这样做：
var values = new List<string>(dict.Values);
myFunction(values[0]);
myFunction(values[1]);
myFunction(values[2]);
myFunction(values[3]);
你真正需要知道的是字典不是有序的。说你想要"第一个"键是没有意义的。当然，您可以将从字典的Keys属性获得的KeyCollection转换为List<string>但这可能会导致任何任意不同的顺序。
如果"第一个"键是指键"1"，而"第二个"键是指键"2"，依此类推，那么我认为List<string>更适合这个。它是有序的，您可以使用数字来访问元素。
另外，我不明白为什么循环不起作用。试试这个：
for (int i = 1 ; i <= 4 ; i++) {
myFunction(dict[i.toString()]);
}
这将按"一"->"二"->"三"->"四"的顺序传递值。
您可以使用此代码获取密钥，
List<string> keyList = new List<string>(dict.Keys);
然后传递给带有索引的函数，
myFunction(keyList[0]);
为什么不能使用循环？一个foreach就可以了：
foreach (string key in dict.Keys)
{
myFunction(dict[key]);
}
foreach(var item in dict)
{
myFunction(item.Value);
}
或
foreach(var dictValue in dict.Values)
{
myFunction(dictValue);
}
不知道为什么你认为循环在这里不起作用