Zum Fußzeileninhalt springen
.NET HILFE

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

Listen sind vielseitige und dynamische Datenstrukturen, die verwendet werden, um Sammlungen von Daten in C# zu speichern und zu manipulieren. Sie sind Teil des System.Collections.Generic-Namensraums, der eine Reihe leistungsstarker, typsicherer Sammlungsklassen und stark typisierte Objekte bereitstellt. Dieses anfängerfreundliche Tutorial führt Sie durch die Grundlagen der Verwendung von C#-Listen, einschließlich der Erstellung/Hinzufügung von Elementen, des Zugriffs auf angegebene Indizes oder erste Vorkommen, der Modifizierung bestimmter Elemente und des Entfernens von Elementen sowie einiger häufiger Anwendungsfälle.

Listen erstellen

Um mit der Verwendung der List-Klasse zu beginnen, müssen Sie zuerst den System.Collections.Generic-Namensraum in Ihren Code aufnehmen:

using System.Collections.Generic;
using System.Collections.Generic;
Imports System.Collections.Generic
$vbLabelText   $csharpLabel

Nachdem Sie den generischen Namensraum hinzugefügt haben, erstellen Sie ein neues List-Objekt, indem Sie den Datentyp aller Elemente angeben, die Sie in spitzen Klammern (< >) speichern möchten. Hier ist ein Beispiel, wie man eine Liste von Ganzzahlen erstellt:

List<int> numbers = new List<int>();
List<int> numbers = new List<int>();
Dim numbers As New List(Of Integer)()
$vbLabelText   $csharpLabel

Sie können eine Liste auch mit einigen Anfangswerten initialisieren oder sie durch die angegebene Sammlung wie folgt definieren:

List<string> fruits = new List<string> { "apple", "banana", "cherry" };
List<string> fruits = new List<string> { "apple", "banana", "cherry" };
Dim fruits As New List(Of String) From {"apple", "banana", "cherry"}
$vbLabelText   $csharpLabel

Wir können auch die standardmäßige Anfangskapazität der Liste angeben. Die angegebene Anfangskapazität ist die standardmäßige maximale Kapazität der Liste.

Methoden der Liste

Anzahl der Elemente zu einer Liste hinzufügen

Um Elemente zu Ihrer Liste hinzuzufügen, verwenden Sie die Add()-Methode:

numbers.Add(1);     // Adds first element
numbers.Add(2);
numbers.Add(3);
numbers.Add(1);     // Adds first element
numbers.Add(2);
numbers.Add(3);
numbers.Add(1) ' Adds first element
numbers.Add(2)
numbers.Add(3)
$vbLabelText   $csharpLabel

Sie können auch einen Bereich von Elementen aus einer angegebenen Sammlung mit der AddRange-Methode zur Liste hinzufügen:

List<int> moreNumbers = new List<int> { 4, 5, 6 };
numbers.AddRange(moreNumbers);
List<int> moreNumbers = new List<int> { 4, 5, 6 };
numbers.AddRange(moreNumbers);
Dim moreNumbers As New List(Of Integer) From {4, 5, 6}
numbers.AddRange(moreNumbers)
$vbLabelText   $csharpLabel

Zugriff auf Listenelemente

Sie können auf einzelne Elemente einer Liste über einen Index genauso zugreifen wie bei Arrays:

string firstFruit = fruits[0];          // "apple"
string secondFruit = fruits[1];         // "banana"
string firstFruit = fruits[0];          // "apple"
string secondFruit = fruits[1];         // "banana"
Dim firstFruit As String = fruits(0) ' "apple"
Dim secondFruit As String = fruits(1) ' "banana"
$vbLabelText   $csharpLabel

Beachten Sie, dass Listen nullbasiert indiziert sind, sodass das erste Element einen Index von 0 hat. Das obige Beispiel speichert das Element in der Zeichenkette, wenn es existiert.

Ändern von Listenelementen

Um ein Element in einer Liste zu modifizieren, weisen Sie einfach dem Element an der gewünschten Indexstelle einen neuen Wert zu, wobei Sie den nullbasierten Index beachten:

fruits[1] = "blueberry";
fruits[1] = "blueberry";
fruits(1) = "blueberry"
$vbLabelText   $csharpLabel

Jetzt ist das zweite Element in der Obstliste "Heidelbeere" statt "Banane".

Elemente aus einer Liste entfernen

Um ein Element aus einer Liste zu entfernen, können Sie die Remove-Methode verwenden, die das erste Vorkommen eines angegebenen Elements entfernt:

