C# 合并2个或多个内部列表

我正在使用下面的代码生成上面的列表

{
 "ProductDMList":
   [
    {
     "ProductID" : 1,
     "CabinetList":
        [
         {
          "Min" : 1,
          "Max" : 12
         }
        ]
    },
     {
     "ProductID" : 1,
     "CabinetList":
        [
         {
          "Min" : 16,
          "Max" : 100
         }
        ]
    }
   ]
}

---

我尝试了

AddRange（）

和

Concat（）

方法。但我无法获得上述预期结果。

我建议使用字典按其ID访问已看到的产品，然后在循环未合并列表时添加InventoryDM实例：

{
 "ProductDMList":
   [
    {
     "ProductID" : 1,
     "CabinetList":
        [
         {
          "Min" : 1,
          "Max" : 12
         },
         {
          "Min" : 16,
          "Max" : 100
         }
        ]
     }
   ]
}

static void Main（字符串[]args）
{
List productDMList=新列表（）
{
新产品dm（）
{
ProductID=1，
CabinetList=新列表（）
{
新目录dm（）
{
最小值=1，
最大值=12
}
}
},
新产品dm（）
{
ProductID=1，
CabinetList=新列表（）
{
新目录dm（）
{
最小=16，
最大值=100
}
}
},
};
Dictionary dict=新字典（）；
foreach（productDMList中的ProductDM产品）
{
如果（！dict.ContainsKey（product.ProductID））
{
dict.Add（product.ProductID，product）；
}
其他的
{
dict[product.ProductID].CabinetList.AddRange（product.CabinetList.ToArray（））；
}
}
Console.ReadKey（true）；
}

---

dict.Values

是您的合并列表

我建议使用字典按其ID访问已看到的产品，然后在循环未合并列表时添加InventoryDM实例：

{
 "ProductDMList":
   [
    {
     "ProductID" : 1,
     "CabinetList":
        [
         {
          "Min" : 1,
          "Max" : 12
         },
         {
          "Min" : 16,
          "Max" : 100
         }
        ]
     }
   ]
}

static void Main（字符串[]args）
{
List productDMList=新列表（）
{
新产品dm（）
{
ProductID=1，
CabinetList=新列表（）
{
新目录dm（）
{
最小值=1，
最大值=12
}
}
},
新产品dm（）
{
ProductID=1，
CabinetList=新列表（）
{
新目录dm（）
{
最小=16，
最大值=100
}
}
},
};
Dictionary dict=新字典（）；
foreach（productDMList中的ProductDM产品）
{
如果（！dict.ContainsKey（product.ProductID））
{
dict.Add（product.ProductID，product）；
}
其他的
{
dict[product.ProductID].CabinetList.AddRange（product.CabinetList.ToArray（））；
}
}
Console.ReadKey（true）；
}

---

dict.Values

那么您的合并列表是不是就是这个？如果我明白你的要求

    static void Main(string[] args)
    {
        List<ProductDM> productDMList = new List<ProductDM>()
        {
            new ProductDM()
            {
                ProductID = 1,
                CabinetList = new List<InventoryDM>()
                {
                    new InventoryDM()
                    {
                        Min = 1,
                        Max = 12
                    }
                }
            },
            new ProductDM()
            {
                ProductID = 1,
                CabinetList = new List<InventoryDM>()
                {
                    new InventoryDM()
                    {
                        Min = 16,
                        Max = 100
                    }
                }
            },
        };

        Dictionary<int, ProductDM> dict = new Dictionary<int, ProductDM>();

        foreach(ProductDM product in productDMList)
        {
            if(!dict.ContainsKey(product.ProductID))
            {
                dict.Add(product.ProductID, product);
            }
            else
            {
                dict[product.ProductID].CabinetList.AddRange(product.CabinetList.ToArray());
            }
        }

        Console.ReadKey(true);

    }

