LINQ sum 项目集合以返回带有结果的对象（多列）

Question

我知道我可以用 foreach 来做下面的事情，但想知道是否有一种干净和“性感”的方式来用 LINQ 来做这件事。

public class item
{
    public int total { get; set; }
    public int net { get; set; }
}


class Program
{
    static void Main(string[] args)
    {
        List<item> items = new List<item>()
                               {
                                   new item() { total = 123, net = 423},
                                   new item() { total = 432, net = 54},
                                   new item() { total = 33, net = 57654},
                                   new item() { total = 33, net = 423},
                                   new item() { total = 3344, net = 423},
                                   new item() { total = 123, net = 423},
                                   new item() { total = 123, net = 98},
                                   new item() { total = 123, net = 867},
                                   new item() { total = 123, net = 876},
                                   new item() { total = 123, net = 423},
                                   new item() { total = 123, net = 543},
                                   new item() { total = 543, net = 345},
                               };

        item i = new item();
        foreach (var item in items)
        {
            i.net += item.net;
            i.total += item.total;
        }
    }
}

我想要做的是，对于给定的对象列表，对每个列/字段求和并返回一个具有每个值总和的对象。

我试过了：

var result = (from e in items
                     select new
                                {
                                    NET_GRAND = e.net,
                                    TOTAL_GRAND = e.total
                                }).ToList();

以及下面的变化，但没有运气：

 var result = (from t in items
                     group t by new {t.net, t.total}
                     into grp
                     select new
                                {
                                    NET_GRAND = grp.Sum(t => t.net),
                                    TOTAL_GRAND = grp.Sum(t => t.total)
                                }).GroupBy(x => new { x.NET_GRAND, x.TOTAL_GRAND }).ToList();

编辑

应该指出，效率在这里很重要，性感也很重要。

Answer 1

如果你不关心重复列表两次，

var i = new item
    { 
        net = items.Sum(it => it.net), 
        total = items.Sum(it => it.total) 
    };

如果您确实关心对列表进行两次迭代（就像您为未知来源的IEnumerable执行此操作一样），

var i = items.Aggregate(new item(), 
    (accumulator, it) => 
        new item 
        {
            net = accumulator.net + it.net, 
            total = accumulator.total + it.total 
        } 
);

Answer 2

看起来你真的想要：

var result = new {
    NetGrand = items.Sum(t => t.net),
    TotalGrand = items.Sum(t => t.total)
};

另一方面，我可能只是将它们分成两个不同的局部变量：

var netGrand = items.Sum(t => t.net);
var totalGrand = items.Sum(t => t.total);

当然，这会遍历列表两次，但在大多数情况下，我希望这不会引起注意。

Answer 3

item totals = new item 
              { 
                 net = items.Sum(i => i.net),
                 total = items.Sum(i => i.total)  
              };

但是，请记住，这个查询将枚举列表两次，所以对于大名单这不会那么有效，因为老好单foreach循环。

Answer 4

var item = new item();
item.net = items .Sum(x=>x.net);
item.total = items.Sum(x=>x.total);

Answer 5

使用 foreach 循环。 您声明您关心效率，即使您不关心，也没有理由为了使用 Linq 而使用 Linq 编写它。

随着我们获得更多程序经验，我们发现的一件事是，仅仅因为某些事情是“以旧方式”完成的，并不会使它变得糟糕。 转换为 new-wiz-bang 方法并不会让它变得更好。 事实上，如果你的代码以旧方式工作，“升级”是注入缺陷的一个原因，在许多情况下没有任何好处。

充其量，此 Linq 方法将花费 2 倍的时间来计算。

var i = new item
    { 
        net = items.Sum(it => it.net), 
        total = items.Sum(it => it.total) 
    };

不确定聚合方法，但显然需要更长的时间。

Answer 6

我相信您可以使用 LINQ 完成此操作，而无需通过使用 GroupBy 和键的常量值（在这种情况下我使用 1）进行迭代。

item totals = items.GroupBy(i => 1).Select(g => new item()
{
    net = g.Sum(i => i.net),
    total = g.Sum(i => i.total)
}).Single();