Comment fonctionne la fonction d'agrégation de LINQ pour la sommation, la concaténation et la multiplication ?

LINQ Aggregate : une explication complète

La fonction LINQ Aggregate effectue une opération sur une séquence d'éléments tout en prenant en compte les résultats des opérations précédentes. Essentiellement, il traite de manière itérative chaque élément de la séquence, accumulant le résultat de l'opération.

Description et exemples

Pour comprendre Aggregate, considérez les définitions et exemples suivants :

• Sommation : Calcule la somme d'une série de nombres.

var nums = new[] { 1, 2, 3, 4 };
var sum = nums.Aggregate((a, b) => a + b);
Console.WriteLine(sum); // Output: 10 (1 + 2 + 3 + 4)

• Concaténation de chaînes : Crée une liste séparée par des virgules à partir d'un tableau de chaînes.

var chars = new[] { "a", "b", "c", "d" };
var csv = chars.Aggregate((a, b) => a + "," + b);
Console.WriteLine(csv); // Output: a,b,c,d

• Multiplication avec graine : Commence par une valeur de graine et la multiplie par chaque élément dans la séquence.

var multipliers = new[] { 10, 20, 30, 40 };
var multiplied = multipliers.Aggregate(5, (a, b) => a * b);
Console.WriteLine(multiplied); // Output: 1200000 ((((5 * 10) * 20) * 30) * 40)

Exemples détaillés

Exemple 1 : Somme des nombres

var nums = new[] { 1, 2, 3, 4 };
var sum = nums.Aggregate((a, b) => a + b);

Explication :

• La fonction Agrégation commence par les deux premiers éléments, 1 et 2, et effectue l'addition (1 2 = 3).
• Le résultat (3) devient l'accumulateur (a) pour l'étape suivante.
• L'accumulateur est ensuite combiné avec l'élément suivant, 3, résultant en un nouvel accumulateur (6).
• Ce processus se poursuit jusqu'à ce que tous les éléments aient été traités, accumulant la somme (6 4 = 10).

Exemple 2 : Création d'un CSV à partir de chaînes

var chars = new[] { "a", "b", "c", "d" };
var csv = chars.Aggregate((a, b) => a + "," + b);

Explication :

• Comme l'exemple précédent, Aggregate parcourt la séquence.
• Il démarre en combinant les deux premiers éléments ("a" et "b") en "a,b".
• L'accumulateur ("a,b") est ensuite concaténé avec l'élément suivant ("c") pour devient "a,b,c".
• Le résultat final est une chaîne avec tous les éléments séparés par des virgules ("a,b,c,d").

Exemple 3 : Multiplier des nombres avec une graine

var multipliers = new[] { 10, 20, 30, 40 };
var multiplied = multipliers.Aggregate(5, (a, b) => a * b);

Explication :

• L'agrégat accepte une surcharge où une valeur "seed" (5) est fourni.
• La graine est la valeur initiale de l'accumulateur.
• La fonction multiplie l'accumulateur par le premier élément (5 * 10 = 50).
• L'accumulateur résultant (50) est ensuite multiplié par l'élément suivant (50 * 20 = 1000).
• Ce processus se poursuit, finalement multiplier tous les éléments et la graine (1 000 * 40 = 1 200 000).

Conclusion

LINQ Aggregate fournit un moyen puissant d'effectuer diverses opérations sur des séquences, notamment la sommation, la concaténation et la multiplication. accumulation. Sa polyvalence et sa facilité d'utilisation en font un outil précieux pour la manipulation de données en C# et d'autres langages .NET.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!