Comments on: System.Linq.Enumerable.Aggregate – Better Know an Extension Method Part 1

By: loopdoop

loopdoop — Thu, 03 Dec 2009 15:17:08 +0000

defeniately bookmarked

By: Paul

Paul — Thu, 07 May 2009 13:22:22 +0000

Is this only available in vs 2008 or could I use this functionality in vs 2005 and just include the System.Core?

By: Tristan Smith

Tristan Smith — Mon, 30 Mar 2009 10:08:49 +0000

It’s surprising just how much of a productivity boost advances like this give us.

Nice tip!

By: Bart Czernicki

Bart Czernicki — Fri, 20 Feb 2009 05:21:58 +0000

The aggregate function expression is also part of the F# functional language. Other places it is useful is when doing things like a weighted average on the fly for records bound in a data grid control or doing statistical calculations or business intelligence calcs. Back in the .NET 1.x days this was such a pain in the ass (as I didn’t understand delegates back then well enough to be dangerous).

By: Niki

Niki — Thu, 19 Feb 2009 14:31:53 +0000

Sorry, the part about folds was a little cryptic: What I meant was that Enumerable.Aggregate is equivalent to the operation called “left fold” in functional programming (http://en.wikipedia.org/wiki/Fold_(higher-order_function) ).

In functional programming, folding is often used to build complex data structures like lists: You define a function called “Cons” that builds a linked list, so if nil is the empty list Cons(1, nil) would be the list containing only the element 1, Cons(1, Cons(2, nil)) would be the list containing 1,2 and so on. Then you can do things like (in .NET syntax):
myList.Aggregate( (nextElement, list) => Cons(nextElement, list), nil);
or shorter:
myList.Aggregate(Cons, nil);
Which would just duplicate the list. But you can do any kind of processing in the fold, e.g. you might check for a condition:
myList.Aggregate( (nextElement, list) => someCondition(nextElement) ? Cons(nextElement, list) : list, nil);
which filters a list like “Enumerable.Where”.

By: Chris Hampson

Chris Hampson — Thu, 19 Feb 2009 12:11:52 +0000

@Niki didnt really think of it in the way of a fold, what do you mean by con?

By: Chris Hampson

Chris Hampson — Thu, 19 Feb 2009 12:10:33 +0000

@J thanks I will look at this some more and update the article.

By: J

Thu, 19 Feb 2009 11:43:04 +0000

Note that in Test Case 3 you can change the result type in the last overload. So instead of x => x.Append(“DONE”) you can do x => x.ToString(), and not have to worry about the string builder object except in the scope of the Aggregate function.

This same technique could be used in the last example to convert the double to decimal.

By: Niki

Niki — Thu, 19 Feb 2009 10:46:23 +0000

@Chris: There are lots of use cases for Aggregate: The most obvious are of course logical/arithmetic operations. Enumerable does have a Sum extension method, but with Aggregate you can also easily calculate the product of a list of numbers, or the sum of the squares, or an xor-checksum.
(Actually, Aggregate is a lot more general than that: Almost any list processing can be simplified to a fold aka Enumberable.Aggregate. Unfortunately, Linq has no built-in equivalent for Cons, so it’s harder to exploit the general power of Aggregate to build new lists as result.)

BTW: I think you’re not using it the way it’s meant:
var roundedGrandTotal = orders.Aggregate(new double(),
(total, order) => total += order.Total,
(total) => Math.Round(total, 2));

In the second parameter “(total, order) => total += order.Total”, the “total” parameter of the lambda expression is not a mutable variable. It’s a by-value parameter, and it’s value is lost as soon as it goes out of scope. Your code only works because += has a value. This would be clearer:
var roundedGrandTotal = orders.Aggregate(new double(),
(total, order) => total + order.Total,
(total) => Math.Round(total, 2));

By: Neil Bostrom

Neil Bostrom — Thu, 19 Feb 2009 10:09:00 +0000

Great article, so many hidden gems in those extension methods on IEnumerable.

Keep up the great work!