Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. guide-csharp-orderby
.NET AIDE

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

Curtis Chau
Curtis Chau
Mis à jour:

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

Ici, la collection est la source de collection IEnumerable que vous souhaitez trier, et OrderByProperty est la propriété ou l'expression par laquelle vous souhaitez ordonner les éléments. L'expression lambda au sein de 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)
$vbLabelText   $csharpLabel

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

Dans cet exemple, la collection est d'abord triée par OrderByProperty1 par ordre croissant. Ensuite, pour les éléments ayant la même valeur OrderByProperty1, elle est triée par OrderByProperty2 par 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 de 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())
$vbLabelText   $csharpLabel

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
$vbLabelText   $csharpLabel

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
$vbLabelText   $csharpLabel

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
$vbLabelText   $csharpLabel

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

La sortie suivante est visible dans la console :

C# Orderby (Comment cela fonctionne pour les développeurs) : Figure 1 - Sortie du code précédent triant 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)
$vbLabelText   $csharpLabel

Cet exemple utilise le 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 les scénarios critiques en termes de performance, vous pourriez explorer des alternatives comme le tri en place en utilisant la méthode List<T>.Sort.

Présentation d'IronPDF

Discover IronPDF capabilities within the C# PDF library from 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
$vbLabelText   $csharpLabel

Installation

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

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 cela fonctionne pour les développeurs) : Figure 2 - Installation d'IronPDF via le gestionnaire de packages NuGet

Générer un PDF en utilisant 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 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

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 un document PDF.

Sortie

La sortie suivante est disponible dans le PDF :

C# Orderby (Comment cela fonctionne pour les développeurs) : Figure 3 - Sortie PDF 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"

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.

Questions Fréquemment Posées

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. Ceci est utile pour trier des objets complexes ou lorsque le comportement de tri par défaut ne répond pas à des besoins 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.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit