¿Cómo funciona el método GroupBy con sintaxis de método en C#?

Usando la sintaxis de método con expresiones lambda, el método GroupBy agrupa elementos por una clave especificada. Por ejemplo, puedes agrupar una lista de estudiantes por edad, creando grupos de estudiantes con edades similares.

¿Puedes usar la sintaxis de consulta con el método GroupBy?

Sí, la sintaxis de consulta se puede usar con el método GroupBy, proporcionando una manera más parecida a SQL y expresiva de realizar operaciones de agrupamiento, especialmente para transformaciones de datos complejas.

¿Cómo puedes agrupar datos por múltiples claves usando GroupBy?

Puedes agrupar datos por múltiples claves usando objetos anónimos o tuplas, permitiendo un análisis de datos más detallado basado en combinaciones de propiedades.

¿Qué es la ejecución diferida en el contexto de GroupBy?

La ejecución diferida significa que la operación GroupBy no se ejecuta inmediatamente cuando se invoca. Se procesa cuando los datos agrupados son iterados, permitiendo optimizaciones de consulta.

¿Cómo puedes generar informes PDF a partir de datos agrupados usando C#?

Puedes usar IronPDF para convertir cadenas HTML, que formatean los datos agrupados en informes, en documentos PDF. Esto permite la generación fácil de informes PDF bien formateados a partir de datos agrupados con GroupBy.

¿Cuáles son algunas técnicas avanzadas de agrupamiento en C#?

Las técnicas avanzadas de agrupamiento en C# implican el uso de objetos anónimos o tuplas para agrupar datos por múltiples claves o propiedades, mejorando la capacidad de realizar un análisis de datos complejo.

¿Cómo puede IronPDF asistir en la gestión de PDF de grado profesional en aplicaciones .NET?

IronPDF proporciona a los desarrolladores de C# herramientas para crear y manipular documentos PDF, incluyendo la generación de informes PDF a partir de contenido HTML. Esto ayuda a gestionar PDFs de grado profesional de manera eficiente en aplicaciones .NET.

¿Cómo puede convertir HTML a PDF en C#?

Puede usar el método RenderHtmlAsPdf de IronPDF para convertir cadenas de HTML en PDFs. También puede convertir archivos HTML a PDFs usando RenderHtmlFileAsPdf .

What are some additional operations you can perform with GroupBy and LINQ?

Beyond grouping, LINQ allows you to perform counting, filtering, or ordering on grouped data, enhancing the versatility of data manipulation and analysis in C#.

La Biblioteca PDF de C#

Q: ¿Qué es el método GroupBy en C#?

En C#, el método GroupBy es una característica de LINQ que organiza elementos de una fuente de datos en grupos basados en una clave especificada, simplificando el análisis y manipulación de datos.

Explore IronPDF Prueba gratis

HTML a PDF

Online Demo Ver Todos los Ejemplos de Código %s

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

PM >Install-Package IronPdf

Install-Package IronPdf

ACTUALIZACIONES PARA DESARROLLADORES

C# Groupby (Cómo Funciona para Desarrolladores)

Jacob Mellor

Updated: 21 de abril de 2026

En C#, el método GroupBy es una herramienta poderosa que organiza elementos de una fuente de datos en grupos basados en una clave especificada. Este método es parte de LINQ (Consulta Integrada en el Lenguaje) y puede usarse para agrupar elementos por una sola propiedad o múltiples propiedades, lo que lo hace invaluable para el análisis y la manipulación de datos. El método GroupBy simplifica las operaciones complejas de datos, permitiendo una organización y recuperación eficiente de datos basada en criterios específicos. Hablaremos sobre GroupBy y la biblioteca IronPDF en este blog.

Básicos de GroupBy

