Super court Les fonctions d'agrégation fonctionnent comme fold en Haskell/ML/F#.
Légèrement plus long .Max(), .Min(), .Sum(), .Average() itère sur les éléments d'une séquence et les agrège en utilisant la fonction d'agrégation respective. .Aggregate () est un agrégateur généralisé car il permet au développeur de spécifier l'état initial (également appelé seed) et la fonction d'agrégation.
Je sais que vous avez demandé une explication courte mais comme d'autres ont donné quelques réponses courtes, j'ai pensé que vous seriez peut-être intéressé par une réponse un peu plus longue
Version longue avec du code Une façon d'illustrer ce que cela pourrait être est de montrer comment implémenter l'écart type en utilisant une boucle foreach une fois et en utilisant .Aggregate une fois. Remarque : Je n'ai pas privilégié les performances ici donc je parcours plusieurs fois la collection inutilement
Tout d'abord une fonction d'aide utilisée pour créer une somme des distances quadratiques :
static double SumOfQuadraticDistance (double average, int value, double state)
{
var diff = (value - average);
return state + diff * diff;
}
Ensuite l'écart type en utilisant ForEach :
static double SampleStandardDeviation_ForEach (
this IEnumerable ints)
{
var length = ints.Count();
if (length < 2)
{
return 0.0;
}
const double seed = 0.0;
var average = ints.Average();
var state = seed;
foreach (var value in ints)
{
state = SumOfQuadraticDistance(average, value, state);
}
var sumOfQuadraticDistance = state;
return Math.Sqrt(sumOfQuadraticDistance / (length - 1));
}
Puis une fois en utilisant .Aggregate :
static double SampleStandardDeviation_Aggregate (
this IEnumerable ints)
{
var length = ints.Count();
if (length < 2)
{
return 0.0;
}
const double seed = 0.0;
var average = ints.Average();
var sumOfQuadraticDistance = ints
.Aggregate(
seed,
(state, value) => SumOfQuadraticDistance(average, value, state)
);
return Math.Sqrt(sumOfQuadraticDistance / (length - 1));
}
Remarquez que ces fonctions sont identiques sauf pour la façon dont sumOfQuadraticDistance est calculé :
var state = seed;
foreach (var value in ints)
{
state = SumOfQuadraticDistance(average, value, state);
}
var sumOfQuadraticDistance = state;
Comparé à :
var sumOfQuadraticDistance = ints
.Aggregate(
seed,
(state, value) => SumOfQuadraticDistance(average, value, state)
);
Donc ce que fait .Aggregate c'est qu'il encapsule ce motif d'agrégation et je m'attends à ce que l'implémentation de .Aggregate ressemble à ceci :
public static TAggregate Aggregate (
this IEnumerable values,
TAggregate seed,
Func aggregator
)
{
var state = seed;
foreach (var value in values)
{
state = aggregator(state, value);
}
return state;
}
Utiliser les fonctions d'écart type ressemblerait à ceci :
var ints = new[] {3, 1, 4, 1, 5, 9, 2, 6, 5, 4};
var average = ints.Average();
var sampleStandardDeviation = ints.SampleStandardDeviation_Aggregate();
var sampleStandardDeviation2 = ints.SampleStandardDeviation_ForEach();
Console.WriteLine(average);
Console.WriteLine(sampleStandardDeviation);
Console.WriteLine(sampleStandardDeviation2);
À mon avis
Est-ce que .Aggregate aide à la lisibilité ? En général, j'adore LINQ car je pense que .Where, .Select, .OrderBy et ainsi de suite aident grandement à la lisibilité (si vous évitez les .Selects hiérarchiques en ligne). Aggregate doit être dans Linq pour des raisons de complétude mais personnellement je ne suis pas convaincu que .Aggregate ajoute de la lisibilité par rapport à un foreach bien écrit.
