Cargando...

Referencia de Colecciones

En C#, la Referencia de Colecciones constituye un conjunto esencial de estructuras de datos que permiten almacenar, organizar y manipular información de manera eficiente. Su dominio es crucial para desarrolladores avanzados, ya que facilita la implementación de algoritmos complejos, optimiza el rendimiento de las aplicaciones y asegura que el código sea escalable y mantenible. Las colecciones en C# incluyen List, Dictionary\, Queue, Stack, HashSet y otras, cada una diseñada para escenarios específicos como acceso rápido, almacenamiento único de elementos, o gestión de datos en formato FIFO/LIFO.
El uso adecuado de estas colecciones requiere comprensión de conceptos clave como genéricos, interfaces (IEnumerable, ICollection, IList), LINQ y principios de programación orientada a objetos, incluyendo encapsulación, herencia y polimorfismo. Conocer cuándo usar cada tipo de colección es vital para optimizar la eficiencia, evitar errores comunes como fugas de memoria, y aplicar técnicas de manejo de excepciones de forma segura.
Este documento guía al lector a través de la selección de colecciones adecuadas, implementación de algoritmos eficientes y prácticas recomendadas para mantener la integridad y seguridad de los datos. También ofrece ejemplos prácticos que muestran cómo aplicar estas estructuras en proyectos reales, integrando conceptos avanzados de C# para construir sistemas robustos y de alto rendimiento.

Ejemplo Básico

text
TEXT Code 
using System;
using System.Collections.Generic;

namespace ColeccionesReferencia
{
class Program
{
static void Main(string\[] args)
{
// Crear una lista de frutas
List<string> frutas = new List<string> { "Manzana", "Banana", "Cereza" };

// Agregar un elemento
frutas.Add("Naranja");

// Modificar un elemento
frutas[1] = "Mango";

// Recorrer la lista
Console.WriteLine("Lista de frutas:");
foreach (string fruta in frutas)
{
Console.WriteLine(fruta);
}

// Verificar existencia de un elemento
if (frutas.Contains("Cereza"))
{
Console.WriteLine("Cereza está en la lista.");
}
}
}

}

En este ejemplo se utiliza List para almacenar cadenas de texto de manera dinámica. El método Add permite insertar nuevos elementos al final de la lista, mientras que el acceso por índice, frutas[1] = "Mango", permite modificar un elemento existente. La estructura foreach asegura un recorrido seguro de los elementos, evitando errores por índices fuera de rango. La función Contains valida la existencia de un elemento, protegiendo contra excepciones y proporcionando lógica condicional eficaz.
Este patrón se aplica en escenarios reales como gestión de inventarios, listas de usuarios o datos temporales en memoria. Además, demuestra principios de POO como encapsulación y modularidad, aprovechando la recolección automática de basura de CLR para evitar fugas de memoria. Dominar estas operaciones es fundamental para construir aplicaciones escalables y mantenibles.

Ejemplo Práctico

text
TEXT Code 
using System;
using System.Collections.Generic;

namespace ColeccionesAvanzadas
{
class Persona
{
public string Nombre { get; set; }
public int Edad { get; set; }
}

class Program
{
static void Main(string[] args)
{
// Crear un diccionario con claves únicas
Dictionary<int, Persona> personas = new Dictionary<int, Persona>();

personas.Add(1, new Persona { Nombre = "Ana", Edad = 30 });
personas.Add(2, new Persona { Nombre = "Luis", Edad = 25 });
personas.Add(3, new Persona { Nombre = "Carlos", Edad = 35 });

// Acceso seguro a elementos
if (personas.TryGetValue(2, out Persona encontrado))
{
Console.WriteLine($"Persona encontrada: {encontrado.Nombre}, {encontrado.Edad} años");
}

// Recorrer el diccionario
foreach (var entry in personas)
{
Console.WriteLine($"ID: {entry.Key}, Nombre: {entry.Value.Nombre}");
}

// Eliminar un elemento
personas.Remove(3);
}
}

}

Advanced C# Implementation

text
TEXT Code 
using System;
using System.Collections.Generic;
using System.Linq;

