Question

我有以下TestParam列表......这只是一个参数列表，用于确定如何运行查询。在以下情况中，将针对不同参数的所有组合执行预期结果。因此，列表列表中包含CustomerId 33以及列表中可用的每个产品ID ...

List<TestParam> testList = new List<TestParam>();
        testList.Add(new TestParam() { Name = "CustomerId", Value = "33" });
        testList.Add(new TestParam() { Name = "ProductId", Value = "1" });
        testList.Add(new TestParam() { Name = "ProductId", Value = "2" });
        testList.Add(new TestParam() { Name = "ProductId", Value = "3" });
        testList.Add(new TestParam() { Name = "ProductId", Value = "4" });
        testList.Add(new TestParam() { Name = "ProductId", Value = "5" });
        testList.Add(new TestParam() { Name = "ProductId", Value = "6" });
        testList.Add(new TestParam() { Name = "ProductId", Value = "7" });
        testList.Add(new TestParam() { Name = "ProductId", Value = "8" });

TestParam是一个普通的封装参数类，它有一个名称和一个值......

public class TestParam
    {
        public string Name { get; set; }
        public string Value { get; set; }
    }

最终结果将是具有CustomerId 33的列表列表，其中包含所有其他产品。如果我在TestParam列表中有不同的名称和值（以上只是一个例子），将获得相同的结果。

以下代码最终会有几个列表，具体取决于上面列表的组合...

   // First get a list of distinct unique param collections...
    List<string> distinctParameterNames = new List<string>();
    testList.GroupBy(x => x.Name).ForEach(paramName => {
        distinctParameterNames.Add(paramName.Key);
    });

    // Get counts
    List<int> combinationList = new List<int>();
    foreach (var x in distinctParameterNames) { 
        combinationList.Add(testList.Where(y=>y.Name == x).Count());
    }

    // Will contain 2 lists, one having all combinations of parameters named CustomerId, and another with ProductId combinations...
    List<List<TestParam>> parameterList = new List<List<TestParam>>();
    foreach (var x in distinctParameterNames) {

        // Loop 
        List<TestParam> parameter = new List<TestParam>();
        testList.Where(paramName => paramName.Name == x).ForEach(y =>
        {

            parameter.Add(new TestParam() { Name = y.Name, Value = y.Value });

        });

        parameterList.Add(parameter);

    }

这将是列表之间的交叉，最终结果将是列表列表，每个列表将具有以下组合...因此运行将返回（在这种情况下）：

客户33，产品ID 1
客户33，产品ID 2
客户33，产品ID 3
客户33，产品ID 4
客户33，产品编号5
客户33，产品编号6
客户33，产品编号7
客户33，产品编号8

最有效和最通用的方法是什么？

Answer 1

以下是我正在寻找的解决方案......

public static List<List<T>> AllCombinationsOf<T>(params List<T>[] sets)
        {
            // need array bounds checking etc for production
            var combinations = new List<List<T>>();

            // prime the data
            foreach (var value in sets[0])
                combinations.Add(new List<T> { value });

            foreach (var set in sets.Skip(1))
                combinations = AddExtraSet(combinations, set);

            return combinations;
        }

        private static List<List<T>> AddExtraSet<T>
     (List<List<T>> combinations, List<T> set)
        {
            var newCombinations = from value in set
                                  from combination in combinations
                                  select new List<T>(combination) { value };

            return newCombinations.ToList();
        }

用法（继续我的问题本身的代码片段）：

var intersection = AllCombinationsOf(parameterList.ToArray());

Answer 2

首先获得所有客户名单

var customers = from a in testlist where a.name='customerid'
                select a;

var products = from a in testlist where a.name='productid'
                select a;

然后循环客户

for(var c in customers)
{
    loop products
     for(var p in products)
     {
        var customerproducts = new CustomerProducts{
            Customer = c.Name +' ' + c.Value
            Product = p.Name + ' ' + p.value
         };

       then add it into a list 
     }
}

Answer 3

列表需要按Name分组，然后根据群组数量连接多次：

        var groups = testList.GroupBy(_ => _.Name);

        IEnumerable<IEnumerable<TestParam>> result = null;

        foreach (var g in groups)
        {
            var current = g.Select(_ => new[] { _ });
            if (result == null)
            {
                result = current;
                continue;
            }

            result = result.Join(current, _ => true, _ => true, (actual, c) => actual.Concat(c));
        }

        // check result
        foreach (var i in result)
        {
            Console.WriteLine(string.Join(", ", i.Select(_ => string.Format("{0}-{1}", _.Name, _.Value))));
        }

获取按名称分组的列表的所有组合

3 个答案: