如何传递字典值而不必在c#中使用循环迭代

Question

我正在使用Dictionary类如下

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,在第二次调用中获得第二个值,依此类推.

我无法找到办法做到这一点.任何建议都会有很大帮助.

Answer 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对于每个值,您将使用相同的值四次调用hte函数.

如何做或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]);