fruits.Remove("apple");
fruits.Remove("apple");
fruits.Remove("apple")
$vbLabelText   $csharpLabel

Alternativ können Sie die RemoveAt-Methode verwenden, um ein Element an einem angegebenen Index zu entfernen:

fruits.RemoveAt(0);
fruits.RemoveAt(0);
fruits.RemoveAt(0)
$vbLabelText   $csharpLabel

Um alle Elemente aus einer Liste zu entfernen, verwenden Sie die Clear-Methode:

fruits.Clear();
fruits.Clear();
fruits.Clear()
$vbLabelText   $csharpLabel

Finden von Elementen in einer Liste

Sie können die Contains()-Methode verwenden, um zu überprüfen, ob eine Liste ein bestimmtes Element enthält:

bool containsApple = fruits.Contains("apple");  // true
bool containsApple = fruits.Contains("apple");  // true
Dim containsApple As Boolean = fruits.Contains("apple") ' true
$vbLabelText   $csharpLabel

Um den Index des ersten Auftretens eines Elements zu finden, verwenden Sie die IndexOf-Methode:

int appleIndex = fruits.IndexOf("apple");  // 0
int appleIndex = fruits.IndexOf("apple");  // 0
Dim appleIndex As Integer = fruits.IndexOf("apple") ' 0
$vbLabelText   $csharpLabel

Wenn das Element nicht gefunden wird, gibt IndexOf -1 zurück.

Looping durch eine Liste

Um die Elemente in einer Liste zu durchlaufen, können Sie eine foreach-Schleife verwenden:

foreach (string fruit in fruits)
{
    Console.WriteLine(fruit);
}
foreach (string fruit in fruits)
{
    Console.WriteLine(fruit);
}
For Each fruit As String In fruits
	Console.WriteLine(fruit)
Next fruit
$vbLabelText   $csharpLabel

Alternativ können Sie eine for-Schleife mit der Count-Eigenschaft verwenden, die die Anzahl der Elemente in der Liste zurückgibt:

for (int i = 0; i < fruits.Count; i++)
{
    Console.WriteLine(fruits[i]);
}
for (int i = 0; i < fruits.Count; i++)
{
    Console.WriteLine(fruits[i]);
}
For i As Integer = 0 To fruits.Count - 1
	Console.WriteLine(fruits(i))
Next i
$vbLabelText   $csharpLabel

Sortieren einer Liste

Um eine Liste in aufsteigender Reihenfolge zu sortieren, verwenden Sie die Sort-Methode:

List<int> unsortedNumbers = new List<int> { 5, 2, 8, 1, 4 };
unsortedNumbers.Sort();

// Now, unsortedNumbers is { 1, 2, 4, 5, 8 }
List<int> unsortedNumbers = new List<int> { 5, 2, 8, 1, 4 };
unsortedNumbers.Sort();

// Now, unsortedNumbers is { 1, 2, 4, 5, 8 }
Dim unsortedNumbers As New List(Of Integer) From {5, 2, 8, 1, 4}
unsortedNumbers.Sort()

' Now, unsortedNumbers is { 1, 2, 4, 5, 8 }
$vbLabelText   $csharpLabel

Um eine Liste in absteigender Reihenfolge zu sortieren, können Sie die Sort-Methode mit einem benutzerdefinierten Vergleich verwenden:

unsortedNumbers.Sort((a, b) => b.CompareTo(a));

// Now, unsortedNumbers is { 8, 5, 4, 2, 1 }
unsortedNumbers.Sort((a, b) => b.CompareTo(a));

// Now, unsortedNumbers is { 8, 5, 4, 2, 1 }
unsortedNumbers.Sort(Function(a, b) b.CompareTo(a))

' Now, unsortedNumbers is { 8, 5, 4, 2, 1 }
$vbLabelText   $csharpLabel

Für komplexere Sortierungen können Sie eine benutzerdefinierte IComparer-Klasse implementieren oder LINQ (Language Integrated Query) verwenden. Der Binärsuchalgorithmus funktioniert auf sortierten Listen.

Verwendung von LINQ mit Listen

LINQ ermöglicht es Ihnen, leistungsstarke Abfragen und Transformationen auf Sammlungen, einschließlich Listen, durchzuführen. Um LINQ verwenden zu können, müssen Sie zuerst den System.Linq-Namensraum in Ihren Code aufnehmen:

using System.Linq;
using System.Linq;
Imports System.Linq
$vbLabelText   $csharpLabel

Hier sind einige Beispiele für LINQ-Abfragen auf einer Liste:

Filtern einer Liste

