Bucles y colecciones

Bucles:

Los bucles en C# son estructuras de control que permiten repetir un bloque de código varias veces. Los bucles son fundamentales para controlar el flujo de ejecución en un programa. Aquí tienes una descripción de los tipos de bucles más comunes en C# junto con ejemplos:

Bucle while:

• El bucle while se ejecuta siempre que una condición sea verdadera. Es importante asegurarse de que la condición cambie en algún momento para evitar un bucle infinito.

int contador = 0;
while (contador < 5)
{
    Console.WriteLine("Iteración " + contador);
    contador++;
}

---

Bucle do-while:

• El bucle do-while es similar al while, pero garantiza que el bloque de código se ejecute al menos una vez antes de verificar la condición.

int numero = 5;
do
{
    Console.WriteLine("Número es igual a " + numero);
    numero--;
} while (numero > 0);

---

Bucle for:

• El bucle for es útil cuando se conoce de antemano la cantidad de iteraciones necesarias. Incluye una inicialización, una condición y una expresión de incremento.

for (int i = 0; i < 5; i++)
{
    Console.WriteLine("Iteración " + i);
}

💡 Ademas de hacerlo incremental se puede hacer decreciente!

---

Bucle foreach:

• El bucle foreach se utiliza principalmente para iterar a través de elementos de una colección, como arrays o listas. (En un minuto vas a saber lo que es una lista o array)

string[] nombres = { "Juan", "María", "Pedro" };
foreach (string nombre in nombres)
{
    Console.WriteLine(nombre);
}

---

Bucle break y continue:

• Puedes usar la instrucción break para salir de un bucle antes de que se cumpla la condición y continue para omitir la iteración actual y pasar a la siguiente.

for (int i = 0; i < 10; i++)
{
    if (i == 5)
        break; // Sale del bucle cuando i es igual a 5
    if (i % 2 == 0)
        continue; // Salta las iteraciones pares
    Console.WriteLine("Número impar: " + i);
}

---

Colecciones:

Las colecciones en C# son estructuras de datos que permiten almacenar y manipular conjuntos de elementos. Aquí tienes una descripción de los tipos de colecciones más comunes en C# junto con ejemplos:

Array[]

• Un array es una colección de elementos del mismo tipo con un tamaño fijo que se declara en tiempo de compilación.

int[] numeros = { 1, 2, 3, 4, 5 };

Declaración de un array:

• Para declarar un array, puedes usar la siguiente sintaxis:

tipo[] nombreArray = new tipo[tamaño];
int[] numeros = new int[5]; // Declarar un array de enteros con tamaño 5

Inicialización de un array:

• Puedes inicializar un array con valores en el momento de la declaración:

int[] numeros = { 1, 2, 3, 4, 5 };

Acceso a elementos:

• Para acceder a los elementos de un array, puedes utilizar el índice entre corchetes:

numeros[2] = 10; // Sobrescribir el tercer elemento con el valor 10

Longitud del array:

• Puedes obtener la longitud de un array utilizando la propiedad Length:

int[] copiaNumeros = (int[])numeros.Clone();

Clonar un array:

• Puedes crear una copia de un array utilizando el método Clone():

int[] copiaNumeros = (int[])numeros.Clone();

Ordenar un array:

• Puedes ordenar un array utilizando el método Array.Sort():

Array.Sort(numeros); // Ordenar el array en orden ascendente

Buscar un elemento en un array:

• Puedes buscar un elemento en un array utilizando el método Array.IndexOf():

int indice = Array.IndexOf(numeros, 3); // Buscar el índice del valor 3

Recorrer un array:

