Informationen zum Verwalten von Datensammlungen mit List<T> in C#

Artikel
05/10/2023

Dieses Tutorial bietet eine Einführung in die Sprache C# und die Grundlagen der List<T>-Klasse.

Voraussetzungen

Für dieses Tutorial wird vorausgesetzt, dass Sie einen Computer für die lokale Entwicklung eingerichtet haben. Installationsanweisungen und eine Übersicht über die Anwendungsentwicklung in .NET finden Sie unter Einrichten Ihrer lokalen Umgebung.

Wenn Sie den Code ausführen möchten, ohne eine lokale Umgebung einrichten zu müssen, finden Sie entsprechende Informationen in der interaktiven Browserversion dieses Tutorials.

Beispiel für eine einfache Liste

Erstellen Sie ein Verzeichnis mit dem Namen list-tutorial. Machen Sie dieses Verzeichnis zum aktuellen Verzeichnis, und führen Sie dotnet new console aus.

Wichtig

Die C#-Vorlagen für .NET 6 verwenden Anweisungen der obersten Ebene. Ihre Anwendung passt möglicherweise nicht zum Code in diesem Artikel, wenn Sie bereits ein Upgrade auf .NET 6 durchgeführt haben. Weitere Informationen finden Sie im Artikel Neue C#-Vorlagen generieren Anweisungen auf oberster Ebene.

Das .NET 6 SDK fügt auch eine Reihe impliziterglobal using-Anweisungen für Projekte hinzu, die die folgenden SDKs verwenden:

Microsoft.NET.Sdk
Microsoft.NET.Sdk.Web
Microsoft.NET.Sdk.Worker

Diese impliziten global using-Anweisungen enthalten die gängigsten Namespaces für den Projekttyp.

Weitere Informationen finden Sie im Artikel zum Thema „Implizite Verwendung von Anweisungen“

Öffnen Sie Program.cs in Ihrem bevorzugten Editor, und ersetzen Sie den vorhandenen Code durch Folgendes:

List<string> names = ["<name>", "Ana", "Felipe"];
foreach (var name in names)
{
    Console.WriteLine($"Hello {name.ToUpper()}!");
}

Ersetzen Sie <name> durch Ihren eigenen Namen. Speichern Sie Program.cs. Geben Sie dotnet run in Ihrem Konsolenfenster ein, um es zu testen.

Sie haben eine Liste mit Zeichenfolgen erstellt, dieser Liste drei Namen hinzugefügt und die Namen in Großbuchstaben ausgegeben. Sie verwenden Konzepte, die Sie in früheren Tutorials kennengelernt haben, um die Liste zu durchlaufen.

Im Code zum Anzeigen von Namen wird das Feature Zeichenfolgeninterpolation genutzt. Wenn Sie einem string ein $-Zeichen voranstellen, können Sie C#-Code in die Zeichenfolgendeklaration einbetten. Der Wert, den dieser C#-Code generiert, ist eine Zeichenfolge, durch die der C#-Code ersetzt wird. In diesem Beispiel wird {name.ToUpper()} mit dem jeweiligen in Großbuchstaben konvertierten Namen ersetzt, da Sie die ToUpper-Methode aufgerufen haben.

Setzen wir nun unsere Forschungen fort.

Ändern von Listeninhalten

Die Sammlung, die Sie erstellt haben, nutzt den List<T>-Typ. Dieser Typ speichert Elementsequenzen. Sie geben den Typ der Elemente zwischen den spitzen Klammern an.

Ein wichtiger Aspekt dieses List<T>-Typs ist, dass er wachsen oder schrumpfen kann, sodass Sie Elemente hinzufügen oder entfernen können. Fügen Sie am Ende Ihres Programms den folgenden Code hinzu:

Console.WriteLine();
names.Add("Maria");
names.Add("Bill");
names.Remove("Ana");
foreach (var name in names)
{
    Console.WriteLine($"Hello {name.ToUpper()}!");
}

Sie haben am Ende der Liste zwei weitere Namen hinzugefügt. Sie haben auch einen entfernt. Speichern Sie die Datei, und geben Sie dotnet run zum Testen ein.

List<T> ermöglicht Ihnen auch, mithilfe des Indexes auf einzelne Elemente zu verweisen. Platzieren Sie den Index hinter dem Listennamen zwischen den Zeichen [ und ]. C# verwendet 0 für den ersten Index. Fügen Sie diesen Code direkt unterhalb des Codes hinzu, den Sie gerade hinzugefügt haben, und probieren Sie es aus:

Console.WriteLine($"My name is {names[0]}");
Console.WriteLine($"I've added {names[2]} and {names[3]} to the list");

Sie können nicht auf einen Index zugreifen, der hinter dem Ende der Liste liegt. Denken Sie daran, dass die Indizes mit 0 (null) beginnen, sodass der größte gültige Index um eins kleiner ist als die Anzahl der Elemente in der Liste. Sie können mit der Count-Eigenschaft überprüfen, wie lang die Liste ist. Fügen Sie am Ende Ihres Programms den folgenden Code hinzu:

Console.WriteLine($"The list has {names.Count} people in it");

Speichern Sie die Datei, und geben Sie dotnet run erneut ein, um die Ergebnisse anzuzeigen.

Suchen in und Sortieren von Listen

In unseren Beispielen werden relativ kleine Listen verwendet, aber Ihre Anwendungen erstellen möglicherweise häufig Listen mit viel mehr Elementen, die manchmal in die Tausende gehen. Um in diesen größeren Sammlungen Elemente zu finden, müssen Sie die Liste nach verschiedenen Elementen durchsuchen. Die IndexOf-Methode sucht nach einem Element und gibt den Index des Elements zurück. Wenn das Element nicht in der Liste enthalten ist, gibt IndexOf-1 zurück. Fügen Sie am Ende Ihres Programms den folgenden Code hinzu:

