如何使用LINQ GroupBy进行分组,其中键可以被反转?

5
我正在尝试在LINQ中进行一项复杂的GroupBy操作,但是我在键选择器方面遇到了问题。在下面的代码中,我能够按照一个方向(按SellerID,BuyerID)分组,但实际上我还需要按照相反的方式(按SellerID,BuyerID或BuyerID,SellerID)分组我的关键字。我的最终目标是,当键被颠倒时,我需要使资产金额变为负数。这将允许我计算出两边存在的任何金额的净额,然后我最终将得到只有在特定方面具有金额的记录。
以下代码应该可以解释:
public class Record
{
    public int RecordID;
    public int SellerID;
    public int BuyerID;
    public List<Asset> Assets;
}

public class Asset
{
    public int AssetID;
    public decimal Amount;
}

var groups = new List<Record>
{
    new Record { RecordID = 1, SellerID = 100, BuyerID = 200, Assets = new List<Asset> { new Asset { AssetID = 5, Amount = 10 }}},
    new Record { RecordID = 2, SellerID = 100, BuyerID = 200, Assets = new List<Asset> { new Asset { AssetID = 5, Amount = 20 }}},
    new Record { RecordID = 3, SellerID = 100, BuyerID = 200, Assets = new List<Asset> { new Asset { AssetID = 6, Amount = 60 }}},
    new Record { RecordID = 4, SellerID = 200, BuyerID = 100, Assets = new List<Asset> { new Asset { AssetID = 5, Amount = 40 }}},
    new Record { RecordID = 5, SellerID = 200, BuyerID = 100, Assets = new List<Asset> { new Asset { AssetID = 5, Amount = 50 }}},
    new Record { RecordID = 6, SellerID = 200, BuyerID = 100, Assets = new List<Asset> { new Asset { AssetID = 6, Amount = 35 }}}
};

var result = groups.GroupBy(
    r => new { r.SellerID, r.BuyerID },
    r => r.Assets,
    (r, assets) => new
    {
        r.SellerID,
        r.BuyerID,
        AssetSummation = assets.SelectMany(asset => asset).GroupBy(a => a.AssetID).Select(a2 => new { AssetID = a2.Key, Amount = a2.Sum(a3 => a3.Amount) })
    });

我希望输出的结果如下:
  • 记录1
    • 卖家:100
    • 买家:200
    • 资产:
      • 资产
        • 资产ID:6
        • 金额:25
  • 记录2
    • 卖家:200
    • 买家:100
    • 资产:
      • 资产ID:5
      • 金额:-60
我认为我已经有了一个好的开始,但是我不确定接下来该怎么做。我该如何翻转键并使金额变为负数,以便我可以对它们进行求和?我认为在能够做到这一点之后,我可以过滤掉任何值为0的资产行(这意味着记录由相反的行完成)。
编辑#1:也许我试图做的是将组变量与自身连接,以对连接两侧的所有匹配记录进行求和。因此,我将在左侧将卖方ID与右侧的买方ID连接,在左侧将买方ID与右侧的卖方ID连接。
2个回答

2
这里是一个查询,可以返回您期望的结果:
var result = records
    .SelectMany(r => new[] { r, new Record { // 1
           SellerID = r.BuyerID, 
           BuyerID = r.SellerID, 
           Assets = r.Assets.Select(a => new Asset { 
                        AssetID = a.AssetID, 
                        Amount = -a.Amount
                    }).ToList() }})
    .GroupBy(r => new { r.SellerID, r.BuyerID }) // 2
    .Select(g => new { // 3
           Seller = g.Key.SellerID,
           Buyer = g.Key.BuyerID,
           Assets = g.SelectMany(r => r.Assets)
                     .GroupBy(a => a.AssetID)
                     .Select(ag => new { 
                         AssetID = ag.Key,
                         Amount = ag.Sum(a => a.Amount) })
                     .Where(x => x.Amount > 0) });

它是如何工作的?非常简单:
1. 对于每个记录,我选择两个记录 - 一个不变,另一个将卖家和买家颠倒(所有资产金额都为负数)。 然后使用SelectMany展开所有记录。
2. 并按卖家和买家对它们进行分组。
3. 其余部分是每个组中资产金额的简单计算。
BTW:在最后的select语句中,您可以创建自己的RecordAsset对象,而不是返回匿名对象。

0

辅助类:

public class RecordItem
{
    public int SellerID;
    public int BuyerID;
    public int AssetID;
    public decimal Amount;
}

相等比较器:

public class RecordItemEqualityComparer : IEqualityComparer<RecordItem>
{
    public bool Equals(RecordItem x, RecordItem y)
    {
        if (x.AssetID != y.AssetID)
            return false;

        if (x.BuyerID == y.BuyerID && x.SellerID == y.SellerID)
            return true;

        if (x.BuyerID == y.SellerID && x.SellerID == y.BuyerID)
            return true;

        return false;
    }

    public int GetHashCode(RecordItem obj)
    {
        return string.Format("{0}_{1}", obj.BuyerID * obj.SellerID, obj.AssetID).GetHashCode();
    }
}

还有LINQ查询:

var recordItemComparer = new RecordItemEqualityComparer();

var items = groups.SelectMany(r => r.Assets.Select(a => new RecordItem {
                                                            BuyerID = r.BuyerID,
                                                            SellerID = r.SellerID,
                                                            AssetID =a.AssetID,
                                                            Amount = a.Amount
                                                        }))
                  .GroupBy(ri => ri, recordItemComparer)
                  .Select(g => new RecordItem() {
                        BuyerID = g.Key.BuyerID,
                        SellerID = g.Key.SellerID,
                        AssetID = g.Key.AssetID,
                        Amount = g.Sum(ri => (ri.BuyerID == g.Key.BuyerID) ? ri.Amount : -1 * ri.Amount)
                  }).ToList();

返回你想要的内容:一个包含2个项的列表。总和计算正确,但是买家卖家的顺序可能不正确,所以总和可能是-60而不是60

附注:这真是个很有趣的挑战!


网页内容由stack overflow 提供, 点击上面的
可以查看英文原文,
原文链接