VB.NET 2010 - Yesika Medina

Microsoft Visual Basic
2010
¿Que es .NET?
.Net es la nueva plataforma de desarrollo que ha lanzado al mercado MicroSoft, y en la que ha
estado trabajado durante los últimos años. Sin duda alguna va a ser uno de los entornos de
desarrollo que reinen durante los proximos años.
¿Entonces .NET es un lenguaje de programación?, No. Es mucho más que eso, Microsoft .NET
es un conjunto de tecnologías de software , compuesto de varios lenguajes de programación
que se ejecutan bajo el .NET Framework. Es además un entorno completamente orientado a
objetos y que es capaz de ejecutarse bajo cualquier plataforma. Vamos por partes. Podriamos
dividir el entorno .NET en las siguientes partes:
•
•
•
•
•
•
•
•
.NET Framework, que es el entorno de trabajo de la plataforma .NET y que la engloba
completamente. Toda la plataforma .NET forma parte de .NET framework.
Lenguajes .NET. Destacan C# y VB.NET,y recientemente J#, aunque existen más lenguajes y
con toda seguridad surgirán nuevos.
El Common Runtime Language CRL, que es el motor de ejecución común a todos los
lenguajes .NET.
MSIL, Microsoft Intermedial language, es el lenguaje intermedio al que compilan las apliaciones
(Asemmblies) .NET. Este lenguaje intermedio es interpretado por el CRL en tiempo de
ejecución.
CLS, common Language Specification, que engloban las pautas que deben cumplir los
lenguajes .NET. Es está característica la que va a permitir a otras compañias producir
lenguajes compatibles con .NET.
ADO.NET, es la nueva interfaz de bases de datos. No se trata de una evolución de ADO, sino
que se trata de una interfaz completamente nueva.
ASP.NET, es la nueva tecnología para páginas web dinámicas completamente integrada
dentro del entorno .NET. Representa una autentica revolución en el desarrollo Web (Internet e
Intranet).
Biblioteca de clases .NET, es el conjunto de clases que componen el .NET framework y que
nos permiten realizar casi cualquier tarea de una manera facil y rápida.
¿QUÉ ES VISUAL BASIC .NET 2010 (O VB.NET 10)?
Es un lenguaje de programación orientado a objetos, que se puede considerar una evolución
de Visual Basic (6.0) implementada sobre el framework (o marco de trabajo) .NET No es
compatible hacia atrás con Visual Basic, pero el manejo de las instrucciones es similar a
versiones anteriores de Visual Basic, pero al ser compatible con las tecnologías .NET, se
pueden obtener productos compatibles con las más recientes tecnologías.
Al igual que con todos los lenguajes de programación basados en .NET, los programas escritos
en VB .NET requieren el Framework .NET para ejecutarse.
EL .NET FRAMEWORK
El Framework de .Net es una infraestructura sobre la que se reúne todo un conjunto de
lenguajes y servicios que simplifican el desarrollo de aplicaciones. Mediante esta herramienta
se ofrece un entorno de ejecución que permite crear aplicaciones robustas y escalables. Los
principales componentes de este entorno son: Lenguajes de compilación, Biblioteca de clases
de .Net, CLR (Common Language Runtime)
Actualmente, el Framework de .Net es una plataforma no incluida en los diferentes sistemas
operativos distribuidos por Microsoft, por lo que es necesaria su instalación previa a la
ejecución de programas creados mediante .Net. El Framework se puede descargar
gratuitamente desde la web oficial de Microsoft.
.Net Framework soporta múltiples lenguajes de programación y aunque cada lenguaje tiene sus
características propias, es posible desarrollar cualquier tipo de aplicación con cualquiera de
estos lenguajes. Existen más de 30 lenguajes adaptados a .Net, desde los más conocidos
como C# (C Sharp), Visual Basic o C++ hasta otros lenguajes menos conocidos como Perl o
Cobol.
Common Language Runtime (CLR)
El CLR es el verdadero núcleo del Framework de .Net, ya que es el entorno de ejecución en el
que se cargan las aplicaciones desarrolladas en los distintos lenguajes, ampliando el conjunto
de servicios que ofrece el sistema operativo estándar Win32.
La herramienta de desarrollo compila el código fuente de cualquiera de los lenguajes
soportados por .Net en un mismo código, denominado código intermedio (MSIL, Microsoft
Intermediate Lenguaje). Para generar dicho código el compilador se basa en el Common
Language Specification (CLS) que determina las reglas necesarias para crear código MSIL
compatible con el CLR.
De esta forma, indistintamente de la herramienta de desarrollo utilizada y del lenguaje elegido,
el código generado es siempre el mismo, ya que el MSIL es el único lenguaje que entiende
directamente el CLR. Este código es transparente al desarrollo de la aplicación ya que lo
genera automáticamente el compilador. Sin embargo, el código generado en MSIL no es
código máquina y por tanto no puede ejecutarse directamente. Se necesita un segundo paso
en el que una herramienta denominada compilador JIT (Just-In-Time) genera el código
máquina real que se ejecuta en la plataforma que tenga la computadora.
De esta forma se consigue con .Net cierta independencia de la plataforma, ya que cada
plataforma puede tener su compilador JIT y crear su propio código máquina a partir del código
MSIL. La compilación JIT la realiza el CLR a medida que se invocan los métodos en el
programa y, el código ejecutable obtenido, se almacena en la memoria caché de la
computadora, siendo recompilado sólo cuando se produce algún cambio en el código fuente.
Biblioteca de clases de .Net
Cuando se está programando una aplicación muchas veces se necesitan realizar acciones
como manipulación de archivos, acceso a datos, conocer el estado del sistema, implementar
seguridad, etc. El Framework organiza toda la funcionalidad del sistema operativo en un
espacio de nombres jerárquico de forma que a la hora de programar resulta bastante sencillo
encontrar lo que se necesita.
Para ello, el Framework posee un sistema de tipos universal, denominado Common Type
System (CTS). Este sistema permite que el programador pueda interactuar los tipos que se
incluyen en el propio Framework (biblioteca de clases de .Net) con los creados por él mismo
(clases). De esta forma se aprovechan las ventajas propias de la programación orientada a
objetos, como la herencia de clases predefinidas para crear nuevas clases, o el polimorfismo
de clases para modificar o ampliar funcionalidades de clases ya existentes.
La biblioteca de clases de .Net Framework incluye, entre otros, tres componentes clave:
• ASP.NET para construir aplicaciones y servicios Web.
• Windows Forms para desarrollar interfaces de usuario.
• ADO.NET para conectar las aplicaciones a bases de datos.
La forma de organizar la biblioteca de clases de .Net dentro del código es a través de los
espacios de nombres (namespaces), donde cada clase está organizada en espacios de
nombres según su funcionalidad. Por ejemplo, para manejar ficheros se utiliza el espacio de
nombres System.IO y si lo que se quiere es obtener información de una fuente de datos se
utilizará el espacio de nombres System.Data.
La principal ventaja de los espacios de nombres de .Net es que de esta forma se tiene toda la
bliblioteca de clases de .Net centralizada bajo el mismo espacio de nombres (System).
Además, desde cualquier lenguaje se usa la misma sintaxis de invocación, ya que a todos los
lenguajes se aplica la misma biblioteca de clases.
Ensamblados
Uno de los mayores problemas de las aplicaciones actuales es que en muchos casos tienen
que tratar con diferentes archivos binarios (DLL´s), elementos de registro, conectividad abierta
a bases de datos (ODBC), etc. Para solucionarlo el Framework de .Net maneja un nuevo
concepto denominado ensamblado. Los ensamblados son ficheros con forma de EXE o DLL
que contienen toda la funcionalidad de la aplicación de forma encapsulada. Por tanto la
solución al problema puede ser tan fácil como copiar todos los ensamblados en el directorio de
la aplicación.
Con los ensamblados ya no es necesario registrar los componentes de la aplicación. Esto se
debe a que los ensamblados almacenan dentro de si mismos toda la información necesaria en
lo que se denomina el manifiesto del ensamblado. El manifiesto recoge todos los métodos y
propiedades en forma de meta-datos junto con otra información descriptiva, como permisos,
dependencias, etc.
INICIANDO VISUAL BASIC .NET Y CREANDO EL PROYECTO
Nota: Se asumirá que se cuenta con un equipo de última generación con Visual Basic .NET
2010 (que se incluye en Visual Studio .NET 2010). También puede descargar la versión
Express de este producto.
1. Para iniciar Visual Basic .NET 2010, deberá clickear en el menú Inicio de Windows, luego en
“Todos los Programas” y posteriormente en el grupo de programas “Microsoft Visual Studio
2010, y finalmente en “Microsoft Visual Studio 2010”.
En este momento, se mostrará la pantalla de bienvenida del Entorno Integrado de Desarrollo
(IDE) de Visual Studio 2010.
En este momento, procederemos a crear una “Nueva aplicación para Windows” utilizando el
lenguaje de programación Visual Basic 2010. Para ello, haga clic en el menú “Archivo” y luego
“Nuevo Proyecto” (o presione Control+U). Allí, se mostrará la siguiente ventana:
2. Vaya a la sección izquierda y clickee en la categoría “Visual Basic” y luego, en la región
derecha, seleccione en “Aplicación de Windows Forms”. Finalmente, en la parte inferior de la
pantalla, diríjase al cuadro de texto “Nombre” y escriba el nombre que tendrá nuestro proyecto.
En este caso, colocaremos “sistema” (todo en minúscula), tal como se aprecia en la siguiente
figura:
3. Y finalmente presionamos el botón “Aceptar” para crear el proyecto.
Un proyecto es una colección de archivos (código fuente, imágenes y demás archivos) que el
programador o diseñador de software integra para dar origen al producto final (software)
deseado.
3. Una vez que hemos dado nombre al proyecto, se muestra el entorno de desarrollo integrado,
el cual es un conjunto de herramientas que al trabajar de manera integrada, facilitan el diseño,
codificación, prueba, depuración y demás actividades relacionadas con el desarrollo de
software. A continuación se describen cada una de sus partes:
Cuadro de
herramientas
Menú
Principal
Barras de
herramientas
Explorador
de Soluciones
Formulario
Escritorio
Orígenes de datos
Ventana
Propiedades
Barra de Estado
Escritorio: Es el área blanca que sirve de “soporte” a los elementos que componen el entorno
integrado de desarrollo. No confundir con el escritorio de Windows.
Menú Principal: Es el listado de opciones que permiten desencadenar las distintas acciones
permitidas por el IDE. Es muy similar al de otros programas Windows como Word o Excel, pero
con posibilidades para crear o abrir proyectos, depurar archivos, ejecutar complementos entre
muchas otras posibilidades.
Barras de Herramientas: Contiene métodos abreviados para realizar distintas actividades
referentes al desarrollo del proyecto. Su funcionamiento es muy similar al de otras aplicaciones
Windows.
Formulario: Es el principal objeto contenedor de Visual Basic donde se pueden “dibujar” las
interfaces a modo de ventanas y que pueden contener otros objetos que tienen diversos
comportamientos. Así como en Word existe el documento en blanco sobre el cual, el usuario
comienza a escribir, en Visual Basic existe el formulario.
Cuadro de Herramientas: Es una sección que aparece como una “pestaña” al lado izquierdo
de la ventana principal del IDE. Al clickear sobre ella, se pueden observar una serie de iconos
que representan “clases”, las cuales pueden crear objetos dentro del formulario. Se clasifican
por categorías y abarcan desde etiquetas y cuadros de texto hasta objetos para acceso a
datos.
Orígenes de Datos: Es una sección que permite configurar la accesibilidad hacia bases de
datos (por ejemplo, SQL Server). Abarca la creación de orígenes de datos, creación de bases
de datos, tablas y demás elementos relacionados para utilizarlos dentro de la solución o
proyecto.
Explorador de soluciones: Proporciona una vista organizada de los proyectos y sus archivos,
así como acceso rápido a los comandos relativos a ellos. Normalmente, una barra de
herramientas asociada a esta ventana ofrece los comandos que se utilizan con más frecuencia
con el elemento resaltado en la lista.
Ventana Propiedades: Utilice esta ventana para ver las propiedades de los elementos
seleccionados. También puede utilizarla para ver las propiedades de archivos, proyectos y
soluciones.
Barra de Estado: Muestra el estado de la ejecución de un proceso o actividad dentro del
entorno de trabajo.
LOS OBJETOS BÁSICOS DE VB.NET
Visual Basic.NET permite insertar una gran diversidad de objetos que están dotados de
distintas funcionalidades. A continuación, se presentan algunos de ellos:
OBJETO
DESCRIPCIÓN
Permite activar la selección de objetos dentro del formulario.
Su función es permitir al usuario desplegar un conjunto de acciones al clickear sobre él. Es
muy común encontrar botones de comando como Aceptar o Cancelar. No permite el
ingreso de datos por el usuario en tiempo de ejecución
(Botón de comando)
Inserta una etiqueta de texto que sirve para identificar otros objetos. No permite el ingreso
de datos por el usuario en tiempo de ejecución
(Etiqueta)
Crea un cuadro combinado (textbox+listbox) en el cual, se puede escribir texto y seleccionar
elementos de una lista. Presentan una flecha hacia abajo en la parte derecha del cuadro
que al ser clickeada, muestra la lista.
(Cuadro combinado)
El cuadro de lista presenta un listado de elementos de los cuales se puede elegir uno o
varios según se requiera, pero no permite escritura como en el caso del combobox.
(Cuadro de lista)
(Cuadro de
máscara)
texto
y
Es un cuadro de texto, pero con una máscara de entrada. Se puede utilizar para restringir el
ingreso de ciertos caracteres (por ejemplo, una fecha en formato específico) u ocultar los
caracteres ingresados mostrando otros (como una contraseña).
Permite la inserción de imágenes dentro de un formulario. Por ejemplo, una fotografía.
Algunos formatos soportados son el bmp, jpg y png.
(Caja de dibujo)
Es el objeto primordial para ingreso de texto. Representa un recuadro donde el usuario
puede ingresar un valor que se almacena como una cadena de caracteres.
(Cuadro de texto)
(Botón de opción)
Los Botones de opción se utilizan para crear conjuntos de opciones dentro de las cuales,
sólo se podrá elegir una de ellas, siendo mutuamente excluyentes. Por ejemplo, una
persona no puede tener simultáneamente el sexo “Masculino” y “Femenino”.
Es una barra de progreso que permite mostrar el avance de un proceso en ejecución. Su
uso es típico en los programas de instalación.
(Barra de progreso)
ACCESO A DATOS DESDE VB.NET
En este curso, se creará una pequeña aplicación que conste de un formulario vinculado hacia
una base de datos de Microsoft Access 2010, de tal manera que será necesario que Visual
Basic .NET se “conecte” a ella. Para ello, el Visual Studio .NET provee una serie de
herramientas para acceso a datos, entre las cuales se encuentra el ADO.NET.
1. Para activar el ADO.NET, diríjase al
menú “Proyecto” y luego, haga click en
“Agregar Referencia”, de tal manera que se
muestre la siguiente figura:
Este cuadro de diálogo muestra la lista de
componentes que se pueden utilizar dentro
de las aplicaciones .NET, separados por
fichas:
NET: Son las que corresponden a clases de
Visual Studio.NET
COM: Corresponden al “antiguo” modelo de objetos OCX de versiones anteriores de Visual
Basic.
Proyecto: Corresponde a proyectos de VS.NET que pueden insertarse dentro de nuestra
aplicación y EXAMINAR la utilizaremos cuando queramos vincular una biblioteca (dll), objeto
(ocx) específico a nuestro proyecto.
2. Seleccione la ficha “NET” y allí, posiciónese sobre el ítem “adodb” tal como se muestra:
3. Finalmente, haga click en Aceptar y ya la
referencia habrá sido agregada al proyecto,
permitiendo vincular datos al mismo.
Nota: Si desea agregar varias referencias al
mismo tiempo, puede seleccionar varios
elementos
de
la
lista
manteniendo
presionada la tecla CTRL y clickeando sobre
cada ítem de ella.
3. Ya estamos listos para empezar a trabajar con datos desde Visual Basic .NET 2010.
Específicamente, en este curso aprenderemos cómo vincularnos con Access 2010 aunque
ADO.NET permite conectividad con numerosos motores de bases de datos como SQL Server y
MySQL entre otros.
Es importante que antes de conectarnos con cualquier motor de bases de datos, revisemos la
documentación respectiva, ya que cada uno tiene características propias y de compatibilidad
con Visual Studio.NET y más específicamente con VB.NET
INSERTANDO OBJETOS EN NUESTRO FORMULARIO
Se pretende crear una pequeña aplicación que conste de un formulario con acceso a datos
donde el usuario puede crear, editar, eliminar y consultar registros de una tabla de “alumnos”
dentro de una base de datos de Access llamada “central”. Primeramente, debemos saber cómo
se insertan los objetos en nuestro formulario.
1. Insertaremos un label en nuestro formulario. Para ello, abrimos el cuadro de controles (nos
posicionamos con el mouse sobre la pestaña “cuadro de herramientas” que está a la izquierda
de la pantalla) y allí se abrirá la paleta de controles.
2. Ubicamos el icono
(que es el objeto que deseamos insertar).
3. Haga doble click sobre el icono identificado en el paso anterior (Label) y allí se insertará un
objeto de tipo “Etiqueta” en la esquina superior izquierda del
formulario.
4. Arrastre el objeto “Label1” un poco
hacia abajo, tal como se muestra en la
siguiente figura:
5. También puede insertar un objeto en el formulario yendo al cuadro de herramientas y
haciendo un clic sobre el control deseado, luego, ir al formulario y arrastrar de izquierda a
derecha el puntero de forma tal que el objeto quede dibujado sobre éste.
MODIFICACIÓN DE LAS PROPIEDADES DE LOS OBJETOS
Una propiedad es una característica de un objeto. Así como los seres humanos tienen una
altura, color de ojos, color de cabello, etc; los objetos también poseen características que
varían en su valor. Por ejemplo, la altura viene dada por un número (1.80) y una unidad (cms),
mientras que el color viene dado por una “palabra” como “negro” o “verde”; lo que quiere decir,
que una propiedad de objeto recibe un valor, tal como a una variable se le asigna un dato.
Las propiedades de los objetos vienen preestablecidas por el lenguaje y son visibles en la
ventana “propiedades” de Visual Studio. Si queremos visualizar las propiedades de un objeto
cualquiera, debemos seleccionarlo (haciendo un clic sobre él) y observar la ventana
propiedades (la que aparece si presionamos F4)
Ahora, modifiquemos algunas propiedades del formulario que tenemos en la pantalla:
1. Haga un clic sobre el formulario (no sobre la etiqueta que acabamos de agregar)
2. Si no se ha mostrado la ventana propiedades en el lado derecho de la pantalla, actívela
presionando F4.
Las propiedades aparecen en orden alfabético A-Z y pueden ser modificadas en tiempo de
diseño. Las mismas, aparecen en inglés. Esto se debe a compatibilidad con otros lenguajes VS
e incluso versiones anteriores.
No es absolutamente necesario que las aprenda o memorice, ya que cada objeto tiene sus
propiedades típicas y esenciales. Basta con haber instalado el sistema de ayuda o consultar
vía internet en caso de alguna duda.
A continuación, se describen las partes de la ventana propiedades con mayor detalle:
Nombre del
objeto
seleccionado y
Espacio de
nombres
Nombres de las
propiedades
Valores
asignados a cada
propiedad
Descripción de la
propiedad
seleccionada
En la parte superior se muestra una lista desplegable con el nombre del objeto y el espacio de
nombres del cual proviene. En el caso de la figura, dado que se trata una aplicación para
Windows, se observa “System.Windows.Forms….”
Esta lista desplegable también puede ser utilizada para seleccionar un objeto del formulario
directamente desde la ventana propiedades (sin clickear sobre el objeto del formulario).
En la parte izquierda se visualizan los nombres de las propiedades del objeto, por ejemplo:
Text, Tag, WindowState, etc.
Al lado de cada propiedad se encuentra el valor asignado a ella. En el ejemplo, se visualiza la
propiedad “Text” y su valor “Form1”, así como también ShowInTaskBar con True. Cabe
destacar que algunas propiedades reciben una cadena de caracteres, otras valores lógicos
(True/False) o numéricos como en el caso de Height y Width (altura, anchura).
Algunos especialistas aseguran que las propiedades deben pensarse como variables debido a
que a éstas también se le asignan valores de diversos tipos. El tipo de datos de estos valores,
dependerá entonces de la naturaleza de la propiedad, por lo que se recomienda documentarse
un poco sobre su utilización.
3. Ahora bien, es el momento de modificar algunas propiedades de nuestro formulario. Si aún
no lo hemos seleccionado, hagamos un click sobre él e inmediatamente dirijámonos a la
ventana propiedades.
4. Busquemos la propiedad Text y coloquemos la frase “Mantenimiento de Alumnos” (sin
comillas). Esto cambiará el título de nuestra ventana.
5. Ahora, vayamos a la propiedad MaximizeBox y seleccionamos el valor False. Esto para
evitar que nuestro formulario tenga el botón Maximizar.
6. Luego, en la propiedad StartUpPosition seleccione el valor CenterScreen para que la
ventana aparezca en el centro de la pantalla cuando nuestra aplicación se ejecute. Recuerde
que aún estamos en tiempo de diseño.
7. Ahora, es el momento de asignar el Nombre del objeto (Name), propiedad de mucha
importancia, ya que a través de él, haremos referencia a dicho objeto a nivel de código. En el
caso de nuestro formulario, lo llamaremos frmAlumnos.
Así como los seres humanos tienen características únicas (por ejemplo el número de cédula)
que no es compartido por ningún otro, por lo menos en el mismo País, los objetos tienen una
propiedad que es el nombre (o name) cuyo valor no puede ser compartido por ningún otro
objeto dentro del mismo formulario. En otras palabras, dos o más objetos no pueden tener el
mismo nombre dentro del mismo formulario.
Para asignar el nombre a un objeto, deben seguirse una serie de reglas, entre las cuales
tenemos:
a. El nombre de un objeto no distingue entre mayúsculas y minúsculas. Es lo mismo escribir
“TXTCEDULA” que “txtCedula”, aunque por razones de estética, se recomienda el uso de
minúsculas para el prefijo, mayúscula para la inicial del nombre y el resto en minúsculas.
b. El nombre no puede quedar en blanco y tampoco empezar con números
c. El nombre no puede ser una palabra reservada o propia del lenguaje. Ejm: “function”
d. No deben tener caracteres especiales ($,#, ¡) por ejemplo.
e. Deben ser descriptivos de su contenido, aunque no demasiado largos para su comprensión
f. No deben tener espacios en blanco. Si necesita separar palabras, utilice el guion bajo (_)
g. Es altamente recomendado que se utilice un prefijo en el nombre del objeto y éste debe
estar asociado al tipo al que corresponde, naturaleza o funcionalidad.
Durante años, se han utilizado prefijos que sin ser estándares, se han vuelto costumbre y
obligación entre los programadores no sólo de Visual Basic, sino de otras herramientas. Ellos
son:
PREFIJO
frm
lbl
txt
cmd
cmb
opt
pgr
pic
msk
TIPO DE OBJETO
Formulario
Etiqueta (label)
Cuadro de texto (textbox)
Botón de comando (button o command button)
Cuadro combinado (combobox)
Botón de opción (Radiobutton)
Barra de progreso (Progressbar)
Cuadro de imagen (Picturebox)
Cuadro de texto enmascarado (Masked Textbox)
EJEMPLO
frmAlumnos
lblCedula
txtCedula
cmdGuardar
cmbEstadoCivil
optMasculino
pgrAvance
picFotoEmpleado
mskNumCuenta
El uso de los prefijos tiene su importancia en el hecho de que en un formulario pueden existir
muchos objetos de diversos tipos. Sería confuso llamar a un objeto “Cédula” y luego escribir
código asociado a él, ya que no sabríamos si se trata de un cuadro de texto o una etiqueta.
Entonces sería más descriptivo escribir txtCedula e identificar al objeto como un textbox sin
necesidad de tener que ir al formulario y visualizar el objeto en cuestión.
A continuación se muestran algunos nombres de objeto con errores comunes:
NOMBRE
ERROR
frmFormularioPrincipal Redundancia. Sólo con el prefijo frm sabemos que es un formulario
2lblNombre
Comienza con un número
txtNombre Alumno
Tiene un espacio en blanco entre las palabras “Nombre” y “Alumno”
cmdCommand1
Aun cuando tiene prefijo, el nombre no es descriptivo de su función
Sub
La palabra “Sub” está reservada por el lenguaje Visual Basic
pic$Foto
Contiene un carácter especial $
TXTcedulaALUMNO
El nombre es correcto, pero no es muy estético y genera confusión
DIBUJANDO NUESTRA INTERFAZ
Ahora que sabemos cómo insertar objetos en nuestro formulario, comenzaremos a “dibujar”
todos los objetos que contendrá. Recordemos que ya tenemos una etiqueta llamada “Label1”.
1. Primeramente, hagamos un clic sobre ella y quedará seleccionada.
2. Luego, vayamos a la ventana propiedades (si no se muestra, presione F4).
3. Ubicamos la propiedad Name. El nombre a asignar será lblCedula
4. Ahora, vayamos a la propiedad
Text y coloquemos el valor
“Cédula” (sin comillas y puede
incluir el acento).
5. En este momento, el objeto
cambiará el texto de Label1 a
Cédula.
El formulario quedará como se
muestra en la siguiente figura:
Ahora, procedamos a agregar el resto de los objetos
que necesitamos para que nuestro formulario quede
listo para recibir el código. En la siguiente tabla se
indican los nombres de objetos, tipos y otras
propiedades que usted deberá ajustar.
Recuerde que para insertar un objeto debe ir al
cuadro de herramientas y hacer doble clic sobre el
icono del tipo de objeto que desea insertar, sea un
cuadro de texto, botón, etc.
Así mismo, en la tabla no aparece el label “Cédula” puesto que ya lo hemos agregado
anteriormente.
TIPO DE OBJETO
PROPIEDAD
VALOR
Label
Name
Text
lblNombre
“Nombre” (sin comillas)
Label
Name
Text
lblApellido
“Apellido” (sin comillas)
Label
Name
Text
lblDir
“Dirección” (sin comillas)
Label
Name
Text
lblTelf
“Teléfono” (sin comillas)
Label
Name
Text
lblTelf
“Teléfono” (sin comillas)
6. Ahora, es el turno de los cuadros de texto (textboxes). Nota: El texto de la propiedad Text se
borrará dejando la propiedad vacía.
TIPO DE OBJETO
PROPIEDAD
VALOR
TextBox
Name
Text
txtCedula
“” (Vacío)
TextBox
Name
Text
txtNombre
“”
TextBox
Name
Text
txtApellido
“”
TextBox
Name
Text
txtDir
“”
TextBox
Name
Text
txtTelf
“”
Nota: Todos los textboxes deberán tener además, la propiedad Enabled a False.
7. Procedamos ahora a incluir los botones de comando (buttons) que desplegarán las acciones
en el formulario.
TIPO DE OBJETO
PROPIEDAD
VALOR
Button
Name
Text
cmdAgregar
Agregar
TextBox
Name
Text
cmdModificar
Modificar
TextBox
Name
Text
cmdEliminar
Eliminar
TextBox
Name
Text
cmdBuscar
Buscar
TextBox
Name
Text
cmdBuscar
Buscar
TextBox
Name
Text
cmdCerrar
Cerrar
Name
Text
Enabled
cmdGuardar
Guardar
False
Name
Text
Enabled
cmdCancelar
Cancelar
False
TextBox
TextBox
Al terminar de ajustar las propiedades, sólo basta ajustar algunos detalles estéticos como el
tamaño de los cuadros de texto (trate de dejarlos todos del mismo tamaño). Para ello, utilice el
mouse como si de ajustar una imagen se tratara.
El producto final queda de la siguiente manera:
Es importante resaltar
que todos los botones
de comando deben
estar con la propiedad
Enabled establecida
a True, exceptuando
los
botones
cmdGuardar
y
cmdCancelar,
los
cuales deben estar
con
la
propiedad
Enabled establecida
a False.
Es un buen momento
para
guardar
los
cambios
en
el
proyecto. Presione el icono del disquete en la barra de herramientas (o CTRL+S)
UN VISTAZO A LAS PROPIEDADES QUE HEMOS UTILIZADO
Como se habrá dado cuenta, hemos utilizado algunas propiedades al momento de diseñar
nuestra interfaz. De allí, es importante conocer su significado de cada una de ellas y algunos
detalles que facilitarán nuestro trabajo.
Name: Indica el nombre del objeto. Este punto fue tratado extensivamente en un apartado
anterior. Aplica para todos los objetos.
MaximizeBox / MinimizeBox: Permite que el formulario muestre los botones de Maximizar y
Minimizar. Aplica al objeto Form.
Enabled: Activa o desactiva un objeto para que el usuario pueda posicionarse o escribir sobre
él. Aplica a los textboxes, combos, forms, entre muchos otros.
StartupPosition: Indica en qué posición se desea que el formulario se muestre cuando se
ejecute. Si se quiere que aparezca en el centro de la pantalla, seleccione “CenterScreen”.
ShowInTaskBar: Indica si el formulario debe mostrarse en la barra de tareas o no. Aplica al
objeto Forn.
Height / Width: Alto / Ancho de un objeto. Indican las dimensiones de un objeto. Aparecen
como detalle de la propiedad Size. Aplica para distintos tipos de objetos.
Text: Importante propiedad que almacena el valor ingresado en un textbox (el que el usuario
ingresa), o bien, el titulo o leyenda de un objeto. Por lo tanto, no debe confundirse con el
Name, ya que el Text es una cadena de caracteres que en la mayoría de los casos es visible
en tiempo de diseño y ejecución, además, permite el uso de espacios en blanco y caracteres
especiales.
En otras palabras, si deseamos saber qué valor ha ingresado el usuario en el cuadro de texto
con el nombre txtCedula, debemos leer la propiedad Text del referido objeto.
PERSPECTIVA DEL PROGRAMA (¿QUÉ DEBE HACER Y CÓMO LO HARÁ?)
El programa debe permitir el ingreso, actualización, eliminación y consulta de datos de los
alumnos de un colegio. Al inicio, todos los cuadros de texto deben estar desactivados y sólo se
activarán cuando el usuario desee agregar o modificar datos. En tal caso, los únicos botones
que deben quedar activos son Guardar y Cancelar, ya que durante una operación de edición o
agregación sólo se pueden almacenar los datos o deshacerlos.
Al inicio, los botones Nuevo, Modificar, Eliminar, Cerrar y Buscar, deben estar activos ya que se
espera que el usuario desencadene una de estas acciones, estando inactivos los botones
Guardar y Cancelar.
Luego de una operación de agregación o modificación, cuando el usuario selecciona Guardar o
Cancelar, se regresan todos los cuadros de texto a su estado inactivo y los botones Nuevo,
Modificar, Eliminar, Cerrar y Buscar, se activan; desactivando entonces a Guardar y Cancelar.
ADICIÓN DEL CÓDIGO A NUESTRO FORMULARIO.
Es el momento de codificar los objetos del formulario para conectarnos a nuestra base de datos
“central” (de Access 2010), específicamente a la tabla “alumnos”. Para ello, hagamos doble
click sobre cualquier área libre de nuestro formulario. Al hacer esto, aparecerá la siguiente
ventana:
Esta
es
la
ventana
“Código” donde podrá
agregar las instrucciones
necesarias para que su
aplicación funcione según
sus necesidades.
No elimine el código que
el IDE de Visual Studio ha agregado por usted, ya que son instrucciones propias de lenguaje
sobre los objetos que ha insertado.
En la figura se muestran las siguientes estructuras:
Public Class frmAlumnos
Private Sub frmAlumnos_Load(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles MyBase.Load
End Sub
End Class
El Public Class nos indica que se ha definido una Clase llamada frmAlumnos. Una clase es
una plantilla u objeto base sobre la que se habrá de “hacer algo”. Recuerde algunas
definiciones básicas de la programación orientada a objetos.
El Public Class deberá terminar con su respectivo End Class.
Así mismo, se observa un Private Sub frmAlumnos_Load(….) que define un Procedimiento
de Evento llamado frmAlumnos_Load, es decir, un conjunto de instrucciones que se
ejecutarán cuando el formulario se “carga” en memoria.
Un Procedimiento de Evento es un conjunto de instrucciones o código que se ejecutará en
determinado momento y que no devuelve ningún valor. Por ejemplo, si se desea mostrar un
mensaje o cualquier otra acción que se nos pueda ocurrir. No debe confundirse con una
Función que es una serie de instrucciones pero que si devuelven valores. Por ejemplo, si
invocamos la función Raiz_Cuadrada(4), esperaremos que nos devuelva el valor 2.
Cuando se abre un Private Sub debe cerrarse con un End Sub. De lo contrario, se generará
un error. No debe borrar las líneas Private Sub ni End Sub.
Algunos Provedimientos de Evento (o Sub) reciben valores para que puedan hacer lo que
tienen programado. Visual Basic nos coloca automáticamente cuáles son esos valores
llamados Parámetros. Los podemos visualizar en la línea:
Private Sub frmAlumnos_Load(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles MyBase.Load
Entiéndase que los parámetros son los que están encerrados entre paréntesis y tampoco
deben ser cambiados por el programador, aunque los valores que reciben si pueden utilizarse a
conveniencia.
1. Ahora, ubíquese en la línea Public Class frmAlumnos y agregue unas 2 o 3 lineas de
código en blanco (presione ENTER al final de la palabra frmAlumnos) tal como lo haría en
Word, luego, agrégue las siguientes líneas de código:
Public db As New ADODB.Connection 'Declara variable publica de conexion
Public rst As New ADODB.Recordset 'Declara variable publica de recordset
Lo primero que observamos, es la declaración de dos variables públicas, una para abrir la
conexión hacia nuestra base de datos y otra para “abrir” la tabla o conjunto de registros que
necesitamos. Vayamos paso a paso…
En Visual Basic (con las librerías de ADO.NET) existe un objeto llamado Connection que es
invisible en tiempo de diseño y de ejecución, pero que nos permite conectarnos con algunos
motores de bases de datos (como Access). De allí que se declara una variable llamada db
como un objeto NUEVO (New) ADODB.Connection.
Este objeto también tiene propiedades que podemos utilizar (se verán posteriormente) y
muchas otras bondades.
Cabe destacar que una Variable podría definirse como un objeto de programa que almacena
un valor temporalmente (en memoria) y que podemos utilizar para realizar algún cálculo o
acción cualquiera. Por ejemplo, si deseásemos almacenar la edad de una persona en memoria,
podríamos declarar una variable llamada Edad y colocarle el valor 30 en números. Edad=30.
Así, quedaría establecido el valor 30 a la variable que hemos dispuesto.
Las variables pueden tener distintos tipos de datos y para nombrarlas se seguirán los mismos
lineamientos de los nombres de objetos. Los tipos de datos soportados por VB.NET 2010 se
muestran al final de esta guía
En el mismo orden de ideas, para declarar una variable de cualquier tipo se utiliza la palabra
reservada DIM y la siguiente sintaxis:
Dim Nombre_Variable AS [NEW] Tipo_de_Datos
Dim: Es la palabra “mágica” para declarar una variable
Nombre_Variable: Indica el nombre de la variable que se declara. Siga los mismos
convencionalismos que los nombres de objeto.
AS: Significa “como…” es decir, declarar la variable “X” como… (para luego indicar el tipo de
datos)
NEW: Palabra opcional utilizada para declarar variables de algunos tipos de objetos como
Connection y Recordset. Indica que la variable declarada hace referencia a un objeto.
Tipo_de_Datos: Indica el tipo de datos que se le asignará a la variable. Puede ser un String
(Cadena de caracteres), Byte, Date (Fecha) o cualquier tipo permitido.
2. Es el momento de agregar el código para abrir la conexión a la base de datos. Es importante
que tenga en cuenta lo siguiente:
El archivo de la base de datos debe llamarse “central.accdb” y debe estar ubicado en la carpeta
\debug del proyecto, en este caso:
C:\Documents and Settings\Administrador\Mis documentos\Visual Studio 2010\Projects\sistema\sistema\bin\Debug
De no ser así, podría generarse un error al momento de ejecutar el programa, ya que no podría
encontrar la base de datos.
3. Ahora, agregue las siguientes líneas de código dentro del procedimiento Private Sub
frmAlumnos_Load
db.ConnectionString = "Provider =Microsoft.ACE.OLEDB.12.0; Data Source =" &
Application.StartupPath & "\sistema.accdb; Persist Security Info =False;"
db.Open()
Nota: La instrucción db.ConnectionString se escribirá toda en una línea, ya que por razones de
espacio, en esta guía abarca 2 líneas. Así mismo, la instrucción db.open() debe estar en una
línea independiente de la anterior.
Al analizar un poco el código, se tiene que el objeto db tiene una propiedad llamada
ConnectionString que no es más que una Cadena de Conexión, es decir, una cadena de
caracteres de uso especial donde se le indica a Visual Basic (o mejor dicho, a ADO.NET) la
ubicación de la base de datos, el motor al cual pertenece e inclusive algunos parámetros de
seguridad.
La cadena de conexión utilizada en este ejemplo es válida para Access 2007 y 2010. Si se
desea utilizar versiones anteriores u otros motores de bases de datos como MySQL, SQL
Server, ORACLE o similar, debe buscar la documentación pertinente.
En la página http://www.connectionstrings.com/ podrá encontrar las cadenas de conexión
que necesite para numerosos gestores de bases de datos.
Las partes de la cadena de conexión son:
a. El Proveedor (Provider o motor de Bases de datos). En este caso es OLEDB.12.0
b. El Origen de Datos (Data Source). Es decir, la ruta donde se encuentra nuestro archivo de
bases de datos. Nótese que se utiliza la instrucción Application.StartupPath para obtener
automáticamente la ruta desde donde se está ejecutando nuestra aplicación, asumiendo que
es la misma donde se encuentra la base de datos.
c. Opciones Adicionales: Dependen de cada motor de bases de datos. Por ejemplo, si la base
de datos tiene contraseña, debemos especificar el Password.
4. Finalmente, se observa la instrucción db.Open que abrirá propiamente la conexión y la base
de datos quedará lista para ser utilizada por nuestro formulario.
Es importante resaltar que estas instrucciones se han colocado en el evento Load para que se
ejecuten cuando el formulario se carga en memoria.
5. Procedamos ahora a escribir el código del botón cmdAgregar, específicamente, en el
evento Click(). Para ello, hagamos doble click sobre nuestro botón cmdAgregar y veremos
que se abre la siguiente ventana:
6. Es el momento de copier el siguiente código en el procedimiento cmdAgregar_Click(..)
Me.txtApellido.Enabled = True
Me.txtNombre.Enabled = True
Me.txtCedula.Enabled = True
Me.txtDir.Enabled = True
Me.txtTelf.Enabled = True
Me.txtApellido.Text = ""
Me.txtNombre.Text = ""
Me.txtCedula.Text = ""
Me.txtDir.Text = ""
Me.txtTelf.Text = ""
Me.cmdAgregar.Enabled = False
Me.cmdModificar.Enabled = False
Me.cmdBuscar.Enabled = False
Me.cmdEliminar.Enabled = False
Me.cmdCerrar.Enabled = False
Me.cmdGuardar.Enabled = True
Me.cmdCancelar.Enabled = True
Básicamente, lo que se hace en este código es activar todos los cuadros de texto para que el
usuario pueda escribir sobre ellos (Enabled=True) y se limpia el contenido para que queden en
blanco (se establece la propiedad Text a “” que indica “vacío”).
Nótese el uso de la palabra reservada Me que no es más que una referencia al formulario
actual (en este caso, frmAlumnos). Recordemos que por herencia, el objeto formulario (Me),
”contiene” el resto de los objetos como cuadros de texto y botones.
Finalmente, se activan solamente los botones para Guardar y Cancelar ya que serán las
únicas opciones permitidas al agregar nuevos registros a la base de datos (Enabled=True) y
se desactiva el resto de los botones.
7. Ahora, haga doble clic sobre el botón cmdModificar y escriba el código en el evento
Click(…) que se muestra a continuación:
Me.txtApellido.Enabled = True
Me.txtNombre.Enabled = True
Me.txtDir.Enabled = True
Me.txtTelf.Enabled = True
Me.cmdAgregar.Enabled = False
Me.cmdModificar.Enabled = False
Me.cmdBuscar.Enabled = False
Me.cmdEliminar.Enabled = False
Me.cmdCerrar.Enabled = False
Me.cmdGuardar.Enabled = True
Me.cmdCancelar.Enabled = True
En este botón lo único que hacemos es activar los cuadros de texto (excluyendo txtCedula) ya
que cuando editamos un registro, no “debemos” cambiar el valor del campo clave de la tabla
por razones de integridad de datos. Además, es importante destacar que como estaríamos
editando un registro, sólo permitimos los botones cmdGuardar y cmdCancelar, dejando el
resto inactivo.
8. Ahora, agregamos el código del botón cmdCancelar, específicamente en el evento Click(..).
Hacemos doble clic sobre este botón y allí, copiamos el siguiente código:
Me.txtApellido.Enabled = False
Me.txtNombre.Enabled = False
Me.txtCedula.Enabled = False
Me.txtDir.Enabled = False
Me.txtTelf.Enabled = False
Me.txtApellido.Text = ""
Me.txtNombre.Text = ""
Me.txtCedula.Text = ""
Me.txtDir.Text = ""
Me.txtTelf.Text = ""
Me.cmdAgregar.Enabled = True
Me.cmdModificar.Enabled = True
Me.cmdBuscar.Enabled = True
Me.cmdEliminar.Enabled = True
Me.cmdCerrar.Enabled = True
Me.cmdGuardar.Enabled = False
Me.cmdCancelar.Enabled = False
Es importante revisar el hecho de que como se está cancelando la edición de un registro,
desactivamos los cuadros de texto, limpiamos su contenido para evitar que se muestren
valores de registros anteriores y en cuanto a la botonera, volvemos cada botón a su estado
inicial, desactivando a cmdGuardar y cmdCancelar, dejando activos a los demás. Esto
permitirá que el usuario puede agregar, modificar, eliminar o buscar según lo requiera.
9. Ahora, agregamos el código del botón cmdCerrar, específicamente en el evento Click(..).
Este servirá para terminar la ejecución de nuestra aplicación.
Application.Exit()
Es importante destacar que no es lo mismo cerrar una aplicación (Terminarla) que cerrar un
formulario (destruirlo o descargarlo de memoria). En este caso, se utiliza la instrucción
Application.Exit() para terminar nuestra aplicación, ya que por ahora sólo tiene un formulario.
Sin embargo, para aquellas aplicaciones donde tengamos muchos forms y sólo deseemos
cerrar el actual, dejando la ventana principal abierta, es conveniente utilizar la instrucción
Me.Close()
10. Procedamos Entonces a agregar el código del botón cmdGuardar (Evento Click( )). Es
importante resaltar que en este procedimiento, se conectará con la tabla alumnos de la base
de datos previamente creada. (sistema.accdb).
Antes de describir el código, veamos algunas estructuras básicas que utilizaremos…
Primeramente, la estructura condicional if la cual, permite evaluar una condición y tomar uno
de dos caminos posibles (nunca ambos). Su sintaxis es la siguiente…
If condición then
Instrucciones
Else
Instrucciones
End if
La condición se evalúa y si resulta verdadera, se ejecuta el primer bloque de instrucciones (el
que está antes del Else). De lo contrario, (es decir, si la condición es falsa, se ejecuta el
segundo bloque. También debe estar consciente de que el bloque Else es opcional
dependiendo del caso y en cualquier momento puede ejecutar Exit Sub para salir de ese
procedimiento sin continuar ejecutando el resto de las instrucciones.
Otra instrucción (o método) que debemos revisar es el MessageBox.Show() que dibuja
rápidamente un cuadro de mensaje en la pantalla. Recordemos que en Windows existen 4
tipos de mensajes: 1=Información (los que tienen el icono de i), 2=Advertencia (los que tienen
la exclamación), 3=Pregunta (tienen la interrogación) y 4=Errores críticos (los que tienen la “x”).
Así, la sintaxis general del MessageBox.Show() es la siguiente:
returnValue = MessageBox.Show(text, titulo, botones, icono)
text: Texto que se va a mostrar en el cuadro de mensaje.
título: Texto que se va a mostrar en la barra de título del cuadro de mensaje.
Botones: Uno de los valores MessageBoxButtons que especifica qué botones se mostrarán en el
cuadro de mensaje.
Icono: Valor que indica el icono a mostrar en el cuadro. Corresponde con uno de los valores de
la colección MessageBoxIcon Los valores permitidos por MessageBoxIcon son los siguientes:
Valor
Descripción
Asterisk
El cuadro de mensaje está compuesto por un símbolo que consiste en un letra 'i'
minúscula en un círculo.
Error
El cuadro de mensaje está compuesto por un símbolo que consiste en una X
blanca en un círculo con fondo rojo.
Exclamation El cuadro de mensaje está compuesto por un símbolo que consiste en un signo
de exclamación en un triángulo con fondo amarillo.
Hand
El cuadro de mensaje está compuesto por un símbolo que consiste en una X
blanca en un círculo con fondo rojo.
Information
El cuadro de mensaje está compuesto por un símbolo que consiste en un letra 'i'
minúscula en un círculo.
None
El cuadro de mensaje no contiene ningún símbolo.
Question
El cuadro de mensaje está compuesto por un símbolo que consiste en un signo
de interrogación en un círculo.
Stop
El cuadro de mensaje está compuesto por un símbolo que consiste en una X
blanca en un círculo con fondo rojo.
Warning
El cuadro de mensaje está compuesto por un símbolo que consiste en un signo
de exclamación en un triángulo con fondo amarillo.
Los valores permitidos por MessageBoxButtons son los siguientes
Valor
Descripción
AbortRetryIgnore
El cuadro de mensaje contiene los botones Anular, Reintentar y Omitir.
OK
El cuadro de mensaje contiene un botón Aceptar.
OKCancel
El cuadro de mensaje contiene un botón Aceptar y otro Cancelar.
RetryCancel
El cuadro de mensaje contiene un botón Reintentar y otro Cancelar.
YesNo
El cuadro de mensaje contiene un botón Sí y otro No.
YesNoCancel
El cuadro de mensaje contiene botones de Si, No y Cancelar
También debemos revisar el método Execute correspondiente al objeto ADODB.Connection
(en nuestro caso, la variable db que declaramos al inicio). Con Execute podemos ejecutar una
instrucción de SQL en nuestra base de datos. Dicha instrucción debe pasarse como una
cadena de caracteres así:
db.Execute(“DELETE * FROM alumnos”)
En este caso, el objeto db (que es una conexión de ADO), ejecuta la instrucción “DELETE *
FROM alumnos” que le hemos pasado como parámetro. También puede utilizarse con otras
instrucciones como INSERT INTO y UPDATE.
Así mismo, debemos conocer algunos métodos sobre el objeto recordset (en nuestro caso, la
variable se llama lrst).
lrst.open(), crea una nueva colección de registros en la memoria (recordset). Para abrirlo con
el open, se le debe pasar una instrucción SELECT de SQL. Su sintaxis general es como sigue:
rst.open (cadenaSQL, conexión, tipo_de_cursor,tipo_de_bloqueo)
El parámetro cadenaSQL indica una instrucción SELECT de SQL la cual permitirá abrir un
conjunto de registros de la(s) tabla(s) especificadas.
La variable conexión no es más que una variable tipo objeto que hace referencia a nuestra
conexión de ADO.NET (la que hemos declarado como pública en nuestro formulario).
El tipo_de_cursor se refiere al tipo de puntero de registros. Un puntero de registros,
apuntador o cursor es una variable dinámica que marca la posición de un registro dentro de la
tabla. Esto permite conocer la ubicación del mismo entre otras posibilidades. Existen varios
tipod de puntero, entre los cuales se encuentran el adOpenDynamic que se utiliza para
lectura-escritura de registros en las tablas. Puede utilizar instrucciones SQL combinadas con
INNER JOIN y funciones de todo tipo. Por suparte el adOpenForwardOnly es de sólo lectura y
se utiliza principalmente para las búsquedas de registros, ya que el tiempo de carga en
memoria es mucho menor que con el adOpenDynamic.
Para mayor información, consulte la ayuda de Visual Stuio.NET 2010. Las constantes descritas
anteriormente, pertenecen a la colección de objetos ADODB.CursorTypeEnum.
En lo que corresponde al tipo_de_bloqueo es el tipo de bloqueo de registros utilizado por el
recordset. En otras palabras, si un usuario está actualizando un registro dentro de la tabla
alumnos, habría que bloquear el mismo para evitar que otro usuario intentara modificarlo
simultáneamente, pero que al terminar de realizar la actualización sobre éste, que quedase
disponible para cualquier usuario. Es como si alguien quisiese utilizar nuestros zapatos
mientras nosotros los llevamos puestos. Obviamente esto no es posible a menos que nos los
quitemos y los dejemos disponibles para la otra persona que los desee utilizar.
El ejemplo anterior corresponde al bloqueo Optimista, es decir, sólo se bloquea el registro que
se está utilizando en ese momento y no se bloquea la totalidad de la tabla.
Por su parte, existe el bloqueo Pesimista que no es más que el bloqueo de toda la tabla para
evitar que otros usuarios puedan acceder a ella mientras nosotros la estamos utilizando. Esta
opción no es práctica en entornos multiusuario y debe utilizarse con cuidado. Para activar el
bloqueo optimista o pesimista, utilizamos las constantes adLockOptimistic y
adLockPessimistic respectivamente.
Existen otros modos de bloqueo que pueden ser revisados en la documentación de Visual
Studio.NET 2010 y pertenecen a la colección de objetos ADODB.LockTypeEnum.
lrst.addnew() agrega un nuevo registro en blanco al final de la tabla, el cual, esperará que se
genere un update() para actualizar los cambios físicamente.
lrst.update() realiza los cambios físicamente en la tabla. Si ha indicado previamente un
addnew() se creará un nuevo registro, pero si no lo hace, se asumirá una modificación.
lrst.recordcount() devuelve un número entero que indica la cantidad registros encontrados
mediante un open() de un recordset. Para que el valor obtenido sea correcto, se debe
establecer
la
propiedad
CursorLocation
del
recordset
a
ADODB.CursorLocationEnum.adUseClient. Esto indicará que nuestro puntero de registros
se encuentra en nuestra máquina cliente, ya que de lo contrario, se asumirá que el recordset se
ha creado en el servidor, lo que es falso y devolverá un valor errado de -1.
Para revisar mayor documentación sobre la propiedad CursorLocation del objeto Recordset,
revise la documentación de Visual Studio.NET 2010.
lrst.close() = Cierra un recordset. Es importante cerrar un recordset abierto, ya que si hemos
dejado el recordset en memoria y volvemos a disparar erróneamente un open() se generará un
error. Adoptaremos la regla “recordset que abre, recordset que cierra”.
lrst.Fields.Item("campo").Value se utilize para “capturer”, (leer o escribir) el valor que tiene en ese
momento el campo de la tabla. Entonces, si queremos que el campo nombre de nuestra tabla
alumnos reciba el valor que tiene el objeto txtCedula.Text, debemos escribir:
lrst.Fields.Item("nombre").Value = Trim(Me.txtNombre.Text)
El nombre del campo debe ir entre comillas y podríamos utilizar el índice numérico del campo en la
tabla, pero no es muy recomendable; así, lo que el usuario haya ingresado en el cuadro de texto
txtNombre (específicamente en la propiedad Text), se le asignará al campo “nombre” del
recordset que tenemos previamente abierto en la memoria.
Recuerde que los valores no se guardarán físicamente en la tabla si no se dispara un update().
Es importante tomar en cuenta la función Trim() cuya función es eliminar los espacios en blanco del
valor de una variable tipo cadena. En este caso, si guardamos el valor “ALFREDO
“ dentro del
objeto txtNombre (específicamente en la propiedad Text), se guardará la cadena completa
incluyendo los espacios en blanco; pero si utilizamos Trim(Me.txtNombre.Text) y previamente
hemos incluido el valor con espacios, sólo se guardará la cadena como tal y se ignorarán todos los
“blancos” que existan.
Bien, ahora es el momento de escribir el código del botón cmdGuardar, evento Click(..)
Dim sSQL As String
Dim lrst As New ADODB.Recordset
lrst.CursorLocation=ADODB.CursorlocationEnum.adUseClient
If Me.txtApellido.Text = "" Or Me.txtCedula.Text = "" Or Me.txtDir.Text = "" Or
Me.txtNombre.Text = "" Or Me.txtTelf.Text = "" Then
MessageBox.Show("Debe ingresar todos los datos para poder guardar", "Error",
MessageBoxButtons.OK, MessageBoxIcon.Error)
Exit Sub
Else
sSQL = "SELECT * FROM alumnos WHERE cedula='" + Trim(Me.txtCedula.Text) + "'"
lrst.Open(sSQL, db, ADODB.CursorTypeEnum.adOpenDynamic,
ADODB.LockTypeEnum.adLockOptimistic)
If lrst.RecordCount > 0 Then
If MessageBox.Show("Ya existe esta cédula. ¿Reemplazar Registro?", "Registro
Existente", MessageBoxButtons.YesNo, MessageBoxIcon.Question) =
Windows.Forms.DialogResult.No Then
lrst.Close()
Exit Sub
Else
db.Execute("DELETE * FROM alumnos WHERE cedula='" + Trim(Me.txtCedula.Text)
+ "'")
End If
End If
lrst.AddNew()
lrst.Fields.Item("cedula").Value = Trim(Me.txtCedula.Text)
lrst.Fields.Item("nombre").Value = Trim(Me.txtNombre.Text)
lrst.Fields.Item("apellido").Value = Trim(Me.txtApellido.Text)
lrst.Fields.Item("dir").Value = Trim(Me.txtDir.Text)
lrst.Fields.Item("telf").Value = Trim(Me.txtTelf.Text)
lrst.Update()
MessageBox.Show("Registro Guardado", "Guardar", MessageBoxButtons.OK,
MessageBoxIcon.Information)
lrst.Close()
Me.cmdCancelar_Click(sender, e)
End If
Entonces, es poco lo que habría que acotar sobre el procedimiento de guardar. Primeramente,
se declara una variable tipo recordset (local) para abrir la tabla alumnos y se le establece que
el cursor se abre en el equipo cliente (ya este punto se ha abordado anteriormente). Luego, se
verifica que los cuadros de texto tengan algún valor ingresado en su propiedad text. De no ser
así, se emite un mensaje de error. Nótese el uso del operador lógico OR, ya que se leería
como: “Si el nombre, o el apellido, o la cédula, etc, están en blanco, hacer esto…”. Si existe
error en el ingreso de los valores requeridos, se muestra un error y no continua ejecutando el
procedimiento. Nótese el Exit Sub.
Luego, se abre un recordset dinámico de tipo optimista para verificar si previamente no se
ha ingresado un alumno con esa misma cédula (utilizamos el recordcount). De ser así,
muestra un mensaje preguntando si se desea reemplazar este registro. Si responde
afirmativamente, se ejecuta un DELETE al registro en cuestión para borrarlo y crearlo con los
nuevos datos; pero si responde negativamente, sencillamente se cierra el recordset() y se
dispara un Exit Sub para salir del procedimiento.
Luego, se procede a la creación del registro y para ello, utilizamos el método addnew() del
recordset. Procedemos a asignarle los valores de los textboxes a cada campo de dicho
recordset como se ha explicado anteriormente y al final disparamos un update() para que los
cambios se realicen físicamente. Por último, mostramos un mensaje informando que se ha
guardado correctamente; cerramos el recordset con el close() e invocamos al evento click()
del botón cancelar con el único objetivo de volver a todos los objetos del formulario a su estado
inicial.
11. Ahora, haga doble click sobre el botón cmdEliminar (evento Click()) y agregue el
siguiente código…
Dim lrst As New ADODB.Recordset
Dim lsql As String
lrst.CursorLocation = ADODB.CursorLocationEnum.adUseClient
If Trim(Me.txtCedula.Text) = "" Then
MessageBox.Show("Debe tener un registro en pantalla para eliminarlo", "Error",
MessageBoxButtons.OK, MessageBoxIcon.Error)
Exit Sub
End If
lsql = "SELECT * FROM alumnos WHERE cedula='" + Trim(Me.txtCedula.Text) + "'"
lrst.Open(lsql, db, ADODB.CursorTypeEnum.adOpenDynamic,
ADODB.LockTypeEnum.adLockOptimistic)
If lrst.RecordCount > 0 Then
If MessageBox.Show("¿Seguro que desea Eliminar el registro?", "Eliminar",
MessageBoxButtons.YesNo, MessageBoxIcon.Question) =
Windows.Forms.DialogResult.Yes Then
db.Execute("DELETE * FROM alumnos WHERE cedula='" + Trim(Me.txtCedula.Text) +
"'")
MessageBox.Show("Registro Eliminado", "Eliminación", MessageBoxButtons.OK,
MessageBoxIcon.Information)
End If
End If
lrst.Close()
Aquí lo único destacable es que verificamos que tengamos un registro mostrándose en la
pantalla (para ello hacemos if Trim(Me.txtCedula.Text)=”” y de no ser así, mostramos un
error y salimos del procedimiento. Ahora, si tenemos un registro en pantalla, abrimos un
recordset para ubicarlo, y si el recordcount > 0, es decir, que si lo encontró, preguntamos si lo
deseamos eliminar. Al responder afirmativamente al cuadro de mensaje, se ejecuta un
DELETE de SQL (con db.execute) y se muestra el mensaje de eliminación satisfactoria.
12. Es el turno del botón cmdBuscar, evento click(..). Hagamos doble clic sobre este botón y
agreguemos el siguiente código:
Dim lsValor As String
Dim lrst As New ADODB.Recordset
Dim lsql As String
lrst.CursorLocation = ADODB.CursorLocationEnum.adUseClient
lsValor = InputBox("Ingrese la cédula a buscar: ", "Búsqueda de Registros")
If Trim(lsValor) = "" Then
MessageBox.Show("No se ha ingresado la cédula a buscar", "Error",
MessageBoxButtons.OK, MessageBoxIcon.Error)
Exit Sub
End If
lsql = "SELECT * FROM alumnos WHERE cedula='" + Trim(lsValor) + "'"
lrst.Open(lsql, db, ADODB.CursorTypeEnum.adOpenDynamic,
ADODB.LockTypeEnum.adLockOptimistic)
If lrst.RecordCount > 0 Then
Me.txtCedula.Text = Trim(lrst.Fields.Item("cedula").Value)
Me.txtApellido.Text = Trim(lrst.Fields.Item("apellido").Value)
Me.txtDir.Text = Trim(lrst.Fields.Item("dir").Value)
Me.txtNombre.Text = Trim(lrst.Fields.Item("nombre").Value)
Me.txtTelf.Text = Trim(lrst.Fields.Item("telf").Value)
Else
MessageBox.Show("No se encuentra el registro", "Búsqueda",
MessageBoxButtons.OK, MessageBoxIcon.Error)
End If
lrst.Close()
En cuanto a este botón, lo primero que observamos es la declaración de la variable lsValor
que nos permitirá ingresar el valor de la cédula a buscar dentro de los registros existentes.
Observamos el uso de la función InputBox() la cual, nos permite dibujar rápidamente un
cuadro de mensaje donde el usuario podrá ingresar un valor dentro de un cuadro de texto que
ya está “dibujado” dentro de ese recuadro.
El valor ingresado mediante el InputBox() se le asigna a la variable lsValor y luego se abre un
recordset para buscar algún registro que coincida con el mismo (es decir, que se haya
registrado un alumno con esa cédula). De encontrar alguno, (recordcount > 0), procede a
mostrarlo. De no ser así, genera un mensaje de error.
Cabe destacar que para mostrar el valor de cada campo en los cuadros de texto
correspondientes, se utiliza la siguiente estructura:
Me.txtCedula.Text = Trim(lrst.Fields.Item("cedula").Value)
Lo que se hace aquí es leer el valor del campo en el recordset y luego pasárselo al cuadro de
texto correspondiente.
Actualice los cambios en el proyecto presionando el icono del disquete o CTRL+S
Ya puede ejecutar su aplicación. Presione F5 para iniciarla y pruebe agregar, modificar,
eliminar y consultar registros.
MENÚS EN VISUAL BASIC
En este apartado estudiaremos la manera de crear menús en Visual Basic.NET. Para ello, es
necesario que agreguemos otro formulario.
1. Vayamos al menú Proyecto y seleccionemos la primera opción: Agregar Windows Forms.
De esta manera, se agregará un formulario nuevo “en blanco”
2. En el cuadro de diálogo de “Agregar nuevo elemento”, seleccione Windows Forms y
coloque el nombre “frmMain.vb”
3. Ahora, aparecerá un nuevo formulario en blanco donde “dibujaremos nuestro menú”.
4. Vaya al cuadro de controles y seleccione el objeto MenuStrip. Al punto, aparecerá en la
parte inferior un contenedor con este objeto de nombre MenuStrip1
5. Haga un clic sobre el objeto MenuStrip1 y cámbiele el
nombre en la ventana Propiedades. Asígnele en Name
“mnuPrincipal”
6. Es el momento de incluir los ítems del menú. Para ello, haga
un clic sobre la barra superior que se aprecia tenuemente en el
formulario con la leyenda “Escriba aquí”
7. Cuando aparezca esta
leyenda, haga doble clic
sobre ella para activar el
modo de edición
8. Escriba el título del menú. En este caso, “Archivo”. Note que este no es el nombre del
objeto “menú” y en VB.NET todos los ítems del mismo deben tener un nombre asociado.
Entonces, el mismo entorno de VB le asignará nombres automáticamente (aunque los
podemos cambiar según nuestra conveniencia). Por ejemplo, en este primer ítem, si vamos a la
propiedad Name en la ventana propiedades, encontraremos que se llama
ArchivoToolStripMenuItem.
9. Una vez que hemos ingresado el ítem “Archivo” dentro del menú, hay que agregar los
ítems que conformarán la lista de opciones de este menú. Para ello, clickeamos en el recuadro
que aparece justo debajo de “Archivo” que también podemos editar y escribamos la palabra
“Alumnos”, y luego, agregamos otro ítem con el texto “Profesores” y “Salir”, quedando tal
como se muestra en la siguiente figura:
10. Agregue un menú al lado de la palabra
Archivo¸ es decir, tendrá el mismo nivel de éste,
conformando una barra de menú. La llamaremos
“Reportes”, tal como se muestra a continuación:
11. Ahora, justo debajo del menú Reportes, agregamos un ítem de menú llamado “Listado de
Alumnos” y otro denominado “Consulta de Alumnos”, tal como se muestra en la figura:
12. Es el momento de agregar código al menú. Para
ello, vayamos al menú Archivo, específicamente al
ítem Alumnos que acabamos de crear y hacemos
doble clic sobre él para abrir la ventana código
13. Agregue la siguiente línea de código en el procedimiento Click() del Item “Alumnos”
frmAlumnos.Show()
Este permitirá mostrar el formulario frmAlumnos que hemos creado previamente. Esa es la
función del método Show() de los formularios.
14. Ahora, presione CTRL+F4 para cerrar la ventana código y haga doble clic sobre el ítem
Salir del menú Archivo. Allí se abrirá el procedimiento Click() de este elemento de menú.
Agregue el siguiente código:
Application.Exit()
Este permitirá Salir de la aplicación, no sólo descargará el formulario actual de la memoria, sino
la aplicación completa.
15. Ahora, vaya al menú de VB.NET y ubique la opción Proyecto y luego Propiedades del
Sistema. Allí debemos establecer que nuestro formulario inicial ahora es frmMain.
16. En la ventana que aparece como propiedades del sistema, buscamos la opción
Formulario de Inicio y seleccionamos frmMain. Luego, damos CTRL+F4 y se guardarán los
cambios realizados.
Existen muchas otras opciones relacionadas con la gestión de menús, pero no serán
abordadas por razones de tiempo. Puede revisar en detalle la ayuda de VB:NET 2010 para
aclarar sus dudas.
REPORTES EN VB.NET
Un reporte es un documento impreso, por pantalla o guardado como archivo que representa
resultados del procesamiento de información de manera organizada a través de listados de
registros agrupados o no, con gráficos, cálculos y demás elementos de información.
En Visual Basic.NET se pueden agregar reportes a una aplicación. En este caso, crearemos el
Listado de Alumnos.
1. Para ello, vayamos al menú Proyecto de VB.NET y seleccionamos Agregar Nuevo
Elemento.
2. Luego, seleeccionamos el ítem Asistente para Informes y le asignamos el nombre
rptAlumnos.rdlc
3. Presionamos Agregar y se cerrará la ventana, mostrándonos el asistente.
4. El primer paso es indicar de dónde se tomarán los datos. Seleccionemos Base de Datos y
presionamos Siguiente.
5. En el siguiente paso, debemos
elegir el modelo de datos a utilizar.
El modelo de base de datos que elija
determina los tipos de objetos de
datos que utiliza el código de la
aplicación.
En este caso, elegimos la opción
Conjunto de Datos y presionamos
Siguiente.
6. En el paso siguiente, debemos
seleccionar la conexión de datos que
utilizaremos para el reporte y para ello,
hacemos click en el botón Nueva
Conexión que aparece del lado
derecho superior de la pantalla.
7. Al presionar Nueva Conexión,
aparecerá el cuadro de diálogo para
crear una nueva conexión a datos.
8. En este cuadro de diálogo, debe indicar con qué
motor de base de datos se conectará. En este
caso, será Microsoft Access y para ello, haga clic
en el botón Cambiar y aparecerá un cuadro de
diálogo como el siguiente:
9. Elija la opción Archivo de Base de datos de
Microsoft Access y presione Aceptar
10. Ahora, elija el archivo de Access que quiere enlazar con la aplicación que estamos
desarrollando. Para ello, Haga click en el botón Examinar del cuadro de diálogo Agregar
Conexión y busque el archivo sistema.accdb dentro de la carpeta siguiente:
C:\Documents and Settings\Administrador\Mis documentos\Visual Studio 2010
\Projects\sistema\sistema\bin\Debug
Y presione Aceptar para terminar de crear la conexión.
11. Al hacer lo anterior, volveremos al asistente, donde se mostrará nuestra cadena de
conexión (si presionamos el botón de “+” que aparece en la parte inferior del cuadro de
diálogo).
12. En este cuadro, presione el botón
Siguiente.
13. Es probable que reciba el siguiente
cuadro de diálogo solicitando que se
agregue la base de datos al proyecto.
Esto será especialmente útil cuando se
instale en otras PC. Responda Si
14. Ahora, se nos preguntará si deseamos guardar la conexión. Para ello, tildamos la casilla de
verificación y presionamos Siguiente
15. En este momento, debemos seleccionar la tabla alumnos que vincularemos al reporte y al
mismo tiempo, tenemos que guardar el DataSet. El DataSet es el conjunto de datos asociado al
informe que proviene de la(s) tabla(s) que hayamos seleccionado.
16. Para seleccionar la tabla alumnos
debemos clickear sobre el signo “+”
que está al lado de la categoría tablas
y luego aparece propiamente alumnos.
Luego, clickeamos en Finalizar.
Ahora, propiamente debemos diseñar
el informe. Se mostrará entonces la
siguiente ventana a manera de
resumen:
17. Ahora, haga clic en Siguiente para empezar a diseñarlo.
18. Luego aparece la siguiente ventana
donde deberá indicar qué campos
desea estén reflejados en el informe.
Así:
19. Ahora, vaya a la lista campos disponibles y arrastre los campos cédula, nombre,
apellido, dir y telf hasta el cuadro Valores quedando asi:
20. Presione el botón
Siguiente para continuar
con el siguiente paso.
21. Es el momento de elegir el
diseño del reporte; sin embargo,
sólo tenemos disponible el
predeterminado.
Presione
Siguiente
22. Ahora, hacemos clic en
Finalizar
23. Al finalizar el asistente, aparecerá el reporte en modo diseño donde podremos hacer
algunos ajustes de estética y funcionalidad. A efectos de este curso, lo dejaremos sin mayores
cambios.
24. En este momento ya hemos diseñado el informe y el paso siguiente, es mostrarlo desde un
ítem de menú. Para ello, debemos crear un nuevo formulario. Recordemos que para hacerlo,
clickeamos en el menú Proyecto de Visual Basic y seleccionamos Agregar Nuevo Elemento.
25. Posteriormente, seleccionamos Windows
frmReporte.vb para el nuevo formulario.
Forms
y
especificamos
el
nombre
26. Vamos a la propiedad Name del nuevo formulario y verifiquemos que el nombre se ha
especificado a frmReporte
27. El paso siguiente es insertar un objeto ReportViewer dentro del formulario. Para ello,
vamos al cuadro de controles y buscamos el grupo Informe para luego, hacer doble click
sobre el objeto ReportViewer. Nuestro formulario quedará así:
28. En el panel Tareas de ReportViewer despliegue la lista Elegir Informe y seleccione
sistema.rptalumnos.rdlc.
29. Luego, seleccione el objeto ReportViewer que ha pegado en su formulario y cambiemos la
propiedad Anchor marcando las 4 opciones disponibles: Top, Left, Right, Bottom
Así mismo, teniendo el ReportViewer seleccionado, debemos buscar la propiedad
AutoSizeMode y cambiar su valor a GrowAndShrink. Con estos últimos ajustes, si
llegásemos a cambiar de tamaño al formulario, nuestro reporte adoptaría el nuevo tamaño.
30. Es un buen momento para guardar los cambios. Así mismo, vaya al formulario frmMain,
específicamente al ítem de menú Listado de Alumnos y haga doble clic sobre él para agregar
el código para mostrar el reporte.
Allí, sólo agregaremos la siguiente línea:
frmReporte.Show()
31. Y finalmente, guardamos los cambios y ejecutamos la aplicación con F5
CUADRÍCULAS EN VISUAL BASIC
Las cuadrículas son objetos muy importantes en Visual Basic y en cualquier lenguaje de
programación, ya que permiten mostrar una serie de registros de manera integral, al punto que
pueden responder a una serie de criterios indicados por el usuario. En VB.NET la plataforma
ADO.NET (que se utiliza para manipular datos), provee una herramienta o “clase” para utilizar
cuadrículas en las aplicaciones que desarrollamos. Esta se denomina DataGridView.
1. Agregue un nuevo formulario (vaya al menú Proyecto > Agregar Windows Forms) y
coloque el nombre frmConsulta.vb.
2. Vaya al cuadro de controles y busque la “clase” DataGridView que se encuentra dentro del
grupo Datos. Luego, inserte un objeto de este tipo haciendo doble clic sobre el icono del
DataGridView y su formulario quedará provisto de uno de ellos.
3. En este punto, observará un panel de tareas flotante como el que se muestra en la siguiente
figura:
4. Despliegue la lista Elegir origen de
datos y allí seleccione el que creamos
cuando
definimos
el
reporte.
AlumnosBindingSource.
En este momento, nuestra cuadrícula
cambiará de aspecto y adoptará la
estructura del origen de datos.
5. También es recomendable marcar la
opción Acoplar al contenedor primario y se ajustará el tamaño del grid al del formulario
quedando así:
6. Existen otras opciones como
habilitar la agregación, edición o
eliminación directamente sobre la
cuadrícula. Las dejaremos como
vienen
configuradas,
pero
en
desarrollos profesionales debemos
tener cuidado con ellas.
7. Finalmente, lo que corresponde
hacer es agregar una linea de código
para mostrar el formulario de consulta. Para ello, vaya al formulario frmMain y específicamente
al elemento de menú Consulta de Alumnos que está dentro del menú Reportes
8. Abra la ventana código (doble clic sobre el elemento Consulta de Alumnos) y allí escriba la
siguiente línea para mostrar el formulario frmConsulta.
frmConsulta.Show()
9. Es un buen momento para guardar los cambios y ejecutar el programa
IMÁGENES EN VB.NET
Otra de las posibilidades de Visual Basic.NET es la inclusión de imágenes dentro de la
aplicación. Por ejemplo, una fotografía en un formulario de empleados o el logotipo de la
empresa para la cual trabajamos en el formulario principal. Para ello podemos utilizar el objeto
PictureBox que se encuentra dentro de los controles comunes del cuadro de controles.
1. Vayamos al formulario frmMain e insertemos un PictureBox, así:
2. Debido a que sólo insertaremos un
PictureBox, no le cambiaremos el nombre y
quedará como PictureBox1
3. Podemos incrustar una imagen utilizando la
propiedad Image que está en la ventana
propiedades. Al ubicar dicha propiedad,
presionemos el botón de tres puntos suspensivos
y aparecerá la siguiente ventana:
4. Utilizaremos la opción Recurso Local y
luego, clickeamos en el botón Importar.
5. Aparecerá el cuadro de diálogo Abrir donde
ubicaremos una imagen y presionamos el botón
Aceptar
6. Existe una propiedad llamada SizeMode, la
cual, configuraremos al valor StretchImage.
Esto con el fin de que la imagen se ajuste al
tamaño del cuadro de imagen y no se deforme
o desproporcione. Esto es muy útil para fines de
estética y presentación.
7. El producto final quedará así:
También existe otra manera de incluir imágenes
utilizando código, mediante la propiedad ImageLocation
la cual, permitirá indicar mediante una cadena de
caracteres, la dirección de la imagen que deseemos
insertar. Así:
Me.PictureBox1.ImageLocation = "C:\imagen.jpg"
Cabe destacar que la imagen debe existir en la ruta a la
cual apunta incluso cuando la aplicación se ejecuta como
un archivo .exe
Algunos formatos reconocidos son gif, png, jpg y bmp.
COMPILACIÓN DE UNA SOLUCIÓN.
Recordemos que una solución en VB.NET es un conjunto de proyectos o archivos que se
agrupan, ordenan y disponen con el fin de “solucionar” un problema. Entonces, cuando ya
tenemos listo nuestro(s) proyectos, ha llegado la hora de compilar nuestra solución.
La compilación es el proceso mediante el cual, se convierte el código fuente (de alto nivel) en
código objeto (binario). Pero recordemos que en VS.NET existe un código intermedio que se
denomina MSIL (Microsoft Intermediate Language) que realmente es “interpretado por el .NET
framework. También debemos generar el archivo .exe (archivo ejecutable) a través del cual,
ejecutaremos nuestra aplicación.
Para ello, vamos al menú de Visual Studio Generar y luego, en la primera opción Generar
Sistema.
En la barra de estado nos indicará que está iniciando la generación del ejecutable y también
cuando ya ha finalizado.
Esta acción producirá un archivo .exe pero antes de seguir, debemos aprender una regla de
oro: Para correr un archivo .exe generado en VB.NET, es necesario que el equipo tenga
instalado el .NET Framework actualizado. En nuestro caso, la versión 4.0.30319
EMPAQUETADO DE UNA SOLUCIÓN
El empaquetado consiste en agrupar todos los archivos requeridos para que nuestra aplicación
corra en un equipo sin necesidad de tener el Visual Studio instalado. En otras palabras, crear
un programa de instalación, tal como cualquier aplicación que funcione bajo Windows. Para
ello, procedamos de la siguiente manera:
1. Vamos al menú Archivo de Visual Basic y seleccionamos la plantilla Instalador de Visual
Studio. Luego, Asistente para proyectos de instalación. (la penúltima opción), tal como se
observa en la figura:
2. Le damos el nombre Instalador al proyecto y dejamos marcada la tilde Crear directorio
para la solución. Presionamos Aceptar.
3. Luego, se mostrará el asistente para instalación, así:
4. Ahora, corresponde elegir el tipo
de proyecto. Debemos seleccionar
la opción Crear un programa de
instalación de una aplicación
para Windows y presionamos
Siguiente
5. Luego, se le pedirá si desea agregar archivos adicionales al proyecto. Sencillamente
presione Siguiente.
6. Por último, aparece un
cuadro resumiendo todas
las
configuraciones
establecidas
para
el
instalador.
Presione
Finalizar.
En
este
aparecerá
la
pantalla:
momento,
siguiente
7. En este
momento,
debemos
incluir los
archivos que
deseamos
distribuir.
Hacemos clic
en la
categoría Carpeta de la aplicación en el panel izquierdo y luego hacemos clic con el botón
derecho sobre esta categoría, desplegando entonces los menús contextuales, así:
8. Seleccionamos Agregar > Archivo y aparecerá un cuadro de diálogo Abrir donde
buscaremos la carpeta C:\Documents and Settings\Administrador\Mis documentos\Visual
Studio 2010\Projects\sistema\sistema\bin\Debug
9. En esta carpeta debemos seleccionar los archivos que deseamos empaquetar, entre los
cuales se encuentran el .exe previamente generado y la base de datos central.accdb.
Sencillamente seleccionemos todos los archivos y agreguémoslos al proyecto de instalación,
quedando así:
10.
Ahora,
indiquemos
al
instalador que debe
crear
un
acceso
directo en el menú
inicio para nuestro
producto. Para ello,
hacemos lo siguiente:
11.
Primero, nos
ubicamos
en
la
categoría Carpeta de la Aplicación y cambiamos la propiedad AlwaysCreate a True.
11. Ahora, vayamos a la categoría Menú Programas del Usuario y cambiamos la propiedad
AlwaysCreate a True. Al mismo tiempo, hacemos clic derecho sobre el área blanca de la
derecha y luego en Crear Acceso Directo. Cuidemos de haber seleccionado previamente la
categoría Menú Programas del Usuario, tal como se muestra en la figura:
12. Aparecerá un cuadro de diálogo donde debemos buscar el archivo .exe al cual apuntará el
acceso directo, así
13. Hacemos doble clic en la
Carpeta de la Aplicación y
luego
en
sistema.exe
y
presionamos Aceptar
14. Ahora, editamos el nombre
del acceso directo y lo llamamos
sencillamente Sistema.
15. Ahora, vamos al menú
Generar
y
seleccionamos
Generar Instalador.
16. El producto final se encuentra en C:\Documents and Settings\Administrador\Mis
documentos\Visual Studio 2010\Projects\Instalador\Instalador\Debug
17. Para instalar la aplicación, haga clic en el archivo Setup.exe o en el msi.
Ya ha creado una aplicación totalmente funcional, empaquetada y lista para distribuir!!!
APÉNDICE. TIPOS DE DATOS EN VB.NET
Tipo de Visual
Basic
Asignación de
almacenamiento
nominal
Intervalo de valores
Boolean
En función de la
True o False
plataforma de
implementación
Byte
1 byte
0 a 255 (sin signo)
Char (carácter
2 bytes
0 a 65535 (sin signo)
8 bytes
0:00:00 (medianoche) del 1 de enero de 0001 a 11:59:59 p.m. del 31 de
individual)
Date
diciembre de 9999.
Decimal
16 bytes
0 a +/-79.228.162.514.264.337.593.543.950.335 (+/-7,9... E+28) †sin
separador decimal; 0 a +/-7,9228162514264337593543950335 con 28
posiciones a la derecha del decimal;
el número distinto de cero más pequeño es +/0,0000000000000000000000000001 (+/-1E-28) †
Double (punto
8 bytes
flotante de
-1,79769313486231570E+308 a -4,94065645841246544E-324 †para los
valores negativos;
precisión doble)
4,94065645841246544E-324 a 1,79769313486231570E+308 †para los
valores positivos
Integer
4 bytes
Long (entero largo) 8 bytes
-2.147.483.648 a 2.147.483.647 (con signo)
-9.223.372.036.854.775.808 a 9.223.372.036.854.775.807 (9,2...E+18 †)
(con signo)
Object
4 bytes en
Cualquier tipo puede almacenarse en una variable de tipoObject
plataforma de 32 bits
8 bytes en
plataforma de 64 bits
SByte
1 byte
-128 a 127 (con signo)
Short (entero
2 bytes
-32.768 a 32.767 (con signo)
4 bytes
-3,4028235E+38 a -1,401298E-45 † para los valores negativos;
corto)
Single (punto
flotante de
1,401298E-45 a 3,4028235E+38 † para los valores positivos
precisión simple)
String(longitud
En función de la
0 a 2.000 millones de caracteres Unicode aprox.
variable)
plataforma de
implementación
UInteger
4 bytes
0 a 4.294.967.295 (sin signo)
ULong
8 bytes
0 a 18.446.744.073.709.551.615 (1,8...E+19 †) (sin signo)
User-
En función de la
Cada miembro de la estructura tiene un intervalo de valores determinado
Defined(estructura) plataforma de
UShort
†
por su tipo de datos y es independiente de los intervalos de valores
implementación
correspondientes a los demás miembros.
2 bytes
0 a 65.535 (sin signo)
En la notación científica, "E" hace referencia a una potencia de 10. Por lo tanto, 3,56E+2 significa 3.56 x 102 o 356, y
3,56E-2 significa 3.56 / 102 o 0,0356.