Resolviendo problemas en VisualBasic: arreglos de tamaño variable

Resolviendo problemas en VisualBasic

Arreglos de tamaño variable

Hace dos años empecé a trabajar en un programa que otra persona ya había comenzado. Y éste no era el único problema: tenía que ser en VisualBasic.Net.

Mi primer contacto con VisualBasic fue con la versión 3. Aunque fácil de usar me pareció muy limitado, especialmente en comparación con otras herramientas que había usado anteriormente, como Delphi por ejemplo. Con .Net había la promesa de mayores facilidades que ponían a VisualBasic.Net al mismo nivel que los otros lenguajes soportados en Visual Studio. Pero esto implicó cambios importantes en el lenguaje así como una colección muuuuuy grande de clases.

Ni modo. Hay que adaptarse. Así que tomé uno de los tantos libros sobre VisualBasic.Net que hay en el mercado, lo leí rápidamente (dos semanas, medio tiempo) y me puse a trabajar. Después de un par de años, me siento cómodo con esta herramienta y hasta desarrollé unos cuantos "trucos" que quiero compartir con otros desarrolladores de software.

Problema

¡Comencemos! Supongamos que tenemos que leer unos nombres de una base de datos y mantenerlos en memoria hasta que hayamos terminado de usarlos. Mmmm. Eso suena a que podemos usar un arreglo. Ya estaría el problema resuelto sino fuera porque no sabemos cuántos nombres vamos a leer.

Una opción sería definir un arreglo con un gran tamaño, lo suficientemente grande como para contener la lista más larga que se nos ocurra es posible se presente. Si la computadora donde vaya a correr el programa tuviera mucha memoria ya podríamos pasar a otra cosa. Pero la realidad raramente nos complace. Además desde el punto de vista del programador esta solución dista de ser profesional porque malgasta memoria.

Otra opción es usar ReDim que nos permite cambiar las dimensiones de un arreglo y hasta preservar los datos que éste contenga. Lo único que tendríamos que hacer es llevar un contador de datos y cuando lleguemos al límite, usamos ReDim para aumentar el arreglo.

VisualBasic.Net nos provee una solución más elegante, el ArrayList. Veamos cómo usarlo.

Para declarar y crear un ArrayList escribimos

Dim miArreglo As New ArrayList

¡y ya está! No necesitamos especificar un tamaño.

Cuando agregamos un elemento en el arreglo, éste aumenta su tamaño dinámicamente. Y hablando de agregar un elemento, se hace así

miArreglo.Add("nombre1")
miArreglo.Add("nombre2")
miArreglo.Add("nombre3")

esto agrega las cadenas de caracteres "nombre1", "nombre2" y "nombre3" al arreglo miArreglo. No estamos limitados a cadenas de caracteres, podemos usar números u otros objetos.

Para leerlos usamos la misma notación al que estamos acostumbrados:

MsgBox(miArreglo(0))
MsgBox(miArreglo(1))
MsgBox(miArreglo(2))

Fíjese que el primer elemento está almacenado en la posición 0. Esto quiere decir que si queremos ver todos los elementos usaríamos el ciclo

For i = 0 to miArreglo.Count - 1
    MsgBox(miArreglo(i))
Next

miArreglo.Count dá el número de elementos que contiene.

Si queremos saber si un nombre ya está en el arreglo usamos Contains:

If miArreglo.Contains("nombre3") Then
    MsgBox("El arreglo contiene nombre3")
Else
    MsgBox("El arreglo no contiene nombre3")
End If

Contains realiza una búsqueda lineal y dá como resultado True si el arreglo contiene el elemento especificado y False en caso contrario.

Esto es suficiente para trabajar con ArrayList. Para aprovecharlo al máximo revise la ayuda de Visual Studio. De interés son BinarySearch, Insert, IndexOf, LastIndexOf, Remove, RemoveAt y Sort.

Publicado el 18 de septiembre del 2007.

CSS original de styleshout

SobrePC