List<int> evenNumbers = numbers.Where(x => x % 2 == 0).ToList();
List<int> evenNumbers = numbers.Where(x => x % 2 == 0).ToList();
Dim evenNumbers As List(Of Integer) = numbers.Where(Function(x) x Mod 2 = 0).ToList()
$vbLabelText   $csharpLabel

Elemente in einer Liste abbilden (umwandeln)

List<string> fruitNamesUpperCase = fruits.Select(x => x.ToUpper()).ToList();
List<string> fruitNamesUpperCase = fruits.Select(x => x.ToUpper()).ToList();
Dim fruitNamesUpperCase As List(Of String) = fruits.Select(Function(x) x.ToUpper()).ToList()
$vbLabelText   $csharpLabel

Minimal- und Maximalwerte in einer Liste finden

int minValue = numbers.Min();
int maxValue = numbers.Max();
int minValue = numbers.Min();
int maxValue = numbers.Max();
Dim minValue As Integer = numbers.Min()
Dim maxValue As Integer = numbers.Max()
$vbLabelText   $csharpLabel

Konvertierung einer Liste in ein Array

Um eine Liste in ein Array zu konvertieren, können Sie die ToArray-Methode verwenden:

int[] numbersArray = numbers.ToArray();
int[] numbersArray = numbers.ToArray();
Dim numbersArray() As Integer = numbers.ToArray()
$vbLabelText   $csharpLabel

Listendaten mit IronPDF in eine PDF-Datei exportieren

In diesem Abschnitt zeigen wir, wie Sie die Daten in einer Liste mit der IronPDF-Bibliothek in eine PDF-Datei exportieren. Dies kann hilfreich sein, wenn Sie einen Bericht oder eine druckbare Version Ihrer Daten erstellen möchten.

Laden Sie zuerst das IronPDF NuGet-Paket herunter und installieren Sie es in Ihrem Projekt:

Install-Package IronPdf

Fügen Sie anschließend den IronPdf-Namensraum in Ihren Code ein:

using IronPdf;
using IronPdf;
Imports IronPdf
$vbLabelText   $csharpLabel

Nun, lassen Sie uns eine einfache Funktion erstellen, die eine List von Zeichenfolgen in eine HTML-Tabelle konvertiert und dann in eine PDF-Datei exportiert:

using System.Collections.Generic;
using System.Text;
using IronPdf;

void ExportListToPdf(List<string> data, string pdfFilePath)
{
    // Create an HTML table from the list data
    StringBuilder htmlBuilder = new StringBuilder();
    htmlBuilder.Append("<table><tr><th>Item</th></tr>");

    foreach (string item in data)
    {
        htmlBuilder.Append($"<tr><td>{item}</td></tr>");
    }

    htmlBuilder.Append("</table>");

    // Convert the HTML table to a PDF using IronPDF
    var renderer = new ChromePdfRenderer();
    PdfDocument pdf = renderer.RenderHtmlAsPdf(htmlBuilder.ToString());

    // Save the PDF to the specified file path
    pdf.SaveAs(pdfFilePath);
}
using System.Collections.Generic;
using System.Text;
using IronPdf;

void ExportListToPdf(List<string> data, string pdfFilePath)
{
    // Create an HTML table from the list data
    StringBuilder htmlBuilder = new StringBuilder();
    htmlBuilder.Append("<table><tr><th>Item</th></tr>");

    foreach (string item in data)
    {
        htmlBuilder.Append($"<tr><td>{item}</td></tr>");
    }

    htmlBuilder.Append("</table>");

    // Convert the HTML table to a PDF using IronPDF
    var renderer = new ChromePdfRenderer();
    PdfDocument pdf = renderer.RenderHtmlAsPdf(htmlBuilder.ToString());

    // Save the PDF to the specified file path
    pdf.SaveAs(pdfFilePath);
}
Imports System.Collections.Generic
Imports System.Text
Imports IronPdf

Private Sub ExportListToPdf(ByVal data As List(Of String), ByVal pdfFilePath As String)
	' Create an HTML table from the list data
	Dim htmlBuilder As New StringBuilder()
	htmlBuilder.Append("<table><tr><th>Item</th></tr>")

	For Each item As String In data
		htmlBuilder.Append($"<tr><td>{item}</td></tr>")
	Next item

	htmlBuilder.Append("</table>")

	' Convert the HTML table to a PDF using IronPDF
	Dim renderer = New ChromePdfRenderer()
	Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(htmlBuilder.ToString())

	' Save the PDF to the specified file path
	pdf.SaveAs(pdfFilePath)
End Sub
$vbLabelText   $csharpLabel

