Em C#, o método GroupBy é uma ferramenta poderosa que organiza elementos de uma fonte de dados em grupos com base em uma chave especificada. Este método faz parte do LINQ (Language Integrated Query) e pode ser usado para agrupar itens por uma única propriedade ou por múltiplas propriedades, tornando-o indispensável para análise e manipulação de dados. O método GroupBy simplifica operações complexas de dados, permitindo a organização e recuperação eficientes de dados com base em critérios específicos. Neste blog, discutiremos o GroupBy e a biblioteca IronPDF .
A essência do método GroupBy reside na sua capacidade de categorizar elementos de uma determinada coleção em grupos de acordo com uma chave especificada. Essa propriedade fundamental determina como os itens são agrupados. Por exemplo, você pode agrupar uma lista de alunos pelo valor da sua idade, criando grupos de alunos com a mesma idade. Cada grupo é representado por um valor-chave e uma coleção de itens que compartilham essa chave. A propriedade chave pode ser qualquer objeto, como uma string, um número ou até mesmo um objeto anônimo, proporcionando flexibilidade na forma como os dados são agrupados.
Em C#, existem duas maneiras de aplicar o método GroupBy: sintaxe de método e sintaxe de consulta. A sintaxe do método usa expressões lambda para definir a chave de agrupamento e é uma abordagem direta para aplicar a operação GroupBy.
Considere o seguinte exemplo usando a sintaxe de método para agrupar uma lista de alunos por idade:
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
O método GroupBy do LINQ usa uma expressão lambda para agrupar alunos pelo valor da chave " Idade" . group.Key representa a faixa etária, e o loop foreach interno itera sobre cada aluno dentro de um grupo, imprimindo seus nomes.
A sintaxe de consulta oferece uma maneira mais expressiva de realizar operações de agrupamento, assemelhando-se a consultas do tipo SQL. É particularmente útil ao lidar com transformações de dados complexas e múltiplos critérios de agrupamento. Veja como você pode obter uma funcionalidade semelhante à do exemplo anterior usando a sintaxe 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}");
}
}
}
}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 ClassNeste trecho de código, a sintaxe da consulta agrupa os alunos por idade , semelhante à sintaxe do método, mas com uma sintaxe diferente que alguns consideram mais legível.
Uma utilização mais avançada do método GroupBy envolve o agrupamento de dados por múltiplas chaves ou propriedades. Essa técnica permite uma análise e categorização de dados mais detalhadas com base em múltiplos valores. Ao usar objetos anônimos ou tuplas, você pode agrupar itens com base em uma combinação de propriedades, proporcionando uma estrutura de dados mais rica para seus aplicativos.
Considere um cenário em que você precisa agrupar alunos não apenas pela idade, mas também pelo nome, para identificar alunos com o mesmo nome e idade em uma lista. Isso pode ser feito agrupando por um tipo anônimo que contenha tanto o nome quanto a idade.
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 ModuleNeste exemplo, os alunos são agrupados por nome e idade, utilizando um tipo anônimo como chave. Isso resulta em grupos onde cada combinação única de nome e idade é representada como um grupo separado, demonstrando a flexibilidade do GroupBy para cenários de agrupamento complexos.
O GroupBy torna-se ainda mais poderoso quando você precisa agrupar por vários valores-chave ou quando deseja executar operações adicionais nos dados agrupados, como contagem, filtragem ou ordenação. Você pode conseguir isso combinando o GroupBy com outros métodos LINQ ou usando tipos anônimos para agrupar por múltiplas propriedades.
É importante notar que o GroupBy utiliza execução adiada, processando os itens à medida que são iterados por uma determinada chave. Isso significa que a operação de agrupamento não é executada imediatamente quando o método GroupBy é chamado. Em vez disso, a execução é adiada até que os dados agrupados sejam iterados, como em um loop foreach. Esse comportamento é eficiente porque permite otimizações e modificações adicionais na consulta antes que os dados sejam finalmente processados.
IronPDF é uma biblioteca completa para C# que permite aos desenvolvedores criar, manipular e converter documentos PDF em aplicações .NET . Esta poderosa ferramenta oferece uma ampla gama de funcionalidades, desde a geração de PDFs a partir de HTML até a edição de arquivos PDF existentes e muito mais. O IronPDF simplifica a integração de recursos de PDF em seus aplicativos, tornando-se um recurso valioso para qualquer projeto que exija manipulação de PDFs.
A principal característica do IronPDF é a sua conversão de HTML para PDF , garantindo que os layouts e estilos sejam preservados. Ele gera PDFs a partir de conteúdo da web, sendo ótimo para relatórios, faturas e documentação. Arquivos HTML, URLs e strings HTML podem ser convertidos em PDFs sem problemas.
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 ClassVamos expandir nossos exemplos anteriores de agrupamento de alunos por valor-chave de idade. Após agrupar os alunos, usaremos o IronPDF para gerar um relatório em PDF que listará esses grupos juntamente com os nomes dos alunos em 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}");
}
}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 ClassNeste exemplo, primeiro agrupamos os alunos por idade usando o método GroupBy . Em seguida, construímos uma string HTML, retornada pelo método, que formata esses dados agrupados em um relatório, com cabeçalhos para cada faixa etária e listas de nomes de alunos em cada grupo. A classe ChromePdfRenderer do IronPDF é então usada para converter essa string HTML em um documento PDF. O PDF resultante é salvo em um arquivo, fornecendo um relatório bem formatado dos alunos agrupados por idade.
Aqui está o PDF gerado pelo IronPDF:
O método GroupBy em C# é uma ferramenta versátil e poderosa para agrupar dados com base em chaves específicas. Quer você prefira a sintaxe de método com expressões lambda ou a sintaxe de consulta mais declarativa, o GroupBy permite organizar estruturas de dados complexas de maneira gerenciável e legível. Ao dominar o GroupBy e outros métodos do LINQ, você pode aprimorar significativamente sua capacidade de manipular e analisar dados em seus aplicativos C#.
O IronPDF oferece um período de teste gratuito para quem deseja explorar seus recursos antes de efetuar a compra. Para aqueles prontos para integrá-lo em seus projetos, o licenciamento começa em $999, tornando-o um investimento valioso para manipulação e geração de PDFs de nível profissional em aplicações C#.
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.
IronPDF faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
Quando você precisa que seu PDF tenha a aparência de HTML, rapidamente.
