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

C# Orderby (Como funciona para desenvolvedores)

Curtis Chau
Curtis Chau
Atualizado:

A ordenação é uma operação fundamental em qualquer linguagem de programação, e o método OrderBy do C# é uma ferramenta poderosa para organizar elementos em coleções. Seja trabalhando com arrays, listas ou outras estruturas enumeráveis, entender como usar o OrderBy pode melhorar muito a legibilidade e a funcionalidade do seu código.

Mais adiante neste artigo, apresentaremos a biblioteca IronPDF da Iron Software e como podemos usar o método OrderBy do LINQ com o IronPDF para gerar PDFs formatados e classificados.

O que é o método OrderBy do LINQ?

O método OrderBy faz parte da biblioteca LINQ (Language-Integrated Query) em C# e foi projetado especificamente para classificar elementos em ordem crescente; Como essa é a forma padrão de classificar dados, não há necessidade de uma palavra-chave ascendente.

Como usar o método OrderBy do LINQ

Ordenando dados em ordem crescente

Em C#, existem duas maneiras de aplicar esse método: por meio da sintaxe de método ou da sintaxe de consulta. Usaremos a sintaxe do método, pois é simples:

var sortedCollection = collection.OrderBy(item => item.OrderByProperty);
var sortedCollection = collection.OrderBy(item => item.OrderByProperty);
Dim sortedCollection = collection.OrderBy(Function(item) item.OrderByProperty)
$vbLabelText   $csharpLabel

Aqui, collection é a coleção de origem IEnumerable que você deseja classificar e OrderByProperty é a propriedade ou expressão pela qual você deseja ordenar os elementos. A expressão lambda dentro de OrderBy especifica o critério de classificação.

Ordenando os dados em ordem decrescente.

Para ordenar em ordem decrescente, você pode usar o método OrderByDescending utilizando a sintaxe baseada em método:

var sortedCollectionDesc = collection.OrderByDescending(item => item.OrderByProperty);
var sortedCollectionDesc = collection.OrderByDescending(item => item.OrderByProperty);
Dim sortedCollectionDesc = collection.OrderByDescending(Function(item) item.OrderByProperty)
$vbLabelText   $csharpLabel

Classificação de dados por múltiplos critérios

Em cenários do mundo real, muitas vezes é necessário classificar uma coleção com base em vários critérios. OrderBy permite isso encadeando múltiplas chamadas ThenBy ou ThenByDescending:

var multiSortedCollection = collection
    .OrderBy(item => item.OrderByProperty1)
    .ThenByDescending(item => item.OrderByProperty2);
var multiSortedCollection = collection
    .OrderBy(item => item.OrderByProperty1)
    .ThenByDescending(item => item.OrderByProperty2);
Dim multiSortedCollection = collection.OrderBy(Function(item) item.OrderByProperty1).ThenByDescending(Function(item) item.OrderByProperty2)
$vbLabelText   $csharpLabel

Neste exemplo, a coleção é primeiro ordenada por OrderByProperty1 em ordem crescente. Em seguida, para elementos com o mesmo valor OrderByProperty1, eles são classificados por OrderByProperty2 em ordem decrescente.

Comparadores personalizados

Para requisitos de classificação mais complexos, você pode usar comparadores personalizados. O método OrderBy permite que você passe uma implementação de IComparer<t>, como mostrado no exemplo a seguir:

var customSortedCollection = collection.OrderBy(item => item.Property, new CustomComparer());
var customSortedCollection = collection.OrderBy(item => item.Property, new CustomComparer());
Dim customSortedCollection = collection.OrderBy(Function(item) item.Property, New CustomComparer())
$vbLabelText   $csharpLabel

Aqui, CustomComparer é uma classe que implementa a interface IComparer<t>, fornecendo lógica personalizada para comparar elementos.

Exemplo prático: Classificando objetos

Ordenando uma lista de números inteiros

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

class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 5, 2, 8, 1, 7 };
        var sortedNumbers = numbers.OrderBy(num => num);
        Console.WriteLine("Sorted Numbers:");
        foreach (var number in sortedNumbers)
        {
            Console.WriteLine(number);
        }
    }
}
using System;
using System.Linq;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 5, 2, 8, 1, 7 };
        var sortedNumbers = numbers.OrderBy(num => num);
        Console.WriteLine("Sorted Numbers:");
        foreach (var number in sortedNumbers)
        {
            Console.WriteLine(number);
        }
    }
}
Imports System
Imports System.Linq
Imports System.Collections.Generic

