Curso de iniciación a la programación con Visual Basic .NET
Guilermo Som “el Guille”
(Adaptación a Word, Marc Salvador. Rev A) 2
0.1.
Introducción:................................................................................................................7
0.2. ¿Qué
es el .NET Framework?.....................................................................................7
0.3. Sobre
la versión de Visual Basic .NET:......................................................................8
0.4.
Algunas aclaraciones preliminares:............................................................................8
1. Nuestra
primera aplicación con Visual Basic .NET.: Primera entrega......................11
1.1. ¿Que
es un Namespace (o espacio de nombres)?.....................................................13
1.2. ¿Que
es un assembly (o ensamblado)?......................................................................14
2. Segunda
entrega............................................................................................................17
3. Tercera
entrega..............................................................................................................27
4. Cuarta
entrega...............................................................................................................41
4.1.
Variables, constantes y otros conceptos relacionados..............................................41
4.2. Tipos
de datos de Visual Basic.NET y su equivalente en el Common Language Runtime
(CLR)........................................................................................................................43
4.3. Sobre
la necesidad u obligatoriedad de declarar las variables:...............................45
4.4. ¿Qué
ventajas tiene usar constantes en lugar de usar el valor directamente?........48
4.5.
Evaluar expresiones lógicas.......................................................................................51
5. Quinta
entrega...............................................................................................................57
5.1.
Declarar varias variables en una misma línea:........................................................57
5.2.
Declarar varios tipos de variables en una misma línea:...........................................57
5.3. La
visibilidad (o alcance) de las variables:...............................................................59
6. Sexta
entrega..................................................................................................................63
6.1.
Prioridad de los operadores.......................................................................................65
6.2.
Bucles en Visual Basic .NET.....................................................................................66
7. Séptima
entrega.............................................................................................................71
7.1. Las enumeraciones (Enum)..............................................................................72
8. Octava
entrega...............................................................................................................81
8.2. Cómo
hacer que se produzca una excepción:...........................................................87
9. Novena
entrega..............................................................................................................91
9.1. Tipos
de datos por valor.............................................................................................91
9.2. Tipos
de datos por referencia.....................................................................................91
9.3. Los
Arrays...................................................................................................................94
9.4. ¿Qué
tipos de datos se pueden usar para crear arrays?...........................................94
9.5.
Declarar variables como arrays.................................................................................95
9.6.
Reservar memoria para un array...............................................................................95
9.7.
Asignar valores a un array.........................................................................................96
3
9.8. Acceder a un
elemento de un array..........................................................................96
9.9. Los límites de
los índices de un array.......................................................................96
9.10. Saber el tamaño
de un array.....................................................................................96
9.11. Inicializar un
array al declararla..............................................................................97
9.12. Los arrays
pueden ser de cualquier tipo...................................................................97
9.13. Usar un bucle
For Each para recorrer los elementos de un array..........................97
9.14. Clasificar el
contenido de un array...........................................................................98
9.15. El contenido de
los arrays son tipos por referencia.................................................99
9.16. Copiar los
elementos de un array en otro array.......................................................99
10. Décima entrega............................................................................................................101
10.1. Los arrays
multidimensionales................................................................................101
10.2. Declarar arrays
multidimensionales.......................................................................101
10.3. El tamaño de un
array multidimensional...............................................................102
10.4. El número de
dimensiones de un array multidimensional....................................102
10.6. Redimensionar un
array multidimensional............................................................104
10.7. Eliminar un
array de la memoria...........................................................................105
10.8. ¿Podemos
clasificar un array multidimensional?..................................................105
10.9. Copiar un array
multidimensional en otro.............................................................105
10.10. Los formatos a
usar con las cadenas de Console.Write y WriteLine.................106
11. Undécima entrega.......................................................................................................111
11.1. La programación
orientada a objetos.....................................................................111
11.2. Los tres pilares
de la Programación Orientada a Objetos.....................................111
11.3. Las clases.................................................................................................................114
11.4. Los Objetos...............................................................................................................114
11.5. Los miembros de
una clase......................................................................................114
11.6. Crear o definir
una clase.........................................................................................115
11.7. Acceder a los
miembros de una clase......................................................................116
11.8. Ejemplo de cómo
usar la herencia..........................................................................117
12. Duodécima entrega.....................................................................................................121
12.1. Las partes o
elementos de un proyecto de Visual Basic .NET...............................121
12.2. Las partes o
elementos de una clase.......................................................................123
12.3. Los
procedimientos: métodos de las clases.............................................................124
12.4. Parámetros o
argumentos de los procedimientos...................................................125
12.5. Parámetros por
valor y parámetros por referencia................................................126
13. Treceava entrega.........................................................................................................129
13.1. Parámetros
opcionales.............................................................................................129
4
13.2. Sobrecarga de
procedimientos.................................................................................131
13.3. Sobrecargar el
constructor de las clases.................................................................133
13.4. Array de
parámetros opcionales..............................................................................133
14. Glosario.......................................................................................................................135
5
6
Curso de iniciación a la programación con
Visual Basic .NET
(http://guille.costasol.net/NET/cursoVB.NET/tutorVBNET01.htm)
0.1. Introducción:
Debido a que la nueva versión de Visual Basic no es sólo una
mejora con respecto a las versiones anteriores, sino que cambia mucho, tanto
como si de otro lenguaje de programación se tratara, creo que se merece que se
explique de forma más o menos fácil de comprender para que cualquiera que se
decida a elegirlo como su lenguaje de programación lo tenga, valga la
redundancia, fácil.
Tan fácil como permitan las circunstancias, y además, (para que
esto de estudiar no resulte algo tedioso), tan ameno como me sea posible, ya
que las cosas se pueden explicar de muchas formas y, a pesar de parecer que
peco de falta de modestia, estoy seguro que este curso de iniciación a la
programación con Visual Basic .NET te va a resultar ameno y fácil de comprender... ¡seguro!
Pero no sólo vas a aprender a programar con VB.NET, sino que al
estar "basado" en el .NET
Framework, conocerás lo suficiente de este marco de
desarrollo que podrás atreverte con otros lenguajes .NET, tales como C#, ya que
al fin y al cabo, el corazón de los lenguajes .NET es el .NET Framework.
Para ir aclarando ideas, veamos algunos conceptos que habrá que
tener claros desde el principio:
Visual Basic .NET usa una jerarquía de clases que están
incluidas en el .NET Framework, por tanto conocer el .NET Framework nos ayudará
a conocer al propio Visual Basic .NET, aunque también necesitarás conocer la
forma de usar y de hacer del VB ya que, aunque en el fondo sea lo mismo, el
aspecto sintáctico es diferente para cada uno de los lenguajes basados en .NET
Framework, si no fuese así, ¡sólo existiría un solo lenguaje!
Me imagino que la primera pregunta a la que habría que
responder es:
0.2. ¿Qué es el .NET Framework?
Voy a intentar dar una respuesta que sea
fácil de "asimilar", a ver si lo consigo...
Primer intento, lo que se dice en el eBook Microsoft
.NET Framework, cuya versión en Castellano puedes
conseguir usando este link: (este link está actualizado, al menos a fecha
de hoy 10 de noviembre de 2002)
".NET Framework es un entorno para construir, instalar y
ejecutar servicios Web y otras aplicaciones.
Se compone de tres partes principales: el Common Language
Runtime, las clases Framework y ASP.NET"
Aunque dicho libro está basado en la Beta1 es válido para
aclarar conceptos sobre lo que es el .NET Framework además de otros conceptos
como el Common Language Runtime (CLR), Common Language Specification (CLS), Common Type System (CTS), Microsoft Intermediate Language (MSIL), los ensamblados o assemblies, así como sobre ASP.NET, conceptos que si bien no son imprescindibles para poder usar
Visual Basic .NET, es conveniente leer un poco sobre ellos, para no estar
totalmente perdidos cuando nos encontremos con esos conceptos...
Segundo intento, lo que dice la MSDN Library:
7
"El .NET Framework es un entorno
multi-lenguaje para la construcción, distribución y ejecución de Servicios Webs
y aplicaciones."
"El .NET Framework es una nueva plataforma diseñada para
simplificar el desarrollo de aplicaciones en el entorno distribuido de Internet."
"El .NET Framework consta de dos componentes principales:
el Common Language Runtime y la librería de clases .NET Framework."
Tercer intento, aclarando las cosas, para
que se te "queden" grabadas:
El .NET Framework es el corazón de .NET, cualquier cosa que
queramos hacer en cualquier lenguaje .NET debe pasar por el filtro cualquiera
de las partes integrantes del .NET Framework.
El Common Lenguage Runtime (CLR) es una serie de librerías
dinámicas (DLLs), también llamadas assemblies, que hacen las veces de las DLLs
del API de Windows así como las librerías runtime de Visual Basic o C++. Como
sabrás, y si no lo sabes ahora te lo cuento yo, cualquier ejecutable depende de
una forma u otra de una serie de librerías, ya sea en tiempo de ejecución como
a la hora de la compilación. Pues el CLR es eso, una serie de librerías usadas
en tiempo de ejecución para que nuestros ejecutables o cualquiera basado en
.NET puedan funcionar. Se acabó eso de que existan dos tipos de ejecutables:
los que son autosuficientes y no dependen de librerías externas o los que
necesitan de librerías en tiempo de ejecución para poder funcionar, tal es el
caso de las versiones anteriores de Visual Basic.
Por otro lado, la librería de clases de .NET Framework
proporciona una jerarquía de clases orientadas a objeto disponibles para
cualquiera de los lenguajes basados en .NET, incluido el Visual Basic. Esto
quiere decir que a partir de ahora Visual Basic ya no será la "oveja negra"
de los lenguajes de programación, sino que tendrá a su disposición todas las
clases disponibles para el resto de los lenguajes basados en .NET, (o casi),
con lo cual sólo nos diferenciará del resto de programadores en la forma de
hacer las cosas: ¡más fáciles!
VB.NET ahora es totalmente un lenguaje orientado a objetos con
herencia y todo. También permite crear Threads o hilos o tramas de ejecución y
otras cosas que antes nos estaban vetadas. De todo esto veremos en esta serie
de "entregas", espero que, aunque es un poco más complicado que el
Visual Basic de "siempre", confío en que te sea fácil de asimilar. ¡A
ver si lo consigo!
0.3. Sobre la versión de Visual
Basic .NET:
A la hora de escribir estas líneas, la versión de Visual Basic
.NET que hay disponible es la que se incluye en la Beta2 de Visual Studio .NET.
Pero según dicen, la versión final tendrá pocos cambios con respecto a la Beta
2, así que, espero que todo lo que aquí explique sea válido para la versión
definitiva de Visual Basic .NET.
0.4. Algunas aclaraciones
preliminares:
Antes de empezar a ver el código, un par
de aclaraciones, que aunque ahora puede ser que te suenen a chino, (si eres chino o conoces ese idioma, sólo decirte que es una
frase hecha: "me suena a chino" es como decir: "no sé de que me
estás hablando"), pronto serán tan usuales que acabarás
por asimilarlas como si toda tu vida las hubieras estado usando... o casi...
Extensión de los ficheros de código.
En Visual Basic .NET a diferencia de lo que ocurría en las
versiones anteriores de Visual Basic, sólo existe un tipo de fichero de código,
el cual tiene la extensión .vb, en este tipo de fichero pueden coexistir distintos tipos de elementos, por
ejemplo: un módulo de clase, un formulario, un módulo de código, un control,
etc.; mientras que en las versiones anteriores de Visual Basic, cada uno de
estos elementos tenían su propio tipo
8
de fichero con su respectiva extensión. Si
no sabes o no quieres saber de lo que ocurría en las versiones anteriores, me
parece muy bien... pero esto sólo es para que lo sepas y no te sorprenda, si es
que hay algo que aún puede sorprenderte, claro.
Tipos de ejecutables.
Con Visual Basic .NET puedes crear básicamente estos dos tipos
de ejecutables:
de consola, no gráfico, al estilo del viejo MS-DOS, y gráficos,
como los que normalmente estamos acostumbrados a ver en Windows.
Existen otros tipos de aplicaciones que se pueden crear con
Visual Basic .NET: aplicaciones ASP.NET, (realmente no es una aplicación o
ejecutable, sino un compendio de distintos tipos de elementos...), servicios
Web, servicios Windows, etc.
9
10
1. Nuestra primera aplicación con
Visual Basic .NET.: Primera entrega
Para ir calentando motores, creo que lo
mejor es empezar creando una pequeña aplicación con VB.NET, después iremos
aclarando los distintos conceptos usados... así te resultará menos complicado
todo lo que tengo preparado para ti.
Inicia el Visual Studio .NET, por defecto
te mostrará la "página de inicio" desde la cual pueden crearse nuevos
proyectos o bien abrir alguno de los más recientemente abiertos. Pulsa en Nuevo
proyecto
Te mostrará los diferentes tipos de
proyectos que se pueden crear, en el panel izquierdo selecciona Proyectos de
Visual Basic (Visual Basic Projects) y de los que muestra en el panel de la
derecha, selecciona Console Application
11
Tendrás que especificar el directorio en
el que se guardará el proyecto, así como el nombre del mismo, (creando un
directorio con el nombre del proyecto indicado), deja el nombre que muestra por
defecto, en la versión inglesa de Visual Studio .NET se llamará
ConsoleApplication1. Pulsa en OK (Aceptar) y se creará el proyecto.
Por defecto te mostrará lo siguiente:
Es decir, creará un fichero llamado Module1.vb, (mostrado a la
derecha en el Solution Explorer), con el código necesario para empezar a
escribir. Fíjate que además del procedimiento Sub
Main, el cual se usará como punto de entrada
de nuestro ejecutable, también ha creado una "definición" llamada Module Module1 con
su respectivo End Module, el cual indica dónde termina la definición del módulo. Esto
es así, porque, como te dije hace un rato, en un mismo fichero .vb, pueden
existir distintos tipos de elementos. Por ahora, dejémoslo así... ya habrá
tiempo de complicarnos la vida...
Una aclaración: lo
que estamos creando es una aplicación tipo consola, es decir, no se creará
ninguna ventana gráfica, sino que el ejecutable que vamos a crear funciona
desde una ventana de MS-DOS (o consola). Esto lo comprobaremos cuando
ejecutemos el proyecto.
Lo que queremos, (o mejor dicho, lo que YO QUIERO), mostrar, es
un mensaje que diga algo así como: Hola mundo .NET ¡que original! ¿verdad?, por
tanto para mostrar un texto en la "consola", usaremos una función,
método o instrucción, (como prefieras llamarla), que si bien no es nativa de
Visual Basic .NET, la usaremos como si lo fuese... como veremos más tarde, TODO
esto es posible gracias a los assemblies o a las clases incluidas en el .NET
Framework. Por ahora simplemente confía en mí y escribe lo que te voy a decir.
La función en cuestión, (realmente todo lo
que se usa en .NET son funciones), es Console.Write
y se usa de la siguiente forma:
Console.Write("Hola mundo .NET"), es decir incluiremos dentro de paréntesis lo que queremos que
se muestre en la consola, en este caso queremos mostrar un texto, el cual hay
que incluirlo dentro de comillas dobles.
Escríbelo entre el Sub
Main() y el End Sub. Comprueba que cuando
escribas Console y el punto, se mostrarán las funciones que Console pone a
nuestra disposición, así como una pequeña ayuda, en modo de ToolTip, aunque a
esto, o a algo parecido, ya estarás acostumbrado si has usado alguna vez el
Visual Basic 5/6.
Bien, ya tenemos todo lo que necesitamos. Ahora tendremos que
indicarle al "Entorno Integrado" (IDE) que compile el proyecto y lo
ejecute, y después de compilarse el proyecto, se deberá mostrar el texto en una
ventana de DOS (o consola).
(Guille, ¿por qué me da la impresión de que no se va a mostrar
nada? te gustaría preguntarme en este preciso momento)
Para salir de dudas, pulsa F5 (o a la flecha azul o botón con
figura de PLAY de un reproductor)
Pregunta: ¿Que ha
pasado?
Respuesta: Realmente se
ha mostrado el mensaje en una ventana de consola...
12
(Salvo que hayas cometido algún error,
cosa que sólo habrá ocurrido si en lugar de estar leyendo, te has dedicado a
hacer tus propias pruebas, así que... ¡HAZ EL FAVOR DE ATENDER EN CLASE! ¡Ya
tendrás tiempo de hacer tus propias pruebas!)
P: Entonces, ¿por qué no se ve?
R: Porque después de mostrarse se ha cerrado
la ventana.
P: ¿Cómo podemos ver el mensaje?
R: Ejecutando el EXE desde una ventana de DOS
(o consola)
Pero lo mejor sería hacer que el programa se pare hasta que
pulsemos la tecla Intro. Para ello, añade la siguiente línea a continuación de
la anterior:
Console.Read()
Pulsa de nuevo F5 y verás como esta vez si que se muestra el
mensaje, además de que la ventana no se cierra hasta que pulses Intro.
Realmente puedes escribir lo que te de la gana y se irá
mostrando en la ventana de consola, pero hasta que pulses Intro no dejará de
mostrarse. (Tampoco iba a ser el primer ejemplo tan perfecto... ¡que te
crees!).
Pues ésta es nuestra primera aplicación con el Visual Basic
.NET.
Realmente tan inútil como poco práctica, pero... queda muy bien
eso de saber que ya somos capaces de crear nuestros propios ejecutables. La
verdad es que a estas alturas (o mejor dicho bajuras) del curso o tutorial no
pretenderás hacer cosas más "sofisticadas", entre otras razones,
porque se supone que no sabes nada de nada... ¿cómo? que si que sabes... que ya
has trabajado antes con el Visual Basic... que incluso te has leído mi Curso
Básico de VB... entonces... tendrás que esperar algunas entregas o unirte al
grupo de estudiantes noveles (o principiantes o novatos o... como quieras
llamarlos) y esperar a que los conceptos básicos estén aclarados, ya que este
curso es un curso de iniciación y si los que lo siguen ya supieran tanto como
tú, no sería un curso de iniciación... pues eso... (¡Que borde (desagradable)
eres algunas veces Guille!)
Olvidemos a los otros Guilles y
sigamos...
Antes de continuar, vamos a conocer un
poco sobre el entorno de desarrollo de Visual Studio .NET, (que es el que se
usa con Visual Basic .NET), para que podamos configurar algunos aspectos, por
ejemplo para indicar cómo se comportará el compilador e intérprete sobre el
código que escribamos o para configurar las librerías (assemblies) que se
usarán en nuestras aplicaciones. Recuerda que Visual Basic .NET usa una serie
de librerías (de clases) con las funciones que necesitemos en cada momento...
¿Te parece complicado? No te preocupes... ahora simplemente lee
y pronto entenderás, pero por favor: ¡lee! no intentes pasar todo este
"rollo" por alto, ya que si no te enteras de lo que te estoy contando,
seguramente acabarás preguntándomelo por e-mail y la única respuesta que
recibirás por mi parte es que te vuelvas a leer toda esta parrafada... gracias.
Por ejemplo, para poder mostrar un texto
en la consola, necesitamos tener disponible la librería en la cual está
declarada la clase Console,
para que podamos acceder a las funciones que dicha clase pone a nuestra
disposición, (por ejemplo Write o Read); en este caso la librería en la que
está la clase Console es: System. System realmente es un Namespace
o espacio de nombres, no es una librería o
assembly.
1.1. ¿Que es un Namespace (o espacio
de nombres)?
"Un espacio de nombres es un esquema lógico de nombres
para tipos en el que un nombre de tipo simple, como MiTipo, aparece precedido
por un nombre jerárquico separado por puntos. [...]"
Así es como lo definen en el eBook de .NET
Framework que mencioné al principio.
Para que nos entendamos, un Namespace,
(prefiero usar el nombre en inglés, ya que así es como aparecerá en el código),
es una forma de agrupar clases, funciones, tipos de datos, etc. que están
relacionadas entre sí. Por ejemplo, entre los Namespaces que
13
podemos
encontrar en el .NET Framework encontramos uno con funciones relacionadas con
Visual Basic: Microsoft.VisualBasic. Si te fijas, Microsoft y VisualBasic están separados por un
punto, esto significa que Microsoft a su vez es un Namespace que contiene otros "espacios de
nombres", tales como el mencionado VisualBasic, CSharp y
Win32 con
el cual podemos acceder a eventos o manipular el registro del sistema...
Para saber que es lo que contiene un Namespace, simplemente
escribe el nombre con un punto y te mostrará una lista desplegable con los
miembros que pertenecen a dicho espacio de nombres.
Por regla general se deberían agrupar en
un Namespace funciones o clases que estén relacionadas entre sí. De esta forma,
será más fácil saber que estamos trabajando con funciones relacionadas entre
sí.
Pero el que distintos espacios de nombres
pertenezcan a un mismo Namespace, (viene bien esto de usar la traducción
castellana e inglesa de una palabra, para no ser redundante), no significa que
todos estén dentro de la misma librería o assembly. Un Namespace puede estar
repartido en varios assemblies o librerías. Por otro lado, un assembly, (o
ensamblado), puede contener varios Namespaces.
Pero de esto no debes preocuparte, ya que
el IDE de Visual Studio .NET se encarga de "saber" en que assembly
está el Namespace que necesitamos.
1.2. ¿Que es un assembly (o ensamblado)?
"Un ensamblado es el bloque constructivo primario de una
aplicación de .NET Framework. Se trata de una recopilación de funcionalidad que
se construye, versiona e instala como una única unidad de implementación (como
uno o más archivos). [...]"
Para que nos entendamos, podríamos decir
que un assembly es una librería dinámica (DLL) en la cual pueden existir
distintos espacios de nombres. Aunque esto es simplificar mucho, por ahora nos
vale.
Un ensamblado o assembly puede estar formado por varios
ficheros DLLs y EXEs, pero lo más importante es que todos los ensamblados
contienen un manifiesto (o manifest), gracias al cual se evitan muchos de los
quebraderos de cabeza a los que Windows nos tiene acostumbrados, al menos en lo
referente a las distintas versiones de las librerías y ejecutables, seguramente
habrás oído hablar de las DLL
Hell (o librerías del demonio) expresión que se
usa cuando hay incompatibilidad de versiones entre varias librerías que están
relacionadas entre si. Por ejemplo, supongamos que tenemos una librería DLL que
en su primera versión contenía X funciones. Al tiempo, se crea la segunda
versión de dicha librería en la que se cambian algunas funciones y se añaden
otras nuevas, para mejorar el rendimiento de las funciones contenidas en esa
librería se usa otra DLL que es usada por algunas de las funciones contenidas
en esa segunda versión. Esa otra librería puede ser una librería del sistema,
la cual a su vez se actualiza con nueva funcionalidad y puede que dicha
funcionalidad dependa a su vez de una tercera librería.
Resulta que instalamos un programa que usa las últimas
versiones de todas estas librerías. Todo va bien, el programa funciona a las
mil maravillas y nosotros estamos "supersatisfechos" de ese programa
que no se cuelga ni una sola vez... (¿Quién habrá hecho ese programa tan
maravilloso?, sin comentarios...)
Ahora llega a nuestras manos otra aplicación que necesitamos
instalar y la instalamos, pero resulta que esa aplicación usa la primera versión
de nuestra famosa librería. Si el programa de instalación está bien hecho, no
ocurrirá nada malo, ya que al descubrir que tenemos una versión más reciente de
la librería, deja la que ya está instalada. Probamos el programilla de marras y
todo funciona bien. Probamos el maravilloso programa anterior y también
funciona bien. ¿Cual es el problema? Por ahora ninguno, pero espera... Después
instalamos un programa que usa una de las librerías del sistema u otra que
también usa nuestra "flamante" librería, pero ese programa se ha
instalado de "mala manera", bien porque el programa de instalación
sea una caca o bien porque
14
simplemente se ha instalado mal... como
quiera que ha instalado una librería anterior a la que nuestros dos
maravillosos ejecutables usan, se puede dar el caso de que ninguno de los dos
programas funcionen correctamente... esto ocurrió cuando salió el Internet
Explorer 4 y a más de uno nos trajo de cabeza, aunque también ha ocurrido con
otros programas que no han tenido en cuenta a la hora de instalar que ya existe
una versión más reciente de la librería. Por suerte, esto ya es menos común que
hace unos años, sobre todo si los programas de instalación están creados con el
Windows Installer o estamos usando el Windows 2000/XP. Pero es que .NET mejora
aún esa "imposibilidad" de meter la pata ya que cada assembly
contiene un manifiesto en el cual se indica: -el nombre y la versión del
assembly, -si este assembly depende de otros ensamblados, con lo cual se indica
hasta la versión de dichos ensamblados,
- los tipos expuestos por el assembly (clases, etc.),
- permisos de seguridad para los distintos tipos contenidos en
el assembly.
También se incluyen en los assemblies los
datos del copyright, etc.
Nuevamente he de decirte que no debes preocuparte
demasiado por esto, ya que es el propio .NET el que se encarga de que todo
funciones a las mil maravillas, o al menos esa es la intención.
La ventaja de los ensamblados es que
"realmente" no necesitan de una instalación y un registro correcto en
el registro del sistema de Windows, ya que es el "intérprete" de .NET
el que se encarga de hacer las comprobaciones cuando tiene que hacerlas. Por
tanto podríamos distribuir una aplicación sin necesidad de crear un programa de
instalación. Pero, (¿por qué siempre hay un pero?), si la aplicación usa
ensamblados compartidos, puede que sea necesario usar una instalación.
Los ensamblados compartidos se pueden usar
por varias aplicaciones diferentes y deben estar "debidamente"
instalados en el directorio asignado por el propio .NET Framework.
Ejemplo de ensamblados compartidos son los
que definen las clases (tipos) usados por el propio .NET Framework.
Para terminar esta primera entrega
introductoria al mundo .NET vamos a ver algunos conceptos que usaremos con
bastante frecuencia en el resto de las entregas:
Nota: Las palabras o conceptos están en la página del
glosario.
15
16
2. Segunda entrega
En la entrega anterior vimos
algunos conceptos generales que acompañan a esta versión de Visual Basic,
también vimos algunas palabras que usaremos durante todo este curso de iniciación, dichas
palabras están en el glosario, al cual iré añadiendo nuevas
definiciones, conforme surjan o yo me vaya acordando, así que te recomiendo que
de vez en cuando le eches un vistazo.
Ahora vamos a empezar con esta segunda
entrega del Curso de Iniciación a la programación con Visual Basic .NET
Lo primero que vamos a aprender es a saber
manejarnos un poco con el entorno de desarrollo (IDE) de Visual Studio .NET, sí
he dicho entorno de desarrollo de Visual Studio, no de Visual Basic... y no me
he confundido, ya que dicho IDE es el mismo para cualquier lenguaje .NET. Por
tanto, si además de usar el VB.NET quieres hacer tus "pinitos" con el
C# o con cualquier otro, no tendrás que abrir otro programa para cada uno de
esos lenguajes. Incluso podrás trabajar con varios proyectos a un mismo tiempo,
aunque sean de lenguajes diferentes. Además, si así lo quieres y
"sabes" cómo hacerlo, puedes crear tus propios complementos para que
se integren con el IDE de Visual Studio .NET.
Aunque eso, casi con total seguridad, no
lo veremos en este curso de iniciación.
Lo primero que vamos a hacer es cargar el
entorno de desarrollo del Visual Studio .NET, así que... ya puedes abrirlo, si
es que no la has hecho ya.
En la pantalla de inicio, selecciona un
nuevo proyecto. Pero esta vez vamos a seleccionar una aplicación de Windows:
Figura
1
No te preocupes, que no te voy a complicar
la vida, simplemente vamos a tener algún tipo de proyecto cargado en el entorno
de desarrollo, ya que lo que vamos a ver es cómo modificar y configurar algunos
de los aspectos del mismo.
17
Déjale
el nombre que te muestra, ya que nos da igual cómo se llame. (el Guille está un
poco pasota,
¿verdad?)
En el proyecto, se habrá creado un
formulario, el cual seguramente te lo mostrará de forma automática. Si no se
mostrara nada y siguiera estando la pantalla de inicio... dale un respiro ya
que seguramente se lo estará pensando... en caso de que después de pensárselo
no lo mostrara tampoco... fíjate en el lado derecho de la pantalla, verás que
hay un "panel" o ventana en la que se indica el proyecto actual y se
muestran los ficheros que lo componen. Ese panel es el "Solution Explorer"
o Explorardor de Soluciones, (te digo cómo se llama en los dos idiomas, ya que, algunas de
las imágenes que te voy a mostrar están capturadas de la versión en castellano
del Visual Studio .NET y otras de la versión en inglés... así cuando la veas en
un idioma o en otro, sabrás de que estoy hablando).
Figura
2
Para que se muestre el formulario (Form1),
haz doble click en dicho "elemento" del explorador de soluciones.
Lo que vamos a hacer ahora es cambiar la separación
de los puntos que se muestran en el formulario, ese "grid" o grilla,
servirá para ajustar los controles (ya sabrás de qué hablo) que se añadan a
dicho formulario.
Por defecto la separación es de 8x8 puntos
o pixels... y vamos a ponerlo en 4x4.
Selecciona el formulario, (el cual se
supone que ya si puedes verlo), simplemente con hacer un click en él es
suficiente. Verás que tiene este aspecto:
18
Figura 3
Realmente no tendrá ese aspecto, salvo que
tengas el Windows XP, pero al aspecto que me refiero es al de la separación de los
puntos.
En el panel de la derecha, debajo del
explorador de soluciones, está la ventana de propiedades del elemento que
actualmente esté seleccionado, en nuestro caso son las propiedades del Form1.
Vamos a buscar el elemento GridSize para poder cambiar el tamaño de separación. Verás que se
muestran dos valores separados por punto y coma, pero también hay una cruz a la
izquierda de la palabra GridSize, si pulsas en esa cruz, se mostrarán los
tamaños a lo que se refiere esos valores separados por punto y coma:
Figura
4
Posiciónate en cualquiera de ellos y
asígnale el valor 4, de esta forma, tendremos un formulario con una cuadrícula
más pequeña, en la que será más fácil posicionar los controles que queramos
añadir al formulario en cuestión.
Fíjate
que después de haber cambiado esos valores, los mismos se muestran en
"negrita", indicándonos de esta forma que son valores que nosotros
hemos asignado, los que tiene por defecto. También te habrás fijado que ahora
el "grid" tiene los puntos más juntos. Si no te gusta así como está
ahora, ponlos a tu gusto. Yo los configuro a 4x4, pero tu eres libre de
ponerlos como mejor te plazca...
El
aspecto habrá cambiado a este otro, te muestro el aspecto de Windows XP y el
del Windows 2000 (clásico), aunque en resumidas cuentas, lo que hay que ver es
que los punticos esos están más arrejuntaos...
