Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. .NET Hilfe
  4. C# Sortierung mit OrderBy - Leitfaden
.NET HILFE

C# Orderby (Funktionsweise für Entwickler)

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
Aktualisiert:

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

Hier ist die collection die IEnumerable-Quellensammlung, die Sie sortieren möchten, und OrderByProperty ist die Eigenschaft oder Ausdruck, anhand derer Sie die Elemente sortieren möchten. Der Lambda-Ausdruck innerhalb von OrderBy gibt das Sortierkriterium an.

Sortieren von Daten in absteigender Reihenfolge

Um in absteigender Reihenfolge zu sortieren, können Sie die OrderByDescending-Methode 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)
$vbLabelText   $csharpLabel

Daten nach mehreren Kriterien sortieren

In realen Szenarien müssen Sie oft eine Sammlung basierend auf mehreren Kriterien sortieren. OrderBy ermöglicht dies, indem mehrere ThenBy- oder ThenByDescending-Aufrufe verkettet werden:

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

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

Benutzerdefinierte Vergleiche

Bei komplexeren Sortieranfragen können Sie benutzerdefinierte Vergleicher verwenden. Die OrderBy-Methode erlaubt es, eine IComparer-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())
$vbLabelText   $csharpLabel

Hier ist CustomComparer eine Klasse, die das IComparer-Interface implementiert und benutzerdefinierte Logik zum Vergleichen von Elementen bereitstellt.

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

In diesem Beispiel wird eine Liste von Ganzzahlen 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
$vbLabelText   $csharpLabel

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

In diesem Beispiel wird eine Liste benutzerdefinierter Person-Objekte basierend auf der Age-Eigenschaft in aufsteigender Reihenfolge sortiert.

Folgende Ausgabe ist in der Konsole sichtbar:

C# Orderby (Wie es für Entwickler funktioniert): 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)
$vbLabelText   $csharpLabel

In diesem Beispiel wird der StringComparer.OrdinalIgnoreCase verwendet, um eine nicht-case-sensitive 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 leistungskritische Szenarien könnten Sie Alternativen wie In-Place-Sortierung mit der List.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
$vbLabelText   $csharpLabel

Installation

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

Install-Package IronPdf

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

C# Orderby (Wie es für Entwickler funktioniert): Abbildung 2 - Installation von IronPDF über den NuGet-Paketmanager

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

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

Ausgabe

Folgende Ausgabe ist im PDF verfügbar:

C# Orderby (Wie es für Entwickler funktioniert): 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"

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.

Häufig gestellte Fragen

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<T>-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.

Jacob Mellor, Chief Technology Officer @ Team Iron
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 führend in der C# PDF-Technologie ist. Als ursprünglicher Entwickler der Iron Software-Kerncodebasis hat er die Produktarchitektur des Unternehmens seit seiner Gründung gestaltet und zusammen mit CEO Cameron Rimington in ein Unternehmen ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen