Implementer sorterede samlinger med Liste<T>

  • 6 minutter

Ordnede samlinger i C#, f.eks List<T> . klassen, udfører almindelige handlinger, f.eks. tilføjelse, fjernelse og gentagelse via elementer. Et eksempel på List<T> administration af en liste over studerende eller bøger.

Bruges List<T> til administration af ordnede samlinger

List<T> er en generisk samling, der er udviklet til scenarier, hvor du skal gemme og administrere en sorteret sekvens af elementer af en bestemt type (T). Det giver typesikkerhed, bedre ydeevne og fleksibilitet sammenlignet med ikke-generiske samlinger som ArrayList, hvilket eliminerer behovet for type casting, når du får adgang til elementer.

Seddel

i <T>List<T> er en pladsholder for den type elementer, som listen gemmer. Definerer f.eks List<string> . en liste over strenge, mens List<int> definerer en liste over heltal. Du angiver typen, når du erklærer listen.

  • Bruges List<T> , når du har brug for følgende:
    • Indekseret adgang til elementer.
    • Dynamisk tilpasning af størrelsen på samlingen.
    • Effektiv optælling ved hjælp af foreach løkker.
  • Undgå at bruge List<T> i offentlige API'er. Overvej i stedet mere specialiserede samlingstyper for at få bedre abstraktion og fleksibilitet.

Seddel

List<T> udvider automatisk kapaciteten, når det er nødvendigt, men denne udvidelse kan påvirke ydeevnen. Hvis du vil optimere, skal du angive en indledende kapacitet baseret på samlingens anslåede størrelse.

Tilføje, fjerne og gentage elementer i en List<T>

List<T> indeholder metoder til effektivt at tilføje, fjerne og gentage elementer. Disse handlinger er enkle og bruges ofte i programudvikling.

  • Tilføjelse af elementer: Hvis du vil føje elementer til listen, skal du bruge Add metoden .
  • Fjerner elementer: Hvis du vil slette elementer, skal du bruge metoder som Remove, RemoveAteller Clear.
  • Gentagelse via elementer: Brug en foreach løkke eller LINQ (Language Integrated Query) til optælling.
// 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

I dette eksempel kan du se, hvordan du føjer elementer til et List<T> og samtidig bevarer eksisterende elementer, fjerner elementer fra bestemte placeringer på listen og gentager indholdet på listen.

Drikkepenge

LINQ-forespørgsler kan forenkle filtrerings-, sorterings- og grupperingshandlinger på List<T>.

Administrer en liste over studerende eller bøger ved hjælp af List<T>

List<T> er ideel til administration af samlinger af objekter, f.eks. studerende eller bøger. Du kan definere en brugerdefineret klasse for elementerne og anvende List<T> til at gemme og manipulere dem.

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

Seddel

I forbindelse med dynamisk databinding i brugergrænsefladeprogrammer kan du overveje at bruge ObservableCollection<T> i stedet for List<T> automatisk at opdatere brugergrænsefladen, når samlingen ændres.

List i C# bruges til at administrere ordnede samlinger, tilbyde typesikkerhed, dynamisk tilpasning af størrelse og effektiv optælling med handlinger som tilføjelse, fjernelse og gentagelse via elementer.