C# Orderby (Wie es für Entwickler funktioniert)

Sortieren ist eine grundlegende Operation in jeder Programmiersprache, und die C# OrderBy-Methode ist ein leistungsfähiges Werkzeug für die Anordnung von Elementen in Sammlungen. Egal, ob Sie mit Arrays, Listen oder anderen aufzählbaren Strukturen arbeiten, wenn Sie wissen, wie Sie OrderBy nutzen können, können Sie die Lesbarkeit und Funktionalität Ihres Codes erheblich verbessern.

Später in diesem Artikel werden wir die IronPDF-Bibliothek von Iron Software vorstellen und wie wir die LINQ OrderBy-Methode und IronPDF verwenden 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 wurde speziell entwickelt, um Elemente in aufsteigender Reihenfolge zu sortieren; da die Daten standardmäßig aufsteigend sortiert werden, ist ein aufsteigendes Schlüsselwort nicht erforderlich.

Wie man die LINQ OrderBy-Methode verwendet

Sortieren von Daten in aufsteigender Reihenfolge

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

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

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

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

Hierbei ist die Sammlung die IEnumerable-Quellensammlung, die Sie sortieren möchten, und OrderByProperty ist die Eigenschaft oder der Ausdruck, nach dem Sie die Elemente ordnen möchten. Die Lambda-Ausdrucks-Erweiterungsmethode innerhalb von OrderBy legt das Sortierkriterium fest.

Sortieren von Daten in absteigender Reihenfolge

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

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

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

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

Sortieren von Daten nach mehreren Kriterien

In der Praxis müssen Sie häufig eine Sammlung nach mehreren Kriterien sortieren. OrderBy ermöglicht dies durch Verkettung 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)

In diesem Beispiel wird die Sammlung zunächst nach OrderByProperty1 in aufsteigender Reihenfolge sortiert. Dann werden die Elemente mit demselben OrderByProperty1-Wert nach OrderByProperty2 in absteigender Reihenfolge sortiert.

Benutzerdefinierte Vergleicher

Für komplexere Sortieranforderungen 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())

Hier ist CustomComparer eine Klasse, die das IComparer<T>-Interface implementiert und benutzerdefinierte Logik für den Vergleich von Elementen bereitstellt.

Praktisches Beispiel: Objekte sortieren

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

In diesem Beispiel wird eine Liste von ganzen Zahlen in aufsteigender Reihenfolge mithilfe 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

Dieses Beispiel zeigt, wie eine Liste von Zeichenketten in aufsteigender Reihenfolge alphabetisch sortiert wird.

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

In diesem Beispiel wird eine Liste von benutzerdefinierten Personenobjekten auf der Grundlage der Eigenschaft Alter in aufsteigender Reihenfolge sortiert.

Die folgende Ausgabe ist in der Konsole zu sehen

Handhabung von String-Vergleichen

Wenn Sie mit Zeichenketteneigenschaften arbeiten, sollten Sie die Groß- und Kleinschreibung bei der Sortierung nicht berücksichtigen:

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)

Dieses Beispiel verwendet den StringComparer.OrdinalIgnoreCase, um eine Groß-/Kleinschreibung ignorierende Sortierung basierend auf der LastName-Eigenschaft durchzuführen.

Überlegungen zur Leistung

LINQ bietet zwar eine übersichtliche Möglichkeit zum Sortieren von Sammlungen, aber es ist wichtig, die Auswirkungen auf die Leistung zu berücksichtigen, insbesondere bei großen Datensätzen. Für performancekritische Szenarien können Sie Alternativen wie das Sortieren an Ort und Stelle mit der List<T>.Sort-Methode in Betracht ziehen.

Einführung in IronPDF

Entdecken Sie die Möglichkeiten von IronPDF innerhalb der C# PDF-Bibliothek von Iron Software, die beim Lesen und Erstellen von PDF-Dokumenten hilft. Sie kann formatierte Dokumente mit Stilinformationen problemlos in PDF konvertieren. IronPDF kann PDFs aus HTML-Strings generieren oder den HTML-Code von der URL herunterladen und dann PDFs generieren.

IronPDF glänzt, wenn es um die Konvertierung von HTML in PDF geht, wobei alle Layouts und Stile erhalten bleiben. Es kann PDFs aus verschiedenen Webinhalten generieren, wie zum Beispiel Berichte, Rechnungen und Dokumentationen. Das Werkzeug arbeitet mit HTML-Dateien, URLs und HTML-Zeichenfolgen, 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

Einrichtung

IronPDF kann über die NuGet-Paketmanager-Konsole oder den Visual Studio-Paketmanager installiert werden.

dotnet add package IronPdf

dotnet add package IronPdf

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'dotnet add package IronPdf

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

Erzeugen einer PDF-Datei mit IronPDF

Im Folgenden finden Sie den Code für die Erstellung eines PDF-Berichts mithilfe eines HTML-Strings und des IronPDF-Generators:

// See https://aka.ms/new-console-template for more information
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);
        string name = "Sam";
        var count = people.Count;
        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
        var pdfDocument = new ChromePdfRenderer();
        pdfDocument.RenderHtmlAsPdf(content).SaveAs("personByAge.pdf");
    }
}

// See https://aka.ms/new-console-template for more information
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);
        string name = "Sam";
        var count = people.Count;
        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
        var pdfDocument = new ChromePdfRenderer();
        pdfDocument.RenderHtmlAsPdf(content).SaveAs("personByAge.pdf");
    }
}

Imports Microsoft.VisualBasic

' See https://aka.ms/new-console-template for more information
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)
		Dim name As String = "Sam"
		Dim count = people.Count
		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
		Dim pdfDocument = New ChromePdfRenderer()
		pdfDocument.RenderHtmlAsPdf(content).SaveAs("personByAge.pdf")
	End Sub
End Class

Hier generieren wir zunächst einen HTML-String aus sortedPeople, der in aufsteigender Reihenfolge mit allen für die Berichte erforderlichen Formatierungen sortiert ist. Dann verwenden wir IronPDF, um ein PDF-Dokument zu erstellen. Wir verwenden die Methode RenderHtmlAsPdf, um den HTML-String in ein PDF-Dokument zu konvertieren.

Ausgabe

Die folgende Ausgabe ist in der PDF-Datei verfügbar.

Lizenzierung (kostenlose Testversion verfügbar)

Ein Testschlüssel kann von IronPDF Trial License erhalten werden. Dieser Schlüssel muss in appsettings.json platziert werden.

"IronPdf.LicenseKey": "your license key"

"IronPdf.LicenseKey": "your license key"

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'"IronPdf.LicenseKey": "your license key"

Geben Sie Ihre E-Mail-Adresse an, um eine Testlizenz zu erhalten.

Schlussfolgerung

Die OrderBy-Methode in C# ist ein vielseitiges Werkzeug zum Sortieren von Sammlungen nach verschiedenen Kriterien. Unabhängig davon, ob Sie in aufsteigender oder absteigender Reihenfolge, nach einzelnen oder mehreren Kriterien sortieren oder benutzerdefinierte Vergleicher verwenden, kann die Beherrschung von OrderBy die Klarheit und Effizienz Ihres Codes erheblich verbessern.

Zusammen mit der IronPDF-Bibliothek zur Erstellung von PDF-Dokumenten ist es eine großartige Kombination zur Erstellung einer schön formatierten und sortierten Sammlung als Dokument.