Um diese Funktion zu verwenden, rufen Sie sie einfach mit Ihrer Liste und dem gewünschten PDF-Dateipfad auf:

List<string> fruits = new List<string> { "apple", "banana", "cherry" };
ExportListToPdf(fruits, "Fruits.pdf");
List<string> fruits = new List<string> { "apple", "banana", "cherry" };
ExportListToPdf(fruits, "Fruits.pdf");
Dim fruits As New List(Of String) From {"apple", "banana", "cherry"}
ExportListToPdf(fruits, "Fruits.pdf")
$vbLabelText   $csharpLabel

Dies wird eine PDF-Datei mit dem Namen "Fruits.pdf" erzeugen, die eine Tabelle mit der Obstliste enthält, indem Sie HTML mit IronPDF in PDF umwandeln. Sie können die ExportListToPdf-Funktion anpassen, um Ihren Bedürfnissen zu entsprechen, wie das Hinzufügen von benutzerdefiniertem Styling zur HTML-Tabelle oder zusätzlichen Inhalten zur PDF.

C#-Liste (Wie es für Entwickler funktioniert) Abbildung 1 - HTML zu PDF

Abschluss

In diesem anfängerfreundlichen Tutorial haben wir die Grundlagen der Verwendung von C#-Listen behandelt und gezeigt, wie man IronPDF integriert, um Listendaten in eine PDF-Datei zu exportieren. Durch die Einbindung von IronPDF in Ihre Projekte können Sie einfach Berichte, Rechnungen oder andere druckbare Dokumente aus Ihren C#-Projekten generieren.

IronPDF bietet eine kostenlose Testversion, mit der Sie seine Fähigkeiten testen können, bevor Sie einen Kauf tätigen.

Häufig gestellte Fragen

Wie kann ich eine Liste in C# erstellen?

Um eine Liste in C# zu erstellen, müssen Sie den Namespace System.Collections.Generic einbinden. Sie können dann eine Liste deklarieren, indem Sie den Datentyp in spitzen Klammern angeben. Zum Beispiel: List numbers = new List();

Welche Methoden fügen Elemente zu einer C#-Liste hinzu?

Elemente können zu einer C#-Liste mit der Add()-Methode für einzelne Elemente und AddRange() zum Hinzufügen einer Sammlung von Elementen hinzugefügt werden.

Wie kann ich eine C#-Liste in eine PDF-Datei exportieren?

Um eine C#-Liste in eine PDF-Datei zu exportieren, können Sie die IronPDF-Bibliothek verwenden. Konvertieren Sie Ihre Listendaten in ein HTML-Tabellenformat und rendern Sie es dann als PDF mit IronPDF.

Was ist der beste Weg, um eine C#-Liste zu sortieren?

Sie können eine C#-Liste in aufsteigender Reihenfolge mit der Sort()-Methode sortieren. Um in absteigender Reihenfolge zu sortieren, können Sie Sort() mit einem benutzerdefinierten Vergleichsdelegaten verwenden.

Wie greift man auf Elemente in einer C#-Liste zu?

Auf Elemente in einer C#-Liste kann mit ihrem Index zugegriffen werden, ähnlich wie bei Arrays. Listen sind nullbasiert indiziert, sodass Sie die Position eines Elements in der Liste verwenden können, um darauf zuzugreifen.

Welche Optionen gibt es, um Elemente aus einer C#-Liste zu entfernen?

Sie können Elemente aus einer C#-Liste mit Remove() für bestimmte Elemente, RemoveAt() für einen Index oder Clear() entfernen.

Wie kann LINQ mit C#-Listen genutzt werden?

LINQ kann mit C#-Listen verwendet werden, um leistungsstarke Abfragen und Transformationen durchzuführen, wie z.B. Filtern, Mapping und effizientes Finden von Minimal- oder Maximalwerten.

Wie kann ich eine Liste in ein Array in C# umwandeln?

Sie können eine C# Liste mit der Methode ToArray() in ein Array umwandeln, die ein neues Array erstellt, das die Elemente der Liste enthält.

Was sind einige gängige Anwendungsfälle für C#-Listen?

C#-Listen werden häufig zum Verwalten dynamischer Datensammlungen, zum Durchführen komplexer Abfragen mit LINQ und zum Erstellen von Berichten oder Dokumenten mit Bibliotheken wie IronPDF verwendet.

Wie iteriert man über Elemente in einer C#-Liste?

Sie können über Elemente in einer C#-Liste mit foreach-Schleifen für einfache Iterationen oder for-Schleifen iterieren, wenn Sie den Index benötigen.

Jacob Mellor, Chief Technology Officer @ Team Iron
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