Wie funktioniert die OrderBy-Methode in C#?

Die OrderBy-Methode in C#, Teil der LINQ-Bibliothek, sortiert Elemente einer Sammlung in aufsteigender Reihenfolge. Sie kann sowohl mit Methoden- als auch mit Abfragesyntax verwendet werden und ist vielseitig genug, um mit ganzen Zahlen, Zeichenfolgen und benutzerdefinierten Objekten zu arbeiten.

Wie kann ich Daten in absteigender Reihenfolge in C# sortieren?

Um Daten in absteigender Reihenfolge in C# zu sortieren, können Sie die OrderByDescending-Methode verwenden. Diese ist Teil der LINQ-Bibliothek und ergänzt OrderBy für unterschiedliche Sortieranforderungen.

Ist es möglich, nach mehreren Feldern in C# zu sortieren?

Ja, in C# können Sie mit OrderBy in Kombination mit ThenBy oder ThenByDescending nach mehreren Feldern sortieren. Dies ermöglicht komplexe Sortierkriterien, die es Entwicklern erlauben, Sammlungen basierend auf mehreren Attributen zu sortieren.

Was ist ein benutzerdefinierter Vergleichsrichter und wie wird er beim Sortieren in C# verwendet?

Ein benutzerdefinierter Vergleicher in C# ist eine Implementierung des IComparer -Interfaces, das benutzerdefinierte Logik für den Vergleich von Elementen während des Sortierens bietet. Dies ist nützlich für das Sortieren komplexer Objekte oder wenn das standardmäßige Sortierverhalten spezifische Anforderungen nicht erfüllt.

Wie kann ich IronPDF verwenden, um PDFs in C# zu erzeugen?

Sie können IronPDF in C# verwenden, um PDFs aus HTML-Strings, Dateien oder sogar Web-URLs zu erzeugen. IronPDF bewahrt das Layout und den Stil des Originalinhalts, was es ideal für die Erstellung professioneller Dokumente wie Berichte und Rechnungen macht.

Welche Schritte sind nötig, um IronPDF in einem C#-Projekt zu installieren?

IronPDF kann in einem C#-Projekt mit dem NuGet-Paketmanager installiert werden. Sie können den Befehl dotnet add package IronPDF in der Konsole ausführen oder den Paketmanager in Visual Studio verwenden, um es zu Ihrem Projekt hinzuzufügen.

Wie integriert sich IronPDF mit C# OrderBy zur PDF-Erstellung?

IronPDF kann mit C# OrderBy integriert werden, um sortierte und formatierte PDF-Berichte zu erstellen. Indem Sie Datenkollektionen vor dem Rendern mit OrderBy sortieren, stellen Sie sicher, dass der PDF-Ausgabe entsprechend Ihren Sortierkriterien organisiert ist.

Kann IronPDF eine Web-URL in ein PDF konvertieren?

Ja, IronPDF kann Webinhalte von einer URL in ein PDF-Dokument umwandeln. Es bewahrt das ursprüngliche Layout und die Stile der Webseite, was es geeignet macht für die Archivierung von Webseiten oder die Erstellung druckbarer Versionen.

Die C# PDF-Bibliothek

Explore IronPDF Gratis testen

HTML zu PDF

Online Demo Alle Codebeispiele anzeigen

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

ENTWICKLER-UPDATES

C# Orderby (Funktionsweise für Entwickler)

Jacob Mellor

Updated: 21. April 2026

Sortieren ist eine grundlegende Operation in jeder Programmiersprache, und die C# OrderBy-Methode ist ein leistungsstarkes Werkzeug zum Anordnen von Elementen innerhalb von Sammlungen. Ob Sie mit Arrays, Listen oder anderen aufzählbaren Strukturen arbeiten, das Verständnis, wie man OrderBy nutzt, kann die Lesbarkeit und Funktionalität Ihres Codes erheblich verbessern.

Später in diesem Artikel stellen wir die IronPDF-Bibliothek von Iron Software vor und wie wir die LINQ OrderBy-Methode und IronPDF nutzen können, um formatierte und sortierte PDFs zu erstellen.

Was ist die LINQ OrderBy Methode?

Die OrderBy-Methode ist Teil der LINQ (Language-Integrated Query)-Bibliothek in C# und ist speziell dafür ausgelegt, Elemente in aufsteigender Reihenfolge zu sortieren; da es der Standardweg ist, Daten zu sortieren, ist kein aufsteigendes Schlüsselwort erforderlich.

Wie man die LINQ OrderBy Methode verwendet

Daten in aufsteigender Reihenfolge sortieren

In C# gibt es zwei Möglichkeiten, diese Methode anzuwenden: durch Methodensyntax oder Abfragesyntax. Wir werden die Methodensyntax verwenden, da sie einfach ist:

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)

Hierbei ist collection die IEnumerable-Quellenkollektion, die Sie sortieren möchten, und OrderByProperty ist die Eigenschaft oder der Ausdruck, nach dem Sie die Elemente ordnen möchten. Der Lambdaausdruck innerhalb von OrderBy legt das Sortierkriterium fest.

Sortieren von Daten in absteigender Reihenfolge

Um in absteigender Reihenfolge zu sortieren, können Sie die OrderByDescending-Methode mit der methode-basierten Syntax verwenden:

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)

Daten nach mehreren Kriterien sortieren

In realen Szenarien müssen Sie oft eine Sammlung basierend auf mehreren Kriterien sortieren. OrderBy ermöglicht dies durch das Verketten mehrerer ThenBy- oder ThenByDescending-Aufrufe:

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)

