Comment fonctionne la méthode OrderBy de C# ?

La méthode OrderBy de C#, faisant partie de la bibliothèque LINQ, trie les éléments d'une collection par ordre croissant. Elle peut être utilisée avec une syntaxe de méthode ou de requête et est suffisamment polyvalente pour gérer des entiers, des chaînes et des objets personnalisés.

Comment puis-je trier des données par ordre décroissant en C# ?

Pour trier des données par ordre décroissant en C#, vous pouvez utiliser la méthode OrderByDescending. Celle-ci fait partie de la bibliothèque LINQ et complète OrderBy pour répondre à différents besoins de tri.

Est-il possible de trier par plusieurs champs en C# ?

Oui, en C#, vous pouvez trier par plusieurs champs en utilisant OrderBy en combinaison avec ThenBy ou ThenByDescending. Cela permet des critères de tri complexes, permettant aux développeurs de trier des collections en fonction de plusieurs attributs.

Qu'est-ce qu'un comparateur personnalisé et comment est-il utilisé dans le tri en C# ?

Un comparateur personnalisé en C# est une implémentation de l'interface IComparer, qui fournit une logique personnalisée pour comparer des éléments lors du tri. Cela est utile pour trier des objets complexes ou lorsque le comportement de tri par défaut ne répond pas à des exigences spécifiques.

Comment puis-je utiliser IronPDF pour générer des PDFs en C# ?

Vous pouvez utiliser IronPDF en C# pour générer des PDFs à partir de chaînes HTML, de fichiers ou même d'URL Web. IronPDF maintient la mise en page et le style du contenu original, ce qui le rend idéal pour créer des documents professionnels tels que des rapports et des factures.

Quelles sont les étapes pour installer IronPDF dans un projet C# ?

IronPDF peut être installé dans un projet C# à l'aide du gestionnaire de packages NuGet. Vous pouvez exécuter la commande dotnet add package IronPDF dans la console ou utiliser le gestionnaire de packages dans Visual Studio pour l'ajouter à votre projet.

Comment IronPDF s'intègre-t-il avec C# OrderBy pour la génération de PDF ?

IronPDF peut être intégré avec C# OrderBy pour créer des rapports PDF triés et formatés. En triant les collections de données à l'aide de OrderBy avant le rendu, vous vous assurez que la sortie PDF est organisée selon vos critères de tri.

IronPDF peut-il convertir une URL de page Web en PDF ?

Oui, IronPDF peut convertir le contenu Web d'une URL en document PDF. Il préserve la mise en page et les styles originaux de la page Web, ce qui le rend adapté à l'archivage de pages Web ou à la création de versions imprimables.

La Bibliothèque PDF C#

Explore IronPDF Essai gratuit

HTML en PDF

Online Demo Voir tous les exemples de code %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

MISES À JOUR POUR LES DÉVELOPPEURS

C# Orderby (Comment ça fonctionne pour les développeurs)

Jacob Mellor

Updated: 21 avril 2026

Le tri est une opération fondamentale dans n'importe quel langage de programmation, et la méthode OrderBy en C# est un outil puissant pour organiser les éléments au sein des collections. Que vous travailliez avec des tableaux, des listes ou d'autres structures énumérables, comprendre comment exploiter OrderBy peut grandement améliorer la lisibilité et la fonctionnalité de votre code.

Plus loin dans cet article, nous présenterons la bibliothèque IronPDF d'Iron Software et comment nous pouvons utiliser la méthode LINQ OrderBy et IronPDF pour générer des PDF formatés et triés.

Qu'est-ce que la méthode LINQ OrderBy ?

La méthode OrderBy fait partie de la bibliothèque LINQ (Language-Integrated Query) en C# et est spécialement conçue pour trier les éléments par ordre croissant; comme c'est le moyen par défaut de trier les données, il n'est pas nécessaire d'utiliser un mot-clé pour l'ordre croissant.

Comment utiliser la méthode LINQ OrderBy

Trier les données par ordre croissant

En C#, il existe deux façons d'appliquer cette méthode : par la syntaxe de méthode ou la syntaxe de requête. Nous utiliserons la syntaxe de méthode car elle est simple :

var sortedCollection = collection.OrderBy(item => item.OrderByProperty);

var sortedCollection = collection.OrderBy(item => item.OrderByProperty);

Dim sortedCollection = collection.OrderBy(Function(item) item.OrderByProperty)

Dim sortedCollection = collection.OrderBy(Function(item) item.OrderByProperty)

Ici, collection est la collection source IEnumerable que vous voulez trier, et OrderByProperty est la propriété ou l'expression selon laquelle vous voulez ordonner les éléments. L'expression lambda dans OrderBy spécifie le critère de tri.

Trier les données par ordre décroissant

Pour trier par ordre décroissant, vous pouvez utiliser la méthode OrderByDescending en utilisant la syntaxe basée sur les méthodes :

var sortedCollectionDesc = collection.OrderByDescending(item => item.OrderByProperty);

var sortedCollectionDesc = collection.OrderByDescending(item => item.OrderByProperty);

Dim sortedCollectionDesc = collection.OrderByDescending(Function(item) item.OrderByProperty)

Dim sortedCollectionDesc = collection.OrderByDescending(Function(item) item.OrderByProperty)

Trier les données par plusieurs critères

Dans les scénarios réels, vous devez souvent trier une collection basée sur plusieurs critères. OrderBy permet cela en enchaînant plusieurs appels 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)

Dim multiSortedCollection = collection.OrderBy(Function(item) item.OrderByProperty1).ThenByDescending(Function(item) item.OrderByProperty2)

Dans cet exemple, la collection est d'abord triée par OrderByProperty1 en ordre croissant. Ensuite, pour les éléments ayant la même valeur OrderByProperty1, elle est triée par OrderByProperty2 en ordre décroissant.

Comparateurs personnalisés

Pour des exigences de tri plus complexes, vous pouvez utiliser des comparateurs personnalisés. La méthode OrderBy vous permet de passer une implémentation IComparer<t>, comme montré dans l'exemple suivant :

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

Dim customSortedCollection = collection.OrderBy(Function(item) item.Property, New CustomComparer())

Ici, CustomComparer est une classe implémentant l'interface IComparer<t>, fournissant une logique personnalisée pour comparer les éléments.

Exemple pratique : Trier des objets

Trier une liste d'entiers

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

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

Dans cet exemple, une liste d'entiers est triée par ordre croissant en utilisant OrderBy.

Trier une liste de chaînes de caractères

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

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

Cet exemple illustre le tri d'une liste de chaînes de caractères par ordre croissant alphabétiquement.

Trier une liste d'objets personnalisés

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

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

Dans cet exemple, une liste d'objets personnalisés Person est triée basée sur la propriété Age par ordre croissant.

La sortie suivante est visible dans la console :

C# Orderby (Comment ça fonctionne pour les développeurs) : Figure 1 - Résultat du tri précédent des objets personnalisés

Gestion des comparaisons de chaînes de caractères

Lorsque vous traitez avec des propriétés de chaîne de caractères, vous souhaiterez peut-être assurer un tri insensible à la casse :

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)

Dim sortedPeopleByName = people.OrderBy(Function(person) person.LastName, StringComparer.OrdinalIgnoreCase)

Cet exemple utilise StringComparer.OrdinalIgnoreCase pour effectuer un tri insensible à la casse basé sur la propriété LastName.

Considérations de Performance

Bien que LINQ offre un moyen concis de trier les collections, il est essentiel de prendre en compte les implications sur les performances, surtout pour les grands ensembles de données. Pour des scénarios critiques en termes de performances, vous pourriez explorer des alternatives comme le tri en place en utilisant la méthode List<t>.Sort.

