C# 需要从多个字典中获取唯一的密钥集<；日期时间，双精度>；

我有20本

字典，它们大多用于相同的日期范围（例如2012年2月24日至2012年6月4日）。有些词典有额外的天数，有些则缺少天数。我想要一个所有使用的唯一日期的数组

目前，我正在迭代所有键，并将其添加到hashset以获得唯一集，然后将hashset转换为数组。有没有更有效的方法

---

对于记录，我还考虑迭代并使用字典的containsKey函数，并将其添加到列表或LINQ。我现有的流程似乎可以做到这一点。

您描述的代码是您所能获得的最高效的代码。
使用LINQ，您可以用更少的代码（和类似的效率）完成此任务：

dicts.SelectMany(d => d.Keys).Distinct().ToArray();

---

您所描述的代码是您能获得的最有效的代码。
使用LINQ，您可以用更少的代码（和类似的效率）完成此任务：

dicts.SelectMany(d => d.Keys).Distinct().ToArray();

---

您可以将所有字典拉入允许“键中重复”的列表，然后使用Distinct函数：

        Dictionary<DateTime, double> dic = new Dictionary<DateTime, double>()
        {
            {DateTime.Now, 111}
        };

        Dictionary<DateTime, double> dic2 = new Dictionary<DateTime, double>()
        {
            {DateTime.Now, 111}
        };

        var list = dic.ToList();
        list.AddRange(dic2.ToList());

        var final = list.Distinct().ToDictionary(x => x.Key, x => x.Value);

Dictionary dic=新字典（）
{
{DateTime.Now，111}
};
字典dic2=新字典（）
{
{DateTime.Now，111}
};
var list=dic.ToList（）；
list.AddRange（dic2.ToList（））；
var final=list.Distinct（）.ToDictionary（x=>x.Key，x=>x.Value）；

您可以将所有字典拉入允许“键中重复”的列表，然后使用Distinct功能：

        Dictionary<DateTime, double> dic = new Dictionary<DateTime, double>()
        {
            {DateTime.Now, 111}
        };

        Dictionary<DateTime, double> dic2 = new Dictionary<DateTime, double>()
        {
            {DateTime.Now, 111}
        };

        var list = dic.ToList();
        list.AddRange(dic2.ToList());

        var final = list.Distinct().ToDictionary(x => x.Key, x => x.Value);

Dictionary dic=新字典（）
{
{DateTime.Now，111}
};
字典dic2=新字典（）
{
{DateTime.Now，111}
};
var list=dic.ToList（）；
list.AddRange（dic2.ToList（））；
var final=list.Distinct（）.ToDictionary（x=>x.Key，x=>x.Value）；

我在寻找一个稍有不同的问题的解决方案时发现了这篇文章，但使用了公认的答案作为我的解决方案的基础，因此我认为有人可能也会遇到同样的问题

我在寻找一种方法，在一组对象中找到一个在每个对象的属性集中唯一的属性。我在字典中有属性名，我想要一个只出现在一个字典中的键列表

这是我的解决方案，您应该可以将其粘贴到linqpad中，以查看它的工作情况

