组内的 LINQ 到对象索引 + 对于不同的分组（又名 ROW_NUMBER 与 PARTITION BY 等效）

Question

经过大量 Google 搜索和代码实验后，我被一个复杂的 C# LINQ-to-objects 问题难住了，在 SQL 中，使用一对 ROW_NUMBER()...PARTITION BY 函数和一个或两个子查询很容易解决这个问题。

简而言之，这就是我在代码中尝试做的事情——基本要求是从列表中删除重复的文档：

1. 首先，按 (Document.Title, Document.SourceId) 对列表进行分组，假设有一个（简化的）类定义像这样：
   

   类文档 
     { 
         字符串标题； 
         int 源 ID；   // 源具有优先级（ID=1 优于 ID=2） 
     }

2. 在该组中，为每个文档分配一个索引（例如，索引 0 == 具有此来源的此标题的第一个文档，索引 1 = 具有此来源的此标题的第二个文档，等等）。 我喜欢 SQL 中 ROW_NUMBER() 的等效项！
   
   
3. 现在按 (Document.Title, Index) 分组，其中 Index 是在步骤 #2 中计算的。 对于每一组，仅返回一个文档：Document.SourceId 最低的文档。

步骤＃1很简单（例如codepronet.blogspot.com/2009/01/group-by-in-linq.html），但我在步骤＃2和＃3上遇到了困难。 我似乎无法构建一个无红色曲线的 C# LINQ 查询来解决所有三个步骤。

Anders Heilsberg 在 此主题上的帖子 是我认为如果语法正确的话，上面的步骤 #2 和 #3 的答案。

我宁愿避免使用外部局部变量来进行索引计算，正如 slodge.blogspot.com/2009/01/adding-row-number-using-linq-to-objects.html 上建议的那样，因为该解决方案会中断如果外部变量被修改。

最佳情况下，可以首先完成按标题分组步骤，因此“内部”分组（首先按源计算索引，然后按索引过滤掉重复项）可以对每个“按标题”中的少量对象进行操作组，因为每个按标题组中的文档数量通常低于 100。我真的不想要 N² 解决方案！

我当然可以使用嵌套的 foreach 循环来解决这个问题，但这似乎是使用 LINQ 应该很简单的问题。

有任何想法吗？

Answer 1

我认为 jpbochi 错过了您希望按值对进行分组（标题+SourceId，然后标题+索引）。 这是一个 LINQ 查询（主要）解决方案：

var selectedFew = 
    from doc in docs
    group doc by new { doc.Title, doc.SourceId } into g
    from docIndex in g.Select((d, i) => new { Doc = d, Index = i })
    group docIndex by new { docIndex.Doc.Title, docIndex.Index } into g
    select g.Aggregate((a,b) => (a.Doc.SourceId <= b.Doc.SourceId) ? a : b);

首先，我们按 Title+SourceId 进行分组（我使用匿名类型，因为编译器为分组查找构建了一个良好的哈希码）。 然后我们使用 Select 将分组索引附加到文档，我们在第二个分组中使用它。 最后，对于每个组，我们选择最低的 SourceId。

鉴于此输入：

var docs = new[] {
    new { Title = "ABC", SourceId = 0 },
    new { Title = "ABC", SourceId = 4 },
    new { Title = "ABC", SourceId = 2 },
    new { Title = "123", SourceId = 7 },
    new { Title = "123", SourceId = 7 },
    new { Title = "123", SourceId = 7 },
    new { Title = "123", SourceId = 5 },
    new { Title = "123", SourceId = 5 },
};

我得到此输出：

{ Doc = { Title = ABC, SourceId = 0 }, Index = 0 }
{ Doc = { Title = 123, SourceId = 5 }, Index = 0 }
{ Doc = { Title = 123, SourceId = 5 }, Index = 1 }
{ Doc = { Title = 123, SourceId = 7 }, Index = 2 }

更新：我刚刚看到您关于首先按标题分组的问题。 您可以在标题组上使用子查询来执行此操作：

var selectedFew =
    from doc in docs
    group doc by doc.Title into titleGroup
    from docWithIndex in
        (
            from doc in titleGroup
            group doc by doc.SourceId into idGroup
            from docIndex in idGroup.Select((d, i) => new { Doc = d, Index = i })
            group docIndex by docIndex.Index into indexGroup
            select indexGroup.Aggregate((a,b) => (a.Doc.SourceId <= b.Doc.SourceId) ? a : b)
        )
    select docWithIndex;

