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

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

类似这样的东西：

(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"
 };

在这里，您只需要选择包含字典值的字典即可。

这样写linq：

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

所以您将得到如下输出：

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

有关更多信息，请检查this

我的问题是关于使用C＃linq将List <string>与字典<string，List <string >>比较

3 个答案: