Taller Electiva Interdisciplinar 2

Anibal Ceballos Vecino

Collections C#

Una coleccin es un tipo de dato que acta como un contenedor para un

conjunto de objetos.
Cuando se define un arreglo, se especifica el tipo de dato que almacena el
arreglo y el tamao del arreglo. Una coleccin es ms flexible ya que al
momento de crearla no se tiene que especificar el tamao ni el tipo de dato
a almacenar.

Collection List
Representa una lista de objetos fuertemente tipados a la que se puede
obtener acceso por ndice. Proporciona mtodos para buscar, ordenar y
manipular listas.

Sintaxis:
[SerializableAttribute]
public class List<T> : IList<T>, ICollection<T>,
IList, ICollection, IReadOnlyList<T>, IReadOnlyCollection<T>,
IEnumerable<T>,
IEnumerable

El tipo List<T> expone los siguientes miembros.

Constructores, propiedades y mtodos
Dentro de los constructores encontramos:

List<T>(): Inicializa una nueva instancia de la clase List<T> que est vaca
y tiene la capacidad inicial predeterminada.

List<T>(IEnumerable<T>): Inicializa una nueva instancia de la

clase List<T> que contiene elementos copiados de la coleccin especificada
y tiene una capacidad suficiente para aceptar el nmero de elementos
copiados.

List<T>(Int32): Inicializa una nueva instancia de la clase List<T> que est

vaca y tiene la capacidad inicial especificada.

Dentro de las propiedades tenemos:

-

Capacity: Obtiene o establece el nmero total de elementos que puede

contener la estructura de datos interna sin cambiar el tamao.
Count: Obtiene el nmero de elementos incluidos en List<T>.
Item: Obtiene o establece el elemento que se encuentra en el ndice
especificado.

Algunos de los mtodos que podemos encontrar son:

-

Add: Agrega un objeto al final deList<T>.

AddRange: Agrega los elementos de la coleccin especificada al final

deList<T>.

AsReadOnly: Devuelve un contenedor deI List<T> de solo lectura para la

coleccin actual.

La clase List<T> es el equivalente genrico de la clase ArrayList.

Implementa la interfaz genrica de IList<T> utilizando una matriz cuyo
tamao se aumenta dinmicamente segn sea necesario.
Puede agregar elementos a List<T> mediante los mtodos de Add o de
AddRange .

Ejemplo:
// Creamos una lista de tipo String
var salmons = new List<string>();
salmons.Add("Anibal");
salmons.Add("Joel");
salmons.Add("Julio");
salmons.Add("Celina");
foreach (var salmon in salmons)
{
Console.Write(salmon + " ");
}

Collection Dictionary
Una clase Dictionary es una estructura de datos que representa una
coleccin de claves y valores de par de datos. La clave es idntica en un par
clave-valor y puede tener como mximo un valor en el diccionario, pero un
valor puede ser asociado con muchas llaves diferentes.
Esta clase se define en el espacio de nombres System.Collections.Generic,
por lo que debe importar o using namespace System.Collections.Generic.
Sintaxis:
[SerializableAttribute]
[ComVisibleAttribute(false)]
public class Dictionary<TKey, TValue> : IDictionary<TKey, TValue>,
ICollection<KeyValuePair<TKey, TValue>>, IDictionary,
ICollection,
IReadOnlyDictionary<TKey, TValue>,
IReadOnlyCollection<KeyValuePair<TKey, TValue>>,
IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable,
ISerializable,
IDeserializationCallback

Parmetros de tipo

TKey
Tipo de las claves del diccionario.
TValue
Tipo de los valores del diccionario.

Ejemplo
Dictionary < string, int > dict = new Dictionary < string, int > ();
dict.Add("Uno", 1);
dict.Add("Dos", 2);
dict.Add("Tres", 3);
dict.Add("Cuatro", 4);
foreach (KeyValuePair < string, int > pair in dict)
{
Console.Write(pair.Key.ToString() + " - " +
pair.Value.ToString());
}

