Curso de ASP.NET

Los "arraylist" son matrices dinámicas en las que no hace falta declarar el número de elementos que va a tener. Por ejemplo, observa este código:

'Declaramos la matriz dinámica, sin indicarle un número de elementos fijo:
Dim Lista_dinamica as New ArrayList

'Añadimos elementos a esa matriz:
Lista_dinamica.Add ("uno")
Lista_dinamica.Add ("dos")
Lista_dinamica.Add ("tres")

'Recuperamos un valor de la matriz:
Valor=CType (lista_dinamica (0), String)

Es muy útil porque en ocasiones tendremos que crear una matriz de elementos sin saber a priori cuantos valores tienes. Por ejemplo, leer líneas de un fichero texto, no sabemos cuantas líneas hay así que tendremos que ir leyendo el fichero hasta que se termine, en ese caso iremos creando tantos elementos con el método "Add" mientras leamos líneas del fichero.

La función CType la veremos mas adelante, estamos realizando una conversión de tipos para asegurarnos que metemos un valor de tipo "String" en la variable.

Hasta ahora hemos visto los tipos de variables que nos proporciona Visual Basic .NET, pero ¿puedo yo crear algo mas complejo para adaptarlo a mi programa? La respuesta está en las estructuras.

Las estructuras permiten crear nuestro propios tipos de datos. Una estructura contiene uno o mas miembros que pueden ser del mismo o diferente tipo de datos. Cada miembro tiene un nombre que permite referenciarlo de forma única en la estructura, es decir, no puede haber dos elementos con el mismo nombre en la estructura. En anteriores versiones de Visual Basic se definían con la palabra clave "Type", ahora utilizaremos "Structure" con esta sintaxis:

Structure nombre
    declaraciones
End Structure

En el siguiente ejemplo veremos cómo se declaraban antes en VB6 y cómo se declaran ahora.

Una vez definida la estructura ya podemos utilizarla con normalidad en el programa, para referirnos a cada uno de los miembros de la estructura simplemente se lo indicaremos con: estructura.miembro:

Dim emp1 As Empleado
dim emp2 As Empleado

emp1.Numero=10
emp1.Nombre="Jose"
emp1.Direccion="Jorge Vigon"
emp1.Puesto="Muy Jefe"

emp2.Numero=11
emp2.Nombre="Maria"
emp2.Direccion="Club Deportivo"
emp2.Puesto="Currante"

¿Y podría crear una matriz de estos elementos? Pues también, sólo indicando el tipo de datos:

Dim matriz_empleados (10) as Empleado

matriz_empleados (0).Numero=10
matriz_empleados (0).Nombre="Jose"
matriz_empleados (0).Direccion="Jorge Vigon"
matriz_empleados (0).Puesto="Muy Jefe"

Es un tipo de datos muy utilizado cuando manejamos muchos datos en los formularios. Si son coherentes, es decir, fichas de empleados, datos de materiales, podemos declarar una variable de este tipo y quedará mucho mas legible y elegante el trabajo con estos datos.

Una enumeración es un tipo especial de variable numérica en la que los valores que dicha variable puede tomar, son constantes simbólicas, es decir que en lugar de usar un número, se usa una palabra (constante) que hace referencia a un número.

Las enumeraciones proporcionan una forma cómoda de trabajar con conjuntos de constantes relacionadas y de asociar valores de constantes con nombres. Por ejemplo, se puede declarar una enumeración para un conjunto de constantes de tipo entero asociadas con los días de la semana, y después utilizar los nombres de los días en el código en lugar de sus valores enteros.

Por ejemplo, si queremos tener una variable llamada color y queremos que contenga un valor numérico que haga referencia a un color en particular, así en lugar de usar el valor 1, 2 ó 3, queremos usar la constante rojo, azul, verde, etc. Esto lo haríamos de esta forma:

Enum colores
    rojo = 1
    azul
    verde
End Enum

Las declaraciones de las enumeraciones hay que hacerla fuera de cualquier procedimiento, por ejemplo dentro de una clase o un módulo (ya llegaremos a estas partes de Clases y Módulos), pero también pueden estar declarados dentro de un espacio de nombres (recuerda los spacenames), todo dependerá del alcance (o amplitud de acceso) que queramos darle.