Friend Class Program
	Shared Sub Main()
		Dim numbers As New List(Of Integer) From {5, 2, 8, 1, 7}
		Dim sortedNumbers = numbers.OrderBy(Function(num) num)
		Console.WriteLine("Sorted Numbers:")
		For Each number In sortedNumbers
			Console.WriteLine(number)
		Next number
	End Sub
End Class
$vbLabelText   $csharpLabel

Neste exemplo, uma lista de números inteiros é classificada em ordem crescente usando OrderBy.

Ordenando uma lista de strings

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

class Program
{
    static void Main()
    {
        List<string> names = new List<string> { "Alice", "Charlie", "Bob", "David" };
        var sortedNames = names.OrderBy(name => name);
        Console.WriteLine("Sorted Names:");
        foreach (var name in sortedNames)
        {
            Console.WriteLine(name);
        }
    }
}
using System;
using System.Linq;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<string> names = new List<string> { "Alice", "Charlie", "Bob", "David" };
        var sortedNames = names.OrderBy(name => name);
        Console.WriteLine("Sorted Names:");
        foreach (var name in sortedNames)
        {
            Console.WriteLine(name);
        }
    }
}
Imports System
Imports System.Linq
Imports System.Collections.Generic

Friend Class Program
	Shared Sub Main()
		Dim names As New List(Of String) From {"Alice", "Charlie", "Bob", "David"}
		Dim sortedNames = names.OrderBy(Function(name) name)
		Console.WriteLine("Sorted Names:")
		For Each name In sortedNames
			Console.WriteLine(name)
		Next name
	End Sub
End Class
$vbLabelText   $csharpLabel

Este exemplo demonstra como ordenar uma lista de strings em ordem alfabética crescente.

Ordenando uma lista de objetos personalizados

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

class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int Age { get; set; }
}

class Program
{
    static void Main()
    {
        List<Person> people = new List<Person>
        {
            new Person { FirstName = "John", LastName = "Doe", Age = 30 },
            new Person { FirstName = "Alice", LastName = "Smith", Age = 25 },
            new Person { FirstName = "Bob", LastName = "Johnson", Age = 35 }
        };
        var sortedPeople = people.OrderBy(person => person.Age);
        Console.WriteLine("Sorted People by Age:");
        foreach (var person in sortedPeople)
        {
            Console.WriteLine($"{person.FirstName} {person.LastName}, Age: {person.Age}");
        }
    }
}
using System;
using System.Linq;
using System.Collections.Generic;

class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int Age { get; set; }
}

class Program
{
    static void Main()
    {
        List<Person> people = new List<Person>
        {
            new Person { FirstName = "John", LastName = "Doe", Age = 30 },
            new Person { FirstName = "Alice", LastName = "Smith", Age = 25 },
            new Person { FirstName = "Bob", LastName = "Johnson", Age = 35 }
        };
        var sortedPeople = people.OrderBy(person => person.Age);
        Console.WriteLine("Sorted People by Age:");
        foreach (var person in sortedPeople)
        {
            Console.WriteLine($"{person.FirstName} {person.LastName}, Age: {person.Age}");
        }
    }
}
Imports System
Imports System.Linq
Imports System.Collections.Generic

Friend Class Person
	Public Property FirstName() As String
	Public Property LastName() As String
	Public Property Age() As Integer
End Class

Friend Class Program
	Shared Sub Main()
		Dim people As New List(Of Person) From {
			New Person With {
				.FirstName = "John",
				.LastName = "Doe",
				.Age = 30
			},
			New Person With {
				.FirstName = "Alice",
				.LastName = "Smith",
				.Age = 25
			},
			New Person With {
				.FirstName = "Bob",
				.LastName = "Johnson",
				.Age = 35
			}
		}
		Dim sortedPeople = people.OrderBy(Function(person) person.Age)
		Console.WriteLine("Sorted People by Age:")
		For Each person In sortedPeople
			Console.WriteLine($"{person.FirstName} {person.LastName}, Age: {person.Age}")
		Next person
	End Sub
End Class
$vbLabelText   $csharpLabel

Neste exemplo, uma lista de objetos personalizados Person é classificada com base na propriedade Age em ordem crescente.

A seguinte saída é visível no console:

Orderby em C# (Como funciona para desenvolvedores): Figura 1 - Saída do código anterior classificando objetos personalizados

Manipulação de comparações de strings

Ao lidar com propriedades de string, convém garantir a ordenação sem distinção entre maiúsculas e minúsculas:

var sortedPeopleByName = people.OrderBy(person => person.LastName, StringComparer.OrdinalIgnoreCase);
var sortedPeopleByName = people.OrderBy(person => person.LastName, StringComparer.OrdinalIgnoreCase);
Dim sortedPeopleByName = people.OrderBy(Function(person) person.LastName, StringComparer.OrdinalIgnoreCase)
$vbLabelText   $csharpLabel