Collection HashTable
Hashtable en C # representa una coleccin de pares de clave / valor que
mapea claves para valorar. Cualquier objeto no nulo puede ser utilizado
como una clave pero una lata de valor. Podemos recuperar los elementos de
tabla hash para proporcionar la clave. Ambas claves y valores son objetos.
Las funciones de uso comn en Hashtable son:
-

Add: Para agregar un par de valor en HashTable

ContainsKey: Comprobar si existe una clave especificada o no
ContainsValue: Comprobar el valor especificado si existe en
HashTable
Remove: Elimina el valor de clave y correspondiente especificado

Ejemplo
Dictionary < string, int > dict = new Dictionary < string, int > ();
dict.Add("one", 1);
dict.Add("two", 2);
dict.Add("three", 3);
dict.Add("four", 4);
foreach (KeyValuePair < string, int > pair in dict)
{
Console.Write(pair.Key.ToString() + " - " +
pair.Value.ToString());
}

Collection ArrayList
ArrayList es uno de la estructura de datos ms flexible de C#. ArrayList
contiene una simple lista de valores. ArrayList implementa la interfaz IList
utilizando una matriz y muy fcilmente podemos agregar, insertar, eliminar,
ver, etc. Es muy flexible, ya que podemos aadir sin informacin cualquier
tamao, es decir va a crecer de forma dinmica y tambin disminuir.

Add: Agregar un elemento en un ArrayList

Insert: insertar un elemento en una posicin determinada en un ArrayList
remove: eliminar un elemento de ArrayList
RemoveAt: eliminar un elemento de una posicin especificada
Sort: ordenar los elementos en un ArrayList
int i = 0;
ArrayList ItemList = new ArrayList();
ItemList.Add("Item4");
ItemList.Add("Item5");
ItemList.Add("Item2");
ItemList.Add("Item1");
ItemList.Add("Item3");
MessageBox.Show ("Shows Added Items");
for (i = 0; i < = ItemList.Count - 1; i++)
{
Console.Write(ItemList[i].ToString());
}
ItemList.Insert(3, "Item6");
ItemList.Sort();
ItemList.Remove("Item1");
ItemList.RemoveAt(3);
Console.Write("Shows final Items the ArrayList");
for (i = 0; i < = ItemList.Count - 1; i++)
{
Console.Write(ItemList[i].ToString());
}

Collection Sets
HashSet: es un conjunto de recopilacin optimizada. Ayuda elimina
duplicados cadenas o elementos en una matriz. Proporciona una sintaxis
sencilla para la toma de la unin de los elementos de un conjunto. Esto se
realiza en su constructor.
Sintaxis:

[SerializableAttribute]

[HostProtectionAttribute(SecurityAction.LinkDemand, MayLeakOnAbort =
true)]
public class HashSet<T> : ISerializable, IDeserializationCallback,
ISet<T>, ICollection<T>, IEnumerable<T>, IEnumerable

Parmetros de tipo
T
Tipo de los elementos del conjunto hash.

Ejemplo
using System;
using System.Collections.Generic;
class Program
{
static void Main()
{
HashSet<int> evenNumbers = new HashSet<int>();
HashSet<int> oddNumbers = new HashSet<int>();
for (int i = 0; i < 5; i++)
{
evenNumbers.Add(i * 2);
oddNumbers.Add((i * 2) + 1);
}
Console.Write("evenNumbers contains {0} elements: ",
evenNumbers.Count);
DisplaySet(evenNumbers);
Console.Write("oddNumbers contains {0} elements: ",
oddNumbers.Count);
DisplaySet(oddNumbers);
HashSet<int> numbers = new HashSet<int>(evenNumbers);
Console.WriteLine("numbers UnionWith oddNumbers...");
numbers.UnionWith(oddNumbers);
Console.Write("numbers contains {0} elements: ",
numbers.Count);
DisplaySet(numbers);
}
private static void DisplaySet(HashSet<int> set)
{
Console.Write("{");

foreach (int i in set)

{
Console.Write(" {0}", i);
}
Console.WriteLine(" }");
}
}

SortedSet: Representa una coleccin de objetos que se mantiene en el

