C# 自定义组合4个词典

我有四本类型的字典

Dictionary<string,string>

dict1

k1 = v1
k2 = v2
k4 = v4

dict 2

k2 = vv2
k3 = v3


dict3
k2 = vvv2

dict 4

k4 = vvvv4

---

这是可以实现的吗？任何扩展方法？？？

不是内置的；但可能是这样的：

var keys = dict1.Keys.Union(dict2.Keys).Union(dict3.Keys).Union(dict4.Keys);
var result = new Dictionary<string,List<string>>();
foreach(var key in keys) {
    List<string> list = new List<string>();
    list.Add(dict1.ContainsKey(key) ? dict1[key] : "");
    list.Add(dict2.ContainsKey(key) ? dict2[key] : "");
    list.Add(dict3.ContainsKey(key) ? dict3[key] : "");
    list.Add(dict4.ContainsKey(key) ? dict4[key] : "");
    result.Add(key, list);
}

var-keys=dict1.keys.Union（dict2.keys）.Union（dict3.keys）.Union（dict4.keys）；
var result=newdictionary（）；
foreach（var键入键）{
列表=新列表（）；
list.Add（dict1.ContainsKey（键）？dict1[key]：“”）；
添加（dict2.ContainsKey（键）？dict2[key]：“”）；
list.Add（dict3.ContainsKey（键）？dict3[key]：“”）；
list.Add（dict4.ContainsKey（键）？dict4[键]：“”）；
结果。添加（键、列表）；
}

不是内置的；但可能是这样的：

var keys = dict1.Keys.Union(dict2.Keys).Union(dict3.Keys).Union(dict4.Keys);
var result = new Dictionary<string,List<string>>();
foreach(var key in keys) {
    List<string> list = new List<string>();
    list.Add(dict1.ContainsKey(key) ? dict1[key] : "");
    list.Add(dict2.ContainsKey(key) ? dict2[key] : "");
    list.Add(dict3.ContainsKey(key) ? dict3[key] : "");
    list.Add(dict4.ContainsKey(key) ? dict4[key] : "");
    result.Add(key, list);
}

var-keys=dict1.keys.Union（dict2.keys）.Union（dict3.keys）.Union（dict4.keys）；
var result=newdictionary（）；
foreach（var键入键）{
列表=新列表（）；
list.Add（dict1.ContainsKey（键）？dict1[key]：“”）；
添加（dict2.ContainsKey（键）？dict2[key]：“”）；
list.Add（dict3.ContainsKey（键）？dict3[key]：“”）；
list.Add（dict4.ContainsKey（键）？dict4[键]：“”）；
结果。添加（键、列表）；
}

使用以下各项进行测试：

