使用 linq 对数据进行分层分组 - 删除递归答案

【问题标题】：Hierarchical grouping data using linq - remove recursion使用 linq 对数据进行分层分组 - 删除递归
【发布时间】：2016-02-25 11:05:03
【问题描述】：

我在这个 stackoverflow 中找到了分层分组的好解决方案。

How can I hierarchically group data using LINQ?

它对我帮助很大，但我想问我如何才能达到相同的结果，但没有递归。老实说，我在转换它时遇到了问题，因为递归对我来说是自然的方法。任何人都可以将此方法转换为不使用递归？

用法：

var result = customers.GroupByMany(c => c.Country, c => c.City);

已编辑：

public class GroupResult
{
    public object Key { get; set; }
    public int Count { get; set; }
    public IEnumerable<GroupResult> SubGroups { get; set; }
    public override string ToString()
    { return string.Format("{0} ({1})", Key, Count); }
}

public static class MyEnumerableExtensions
{
    public static IEnumerable<GroupResult> GroupByMany<TElement>(
        this IEnumerable<TElement> elements,
        params Func<TElement, object>[] groupSelectors)
    {
        if (groupSelectors.Length > 0)
        {
            var selector = groupSelectors.First();

            //reduce the list recursively until zero
            var nextSelectors = groupSelectors.Skip(1).ToArray();
            return
                elements.GroupBy(selector).Select(
                    g => new GroupResult
                    {
                        Key = g.Key,
                        Count = g.Count(),
                        SubGroups = g.GroupByMany(nextSelectors)
                    });
        }
        return null;
    }
}

提前致谢

【问题讨论】：

提示。使用循环而不是带有递归的 if 语句 while(groupselectors.Length > 0) do things inside loop
有什么理由需要移除递归？
顺便说一句，您发布的代码无法编译。
@Ivan Stoev 现在应该可以编译了
谢谢，但如果你能提供某种动机（理由）来满足转换的需要，那就太好了。

标签： c# linq recursion refactoring hierarchy

【解决方案1】：

有点挑战性，但你去吧：

public class GroupResult<T>
{
    public object Key { get; set; }
    public int Count { get; set; }
    public IEnumerable<T> Items { get; set; }
    public IEnumerable<GroupResult<T>> SubGroups { get; set; }
    public override string ToString() { return string.Format("{0} ({1})", Key, Count); }
}

public static class MyEnumerableExtensions
{
    public static IEnumerable<GroupResult<TElement>> GroupByMany<TElement>(
        this IEnumerable<TElement> elements,
        params Func<TElement, object>[] groupSelectors)
    {
        Func<IEnumerable<TElement>, IEnumerable<GroupResult<TElement>>> groupBy = source => null;
        for (int i = groupSelectors.Length - 1; i >= 0; i--)
        {
            var keySelector = groupSelectors[i]; // Capture
            var subGroupsSelector = groupBy; // Capture
            groupBy = source => source.GroupBy(keySelector).Select(g => new GroupResult<TElement>
            {
                Key = g.Key,
                Count = g.Count(),
                Items = g,
                SubGroups = subGroupsSelector(g)
            });
        }
        return groupBy(elements);
    }
}

诀窍是以相反的顺序构建分组 lambda 表达式，使用上一步的结果并使用闭包来捕获执行 lambda 所需的必要信息。

【讨论】：

【解决方案2】：

主要问题应该是为什么要从实现中摆脱递归？您提供的代码具有最大递归深度 = groupSelectors.Length。在这种情况下，我认为堆栈的使用不应该是您关心的问题。

Ivan 提供的解决方案是正确的，但我认为它也有间接递归方法，并提供相同的堆栈消耗水平。它不是命名声明的方法调用，而是构建嵌套委托 (Func) 调用链。

如果您的目标是欺骗一些静态代码分析工具（它们通常不喜欢递归调用），您可以将 GroupByMany 的一部分提取到单独的方法中，然后相互调用。

【讨论】：