namespace ColeccionesEnterprise
{
class Producto
{
public string Nombre { get; set; }
public decimal Precio { get; set; }
}

class Program
{
static void Main(string[] args)
{
try
{
// HashSet para evitar duplicados
HashSet<Producto> productos = new HashSet<Producto>(new ComparadorProducto())
{
new Producto { Nombre = "Laptop", Precio = 1200 },
new Producto { Nombre = "Tablet", Precio = 450 },
new Producto { Nombre = "Laptop", Precio = 1200 } // duplicado ignorado
};

// Uso de LINQ para filtrar y ordenar
var productosCaros = productos
.Where(p => p.Precio > 500)
.OrderByDescending(p => p.Precio)
.ToList();

foreach (var p in productosCaros)
{
Console.WriteLine($"Producto: {p.Nombre}, Precio: {p.Precio}");
}
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex.Message}");
}
}
}

class ComparadorProducto : IEqualityComparer<Producto>
{
public bool Equals(Producto x, Producto y)
{
return x.Nombre == y.Nombre && x.Precio == y.Precio;
}

public int GetHashCode(Producto obj)
{
return obj.Nombre.GetHashCode() ^ obj.Precio.GetHashCode();
}
}

}

Los ejemplos avanzados demuestran el uso de Dictionary\ para acceso rápido, HashSet para asegurar unicidad, y LINQ para filtrar y ordenar colecciones de manera eficiente. La clase ComparadorProducto define reglas de igualdad personalizadas. Las mejores prácticas incluyen manejo de excepciones, uso de genéricos para seguridad de tipos y optimización mediante LINQ. La elección adecuada de la colección según el escenario es clave: List para secuencias ordenadas, Dictionary\ para búsquedas rápidas y HashSet para elementos únicos. Comprender estas técnicas permite construir aplicaciones robustas, modulares y escalables.

Las mejores prácticas en C# para Referencia de Colecciones incluyen usar colecciones genéricas, seleccionar la estructura de datos apropiada, recorrer elementos de manera segura con foreach, minimizar bucles anidados y manejar excepciones correctamente. Para prevenir fugas de memoria, se recomienda eliminar referencias innecesarias y monitorear el rendimiento en colecciones grandes. En entornos multihilo, usar colecciones concurrentes garantiza seguridad. La optimización puede involucrar LINQ eficiente y comparadores personalizados. En cuanto a seguridad, validar los datos antes de agregarlos y proteger colecciones compartidas entre hilos es esencial.

📊 Referencia Completa

C# Element/Method Description Syntax Example Notes
List<T> Lista dinámica ordenada List<int> numeros = new List<int>(); numeros.Add(10); Acceso por índice, ajuste automático de tamaño
List<T>.Add() Agregar elemento numeros.Add(10); numeros.Add(5); O(1) promedio
List<T>.Remove() Eliminar elemento numeros.Remove(10); numeros.Remove(5); Devuelve true si se elimina
List<T>.Contains() Verificar existencia numeros.Contains(10); bool existe = numeros.Contains(5); Búsqueda lineal
List<T>.Count Cantidad de elementos numeros.Count int total = numeros.Count; Actualización automática
Dictionary\<TKey,TValue> Claves y valores Dictionary\<int,string> dict = new Dictionary\<int,string>(); dict.Add(1,"Ana"); Acceso rápido por clave
Dictionary\<TKey,TValue>.Add() Agregar par clave-valor dict.Add(1,"Ana"); dict.Add(2,"Luis"); Error si la clave existe
Dictionary\<TKey,TValue>.TryGetValue() Acceso seguro dict.TryGetValue(2,out string val); bool encontrado = dict.TryGetValue(1,out string nombre); Evita excepción
Dictionary\<TKey,TValue>.Remove() Eliminar par dict.Remove(1); dict.Remove(2); Devuelve true si se elimina
Dictionary\<TKey,TValue>.Keys Colección de claves var keys = dict.Keys; foreach(var key in dict.Keys) Solo lectura
Dictionary\<TKey,TValue>.Values Colección de valores var values = dict.Values; foreach(var val in dict.Values) Solo lectura
Queue<T> Cola FIFO Queue<int> q = new Queue<int>(); q.Enqueue(10); Primero en entrar, primero en salir
Queue<T>.Enqueue() Agregar elemento q.Enqueue(10); q.Enqueue(20) O(1)
Queue<T>.Dequeue() Eliminar primer elemento q.Dequeue(); int primero = q.Dequeue(); Error si está vacía
Queue<T>.Peek() Ver primer elemento q.Peek(); int peek = q.Peek(); Error si está vacía
Stack<T> Pila LIFO Stack<int> s = new Stack<int>(); s.Push(10); Último en entrar, primero en salir
Stack<T>.Push() Agregar elemento s.Push(10); s.Push(20) O(1)
Stack<T>.Pop() Eliminar elemento superior s.Pop(); int top = s.Pop(); O(1), error si está vacía
Stack<T>.Peek() Ver elemento superior s.Peek(); int top = s.Peek(); Error si está vacía
HashSet<T> Elementos únicos HashSet<int> hs = new HashSet<int>(); hs.Add(10); Evita duplicados
HashSet<T>.Add() Agregar único hs.Add(10); hs.Add(5); True si se agregó
HashSet<T>.Remove() Eliminar elemento hs.Remove(10); hs.Remove(5); True si se eliminó
ObservableCollection<T> Colección observable ObservableCollection<string> oc = new ObservableCollection<string>(); oc.Add("Item"); Notifica cambios a UI
ConcurrentDictionary\<TKey,TValue> Diccionario concurrente ConcurrentDictionary\<int,string> cd = new ConcurrentDictionary\<int,string>(); cd.TryAdd(1,"Ana"); Seguro en múltiples hilos
ConcurrentQueue<T> Cola concurrente ConcurrentQueue<int> cq = new ConcurrentQueue<int>(); cq.TryDequeue(out int val); Multihilo seguro
ConcurrentStack<T> Pila concurrente ConcurrentStack<int> cs = new ConcurrentStack<int>(); cs.TryPop(out int val); Multihilo seguro