Este exemplo usa o StringComparer.OrdinalIgnoreCase para realizar uma classificação que não diferencia maiúsculas de minúsculas com base na propriedade LastName.

Considerações sobre o desempenho

Embora o LINQ ofereça uma maneira concisa de classificar coleções, é essencial considerar as implicações de desempenho, especialmente para conjuntos de dados grandes. Para cenários críticos de desempenho, você pode explorar alternativas como a classificação no local usando o método List<t>.Sort.

Apresentando o IronPDF

Descubra as funcionalidades do IronPDF dentro da biblioteca C# PDF da Iron Software , que ajuda a ler e gerar documentos PDF. Ele consegue converter facilmente documentos formatados com informações de estilo para PDF. O IronPDF pode gerar PDFs a partir de strings HTML, ou pode baixar o HTML de uma URL e então gerar os PDFs.

O IronPDF se destaca na conversão de HTML para PDF , preservando todos os layouts e estilos. Ele pode gerar PDFs a partir de diversos conteúdos da web, como relatórios, faturas e documentação. A ferramenta funciona com arquivos HTML, URLs e strings HTML para criar arquivos 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");
    }
}
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
$vbLabelText   $csharpLabel

Instalação

O IronPDF pode ser instalado usando o console do gerenciador de pacotes NuGet ou o gerenciador de pacotes do Visual Studio.

Install-Package IronPdf

Você também pode instalar o IronPDF usando o Gerenciador de Pacotes NuGet , pesquisando "IronPDF" na barra de pesquisa.

Ordenar por C# (Como funciona para desenvolvedores): Figura 2 - Instalando o IronPDF através do Gerenciador de Pacotes NuGet

Gerando um PDF usando o IronPDF

Abaixo está o código para gerar um relatório em PDF usando uma string HTML e o gerador IronPDF :

// See https://aka.ms/new-console-template for more information

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

class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int Age { get; set; }
}

class Program
{
    static void Main()
    {
        List<Person> people = new List<Person>
        {
            new Person { FirstName = "John", LastName = "Doe", Age = 30 },
            new Person { FirstName = "Alice", LastName = "Smith", Age = 25 },
            new Person { FirstName = "Bob", LastName = "Johnson", Age = 35 }
        };

        // Sort people by age
        var sortedPeople = people.OrderBy(person => person.Age);

        string name = "Sam";
        var count = people.Count;

        // Generate an HTML string
        string content = $@"<!DOCTYPE html>
<html>
<body>
<h1>Hello, {name}!</h1>
<p>You have {count} people sorted by Age.</p>
" + string.Join("\n", sortedPeople.Select(person => $"{person.FirstName} {person.LastName}, Age: {person.Age}"))
+ @"
</body>
</html>";

        // Create a new PDF document and save it
        var pdfDocument = new ChromePdfRenderer();
        pdfDocument.RenderHtmlAsPdf(content).SaveAs("personByAge.pdf");
    }
}
// See https://aka.ms/new-console-template for more information

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

class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int Age { get; set; }
}

class Program
{
    static void Main()
    {
        List<Person> people = new List<Person>
        {
            new Person { FirstName = "John", LastName = "Doe", Age = 30 },
            new Person { FirstName = "Alice", LastName = "Smith", Age = 25 },
            new Person { FirstName = "Bob", LastName = "Johnson", Age = 35 }
        };

        // Sort people by age
        var sortedPeople = people.OrderBy(person => person.Age);

        string name = "Sam";
        var count = people.Count;

        // Generate an HTML string
        string content = $@"<!DOCTYPE html>
<html>
<body>
<h1>Hello, {name}!</h1>
<p>You have {count} people sorted by Age.</p>
" + string.Join("\n", sortedPeople.Select(person => $"{person.FirstName} {person.LastName}, Age: {person.Age}"))
+ @"
</body>
</html>";

        // Create a new PDF document and save it
        var pdfDocument = new ChromePdfRenderer();
        pdfDocument.RenderHtmlAsPdf(content).SaveAs("personByAge.pdf");
    }
}
' See https://aka.ms/new-console-template for more information

Imports Microsoft.VisualBasic
Imports IronPdf
Imports System
Imports System.Collections.Generic
Imports System.Linq

Friend Class Person
	Public Property FirstName() As String
	Public Property LastName() As String
	Public Property Age() As Integer
End Class

