I'm new to lambdas and they seemed fairly straight-forward until I tried to do something more complex. I have this dictionary.
Dictionary<int, int> dict = new Dictionary<int,int>();
of which I want to obtain the key of the key-val pair with the largest value. What I tried is:
dict.Keys.Max(g => dict[g])
The reasoning being that out of the list of Keys, pick that one for which dict[key] is largest. However, this picks the largest value itself, rather than its corresponding key.
dict.Keys.OrderByDescending(g => dict[g]).First() will accomplish what you want, but may be inefficient for large dictionaries. MaxBy in John Skeet's MoreLinq will do exactly what you want efficiently.
var maxValue = dict.Max((maxPair) => maxPair.Value);
var maxPairs = dict.Where((pair) => pair.Value == maxValue);
This will give you a list of all of the pairs that have the maximum value.
If you just want the keys, you can do this afterwards:
var maxKeys = maxPairs.Select((pair) => pair.Key);
MaxBy will be even faster since this way is forced to iterate over the list of keys twice.
dict.Max is executed for every element. This is not automatically cached by LINQ. The proper way to do the above is: var maxValue = dict.Max(p => p.Value); var maxPairs = dict.Where(p => p.Value == maxValue);. On my system with 10,000 elements the perf is: this answer=3982ms, OrderBy=113ms, mine=13ms. I would also suggest to answer the question you need to add .Select(p => p.Key) to get the keys for the elements with the largest value rather than the key value pairs.I decided to add an answer based on my thoughts on McKay's. This will perform very fast given the standard LINQ methods, provides just the key:
var maxValue = dict.Max(p => p.Value);
var keys = dict.Where(p => p.Value == maxValue).Select(p => p.Key);
Now, if the OP knows that there is always just one key (no duplicate values) then an improvement (very small) would be to use First with this as due to lazy evaluation only the elements up to the one with the maximum value would be evaluated after all were evaluated to first find the maximum value:
var key = dict.Where(p => p.Value == maxValue).First().Key;
dict.OrderBy(v => v.Value).Last().Key;
should do it. Basically you are ordering the KeyValuePair by value and picking the last one which will be the maximum. And within the last one you are only interested in the Key.
dict.Values.Max().