Una ventaja de las estructuras dinámicas es que permiten guardar datos de cualquier tipo, incluso datos de distinto tipo en una misma estructura. En ocasiones puede ser interesante ser algo un poco más rígido, y que un ArrayList esté adaptado a un tipo de dato, y no necesite una conversión de tipos cada vez que extraigamos un dato.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Collections;
namespace TablaHash
{
class Program
{
static void Main(string[] args)
{
List miLista = new List();
// Creamos un alista de cadenas
// List miLista = new List();
miLista.Add("Juan");
miLista.Add("Pedro");
miLista.Add("Judas");
miLista.Add("Pablo");
miLista.Add("Simmón");
miLista.Add("Santiago");
miLista.Add("Matías");
miLista.Add("Mateo");
// Navegamos a través de la lista
foreach (var miItem in miLista)
{
Console.Write(miItem + " ");
}
Console.ReadKey();
}
}
}
Otra forma de inicializar la lista
...
List miLista = new List(new string[]{"Juan", "Pedro", "Judas", "Pablo", "Simón", "Santiago", "Matías", "Mateo"});
// Navegamos a través de la lista
foreach (var miItem in miLista)
{
Console.Write(miItem + " ");
}
También podemos recorrerlo mediante un blucle for
...
var miLista= new List { "Juan", "Pedro", "Judas", "Pablo", "Simón", "Santiago", "Matías", "Mateo" };
// Navegamos a través de la lista
for (var index = 0; index < miLista.Count; index++)
{
Console.Write(miLista[index] + " ");
}
De esta misma forma, podríamos crear una lista de structs, o de objetos, o de cualquier otro dato.
Ejemplo de struct:
...
public struct CoOrds
{
public int x, y;
public CoOrds(int p1, int p2)
{
x = p1;
y = p2;
}
}
...
class TestCoOrds
{
static void Main()
{
// Initialize:
CoOrds coords1 = new CoOrds();
CoOrds coords2 = new CoOrds(10, 10);
// Display results:
Console.Write("CoOrds 1: ");
Console.WriteLine("x = {0}, y = {1}", coords1.x, coords1.y);
Console.Write("CoOrds 2: ");
Console.WriteLine("x = {0}, y = {1}", coords2.x, coords2.y);
Console.WriteLine("Pulsa una tecla para salir.");
Console.ReadKey();
}
}
Ejemplo que compara una estructura con una clase:
// struct2.cs
using System;
class TheClass
{
public int x;
}
struct TheStruct
{
public int x;
}
class TestClass
{
public static void structtaker(TheStruct s)
{
s.x = 5;
}
public static void classtaker(TheClass c)
{
c.x = 5;
}
public static void Main()
{
TheStruct a = new TheStruct();
TheClass b = new TheClass();
a.x = 1;
b.x = 1;
structtaker(a);
classtaker(b);
Console.WriteLine("a.x = {0}", a.x);
Console.WriteLine("b.x = {0}", b.x);
}
}
El resultado:
a.x = 1 b.x = 5
El resultado del ejemplo muestra que, cuando se pasa la instancia de clase al método classtaker, sólo cambia el valor del campo de la clase. Sin embargo, el campo de una estructura no cambia al pasar su instancia al método structtaker. Esto es debido a que lo que se pasa al método structtaker es una copia de la estructura mientras que lo que se pasa al método classtaker es una referencia a la clase.
Las estructuras pueden declarar constructores, pero deben utilizar parámetros. Es un error declarar un constructor predeterminado (sin parámetros) para una estructura. Los miembros de una estructura no pueden tener inicializadores. Siempre existe un constructor predeterminado que inicializa los miembros de la estructura con sus valores predeterminados.
Cuando se crea un objeto struct mediante el operador new, se crea y se llama al constructor apropiado. A diferencia de las clases, se pueden crear instancias de las estructuras sin utilizar el operador New. Si no se utiliza New, los campos permanecerán sin asignar y el objeto no se podrá utilizar hasta haber inicializado todos los campos.
A diferencia de las clases, para las estructuras no existe herencia. Una estructura no puede heredar de otra estructura o clase, ni puede ser la base de una clase. Sin embargo, las estructuras heredan de la clase base object.
No sólo tenemos listas. Por ejemplo, también existe un tipo “Dictionary”, que equivale a una tabla Hash, pero en la que las claves y los valores no tienen por qué ser strings, sino el tipo de datos que nosotros decidamos. Por ejemplo, podemos usar una cadena como clave, pero un número entero como valor obtenido:
using System.Collections.Generic; ... Dictionary<string, int> dict = new Dictionary<string, int>(); ...
Ejemplo:
using System;
using System.Collections.Generic;
class Program
{
static void Main()
{
Dictionary<string, int> dictionary = new Dictionary<string, int>();
dictionary.Add("gato", 2);
dictionary.Add("perro", 1);
dictionary.Add("llama", 0);
dictionary.Add("iguana", -1);
}
}
Otro ejemplo:
using System;
using System.Collections.Generic;
class Program
{
static void Main()
{
Dictionary<string, int> dictionary = new Dictionary<string, int>();
dictionary.Add("apple", 1);
dictionary.Add("linux", 3);
dictionary.Add("windows", 5);
if (dictionary.ContainsKey("apple"))
{
int value = dictionary["apple"];
Console.WriteLine(value);
}
if (!dictionary.ContainsKey("acorn"))
{
Console.WriteLine(false);
}
}
}
Recorrer el diccionario:
using System;
using System.Collections.Generic;
class Program
{
static void Main()
{
Dictionary<string, int> d = new Dictionary<string, int>()
{
{"gato", 2},
{"perro", 1},
{"llama", 0},
{"iguana", -1}
};
foreach (KeyValuePair<string, int> pair in d)
{
Console.WriteLine("{0}, {1}",
pair.Key,
pair.Value);
}
foreach (var pair in d)
{
Console.WriteLine("{0}, {1}",
pair.Key,
pair.Value);
}
}
}
Este método será más lento, pero a veces poner las claves en una array o lista será más eficaz.
using System;
using System.Collections.Generic;
class Program
{
static void Main()
{
Dictionary<string, int> d = new Dictionary<string, int>()
{
{"gato", 2},
{"perro", 1},
{"llama", 0},
{"iguana", -1}
};
// Store keys in a List
List list = new List(d.Keys);
// Loop through list
foreach (string k in list)
{
Console.WriteLine("{0}, {1}",
k,
d[k]);
}
}
}