criterio de ordenacin.
Sintaxis:
[SerializableAttribute]
public class SortedSet<T> : ISet<T>,
ICollection<T>, IEnumerable<T>, ICollection, IEnumerable,
ISerializable,
IDeserializationCallback

Parmetros de tipo
T
Tipo de elementos del conjunto

Un objeto de SortedSet<T> mantiene una orden ordenada sin afectar al

rendimiento a medida que se insertan y se eliminan los elementos. No
se permiten elementos duplicados. Cambiar los valores de ordenacin
de elementos existentes no se admite y puede causar un
comportamiento inesperado.

Para una alternativa segura para subprocesos a SortedSet<T>

Ejemplo:
using
using
using
using

System;
System.Collections;
System.Collections.Generic;
System.IO;

class Program
{
static void Main(string[] args)
{
try
{
IEnumerable<string> files1 =

Directory.EnumerateFiles(@"\\archives\2007\media",
"*", SearchOption.AllDirectories);
SortedSet<string> mediaFiles1 =
new SortedSet<string>(new ByFileExtension());
foreach (string f in files1)
{
mediaFiles1.Add(f.Substring(f.LastIndexOf(@"\") + 1));
}
Console.WriteLine("Remove docs from the set...");
Console.WriteLine("\tCount before: {0}",
mediaFiles1.Count.ToString());
mediaFiles1.RemoveWhere(isDoc);
Console.WriteLine("\tCount after: {0}",
mediaFiles1.Count.ToString());

Console.WriteLine();
SortedSet<string> aviFiles =
mediaFiles1.GetViewBetween("avi", "avj");
Console.WriteLine("AVI files:");
foreach (string avi in aviFiles)
{
Console.WriteLine("\t{0}", avi);
}
Console.WriteLine();
IEnumerable<string> files2 =
Directory.EnumerateFiles(@"\\archives\2008\media",
"*", SearchOption.AllDirectories);
SortedSet<string> mediaFiles2 = new SortedSet<string>(new
ByFileExtension());
foreach (string f in files2)
{
mediaFiles2.Add(f.Substring(f.LastIndexOf(@"\") + 1));
}
Console.WriteLine("Remove duplicates (of mediaFiles2) from
the set...");
Console.WriteLine("\tCount before: {0}",
mediaFiles1.Count.ToString());
mediaFiles1.ExceptWith(mediaFiles2);
Console.WriteLine("\tCount after: {0}",
mediaFiles1.Count.ToString());
Console.WriteLine();

Console.WriteLine("List of mediaFiles1:");
foreach (string f in mediaFiles1)
{
Console.WriteLine("\t{0}",f);
}
IEqualityComparer<SortedSet<string>> comparer =
SortedSet<string>.CreateSetComparer();
HashSet<SortedSet<string>> allMedia =
new HashSet<SortedSet<string>>(comparer);
allMedia.Add(mediaFiles1);
allMedia.Add(mediaFiles2);
}
catch(IOException ioEx)
{
Console.WriteLine(ioEx.Message);
}
catch (UnauthorizedAccessException AuthEx)
{
Console.WriteLine(AuthEx.Message);
}
}
private static bool isDoc(string s)
{
if (s.ToLower().EndsWith(".txt") ||
s.ToLower().EndsWith(".doc") ||
s.ToLower().EndsWith(".xls") ||
s.ToLower().EndsWith(".xlsx") ||
s.ToLower().EndsWith(".pdf") ||
s.ToLower().EndsWith(".doc") ||
s.ToLower().EndsWith(".docx"))
{
return true;
}
else
{
return false;
}
}

}
public class ByFileExtension : IComparer<string>
{
string xExt, yExt;

CaseInsensitiveComparer caseiComp = new

CaseInsensitiveComparer();
public int Compare(string x, string y)
{
xExt = x.Substring(x.LastIndexOf(".") + 1);
yExt = y.Substring(y.LastIndexOf(".") + 1);
int vExt = caseiComp.Compare(xExt, yExt);
if (vExt != 0)
{
return vExt;
}
else
{
return caseiComp.Compare(x, y);
}
}
}