C# Groupby (Comment ça marche pour les développeurs)

En C#, l'option méthode GroupBy** est un outil puissant qui permet d'organiser les éléments d'une source de données en groupes sur la base d'une clé spécifiée. Cette méthode fait partie de LINQ (Langue Requête intégrée) et peut être utilisé pour regrouper des éléments en fonction d'une ou de plusieurs propriétés, ce qui en fait un outil précieux pour l'analyse et la manipulation de données. La méthode GroupBy simplifie les opérations complexes sur les données, permettant une organisation et une recherche efficaces des données sur la base de critères spécifiques. Nous discuterons de Groupby et de IronPDF dans ce blog.

Principes de base de GroupBy

L'essence de la méthode GroupBy réside dans sa capacité à classer les éléments d'une collection donnée dans des groupes en fonction d'une clé spécifiée. Cette propriété clé détermine la manière dont les éléments sont regroupés. Par exemple, vous pouvez regrouper une liste d'étudiants en fonction de leur valeur clé d'âge, créant ainsi des groupes d'étudiants ayant le même âge. Chaque groupe est représenté par une valeur clé et une collection d'éléments qui partagent cette clé. La propriété clé peut être n'importe quel objet, tel qu'une chaîne de caractères, un nombre ou même un objet anonyme, ce qui offre une certaine souplesse dans la manière dont les données sont regroupées.

Utilisation de GroupBy avec la syntaxe de la méthode

En C#, il existe deux façons d'appliquer la méthode GroupBy : la syntaxe de méthode et la syntaxe de requête. La syntaxe de la méthode utilise des expressions lambda pour définir la clé de regroupement et constitue une approche directe de l'application de l'opération GroupBy.

Prenons l'exemple suivant, qui utilise la syntaxe de méthode pour regrouper une liste d'étudiants en fonction de leur âge :

public class Student
{
    public string Name { get; set; }
    public int Age { get; set; }
}
public class Program
{
    public static void Main()
    {
        List<Student> studentList = new List<Student>
        {
            new Student { Name = "Alice", Age = 20 },
            new Student { Name = "Bob", Age = 20 },
            new Student { Name = "Charlie", Age = 21 }
        };
        var groupedResult = studentList.GroupBy(student => student.Age);
        foreach (var group in groupedResult)
        {
            Console.WriteLine($"Age Group: {group.Key}");
            foreach (var student in group)
            {
                Console.WriteLine($"Student Name: {student.Name}");
            }
        }
    }
}

public class Student
{
    public string Name { get; set; }
    public int Age { get; set; }
}
public class Program
{
    public static void Main()
    {
        List<Student> studentList = new List<Student>
        {
            new Student { Name = "Alice", Age = 20 },
            new Student { Name = "Bob", Age = 20 },
            new Student { Name = "Charlie", Age = 21 }
        };
        var groupedResult = studentList.GroupBy(student => student.Age);
        foreach (var group in groupedResult)
        {
            Console.WriteLine($"Age Group: {group.Key}");
            foreach (var student in group)
            {
                Console.WriteLine($"Student Name: {student.Name}");
            }
        }
    }
}

Public Class Student
	Public Property Name() As String
	Public Property Age() As Integer
End Class
Public Class Program
	Public Shared Sub Main()
		Dim studentList As New List(Of Student) From {
			New Student With {
				.Name = "Alice",
				.Age = 20
			},
			New Student With {
				.Name = "Bob",
				.Age = 20
			},
			New Student With {
				.Name = "Charlie",
				.Age = 21
			}
		}
		Dim groupedResult = studentList.GroupBy(Function(student) student.Age)
		For Each group In groupedResult
			Console.WriteLine($"Age Group: {group.Key}")
			For Each student In group
				Console.WriteLine($"Student Name: {student.Name}")
			Next student
		Next group
	End Sub
End Class

La méthode LINQ GroupBy utilise une expression lambda pour regrouper les étudiants en fonction de leur valeur clé Age. group.Key représente le groupe d'âge, et la boucle interne foreach itère sur chaque étudiant au sein d'un groupe, en imprimant leurs noms.

Utilisation de GroupBy avec la syntaxe des requêtes

