Ícono de mensaje
Saltar al pie de página
  1. IronPDF
  2. Blog de IronPDF
  3. .NET Ayuda
  4. guía-de-orderby-csharp
.NET AYUDA

C# Orderby (Cómo Funciona para Desarrolladores)

Jacob Mellor, Director de Tecnología @ Team Iron
Jacob Mellor
Actualizado:

La clasificación es una operación fundamental en cualquier lenguaje de programación, y el método OrderBy de C# es una herramienta poderosa para organizar elementos dentro de colecciones. Ya sea trabajando con matrices, listas u otras estructuras enumerables, comprender cómo aprovechar OrderBy puede mejorar significativamente la legibilidad y funcionalidad de tu código.

Más adelante en este artículo, presentaremos la biblioteca IronPDF de Iron Software y cómo podemos utilizar el método LINQ OrderBy e IronPDF para generar PDFs formateados y ordenados.

¿Qué es el método LINQ OrderBy?

El método OrderBy es parte de la biblioteca LINQ (Consulta Integrada en el Lenguaje) en C# y está diseñado específicamente para ordenar elementos en orden ascendente; ya que es la forma predeterminada de ordenar datos, no hay necesidad de una palabra clave para ascendente.

Cómo utilizar el método LINQ OrderBy

Clasificación de datos en orden ascendente

En C#, hay dos formas de aplicar este método: mediante la sintaxis de método o la sintaxis de consulta. Usaremos la sintaxis de método ya que es directa:

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

Aquí, la colección es la colección fuente IEnumerable que deseas ordenar, y OrderByProperty es la propiedad o expresión por la que deseas ordenar los elementos. La expresión lambda dentro de OrderBy especifica el criterio de ordenación.

Clasificación de datos en orden descendente

Para ordenar en orden descendente, puedes usar el método OrderByDescending utilizando la sintaxis basada en métodos:

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

Ordenación de datos por múltiples criterios

En escenarios del mundo real, a menudo necesitas ordenar una colección basada en múltiples criterios. OrderBy permite esto al encadenar múltiples llamadas a ThenBy o 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

En este ejemplo, la colección primero se ordena por OrderByProperty1 en orden ascendente. Luego, para elementos con el mismo valor de OrderByProperty1, se ordena por OrderByProperty2 en orden descendente.

Comparadores personalizados

Para requisitos de ordenación más complejos, puedes usar comparadores personalizados. El método OrderBy te permite pasar una implementación IComparer, como se muestra en el siguiente ejemplo:

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

Aquí, CustomComparer es una clase que implementa la interfaz IComparer, proporcionando una lógica personalizada para comparar elementos.

Ejemplo práctico: Ordenación de objetos

Ordenación de una lista de números enteros

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

En este ejemplo, una lista de enteros se ordena en orden ascendente utilizando OrderBy.

Ordenar una lista de cadenas

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 ejemplo demuestra cómo ordenar una lista de cadenas en orden ascendente alfabéticamente.

Ordenación de una 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

En este ejemplo, una lista de objetos personalizados Persona se ordena basada en la propiedad Edad en orden ascendente.

La siguiente salida es visible en la consola:

C# Orderby (Cómo Funciona para Desarrolladores): Figura 1 - Salida del código anterior ordenando objetos personalizados

Manejo de comparaciones de cadenas

Al tratar con propiedades de cadena, es posible que quieras garantizar una ordenación insensible a mayúsculas y 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 ejemplo utiliza el StringComparer.OrdinalIgnoreCase para realizar una ordenación insensible a mayúsculas y minúsculas basada en la propiedad Apellido.

Consideraciones sobre el rendimiento

Aunque LINQ proporciona una forma concisa de ordenar colecciones, es esencial considerar las implicaciones de rendimiento, especialmente para grandes conjuntos de datos. Para escenarios críticos de rendimiento, puedes explorar alternativas como ordenar en el lugar utilizando el método List.Sort.

Presentando IronPDF

Descubre las capacidades de IronPDF dentro de la biblioteca de PDF de C# de Iron Software, que ayuda a leer y generar documentos PDF. Puede convertir fácilmente documentos formateados con información de estilo a PDF. IronPDF puede generar PDFs a partir de cadenas de HTML, o puede descargar el HTML de la URL y luego generar PDFs.

IronPDF destaca cuando se trata de convertir HTML a PDF, preservando todos los diseños y estilos. Puede generar PDFs a partir de varios contenidos web, como informes, facturas y documentación. La herramienta trabaja con archivos HTML, URLs y cadenas de HTML para crear archivos 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

