C# 如何在C语言中检查字典中字典的键是否存在#

在下面的代码中，我如何检查字典中字典的键是否存在

当前执行抛出密钥存在错误

输出， 对于键“a”，另一个键“X”的值为1和2

我们有更好的收藏吗

 var data = new Dictionary<string, Dictionary<string, object>>();

        foreach (var j in GetTopData())
        {
            foreach (var p in BottomData())
            {
                if (data.Keys.Contains(j.ToString()))
                {
                    data[j].Add(p.Name, p.Value);
                }
                else
                {
                    data.Add(j, new Dictionary<string, object> { { p.Name, p.Value } });
                }
            }
        }

var data=newdictionary（）；
foreach（GetTopData（）中的var j）
{
foreach（BottomData（）中的var p）
{
if（data.Keys.Contains（j.ToString（）））
{
数据[j]。添加（p.Name，p.Value）；
}
其他的
{
添加（j，新字典{p.Name，p.Value}）；
}
}
}

以下是数据类

private static List<TempData> BottomData()
    {
        return new List<TempData>
        {
            new TempData{ Name="X", Value=1},
            new TempData{ Name="X", Value=2}
        };
    }

    private static List<string> GetTopData()
    {
        return new List<string> { "a"};
    }

public class TempData
{
    public string Name { get; set; }
    public object Value { get; set; }
}

私有静态列表数据（）
{
返回新列表
{
新的TempData{Name=“X”，Value=1}，
新的TempData{Name=“X”，Value=2}
};
}
私有静态列表GetTopData（）
{
返回新列表{“a”}；
}
公共类临时数据
{
公共字符串名称{get；set；}
公共对象值{get；set；}
}

您的代码可以简化为：

        var data = new Dictionary<string, Dictionary<string, List<object>>>();

        foreach (var j in GetTopData())
        {
            foreach (var p in BottomData())
            {
                Dictionary<string, List<object>> values;
                var existed = data.TryGetValue(j, out values);

                if (!existed)
                    values = new Dictionary<string, List<object>>();

                List<Object> list;

                var existed2 = values.TryGetValue(p.Name, out list);
                if (!existed2)
                    list = new List<object>();

                list.Add(p.Value);

                if (!existed)
                    data.Add(j, values);

                if (!existed2)
                    values.Add(p.Name, list);
            }
        }

var data=newdictionary（）；
foreach（GetTopData（）中的var j）
{
foreach（BottomData（）中的var p）
{
字典值；
var existed=data.TryGetValue（j，out值）；
如果（！存在）
值=新字典（）；
名单；
var existed2=values.TryGetValue（p.Name，out list）；
如果（！existed2）
列表=新列表（）；
列表。添加（p.值）；
如果（！存在）
数据。添加（j，值）；
如果（！existed2）
添加（p.名称、列表）；
}
}

您的代码可以简化为：

        var data = new Dictionary<string, Dictionary<string, List<object>>>();

        foreach (var j in GetTopData())
        {
            foreach (var p in BottomData())
            {
                Dictionary<string, List<object>> values;
                var existed = data.TryGetValue(j, out values);

                if (!existed)
                    values = new Dictionary<string, List<object>>();

                List<Object> list;

                var existed2 = values.TryGetValue(p.Name, out list);
                if (!existed2)
                    list = new List<object>();

                list.Add(p.Value);

                if (!existed)
                    data.Add(j, values);

                if (!existed2)
                    values.Add(p.Name, list);
            }
        }

var data=newdictionary（）；
foreach（GetTopData（）中的var j）
{
foreach（BottomData（）中的var p）
{
字典值；
var existed=data.TryGetValue（j，out值）；
如果（！存在）
值=新字典（）；
名单；
var existed2=values.TryGetValue（p.Name，out list）；
如果（！existed2）
列表=新列表（）；
列表。添加（p.值）；
如果（！存在）
数据。添加（j，值）；
如果（！existed2）
添加（p.名称、列表）；
}
}

您需要检查两个词典中的现有数据。目前，您仅在一个字典中检查是否存在：

