Ícone de mensagem
Ir para o conteúdo do rodapé
  1. IronPDF
  2. Blog do IronPDF
  3. Ajuda do .NET
  4. csharp-groupby
AJUDA DO .NET

Agrupamento em C# (Como funciona para desenvolvedores)

Curtis Chau
Curtis Chau
Atualizado:

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 .

Noções básicas de GroupBy

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.

Utilizando GroupBy com sintaxe de método

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}");
            }
        }
    }
}
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 student
		Next group
	End Sub
End Class
$vbLabelText   $csharpLabel

C# GroupBy (Como funciona para desenvolvedores): Figura 1 - Saída do console do exemplo de código anterior

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.

Utilizando o GroupBy com a sintaxe de consulta

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}");
            }
        }
    }
}
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 {
				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
End Module
$vbLabelText   $csharpLabel

Neste 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.

Agrupamento por múltiplas chaves e propriedades

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.

Exemplo: Agrupamento de alunos por nome e idade

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}");
            }
        }
    }
}
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 student
		Next group
	End Sub
End Module
$vbLabelText   $csharpLabel

Neste 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.

Informações adicionais de agrupamento

Uso avançado do GroupBy

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.

Execução adiada em GroupBy

É 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.

Apresentando o IronPDF para projetos em C

C# GroupBy (Como funciona para desenvolvedores): Figura 2 - Página web do IronPDF

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");
    }
}
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
$vbLabelText   $csharpLabel

Geração de relatórios em PDF a partir de dados agrupados

Vamos 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}");
    }
}
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 = "<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

		' Initialize IronPDF renderer and generate PDF
		Dim renderer = New ChromePdfRenderer()
		Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)

		' Specify path to save the PDF file
		Dim outputPath = "StudentReport.pdf"
		pdf.SaveAs(outputPath)

		Console.WriteLine($"PDF report generated at {outputPath}")
	End Sub
End Class
$vbLabelText   $csharpLabel

Neste 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.

Saída

Aqui está o PDF gerado pelo IronPDF:

C# GroupBy (Como funciona para desenvolvedores): Figura 3 - PDF gerado pelo exemplo de código anterior

Conclusão

C# GroupBy (Como funciona para desenvolvedores): Figura 4 - Plano de licenciamento do 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 que desejam integrá-lo em seus projetos, o licenciamento começa em $799, tornando-o um investimento que vale a pena para manipulação e geração de PDFs de nível profissional em aplicativos C#.

Perguntas frequentes

O que é o método GroupBy em C#?

Em C#, o método GroupBy é um recurso do LINQ que organiza elementos de uma fonte de dados em grupos com base em uma chave especificada, simplificando a análise e manipulação de dados.

Como o método GroupBy funciona com a sintaxe de método em C#?

Utilizando a sintaxe de método com expressões lambda, o método GroupBy agrupa elementos por uma chave especificada. Por exemplo, você pode agrupar uma lista de alunos por idade, criando grupos de alunos com idades semelhantes.

É possível usar a sintaxe de consulta com o método GroupBy?

Sim, a sintaxe de consulta pode ser usada com o método GroupBy, proporcionando uma maneira mais expressiva e semelhante ao SQL para realizar operações de agrupamento, especialmente para transformações de dados complexas.

Como agrupar dados por múltiplas chaves usando GroupBy?

É possível agrupar dados por múltiplas chaves usando objetos anônimos ou tuplas, permitindo uma análise de dados mais detalhada com base em combinações de propriedades.

O que é execução adiada no contexto do GroupBy?

A execução diferida significa que a operação GroupBy não é executada imediatamente quando chamada. Ela é processada quando os dados agrupados são iterados, permitindo otimizações de consulta.

Como gerar relatórios em PDF a partir de dados agrupados usando C#?

Você pode usar o IronPDF para converter strings HTML, que formatam dados agrupados em relatórios, em documentos PDF. Isso permite a geração fácil de relatórios em PDF com formatação impecável a partir de dados agrupados com GroupBy.

Quais são algumas técnicas avançadas de agrupamento em C#?

Em C#, as técnicas avançadas de agrupamento envolvem o uso de objetos anônimos ou tuplas para agrupar dados por múltiplas chaves ou propriedades, aprimorando a capacidade de realizar análises de dados complexas.

Como o IronPDF pode auxiliar no gerenciamento de PDFs de nível profissional em aplicações .NET?

O IronPDF fornece aos desenvolvedores C# ferramentas para criar e manipular documentos PDF, incluindo a geração de relatórios em PDF a partir de conteúdo HTML. Isso auxilia no gerenciamento eficiente de PDFs de nível profissional em aplicações .NET.

Como converter HTML para PDF em C#?

Você pode usar o método RenderHtmlAsPdf do IronPDF para converter strings HTML em PDFs. Você também pode converter arquivos HTML em PDFs usando o RenderHtmlFileAsPdf .

Curtis Chau
Curtis Chau
  Converse agora mesmo com a equipe de engenharia.
Redator Técnico

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 ...

Leia mais

Artigos relacionados

Teste grátis por 30 dias → Produto completo. Sem limites. Sem cartão. Teste gratuito

Equipe de suporte de ferro

Estamos online 24 horas por dia, 5 dias por semana.
Bater papo
E-mail
Liga para mim