Présentation d'IronPDF

Découvrez les capacités d'IronPDF au sein de la bibliothèque PDF C# d'Iron Software, qui aide à lire et à générer des documents PDF. Il peut convertir facilement des documents formatés avec des informations de style en PDF. IronPDF peut générer des PDF à partir de chaînes HTML, ou il peut télécharger le HTML de l'URL puis générer des PDF.

IronPDF brille lorsqu'il s'agit de convertir du HTML en PDF, préservant toutes les mises en page et styles. Il peut générer des PDF à partir de divers contenus web, tels que des rapports, des factures et de la documentation. L'outil fonctionne avec des fichiers HTML, des URL, et des chaînes HTML pour créer des fichiers 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

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

Installation

IronPDF peut être installé en utilisant la console de gestionnaire de packages NuGet ou en utilisant le gestionnaire de packages Visual Studio.

PM > Install-Package IronPdf

Install-Package IronPdf

Vous pouvez également installer IronPDF en utilisant le gestionnaire de packages NuGet en recherchant " IronPDF " dans la barre de recherche.

C# Orderby (Comment ça fonctionne pour les développeurs) : Figure 2 - Installation de IronPDF via le gestionnaire de packages NuGet

Générer un PDF avec IronPDF

Voici le code pour générer un rapport PDF en utilisant une chaîne HTML et le générateur 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 IronPdf
Imports System
Imports System.Collections.Generic
Imports System.Linq

Class Person
    Public Property FirstName As String
    Public Property LastName As String
    Public Property Age As Integer
End Class

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 As New ChromePdfRenderer()
        pdfDocument.RenderHtmlAsPdf(content).SaveAs("personByAge.pdf")
    End Sub
End Class

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

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

Class Person
    Public Property FirstName As String
    Public Property LastName As String
    Public Property Age As Integer
End Class

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 As New ChromePdfRenderer()
        pdfDocument.RenderHtmlAsPdf(content).SaveAs("personByAge.pdf")
    End Sub
End Class

Ici, nous générons d'abord une chaîne HTML à partir de sortedPeople qui est triée par ordre croissant avec tout le formatage requis pour les rapports. Ensuite, nous utilisons IronPDF pour générer un document PDF. Nous utilisons la méthode RenderHtmlAsPdf pour convertir la chaîne HTML en document PDF.

Sortie

La sortie suivante est disponible dans le PDF :

C# Orderby (Comment ça fonctionne pour les développeurs) : Figure 3 - PDF de sortie du code précédent

Licence (Essai Gratuit Disponible)

Une clé d'essai peut être obtenue à partir de IronPDF Trial License. Cette clé doit être placée dans appsettings.json.

"IronPdf.LicenseKey": "your license key"

"IronPdf.LicenseKey": "your license key"

JSON

Fournissez votre email pour obtenir une licence d'essai.

Conclusion

La méthode OrderBy en C# est un outil polyvalent pour trier les collections basées sur divers critères. Que vous triiez par ordre ascendant ou descendant, par un ou plusieurs critères, ou en utilisant des comparateurs personnalisés, maîtriser OrderBy peut améliorer considérablement la clarté et l'efficacité de votre code.

Avec la bibliothèque IronPDF pour générer des documents PDF, c'est une excellente combinaison pour générer une collection joliment formatée et triée sous forme de document.

Jacob Mellor

Discutez maintenant avec l'équipe d'ingénierie

Directeur technique

Jacob Mellor est directeur de la technologie chez Iron Software et un ingénieur visionnaire pionnier de la technologie C# PDF. En tant que développeur à l'origine de la base de code centrale d'Iron Software, il a façonné l'architecture des produits de l'entreprise depuis sa création, la transformant aux côtés du PDG Cameron Rimington en une entreprise de plus de 50 personnes au service de la NASA, de Tesla et d'agences gouvernementales mondiales.

...