void Main()
{
  var d = new Dictionary<string, Dictionary<string, string>>
        {
            {
                "First",
                new Dictionary<string, string>
                {
                    {"A", "ash"},
                    {"B", "brett"},
                    {"R", "ripley"},
                    {"J", "jones"},
                    {"D", "dallas"}
                }
            },
            {
                "Second",
                new Dictionary<string, string>
                {
                    {"A", "ash"},
                    {"B", "brett"},
                    {"R", "ripley"},
                    {"D", "dallas"},
                    {"K", "kane"}
                }
            },
            {
                "Third",
                new Dictionary<string, string>
                {
                    {"A", "ash"},
                    {"B", "brett"},
                    {"R", "ripley"},
                    {"D", "dallas"},
                    {"V", "vasquez"}
                }
            },
            {
                "Fourth",
                new Dictionary<string, string>
                {
                    {"A", "ash"},
                    {"B", "brett"},
                    {"R", "ripley"},
                    {"D", "dallas"},
                    {"H", "hicks"}
                }
            }
        };

var u = d.Values.SelectMany(x => x.Keys).Distinct().Where(y => d.Values.SelectMany(z => z.Keys).Count(a => a == y) == 1).ToArray();

        foreach (var f in u)
        {
            Console.WriteLine("{0} => {1}", f, d.Keys.Single(s => ((Dictionary<string, string>)d[s]).ContainsKey(f)));
        }

void Main（）
{
var d=新字典
{
{
“第一”，
新词典
{
{“A”，“ash”}，
{“B”，“brett”}，
{“R”，“里普利”}，
{“J”，“琼斯”}，
{“D”，“达拉斯”}
}
},
{
“第二”，
新词典
{
{“A”，“ash”}，
{“B”，“brett”}，
{“R”，“里普利”}，
{“D”，“达拉斯”}，
{“K”，“凯恩”}
}
},
{
“第三”，
新词典
{
{“A”，“ash”}，
{“B”，“brett”}，
{“R”，“里普利”}，
{“D”，“达拉斯”}，
{“V”，“vasquez”}
}
},
{
“第四”，
新词典
{
{“A”，“ash”}，
{“B”，“brett”}，
{“R”，“里普利”}，
{“D”，“达拉斯”}，
{“H”，“hicks”}
}
}
};
var u=d.Values.SelectMany（x=>x.Keys）.Distinct（）.其中（y=>d.Values.SelectMany（z=>z.Keys）.Count（a=>a==y）==1.ToArray（）；
foreach（变量f在u中）
{
Console.WriteLine（“{0}=>{1}”，f，d.Keys.Single（s=>（（Dictionary）d[s]）.ContainsKey（f））；
}

---

}

我在寻找一个稍有不同的问题的解决方案时发现了这篇文章，但使用了公认的答案作为我解决方案的基础，因此我认为有人可能也会遇到同样的问题

我在寻找一种方法，在一组对象中找到一个在每个对象的属性集中唯一的属性。我在字典中有属性名，我想要一个只出现在一个字典中的键列表

这是我的解决方案，您应该可以将其粘贴到linqpad中，以查看它的工作情况

void Main()
{
  var d = new Dictionary<string, Dictionary<string, string>>
        {
            {
                "First",
                new Dictionary<string, string>
                {
                    {"A", "ash"},
                    {"B", "brett"},
                    {"R", "ripley"},
                    {"J", "jones"},
                    {"D", "dallas"}
                }
            },
            {
                "Second",
                new Dictionary<string, string>
                {
                    {"A", "ash"},
                    {"B", "brett"},
                    {"R", "ripley"},
                    {"D", "dallas"},
                    {"K", "kane"}
                }
            },
            {
                "Third",
                new Dictionary<string, string>
                {
                    {"A", "ash"},
                    {"B", "brett"},
                    {"R", "ripley"},
                    {"D", "dallas"},
                    {"V", "vasquez"}
                }
            },
            {
                "Fourth",
                new Dictionary<string, string>
                {
                    {"A", "ash"},
                    {"B", "brett"},
                    {"R", "ripley"},
                    {"D", "dallas"},
                    {"H", "hicks"}
                }
            }
        };

var u = d.Values.SelectMany(x => x.Keys).Distinct().Where(y => d.Values.SelectMany(z => z.Keys).Count(a => a == y) == 1).ToArray();

        foreach (var f in u)
        {
            Console.WriteLine("{0} => {1}", f, d.Keys.Single(s => ((Dictionary<string, string>)d[s]).ContainsKey(f)));
        }

void Main（）
{
var d=新字典
{
{
“第一”，
新词典
{
{“A”，“ash”}，
{“B”，“brett”}，
{“R”，“里普利”}，
{“J”，“琼斯”}，
{“D”，“达拉斯”}
}
},
{
“第二”，
新词典
{
{“A”，“ash”}，
{“B”，“brett”}，
{“R”，“里普利”}，
{“D”，“达拉斯”}，
{“K”，“凯恩”}
}
},
{
“第三”，
新词典
{
{“A”，“ash”}，
{“B”，“brett”}，
{“R”，“里普利”}，
{“D”，“达拉斯”}，
{“V”，“vasquez”}
}
},
{
“第四”，
新词典
{
{“A”，“ash”}，
{“B”，“brett”}，
{“R”，“里普利”}，
{“D”，“达拉斯”}，
{“H”，“hicks”}
}
}
};
var u=d.Values.SelectMany（x=>x.Keys）.Distinct（）.其中（y=>d.Values.SelectMany（z=>z.Keys）.Count（a=>a==y）==1.ToArray（）；
foreach（var f