Descripción general de List<T>

La colección List<T> en C# es un arreglo dinámico incluido en System.Collections.Generic, diseñado para almacenar y manipular conjuntos de datos con flexibilidad. A diferencia de los arreglos fijos, List permite crecer y reducirse automáticamente, optimizando el manejo de colecciones en tiempo de ejecución.

1. Declaración y adición de elementos

Para crear una lista de enteros y poblarla, se instancia el tipo genérico y se usan métodos como Add. Aquí un ejemplo con números primos modificados:

using System.Collections.Generic;

class DemoList
{
    static void Main()
    {
        List<int> primos = new List<int>();
        primos.Add(3);
        primos.Add(5);
        primos.Add(7);
        primos.Add(11);
    }
}

La lista soporta tanto tipos de valor como de referencia, adaptándose a diversas necesidades de almacenamiento.

2. Iteración con bucles

Los bucles for y foreach son esenciales para recorrer elementos. La propiedad Count define el límite superior, similar a Length en arreglos. Ejemplo con iteración inversa:

using System;
using System.Collections.Generic;

class RecorridoList
{
    static void Main()
    {
        List<string> colores = new List<string> { "rojo", "azul", "verde" };

        // Iteración con foreach
        foreach (string color in colores)
        {
            Console.WriteLine(color);
        }

        // Iteración con for inverso
        for (int idx = colores.Count - 1; idx >= 0; idx--)
        {
            Console.WriteLine(colores[idx]);
        }
    }
}

3. Gestión de tamaño y limpieza

La propiedad Count ofrece acceso rápido al número de elementos. Para eliminar todos los datos, se emplea el método Clear, o se puede asignar null para reiniciar la lista, requiriendo una nueva instancia después.

using System;
using System.Collections.Generic;

class GestionTamano
{
    static void Main()
    {
        List<bool> estados = new List<bool> { true, false, true };
        Console.WriteLine(estados.Count); // 3
        estados.Clear();
        Console.WriteLine(estados.Count); // 0
    }
}

4. Creación desde un arreglo

El constructor de List puede aceptar un arreglo existente para inicializar la lista, simplificando la conversión de datos estáticos a dinámicos.

using System;
using System.Collections.Generic;

class ArregloAList
{
    static void Main()
    {
        int[] datosOriginales = new int[] { 10, 20, 30 };
        List<int> listaConvertida = new List<int>(datosOriginales);
        Console.WriteLine(listaConvertida.Count); // 3
    }
}

5. Búsqueda y verificación de elementos

Para comprobar la existencia de un valor, se pueden usar métodos integrados como Contains o iteraciones manuales. Ejemplo con búsqueda simple:

using System;
using System.Collections.Generic;

class BusquedaElementos
{
    static void Main()
    {
        List<string> frutas = new List<string> { "manzana", "plátano", "uva" };
        bool contienePlatano = frutas.Contains("plátano");
        Console.WriteLine(contienePlatano); // True
    }
}

6. Optimización de rendimiento

La propiedad Capacity permite preasignar memoria para mejorar la eficiencia al agregar múltiples elementos. El método TrimExcess reduce el uso de memoria liberando espacio no utilizado, siempre que la lista esté por encima del 90% de su capacidad.

7. Métodos operativos avanzados

List ofrece utilidades como AddRange para agregar colecciones, Insert para inserciones posicionales, y Remove para eliminaciones. Para ordenamiento, se usa Sort o Reverse, y para subconjuntos, GetRange proporciona segmentos específicos.

8. Uso con estructuras (structs)

Las esturcturas pueden optimizar el rendimiento en List al almacenarse en memoria contigua. Sin embargo, al ser tipos por valor, las modificaciones requieren copiar el elemento, modificarlo y reasignarlo.

public struct Producto
{
    public int Codigo;
    public string Descripcion;
}

class UsoStructs
{
    static void Main()
    {
        List<Producto> productos = new List<Producto>();
        Producto prod1 = new Producto { Codigo = 1, Descripcion = "Teclado" };
        productos.Add(prod1);

        // Modificación indirecta por ser struct
        Producto temp = productos[0];
        temp.Descripcion = "Teclado mecánico";
        productos[0] = temp;
    }
}

9. Inferencia de tipos con var

La palabra clave var simplifica la declaración de List, mejorando la legibilidad sin afectar el rendimiento. Su uso es equivalente a especificar el tipo explícitamente.

var listaImplicita = new List<double>(); // Igual que List<double> listaImplicita = new List<double>();