La esencia del método GroupBy radica en su capacidad para categorizar elementos de una colección dada en grupos según una clave especificada. Esta propiedad clave determina cómo se agrupan los elementos. Por ejemplo, puedes agrupar una lista de estudiantes por su valor de clave de edad, creando conglomerados de estudiantes con la misma edad. Cada grupo está representado por un valor de clave y una colección de elementos que comparten esa clave. La propiedad clave puede ser cualquier objeto, como una cadena, un número, o incluso un objeto anónimo, proporcionando flexibilidad en cómo se agrupan los datos.

Uso de GroupBy con la sintaxis de métodos

En C#, hay dos formas de aplicar el método GroupBy: sintaxis de métodos y sintaxis de consulta. La sintaxis de métodos utiliza expresiones lambda para definir la clave de agrupamiento y es un enfoque directo para aplicar la operación GroupBy.

Considera el siguiente ejemplo usando sintaxis de métodos para agrupar una lista de estudiantes por su edad:

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()
    {
        List<Student> studentList = new List<Student>
        {
            new Student { Name = "Alice", Age = 20 },
            new Student { Name = "Bob", Age = 20 },
            new Student { Name = "Charlie", Age = 21 }
        };
        
        // Group students by their age using GroupBy
        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}");
            }
        }
    }
}

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()
    {
        List<Student> studentList = new List<Student>
        {
            new Student { Name = "Alice", Age = 20 },
            new Student { Name = "Bob", Age = 20 },
            new Student { Name = "Charlie", Age = 21 }
        };
        
        // Group students by their age using GroupBy
        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}");
            }
        }
    }
}

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()
        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}
        }
        
        ' Group students by their age using GroupBy
        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
        Next
    End Sub
End Class

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()
        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}
        }
        
        ' Group students by their age using GroupBy
        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
        Next
    End Sub
End Class

C# GroupBy (Cómo funciona para desarrolladores): Figura 1 - Salida de consola del ejemplo de código anterior

El método GroupBy de LINQ utiliza una expresión lambda para agrupar los estudiantes por su valor de clave Age. group.Key representa el grupo de edad, y el bucle foreach interno itera sobre cada estudiante dentro de un grupo, imprimiendo sus nombres.

Utilización de GroupBy con la sintaxis de consulta

La sintaxis de consulta ofrece una forma más expresiva de realizar operaciones de agrupación, asemejándose a consultas similares a SQL. Es particularmente útil al tratar con transformaciones de datos complejas y múltiples criterios de agrupamiento. Así es como puedes lograr una funcionalidad similar al ejemplo anterior usando sintaxis de consulta:

using System;
using System.Collections.Generic;
using System.Linq;

public static 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 }
        };
        
        // Group students by their age using query syntax
        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}");
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;

public static 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 }
        };
        
        // Group students by their age using query syntax
        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}");
            }
        }
    }
}

Imports System
Imports System.Collections.Generic
Imports System.Linq

Public Module Program
    Public 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}
        }

        ' Group students by their age using query syntax
        Dim groupedResult = From student In studentList
                            Group student By student.Age Into ageGroup = Group
                            Select New With {.Age = ageGroup.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
        Next
    End Sub
End Module

Public Class Student
    Public Property Name As String
    Public Property Age As Integer
End Class

Imports System
Imports System.Collections.Generic
Imports System.Linq

Public Module Program
    Public 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}
        }

        ' Group students by their age using query syntax
        Dim groupedResult = From student In studentList
                            Group student By student.Age Into ageGroup = Group
                            Select New With {.Age = ageGroup.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
        Next
    End Sub
End Module

Public Class Student
    Public Property Name As String
    Public Property Age As Integer
End Class

En este fragmento, la sintaxis de consulta agrupa a los estudiantes por Age, similar a la sintaxis de métodos pero con una sintaxis diferente que algunos encuentran más legible.

Agrupación por múltiples claves y propiedades

Un uso más avanzado del método GroupBy implica agrupar datos por múltiples claves o propiedades. Esta técnica permite un análisis de datos más detallado y categorización basada en múltiples valores. Al usar objetos anónimos o tuplas, se pueden agrupar elementos basados en una combinación de propiedades, proporcionando una estructura de datos más rica para tus aplicaciones.

Ejemplo: Agrupación de alumnos por nombre y edad

Considera un escenario donde necesitas agrupar estudiantes no solo por su valor de clave de edad sino también por su nombre, para identificar estudiantes con el mismo nombre y valores de clave de edad en una lista. Esto se puede lograr agrupando por un tipo anónimo que contiene tanto el nombre como la edad.

using System;
using System.Collections.Generic;
using System.Linq;

public static class Program
{
    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 }
        };
        
        // Group students by both Name and Age using an anonymous type as the key
        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}");
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;