• Puedes recorrer un array utilizando bucles como for o foreach (como vimos en la seccion anterior.

Ten en cuenta que si necesitas agregar o quitar elementos de una colección de manera dinámica, es posible que desees considerar el uso de otras estructuras de datos como List<T> en lugar de arrays, ya que las listas permiten operaciones más flexibles de inserción y eliminación de elementos.

---

List<>

• Una lista es una colección dinámica que puede crecer o reducirse en tamaño según sea necesario.

List<int> numeros = new List<int>();

Agregar elementos a una lista:

• Puedes agregar elementos a una lista utilizando el método Add():

List<string> nombres = new List<string>();
nombres.Add("Juan");
nombres.Add("María");
nombres.Add("Pedro");

Acceder a elementos de una lista:

• Para acceder a los elementos de una lista, puedes utilizar el índice entre corchetes, al igual que con los arrays:

int primerNumero = numeros[0];
int segundoNumero = numeros[1];

Sobrescribir elementos de una lista:

• Puedes sobrescribir un elemento existente de una lista utilizando el índice:

numeros[2] = 10;

Obtener la longitud de una lista:

• Puedes obtener la cantidad de elementos en una lista utilizando la propiedad Count: (Cuidado que no es como el array donde se usa Length)

int primerNumero = numeros[0];
int segundoNumero = numeros[1];
int tercerNumero = numeros[2];
int longitud = numeros.Count; // Obtener la longitud de la lista (en este caso, 3) Aunque el maximo indice es 2

Clonar una lista:

• Puedes crear una copia de una lista utilizando el constructor de List<T> que toma otra lista como argumento:

List<int> copiaNumeros = new List<int>(numeros);

Ordenar una lista:

• Puedes ordenar una lista utilizando el método Sort():

numeros.Sort(); // Ordenar la lista en orden ascendente

Buscar un elemento en una lista:

• Puedes buscar un elemento en una lista utilizando el método IndexOf():

int indice = numeros.IndexOf(3); // Buscar el índice del valor 3

Eliminar elementos de una lista:

• Puedes eliminar elementos de una lista utilizando métodos como Remove(), RemoveAt(), o RemoveAll():

numeros.Remove(2); // Eliminar el valor 2 de la lista
numeros.RemoveAt(0); // Eliminar el primer elemento de la lista
numeros.RemoveAll(x => x > 5); // Eliminar todos los elementos mayores que 5

Recorrer una lista:

• Puedes recorrer una lista utilizando bucles como for o foreach al igual que con el array.

---

Dictionary

****Los diccionarios en C# son una estructura de datos que almacena pares clave-valor, donde cada clave es única. Aquí tienes una descripción de las operaciones más comunes que puedes realizar con un Dictionary<TKey, TValue> en C#, junto con ejemplos:

---

Declaración e inicialización de un diccionario:

• Puedes declarar e inicializar un diccionario de la siguiente manera:

Dictionary<string, int> edades = new Dictionary<string, int>();

Agregar elementos a un diccionario:

• Puedes agregar pares clave-valor a un diccionario utilizando el método Add():

edades.Add("Juan", 30);
edades.Add("María", 25);
edades.Add("Pedro", 28);

Acceder a valores de un diccionario:

• Para acceder a los valores de un diccionario, puedes utilizar la clave como índice:

int edadDeJuan = edades["Juan"];

Ten en cuenta que si la clave no existe en el diccionario, esto generará una excepción KeyNotFoundException. Para evitar esto, puedes utilizar el método TryGetValue():

int edadDeJuan;
if (edades.TryGetValue("Juan", out edadDeJuan))
{
    // La clave existe y se ha obtenido el valor
}

Verificar si una clave existe en un diccionario:

• Puedes verificar si una clave existe en un diccionario utilizando el método ContainsKey():

if (edades.ContainsKey("María"))
{
    // La clave "María" existe en el diccionario
}

Eliminar elementos de un diccionario:

• Puedes eliminar elementos de un diccionario utilizando el método Remove():

edades.Remove("Pedro"); // Eliminar la entrada con la clave "Pedro"

Limpiar un diccionario:

• Puedes eliminar todos los elementos de un diccionario utilizando el método Clear():

edades.Clear(); // Eliminar todos los elementos del diccionario

Obtener la cantidad de elementos en un diccionario:

• Puedes obtener la cantidad de elementos en un diccionario utilizando la propiedad Count:

int cantidadDeElementos = edades.Count;

Recorrer un diccionario:

• Puedes recorrer un diccionario utilizando un bucle foreach o acceder a sus claves o valores utilizando las propiedades Keys y Values . Igual que con array y List pero teniendo en cuenta que manejas 2 valores.

foreach (var kvp in edades)
{
    Console.WriteLine($"Clave: {kvp.Key}, Valor: {kvp.Value}");
}

foreach (string nombre in edades.Keys)
{
    Console.WriteLine("Nombre: " + nombre);
}

foreach (int edad in edades.Values)
{
    Console.WriteLine("Edad: " + edad);
}

Los diccionarios (Dictionary<TKey, TValue>) son ideales cuando necesitas asociar valores con claves únicas y realizar búsquedas eficientes. Son una estructura de datos fundamental en la programación y se utilizan ampliamente en muchas aplicaciones.

---

Otras colecciones:

Si bien lo mas común es usar Array, List y Dictionary. Hay otros tipos de colecciones muy utiles y que tienen otros usos. No voy a profundizar en ellos ahora porque seria mucha data todo junto. Pero si es importante que los leas para saber que existes y si alguna vez tienes que hacer algo parecido puedas googlear como se usan y que hacen.

Tuple:

• Una tupla es una colección ordenada de elementos de diferentes tipos. Se utiliza cuando se necesita una estructura de datos simple para almacenar valores relacionados. A diferencia del Dictionary la tupla puede guardar 2 keys o mas iguales. Porque no son key.

Tuple<string, int, bool> persona = new Tuple<string, int, bool>("Juan", 30, true);

---

HashSet:

• Un conjunto (HashSet) es una colección que almacena elementos únicos sin duplicados. Es útil cuando se necesita garantizar que no haya elementos repetidos. Es lo contrario a un Dictionary donde en vez de no poder tener 2 key iguales. No puedes tener 2 valores iguales.

HashSet<int> numerosUnicos = new HashSet<int>();
numerosUnicos.Add(1);
numerosUnicos.Add(2);
numerosUnicos.Add(1); // No se agregará, ya que 1 está duplicado

---

Stack:

• Una pila (Stack) es una colección que sigue el principio LIFO (último en entrar, primero en salir). Se utiliza para almacenar elementos que deben procesarse en orden inverso. Se puede usar tranquilamente en un maso de cartas. Porque la primera que agregues va a ser la ultima en salir.

Stack<string> cards = new Stack<string>();
cards.Push("AnchoEspada");
cards.Push("AnchoBasto");
string ultimaCarta= pilaTareas.Pop(); // Devuelve "AnchoBasto"

---

Queue (Cola):

• Una cola (Queue) es una colección que sigue el principio FIFO (primero en entrar, primero en salir). Se utiliza para almacenar elementos que deben procesarse en el orden en el que se agregaron, similar a una fila en la vida real. (Lo contrario al Stack)

Queue<string> colaClientes = new Queue<string>();
colaClientes.Enqueue("Cliente1");
colaClientes.Enqueue("Cliente2");
string siguienteCliente = colaClientes.Dequeue(); // Devuelve "Cliente1"

En el ejemplo, los clientes se agregan a la cola en orden. Cuando se llama a Dequeue(), se elimina y devuelve el primer cliente que llegó a la cola, que en este caso es "Cliente1". Esto garantiza que los elementos se manejen en el mismo orden en el que se agregaron, lo que es útil en situaciones en las que es importante mantener un orden específico, como la gestión de tareas o procesos en un sistema.

---