Instalación

IronPDF se puede instalar utilizando la consola de administración de paquetes NuGet o utilizando el administrador de paquetes de Visual Studio.

Install-Package IronPdf

También puedes instalar IronPDF utilizando el Administrador de Paquetes NuGet buscando "IronPDF" en la barra de búsqueda.

C# Orderby (Cómo Funciona para Desarrolladores): Figura 2 - Instalación de IronPDF a través del Administrador de Paquetes NuGet

Generación de un PDF con IronPDF

A continuación se muestra el código para generar un informe PDF usando una cadena de HTML y el generador de 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

Aquí primero estamos generando una cadena HTML de sortedPeople que está ordenada en orden ascendente con todo el formato requerido para los informes. Luego usamos IronPDF para generar un documento PDF. Usamos el método RenderHtmlAsPdf para convertir la cadena HTML a un documento PDF.

Resultado

La siguiente salida está disponible en el PDF:

C# Orderby (Cómo Funciona para Desarrolladores): Figura 3 - Salida en PDF del código anterior

Licencia (Prueba gratuita disponible)

Se puede obtener una clave de prueba de Licencia de Prueba de IronPDF. Esta clave debe colocarse en appsettings.json.

"IronPdf.LicenseKey": "your license key"

Proporcione su correo para una licencia de prueba.

Conclusión

El método OrderBy en C# es una herramienta versátil para ordenar colecciones basadas en varios criterios. Ya sea que estés ordenando en orden ascendente o descendente, por un solo criterio o por múltiples criterios, o utilizando comparadores personalizados, dominar OrderBy puede mejorar significativamente la claridad y eficiencia de tu código.

Junto con la biblioteca IronPDF para generar documentos PDF, es una gran combinación para generar una colección bellamente formateada y ordenada como documento.

Preguntas Frecuentes

¿Cómo funciona el método OrderBy de C#?

El método OrderBy de C#, parte de la biblioteca LINQ, ordena elementos de una colección en orden ascendente. Puede usarse tanto con la sintaxis de método como con la sintaxis de consulta, y es lo suficientemente versátil como para manejar enteros, cadenas y objetos personalizados.

¿Cómo puedo ordenar los datos en orden descendente usando C#?

Para ordenar datos en orden descendente en C#, puedes usar el método OrderByDescending. Esto es parte de la biblioteca LINQ y complementa a OrderBy para diferentes necesidades de clasificación.

¿Es posible ordenar por múltiples campos en C#?

Sí, en C#, puedes ordenar por múltiples campos usando OrderBy en combinación con ThenBy o ThenByDescending. Esto permite criterios de clasificación complejos, permitiendo a los desarrolladores ordenar colecciones basadas en múltiples atributos.

¿Qué es un comparador personalizado y cómo se utiliza en la clasificación de C#?

Un comparador personalizado en C# es una implementación de la interfaz IComparer, que proporciona lógica personalizada para comparar elementos durante la ordenación. Esto es útil para ordenar objetos complejos o cuando el comportamiento de ordenación predeterminado no cumple con requisitos específicos.

¿Cómo puedo usar IronPDF para generar PDFs en C#?

Puedes usar IronPDF en C# para generar PDFs a partir de cadenas HTML, archivos o incluso URLs web. IronPDF mantiene el diseño y estilo del contenido original, siendo ideal para crear documentos profesionales como informes y facturas.

¿Cuáles son los pasos para instalar IronPDF en un proyecto C#?

IronPDF se puede instalar en un proyecto C# usando el gestor de paquetes NuGet. Puedes ejecutar el comando dotnet add package IronPdf en la consola o usar el gestor de paquetes en Visual Studio para agregarlo a tu proyecto.

¿Cómo se integra IronPDF con C# OrderBy para la generación de PDFs?

IronPDF se puede integrar con C# OrderBy para crear informes en PDF ordenados y formateados. Al ordenar las colecciones de datos usando OrderBy antes de renderizar, aseguras que la salida en PDF esté organizada según tus criterios de ordenación.

¿Puede IronPDF convertir una URL de página web en un PDF?

Sí, IronPDF puede convertir contenido web desde una URL en un documento PDF. Preserva el diseño y los estilos originales de la página web, haciéndolo adecuado para archivar páginas web o crear versiones imprimibles.

Jacob Mellor, Director de Tecnología @ Team Iron
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, ...

Leer más

Artículos Relacionados

Prueba de 30 días → Producto completo. Sin límites. Sin tarjeta. Prueba gratis