在 LINQ 中分组时将丢失的记录添加到总数（整数）中

Question

我有一个奇怪的情况，我有两个集合。一个集合基本上包含我的项目中的所有 ItemID，而另一个集合仅包含有销售的 ItemID（包括销售数据）。

现在我已经确定，Collection #1 中没有出现在 Collection #2 中的 ItemID 的销售额为 0。现在我不知道该怎么办的情况如下：

var items = new List<Collection1>(); // Contains all ItemIDs where ItemID is a plain string

var itemsTransactions = new List<Collection2>(); // contains item id's that have sales.

现在在第三步中，我将通过 itemsTransationCollection 按名为 Username 的属性进行分组，如下所示：

var groupedByUsername = itemTransactions
    .GroupBy( x => x.Username )
    .Select( item => new MyClass
    {
        TotalItems = item
            .Select( x => x.ItemID )
            .Count(), // sub query should be performed here... ?

        SuccessfulItems = item
            .Select( x => x.ItemID )
            .Count()
    } )
    .ToList();

现在的诀窍是成功商品的计算已经正确，因为 itemsTransactions 集合已经只包含实际有销售额的商品 id...

我不确定如何进行我刚才提到的比较，以将丢失的项目包括在此属性TotalItems 的计数中？

所以我的问题是，是否可以在 LINQ 中进行分组时执行子查询以将丢失的项目添加到属性 TotalItems 的计数中？

谁能帮帮我？

@DavidLee 所以输出应该是这样的：

Username  TotalItems(sold + unsold)  Successful items( only ones with sales)
DavidLee    5                                                   2

xyz         4                                                   1
Ronaldo     19                                                  12 

成功的项目不应大于 TotalListings（这在数学上不可能）

对于@Vlad 示例输入和所需输出：

物品集合

ItemID 用户名

1 卖家1 2 卖家2 3 卖家3 4 卖家4 5 卖家5

itemsTransactions 集合：

ItemID     Username     Sales

1          Seller1       2
2          Seller2       4 
3          Seller3       5 
4          Seller4       6 
5          Seller5       7 
5          Seller5       4

itemsTransactions 集合包含未分组的销售数据...这就是我在第三步中对其进行分组的原因...

Answer 1

这是解决方案的最终版本：

   var result = itemsTransactions.GroupBy(_ => _.Name).Select(_ =>
    new
    {
        SuccessfulCount = _.Select(_ => _.ItemId).Distinct().Count(),
        TotalCount = items.Where(item => item.Name == _.Key).Select(it => it.ItemId).Distinct().Count()
    });

Answer 2

我会创建两个子查询，然后加入它们。我认为主要问题是使用 itemsTransaction 集合作为起始查询，虽然可以做到，但 IMO 从 items 集合开始更容易。非常冗长，可以缩短，但我发现它更容易理解发生了什么。

var itemsByUser = items
    .GroupBy(x => x.Username)
    .Select(x => new
    {
        Username = x.Key,
        Count = x.Count()
    };

var itemsWithSalesByUser = itemTransactions
    .GroupBy(x => x.Username)
    .Select(x => new
    {
        Username = x.Key,
        Count = x.Count()
    };

var joinedDataQuery =
    from i in itemsByUser 
    join s in itemsWithSalesByUser 
        on i.Username equals s.Username into sj
    from s in sj.DefaultIfEmpty() // left join
    select new MyClass
    {
         Username = i.Username
         TotalItems = i.Count,
         SuccessfulItems = s == null ? 0 : s.Count
    };

// this when it goes to memory so building up the queries 
// in separate variables will not have any performance impacts.
var joinedData = joinedDataQuery.ToList(); 

编辑：将 = 更改为 equals

编辑：考虑可能丢失的成功项目。