Agregado LINQ

Resumo : neste tutorial, você aprenderá como usar o Aggregate()método LINQ para realizar uma operação cumulativa em uma sequência.

Introdução ao método LINQ Aggregate()

O Aggregate()método realiza uma operação em cada elemento de uma sequência, levando em consideração o resultado da operação anterior.

O Aggregate()método começa executando uma operação no primeiro e no segundo elementos da sequência e depois leva o resultado adiante. Em seguida, ele opera no resultado anterior e no terceiro elemento e transporta o resultado adiante.

O Aggregate()método continua esse processo para todos os elementos restantes da sequência. Ao final, combina todos os elementos em um único resultado baseado na operação realizada em cada etapa.

Aqui está a sintaxe do Aggregate()método LINQ:

public static TSource Aggregate<TSource>(
    this IEnumerable<TSource> source, 
    Func<TSource, TSource, TSource> func
);Linguagem de código:  C#  ( cs )

Nesta sintaxe:

• source é a sequência de entrada que tem o tipo de Enumerable<T>.
• func– uma expressão lambda que executa a operação nos elementos da sequência.

A expressão lambda leva dois parâmetros:

• Um acumulador que armazena o resultado da operação anterior.
• O valor atual da sequência.

O Aggregate()método possui uma sobrecarga que aceita um valor inicial da seguinte maneira:

public static TResult Aggregate<TSource,TAccumulate,TResult> (
    IEnumerable<TSource> source, 
    TAccumulate seed, 
    Func<TAccumulate,TSource,TAccumulate> func
);Linguagem de código:  C#  ( cs )

Nesta sintaxe, o Aggregate()método começa a operar no valor inicial com o primeiro elemento e carrega o resultado adiante.

Caso queira transformar o resultado, você pode passar a resultSelectorfunção para o Aggregate()método da seguinte forma:

public static TResult Aggregate<TSource,TAccumulate,TResult> (
    IEnumerable<TSource> source, 
    TAccumulate seed, 
    Func<TAccumulate,TSource,TAccumulate> func, 
    Func<TAccumulate,TResult> resultSelector
);Linguagem de código:  C#  ( cs )

Nesta sintaxe, o resultSelectortransforma o valor final do acumulador no valor do resultado.

Exemplos de métodos LINQ Aggregate()

Vejamos alguns exemplos de uso do Aggregate()método.

1) Usando LINQ Aggregate() para calcular a soma dos números

O exemplo a seguir demonstra como usar o Aggregate()método LINQ para calcular a soma dos números de uma lista:

using static System.Console;

List<int> numbers = new() { 1, 2, 3, 4, 5 };
var step = 0;

int result = numbers.Aggregate((acc, current) =>
{
    step++;
    var sum = acc + current;
    WriteLine($"Step {step}: acc={acc}, current={current}, sum={sum}");
    return sum;
});Linguagem de código:  C#  ( cs )

Saída:

Step 1: acc=1, current=2, sum=3
Step 2: acc=3, current=3, sum=6
Step 3: acc=6, current=4, sum=10
Step 4: acc=10, current=5, sum=15Linguagem de código:  C#  ( cs )

Como funciona.

Primeiro, defina uma lista que contenha cinco números de 1 a 5:

List<int> numbers = new() { 1, 2, 3, 4, 5 };Linguagem de código:  C#  ( cs )

Segundo, defina uma variável nessa etapa e inicialize-a com zero:

var step = 0;Linguagem de código:  C#  ( cs )

Terceiro, use o Aggregate()método para realizar uma soma cumulativa na lista. A expressão lambda especificada no Aggregate()método adiciona dois números e retorna o total. Além disso, a expressão lambda incrementa a variável step e grava o valor atual de acc, current e sum no console:

int result = numbers.Aggregate((acc, current) =>
{
    step++;
    var sum = acc + current;
    WriteLine($"Step {step}: acc={acc}, current={current}, sum={sum}");
    return sum;
});Linguagem de código:  C#  ( cs )

O Aggregate()método começa com dois elementos da lista de números e os soma para retornar 3. O Aggregate()método então pega 3 e adiciona-o ao próximo número da lista (3) para obter 6. O método repete esse processo para os elementos restantes. Ele retorna o resultado final de 15.

O programa a seguir simplificou o programa acima sem gravar os resultados imediatos no console:

using static System.Console;

List<int> numbers = new() { 1, 2, 3, 4, 5 };

int result = numbers.Aggregate((acc, current) => acc + current);

WriteLine(result);Linguagem de código:  C#  ( cs )

Observe que o objetivo deste programa é ajudá-lo a entender como Aggregate()funciona. Na prática, você deve usar a Sum()função.

2) Usando LINQ Aggregate() com um valor inicial

O programa a seguir demonstra como usar o Aggregate()método LINQ com um valor inicial para multiplicar todos os números em uma lista:

using static System.Console;

var numbers = new List<int> { 1, 2, 3, 4, 5 };
var product = numbers.Aggregate(10, (acc, current) => acc * current);

WriteLine(product);Linguagem de código:  C#  ( cs )

Saída:

1200Linguagem de código:  C#  ( cs )

Neste exemplo, usamos o Aggregate()método para multiplicar todos os números da lista de números e retornar o resultado.

O Aggregate()método começa com um valor inicial (10) e multiplica-o pelo primeiro número da lista de números, que resulta em 10.

O Aggregate()método então multiplica o resultado (10) pelo próximo elemento da lista (2) para obter 20.

O Aggregate()método repete esse processo para os números restantes da lista até multiplicar todos os números e retornar o resultado final de 1200.

3) Usando o método LINQ Aggregate() com uma função resultSelector

O exemplo a seguir demonstra como usar o Aggregate()método LINQ com uma função seletora de resultados:

List<string> words = new() {"simple", "is", "better", "than", "complex" };

string sentence = words.Aggregate(
    "",
    (acc, word) => { return acc != string.Empty ? acc + " " + word : word; },
    acc => acc.ToUpper()
);

Console.WriteLine(sentence);Linguagem de código:  C#  ( cs )

Saída:

SIMPLE IS BETTER THAN COMPLEXLinguagem de código:  C#  ( cs )

Como funciona.

Primeiro, defina uma lista com cinco strings.

Segundo, use o Aggregate()método para concatenar todas as strings da lista, separadas por espaços, e converter o acumulador final em maiúsculas.

A primeira expressão lambda leva dois parâmetros acce uma palavra que representa o acumulador e o elemento atual sendo processado respectivamente:

(acc, word) =>
{
    return acc != string.Empty ? acc + " " + word : word;
}Linguagem de código:  C#  ( cs )

Ele concatena o elemento string atual com o acumulador, separado por um espaço se o acumulador não estiver vazio, e retorna o resultado como um acumulador.

A segunda expressão lambda usa um único parâmetro accque representa o valor final do acumulador. Ele converte esse valor para maiúscula e o retorna como resultado final do Aggregate()método:

acc => acc.ToUpper()Linguagem de código:  C#  ( cs )

Resumo

• Use o Aggregate()método para realizar uma operação no primeiro e no segundo elementos e levar o resultado adiante.