Implementar colecciones ordenadas con List<T>

  • 6 minutos

Las colecciones ordenadas en C#, como la List<T> clase , realizan operaciones comunes como agregar, quitar e iterar a través de elementos. Ejemplo en el que List<T> se administra una lista de alumnos o libros.

Uso List<T> para administrar colecciones ordenadas

List<T> es una colección genérica diseñada para escenarios en los que es necesario almacenar y administrar una secuencia ordenada de elementos de un tipo específico (T). Proporciona seguridad de tipos, mejor rendimiento y flexibilidad en comparación con colecciones no genéricas, como ArrayList, lo que elimina la necesidad de conversión de tipos al acceder a elementos.

Nota:

<T> en List<T> es un marcador de posición para el tipo de elementos que almacena la lista. Por ejemplo, List<string> define una lista de cadenas, mientras List<int> que define una lista de enteros. Se especifica el tipo al declarar la lista.

  • Use List<T> cuando necesite:
    • Acceso indexado a elementos.
    • Cambio de tamaño dinámico de la colección.
    • Enumeración eficaz mediante bucles foreach.
  • Evite el uso List<T> de en API públicas; en su lugar, considere la posibilidad de usar tipos de colección más especializados para mejorar la abstracción y la flexibilidad.

Nota:

List<T> expande automáticamente su capacidad cuando sea necesario, pero esta expansión puede afectar al rendimiento. Para optimizar, establezca una capacidad inicial en función del tamaño estimado de la colección.

Agregar, quitar y recorrer en iteración los elementos de List<T>

List<T> proporciona métodos para agregar, quitar y recorrer en iteración elementos de forma eficaz. Estas operaciones son sencillas y se usan habitualmente en el desarrollo de aplicaciones.

  • Agregar elementos: para anexar elementos a la lista, use el Add método .
  • Quitar elementos: para eliminar elementos, use métodos como Remove, RemoveAto Clear.
  • Iteración a través de elementos: Para la enumeración, utilice un bucle foreach o LINQ (Consulta Integrada de Lenguaje).
// 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

En este ejemplo se muestra cómo agregar elementos a un List<T> mientras se conservan los elementos existentes, se quitan elementos de ubicaciones específicas de la lista y se recorre en iteración la lista para mostrar su contenido.

Sugerencia

Las consultas LINQ pueden simplificar las operaciones de filtrado, ordenación y agrupación en List<T>.

Administrar una lista de alumnos o libros mediante List<T>

List<T> es ideal para administrar colecciones de objetos, como estudiantes o libros. Puede definir una clase personalizada para los elementos y aplicarlos List<T> para almacenarlos y manipularlos.

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

Nota:

Para el enlace de datos dinámicos en aplicaciones de interfaz de usuario, considere usar ObservableCollection<T> en lugar de List<T> para actualizar automáticamente la interfaz de usuario cuando cambie la colección.

List En C#, se utiliza para administrar colecciones ordenadas, ofreciendo seguridad de tipos, redimensionamiento dinámico y enumeración eficiente, con operaciones como agregar, eliminar y recorrer en iteración elementos.