var data = new Dictionary<string, Dictionary<string, object>>();

            foreach (var j in GetTopData())
            {
                foreach (var p in BottomData())
                {
                    if(data.ContainsKey(j.ToString()))
                    {
                        var mydict = data[j.ToString()];
                        if (!mydict.ContainsKey(p.Name))
                            data[j].Add(p.Name, p.Value);
                    }
                    else
                    {
                        data.Add(j, new Dictionary<string, object> { { p.Name, p.Value } });
                    }
                }
            }

var data=newdictionary（）；
foreach（GetTopData（）中的var j）
{
foreach（BottomData（）中的var p）
{
if（data.ContainsKey（j.ToString（）））
{
var mydict=数据[j.ToString（）]；
如果（！mydict.ContainsKey（p.Name））
数据[j]。添加（p.Name，p.Value）；
}
其他的
{
添加（j，新字典{p.Name，p.Value}）；
}
}
}

您需要检查两个词典中的现有数据。目前，您仅在一个字典中检查是否存在：

var data = new Dictionary<string, Dictionary<string, object>>();

            foreach (var j in GetTopData())
            {
                foreach (var p in BottomData())
                {
                    if(data.ContainsKey(j.ToString()))
                    {
                        var mydict = data[j.ToString()];
                        if (!mydict.ContainsKey(p.Name))
                            data[j].Add(p.Name, p.Value);
                    }
                    else
                    {
                        data.Add(j, new Dictionary<string, object> { { p.Name, p.Value } });
                    }
                }
            }

var data=newdictionary（）；
foreach（GetTopData（）中的var j）
{
foreach（BottomData（）中的var p）
{
if（data.ContainsKey（j.ToString（）））
{
var mydict=数据[j.ToString（）]；
如果（！mydict.ContainsKey（p.Name））
数据[j]。添加（p.Name，p.Value）；
}
其他的
{
添加（j，新字典{p.Name，p.Value}）；
}
}
}

回答您的问题如何在C#中检查字典中是否存在字典的键：

您可以使用Linq进行如下检查：

---

但在此之前，您必须修复代码中的错误。

回答您的问题如何在C#中检查字典中是否存在关键字：

您可以使用Linq进行如下检查：

---

但在此之前，您必须修复代码中的错误。

因为您需要一个键来包含多个值，

字典将不适用于您（它只允许一个值用于特定键）。您可以使用
词典
，但它很难阅读，也很难使用。因此，我认为最好使用Dictionary，在CombinedKey类中将两个键组合成一个键（在C#7.0中，
ValueTuple
也可以使用）：

然后这样使用：

Dictionary<CombinedKey, List<object>> data = new Dictionary<CombinedKey, List<object>>();

foreach (var j in GetTopData())
{
    foreach (var p in BottomData())
    {
        var key = new CombinedKey() { Key1 = j, Key2 = p.Name };
        List<object> list;
        if(!data.TryGetValue(key, out list))
        {
            data[key] = list = new List<object>();
        }
        list.Add(p.Value);
    }
}

字典数据=新字典（）；
foreach（GetTopData（）中的var j）
{
foreach（BottomData（）中的var p）
{
var key=new CombinedKey（）{Key1=j，Key2=p.Name}；
名单；
如果（！data.TryGetValue（键，输出列表））
{
数据[键]=列表=新列表（）；
}
列表。添加（p.值）；
}
}

如果您的数据是不可变的，您也可以使用类来代替。
因为您需要一个键来包含多个值，
字典将不适用于您（它只允许一个值用于特定键）。您可以使用
词典
，但它很难阅读，也很难使用。因此，我认为最好使用Dictionary，在CombinedKey类中将两个键组合成一个键（在C#7.0中，
ValueTuple
也可以使用）：

然后这样使用：

Dictionary<CombinedKey, List<object>> data = new Dictionary<CombinedKey, List<object>>();

foreach (var j in GetTopData())
{
    foreach (var p in BottomData())
    {
        var key = new CombinedKey() { Key1 = j, Key2 = p.Name };
        List<object> list;
        if(!data.TryGetValue(key, out list))
        {
            data[key] = list = new List<object>();
        }
        list.Add(p.Value);
    }
}

字典数据=新字典(