Implementieren von sortierten Sammlungen mit Liste<T>

  • 6 Minuten

Sortierte Auflistungen in C#, z. B. die List<T> Klasse, führen allgemeine Vorgänge aus, z. B. Hinzufügen, Entfernen und Durchlaufen von Elementen. Ein Beispiel, in dem List<T> eine Liste von Studenten oder Büchern verwaltet.

Verwenden Sie List<T> für die Verwaltung geordneter Sammlungen

List<T> ist eine generische Sammlung für Szenarien, in denen Sie eine sortierte Abfolge von Elementen eines bestimmten Typs (T) speichern und verwalten müssen. Es bietet Typsicherheit, bessere Leistung und Flexibilität im Vergleich zu nicht generischen Sammlungen wie ArrayList, wodurch beim Zugriff auf Elemente die Typzuwandlung nicht erforderlich ist.

Hinweis

Der <T> in List<T> ist ein Platzhalter für den Typ der Elemente, die die Liste speichert. Definiert z. B. List<string> eine Liste von Zeichenfolgen, während List<int> eine Liste mit ganzen Zahlen definiert. Sie geben den Typ beim Deklarieren der Liste an.

  • Verwenden Sie List<T> in den folgenden Fällen:
    • Indizierter Zugriff auf Elemente.
    • Dynamische Größenänderung der Sammlung.
    • Effiziente Enumeration mithilfe von foreach-Schleifen.
  • Vermeiden Sie die Verwendung List<T> in öffentlichen APIs. Ziehen Sie stattdessen speziellere Sammlungstypen in Betracht, um eine bessere Abstraktion und Flexibilität zu gewährleisten.

Hinweis

List<T> erweitert die Kapazität bei Bedarf automatisch, aber diese Erweiterung kann sich auf die Leistung auswirken. Um dies zu optimieren, legen Sie eine anfängliche Kapazität basierend auf der geschätzten Größe der Sammlung fest.

Hinzufügen, Entfernen und Durchlaufen von Elementen in einem List<T>

List<T> stellt Methoden zum effizienten Hinzufügen, Entfernen und Durchlaufen von Elementen bereit. Diese Vorgänge sind einfach und häufig in der Anwendungsentwicklung verwendet.

  • Hinzufügen von Elementen: Verwenden Sie die Add Methode, um Elemente an die Liste anzufügen.
  • Entfernen von Elementen: Verwenden Sie Zum Löschen von Elementen Methoden wie Remove, , RemoveAtoder Clear.
  • Durchlaufen von Elementen: Verwenden Sie für die Enumeration eine foreach-Schleife oder LINQ (Language Integrated Query).
// Example: Adding, removing, and iterating through a List<T>

// Define the type T as string for this list
List<string> books = new List<string>(); // T is string
books.Add("Book A"); // Add a string to the list
books.Add("Book B");
books.Add("Book C");
books.Remove("Book A"); // Remove a specific string from the list

foreach (string book in books) // Iterate through the list
{
    Console.WriteLine(book);
}

// Expected output:
// Book B
// Book C

In diesem Beispiel wird veranschaulicht, wie Sie Elemente zu einer List<T> hinzufügen und dabei vorhandene Elemente beibehalten, Elemente an bestimmten Positionen in der Liste entfernen und die Liste durchgehen, um deren Inhalt anzuzeigen.

Tipp

LINQ-Abfragen können das Filtern, Sortieren und Gruppieren von List<T> vereinfachen.

Verwalten einer Liste von Kursteilnehmern oder Büchern mithilfe von List<T>

List<T> eignet sich ideal zum Verwalten von Sammlungen von Objekten, z. B. Kursteilnehmern oder Büchern. Sie können eine benutzerdefinierte Klasse für die Elemente definieren und anwenden List<T> , um sie zu speichern und zu bearbeiten.

// Example: Managing a list of students
public class Student
{
    public string Name { get; set; }
    public int Age { get; set; }
}

List<Student> students = new List<Student>
{
    new Student { Name = "Haneul", Age = 20 },
    new Student { Name = "Magda", Age = 22 }
};

students.Add(new Student { Name = "Dale", Age = 23 });
students.RemoveAt(0); // Remove Haneul

foreach (Student student in students)
{
    Console.WriteLine($"Name: {student.Name}, Age: {student.Age}");
}

// Expected output:
// Name: Magda, Age: 22
// Name: Dale, Age: 23

Hinweis

Bei dynamischer Datenbindung in Benutzeroberflächenanwendungen sollten Sie ObservableCollection<T> anstelle von List<T> verwenden, um die Benutzeroberfläche automatisch zu aktualisieren, wenn sich die Sammlung ändert.

List in C# wird zum Verwalten geordneter Sammlungen verwendet, die Typsicherheit bieten, dynamisch in der Größe anpassbar sind und eine effiziente Enumeration ermöglichen. Zu den Vorgängen gehören Hinzufügen, Entfernen und Durchlaufen von Elementen.