var index = names.IndexOf("Felipe");
if (index == -1)
{
    Console.WriteLine($"When an item is not found, IndexOf returns {index}");
}
else
{
    Console.WriteLine($"The name {names[index]} is at index {index}");
}

index = names.IndexOf("Not Found");
if (index == -1)
{
    Console.WriteLine($"When an item is not found, IndexOf returns {index}");
}
else
{
    Console.WriteLine($"The name {names[index]} is at index {index}");

}

Die Elemente in der Liste können auch sortiert werden. Die Sort-Methode sortiert alle Elemente in der Liste in der normalen Reihenfolge (Zeichenfolgen alphabetisch). Fügen Sie am Ende Ihres Programms den folgenden Code hinzu:

names.Sort();
foreach (var name in names)
{
    Console.WriteLine($"Hello {name.ToUpper()}!");
}

Speichern Sie die Datei, und geben Sie dotnet run ein, um diese neueste Version zu testen.

Bevor Sie mit dem nächsten Abschnitt beginnen, verschieben wir den aktuellen Code in eine separate Methode. Dies erleichtert das Arbeiten mit einem neuen Beispiel. Fügen Sie den gesamten Code, den Sie geschrieben haben, in eine neue Methode namens WorkWithStrings() ein. Rufen Sie diese Methode am Anfang Ihres Programms auf. Anschließend sollte der Code wie folgt aussehen:

WorkWithStrings();

void WorkWithStrings()
{
    List<string> names = ["<name>", "Ana", "Felipe"];
    foreach (var name in names)
    {
        Console.WriteLine($"Hello {name.ToUpper()}!");
    }

    Console.WriteLine();
    names.Add("Maria");
    names.Add("Bill");
    names.Remove("Ana");
    foreach (var name in names)
    {
        Console.WriteLine($"Hello {name.ToUpper()}!");
    }

    Console.WriteLine($"My name is {names[0]}");
    Console.WriteLine($"I've added {names[2]} and {names[3]} to the list");

    Console.WriteLine($"The list has {names.Count} people in it");

    var index = names.IndexOf("Felipe");
    if (index == -1)
    {
        Console.WriteLine($"When an item is not found, IndexOf returns {index}");
    }
    else
    {
        Console.WriteLine($"The name {names[index]} is at index {index}");
    }

    index = names.IndexOf("Not Found");
    if (index == -1)
    {
        Console.WriteLine($"When an item is not found, IndexOf returns {index}");
    }
    else
    {
        Console.WriteLine($"The name {names[index]} is at index {index}");

    }

    names.Sort();
    foreach (var name in names)
    {
        Console.WriteLine($"Hello {name.ToUpper()}!");
    }
}

Listen mit anderen Typen

Sie haben bisher den string-Typ in Listen verwendet. Nun erstellen wir eine List<T> mithilfe eines anderen Typs. Zunächst erstellen wir einen Satz von Zahlen.

Fügen Sie Ihrem Programm nach dem Aufruf von WorkWithStrings() Folgendes hinzu:

List<int> fibonacciNumbers = [1, 1];

Damit wird eine Liste von Ganzzahlen erstellt und für die ersten beiden Ganzzahlen der Wert 1 festgelegt. Dies sind die ersten beiden Werte einer Fibonacci-Sequenz – einer Sequenz von Zahlen. Jede nächste Fibonacci-Zahl wird ermittelt, indem die Summe der beiden vorherigen Zahlen gebildet wird. Fügen Sie den folgenden Code hinzu:

var previous = fibonacciNumbers[fibonacciNumbers.Count - 1];
var previous2 = fibonacciNumbers[fibonacciNumbers.Count - 2];

fibonacciNumbers.Add(previous + previous2);

foreach (var item in fibonacciNumbers)
{
    Console.WriteLine(item);
}

Speichern Sie die Datei, und geben Sie dotnet run ein, um die Ergebnisse anzuzeigen.

Tipp

Um sich genau auf diesen Abschnitt zu konzentrieren, können Sie den Code auskommentieren, der WorkWithStrings(); aufruft. Setzen Sie einfach zwei /-Zeichen wie folgt vor den Aufruf: // WorkWithStrings();.

Herausforderung

Versuchen Sie, einige dieser Konzepte aus dieser Lektion und früheren Lektionen in einen Zusammenhang zu bringen. Erweitern Sie das, was Sie bisher bezüglich Fibonacci-Zahlen erstellt haben. Schreiben Sie den Code zum Generieren der ersten 20 Zahlen der Sequenz. (Hinweis: Die 20. Fibonacci-Zahl lautet 6765.)

Übung abgeschlossen

Eine Beispiellösung finden Sie in Form eines fertiggestellten Beispielcodes auf GitHub.

Mit jeder Iteration der Schleife werden die letzten beiden Ganzzahlen in der Liste summiert, und dieser Wert wird der Liste hinzugefügt. Die Schleife wird wiederholt, bis der Liste 20 Elemente hinzugefügt worden sind.

Herzlichen Glückwunsch, Sie haben das Listentutorial abgeschlossen. Sie können mit zusätzlichen Tutorials in Ihrer eigenen Entwicklungsumgebung fortfahren.

Weitere Informationen zum Arbeiten mit dem List-Typ finden Sie im Artikel „.NET-Grundlagen“ unter Sammlungen. Sie werden auch viele andere Sammlungstypen kennenlernen.