Las colecciones en C Sharp son grupos de objetos relacionados. Las colecciones se diferencian de las matrices en que permiten aumentar o disminuir su capacidad de manera dinámica.
En esta entrada vamos a enfocarnos en las colecciones genéricas que se encuentran en el espacio de nombres; System.Collections.Generic: List<T>, Queue<T>, Stack<T> y Dictionary<TKey, TValue>.
Te puede interesar: Tutorial básico C#
List<T>
La clase List<T> en C# es una colección de elementos a los que se puede tener acceso mediante un índice. Contiene métodos para ordenar, buscar y manejar listas.
varfourElements = new List<string> {"water", "earth", "fire", "air"}; Console.WriteLine("The four elements of nature:"); foreach (var e in fourElements ) { Console.Write($"{e} "); }
En el código anterior creamos una lista con cuatro elementos de tipo texto. Y posteriormente mostramos el resultado por pantalla mediante un bloque foreach.
Console.Write("\nMetod Add: ");
fourElements.Add("other");
foreach (var e in fourElements)
{
Console.Write($"{e} ");
}
Console.Write("\nMethod RemoveAt: ");
fourElements.RemoveAt(fourElements.Count-1);
foreach (var e in fourElements)
{
Console.Write($"{e} ");
}
Console.Write("\nMethod Sort: ");
fourElements.Sort();
foreach (var e in fourElements)
{
Console.Write($"{e} ");
}
Añadimos un nuevo elemento a la lista con el método Add(). Y después eliminamos ese mismo elemento con el método RemoveAt(index). En el argumento de RemoveAt(…) utilizamos la propiedad Count, que devuelve el número de objetos que tiene la colección. Finalmente ordenamos la lista con el método Sort().
Queue<T>
La clase Queue<T> (cola) es una colección de elementos organizados “FIFO”; los primeros elementos en entrar son los primeros en salir. Queue<T> es similar a las colas que se forman cuando estamos en un cajero automático, donde debemos respetar el orden de llegada.
Console.WriteLine("The Kings: ");
var kings = new Queue<string>();
kings.Enqueue("Arturo");
kings.Enqueue("Alejandro");
kings.Enqueue("Melchor");
kings.Enqueue("Gaspar");
kings.Enqueue("Baltasar");
foreach (var king in kings)
{
Console.Write($"{king} ");
}
kings.Dequeue();
kings.Peek();
kings.Dequeue();
Console.WriteLine("\nThe Kings: ");
foreach (var king in kings)
{
Console.Write(king + " ");
}
El bloque de código anterior crea una cola de elementos con new Queue<string>. Añade cinco elementos con el método Enqueue() y los imprime por consola. Después quita de la cola los dos primeros elementos con el método Dequeue().
Stack<T>
La clase Stack<T> (pila) es una colección de objetos organizados “LIFO”; los últimos en entrar son los primeros en salir. Stack<T> se comporta de manera similar a una pila de platos donde los últimos en poner, son los primeros en sacar.
Console.WriteLine("\nPizzas:");
var pizzas = new Stack<string>();
// Add an item to the stack
pizzas.Push("Cuatro estaciones");
pizzas.Push("Romana");
pizzas.Push("Barbacoa");
foreach (var pizza in pizzas)
{
Console.WriteLine(pizza);
}
// Removes an item from the stack
Console.WriteLine($"Method Pop: {pizzas.Pop()}");
// Peek() returns an item but does not remove it from the stack
Console.WriteLine($"Method Peek: {pizzas.Peek()}");
foreach (var pizza in pizzas)
{
Console.WriteLine(pizza);
}
pizzas.Clear();
Console.WriteLine($"Stack Count: {pizzas.Count}");
En el anterior código creamos una instancia de la clase Stack y le añadimos tres elementos con el método Pop(). Removemos el último elemento añadido con Push(). El método Peek() devuelve un elemento pero no lo remueve de la pila. Finalmente vaciamos la pila con el método Clear(). Y comprobamos que no quedan elementos con la propiedad Count.
Dictionary<TKey, TValue>
La clase Dictionary<TKey, TValue> es una colección de pares de clave y valor que se organizan mediante su clave. Las claves no pueden repetirse aunque sí los valores.
Console.WriteLine("- Car Brands");
var carBrands = new Dictionary<string,string>();
carBrands.Add("s3", "Audi");
carBrands.Add("s4", "Audi");
carBrands.Add("zx", "Citroen");
// Iterate each par key value
foreach (var car in carBrands)
{
Console.WriteLine($"Key->{car.Key}, Value->{car.Value}");
}
// Throw an exception if key already exists
try
{
carBrands.Add("zx", "Opel");
}
catch (ArgumentException)
{
Console.WriteLine("\n- Element with Key->zx already exists.");
}
// Get value with TryGetValue
string v = "";
if (carBrands.TryGetValue("s3", out v))
{
Console.WriteLine($"\n- TryGetValue(s3...): Key->s3, value->{v}.");
}
// Check if key is in Dictionary
if(!carBrands.ContainsKey("focus"))
{
carBrands.Add("focus", "Ford");
Console.WriteLine($"- Add(k,v): key->focus, value->{carBrands["focus"]}.");
}
Console.WriteLine("\n - Get, Insert or Modify with the Indexer");
Console.WriteLine($"Get: carBrands[\"s3\"] value->{carBrands["s3"]}.");
Console.WriteLine($"Modify: carBrands[\"s3\"] = \"Au\" value->{carBrands["s3"] = "Au"}.");
Console.WriteLine($"Insert: carBrands[\"s8\"] = \"Audi\" value->{carBrands["s8"] = "Audi"}.");
// Remove element
carBrands.Remove("s3");
Console.WriteLine("\n - Remove(\"s3\")");
foreach (var car in carBrands)
{
Console.WriteLine($"Key->{car.Key}, Value->{car.Value}");
}
En el anterior ejemplo hemos creado un diccionario de cadenas con claves de cadena (new Dictionary<string,string>()) y hemos añadido tres elementos con el método Add(). Iteramos por cada uno de ellos con un bucle foreach para mostrar su clave y valor.
Después intentamos añadir un nuevo elemento con una clave existente. Esto lanza un ArgumentException, ya que un diccionario no puede contener claves repetidas.
A continuación usamos una forma segura de obtener un valor con TryGetValue(key, out Value).
Con ContainsKey(k) comprobamos si el diccionario contiene una clave, en caso contrario añadimos un nuevo elemento usando dicha clave con el método Add(k,v).
En las últimas instrucciones usamos el indexador carBrands[“s3”] como alternativa para añadir y obtener elementos del diccionario. También para modificarlos.
Finalmente usamos Remove(k) para eliminar el elemento con la clave “s3”, y mostramos los nuevos pares clave valor mediante un bucle foreach.
0 comentarios