La syntaxe des requêtes offre un moyen plus expressif d'effectuer des opérations de regroupement, ressemblant à des requêtes de type SQL. Il est particulièrement utile lorsqu'il s'agit de transformations de données complexes et de critères de regroupement multiples. Voici comment vous pouvez obtenir une fonctionnalité similaire à celle de l'exemple précédent en utilisant la syntaxe des requêtes :

public static void Main()
{
    List<Student> studentList = new List<Student>
    {
        new Student { Name = "Alice", Age = 20 },
        new Student { Name = "Bob", Age = 20 },
        new Student { Name = "Charlie", Age = 21 }
    };
    var groupedResult = from student in studentList
                        group student by student.Age into ageGroup
                        select new { Age = ageGroup.Key, Students = ageGroup };
    foreach (var group in groupedResult)
    {
        Console.WriteLine($"Age Group: {group.Age}");
        foreach (var student in group.Students)
        {
            Console.WriteLine($"Student Name: {student.Name}");
        }
    }
}

public static void Main()
{
    List<Student> studentList = new List<Student>
    {
        new Student { Name = "Alice", Age = 20 },
        new Student { Name = "Bob", Age = 20 },
        new Student { Name = "Charlie", Age = 21 }
    };
    var groupedResult = from student in studentList
                        group student by student.Age into ageGroup
                        select new { Age = ageGroup.Key, Students = ageGroup };
    foreach (var group in groupedResult)
    {
        Console.WriteLine($"Age Group: {group.Age}");
        foreach (var student in group.Students)
        {
            Console.WriteLine($"Student Name: {student.Name}");
        }
    }
}

Public Shared Sub Main()
	Dim studentList As New List(Of Student) From {
		New Student With {
			.Name = "Alice",
			.Age = 20
		},
		New Student With {
			.Name = "Bob",
			.Age = 20
		},
		New Student With {
			.Name = "Charlie",
			.Age = 21
		}
	}
	Dim groupedResult = From student In studentList
		Group student By student.Age Into ageGroup = Group
		Select New With {
			Key .Age = Age,
			Key .Students = ageGroup
		}
	For Each group In groupedResult
		Console.WriteLine($"Age Group: {group.Age}")
		For Each student In group.Students
			Console.WriteLine($"Student Name: {student.Name}")
		Next student
	Next group
End Sub

Dans cet extrait, la syntaxe de la requête regroupe les étudiants par âge, de manière similaire à la syntaxe de la méthode, mais avec une syntaxe différente que certains trouvent plus lisible.

Regroupement par touches et propriétés multiples

Une utilisation plus avancée de la méthode GroupBy consiste à regrouper des données en fonction de plusieurs clés ou propriétés. Cette technique permet une analyse plus détaillée des données et une catégorisation basée sur des valeurs multiples. En utilisant des objets anonymes ou des tuples, vous pouvez regrouper des éléments sur la base d'une combinaison de propriétés, offrant ainsi une structure de données plus riche pour vos applications.

Exemple : Regroupement des élèves par nom et par âge

Considérons un scénario dans lequel vous devez regrouper les étudiants non seulement en fonction de leur valeur clé d'âge, mais aussi en fonction de leur nom, afin d'identifier les étudiants ayant les mêmes valeurs clés de nom et d'âge dans une liste. Pour ce faire, vous pouvez regrouper les étudiants en fonction d'un type anonyme contenant à la fois le nom et l'âge.

public static void Main()
{
    List<Student> studentList = new List<Student>
    {
        new Student { Name = "Alice", Age = 20 },
        new Student { Name = "Alice", Age = 21 },
        new Student { Name = "Bob", Age = 20 },
        new Student { Name = "Charlie", Age = 21 }
    };
    var groupedResult = studentList.GroupBy(student => new { student.Name, student.Age });
    foreach (var group in groupedResult)
    {
        Console.WriteLine($"Group Key: Name = {group.Key.Name}, Age = {group.Key.Age}");
        foreach (var student in group)
        {
            Console.WriteLine($"Student Name: {student.Name}, Age: {student.Age}");
        }
    }
}

public static void Main()
{
    List<Student> studentList = new List<Student>
    {
        new Student { Name = "Alice", Age = 20 },
        new Student { Name = "Alice", Age = 21 },
        new Student { Name = "Bob", Age = 20 },
        new Student { Name = "Charlie", Age = 21 }
    };
    var groupedResult = studentList.GroupBy(student => new { student.Name, student.Age });
    foreach (var group in groupedResult)
    {
        Console.WriteLine($"Group Key: Name = {group.Key.Name}, Age = {group.Key.Age}");
        foreach (var student in group)
        {
            Console.WriteLine($"Student Name: {student.Name}, Age: {student.Age}");
        }
    }
}

Public Shared Sub Main()
	Dim studentList As New List(Of Student) From {
		New Student With {
			.Name = "Alice",
			.Age = 20
		},
		New Student With {
			.Name = "Alice",
			.Age = 21
		},
		New Student With {
			.Name = "Bob",
			.Age = 20
		},
		New Student With {
			.Name = "Charlie",
			.Age = 21
		}
	}
	Dim groupedResult = studentList.GroupBy(Function(student) New With {
		Key student.Name,
		Key student.Age
	})
	For Each group In groupedResult
		Console.WriteLine($"Group Key: Name = {group.Key.Name}, Age = {group.Key.Age}")
		For Each student In group
			Console.WriteLine($"Student Name: {student.Name}, Age: {student.Age}")
		Next student
	Next group
End Sub

Dans cet exemple, les élèves sont regroupés par nom et par âge en utilisant un type anonyme comme clé. Il en résulte des groupes où chaque combinaison unique de nom et d'âge est représentée comme un groupe distinct, ce qui démontre la souplesse de GroupBy pour les scénarios de regroupement complexes.

Informations supplémentaires sur les groupes (GroupBy)

Utilisation avancée de GroupBy

GroupBy devient encore plus puissant lorsque vous devez regrouper des données en fonction de plusieurs valeurs clés ou lorsque vous souhaitez effectuer des opérations supplémentaires sur les données regroupées, telles que le comptage, le filtrage ou l'ordonnancement. Vous pouvez y parvenir en combinant GroupBy avec d'autres méthodes LINQ ou en utilisant des types anonymes pour regrouper plusieurs propriétés.

Exécution différée dans GroupBy

Il est important de noter que GroupBy utilise une exécution différée, traitant les éléments lorsqu'ils sont parcourus par une clé donnée. Cela signifie que l'opération de regroupement n'est pas immédiatement exécutée lorsque la méthode GroupBy est appelée. Au lieu de cela, l'exécution est différée jusqu'à ce que les données groupées soient parcourues, par exemple dans une boucle foreach. Ce comportement est efficace car il permet d'optimiser et de modifier les requêtes avant que les données ne soient traitées.

Présentation d'IronPDF à C&num ; Projets

IronPDF est une bibliothèque complète pour C# qui permet aux développeurs de créer, manipuler et convertir des documents PDF dans des applications .NET. Cet outil puissant offre un large éventail de fonctionnalités, allant de générer des PDF à partir de HTML à l'édition de fichiers PDF existants et bien plus encore. IronPDF simplifie l'intégration des fonctionnalités PDF dans vos applications, ce qui en fait un atout précieux pour tout projet nécessitant la manipulation de PDF.

La principale caractéristique d'IronPDF est sa HTML vers PDF en veillant à ce que les mises en page et les styles soient préservés. Il génère des PDF à partir de contenus web, ce qui est idéal pour les rapports, les factures et la documentation. Les fichiers HTML, les URL et les chaînes HTML peuvent être convertis en PDF de manière transparente.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class

Génération de rapports PDF à partir de données groupées

Étendons nos exemples précédents de regroupement d'élèves par valeur clé d'âge. Après avoir regroupé les élèves, nous utiliserons IronPDF pour générer un rapport PDF qui répertorie ces groupes ainsi que les noms des élèves de chaque groupe.

using IronPdf;
using System;
using System.Collections.Generic;
using System.Linq;
public class Student
{
    public string Name { get; set; }
    public int Age { get; set; }
}
public class Program
{
    public static void Main()
    {
        IronPdf.License.LicenseKey = "License";
        List<Student> studentList = new List<Student>
        {
            new Student { Name = "Alice", Age = 20 },
            new Student { Name = "Bob", Age = 20 },
            new Student { Name = "Charlie", Age = 21 },
            new Student { Name = "David", Age = 21 }
        };
        var groupedResult = studentList.GroupBy(student => student.Age);
        var htmlContent = "<h1>Student Report</h1>";
        foreach (var group in groupedResult)
        {
            htmlContent += $"<h2>Age Group: {group.Key}</h2><ul>";
            foreach (var student in group)
            {
                htmlContent += $"<li>{student.Name}</li>";
            }
            htmlContent += "</ul>";
        }
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        var outputPath = "StudentReport.pdf";
        pdf.SaveAs(outputPath);
        Console.WriteLine($"PDF report generated at {outputPath}");
    }
}