Friend Class Program
	Shared Sub Main()
		Dim people As New List(Of Person) From {
			New Person With {
				.FirstName = "John",
				.LastName = "Doe",
				.Age = 30
			},
			New Person With {
				.FirstName = "Alice",
				.LastName = "Smith",
				.Age = 25
			},
			New Person With {
				.FirstName = "Bob",
				.LastName = "Johnson",
				.Age = 35
			}
		}

		' Sort people by age
		Dim sortedPeople = people.OrderBy(Function(person) person.Age)

		Dim name As String = "Sam"
		Dim count = people.Count

		' Generate an HTML string
		Dim content As String = $"<!DOCTYPE html>
<html>
<body>
<h1>Hello, {name}!</h1>
<p>You have {count} people sorted by Age.</p>
" & String.Join(vbLf, sortedPeople.Select(Function(person) $"{person.FirstName} {person.LastName}, Age: {person.Age}")) & "
</body>
</html>"

		' Create a new PDF document and save it
		Dim pdfDocument = New ChromePdfRenderer()
		pdfDocument.RenderHtmlAsPdf(content).SaveAs("personByAge.pdf")
	End Sub
End Class
$vbLabelText   $csharpLabel

Aqui, primeiro geramos uma string HTML a partir de sortedPeople, que é classificada em ordem crescente com toda a formatação necessária para os relatórios. Em seguida, usamos o IronPDF para gerar um documento PDF. Utilizamos o método RenderHtmlAsPdf para converter a string HTML em um documento PDF.

Saída

O seguinte resultado está disponível no PDF:

Orderby em C# (Como funciona para desenvolvedores): Figura 3 - PDF de saída do código anterior

Licenciamento (Teste Gratuito Disponível)

Uma chave de avaliação pode ser obtida em Licença de Avaliação do IronPDF . Essa chave precisa ser inserida no arquivo appsettings.json.

"IronPdf.LicenseKey": "your license key"

Forneça seu e-mail para obter uma licença de avaliação.

Conclusão

O método OrderBy em C# é uma ferramenta versátil para classificar coleções com base em diversos critérios. Quer você esteja classificando em ordem crescente ou decrescente, por um ou vários critérios, ou usando comparadores personalizados, dominar o OrderBy pode melhorar significativamente a clareza e a eficiência do seu código.

Em conjunto com a biblioteca IronPDF para geração de documentos PDF , forma uma ótima combinação para gerar uma coleção bem formatada e organizada em formato de documento.

Perguntas frequentes

Como funciona o método OrderBy em C#?

O método `OrderBy` em C#, parte da biblioteca LINQ, ordena os elementos de uma coleção em ordem crescente. Ele pode ser usado tanto com sintaxe de método quanto com sintaxe de consulta, e é versátil o suficiente para lidar com números inteiros, strings e objetos personalizados.

Como posso ordenar dados em ordem decrescente usando C#?

Para ordenar dados em ordem decrescente em C#, você pode usar o método OrderByDescending. Ele faz parte da biblioteca LINQ e complementa o OrderBy para diferentes necessidades de ordenação.

É possível classificar por múltiplos campos em C#?

Sim, em C#, você pode classificar por vários campos usando `OrderBy` em combinação com `ThenBy` ou `ThenByDescending`. Isso permite critérios de classificação complexos, possibilitando que os desenvolvedores classifiquem coleções com base em múltiplos atributos.

O que é um comparador personalizado e como ele é usado na ordenação em C#?

Um comparador personalizado em C# é uma implementação da interface IComparer, que fornece lógica personalizada para comparar elementos durante a ordenação. Isso é útil para classificar objetos complexos ou quando o comportamento padrão de ordenação não atende a requisitos específicos.

Como posso usar o IronPDF para gerar PDFs em C#?

Você pode usar o IronPDF em C# para gerar PDFs a partir de strings HTML, arquivos ou até mesmo URLs da web. O IronPDF mantém o layout e o estilo do conteúdo original, tornando-o ideal para a criação de documentos profissionais, como relatórios e faturas.

Quais são os passos para instalar o IronPDF em um projeto C#?

O IronPDF pode ser instalado em um projeto C# usando o gerenciador de pacotes NuGet. Você pode executar o comando dotnet add package IronPDF no console ou usar o gerenciador de pacotes do Visual Studio para adicioná-lo ao seu projeto.

Como o IronPDF se integra com o OrderBy do C# para geração de PDFs?

O IronPDF pode ser integrado ao OrderBy do C# para criar relatórios em PDF classificados e formatados. Ao classificar as coleções de dados usando o OrderBy antes da renderização, você garante que o PDF gerado seja organizado de acordo com seus critérios de classificação.

O IronPDF consegue converter um URL de página web em um PDF?

Sim, o IronPDF pode converter conteúdo da web a partir de uma URL em um documento PDF. Ele preserva o layout e os estilos originais da página da web, tornando-o adequado para arquivar páginas da web ou criar versões para impressão.

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