C# 按键从字典中获取项

我有这样的结构：

static Dictionary<int, Dictionary<int, string>> tasks = 
    new Dictionary<int, Dictionary<int, string>>();

我想从这个列表中获得所有的

[8]

字符串，意思是

str1

+

str2

该方法应如下所示：

static List<string> getTasksByNum(int num){

}

静态列表getTasksByNum（int num）{
}

---

如何访问它？

只需迭代第一个层次级别的所有值，并在第二个级别上使用

TryGetValue

：

var result = new List<string>();
foreach(var inner in tasks.Values)
{
    string tmp;
    if(inner.TryGetValue(yourKey, out tmp)
        result.Add(tmp);
}

var result=newlist（）；
foreach（tasks.Values中的内部变量）
{
串tmp；
if（内部.TryGetValue（您的键，输出tmp）
结果：添加（tmp）；
}

该解决方案与目前为止提供的所有其他解决方案相比具有一个主要优势： 它实际上使用第二层次结构级别的字典作为字典，即foreach循环中的部分是O（1），而不是所有其他解决方案中的O（n）。

dictionary tasks=new dictionary（）；
Dictionary<int, Dictionary<int, string>> tasks = new Dictionary<int, Dictionary<int, string>>();

List<string> strings = new List<string>();
foreach(var dict in tasks.Values)
{
  if(dict.ContainsKey(8))
      strings.Add(dict[8]);
}

列表字符串=新列表（）；
foreach（tasks.Values中的var dict）
{
如果（第8条）
strings.Add（dict[8]）；
}

检查此功能：

   tasks.
      Where(task => task.Value.ContainsKey(8)).
      Select(task => task.Value[8]);

---

使用LINQ，您可以执行以下操作：

return tasks.Values
            .Where(dict => dict.ContainsKey(8))
            .Select(dict => dict[8])
            .ToList();      

虽然这很优雅，但是

TryGetValue

模式通常比它使用的两个查找操作更可取（首先尝试

ContainsKey

，然后使用索引器获取值）

如果这是您的问题，您可以（使用合适的助手方法）执行以下操作：

---

您正在构建任务吗？
如果我猜对了，那就是tasks[task_id]（[cpu]=>“task_name”）；
我建议您也构建cpu_任务[cpu]（[task_id]=>“task_name”）

静态字典cpu\u任务

它需要更多的维护，但可以让您更快地运行此特定函数。

Dictionary tasks=new Dictionary（）；
Dictionary<int, Dictionary<int, string>> tasks = new Dictionary<int, Dictionary<int, string>>();
var result = string.Empty;

//more human-readable version
var searchValue = 8;
foreach (var task in tasks)
{
     if (task.Value.ContainsKey(searchValue))
         result += task.Value[searchValue];
}

//one-line version
result = tasks.ToList().Aggregate(string.Empty, (a, kvp) => a += kvp.Value.ContainsKey(searchValue) ? kvp.Value[searchValue] : string.Empty);

var result=string.Empty；
//更人性化的版本
var值=8；
foreach（任务中的var任务）
{
if（task.Value.ContainsKey（searchValue））
结果+=任务值[searchValue]；
}
//单行版本
结果=tasks.ToList（）.Aggregate（string.Empty，（a，kvp）=>a+=kvp.Value.ContainsKey（searchValue）？kvp.Value[searchValue]：string.Empty）；

丹尼尔的解决方案可能是最好的，因为它更容易理解。但也可以在linq方法中使用TryGetValue：

return tasks.Values
    .Select(dictionary => {
        string task;
        var success = dictionary.TryGetValue(yourKey, out task);
        return new { success, task };
    })
    .Where(t => t.success)
    .Select(t => t.task)
    .ToList();

---

循环全部，但它太重。您应该返回IEnumerable而不是ListA。字典中的字典？定义“重”？"无论你使用什么方法，都会使用循环…@QuangAnh Anh，这有什么问题吗？你看到了我的结构…你推荐什么其他解决方案？考虑到你可以使用

GetValue

或

TryGetValue

而不是遍历每个字典中的所有内容，这是非常低效的…是的，你的编辑修复了我所认为的问题编辑（编辑你的答案，然后像我的评论是错误的那样回答，这并不讨人喜欢。）编辑21小时前，你回答了21小时前，我在编辑之前从来没有看到过你的评论。无论如何，我注意到我自己昨天可以通过使用dict[8]快得多，所以你是对的。

static Dictionary<int, Dictionary<int, string>> cpu_tasks

Dictionary<int, Dictionary<int, string>> tasks = new Dictionary<int, Dictionary<int, string>>();
var result = string.Empty;

//more human-readable version
var searchValue = 8;
foreach (var task in tasks)
{
     if (task.Value.ContainsKey(searchValue))
         result += task.Value[searchValue];
}

//one-line version
result = tasks.ToList().Aggregate(string.Empty, (a, kvp) => a += kvp.Value.ContainsKey(searchValue) ? kvp.Value[searchValue] : string.Empty);

return tasks.Values
    .Select(dictionary => {
        string task;
        var success = dictionary.TryGetValue(yourKey, out task);
        return new { success, task };
    })
    .Where(t => t.success)
    .Select(t => t.task)
    .ToList();