In diesem Beispiel wird die Sammlung zuerst nach OrderByProperty1 in aufsteigender Reihenfolge sortiert. Dann, für Elemente mit demselben OrderByProperty1-Wert, wird nach OrderByProperty2 in absteigender Reihenfolge sortiert.

Benutzerdefinierte Vergleiche

Bei komplexeren Sortieranfragen können Sie benutzerdefinierte Vergleicher verwenden. Die OrderBy-Methode ermöglicht es Ihnen, eine IComparer<t>-Implementierung zu übergeben, wie im folgenden Beispiel gezeigt:

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

Hierbei ist CustomComparer eine Klasse, die die IComparer<t>-Schnittstelle implementiert und benutzerdefinierte Logik zum Vergleichen von Elementen bietet.

Praktisches Beispiel: Sortieren von Objekten

Sortieren einer Liste von Ganzzahlen

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

In diesem Beispiel wird eine Liste von Ganzzahlen in aufsteigender Reihenfolge unter Verwendung von OrderBy sortiert.

Sortieren einer Liste von 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

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

In diesem Beispiel wird das Sortieren einer Liste von Zeichenfolgen in aufsteigender alphabetischer Reihenfolge demonstriert.

Sortieren einer Liste von benutzerdefinierten Objekten

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

In diesem Beispiel wird eine Liste von benutzerdefinierten Person-Objekten basierend auf der Age-Eigenschaft in aufsteigender Reihenfolge sortiert.

Folgende Ausgabe ist in der Konsole sichtbar:

C# Orderby (How It Works For Developers): Abbildung 1 - Ausgabe des vorherigen Codes, der benutzerdefinierte Objekte sortiert

Handhabung von String-Vergleichen

Im Umgang mit Zeichenfolgeneigenschaften möchten Sie möglicherweise eine nicht-case-sensitive Sortierung sicherstellen:

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)

Dieses Beispiel verwendet StringComparer.OrdinalIgnoreCase, um eine fallunabhängige Sortierung basierend auf der LastName-Eigenschaft durchzuführen.

Erwägungen zur Leistung

Während LINQ eine prägnante Möglichkeit bietet, Sammlungen zu sortieren, ist es wichtig, die Leistungsauswirkungen insbesondere für große Datensätze zu berücksichtigen. Für leistungsrelevante Szenarien könnten Sie Alternativen wie das Sortieren direkt im Speicher mit der List<t>.Sort-Methode in Betracht ziehen.

Einführung in IronPDF

Entdecken Sie die Fähigkeiten von IronPDF innerhalb der C# PDF-Bibliothek von Iron Software, die hilft, PDF-Dokumente zu lesen und zu erstellen. Es kann formatierte Dokumente mit Stilinformationen problemlos in PDF konvertieren. IronPDF kann PDFs aus HTML-Strings generieren oder das HTML von der URL herunterladen und dann PDFs generieren.

IronPDF brilliert, wenn es darum geht, HTML in PDF zu konvertieren, wobei alle Layouts und Stile erhalten bleiben. Es kann PDFs aus verschiedenen Webinhalten wie Berichten, Rechnungen und Dokumentationen generieren. Das Tool arbeitet mit HTML-Dateien, URLs und HTML-Strings, um PDF-Dateien zu erstellen.

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 kann über die NuGet-Paketmanager-Konsole oder über den Visual Studio Paketmanager installiert werden.

PM > Install-Package IronPdf

Install-Package IronPdf

Sie können IronPDF auch über den NuGet-Paket-Manager installieren, indem Sie "IronPDF" in der Suchleiste suchen.

C# Orderby (How It Works For Developers): Abbildung 2 - Installation von IronPDF über den NuGet-Paket-Manager

PDF-Erzeugung mit IronPDF

Unten ist der Code zur Erstellung eines PDF-Berichts mithilfe eines HTML-Strings und des IronPDF-Generators:

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

Hier erzeugen wir zuerst eine HTML-Zeichenkette aus sortedPeople, die in aufsteigender Reihenfolge sortiert wird, mit all dem für die Berichte erforderlichen Format. Dann verwenden wir IronPDF, um ein PDF-Dokument zu erstellen. Wir nutzen die RenderHtmlAsPdf-Methode, um die HTML-Zeichenkette in ein PDF-Dokument zu konvertieren.

Ausgabe

Folgende Ausgabe ist im PDF verfügbar:

C# Orderby (How It Works For Developers): Abbildung 3 - Ausgabe-PDF aus dem vorherigen Code

Lizenzierung (Kostenlose Testversion verfügbar)

Ein Testschlüssel kann von der IronPDF-Testlizenz erhalten werden. Dieser Schlüssel muss in appsettings.json platziert werden.

"IronPdf.LicenseKey": "your license key"

"IronPdf.LicenseKey": "your license key"

JSON

Geben Sie Ihre E-Mail für eine Testlizenz an.

Abschluss

Die OrderBy-Methode in C# ist ein vielseitiges Werkzeug zum Sortieren von Sammlungen basierend auf verschiedenen Kriterien. Ob Sie in aufsteigender oder absteigender Reihenfolge, nach einzelnen oder mehreren Kriterien oder mit benutzerdefinierten Vergleichern sortieren, das Beherrschen von OrderBy kann die Klarheit und Effizienz Ihres Codes erheblich verbessern.

Zusammen mit der IronPDF-Bibliothek zur Erstellung von PDF-Dokumenten ist es eine großartige Kombination, um eine wunderschön formatierte und sortierte Sammlung als Dokument zu erstellen.

Jacob Mellor

Jetzt mit dem Ingenieurteam chatten

Chief Technology Officer

Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO Cameron Rimington in ein Unternehmen mit mehr als 50 Mitarbeitern verwandelt, das die NASA, Tesla und globale Regierungsbehörden beliefert.

...