Los valores que pueden tener los miembros de una enumeración, pueden ser cualquiera del tipo entero o real. Por defecto el tipo es Integer, pero las enumeraciones también pueden ser de tipo Byte, Long o Short. Para poder especificar un tipo diferente a Integer, lo indicaremos usando As Tipo después del nombre de la enumeración.

Por defecto, el primer valor que tendrá un elemento de una enumeración será cero y los siguientes elementos, salvo que se indique lo contrario, tendrán uno más que el anterior.

En el ejemplo mostrado, el elemento rojo, valdrá 1, azul valdrá 2 y verde tendrá un valor 3.

Para poder cambiar esos valores automáticos, podemos indicarlo usando una asignación como la usada para indicar que rojo vale 1: rojo = 1
En caso de que no indiquemos ningún valor, el primero será cero y los siguientes valdrán uno más que el anterior, por ejemplo, si la declaración anterior la hacemos de esta forma:

Enum colores
    rojo
    azul
    verde
End Enum

En este caso el rojo valdrá 0, azul será igual a 1 y verde tendrá el valor 2. La asignación podemos hacerla en cualquier momento, en el siguiente caso, rojo valdrá cero, azul tendrá el valor 3 y verde uno más que azul, es decir 4.

Enum colores
    rojo
    azul = 3
    verde
End Enum

Por supuesto, los valores que podemos asignar a los elementos (o miembros) de una enumeración serán valores que estén de acuerdo con el tipo de datos, recordemos que si no indicamos nada, serán de tipo Integer, pero si especificamos el tipo de datos, por ejemplo, de tipo Byte, el cual si recordamos la tabla vista en la cuarta entrega, sólo podrá contener valores enteros comprendidos entre 1 y 255. Sabiendo esto, no podríamos declarar la siguiente enumeración sin recibir un mensaje de error:

Enum colores As Byte
    azul = 255
    rojo
    verde
End Enum

¿Por qué? te preguntarás, ¿si el valor está dentro de los valores permitidos? Por la sencilla razón de que azul tiene un valor adecuado, pero tanto rojo como verde, tendrán un valor 256 y 257 respectivamente, los cuales están fuera del rango permitido por el tipo Byte.

Otra cosa que tendremos que tener en cuenta es que una variable declarada del tipo de una enumeración, en teoría no debería admitir ningún valor que no esté incluido en dicha enumeración. Veamos un ejemplo:

Dim unColor As colores
'
unColor = 1

Aunque el valor 1, sea un valor correcto nos indicaría que no se permite la conversión implícita entre Integer y el tipo colores.

	unColor = CType(1, colores)

Es decir, usamos CType para hacer la conversión entre el número y el tipo correcto de datos.

Es decir, primero creamos la enumeración con "Enum" y luego vamos a utilizarla. Escribimos un procedimiento cualquiera y al escribir "Dim micolor as ..." se desplegará una lista con los tipos posibles y veremos que aparece nuestro "colores" luego vamos bien. El segundo paso es utilizarlo:

enum colores as long
    azul
    verde
    rojo
end enum

sub miprograma
    dim micolor as colores

    micolor=colores.azul
end sub

Ya lo tenemos declarado ahora vamos a utilizarlo. Como "micolor" es una variable de tipo la enumeración anterior sólo me debemos seleccionar uno de los colores que he definido antes.

Ahora veremos algunas funciones o métodos de las enumeraciones que nos será muy útiles... observa esta línea de código

    If System.Enum.IsDefined(GetType(colores), 12) Then

Tranquilo no es tan complicada, sólo queremos saber si existe el color número 12. Supón que en el programa necesitamos un elemento de la enumeración, normalmente no tendremos problemas pero deberíamos controlar los errores para que no termine de forma anómala o simplemente no funcione bien nuestro programa.

Utilizaremos entonces las herramientas que nos proporciona VB.NET para manejar las enumeraciones. El ejemplo de antes devolverá un valor falso, ya que 12 no es miembro de la enumeración colores. En el primer caso usamos la variable del tipo colores (miColor) y usamos el método GetType para saber que tipo de datos es esa variable.

