嵌套分组策略/算法c#

Question

不确定我是否必须纠正此类问题的标签，但是您对以下问题的通用解决方案有什么想法吗？

给定发票集合：

var invoices = new List<Invoice>()
{
new Invoice() { Id = 1, Customer = "a", Date = DateTime.Parse("1/1/2009") },
new Invoice() { Id = 2, Customer = "a", Date = DateTime.Parse("1/2/2009") },
new Invoice() { Id = 3, Customer = "a", Date = DateTime.Parse("1/2/2009") },
new Invoice() { Id = 4, Customer = "b", Date = DateTime.Parse("1/1/2009") },
new Invoice() { Id = 5, Customer = "b", Date = DateTime.Parse("1/1/2009") },
new Invoice() { Id = 6, Customer = "b", Date = DateTime.Parse("1/2/2009") }
}

我可以使用什么技术来指定类似以下内容：

var tree = invoices.ToHeirarchy(t => {
    t.GroupBy(x => x.Date);
    t.GroupBy(x => x.Customer);
})

结果如图所示：

Date "1/1/2009"
  Customer a
    Invoice 1
  Customer b
    Invoice 4
    Invoice 5
Date "1/2/2009"
  Customer a
    Invoice 2
    Invoice 3
  Customer b
    Invoice 6

并且还允许通过以下内容（允许对任何级别的发票进行计算）？

Assert.AreEqual(3, tree.Node[0].Items.Count)
Assert.AreEqual(DateTime.Parse("1/1/2009"), tree.Node[0].Key)

Assert.AreEqual(3, tree.Node[1].Items.Count)
Assert.AreEqual(DateTime.Parse("1/2/2009"), tree.Node[1].Key)

Assert.AreEqual("a", tree.Node[0].Node[0].Key)
Assert.AreEqual(1, tree.Node[0].Node[0].Items.Count)

Assert.AreEqual("b", tree.Node[0].Node[1].Key)
Assert.AreEqual(2, tree.Node[0].Node[1].Items.Count)

Answer 1

您正在寻找的术语是“嵌套 groupby”。

http://msdn.microsoft.com/en-us/vcsharp/ aa336754.aspx#nested

Answer 2

远非可重用，但这应该可以做到：

       var tree = invoices.GroupBy(x => x.Date).Select(x => new
            {
                Key = x.Key,
                Items = x.GroupBy(y => y.Customer).Select(y => new
                    {
                        Key = y.Key,
                        Items = y.Select(z => z.Id).ToList()
                    })
            }).ToList();

Answer 3

您需要一种能够表示树结构的类型。 框架中有一些类型可以使用 - 例如 KeyValuePair、树视图节点 TreeNode、XML 元素 XmlElement > 和 XElement，可能还有更多。 以下示例包含两个使用 XElement 表示树的解决方案。 一种使用 lambda 来访问成员，另一种使用字符串，两者都有优点和缺点。 我认为可以从具有更复杂代码的解决方案中获得最佳效果。

static void Main()
{
    IEnumerable<Invoice> invoices = new List<Invoice>()
    { 
        new Invoice() { Id = 1, Customer = "a", Date = DateTime.Parse("1/1/2009") },
        new Invoice() { Id = 2, Customer = "a", Date = DateTime.Parse("1/2/2009") }, 
        new Invoice() { Id = 3, Customer = "a", Date = DateTime.Parse("1/2/2009") }, 
        new Invoice() { Id = 4, Customer = "b", Date = DateTime.Parse("1/1/2009") }, 
        new Invoice() { Id = 5, Customer = "b", Date = DateTime.Parse("1/1/2009") }, 
        new Invoice() { Id = 6, Customer = "b", Date = DateTime.Parse("1/2/2009") } 
    };


    StringBuilder sb = new StringBuilder();
    TextWriter tw = new StringWriter(sb);

    using (XmlWriter xmlWriter = new XmlTextWriter(tw) { Formatting = Formatting.Indented })
    {

        XElement t1 = new XElement("Root", BuildTree(invoices, i => i.Customer, i => i.Date, i => i.Id));
        XElement t2 = new XElement("Root", BuildTree(invoices, "Customer", "Date", "Id"));

        var xyz = t2.Elements("Customer").ElementAt(1).Descendants("Item").Count();

        t1.WriteTo(xmlWriter);
        t2.WriteTo(xmlWriter);
    }

    Console.WriteLine(sb.ToString());

    Console.ReadLine();
}