void Main（）
{
var dict1=新字典
{
{“k1”，“v1”}，
{“k2”，“v2”}，
{“k4”，“v4”}，
};
var dict2=新字典
{
{“k2”，“vv2”}，
{“k3”，“v3”}，
};
var dict3=新字典
{
{“k2”，“vvv2”}，
};
var dict4=新字典
{
{“k4”，“vvv4”}，
};
var keys=dict1.keys
.Union（dict2.Keys）
.Union（dict3.Keys）
.Union（dict4.Keys）；
变量表=
从钥匙插入钥匙
设v1=dict1.ContainsKey（键）？dict1[key]：“”
设v2=dict2.ContainsKey（键）？dict2[key]：“”
设v3=dict3.ContainsKey（键）？dict3[key]：“”
设v4=dict4.ContainsKey（键）？dict4[key]：“”
选择新建{key，values=newlist{v1，v2，v3，v4}；
var结果=表格
.ToDictionary（r=>r.key，r=>r.values）；
result.Dump（）；
}

您可以将整个内容组合到一个Linq查询中：

var result =
    (from key in dict1.Keys.Union(dict2.Keys).Union(dict3.Keys).Union(dict4.Keys)
     let v1 = dict1.ContainsKey(key) ? dict1[key] : ""
     let v2 = dict2.ContainsKey(key) ? dict2[key] : ""
     let v3 = dict3.ContainsKey(key) ? dict3[key] : ""
     let v4 = dict4.ContainsKey(key) ? dict4[key] : ""
     select new { key, values = new List<string> { v1, v2, v3, v4 } })
    .ToDictionary(r => r.key, r => r.values);

var结果=
（来自dict1.Keys.Union（dict2.Keys）.Union（dict3.Keys）.Union（dict4.Keys）
设v1=dict1.ContainsKey（键）？dict1[key]：“”
设v2=dict2.ContainsKey（键）？dict2[key]：“”
设v3=dict3.ContainsKey（键）？dict3[key]：“”
设v4=dict4.ContainsKey（键）？dict4[key]：“”
选择新{键，值=新列表{v1，v2，v3，v4}）
.ToDictionary（r=>r.key，r=>r.values）；

使用以下各项进行测试：

void Main（）
{
var dict1=新字典
{
{“k1”，“v1”}，
{“k2”，“v2”}，
{“k4”，“v4”}，
};
var dict2=新字典
{
{“k2”，“vv2”}，
{“k3”，“v3”}，
};
var dict3=新字典
{
{“k2”，“vvv2”}，
};
var dict4=新字典
{
{“k4”，“vvv4”}，
};
var keys=dict1.keys
.Union（dict2.Keys）
.Union（dict3.Keys）
.Union（dict4.Keys）；
变量表=
从钥匙插入钥匙
设v1=dict1.ContainsKey（键）？dict1[key]：“”
设v2=dict2.ContainsKey（键）？dict2[key]：“”
设v3=dict3.ContainsKey（键）？dict3[key]：“”
设v4=dict4.ContainsKey（键）？dict4[key]：“”
选择新建{key，values=newlist{v1，v2，v3，v4}；
var结果=表格
.ToDictionary（r=>r.key，r=>r.values）；
result.Dump（）；
}

您可以将整个内容组合到一个Linq查询中：

var result =
    (from key in dict1.Keys.Union(dict2.Keys).Union(dict3.Keys).Union(dict4.Keys)
     let v1 = dict1.ContainsKey(key) ? dict1[key] : ""
     let v2 = dict2.ContainsKey(key) ? dict2[key] : ""
     let v3 = dict3.ContainsKey(key) ? dict3[key] : ""
     let v4 = dict4.ContainsKey(key) ? dict4[key] : ""
     select new { key, values = new List<string> { v1, v2, v3, v4 } })
    .ToDictionary(r => r.key, r => r.values);

var结果=
（来自dict1.Keys.Union（dict2.Keys）.Union（dict3.Keys）.Union（dict4.Keys）
设v1=dict1.ContainsKey（键）？dict1[key]：“”
设v2=dict2.ContainsKey（键）？dict2[key]：“”
设v3=dict3.ContainsKey（键）？dict3[key]：“”
设v4=dict4.ContainsKey（键）？dict4[key]：“”
选择新{键，值=新列表{v1，v2，v3，v4}）
.ToDictionary（r=>r.key，r=>r.values）；

我不认为扩展方法是最好的设计。这里有一个标准方法，可以合并任意数量的词典

Dictionary<string,List<string>> Merge(params Dictionary<string,string>[] dicts)
{
    var target = new Dictionary<string, List<string>>();
    var allKeys = dicts.SelectMany(d => d.Keys).Distinct();

    foreach(var key in allKeys)
    {
        foreach(var dict in dicts)
        {
            if(target.ContainsKey( key ) )
            {
                target[key].Add( dict.ContainsKey(key) ? dict[key] : "" );
            }
            else
            {
                target[key] = new[] {dict.ContainsKey(key) ? dict[key] : ""} .ToList();
            }
        }
    }

    return target;
}

字典合并（params Dictionary[]dicts）
{
var target=newdictionary（）；
var allKeys=dicts.SelectMany（d=>d.Keys）.Distinct（）；
foreach（所有键中的var键）
{
foreach（变量dict in dicts）
{
if（目标容器（键））
{
目标[key]。添加（dict.ContainsKey（key）？dict[key]：“”）；
}
其他的
{
target[key]=new[]{dict.ContainsKey（key）？dict[key]：“”}.ToList（）；
}
}
}
回报目标；
}

这比这里发布的其他LINQ解决方案更灵活、更易读

下面是一个LINQPad测试，可用于验证：

var d1 = new Dictionary<string,string> { {"k1","v1"}, {"k2","v2"}, {"k4","v4"}  } ;
var d2 = new Dictionary<string,string> { {"k2","vv2"}, {"k3","v3"}  } ;
var d3 = new Dictionary<string,string> { {"k2","vvv2"} } ;
var d4 = new Dictionary<string,string> { {"k4","vvvv4"} } ;

Merge(d1,d2,d3,d4).Dump();

vard1=新字典{{“k1”、“v1”}、{“k2”、“v2”}、{“k4”、“v4”}；
var d2=新字典{{“k2”、“vv2”}、{“k3”、“v3”}；
var d3=新字典{{“k2”，“vvv2”}；
var d4=新字典{{“k4”，“VVV4”}；
合并（d1，d2，d3，d4）.Dump（）；

我不认为扩展方法是最好的设计。这里有一个标准方法，可以合并任意数量的词典

Dictionary<string,List<string>> Merge(params Dictionary<string,string>[] dicts)
{
    var target = new Dictionary<string, List<string>>();
    var allKeys = dicts.SelectMany(d => d.Keys).Distinct();

    foreach(var key in allKeys)
    {
        foreach(var dict in dicts)
        {
            if(target.ContainsKey( key ) )
            {
                target[key].Add( dict.ContainsKey(key) ? dict[key] : "" );
            }
            else
            {
                target[key] = new[] {dict.ContainsKey(key) ? dict[key] : ""} .ToList();
            }
        }
    }

    return target;
}

字典合并（params Dictionary[]dicts）
{
var target=newdictionary（）；
var allKeys=dicts.SelectMany（d=>d.Keys）.Distinct（）；
foreach（所有键中的var键）
{
foreach（变量dict in dicts）
{
if（目标容器（键））
{
目标[key]。添加（dict.ContainsKey（key）？dict[key]：“”）；
}
其他的
{
target[key]=new[]{dict.ContainsKey（key）？dict[key]：“”}.ToList（）；
}
}
}
回报目标；
}

这比这里发布的其他LINQ解决方案更灵活、更易读

下面是一个LINQPad测试，可用于验证：

var d1 = new Dictionary<string,string> { {"k1","v1"}, {"k2","v2"}, {"k4","v4"}  } ;
var d2 = new Dictionary<string,string> { {"k2","vv2"}, {"k3","v3"}  } ;
var d3 = new Dictionary<string,string> { {"k2","vvv2"} } ;
var d4 = new Dictionary<string,string> { {"k4","vvvv4"} } ;

Merge(d1,d2,d3,d4).Dump();

vard1=新字典{{“k1”、“v1”}、{“k2”、“v2”}、{“k4”，