我的问题是关于使用 C# linq 将 List<string> 与 Dictionary <string, List<string>> 进行比较

Question

我已经在堆栈溢出中引用了以下链接以满足我的要求，它提供了匹配的键和布尔结果。我需要字典中与字符串列表匹配的键和值的结果。

参考链接如下： Array with Dictionary in c# using Linq

上面的同一链接中提供了该示例。无论如何我将在下面提供相同的内容

Dictionary<int, List<string>> dict = new Dictionary<int, <string>>
{ 
    {1, new List<string>(){"A","B"}},
    {2, new List<string>(){"C","D"}},
    {3, new List<string>(){"G","H"}},
    {4, new List<string>(){"E","F"}},
    {5, new List<string>(){"I","J"}},
};

string[] values = new [] 
{
    "A", "D", "E"
};

var result = 
  from kvp in dict
  join s in values on kvp.Value equals s
select new {kvp.Key, Found = true};

我试过的如下：

var result = dict
  .Select(x => new { 
     keys = x.Key, 
     values = values
       .ToList()
       .Any(x.Value.Contains) 
   });

我希望输出类似于{1,A},{2,D},{4,E}，但实际上是{1,True},{4,True},{5,True}

有人可以帮我解决这个问题吗？

Answer 1

从技术上讲，如果你愿意，比如List<object> == {1, "A", 4, "D", 5, "E"};

我希望输出类似于{1,A,4,D,5,E}

您可以尝试Where 过滤掉dict 记录并尝试SelectMany 将它们展平：

  Dictionary<int, string> dict = new Dictionary<int, string>() { 
    {1, new "A"},
    {2, new "B"},
    {3, new "c"},
    {4, new "D"},
    {5, new "E"},
  };

  string[] values = new [] {"A", "D", "E"};

  var result = dict
    .Where(pair => values.Contains(pair.Value))
    .SelectMany(pair => new object[] { pair.Key, pair.Value})
    .ToList();

  Console.Write(string.Join(", ", result));

结果：

  1, A, 4, D, 5, E

但是，我怀疑您是否真的想要这种奇怪的数据表示。过滤后的集合（或字典）没有 SelectMany 更方便：

  List<KeyValuePair<int, string>> result = dict
    .Where(pair => values.Contains(pair.Value))
    .ToList();

  Console.Write(string.Join(", ", result.Select(pair => $"{pair.Key}, {pair.Value}")));

或者

  Dictionary<int, string> result = dict
    .Where(pair => values.Contains(pair.Value))
    .ToDictionary(pair => pair.Key, pair => pair.value);

  Console.Write(string.Join(", ", result.Select(pair => $"{pair.Key}, {pair.Value}")));

产生相同的结果：

  1, A, 4, D, 5, E

编辑：嗯，问题发生了巨大变化。现在我们有

  Dictionary<int, List<string>> dict = new Dictionary<int, <string>>() { 
    {1, new List<string>() {"A", "B"}},
    {2, new List<string>() {"C", "D"}},
    {3, new List<string>() {"G", "H"}},
    {4, new List<string>() {"E", "F"}},
    {5, new List<string>() {"I", "J"}},
  };

  string[] values = new [] { "A", "D", "E" };

我们想要过滤Dictionary<int, List<string>>：

  var result = dict
    .Select(pair => new {
      key = pair.Key,
      value = pair.Value.Intersect(values).ToList()
    })
    .Where(item => item.value.Any())
    .ToDictionary(item => item.key, item => item.value);

  Console.Write(string.Join(Environment.NewLine, result
    .Select(pair => $"{pair.Key} : [{string.Join(", ", pair.Value)}]"))); 

结果：

1 : [A]
2 : [D]
4 : [E]   

Answer 2

所以，您基本上是想在字典中选择值在“values”数组中的键值对，对吧？

类似这样的：

(from kvp in dict
 where values.Contains(kvp.Value)
 select kvp).ToDictionary(key => kvp.Key, value => kvp.Value);

应该可以，但我现在无法测试。

Answer 3

检查此代码

Dictionary<int, string> dict = new Dictionary<int, 
string>
 { 
  {1, "A"},
  {2, "B"},
  {3, "c"},
  {4, "D"},
  {5, "E"},
 };

 string[] values = new [] 
 {
   "A", "D", "E"
 };

在这里，您只需选择包含 dict 值的 dict。

这样写linq：

var query=dict.Where(x=>values.Contains(x.Value));

所以你得到如下输出：

[1, A]
[4, D]
[5, E]

更多信息请查看this