[Linq] Enumerable.Aggregate[转载]

Enumerable.Aggregate() 是 Linq 的扩展方法，用于对集合序列进行累计操作。第一次使用时，可能有点摸不着头脑。

var ints = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };

var result = ints.Aggregate((total, next) =>

{

Console.WriteLine("total:{0}, next:{1}", total, next);

return total + next;

});

Console.WriteLine(result);

输出:

total:1, next:2

total:3, next:3

total:6, next:4

total:10, next:5

total:15, next:6

total:21, next:7

total:28, next:8

total:36, next:9

45

public static TSource Aggregate<TSource>(

this IEnumerable<TSource> source,

Func<TSource, TSource, TSource> func

)

反编译一下，很容易看明白。

public static TSource Aggregate<TSource>(this IEnumerable<TSource> source,

Func<TSource, TSource, TSource> func)

{

// ... 省略部分代码 ...

using (IEnumerator<TSource> enumerator = source.GetEnumerator())

{

if (!enumerator.MoveNext())

{

throw Error.NoElements();

}

TSource current = enumerator.Current;

while (enumerator.MoveNext())

{

current = func(current, enumerator.Current);

}

return current;

}

}

获取迭代器，提取第一个元素作为初始化累计结果，然后循环遍历其他元素，并依次调用 func 委托进行累计操作。func 有两个参数，第一个参数为上一次 func 的执行结果，第二个参数为要处理的集合元素。当然，我们并不一定要完成统计操作，也可以返回某单次 func 执行结果。

演示: 找回最长的字符串

var strs = new[] { "a", "bb", "cccc", "ddd" };

var result = strs.Aggregate((s, next) =>

{

return next.Length > s.Length ? next : s;

});

Console.WriteLine("Max: {0}", result);

输出:

Max: cccc

除此之外，我们还可以给定一个初始值 (Seed)。

public static TAccumulate Aggregate<TSource, TAccumulate>(

this IEnumerable<TSource> source,

TAccumulate seed,

Func<TAccumulate, TSource, TAccumulate> func

)

和上面不同的是，这个重载方法将 seed 作为初始化累计结果。

public static TAccumulate Aggregate<TSource, TAccumulate>(this IEnumerable<TSource> source,

TAccumulate seed,

Func<TAccumulate, TSource, TAccumulate> func)

{

// ... 省略部分代码 ...

TAccumulate local = seed;

foreach (TSource local2 in source)

{

local = func(local, local2);

}

return local;

}

我们修改一下上面的例子，查找最大的字符串长度。我们提供了一个初始化 seed，也就是说第一次传递给 func 的 maxLength = 3。

var strs = new[] { "a", "bb", "cccc", "ddd" };

var result = strs.Aggregate(3, (maxLength, next) =>

{

Console.WriteLine("maxLength:{0}, next:{1}", maxLength, next);

return next.Length > maxLength ? next.Length : maxLength;

});

Console.WriteLine("Max: {0}", result);

输出:

maxLength:3, next:a

maxLength:3, next:bb

maxLength:3, next:cccc

maxLength:4, next:ddd

Max: 4

另外一个重载，可以对累计结果做出更多的处理。

public static TResult Aggregate<TSource, TAccumulate, TResult>(

this IEnumerable<TSource> source,

TAccumulate seed,

Func<TAccumulate, TSource, TAccumulate> func,

Func<TAccumulate, TResult> resultSelector

)

无非是在返回结果以前多调用一个委托而已。

public static TResult Aggregate<TSource, TAccumulate, TResult>(this IEnumerable<TSource> source,

TAccumulate seed,

Func<TAccumulate, TSource, TAccumulate> func,

Func<TAccumulate, TResult> resultSelector)

{

// ... 省略部分代码 ...

TAccumulate local = seed;

foreach (TSource local2 in source)

{

local = func(local, local2);

}

return resultSelector(local);

}

Func resultSelector 接收 func 的最后执行结果，执行一些特定逻辑后返回修正后的结果。

演示: 找出最长的字符串，并返回其大写结果。

var strs = new[] { "a", "bb", "cccc", "ddd" };

var result = strs.Aggregate("haa",

(maxStr, next) =>

{

Console.WriteLine("maxStr:{0}, next:{1}", maxStr, next);

return next.Length > maxStr.Length ? next : maxStr;

},

(maxStr) =>

{

return maxStr.ToUpper();

});

Console.WriteLine("Max: {0}", result);

输出:

maxStr:haa, next:a

maxStr:haa, next:bb

maxStr:haa, next:cccc

maxStr:cccc, next:ddd

Max: CCCC

Aggregate 可以用来执行一个存储了算法委托集合的算法链。

var algorithms = new Func<string, string>[]

{

s => s + "1",

s => s + "2",

s => s + "3!",

s => s + "4",

};

var result = algorithms.Aggregate("Hello, ", (s, a) =>

{

if (s.EndsWith("!")) return s;

return a(s);

});

Console.WriteLine(result);

输出:

Hello, 123!