var list=newlist（）；
var result=list.GroupBy（x=>x.ProductID）
.选择（x=>newproductdm
{
ProductID=x.Key，
Min=x.Min（y=>y.Min），
Max=x.Max（y=>y.Max），
CabinetList=x.SelectMany（y=>y.CabinetList）.ToList（）
}).ToList（）；

---

根据指定的键对序列的元素进行分组 选择器功能

---

也许是这个？如果我明白你的要求

    static void Main(string[] args)
    {
        List<ProductDM> productDMList = new List<ProductDM>()
        {
            new ProductDM()
            {
                ProductID = 1,
                CabinetList = new List<InventoryDM>()
                {
                    new InventoryDM()
                    {
                        Min = 1,
                        Max = 12
                    }
                }
            },
            new ProductDM()
            {
                ProductID = 1,
                CabinetList = new List<InventoryDM>()
                {
                    new InventoryDM()
                    {
                        Min = 16,
                        Max = 100
                    }
                }
            },
        };

        Dictionary<int, ProductDM> dict = new Dictionary<int, ProductDM>();

        foreach(ProductDM product in productDMList)
        {
            if(!dict.ContainsKey(product.ProductID))
            {
                dict.Add(product.ProductID, product);
            }
            else
            {
                dict[product.ProductID].CabinetList.AddRange(product.CabinetList.ToArray());
            }
        }

        Console.ReadKey(true);

    }

var list=newlist（）；
var result=list.GroupBy（x=>x.ProductID）
.选择（x=>newproductdm
{
ProductID=x.Key，
Min=x.Min（y=>y.Min），
Max=x.Max（y=>y.Max），
CabinetList=x.SelectMany（y=>y.CabinetList）.ToList（）
}).ToList（）；

---

根据指定的键对序列的元素进行分组 选择器功能

---

Javascript解决方案非常简单：）

var tempaa={
“产品列表”：
[
{
“ProductID”：1，
“家具清单”：
[
{
"Min":1,，
“最大”：12
}
]
},
{
“ProductID”：1，
“家具清单”：
[
{
“Min”：16，
“最大”：100
}
]
}
]
};
var tempbb=[]；
函数isExistsInBB（productId、currentProductDM、sourceCabinetList）{
如果（tempbb.length==0）{
临时推送（currentProductDM）；
返回；
}
对于（变量i=0；i

Javascript解决方案如此简单：）

var tempaa={
“产品列表”：
[
{
“ProductID”：1，
“家具清单”：
[
{
"Min":1,，
“最大”：12
}
]
},
{
“ProductID”：1，
“家具清单”：
[
{
“Min”：16，
“最大”：100
}
]
}
]
};
var tempbb=[]；
函数isExistsInBB（productId、currentProductDM、sourceCabinetList）{
如果（tempbb.length==0）{
tempbb.p
var tempaa = {
"ProductDMList":
    [
        {
            "ProductID": 1,
            "CabinetList":
                [
                    {
                        "Min": 1,
                        "Max": 12
                    }
                ]
        },
        {
            "ProductID": 1,
            "CabinetList":
                [
                    {
                        "Min": 16,
                        "Max": 100
                    }
                ]
        }
    ]
};

var tempbb = [];

function isExistsInBB(productId, currentProductDM, sourceCabinetList) {

  if (tempbb.length == 0) {
      tempbb.push(currentProductDM);
      return;
  }

  for (var i = 0; i < tempbb.length; i++) {
    var innerItem = tempbb[i];
    if (productId == innerItem.ProductID) {
        innerItem.CabinetList.push(sourceCabinetList);
    } else {
        tempbb.push(currentProductDM);
    }
  }
}

function eachTempaa() {
  for (var i = 0; i < tempaa.ProductDMList.length; i++) {
    var innerItem = tempaa.ProductDMList[i];
    isExistsInBB(innerItem.ProductID, innerItem, innerItem.CabinetList[0]);
  }
  console.log(tempbb);
}

eachTempaa();