📊 Complete C# Properties Reference

Property Values Default Description C# Support
Count int 0 Número de elementos Todas las colecciones
Capacity int Variable Capacidad antes de crecer List<T>, ArrayList
IsReadOnly bool false Solo lectura ICollection<T>, IList<T>
Keys TKey Collection N/A Colección de claves Dictionary\<TKey,TValue>
Values TValue Collection N/A Colección de valores Dictionary\<TKey,TValue>
Comparer IEqualityComparer Default Comparador de elementos HashSet<T>, Dictionary\<TKey,TValue>
SyncRoot object null Objeto de sincronización ICollection
IsSynchronized bool false Seguridad en multihilo ICollection
CollectionChanged Event N/A Evento de cambio ObservableCollection<T>
CapacityChanged Event N/A Evento de cambio de capacidad List<T>
Comparer IComparer Default Comparador para SortedList/SortedDictionary SortedList\<TKey,TValue>, SortedDictionary\<TKey,TValue>

La Referencia de Colecciones en C# es una herramienta clave para desarrolladores avanzados. Conocer y dominar List, Dictionary\, Queue, Stack y HashSet permite construir aplicaciones escalables, seguras y eficientes. La práctica con genéricos, manejo de excepciones, optimización con LINQ y selección correcta de estructuras asegura aplicaciones robustas. Los siguientes pasos incluyen aprender ObservableCollection, colecciones concurrentes y LINQ avanzado, así como diseñar algoritmos eficientes. Se recomienda consultar documentación oficial, proyectos de código abierto y cursos especializados para profundizar en C# avanzado.

Términos de Búsqueda Relacionados

Los usuarios también buscan este contenido usando estos términos:

C# referencia de colecciones ejemplos de colecciones en C# List<T> C# guía Dictionary\<TKey TValue> C# uso Queue y Stack en C# HashSet C# tutorial colecciones genéricas C# LINQ en colecciones ObservableCollection C# ejemplo colecciones concurrentes en C# mejores prácticas colecciones C# manejo de listas en C# optimización de colecciones estructuras de datos avanzadas C# guía completa de colecciones C#

🧠 Pon a Prueba tu Conocimiento

Listo para Empezar

Test Your Knowledge

Test your understanding of this topic with practical questions.

❓
4
Preguntas
🎯
70%
Para Aprobar
♾️
∞
Tiempo
🔄
∞
Intentos

📝 Instrucciones

  • Lee cada pregunta cuidadosamente
  • Selecciona la mejor respuesta para cada pregunta
  • Puedes repetir el quiz tantas veces como quieras
  • Tu progreso se mostrará en la parte superior
Tema 1 de 1
C-Sharp Tutorial