public static class Program
{
    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 }
        };
        
        // Group students by both Name and Age using an anonymous type as the key
        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}");
            }
        }
    }
}

Imports System
Imports System.Collections.Generic
Imports System.Linq

Public Module Program
    Public 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}
        }
        
        ' Group students by both Name and Age using an anonymous type as the key
        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
        Next
    End Sub
End Module

Imports System
Imports System.Collections.Generic
Imports System.Linq

Public Module Program
    Public 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}
        }
        
        ' Group students by both Name and Age using an anonymous type as the key
        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
        Next
    End Sub
End Module

En este ejemplo, los estudiantes son agrupados por nombre y edad usando un tipo anónimo como la clave. Esto resulta en grupos donde cada combinación única de nombre y edad está representada como un grupo separado, demostrando la flexibilidad de GroupBy para escenarios de agrupación complejos.

Información adicional sobre GroupBy

Uso avanzado de GroupBy

GroupBy se vuelve aún más poderoso cuando necesitas agrupar por múltiples valores de clave o cuando deseas realizar operaciones adicionales en los datos agrupados, como contar, filtrar u ordenar. Puedes lograr esto combinando GroupBy con otros métodos LINQ o usando tipos anónimos para agrupar por múltiples propiedades.

Ejecución diferida en GroupBy

Es importante notar que GroupBy utiliza ejecución diferida, procesando elementos cuando se itera sobre ellos por una clave dada. Esto significa que la operación de agrupación no se ejecuta inmediatamente cuando se llama al método GroupBy. En su lugar, la ejecución se difiere hasta que los datos agrupados se iteran, como en un bucle foreach. Este comportamiento es eficiente porque permite más optimizaciones y modificaciones de consulta antes de que se procese finalmente el dato.

Introducción de IronPDF en proyectos C#

C# GroupBy (Cómo funciona para desarrolladores): Figura 2 - Página web de IronPDF

IronPDF es una biblioteca integral para C# que permite a los desarrolladores crear, manipular y convertir documentos PDF dentro de aplicaciones .NET. Esta herramienta poderosa ofrece una amplia gama de funcionalidades, desde generar PDFs desde HTML hasta editar archivos PDF existentes y mucho más. IronPDF simplifica la integración de capacidades PDF en tus aplicaciones, convirtiéndola en un activo valioso para cualquier proyecto que requiera manipulación de PDF.

La característica clave de IronPDF es su conversión de HTML a PDF, asegurando que los diseños y estilos se conserven. Genera PDFs a partir de contenido web, lo que lo hace ideal para informes, facturas y documentación. Archivos HTML, URLs y cadenas de HTML pueden ser convertidos a PDFs sin inconvenientes.

using IronPdf;

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

        // 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");

        // 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");

        // 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();

        // 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");

        // 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");

        // 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()

		' 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")

		' 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")

		' 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

Imports IronPdf

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

		' 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")

		' 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")

		' 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

Generación de informes PDF a partir de datos agrupados

