Question

我需要帮助构建Linq查询。我有这本词典：

var dict = new Dictionary<string, IDictionary<int, double>>  
{  
    { "one", new Dictionary<int, double>  
        {  
            { 1, 2.0 },  
            { 2, 3.0 }  
        }},  
    { "two", new Dictionary<int, double>  
        {  
            { 1, 3.0 },  
            { 2, 4.0 },  
            { 3, 5.0 }  
        }},  
    { "three", new Dictionary<int, double>  
        {  
            { 1, 4.0 },  
            { 2, 5.0}  
        }}  
    };

我想选择关联值为3.0的所有“string”/“int”元组。使用Foreach循环，它看起来像：

var res = new Dictionary<string, int>();
foreach (var elem in dict.Select (d => new { S = d.Key, I = d.Value }))
{
    foreach (var val in elem.I)
    {
        if (val.Value == 3.0)
        {
            res.Add(elem.S, val.Key);
        }
    }
}

我正在尝试使用单个Linq查询执行相同但没有成功（我不知道如何使用子查询中的值“加入”键）。你会怎么做？

提前谢谢！

Answer 1

这样可以解决问题：

var  res = dict
        .Where(outer => outer.Value.Any(inner => inner.Value == 3.0))
        .ToDictionary(outer => outer.Key, outer => outer.Value.First(x=>x.Value == 3.0).Key);

或使代码更通用：

var predicate = new Func<KeyValuePair<int, double>, bool>(inner => inner.Value == 3.0); 
var  res = dict
        .Where(outer => outer.Value.Any(inner => predicate(inner)))
        .ToDictionary(outer => outer.Key, outer => outer.Value.First(inner => predicate(inner)).Key);

Answer 2

这是另一种难以理解的方式：

var results = from key1 in dict.Keys
              let valueDict = dict[key1]
              from key2 in valueDict.Keys
              where valueDict[key2] == 3d
              select new { Key1 = key1, Key2 = key2 };

Answer 3

你可以这样做：

var result = dict
    // flatten to 3-value tuple
    .SelectMany(kvp => kvp.Value
        .Select(kvp2 => new // anonymous object
        {
            OuterKey = kvp.Key, // e.g. "one"
            InnerKey = kvp2.Key, // e.g. 1
            InnerValue = kvp2.Value // e.g. 2.0
        })
    ).Where(o => o.InnerValue == 3.0) // limit to the 3.0 value
    .ToDictionary(o => o.OuterKey, o => o.InnerKey)
    ;

SelectMany将字典字典展平为如下所示的结构：

{ OuterKey = "one", InnerKey = 1, InnerValue = 2.0 },
{ OuterKey = "one", InnerKey = 2, InnerValue = 3.0 },
{ OuterKey = "two", InnerKey = 1, InnerValue = 3.0 },
{ OuterKey = "two", InnerKey = 2, InnerValue = 4.0 },
{ OuterKey = "two", InnerKey = 3, InnerValue = 5.0 },
{ OuterKey = "three", InnerKey = 1, InnerValue = 4.0 },
{ OuterKey = "three", InnerKey = 2, InnerValue = 5.0 }

Where（）将其限制为仅具有InnerValue = 3.0的对象：

{ OuterKey = "one", InnerKey = 2, InnerValue = 3.0 },
{ OuterKey = "two", InnerKey = 1, InnerValue = 3.0 }

ToDictionary（）看起来像这样：

{ "one", 2 },
{ "two", 1 }

如果在同一个外键下可能有多个3.0，那么你可以使用ToLookup（）而不是ToDictionary（）。

找不到Linq查询的相应运算符

3 个答案: