Colecciones en C#

Arreglos

Útiles para crear y trabajar con un número fijo de objetos fuertemente tipados.

El tamaño se define al crear la instancia y permanece constante durante toda su vida útil.

Colecciones

El grupo de objetos puede crecer y reducirse dinámicamente en tiempo de ejecución.

Más flexibles: se adaptan a las necesidades cambiantes de la aplicación.

Características

• El tipo de los elementos puede ser cualquier tipo válido: char, int, float, etc.
• Se almacenan en ubicaciones contiguas de memoria.
• También llamados array, vector o matriz.
• Un escalar es un tensor de orden 0; un vector, de orden 1; una matriz, de orden 2…

Las partes

• <Tipo de dato> — define el tipo de cada elemento.
• [ ] — entre corchetes se define el tamaño y las dimensiones.
• Nombre_del_arreglo — el nombre del arreglo.

Ejemplos de declaración

int[] x;          // elementos int
string[] s;       // elementos string
double[] d;       // elementos double
Persona[] Estudiantes; // instancias de Persona

Declaración

public class MiClase<T>
{
   T value;
}

Por convención, los parámetros de tipo se prefijan con la letra T y deben ser únicos dentro de la declaración para evitar conflictos de nombres.

Ventajas

• Rendimiento — evita boxing/unboxing.
• Seguridad de tipos — errores en tiempo de compilación.
• Reutilización de código — una misma clase para muchos tipos.

Implementación

public class MiClase<T>
{
   T value;
   public MiClase(T t)
   {
      value = t;
   }
   public T GetValor()
   {
      return value;
   }
}

Uso

MiClase<int> Instancia =
   new MiClase<int>();

MiClase<string> Instancia =
   new MiClase<string>();

Dentro de la implementación, el parámetro T se sustituye por el tipo específico: en el primer caso por int, en el segundo por string.

La clase genérica

public class Pila<T>
{
   private List<T> items = new List<T>();

   public void Apilar(T item) => items.Add(item);

   public T Desapilar()
   {
      T ultimo = items[items.Count - 1];
      items.RemoveAt(items.Count - 1);
      return ultimo;
   }

   public int Cantidad => items.Count;
}

Usarla con distintos tipos

// pila de tareas (string)
Pila<string> tareas = new Pila<string>();
tareas.Apilar("Estudiar");
tareas.Apilar("Practicar");

Console.WriteLine(tareas.Desapilar()); // "Practicar"
Console.WriteLine(tareas.Cantidad);     // 1

// la MISMA clase, ahora con int
Pila<int> numeros = new Pila<int>();
numeros.Apilar(10);
numeros.Apilar(20);
Console.WriteLine(numeros.Desapilar()); // 20

Crear una instancia

// lista de objetos int
List<int> MiLista =
   new List<int>();

// diccionario int → string
Dictionary<int, string> MiDiccionario =
   new Dictionary<int,string>();

Agregar elementos

// agrego el 5 a la lista
MiLista.Add(5);

// agrego al diccionario con
// la llave 1 → "Opción 1"
MiDiccionario.Add(1, "Opción 1");

En el diccionario, el primer parámetro es la clave y el segundo el valor asociado.

Crear y agregar

// crear una lista vacía
List<string> frutas = new List<string>();

frutas.Add("Manzana");
frutas.Add("Banana");
frutas.Add("Naranja");

// inicializar con valores
List<int> numeros =
   new List<int>() { 10, 20, 30 };

Acceder, recorrer y contar

// acceso por índice (base 0)
string primera = frutas[0];  // "Manzana"

// recorrer con foreach
foreach (string f in frutas)
{
   Console.WriteLine(f);
}

// cantidad de elementos
int total = frutas.Count;     // 3

Buscar, insertar y quitar

// ¿contiene un elemento?
bool hay = frutas.Contains("Banana");  // true

// posición de un elemento
int pos = frutas.IndexOf("Naranja");    // 2

// insertar en una posición
frutas.Insert(1, "Pera");

// quitar por valor y por índice
frutas.Remove("Manzana");
frutas.RemoveAt(0);

Ordenar y agregar en lote

List<int> numeros = new List<int>() { 30, 10, 20 };

// agregar varios de una vez
numeros.AddRange(new int[] { 40, 50 });

// ordenar de menor a mayor
numeros.Sort();      // 10, 20, 30, 40, 50

// invertir el orden
numeros.Reverse();

// vaciar la lista
numeros.Clear();

Una clase y su lista

class Persona
{
   public string Nombre;
   public int Edad;
}

List<Persona> estudiantes =
   new List<Persona>();

estudiantes.Add(new Persona { Nombre = "Ana", Edad = 20 });
estudiantes.Add(new Persona { Nombre = "Luis", Edad = 22 });

Recorrer y filtrar

// recorrer los objetos
foreach (Persona p in estudiantes)
{
   Console.WriteLine($"{p.Nombre} - {p.Edad}");
}

// acceder por índice
Persona primero = estudiantes[0];  // Ana

// filtrar manualmente (mayores de 21)
List<Persona> mayores = new List<Persona>();
foreach (Persona p in estudiantes)
   if (p.Edad > 21) mayores.Add(p);

Filtrar y proyectar

using System.Linq;

// filtrar: mayores de 21
List<Persona> mayores = estudiantes
   .Where(p => p.Edad > 21)
   .ToList();

// proyectar: solo los nombres
List<string> nombres = estudiantes
   .Select(p => p.Nombre)
   .ToList();

Operaciones de agregado

// ¿hay algún mayor de edad?
bool hayMayor = estudiantes.Any(p => p.Edad >= 18);

// el primero que cumpla
Persona ana = estudiantes.First(p => p.Nombre == "Ana");

// contar y promediar
int cuantos = estudiantes.Count(p => p.Edad > 21);
double promedio = estudiantes.Average(p => p.Edad);

Crear un enum

enum DiaDeLaSemana
{
   Domingo = 0,
   Lunes = 1,
   Martes = 2,
   Miercoles = 3,
   Jueves = 4,
   Viernes = 5,
   Sabado = 6
}

Utilizar un enum

DiaDeLaSemana MiDía =
   DiaDeLaSemana.Domingo;

Se puede definir el tipo subyacente, por ejemplo ushort, y asignar valores arbitrarios:

enum ErrorCode : ushort
{
   Ninguno = 0,
   PerdidaDeConexion = 100,
   RecursoNoEncontrado = 404
}

Declarar con [Flags]

[Flags]
enum Dias
{
   Ninguno = 0,
   Domingo = 1,
   Lunes = 2,
   Martes = 4,
   Miercoles = 8,
   Jueves = 16,
   Viernes = 32,
   Sabado = 64
}

Combinar con operadores lógicos

Dias FindeSemana =
   Dias.Domingo |
   Dias.Sabado;

Se usan los operadores OR (|) para combinar y AND (&) para intersecar / comprobar qué opciones están activas.