Extendamos nuestros ejemplos anteriores de agrupar estudiantes por valor de clave de edad. Después de agrupar a los estudiantes, usaremos IronPDF para generar un informe PDF que enumere estos grupos junto con los nombres de los estudiantes en cada grupo.

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()
    {
        // Initialize IronPDF license if applicable
        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 }
        };
        
        // Group students by their age
        var groupedResult = studentList.GroupBy(student => student.Age);
        
        // Create HTML content for the PDF report
        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>";
        }
        
        // Initialize IronPDF renderer and generate PDF
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        
        // Specify path to save the PDF file
        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()
    {
        // Initialize IronPDF license if applicable
        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 }
        };
        
        // Group students by their age
        var groupedResult = studentList.GroupBy(student => student.Age);
        
        // Create HTML content for the PDF report
        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>";
        }
        
        // Initialize IronPDF renderer and generate PDF
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        
        // Specify path to save the PDF file
        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()
        ' Initialize IronPDF license if applicable
        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}
        }
        
        ' Group students by their age
        Dim groupedResult = studentList.GroupBy(Function(student) student.Age)
        
        ' Create HTML content for the PDF report
        Dim htmlContent As String = "<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
            
            htmlContent += "</ul>"
        Next
        
        ' Initialize IronPDF renderer and generate PDF
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
        
        ' Specify path to save the PDF file
        Dim outputPath As String = "StudentReport.pdf"
        pdf.SaveAs(outputPath)
        
        Console.WriteLine($"PDF report generated at {outputPath}")
    End Sub
End Class

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()
        ' Initialize IronPDF license if applicable
        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}
        }
        
        ' Group students by their age
        Dim groupedResult = studentList.GroupBy(Function(student) student.Age)
        
        ' Create HTML content for the PDF report
        Dim htmlContent As String = "<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
            
            htmlContent += "</ul>"
        Next
        
        ' Initialize IronPDF renderer and generate PDF
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
        
        ' Specify path to save the PDF file
        Dim outputPath As String = "StudentReport.pdf"
        pdf.SaveAs(outputPath)
        
        Console.WriteLine($"PDF report generated at {outputPath}")
    End Sub
End Class

En este ejemplo, primero agrupamos a los estudiantes por edad usando el método GroupBy. Luego, construimos una cadena HTML, que el método devuelve, que formatea estos datos agrupados en un informe, con títulos para cada grupo de edad y listas de nombres de estudiantes bajo cada grupo. La clase ChromePdfRenderer de IronPDF se utiliza luego para convertir esta cadena HTML en un documento PDF. El PDF resultante se guarda en un archivo, proporcionando un informe perfectamente formateado de estudiantes agrupados por edad.

Resultado

Aquí está el PDF de salida generado por el IronPDF:

C# GroupBy (Cómo funciona para desarrolladores): Figura 3 - PDF generado a partir del ejemplo de código anterior

Conclusión

El método GroupBy en C# es una herramienta versátil y poderosa para agrupar datos basados en claves especificadas. Ya sea que prefieras la sintaxis de métodos con expresiones lambda o la sintaxis de consulta más declarativa, GroupBy te permite organizar estructuras de datos complejas de manera manejable y legible. Al dominar GroupBy y otros métodos de LINQ, puedes mejorar significativamente tu capacidad de manipular y analizar datos en tus aplicaciones de C#.

IronPDF proporciona una prueba gratuita para aquellos que deseen explorar sus características antes de comprometerse a una compra. Para aquellos preparados para integrarlo en sus proyectos, la licencia comienza en $999, lo que lo convierte en una inversión que vale la pena para la manipulación y generación de PDF de calidad profesional en aplicaciones C#.

Jacob Mellor

Chatea con el equipo de ingeniería ahora

Director de Tecnología

Jacob Mellor es Director de Tecnología de Iron Software y un ingeniero visionario pionero en la tecnología C# PDF. Como desarrollador original de la base de código principal de Iron Software, ha dado forma a la arquitectura de productos de la empresa desde su creación, transformándola, junto con el director ejecutivo Cameron Rimington, en una empresa de más de 50 personas que presta servicios a la NASA, Tesla y organismos gubernamentales de todo el mundo.

...