La función IsDefined espera dos parámetros, el primero es el tipo de una enumeración, todos los objetos de .NET Framework tienen el método GetType que indica ese tipo de datos. En el segundo parámetro, hay que indicar un valor que será el que se compruebe si está o no definido en dicha enumeración, si ese valor es uno de los incluidos en la enumeración indicada por GetType, la función devolverá True, en caso de que no sea así, devolverá un valor False.

Además de IsDefined, la clase Enum tiene otros métodos que pueden ser útiles:

GetName, indica el nombre con el que se ha declarado el miembro de la enumeración, por ejemplo esta llamada devolvería  "azul":

    System.Enum.GetName(unColor.GetType, 1)

En caso de que el valor indicado no pertenezca a la enumeración, devolverá una cadena vacía.

GetNames, devuelve un array (recuerda las matrices) de tipo String con los nombres de todos los miembros de la enumeración.

	Dim a() As String = System.Enum.GetNames(unColor.GetType)
	Dim i As Integer

	For i = 0 To ubound (a)
	    Response.Write("el valor " & i & " es: " &  a(i))
	Next

Curioso ejemplo, además puedes entenderlo. Por un lado definimos una matriz que no le ponemos un tamaño fijo y le asignamos en la propia declaración un valor y ese valor es la lista de la enumeración definida. Así que hemos hecho tres cosas en una sólo línea. Luego hacemos un bucle desde el primer elemento hasta el último (o hasta a.length-1)

GetValues, devuelve un array con los valores de los miembros de la enumeración. El tipo devuelto es del tipo Array, que en realidad no es un array (o matriz) de un tipo de datos específico, sino más bien es el tipo de datos en el que se basan los arrays o matrices.

Dim a As Array = System.Enum.GetValues(unColor.GetType)
For i = 0 To ubound(a)
    Response.Write("el valor " & i & " es: " &  a.getvalue(i))
Next

Por último vamos a ver un método que, casi con toda seguridad veremos en más de una ocasión:

Parse, devuelve un valor de tipo Object con el valor de la representación de la cadena indicada en el segundo parámetro. Esa cadena puede ser un valor numérico o una cadena que representa a un miembro de la enumeración.

	System.Enum.Parse(unColor.GetType, "1")
	System.Enum.Parse(unColor.GetType, "azul")

Hay más métodos, pero estos que son los más interesantes, de todas formas puedes practicar con la ayuda para ver con mas detalles estos ejemplos y ver que mas posibilidades existen,

Ya que hemos comentado la el método Parse veamos algún detalle mas sobre él. El método Parse se utiliza para convertir una cadena en un valor numérico, el tipo de número devuelto dependerá del tipo desde el que hemos usado ese método, por ejemplo si hacemos lo siguiente:

	Dim s As String = "123"
	Dim i As Integer = Integer.Parse(s)

El valor asignado a la variable numérica i, sería el valor 123 que es un número entero válido. Pero si hacemos esto otro:

	Dim b As Byte = Byte.Parse(s)

También se asignaría el valor 123 a la variable b, que es de tipo Byte, pero el número 123 ya no es un número entero, sino del tipo byte. Vale  pero si el valor guardado en la variable s no estuviese dentro del "rango" de valores aceptados por el tipo Byte, esto produciría una excepción (o error).

s = "129.33"
i = Integer.Parse(s)

En este caso, el error se produce porque 129.33 no es un número entero válido, por tanto, cuando usemos Parse, o cualquiera de las funciones de conversión, tendremos que tener cuidado de que el valor sea el correcto para el tipo al que queramos asignar el valor...

Ya siento meteros toda esta teoría pero debéis conocer todo lo que VB.NET pone a nuestro alcance... Cuando queráis hacer páginas mas complejas necesitaréis cada vez mas estructuras mas complejas para facilitar la escritura del código, aunque las importante es la que vamos a vez a continuación: la estructuración del código mediante procedimientos y funciones

Pulsa aquí para descargar los ejemplos de este tema. Son los que hicimos antes, estos últimos fragmentos no los incluyo.