public static IEnumerable<XElement> BuildTree<T>(IEnumerable<T> collection, params Func<T, Object>[] groups)
{
    if ((groups != null) && (groups.Length > 0))
    {
        return collection
            .GroupBy(groups[0])
            .Select(grp => new XElement(
                "Group",
                new XAttribute("Value", grp.Key),
                BuildTree(grp, groups.Skip(1).ToArray())));
    }
    else
    {
        return collection.Select(i => new XElement("Item"));
    }
}

public static IEnumerable<XElement> BuildTree<T>(IEnumerable<T> collection, params String[] groups)
{
    if ((groups != null) && (groups.Length > 0))
    {
        return collection
            .GroupBy(i => typeof(T).GetProperty(groups[0]).GetValue(i, null))
            .Select(grp => new XElement(
                groups[0],
                new XAttribute("Value", grp.Key),
                BuildTree(grp, groups.Skip(1).ToArray())));
    }
    else
    {
        return collection.Select(i => new XElement("Item"));
    }
}

第一个解决方案的输出如下。

<Root>
  <Group Value="a">
    <Group Value="2009-01-01T00:00:00">
      <Group Value="1">
        <Item />
      </Group>
    </Group>
    <Group Value="2009-02-01T00:00:00">
      <Group Value="2">
        <Item />
      </Group>
      <Group Value="3">
        <Item />
      </Group>
    </Group>
  </Group>
  <Group Value="b">
    <Group Value="2009-01-01T00:00:00">
      <Group Value="4">
        <Item />
      </Group>
      <Group Value="5">
        <Item />
      </Group>
    </Group>
    <Group Value="2009-02-01T00:00:00">
      <Group Value="6">
        <Item />
      </Group>
    </Group>
  </Group>
</Root>

第二种解决方案产生以下结果。

<Root>
  <Customer Value="a">
    <Date Value="2009-01-01T00:00:00">
      <Id Value="1">
        <Item />
      </Id>
    </Date>
    <Date Value="2009-02-01T00:00:00">
      <Id Value="2">
        <Item />
      </Id>
      <Id Value="3">
        <Item />
      </Id>
    </Date>
  </Customer>
  <Customer Value="b">
    <Date Value="2009-01-01T00:00:00">
      <Id Value="4">
        <Item />
      </Id>
      <Id Value="5">
        <Item />
      </Id>
    </Date>
    <Date Value="2009-02-01T00:00:00">
      <Id Value="6">
        <Item />
      </Id>
    </Date>
  </Customer>
</Root>

该解决方案远非完美，但可能会提供一些起点，并且它们提供了 LINQ to XML 查询树的全部功能。 如果您要大量使用此树，我建议为该树构建一个更适合需求的自定义节点类型。 但设计这个可能会非常困难 - 特别是如果你想要强类型。

最后我想提一下，我无法真正看到这样的结构的用途 - 使用 LINQ to object 直接从列表中获取结果不是更容易吗？

Answer 4

您可以按日期和日期对结果进行排序，而不是按树排序。 然后由客户。

Answer 5

我还没有测试过，但我认为 eulerfx 提出的答案是正确的方向。 下面我用 LINQ 理解语法为此类事情编写了自己的解决方案。

var tree =
    (from i in invoices
    group i by i.Date into g1
    select new
    {
        Key = g1.Key,
        Items =
            (from d in g1
            group d by d.Customer into g2
            select new
            {
                Key = g2.Key,
                Items =
                    from d in g2
                    select new
                    {
                        Key = d.Id,
                    }
            }).ToList()
    }).ToList();

ToList() 调用实际上是可选的，具体取决于您试图在投影中实现的目标。

最近我问了一个类似的问题，看来我可能会自己回答。 如果您认为它可能有助于理解有关使用 linq 分组以创建层次结构的其他选项，请查看它。