using IronPdf;
using System;
using System.Collections.Generic;
using System.Linq;
public class Student
{
    public string Name { get; set; }
    public int Age { get; set; }
}
public class Program
{
    public static void Main()
    {
        IronPdf.License.LicenseKey = "License";
        List<Student> studentList = new List<Student>
        {
            new Student { Name = "Alice", Age = 20 },
            new Student { Name = "Bob", Age = 20 },
            new Student { Name = "Charlie", Age = 21 },
            new Student { Name = "David", Age = 21 }
        };
        var groupedResult = studentList.GroupBy(student => student.Age);
        var htmlContent = "<h1>Student Report</h1>";
        foreach (var group in groupedResult)
        {
            htmlContent += $"<h2>Age Group: {group.Key}</h2><ul>";
            foreach (var student in group)
            {
                htmlContent += $"<li>{student.Name}</li>";
            }
            htmlContent += "</ul>";
        }
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        var outputPath = "StudentReport.pdf";
        pdf.SaveAs(outputPath);
        Console.WriteLine($"PDF report generated at {outputPath}");
    }
}

Imports IronPdf
Imports System
Imports System.Collections.Generic
Imports System.Linq
Public Class Student
	Public Property Name() As String
	Public Property Age() As Integer
End Class
Public Class Program
	Public Shared Sub Main()
		IronPdf.License.LicenseKey = "License"
		Dim studentList As New List(Of Student) From {
			New Student With {
				.Name = "Alice",
				.Age = 20
			},
			New Student With {
				.Name = "Bob",
				.Age = 20
			},
			New Student With {
				.Name = "Charlie",
				.Age = 21
			},
			New Student With {
				.Name = "David",
				.Age = 21
			}
		}
		Dim groupedResult = studentList.GroupBy(Function(student) student.Age)
		Dim htmlContent = "<h1>Student Report</h1>"
		For Each group In groupedResult
			htmlContent &= $"<h2>Age Group: {group.Key}</h2><ul>"
			For Each student In group
				htmlContent &= $"<li>{student.Name}</li>"
			Next student
			htmlContent &= "</ul>"
		Next group
		Dim renderer = New ChromePdfRenderer()
		Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
		Dim outputPath = "StudentReport.pdf"
		pdf.SaveAs(outputPath)
		Console.WriteLine($"PDF report generated at {outputPath}")
	End Sub
End Class

Dans cet exemple, nous commençons par regrouper les étudiants par âge en utilisant la méthode GroupBy. Ensuite, nous construisons une chaîne HTML, que la méthode renvoie, qui formate ces données groupées dans un rapport, avec des titres pour chaque groupe d'âge et des listes de noms d'étudiants pour chaque groupe. La classe ChromePdfRenderer d'IronPDF est ensuite utilisée pour convertir cette chaîne HTML en un document PDF. Le PDF obtenu est enregistré dans un fichier, ce qui permet d'obtenir un rapport bien formaté des élèves regroupés par âge.

Sortie

Voici le PDF de sortie généré par IronPDF :

Conclusion

La méthode GroupBy en C# est un outil polyvalent et puissant permettant de regrouper des données sur la base de clés spécifiées. Que vous préfériez la syntaxe des méthodes avec des expressions lambda ou la syntaxe plus déclarative des requêtes, GroupBy vous permet d'organiser des structures de données complexes d'une manière gérable et lisible. En maîtrisant GroupBy et d'autres méthodes LINQ, vous pouvez améliorer considérablement votre capacité à manipuler et à analyser des données dans vos applications C#.

IronPDF fournit un service de essai gratuit pour ceux qui souhaitent découvrir ses fonctionnalités avant de s'engager dans un achat. Pour ceux qui sont prêts à l'intégrer dans leurs projets, la licence commence à $749, ce qui en fait un investissement rentable pour la manipulation et la génération de PDF de qualité professionnelle dans les applications C#.