Answer 2

说实话，我对你的问题很困惑。 也许你应该解释一下你想要解决的问题。 无论如何，我会尝试回答我所理解的。

1) 首先，我假设您已经有一个按 Title+SourceId 分组的文档列表。 出于测试目的，我硬编码了一个列表，如下所示：

var docs = new [] {
    new { Title = "ABC", SourceId = 0 },
    new { Title = "ABC", SourceId = 4 },
    new { Title = "ABC", SourceId = 2 },
    new { Title = "123", SourceId = 7 },
    new { Title = "123", SourceId = 5 },
};

2) 要在每个项目中放置索引，您可以使用 Select 扩展方法，传递 Func 选择器函数。 像这样：

var docsWithIndex
    = docs
    .Select( (d, i) => new { Doc = d, Index = i } );

3）根据我的理解，下一步是按 Title 对最后一个结果进行分组。 操作方法如下：

var docsGroupedByTitle
    = docsWithIndex
    .GroupBy( a => a.Doc.Title );

GroupBy 函数（上面使用的）返回 IEnumerable>。 由于群也是可枚举的，所以我们现在有可枚举的可枚举的。

4) 现在，对于上面的每个组，我们将仅获取具有最小 SourceId 的项目。 为了进行此操作，我们需要 2 级递归。 在 LINQ 中，外层是一个选择（对于每个组，获取其其中一个项目），内层是一个聚合（获取具有最低 SourceId 的项目）：

var selectedFew
    = docsGroupedByTitle
    .Select(
        g => g.Aggregate(
            (a, b) => (a.Doc.SourceId  <= b.Doc.SourceId) ? a : b
        )
    );

只是为了确保它有效，我用一个简单的 foreach 测试了它：

foreach (var a in selectedFew) Console.WriteLine(a);
//The result will be:
//{ Doc = { Title = ABC, SourceId = 0 }, Index = 0 }
//{ Doc = { Title = 123, SourceId = 5 }, Index = 4 }

我不确定这就是你想要的。 如果没有，请评论答案，我可以修复答案。 我希望这有帮助。

观察：我的测试中使用的所有类都是匿名。 因此，您实际上不需要定义 DocumentWithIndex 类型。 实际上，我什至还没有声明一个 Document 类。

Answer 3

基于方法的语法：

var selectedFew = docs.GroupBy(doc => new {doc.Title, doc.SourceId}, doc => doc)
                      .SelectMany((grouping) => grouping.Select((doc, index) => new {doc, index}))
                              .GroupBy(anon => new {anon.doc.Title, anon.index})
                              .Select(grouping => grouping.Aggregate((a, b) =>    a.doc.SourceId <= b.doc.SourceId ? a : b));

您认为上面的语法是等效的基于方法的语法吗？

Answer 4

我实现了一个扩展方法。 它支持多个字段分区以及多个订单条件。

public static IEnumerable<TResult> Partition<TSource, TKey, TResult>(
    this IEnumerable<TSource> source, 
    Func<TSource, TKey> keySelector,
    Func<IEnumerable<TSource>, IOrderedEnumerable<TSource>> sorter,
    Func<TSource, int, TResult> selector)
{
    AssertUtilities.ArgumentNotNull(source, "source");

    return source
        .GroupBy(keySelector)
        .Select(arg => sorter(arg).Select(selector))
        .SelectMany(arg => arg);
}

用法：

var documents = new[] 
{
    new { Title = "Title1", SourceId = 1 },
    new { Title = "Title1", SourceId = 2 },
    new { Title = "Title2", SourceId = 15 },
    new { Title = "Title2", SourceId = 14 },
    new { Title = "Title3", SourceId = 100 }
};

var result = documents
    .Partition(
        arg => arg.Title,  // partition by
        arg => arg.OrderBy(x => x.SourceId), // order by
        (arg, rowNumber) => new { RowNumber = rowNumber, Document = arg }) // select
    .Where(arg => arg.RowNumber == 0)
    .Select(arg => arg.Document)
    .ToList();

结果：

{ Title = "Title1", SourceId = 1 },
{ Title = "Title2", SourceId = 14 },
{ Title = "Title3", SourceId = 100 }