Lists / Listas
C# tiene un amplio rango de clases para lidear con listas. Implementando la
interfaz de iList y la implementación mas popular es la lista generica, normalmente
referida como List<T> La "T" especifica el tipo de objeto contenido en la lista, el
cual tiene el beneficio añadido de que el compliador verificará y se asegurará que
se agreguen unicamente objetos del tipo de la lista - en otras palabras la lista tipo -
List <Type> es segura para agregar elementos de un mismo tipo.
List es muy parecida a la clase ArrayList, que era la opción de ir a la lista antes de
que C # admitiera listas genéricas. Por lo tanto, también verá que List puede hacer
muchas de las mismas cosas que una Matriz (que por cierto también implementa la
interfaz IList), pero en muchas situaciones, List es más simple y fácil de trabajar. Por
ejemplo, no tiene que crear una Lista con un tamaño específico; en su lugar, puede
crearla y .NET la expandirá automáticamente para ajustarse a la cantidad de
elementos a medida que los agregue.
Como mencioné, la T se refiere a tipo y se usa para especificar el tipo de objetos
que quieres que contenga la lista. En nuestro primer ejemplo, te mostraré como
crear una lista que debería contener strings:
List<string> listOfStrings = new List<string>();
Esto crea una lista vacía, pero agregarle algo luego es muy fácil con el método Add:
[Link]("a string");
Sin embargo, si intenta agregar algo que no sea una cadena, el compilador se
quejará de inmediato:
[Link](2);
Error CS1503 Argument 1: cannot convert from 'int' to 'string'
Inicializando una lista con ítems
En el ejemplo anterior, acabamos de crear una lista y luego le agregamos un
elemento. Sin embargo, C # realmente le permite crear una lista Y agregarle
elementos dentro de la misma declaración, utilizando una técnica llamada
inicializadores de colección. Veamos cómo se hace:
List<string> listOfNames = new List<string>()
{
"John Doe",
"Jane Doe",
"Joe Doe"
};
La sintaxis es bastante simple: antes del punto y coma final habitual, tenemos un
conjunto de llaves, que a su vez contiene una lista de los valores que queremos
que estén presentes en la lista desde el principio. Como se trata de una lista de
strings, los objetos iniciales que proporcionamos deben ser del tipo de string. Sin
embargo, se puede lograr exactamente lo mismo para la lista de otros tipos,
incluso si estamos usando nuestras propias clases, como demostraré en el
siguiente ejemplo.
Trabajando con los elementos.
Hay varias formas de trabajar con los elementos de una lista genérica y mostrar
algunos de ellos. He creado un ejemplo más amplio:
using System;
using [Link];
namespace Lists
{
class Program
{
static void Main(string[] args)
{
List<User> listOfUsers = new List<User>()
{
new User() { Name = "John Doe", Age = 42 },
new User() { Name = "Jane Doe", Age = 34 },
new User() { Name = "Joe Doe", Age = 8 },
};
for(int i = 0; i < [Link]; i++)
{
[Link](listOfUsers[i].Name + " is " + listOfUsers[i].Age + "
years old");
}
[Link]();
}
}
class User
{
public string Name { get; set; }
public int Age { get; set; }
}
}
Comencemos desde abajo, donde definimos una clase simple para almacenar
información sobre un Usuario, solo un nombre y una edad. Volvemos a la parte
superior del ejemplo, donde he cambiado nuestra lista para usar esta clase de
usuario en lugar de cadenas simples. Utilizo un inicializador de colección para
completar la lista con los usuarios: observe cómo la sintaxis es la misma que antes,
solo que es un poco más compleja porque se trata de un objeto más complejo que
una cadena.
Una vez que tenemos lista la lista, utilizo un bucle for para ejecutarla - para saber
cuántas iteraciones vamos a hacer, uso la propiedad Count de la lista. En cada
iteración, accedo al usuario en cuestión a través del indexador de la lista, utilizando
la sintaxis de corchetes (por ejemplo, listOfUsers [i]). Una vez que tengo el usuario,
escribo el nombre y la edad.
Añadiendo, insertando y borrando elementos.
Ya intentamos agregar un solo elemento a una lista, pero hay más opciones para
hacerlo. En primer lugar, puede insertar un elemento en lugar de agregarlo; la
diferencia es que, si bien el método Add siempre agrega al final de la lista, el
método Insert le permite insertar un elemento en una posición específica. Aquí hay
un ejemplo:
List<string> listOfNames = new List<string>()
{
"Joe Doe"
};
// Insert at the top (index 0)
[Link](0, "John Doe");
// Insert in the middle (index 1)
[Link](1, "Jane Doe");
Comenzamos la lista con solo un elemento, pero luego insertamos dos elementos
más, primero en la parte superior de la lista y luego en el medio. El primer
parámetro del método Insert es el índice donde queremos insertar el elemento. Sin
embargo, tenga cuidado: se lanzará una excepción si intenta insertar un elemento
en el índice 3, ¡si la lista tiene menos elementos!
Añadiendo múltiples elementos.
Al igual que tenemos los métodos Agregar e Insertar para agregar un solo
elemento, también hay métodos correspondientes para agregar e insertar múltiples
elementos. Se llaman AddRange()() e InsertRange() () y acepta cualquier tipo de
colección que implemente la interfaz IEnumerable como parámetro; esto podría
ser, p.e. una matriz de elementos u otra lista, qué elementos desea agregar o
insertar en la lista actual.
Como ejemplo de los métodos Range, hagamos algo divertido: combinamos el
método AddRange con un inicializador de colección para agregar varios nombres
nuevos a una lista existente en una sola declaración:
[Link](new string[]
{
"Jenna Doe",
"Another Doe"
});
Simplemente creamos una serie de cadenas sobre la marcha e inmediatamente
agregamos sus elementos a nuestra lista de nombres del ejemplo anterior.
Borrando elementos.
Actualmente hay tres métodos a su disposición cuando desea eliminar uno o varios
elementos de una lista: Remove(), RemoveAt() y RemoveAll().
El método Remove() toma solo un parámetro: el elemento que desea eliminar.
Esto es genial para, p.e. una lista de cadenas o enteros, porque simplemente puede
escribir el elemento que desea eliminar. Por otro lado, si tienes una lista de objetos
complejos, primero deberías encontrar ese objeto, para tener una referencia que
puedas pasar al método Remove (). "Vamos a tratar eso más tarde. Aquí hay un
ejemplo muy básico sobre cómo puedes eliminar un solo elemento con el método
Remove ():
List<string> listOfNames = new List<string>()
{
"John Doe",
"Jane Doe",
"Joe Doe",
"Another Doe"
};
[Link]("Joe Doe");
El método Remove () simplemente recorre la lista en iteración hasta que encuentra
la primera instancia del objeto que especificó para su eliminación, y ellos la
eliminan; solo elimina una instancia, y si especifica un elemento en la lista que no
existe, No se arroja ningún error. El método devuelve truesi pudo eliminar un
elemento y false si no lo fue.
El método RemoveAt() aprovecha el hecho de que la lista genérica se basa en
índices al permitirle eliminar un elemento en función de su índice / posición en la
lista. Por ejemplo, podría eliminar el primer elemento de la lista así:
[Link](0);
O el último elemento de la lista así:
[Link]([Link] - 1);
Nuevamente, esto solo elimina un solo elemento y esta vez, debe tener cuidado al
proporcionar el índice del elemento que se eliminará; si utiliza un índice que está
fuera de los límites (inferior a 0 o superior a la cantidad de elementos) se lanzará
una excepción! Entonces, a menos que esté seguro de lo que está haciendo, es
posible que desee envolver el método RemoveAt () en un bloque try-catch para
manejar la excepción (explicado en detalle en otra parte de este tutorial). El
método RemoveAt () no devuelve nada, por lo que tendrá que verificar la cantidad
de elementos en la lista antes y después de la llamada, para decidir si fue exitosa,
por otro lado, si sabe que tiene un índice que existe en la lista, de la que siempre
debe asegurarse, siempre puede esperar que RemoveAt () sea exitoso.
RemoveAll() es el más complejo de los métodos remove, pero definitivamente
también el más poderoso. Toma un delegado a un método como parámetro y este
método decide si un elemento debe eliminarse o no devolviendo verdadero o
falso. Esto le permite aplicar su propia lógica al eliminar elementos y también le
permite eliminar más de un elemento a la vez. Los delegados serán tratados en
otra parte de este tutorial, porque es un tema grande y complejo, pero todavía
quiero que entiendan lo genial que es el método RemoveAll, así que aquí hay un
ejemplo:
List<string> listOfNames = new List<string>()
{
"John Doe",
"Jane Doe",
"Joe Doe",
"Another Doe"
};
[Link](name =>
{
if ([Link]("J"))
return true;
else
return false;
});
En este ejemplo, utilizamos un método anónimo (nuevamente demasiado complejo
para ser explicado aquí, pero será tratado en otro capítulo) como un parámetro
para el método RemoveAll. Nuestro método anónimo es bastante simple: se
llamará para cada elemento de la lista y tendrá un parámetro llamado name, que
es, por supuesto, el elemento actual en la iteración. Mira este nombre y si comienza
con "J", se devuelve true; de lo contrario, es false. El método RemoveAll () usa esta
respuesta (verdadero o falso) para decidir si cada elemento debe eliminarse o no.
Al final, esto deja nuestra lista inicial con solo un miembro de Doe: Another Doe.
Ordenando elementos de Lista
Hasta ahora, los elementos de la lista con los que hemos trabajado se han utilizado
en el orden en que se agregaron a la lista. Sin embargo, es posible que desee
ordenar los elementos de una manera específica, p. alfabéticamente en el caso de
nuestra lista de nombres. La List<T> tiene un método Sort () que podemos usar
para esto:
List<string> listOfNames = new List<string>()
{
"John Doe",
"Jane Doe",
"Joe Doe",
"Another Doe"
};
[Link]();
foreach (string name in listOfNames)
[Link](name);
Como verá en la salida, los elementos de la lista ahora se han ordenado
alfabéticamente, y si lo desea en orden descendente (de Z a A), simplemente llame
al método Reverse()después de realizar la clasificación:
[Link]();
[Link]();
Entonces ordenar una lista fue bastante fácil, ¿verdad? Bueno, fue muy fácil porque
tenemos una lista de cadenas y .NET Framework sabe exactamente cómo comparar
dos cadenas. Si tiene una lista de números, .NET, por supuesto, también sabrá
cómo ordenar eso. Por otro lado, es posible que tenga una lista de objetos
personalizados (ya que laList<T>puede contener cualquier objeto) que .NET no
tiene la posibilidad de saber cómo comparar. Hay varias soluciones a este
problema, p. implementando la interfaz IComparable o usando LINQ (lo veremos
más adelante en este tutorial), pero como solución rápida, también podemos
proporcionar un método para que llame el método Sort (), para aprender cómo se
comparan dos elementos uno contra el otro, así:
using System;
using [Link];
namespace ListSort
{
class Program
{
static void Main(string[] args)
{
List<User> listOfUsers = new List<User>()
{
new User() { Name = "John Doe", Age = 42 },
new User() { Name = "Jane Doe", Age = 39 },
new User() { Name = "Joe Doe", Age = 13 },
};
[Link](CompareUsers);
foreach (User user in listOfUsers)
[Link]([Link] + ": " + [Link] + " years old");
}
public static int CompareUsers(User user1, User user2)
{
return [Link]([Link]);
}
}
public class User
{
public string Name { get; set; }
public int Age { get; set; }
}
}
Make correction
Esto agregó bastante código a nuestro ejemplo, pero en realidad no es demasiado
complicado. Si comenzamos desde abajo, he creado una clase de usuario muy
simple, que consta de un nombre y una edad. En el medio, he declarado un
método llamado CompareUsers(): toma dos usuarios como parámetros y luego
devuelve un número entero, que indicará si un elemento es "más pequeño", "igual"
o "más grande" (-1, 0 o 1). El método Sort () utilizará estos valores para mover los
elementos de modo que el orden de los elementos coincida con lo que queremos.
En este caso, simplemente uso la propiedad Age para comparar, esencialmente
dejándonos con una lista de usuarios ordenados por su edad.
