Visual Basic ASP

Visual Basic y ASP .
NET a su alcance
Nivel Básico/Intermedio
Carlos Alberto Vanegas

Ingeniero de Sistemas
Especialista en Ingeniería de Software
Maestría en Ingeniería de Sistemas
Profesor, Universidad Distrital Francisco José de Caldas
Bogotá, enero 2011
1
2
Contenido
PRÓLOGO .................................................................................................................................... 7
1. INTRODUCCIÓN A VISUAL BASIC .NET .............................................................................. 10
1.1 Microsoft Visual Studio .NET ........................................................................................ 10
1.2 .NET FrameWork ......................................................................................................... 10
1.3 Página de Inicio Visual Studio .NET/2008 .................................................................... 11
2. PROYECTOS WINDOWS FORMS CON VISUAL BASIC .NET ............................................ 14
2.1 Crear una Aplicación Windows Forms ......................................................................... 14
2.2 Elegir la plantilla de aplicaciones. ................................................................................. 14
2.3 Crear la interfaz de usuario. ......................................................................................... 19
2.4 Establecer las propiedades de los controles ................................................................ 20
2.5 Escribir código .............................................................................................................. 21
2.6 Guardar la aplicación .................................................................................................... 22
2.7 Ejecutar la aplicación Windows Forms. ....................................................................... 23
2.8 Cerrar y Abrir un proyecto Windows Forms. ................................................................ 24
3. FUNDAMENTOS DE VISUAL BASIC .NET ............................................................................ 25
3.1 Variables ....................................................................................................................... 25
3.2 Constantes .................................................................................................................... 26
3.3 Tipos de datos .............................................................................................................. 26
3.3.1 Ejemplo práctico tipos de datos ................................................................................. 26
3.4 Funciones de conversión de tipos de datos ................................................................. 30
3.5 Operadores y Expresiones ........................................................................................... 32
3.5.1 Operadores aritméticos ............................................................................................. 32
3.5.2 Operadores relacionales ........................................................................................... 32
3.5.3 Operadores de igualdad ............................................................................................ 32
3.5.4 Operadores Lógicos .................................................................................................. 33
3.5.5 Ejemplo práctico operadores aritméticos .................................................................. 33
3.6 Palabras clave .............................................................................................................. 36
3.7 Comentarios ................................................................................................................. 36
4. ESTRUCTURAS DE CONTROL ............................................................................................. 37
4.1 Estructura de control If - Else ....................................................................................... 37
4.1.1 Sentencia If ................................................................................................................ 37
4.1.2 Sentencia If- Else....................................................................................................... 38
4.1.3 If (operador) ............................................................................................................... 39
4.1.4 IIF ............................................................................................................................... 39
4.1.5 Ejemplo estructura If-Else ......................................................................................... 39
4.2 Sentencia Select ........................................................................................................... 42
4.2.1 Ejemplo estructura Select .......................................................................................... 43
4.3 Estructura For-Next ...................................................................................................... 45
4.3.1 Ejemplo estructura For-Next ...................................................................................... 46
4.4 Estructura While ........................................................................................................... 48
4.4.1 Ejemplo estructura While ........................................................................................... 49
4.5 Do-Loop While .............................................................................................................. 51
4.5.1 Ejemplo estructura Do-Loop while............................................................................. 52
4.6 Estructura For-Each...................................................................................................... 55
4.6.1 Ejemplo estructura For-Each ..................................................................................... 55
4.7 Ejercicios estructuras de control ................................................................................... 58
5. MÓDULOS Y PROCEDIMIENTOS ......................................................................................... 59
5.1 Módulos ........................................................................................................................ 59
5.2 Procedimientos o funciones ......................................................................................... 61
5.2.1 Ejemplo práctico módulo y procedimientos Sub y Function ...................................... 62
5.3 Funciones predeterminadas ......................................................................................... 66
5.3.1 Función de fecha y hora ............................................................................................ 66
3
5.3.1.1 Ejemplo práctico funciones de fecha y hora ........................................................... 67
5.3.2 Funciones Matemáticas ............................................................................................. 69
5.3.2.1 Ejemplo práctico funciones matemáticas ............................................................... 70
5.3.3 Funciones para cadenas de caracteres .................................................................... 72
5.3.3.1 Ejemplo práctico funciones de cadena de caracteres ............................................ 74
5.4 Ejercicios de procedimientos ........................................................................................ 77
6. MATRICES Y COLECCIONES ............................................................................................... 78
6.1 Matrices de una Dimensión o Unidimensionales ......................................................... 78
6.1.1 Ejemplo práctico matriz unidimensional .................................................................... 78
6.2. Matrices de más de una Dimensión ............................................................................ 81
6.2.1 Ejemplo práctico matrices bidimensionales .............................................................. 82
6.3 Colecciones .................................................................................................................. 84
6.3.1 Ejemplo práctico colecciones .................................................................................... 84
6.4 Ejercicios Matrices ........................................................................................................ 90
7. CONTROLES PARA INTERFAZ DE USUARIO ..................................................................... 91
7.1 LinkLabel ...................................................................................................................... 91
7.1.1 Ejemplo práctico LinkLabel ........................................................................................ 91
7.2 Controles ListBox y ComboBox .................................................................................... 93
7.2.1 Ejemplo práctico ListBox y ComboBox...................................................................... 93
7.3 Checkbox y RadioButton .............................................................................................. 99
7.3.1 Ejemplo práctico Checkbox y RadioButton ............................................................... 99
7.4 VScrollBar, HScroolBar, TrackBar. ............................................................................. 102
7.4.1 Ejemplo práctico VScrollBar y TrackBar ................................................................. 102
7.5 DataGridView .............................................................................................................. 105
7.5.1 Ejemplo práctico DataGridView ............................................................................... 105
7.6 ListView ...................................................................................................................... 107
7.6.1 Ejemplo práctico ListView ........................................................................................ 107
7.7 RichTextBox ............................................................................................................... 115
7.7.1 Ejemplo práctico RichTextBox ................................................................................. 115
7.8 TreeView. .................................................................................................................... 118
7.8.1 Ejemplo práctico TreeView ...................................................................................... 119
7.9 FolderBrowserDialog .................................................................................................. 122
7.9.1 Ejemplo práctico FolderBrowserDialog ................................................................... 122
7.10 WebBrowser ............................................................................................................. 125
7.10.1 Ejemplo práctico WebBrowser .............................................................................. 125
7.11 Ejercicios interfaz de usuario .................................................................................... 129
8. MENÚS EN FORMULARIOS ................................................................................................ 130
8.1 Creación de Menús con Interfaz de documento sencillo............................................ 130
8.1.1 Ejemplo práctico menús con interfaz de documento sencillo ................................. 130
8.2 Creación de Menús con interfaz múltiple ................................................................... 141
8.2.1 Ejemplo práctico formularios MDI ............................................................................ 141
8.3 Menú Ventana ............................................................................................................ 153
8.4 Desactivar las opciones del menú en formularios MDI .............................................. 156
8.5 Creación de una barra de herramientas en una aplicación MDI ................................ 156
8.6 Crear un menú contextual .......................................................................................... 159
9. GRÁFICOS Y ANIMACIÓN ................................................................................................... 162
9.1 El espacio de nombres System.Drawing .................................................................... 162
9.2 Movimiento de un control ........................................................................................... 172
9.2.1 Ejemplo práctico movimiento de un control ............................................................. 172
9.3 Expandir y contraer un control .................................................................................... 175
9.3.1 Ejemplo práctico expandir y contraer un control ..................................................... 176
9.4 Animación ................................................................................................................... 178
9.4.1 Ejemplos prácticos de animación ........................................................................... 178
9.5 Ejercicios de gráficos .................................................................................................. 187
10. MANEJO DE EVENTOS (MOUSE – TECLADO) ............................................................... 188
4
10.1 Eventos del mouse ................................................................................................... 188
10.2 Ejercicios de eventos del mouse .............................................................................. 189
10.3 Eventos del teclado .................................................................................................. 193
10.4 Ejercicios de eventos del teclado ............................................................................. 193
11. PROGRAMACIÓN ORIENTADA A OBJETOS CON VB.NET ............................................ 198
11.1 Constructores ........................................................................................................... 199
11.1.1 Constructores sin parámetros ............................................................................... 199
11.1.2 Constructores con parámetros .............................................................................. 200
11.1.3 Sobrecarga de constructores ................................................................................ 200
11.2 Herencia y polimorfismo ........................................................................................... 201
11.3 Ejemplos prácticos de clases ................................................................................... 202
11.4 Interfaces .................................................................................................................. 217
11.5 Ejemplo práctico de interfaces ................................................................................. 218
11.6 Ejercicios P.O.O ....................................................................................................... 222
12. ACCESO A BASES DE DATOS CON VB.NET .................................................................. 223
12.1 Tipos de Bases de Datos. ........................................................................................ 223
12.1.1 bases de datos relacionales .................................................................................. 223
12.1.2 bases de datos orientadas a objetos. .................................................................... 223
12.2 Lenguaje de consulta estructurado (S.Q.L.) ............................................................. 223
12.2.1 Comandos S.Q.L .................................................................................................. 223
12.2.2 Cláusulas S.Q.L .................................................................................................... 224
12.2.3 Operadores lógicos S.Q.L .................................................................................... 224
12.2.4 Operadores de comparación S.Q.L ...................................................................... 225
12.2.5 Funciones de agregado S.Q.L ............................................................................... 225
12.3 Sentencias básicas S.Q.L ........................................................................................ 226
12.3.1 CREATE DATABASE ............................................................................................ 226
12.3.2 DROP DATABASE ................................................................................................ 226
12.3.3 CREATE TABLE .................................................................................................... 226
12.3.4 DROP TABLE ........................................................................................................ 227
12.3.5 INSERT .................................................................................................................. 227
12.3.6 ALTER ................................................................................................................... 227
12.3.7 SELECT ................................................................................................................. 227
12.3.8 DELETE ................................................................................................................. 228
12.3.9 UPDATE ................................................................................................................ 229
12.3.10 INNER JOIN ........................................................................................................ 229
12.4 Conexión a bases de datos con VB.NET ................................................................. 230
12.5 Ejemplos prácticos de bases de datos ..................................................................... 231
12.5.1 Conexión a una base de datos SQL Server por código ........................................ 231
12.5.2. Conexión a SQL Server utilizando el Explorador de servidores .......................... 234
12.5.3 Conexión a una base de datos con DataGridView y BindingNavigator ................ 241
12.5.4 Insertar un nuevo registro a una tabla ................................................................... 248
12.5.5 Filtrar registros de una tabla .................................................................................. 252
12.5.6 Informe de los registros de una tabla .................................................................... 256
12.5.7 Relación de tablas ................................................................................................. 268
12.6 Ejercicios bases de datos ......................................................................................... 276
13. LENGUAJE DE CONSULTA INTEGRADO (LINQ) ............................................................ 277
13.1 Proveedores LINQ .................................................................................................... 277
13.2 Operadores de Consulta LINQ de VB.NET .............................................................. 277
13.3 Escribir una consulta con LINQ en VB.NET ............................................................. 279
13.4 Ejemplos prácticos consultas LINQ .......................................................................... 280
13.4.1 Consulta LINQ a un texto ...................................................................................... 280
13.4.2 Consulta LINQ a una matriz .................................................................................. 283
13.4.3 Consultar una base de datos SQL Server con LINQ To SQL .............................. 286
13.4.4 Operaciones con una tabla de una base de datos SQL Server ............................ 291
13.4.5 Relación entre dos tablas de una base de datos SQL Server .............................. 301
13.4.6 Relación tablas con LINQ to SQL y DataGridView ............................................... 306
13.4.7 Consulta LINQ to DataSet ..................................................................................... 311
5
13.5 Ejercicios de consulta LINQ ..................................................................................... 314
14. APLICACIONES WEB ASP.NET ........................................................................................ 315
14.1 Aplicación Web (ASP.NET) ...................................................................................... 316
14.1.1 Crear un nuevo sitio Web ...................................................................................... 316
14.1.2 Crear la interfaz de usuario ................................................................................... 318
14.1.3 Establecer las propiedades de los controles ......................................................... 319
14.1.5 Ejecutar la aplicación Web .................................................................................... 325
14.1.6 Cerrar y abrir nuevamente un sitio Web ................................................................ 326
14.2 Controles para interfaz de usuario ASP.NET ........................................................... 326
14.2.1 Control CheckBoxList ............................................................................................ 327
14.2.1.1 Ejemplo práctico control CheckBox List ............................................................. 327
14.2.2 Control ImageMap ................................................................................................. 329
14.2.2.1 Ejemplo práctico control ImageMap ................................................................... 330
14.2.3 Control BulletedList ............................................................................................... 333
14.2.3.1 Ejemplo práctico control BulletedList.................................................................. 334
14.2.4 Control RadioButtonList ......................................................................................... 337
14.2.4.1 Ejemplo práctico control RadioButtonList ........................................................... 337
14.2.5 Control MultiView ................................................................................................... 340
14.2.5.1 Ejemplo práctico control MultiView ..................................................................... 341
14.3 Controles para validar datos ..................................................................................... 348
14.3.1 Ejemplo práctico controles de validación .............................................................. 348
15. ACCESO A BASES DE DATOS CON ASP.NET ................................................................ 353
15.1 Controles para operaciones con orígenes de datos ................................................. 353
15.2 Ejemplos prácticos bases de datos con ASP.NET ................................................... 353
15.2.1 Conexión a SQL Server por código ....................................................................... 353
15.2.2 Conexión a una base de datos con un control GridView ...................................... 357
15.2.3 Consulta una base de datos utilizando el Explorador de servidores .................... 362
15.2.4 Insertar un registro en una tabla ............................................................................ 369
15.2.5 Modificar un registro de una tabla ......................................................................... 375
15.2.6 Eliminar un registro de una tabla ........................................................................... 378
15.2.7 Filtrar registros de una tabla .................................................................................. 382
15.2.8 Informe de los registro de una tabla ...................................................................... 388
15.2.9 Visualizar los registros de dos tablas relacionadas............................................... 396
15.3 Ejercicios bases de datos con ASP.NET.................................................................. 404
16. SERVICIOS WEB ................................................................................................................ 405
16.1 Crear un servicio Web desde Visual Basic .NET ..................................................... 405
16.2 Acceder a un Servicio Web ...................................................................................... 411
16.2.1 Ejemplo práctico para acceder a un Servicio Web desde ASP.NET .................... 411
ÍNDICE ...................................................................................................................................... 416
BIBLIOGRAFÍA.......................................................................................................................... 419
INFOGRAFÍA............................................................................................................................. 419
ANEXO A SQL SERVER .......................................................................................................... 420
A.1 Conectarse a SQL Server. ......................................................................................... 420
A.2 Crear una base de datos ............................................................................................ 421
A.3 Crear tablas en la base de datos ............................................................................... 423
A.4 Crear Diagramas de una base de datos .................................................................... 431
A.5 Crear una vista ........................................................................................................... 435
6
PRÓLOGO
Visual Basic y ASP .NET a su alcance (básico / intermedio) proporciona los elementos
necesarios para obtener un conocimiento hasta un nivel intermedio del lenguaje de
programación Visual Basic. Este libro se elaboro pensado en aquellos usuarios que
están interesado en conocer las posibilidades de programación orientada a objetos con
Visual Basic .NET, lo relacionado con la creación de clases, herencia e interfaces.
Además conocer los fundamentos del lenguaje de programación: definición de
variables, constantes, tipos de datos, estructuras de control, módulos, procedimientos,
matrices y colecciones, así como también la creación de interfaz de usuario utilizando
aplicaciones Windows Forms y ASP.NET, acceso a bases de datos, el lenguaje de
consulta integrado LINQ y la creación y la utilización de servicios Web.
Todo el material didáctico del libro se trata de exponer en un lenguaje sencillo,

donde se hace una conceptualización básica sobre cada tema y se complementa con
ejemplos prácticos explicados y graficados que aportan al objetivo de aprendizaje. Cada
ejemplo es explicado línea por línea. En algunos casos se exceptúan explicaciones que
ya se han realizado.
Debido al enfoque practico, basado en ejercicios y al esfuerzo de síntesis resulta

posible utilizarlo para adquirir con facilidad y rapidez un conocimiento para el
desarrollo de aplicaciones con el lenguaje de programación Visual Basic.NET.
Todos los ejemplos del libro se han codificado, compilado y ejecutado desde el
entorno de desarrollo integrado de Microsoft Visual Studio 2008 (la mayoría de los
ejemplos también se pueden trabajar con las versiones Express Edition Visual Basic
2005/2008 y Visual Web Developer 2005/2008).
Capítulos del Libro
Visual Basic y ASP .NET a su alcance contiene 16 capítulos distribuidos de la siguiente

forma:
 Capitulo 1, Introducción a Visual Basic .NET: Se realiza una

conceptualización básica sobre el lenguaje de programación Visual Basic.
NET, el entorno de desarrollo de Microsoft Visual Studio y el componente
.NET Framework.
 Capitulo 2, Un Primer Proyecto Windows Forms con VB.NET: Habla de
cómo crear un proyecto Windows Forms, la elección de la plantilla de
aplicaciones, la creación de la interfaz de usuario, el establecimiento de las
propiedades en un objeto, la escritura de código y la ejecución del proyecto.
 Capitulo 3, Fundamentos de Visual Basic .NET: Maneja los conceptos
básicos del lenguaje de programación Visual Basic .NET: variables,
constantes, tipos de datos, operadores, expresiones y sus palabras reservadas,
con ejemplo prácticos.
 Capitulo 4, Estructuras de control: Maneja los conceptos de las estructuras
de decisión If, Else, IIf, Select y las estructuras repetitivas While, For- Next,
Do- Loop While, For – Each, con una serie de ejemplos que permiten
reforzar los conceptos y con el planteamiento de unos ejercicios para
resolver.
7
 Capitulo 5, Módulos y Procedimientos: Aquí se habla sobre la creación de
módulos y procedimientos Sub y Function. Además se conceptualiza sobre
algunas funciones predeterminadas de fecha y hora, matemáticas y de
manipulación de caracteres, complementado con ejemplos prácticos y
ejercicios para resolver.
 Capitulo 6, Matrices y colecciones: Se habla sobre la estructuración de
datos en matrices unidimensionales y bidimensionales con elementos de un
mismo tipo y las colecciones en memoria con tipos de datos diferentes; aquí
también se presentan ejemplos aplicados al tema, como también ejercicios
para practicar.
 Capitulo 7, Controles para Interfaz de Usuario: Se explican y trabajan
controles que permiten mejorar el diseño de la interfaz gráfica de usuario en
un programa apoyado por ejemplos.
 Capitulo 8, Menús en Formularios: En este capítulo encontrará la forma de
crear menús con interfaz de documento sencillo y múltiple, así como la
creación de barras de herramientas, menús contextuales y desactivar
opciones del menú, explicados a través de ejemplos.
 Capitulo 9, Gráficos y animación: Se conceptualiza sobre el espacio de
nombres System.Drawing, algunas funciones para graficar, el movimiento de
controles, la expansión y contracción de controles, así como los aspectos
básicos para lograr la animación. Todo esto es apoyado con ejemplos
prácticos y ejercicios para practicar.
 Capitulo 10, Manejo de eventos (mouse, teclado) : Se explican los
posibles eventos que pueden ocurrir al utilizar el mouse y el teclado, con
ejemplos prácticos para un mejor aprendizaje.
 Capitulo 11, Programación orientada a objetos utilizando VB.NET: Se
manejan los conceptos de programación orientada a objetos utilizando el
lenguaje de programación Visual Basic .NET en cuanto a: constructores,
sobrecarga de constructores, herencia, polimorfismo e interfaces, cada tema
explicado a través de ejemplos.
 Capitulo 12, Acceso a bases de datos con .NET”: Se conceptualiza sobre
bases de datos, el lenguaje de consulta estructurado (SQL) y como se accede
a una base de datos para manipular la información contenida en ella,
complementada con ejemplos prácticos y ejercicios para resolver.
 Capitulo 13, Lenguaje de consulta integrado (LINQ): En este capítulo se
habla de cómo crear y ejecutar consultas de datos con colecciones de
memoria, con bases de datos SQL Server, apoyado por diversos ejemplos
para complementar el aprendizaje, así como una serie de ejercicios para
practicar.
 Capitulo 14, Aplicaciones Web ASP.NET: En este capítulo se habla de
cómo crear y ejecutar una aplicación Web ASP.NET. Además se explican
algunos controles utilizados en los formularios Web para el diseño de la
interfaz de usuario y para la validación de datos. Todo esto es referenciado
por medio de ejemplos.
 Capitulo 15, Acceso a bases de datos con ASP.NET: Se aplican los
conceptos de bases de datos y las formas de conexión que se manejan en el
capítulo 12 en aplicaciones Web ASP.NET, apoyado con ejemplos. Además
se presentan una serie de ejercicios como complemento al aprendizaje del
acceso a base de datos con ASP.NET.
8
 Capitulo 16 Servicios Web: En este capítulo se conceptualiza sobre los
servicios Web, la creación de un servicio Web, así como la forma de accesar
a un servicio Web desde una aplicación ASP.NET.
 Anexo A: Se explica cómo se realiza la conexión a la base de datos SQL
Server, así como la creación de una base de datos, la creación de tablas,
diagramas y vistas dentro de la base de datos. Este anexo apoya cada uno de
los ejemplos de acceso a bases de datos en aplicaciones Windows Forms y
ASP.NET.
Como apoyo complementario a esta publicación se ha incluido un CD que

contiene cada uno de los capítulos del libro, el anexo explicativo de SQL Server 2005,
el código fuente de todos los ejemplos mostrados en el libro por capítulo. Además se
incluye el documento del libro en pdf.
Si al insertar el CD no se ejecuta automáticamente, el usuario deberá abrir el

archivo inicio.html que se encuentra en el directorio raíz del CD. Una vez abierto, se
podrá ver la página de inicio y al pulsar la imagen Visual Basic y ASP .NET a su
alcance se visualizará la página principal donde encontrará los vínculos para cada
capítulo, el anexo, el software, los archivos con el código fuente y el documento del
libro.
9
1. INTRODUCCIÓN A VISUAL BASIC .NET
Visual Basic .NET (VB.NET) es una versión de Visual Basic enfocada al desarrollo de
aplicaciones .NET. Este lenguaje de programación apareció en el año 1991 como una
evolución del QuickBasic que fabricaba Microsoft. Dicho lenguaje de programación es
orientado a objetos y permite crear la interfaz de usuario utilizando formularios y
controles a los cuales se les puede escribir código para definir el comportamiento de una
aplicación. Visual Basic .NET contiene una serie de instrucciones, funciones y palabras
clave que están relacionados con la interfaz grafica de Windows. Con este lenguaje es
posible la creación de aplicaciones Windows Forms y sitios Web, donde se puede
realizar la gestión estructurada de errores, el soporte para la ejecución de varios
subprocesos, así como la interacción con archivos de texto, bases de datos, utilizando el
envió de datos con documentos XML1 y la generación de informes, etc.. Generalmente
el usuario que programa con Visual Basic .NET utiliza el entorno de desarrollo
integrado de Microsoft Visual Studio NET (2003, 2005, 2008).
1.1 Microsoft Visual Studio .NET
Microsoft Visual Studio .NET es un entorno de desarrollo integrado (Integrated

Development Environment IDE) que ayuda a diseñar, desarrollar, depurar e implantar
con rapidez soluciones basadas en el marco de trabajo de .NET (.NET Framework 2.0,
3.0, 3.5). Desde allí se pueden crear soluciones y proyectos que contendrán los
elementos básicos de una aplicación, conexiones de datos, carpetas y archivos
necesarios para crear aplicaciones de consola, aplicaciones Windows Forms,
aplicaciones Web ASP.NET, servicios Web y aplicaciones móviles. Dicho entorno
permite trabajar con los lenguajes de programación Visual Basic, Visual C#, Visual
C++. Asimismo dichos lenguajes utilizan las funciones de .NET Framework, las cuales
ofrecen acceso a tecnologías clave para simplificar el desarrollo de aplicaciones web
ASP y servicios Web XML. Es por eso, que con Visual Studio se simplifica el diseño,
desarrollo e implementación en equipo de soluciones empresariales utilizando sus
herramientas de desarrollo basadas en componentes y otras tecnologías.
Para el objetivo del libro se trabajará con el entorno Microsoft Visual Studio
2008.
1.2 .NET FrameWork
Es un componente integral de Windows que proporciona un entorno para varios

lenguajes basado en estándares. El diseño de .NET FrameWork trata de cumplir los
siguientes objetivos:
 Proporcionar un entorno de programación orientada a objetos.

 Ofrecer un entorno de ejecución de código que permita la ejecución segura del
mismo.
 Proporcionar un entorno que elimine los problemas de rendimiento.
1
XML, es el estándar de Extensible Markup Language. XML no es más que un conjunto de reglas para
definir etiquetas semánticas que nos organizan un documento en diferentes partes. XML es un
metalenguaje que define la sintaxis utilizada para definir otros lenguajes de etiquetas estructurados.
10
 Ofrecer un entorno coherente entre lenguajes de programación diferentes
basados en Windows o Web.
 Ofrecer estándares para que el código de .NET FrameWork se pueda integrar
con otros tipos de código.
.NET FrameWork se compone de dos partes principales: Common Language Runtime

(CLR) y una biblioteca de clases.
Common Language Runtime es el motor en tiempo de ejecución, ya que

administra el código en tiempo de ejecución y proporciona los servicios de
administración de memoria, de subprocesos y la interacción remota, al tiempo que
aplica una seguridad al acceso del código. El código del motor en tiempo de ejecución
se denomina código administrado, al resto de código se le denomina código no
administrado. Common Language Runtime proporciona servicios estándares de motor
en tiempo de ejecución, el código administrado nunca se interpreta. Una característica
denominada compilación JIT (Just-In-Time) permite ejecutar todo el código
administrado en el lenguaje de máquina nativo del sistema en el que se ejecuta.
Mientras tanto, el administrador de memoria evita que la memoria se pueda fragmentar.
Para entender cómo funciona el .NET FrameWork, es necesario conocer la siguiente
terminología:
 Clase: es una entidad de programación con nombre que consta de un conjunto
común de métodos, propiedades y atributos. Por ejemplo, Form es una de las
clases del espacio de nombres System.Windows.Forms que se utiliza para crear
formularios Windows Forms.
 Espacio de nombres: identifica una colección de clases relacionadas y/u otros
espacios de nombres del .NET FrameWork. Algunos ejemplos de espacios de
nombres incluyen:
 System
 System.Windows.Forms
La biblioteca de clases es una completa colección orientada a objetos de tipos

reutilizables que se pueden emplear para desarrollar aplicaciones de interfaz gráfica de
usuario o de línea de comandos hasta las aplicaciones ASP.NET, como los formularios
Web Forms y los servicios Web XML. La biblioteca de clases permite administrar las
cadenas, recolectar datos, conectar bases de datos y permitir el acceso a archivos, como
también desarrollar las siguientes aplicaciones y servicios:
 Aplicaciones de consola.
 Aplicaciones Windows Forms.
 Aplicaciones Windows Presentation Foundation (WPF).
 Aplicaciones ASP.NET
 Servicios Web.
1.3 Página de Inicio Visual Studio .NET/2008
Al instalarse Microsoft Visual Studio 2008, se crea en el computador una carpeta

llamada Microsoft Visual Studio 2008 (Por omisión), donde encontrará los accesos
directos a los programas: Visual Studio Remote Tools, Visual Studio Tools,
documentación de Microsoft Visual Studio 2008 y Microsoft Visual Studio 2008.
11
Para iniciar el entorno de Visual Studio .NET 2008 pulse la opción Microsoft
Visual Studio 2008.
En la página de inicio de Visual Studio .NET/2008, encontrará una barra de

menús con los menús desplegables: Archivo, Editar, Ver, Herramientas, Prueba,
Ventana y Ayuda. Además una barra de herramientas estándar de Windows, como
también las ventanas: Cuadro de Herramientas, Explorador de soluciones y Lista de
errores. La figura 1.1, muestra la página de inicio:
Figura 1.1 Página de Inicio Visual Studio 2008.
Las principales características del IDE de Microsoft Visual Studio/2008 se

describen en la siguiente tabla:
Tabla 1.1 caracteristicas de programación en Visual Basic .NET.
Característica Descripción
Diseñador de Windows Una superficie de diseño gráfico que permite crear
Forms rápidamente la interfaz de usuario de una aplicación. Se
puede arrastrar o dibujar controles sobre esta superficie.
Herramientas para Se proporciona una plantilla Aplicación Windows Forms,
Aplicaciones Windows con referencias de proyectos básicos y código de inicio
Forms como ayuda para crear aplicaciones Windows Forms
estándares.
Herramientas para Web Se proporciona una plantilla Aplicación Web ASP.NET, con
Forms referencias de proyectos básicos y código de inicio como
ayuda para crear aplicaciones Web ASP.NET en las que la
interfaz de usuario principal es un navegador.
Herramientas para Se proporciona una plantilla Aplicación de servicios Web
servicios Web XML ASP.NET. Esta plantilla construye la estructura de un
proyecto de aplicación Web en un servidor Web de
desarrollo.
12
Soporte de múltiples Soporta los lenguajes de programación de la plataforma
lenguajes .NET: Visual Basic .NET, Visual C++ y Visual C#, que
están integrados en el entorno de desarrollo.
Acceso a datos Componentes para crear aplicaciones que comparten
datos, herramientas de bases de datos visuales para
acceder a los datos y un robusto conjunto de clases de
Microsoft ADO.NET.
Gestión de errores Las herramientas de depuración con soporte multilenguaje
ayudan a encontrar y solucionar errores de código, donde
se pueden utilizar clases de excepciones estructuradas
para incluir la gestión de errores en una aplicación.
Asistentes Los asistentes ayudan a completar rápidamente tareas
comunes. Cada página de un asistente ayuda a establecer
opciones, configurar y personalizar proyectos.
Microsoft Visual Studio/2008 trabaja con el marco de trabajo .NET FrameWork

3.5., el cual agrega de forma incremental las nuevas características de .NET FrameWork
3.0. Algunas de estas características son:
 Integración total de LINQ2 (Language Integrated Query) y del reconocimiento

de los datos: permite escribir código en idiomas habilitados para LINQ para
filtrar, enumerar y crear proyecciones de varios tipos de datos SQL, colecciones,
XML y conjuntos de datos usando la misma sintaxis.
 ASP.NET AJAX: permite crear experiencias Web más eficaces, más interactivas
y con un gran índice de personalización que funcionan con los exploradores más
usados.
 Nueva compatibilidad con el protocolo web para generar servicios WCF, como
por ejemplo AJAX, JSON, REST, POX, RSS, ATOM.
 Nuevas clases en la biblioteca de clases base (BCL) de .NET FrameWork 3.5
que tratan numerosas solicitudes de cliente comunes.
2
Un nuevo conjunto de herramientas diseñado para reducir la complejidad del acceso a Base de Datos.
13
2. PROYECTOS WINDOWS FORMS CON VISUAL BASIC .NET
Crear una aplicación Windows Forms en Visual Basic .NET, requiere de unos pasos
muy sencillos como son: iniciar un nuevo proyecto Visual Basic .NET, crear la interfaz
del usuario, establecer las propiedades de los objetos, escribir el código, guardar la
aplicación y ejecutar el proyecto.
Como ejemplo, se creará un proyecto Windows Forms llamado

MiprogramaWF que permita a un usuario digitar un número y al pulsar un botón se
muestre en una cuadricula la tabla de multiplicación hasta 10 de dicho número.
2.1 Crear una Aplicación Windows Forms
Para crear una aplicación Windows Forms desde la página de inicio de Visual Studio, se
pueden seguir los siguientes pasos:
1. En la ventana proyectos recientes seleccionar la opción Crear: link Proyecto…

Ó
2. Hacer clic en la opción Archivo del menú y seleccionar Nuevo Proyecto...
Cuando se crea un proyecto por cualquier de las dos opciones se visualiza la

siguiente ventana:
Figura 2.1 Ventana Nuevo proyecto.
2.2 Elegir la plantilla de aplicaciones.
Visual Studio .NET ofrece varias plantillas de aplicaciones para soportar el desarrollo
de diferentes tipos de aplicaciones y componentes. Antes de iniciar un nuevo proyecto,
se debe escoger el tipo de plantilla que se va a utilizar. Una plantilla de aplicación
proporciona archivos de inicio y una estructura de proyecto, además contiene los
objetos básicos del proyecto y la configuración del entorno que se necesita para crear el
tipo de aplicación que se desea. En los ejemplos del libro se utilizarán las plantillas:
14
Aplicación para Windows Forms y Aplicación Web ASP.NET. La plantilla
Aplicación para Windows Forms proporciona las herramientas, estructura y código de
inicio para crear una aplicación estándar basada en Windows, añadiendo
automáticamente las referencias básicas del proyecto y los archivos a utilizar como
punto de partida para la aplicación. La plantilla Aplicación Web ASP.NET se utiliza
para crear una aplicación Web ASP.NET en un equipo que tenga instalado Internet
Information Services (IIS)3 versión 5.0 o posterior. Para iniciar el diseño de la
aplicación la plantilla crea los archivos básicos necesarios en el servidor.
Para el ejemplo como Tipo de proyecto se debe seleccionar Visual Basic -

Windows, como plantilla Aplicación de Windows Forms, como Nombre del proyecto
MiProgramaWF. Pulse el botón Aceptar para visualizar el entorno de desarrollo del
proyecto Windows Forms MiProgramaWF.
Figura 2.2 Entorno de desarrollo nuevo proyecto Windows Forms.
Cuando se selecciona una plantilla de aplicaciones, en el entorno de desarrollo

encontrará:
1. Menú principal y la barra de herramientas estándar: Proporcionan acceso a

la mayoría de comandos que controlan el entorno de programación de Visual
Studio .NET. Los comandos del menú principal funcionan igual que en todas
las aplicaciones basadas en Windows. La barra de herramientas proporciona los
iconos que sirven como acceso a la mayoría de comandos estándar de Windows.
También contiene iconos que permiten abrir el explorador de soluciones, la
3
Este servicio convierte a un computador en un servidor de Internet o Intranet es decir
que en los computadores que tienen este servicio instalado se pueden publicar páginas
Web tanto local como remotamente (servidor Web).
15
ventana de propiedades, el cuadro de herramientas y otros elementos
importantes del entorno de desarrollo.
Figura 2.3 Menu principal y barra de herramientas estándar.
Menú Principal
Barra de Herramientas
2. Cuadro de Herramientas: El cuadro de herramientas contiene diversos

controles que se pueden utilizar para añadir ilustraciones, etiquetas, botones,
cuadros de lista, barras de desplazamiento, menús y formas geométricas a una
interfaz de usuario. Cada control que se añade a un formulario se convierte en un
objeto de la interfaz de usuario programable en la aplicación. Estos objetos son
visibles para los usuarios cuando la aplicación se ejecuta y funcionan como los
objetos estándares de cualquier aplicación basada en Windows.
Figura 2.4 Cuadro de Herramientas.
3. Diseñador formulario Windows (Windows Forms): Cuando se inicia un

proyecto en Visual Basic .NET, el Diseñador de formulario de Windows
(Windows Forms) se abre en la vista diseño (un formulario tiene vista diseño
cuando se inicia el proyecto y está en modo de ejecución cuando se ejecuta la
aplicación), mostrándose el formulario Form1 del proyecto. En dicho
formulario se pueden ubicar los controles u objetos necesarios para la aplicación
arrastrándolos desde el cuadro de herramientas para crear la interfaz de usuario.
El formulario predeterminado contiene los elementos mínimos utilizados por la
mayoría de formularios: una barra de título, un cuadro de control y los botones
16
minimizar, maximizar y cerrar. Para visualizar un formulario en la vista Diseño
se puede realizar siguiente:
o Con el Explorador de soluciones , hacer doble clic en el formulario.
Ó
o En el Explorador de soluciones , seleccionar el formulario y dé clic en

el botón Ver Diseñador de la barra de herramientas.
Figura 2.5 Formulario Windows.
4. Explorador de soluciones : Permite visualizar archivos y realizar tareas de

administración de archivos en una solución o en un proyecto. Una solución es un
contenedor para proyectos y elementos de solución que pueden incluirse en una
aplicación. Normalmente, una solución contiene uno o más proyectos
relacionados. Un proyecto es un contendor dentro de una solución que se utiliza
para administrar, generar y depurar lógicamente los elementos del (os) proyecto
(s) que constituyen la aplicación.
Figura 2.6 Ventana Explorador de soluciones.
17
La siguiente tabla describe algunos tipos de archivos habituales específicos para
las soluciones basadas en Visual Basic .NET:
Tabla 2.1 Tipos de Archivos en Visual Basic .NET.
Extensión Nombre Descripción

.sln Solución Visual Organiza proyectos, elementos de proyectos y
Studio elementos de soluciones en una solución
proporcionando al entorno referencias a sus
ubicaciones en disco.
.suo Solution user Registra todas las opciones que podemos asociar a
options nuestra solución de forma que cada vez que
abramos la solución incluya las personalizaciones
que hayamos realizado.
.vb Proyecto Visual Representa los archivos de formularios, controles de
Basic usuario, clases y módulos que pertenecen a la
solución de un solo proyecto. Los archivos que no
estén basados en un lenguaje de programación
tienen su propia extensión. Por ejemplo, un archivo
Crystal Report tiene la extensión .rpt, y un archivo
de texto tiene la extensión .txt.
.vbproj Proyectos Visual Representa los archivos de formularios, controles de
Basic usuario, clases y módulos que pertenecen a la
solución con múltiples proyectos. Esta extensión
nos permite diferenciar entre archivos escritos en
Visual Basic .NET y otros lenguajes compatibles con
.NET. (Visual C# utiliza .csproj.)
.aspx Elementos de Los elementos de proyecto Web incluyen archivos
.asmx proyecto Web Web específicos como .aspx para Web Forms,
.asax .asmx para servicios Web XML, y .asax para clases
globales de aplicaciones. Los proyectos Web
también utilizan la extensión .vb para clases y
módulos.
5. Ventana de propiedades: Muestra una lista de las propiedades que facilitan la

configuración de los valores o propiedades del control seleccionado y se pueden
modificar mientras se crea o se edita la aplicación. Una propiedad describe una
característica de un objeto, como el tamaño, título, color, etc. Algunos controles,
documentos y formularios muestran un gran número de propiedades en la
ventana Propiedades., Esto puede dificultar la localización de la propiedad que
se desea establecer. La ventana Propiedades permite seleccionar las
propiedades de un formulario o control en una vista ordenada por categorías en
lugar de una vista alfabética, según sea el caso se puede realizar lo siguiente:
o Para visualizar las propiedades por categorías: Haga clic en el botón Por
categorías de la ventana Propiedades. Las propiedades para el formulario o

control seleccionado se dividirán en categorías definidas por el control.
o Para visualizar las propiedades de una categoría: se expande el nodo de la

propiedad El signo más (+) permite expandir la propiedad y el signo menos (-)
contraer la propiedad.
o Para visualizar las propiedades alfabéticamente, dé clic en el botón Alfabético

de la ventana de propiedades.
18
Figura 2.7 Cuadro de propiedades.
6. Ventana de depuración de errores: Muestra una lista de los errores que se

generan al realizar modificaciones a los controles o al ejecutar la aplicación.
Figura 2.8 Ventana de lista de errores.
2.3 Crear la interfaz de usuario.
Para crear la interfaz de usuario de la aplicación, en primer lugar se deben ubicar los
controles necesarios en un formulario desde el cuadro de herramientas. Dé clic en el
control que se desea añadir y arrástrelo a la ubicación deseada en el formulario. Para
este caso de ejemplo se diseñara la interfaz de usuario utilizando los siguientes
controles: 3 Label (etiqueta), 1 TextBox (campo de texto), 1 Button (botón) y 1
DataGridView (malla de datos).
Los siguientes pasos permiten:
1. Cambiar la posición de un control: Hacer clic en el mismo para seleccionarlo, y

arrastrarlo a la posición deseada en el formulario.
2. Cambiar el tamaño de un control: Hacer clic en el control para seleccionarlo,
mantener pulsado y arrastrar uno de los extremos de ajuste del tamaño hasta que el
control tenga el tamaño deseado y soltar el botón del mouse.
Cuando existen varios controles del mismo tipo, estos se numeran en el mismo orden en
que son colocados (nombre del control más número del consecutivo). La interfaz de
usuario del ejemplo será como muestra la figura a continuación.
19
Figura 2.9 Prepantalla de la interfaz de usuario.
2.4 Establecer las propiedades de los controles
Después de colocar los controles u objetos a un formulario, se puede establecer sus

propiedades en la ventana Propiedades o en el Editor de código.
Para modificar las propiedades se selecciona el control en el formulario y se
cambia su configuración en la ventana Propiedades. Para el caso del ejemplo
establezca las siguientes modificaciones en la propiedad correspondiente a cada uno de
los siguientes controles:
Tabla 2.2 Propiedades de los controles de la aplicación MiProgramaWF.
Control Propiedad Valor

Label1 Name titulo
Text Generar una tabla de
multiplicar:
Font - Bold True
Label2 Name txtnumero
Text Digite numero:
Label3 Name txttabla
Text La tabla del numero
TextBox1 Name camponumero
Text En blanco
Button1 Name boton
Text Ver tabla
Form1 Name formulario
Text Tablas de multiplicar
La interfaz de usuario con las modificaciones respectivas en las propiedades de

cada control queda como se muestra en la siguiente figura:
20
Figura 2.10 Pantalla final de la interfaz de usuario.
2.5 Escribir código
Una vez se hayan establecido las propiedades iníciales del formulario y sus objetos, se
puede agregar el código que se ejecutará en respuesta a un evento especifico de cada
control. Los eventos ocurren cuando se realizan diferentes acciones sobre un control u
objeto. Por ejemplo, el evento Clic de un botón tiene lugar cuando un usuario hace clic
sobre él con el mouse. Por lo general en las aplicaciones, es necesario escribir código
para lograr el objetivo de dar solución al problema planteado por el usuario. Para
escribir código que se ejecute en un evento determinado de un control, se debe realizar
lo siguiente:
1. Seleccionar el control en el que se desea escribir código.

2. En el menú Ver, dé clic en la opción Código para abrir el Editor de código o doble clic
sobre el control.
3. En la lista Nombre de método, haga clic en el evento deseado para abrir su gestor de
eventos en el Editor de código. El Editor de código muestra las sentencias de
programación que marcan el inicio (Sub) y el final (End Sub) del procedimiento del
evento en particular.
4. Escriba el código entre los puntos inicial y final del cuerpo del procedimiento.
El Editor de código contiene dos listas desplegables en la parte superior de la

ventana: la lista Nombre de Clase a la izquierda y la lista Nombre de método a la
derecha. La lista Nombre de Clase muestra todos los controles del formulario asociado.
Si se hace clic en el nombre de un control de la lista, la lista Nombre de método
muestra todos los eventos de dicho control (los eventos son acciones que se realizan
sobre el control y que la aplicación puede interpretar). Utilizando las listas Nombre de
Clase y Nombre de método conjuntamente, se puede localizar rápidamente y editar el
código de la aplicación.
21
Figura 2.11 Editor de código del objeto boton.
Para el caso del ejemplo dé doble clic en el objeto Button llamado boton y abra
el editor de código, la figura muestra el editor de código del control
Ahora escriba el siguiente código entre Private Sub y End Sub:
With tabla
.Columns.Add("Multiplicando", " Multiplicando ")
.Columns.Add("Multiplicador", " Multiplicador ")
.Columns.Add("Producto", "Producto")
.RowCount = 10
For i As Integer = 0 To .RowCount - 1
.Item(0, i).Value = camponumero.Text
.Item(1, i).Value = i + 1
.Item(2, i).Value = (camponumero.Text * (i + 1))
Next
End With
Este código sirve para rellenar el objeto tabla con los respectivos datos.
Utilizando el método Add de la propiedad Columns se le adicionan los nombres
Multiplicando, Multiplicador, Producto en la primera fila y la propiedad RowCount
se le asigna un valor de 10 filas. Con un ciclo For que se ejecutará desde una posición i
igual a cero (0) hasta el numero de filas -1 del objeto tabla y por cada fila tres ítems. En
la primera columna se imprimirá el valor digitado en el objeto camponumero, en la
segunda columna se imprimirá el valor de i+1, en la tercera columna el producto de
multiplicar el valor del objeto camponumero por i+1.
2.6 Guardar la aplicación
Una vez finalizada la creación de la aplicación, se debe guarda la aplicación dentro del
entorno de desarrollo para asegurar que todos los cambios realizados se almacenen, esto
se puede realizar de la siguiente forma:
 En el menú Archivo, dé clic en Guardar todo.

 O hacer clic en el icono de la barra de herramientas.
Cualquier opción visualizará la siguiente ventana:
22
Figura 2.12 Ventana para Guardar el proyecto.
Se debe seleccionar la ubicación en donde se guardará el proyecto. Al pulsar el

botón Guardar se creará una carpeta con el mismo nombre del proyecto. Dentro de
dicha carpeta se crean los archivos:
1. Un archivo de proyecto .vbproj, el cual contiene información específica para una

determinada tarea de programación.
2. Un archivo de solución .sln, el cual contiene información relacionada con uno o más
proyectos. Siempre elija el archivo solución para abrir un proyecto.
2.7 Ejecutar la aplicación Windows Forms.
Para ejecutar el proyecto en el entorno de desarrollo de Visual Basic.NET se debe

realizar lo siguiente:
1. Hacer clic en el botón Iniciar de la barra de herramientas estándar. También puede
presionar F5 para ejecutar el proyecto. Si la aplicación se ejecuta sin errores,
aparecerá una versión ejecutable del formulario.
2. Cuando termine de ejecutar la aplicación se debe cerrar el formulario para regresar al
entorno de programación.
Cuando se ejecuta un proyecto o solución, automáticamente se crea un archivo

ejecutable (.exe) en la carpeta nombre_carpeta_proyecto\bin\Debug y
nombre_carpeta_proyecto\bin\Release (en el caso del ejercicio el nombre de la
carpeta es MiProgramaWF). Otra forma de generar un archivo ejecutable es seleccionar
en el menú Generar la opción Generar nombre_proyecto.
Para ejecutar la aplicación MiProgramaWF desde el sistema operativo
Windows, existen dos formas de hacerlo: la primera es utilizando el comando Ejecutar
del menú Inicio y buscar el archivo MiProgramaWF.exe que se encuentra en la
carpeta PrimerPrograma\bin\Debug ó PrimerPrograma\bin\Release. La segunda
forma es realizar la búsqueda de la carpeta PrimerPrograma\bin\Debug ó
PrimerPrograma\bin\Release utilizando el explorador de Windows y hacer doble clic
en el nombre del archivo MiProgramaWF.exe para ejecutarlo.
Visual Basic .NET instala de manera automática los archivos de soporte,

incluyendo las bibliotecas de vínculos dinámicos y archivos de .NET Framework.
Visual Studio puede crear dos tipos de archivos ejecutables:
1. Debug: Compilación de depuración, se utiliza cuando se prueba y depura un programa

(Default).
2. Release: Versión de edición, se utiliza cuando se termina el programa siendo esta una
versión optimizada de menor tamaño
23
Si se escribe el número 5 en el campo de texto y se pulsa el botón Ver Tabla, se
visualizará la siguiente figura.
Figura 2.13 Aplicación MiProgramaWF ejecutado.
2.8 Cerrar y Abrir un proyecto Windows Forms.
Para cerrar el proyecto MiProgramaWF o cualquier otro proyecto, en modo diseño se

pueden realizar los siguientes pasos:
1. En el menú Archivo, hacer clic en la opción Cerrar Proyecto.

2. Si desea cerrar el proyecto y salir de Visual Studio, en el menú Archivo haga clic en la
opción Salir.
En cada caso se deben guardar los nuevos cambios que se hayan realizado.
Para volver a abrir la aplicación MiProgramaWF o cualquier otra aplicación

existente se deberán realizar los siguientes pasos:
1. Abrir Visual Studio .NET.

2. Si en la pantalla inicial de Visual Studio .NET se visualiza el nombre del proyecto que
se desea abrir haga doble clic para abrir la aplicación. Si por el contrario no se visualiza
la aplicación en el menú Archivo, seleccione Abrir proyecto..., busque la carpeta
MiProgramaWF y seleccione el archivo MiPrograma.sln y pulse la opción Abrir para
abrir la aplicación en el entorno de desarrollo de Visual Basic .NET.
24
3. FUNDAMENTOS DE VISUAL BASIC .NET
Para iniciar el conocimiento del mundo Visual Basic .NET, es necesario conocer
conceptos fundamentales como: creación de variables, constantes, tipos de datos, tipos
de operadores, definición de comentarios, expresiones, etc.
3.1 Variables
Una variable es un espacio de memoria para almacenar un valor de un determinado

tipo de dato dentro de un programa. El valor de la variable puede ser modificado
durante la ejecución del programa. El nombre de la variable puede contener letras,
números, etc., los nombres de las variables deben aportar información que permita
identificar el tipo de información que se va a almacenar. Para declarar una variable se
utiliza la palabra clave Dim. El formato para declarar variables es:
Dim nombre_variable As tipo_de_dato
Después de declarar el tipo de variable, se le puede asignar un valor inicial de la

siguiente forma:
nombre_variable= valor_inicial
También es posible declarar una variable con el siguiente formato:
Dim nombre_variable As tipo_de_dato = valor_inicial
Las variables pueden ser locales o globales. Las variables locales son aquellas
que se crean dentro de un bloque específico de programación y se destruirán al
finalizarse el bloque de programación.
Ejemplo:
Private Sub función ()
Dim var_local As Integer (variable local)
var_local=10
……
End Sub
Las variables globales son aquellas que pueden ser modificadas desde cualquier
punto de un programa.
Ejemplo:
Public Class Variables_Globales
Public var_global As Integer (variable global)
Private Sub función ()
Dim var_local As integer
var_global=10 (valor modificado en la función1 ())
::::::::
End Sub
Private Sub función2 ()
Dim var_local As integer
var_global=20 (valor modificado en la función2 ())
::::::::::
End Sub
::::::::::::::::
End Class
25
3.2 Constantes
Son variables que permanecen constantes durante el desarrollo del programa. Existen
constantes numéricas, de carácter, lógicas, etc. El formato de la declaración de una
variable constante es:
Const nombre_variable As tipo_de_dato= valor_constante

Ejemplo:
Const miconstante As Integer= 10
3.3 Tipos de datos
Un tipo de dato define todo el posible rango de valores que una variable puede tomar al
momento de la ejecución de un programa y a lo largo de toda la vida útil del propio
programa. Para seleccionar un tipo de dato en un programa se debe tener en cuenta el
que mejor se adapte a los datos. Por ejemplo, si un programa necesita almacenar valores
entre -20000 y 30000, los tipos de datos que se podrían utilizar serían short, long,
integer. Si utiliza el tipo de dato short, la aplicación utilizaría menos memoria para
almacenar el valor de la variable. A continuación se presenta la tabla con los tipos de
datos que soporta Visual Basic .NET y su respectivo tamaño.
Tabla 3.1 Tipos de datos de Visual Basic .NET.
Tipo Valores Tamaño

Boolean Representa un valor verdadero (True) o falso (False). 2 bytes
Byte Representa un valor de 8 bits en un rango entre 0 y 255. 1 byte (0-255)
Char Representa un carácter de 16 bits. 2 bytes (0-65535)
DateTime Representa un valor de fecha y hora. 8 bytes
Decimal Representa un valor de 28 dígitos significativos. De +/- 12 bytes
7,9228162514264337593543950335.
Double Representa un valor en coma flotante de 64 bits. De - 8 bytes
1,79769613486231570E+308 a -
4,94065645841246544E-324 para valores negativos;
4,94065645841246544E-324 a
1,79769613486231570E+308 para valores positivos.
Integer Representa un valor entre un rango de +/-2,147,483,698 4 Bytes
Long Representa un valor entre un rango de +/- 8 Bytes
9.223.372.036.854.775.807
Short Representa un valor entre un rango de +/- 32.677 2 Bytes
Single De -3,4028235E+38 a -1,401298E-45 para los valores 4 bytes
negativos; 1,401298E-45 a 3,4028235E+38 para los
valores positivos.
String Cadena de caracteres 0 a 2 millones de
caracteres.
3.3.1 Ejemplo práctico tipos de datos
Realizar una aplicación Windows Forms llamado TiposdeDatos que permita a un

usuario visualizar en cajas de texto los diferentes tipos de datos cuando se pulse un
botón llamado Tipos de Datos. Además poder salir de la aplicación utilizando un botón
llamado Salir.
26
 Iniciar un nuevo proyecto Visual Basic .NET
1. En el menú Archivo, dé clic en Nuevo Proyecto….

2. En el panel Tipos de proyecto, haga clic en Visual Basic luego en Windows. En el
panel Plantillas, haga clic en Aplicación de Windows Forms.
3. En el cuadro Nombre escriba TiposdeDatos y a continuación dé clic en el botón
Aceptar.
 Crear la interfaz de usuario
Utilizando el cuadro de herramientas haga clic en el control específico y ubique los

siguientes controles en el formulario en la posición deseada: 10 Label, 10 Textbox, 2
Button. La figura 3.1., muestra la interfaz de usuario para la aplicación TiposdeDatos.
Figura 3.1 Interfaz de usuario (tipos de datos).
 Establecer las propiedades de los objetos del interfaz de usuario
Después de colocar los controles u objetos a un formulario, se puede establecer sus

Para modificar las propiedades se selecciona el control en el formulario y se

cambia su configuración en la ventana Propiedades. Para el caso del ejemplo,
establezca las modificaciones a los controles que se muestran en la tabla 3.2:
27
Tabla 3.2 Propiedades de los controles de la aplicación TiposdeDatos.

Label1 Name lblboolean
Text Boolean:
Label2 Name lblbyte
Text Byte:
Label3 Name lblchar
Text Char:
Label4 Name lblfechora
Text Fecha/Hora:
Label5 Name lbldecimal
Text Decimal:
Label6 Name lbldouble
Text Double:
Label7 Name lblinteger
Text Integer:
Label8 Name lbllong
Text Long:
Label9 Name lblshort
Text Short:
Label10 Name lblstring
Text String:
TextBox1…TextBox10 Name Txtcampo1…txtcampo10
Text En blanco
Button1 Name boton
Text Tipos de Datos
Button2 Name botonsalir
Text Salir
Text Tipos de datos en Visual
Basic .NET
 Escribir código
Una vez se hayan establecido las propiedades iníciales del formulario y sus objetos, se
puede agregar código que se ejecutará en respuesta a eventos.
Para escribir código que se ejecute en un evento determinado del control, realice
lo siguiente:
1. En el Explorador de soluciones, seleccione el control para el que desea escribir

código.
2. Escriba el código entre el punto inicial (Sub) y final del cuerpo (End Sub) del
procedimiento.
Para el ejemplo, dé doble clic sobre el objeto boton para ver el editor de código,
la figura 3.2, muestra el editor de código del control.
Figura 3.2 Editor de código del control boton de la aplicación TiposdeDatos.
Public Class formulario
28
Private Sub boton_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)
Handles boton.Click
:::::::::::::::,
End Sub
End Class
Entre Sub y End Sub escriba el siguiente código:
Dim boleana As Boolean = False

Dim bytes As Byte = 101
Dim caracter As Char = "a"
Dim fechas_hora As Date
Dim con_decimal As Decimal = 10.23
Dim entera As Integer = 32000
Dim doble As Double = 63528457
Dim larga As Long = 100258479
Dim corta As Short = 27000
Dim cadena As String = "hola mi gente"
txtcampo1.Text = boleana
txtcampo2.Text = bytes
txtcampo3.Text = caracter
txtcampo4.Text = fechas_hora
txtcampo5.Text = con_decimal
txtcampo6.Text = doble
txtcampo7.Text = entera
txtcampo8.Text = larga
txtcampo9.Text = corta
txtcampo10.Text = cadena
En el anterior código se definen las diferentes variables determinando el tipo de

dato que almacenarán respectivamente. Además se inicializan las variables con los
valores apropiados para cada tipo de dato. La variable fechas_hora es la única que no
es inicializada, en dicha variable se almacenará los valores predeterminados de tipo
Date del sistema operativo. Por último se le asigna a la propiedad Text de cada control
txtcampo1…10 la respectiva variable. Cuando el usuario pulse el botón en tiempo de
ejecución se mostrará en cada cuadro de texto el valor respectivo de la variable que ha
sido asignada.
Después dé doble clic sobre el objeto botonsalir, para abrir el editor de código y escriba
el siguiente código:
End
Se utiliza la instrucción End para detener la ejecución de una aplicación. Visual

Basic .NET dispone de varias palabras reservadas que no pueden ser utilizadas como
variables, este tema será tratado más adelante.
 Guardar la aplicación
Una vez finalizada la creación de la aplicación, se guarda dentro del entorno de

desarrollo para asegurar que se almacenen los cambios realizados en los diferentes
objetos que contiene la aplicación, esto lo puede realizar de la siguiente forma:
 En el menú Archivo, dé clic en Guardar todo.

 O haga clic en el icono de la barra de herramientas
29
 Ejecutar el proyecto
Para ejecutar el proyecto en el entorno de desarrollo de Visual Basic.NET se debe

 Haga clic en el botón Iniciar de la barra de herramientas estándar. También
puede presionar F5 para ejecutar el proyecto. Si la aplicación se ejecuta sin
errores, aparecerá una versión ejecutable de la aplicación. Al pulsar el botón
Tipos de Datos, se visualizará la siguiente figura:
Figura 3.3 Ejecución aplicación TiposdeDatos.
Si desea salir de la aplicación pulse el botón Salir para regresar al entorno de

programación.
3.4 Funciones de conversión de tipos de datos
Son funciones que se utilizan para realizan conversión a un tipo de dato diferente al que
inicialmente estaba estipulado en una variable. Estas funciones generalmente forman
parte del código de un programa. Su formato es:
Objeto_nuevo_tipo=nombre_función_de_conversion (expresión).
Donde expresión es el tipo de datos actual. Algunas funciones de conversión se

presentan en la siguiente tabla:
30
Tabla 3.3 Funciones de conversión.
Función Tipo de dato devuelto Ejemplo

CBool Booleano Dim x,y As Integer
Dim valor as Boolean
x=10
y=10
valor = CBool(x=y) ‘Devuelve verdadero
(True).
CByte Byte Dim x As Double
Dim valor as Byte
x=10.5658
valor = CByte(x) ‘Devuelve 11.
CChar Char Dim x As String
Dim valor as Char
x=”ABC”
valor = CChar(x) ‘Devuelve A. Solo convierte
el primer carácter a Char.
CDbl Double Dim x As Decimal
Dim valor as Double
x=158.2459
valor = CDbl(x) ‘Devuelve 158,2459.
CDate Fecha Dim x As String
Dim valor as Date
x=”Agosto 30, de 2010”
valor = CDate(x) ‘Devuelve 30/8/2010.
CDec Decimal Dim x As Double
Dim valor as Decimal
x=16547.2358
valor= CDec(x) ‘Devuelve 16547,2358.
CInt Entero Dim x As Double

Dim valor as Integer
x=16.23
valor= CInt(x) ‘Devuelve 16.
CLng Long Dim x As Double
Dim valor as Long
x=1658.55
valor= CLng(x) ‘Devuelve 1659. En la parte
decimal se aproxima al entero superior si es
>=.5 y al entero inferior si es <.5.
CShort Short Dim x As Double
Dim valor as Long
x=1658.49
valor= CShort(x) ‘Devuelve 1658. Se
aproxima al entero superior si es >=.5 y al
entero inferior si es <.5.
Str String Dim x As Integer
Dim valor as String
x=15
valor= Str(x) ‘Devuelve el String “15”.
Val Numérico Dim x As String
Dim valor as Integer
x=”15”
valor= Val(x) ‘Devuelve el número 15.
31
3.5 Operadores y Expresiones
Los operadores son símbolos que pueden realizar acciones sobre uno o dos operandos.
Se clasifican en: aritméticos, relacionales, lógicos, de asignación. Las expresiones son
combinaciones de constantes, variables, símbolos de operaciones, paréntesis.
3.5.1 Operadores aritméticos
Se utilizan para crear expresiones aritméticas, estas pueden resultar de la unión de

variables o constantes con operadores.
Tabla 3.4 Operadores Aritméticos.
Operadores de Visual Operador Expresión

Basic .NET
Suma + numero1 +numero2
Resta - numero1 – numero2
Multiplicación * numero1 * numero2
División / numero1 / numero2
División entera \ numero1 \ numero2
Residuo mod numero1 mod numero2
Exponenciación ^ numero1 ^ numero2
3.5.2 Operadores relacionales
Se utilizan para la toma de decisiones que se puedan necesitar dentro de un programa.
Tabla 3.5 Operadores relacionales.
Operadores Operador Expresión

Relacionales
Mayor que > variable1>variable2
Mayor o igual que >= variable1>=variable2
Menor que < variable1<variable2
Menor o igual que <= variable1<=variable2
3.5.3 Operadores de igualdad
Se utilizan para asignar o comparar valores dentro de un programa.
Tabla 3.6 Operadores de igualdad.
Operadores de Operador Expresión

Igualdad
Diferente <> variable1<>variable2
De asignación ó = variable1=valor
Igual a variable1=variable2
32
3.5.4 Operadores Lógicos
Al igual que los operadores de relación se utilizan para la toma de decisiones.
Tabla 3.7 Operadores lógicos.
Operadores Operador Expresión

lógicos
Y And Es verdadero, si al evaluar cada uno de los operandos el
resultado es verdadero, si uno de los operandos es falso el
resultado será falso.
También Y AndAlso Es falso, si al evaluar el primer operando el resultado es
falso, el segundo operando no es evaluado.
O Or Es falso, si al evaluar cada uno de los operandos el
resultado es falso, si uno de los operandos es verdadero el
resultado será verdadero.
También O OrElse Es verdadero, si al evaluar el primer operando el resultado
es verdadero, el segundo operando no es evaluado.
Negación Not El resultado de aplicar este operando es falso si al evaluar
su operando el resultado es verdadero, y verdadero en caso
contrario.
Xor Da como resultado verdadero, si al evaluar cada uno de los
operando uno de ellos es verdadero y el otro falso, caso
contrario es falso.
3.5.5 Ejemplo práctico operadores aritméticos
Realizar una aplicación llamada OperadoresAritmeticos que permita a un usuario

visualizar en cajas de texto las operaciones aritméticas básicas cuando se pulse un botón
llamado Operadores Aritméticos.
 Iniciar un nuevo proyecto Visual Basic .NET
1. 1. En el menú Archivo, dé clic en Nuevo Proyecto….

2. En el panel Tipos de proyecto, haga clic en Visual Basic luego en Windows. En el
panel Plantillas, haga clic en Aplicación de Windows Forms.
3. En el cuadro Nombre escriba OperadoresAritmeticos y a continuación haga clic en el
botón Aceptar.

Button.
 Establecer las propiedades de los objetos de la interfaz de usuario
Después de colocar los controles u objetos en el formulario, se establecen las

propiedades en la ventana Propiedades o en el Editor de código. Para el caso del
ejemplo establezca las siguientes modificaciones a los controles:
33
Tabla 3.8 Propiedades de los controles del proyecto OperadoresAritméticos.

Label1 Name lblsuma
Text Suma
Label2 Name lblresta
Text Resta:
Label3 Name lblmultiplicacion
Text Multiplicación
Label4 Name lbldivision
Text División
Label5 Name lbldiventera
Text División Entera
Label6 Name lblresiduo
Text Residuo
Label7 Name lblexponeniacion
Text Exponenciación
TextBox1…TextBox7 Name txtcampo1…txtcampo7
Text En blanco
Button1 Name boton
Text Operadores Aritméticos
Button2 Name botonsalir
Text Salir
Text Operadores Aritméticos
en Visual Basic .NET
La interfaz de usuario queda como se muestra en la siguiente figura:
Figura 3.4 Interfaz de usuario (OperadoresAritméticos).
34
Seleccione el objeto boton y abra el editor de código y escriba el siguiente código:
Dim valor_uno, valor_dos As Integer

valor_uno=8
valor_dos=5
txtcampo1.Text = valor_uno + valor_dos
txtcampo2.Text = valor_uno - valor_dos
txtcampo3.Text = valor_uno * valor_dos
txtcampo4.Text = valor_uno / valor_dos
txtcampo5.Text = valor_uno \ valor_dos
txtcampo6.Text = valor_uno mod valor_dos
txtcampo7.Text = valor_uno ^ valor_dos
En el anterior código se definen las variables valor_uno y valor_dos de tipo

Integer. Luego en dichas variables se almacenan los valores 8 y 5 respectivamente.
También se le asigna una operación aritmética en la propiedad Text de cada caja de
texto. Cuando el usuario pulse el botón Operadores Aritmeticos en tiempo de
ejecución mostrará en cada cuadro de texto el valor respectivo de la operación que le
fue asignada.
Para ejecutar el proyecto en el entorno de desarrollo de Visual Basic.NET, se debe

 Haga clic en el botón Iniciar de la barra de herramientas estándar. También puede
presionar F5 para ejecutar el proyecto. Si la aplicación se ejecuta sin errores,
aparecerá una versión ejecutable del formulario y al pulsar el botón “Operadores
Aritméticos”, se visualizará la siguiente figura:
Figura 3.5 Ejecución aplicación Operadores Aritméticos .
35
3.6 Palabras clave
Las palabras clave son identificadores predefinidos que tiene significado especial para
el compilador de Visual Basic .NET. Por lo tanto, una variable o constante definida por
el usuario no puede tener el mismo nombre de una palabra clave. Las palabras clave de
Visual Basic .NET se muestran en la siguiente tabla:
Tabla 3.9 Palabras Clave.
Palabras Clave
AddHandler AddressOf ÁndAlso Alias And
Ansi As Assembly Auto Boolean
ByRef Byte Byval Call Case
Match CBool CByte CChar Cdate
CDec CDbl Char CInt Class
CLng CObj Const CShort CSng
CStr CType Date Decimal Declare
Default Delegate Dim DirectCast Do
Double Each Else ElseIf End
Enum Erase Error Event Exit
False Finally For Friend Function
Get GetType GoTo Handles If
Implements Imports In Inherits Integer
Interface Is Lib Like Long
Loop Me Mod Module MustInherit
MustOverride MyBase MyClass Namespace New
Next Not Nothing NotInhertable NotOverridable
Object On Option Optional Or
OrElse Private Property Protected Public
RaiseEvent ReadOnly ReDim Rem RemoveHandler
Resume Return Select Set Shadows
Shared String Structure Static Step
Stop Short Single Sub SyncLock
Then Throw To True Try
Typeof Unicote Until When While
UIT WithEvents WriteOnly Xor
3.7 Comentarios
Para establecer o definir un comentario se utiliza la comilla simple (‘) al inicio del
comentario. Cada comentario debe ir en una sola línea.
Ejemplo:
‘ Este es un comentario
36
4. ESTRUCTURAS DE CONTROL
Cuando se escriben programas a veces es necesario determinar un control del flujo de

ejecución de acuerdo a los cambios que sufran los diferentes tipos de datos. Entonces
cuando se requiere realizar programas más complejos se debe utilizar estructuras de
control que evalúen algunos resultados para determinar qué proceso u operación se debe
ejecutar. En Visual Basic .NET existen palabras clave que permiten tener un control del
flujo de ejecución como lo son las sentencias de toma de decisiones (If, If-Else, Select)
y las estructuras repetitivas (For-Next, While, Do-Loop While, For-Each).
4.1 Estructura de control If - Else
4.1.1 Sentencia If
Representa una toma de decisión sencilla, es decir, si la condición que se evalúa es

verdadera se realizan las instrucciones que pertenezcan al bloque If y continuará con el
resto del programa. Si la condición es falsa no entrará al bloque If y por consiguiente
todas las instrucciones que están en el If no se ejecutarán. Cada vez que se utilice un If
se debe finalizar con EndIf. Su formato es:
1) If (condición) Then
Instrucción(es) a ejecutarse si la condición es verdadera
::::::::
Endif
Resto del programa
Si la condición del If es verdadera se realiza la instrucción y continúa con el

resto del programa.
2) If (condición) Then Instrucción a ejecutarse si la condición es verdadera

Resto del programa
Si la condición del If es verdadera y se requiere realizar solo una instrucción no

es necesario EndIf.
. 3) If (condición) Then
:::::::
If (condición) Then
::::::::
Endif
Endif
Resto del programa
Se pueden anidar varios If, es decir, uno entre otro, para ingresar cada vez al If
más interno es necesario que la condición sea verdadera. Se debe tener en cuenta que
por cada bloque If que se realice debe existir una finalización EndIf. También se
pueden utilizar los operadores lógicos (And, Andalso, Or, OrAlso, Xor, Not) para
concatenar varias condiciones. Si se utiliza el operador lógico And, cada una de las
condiciones debe ser verdadera para que ingrese al If y se ejecuten las instrucciones. En
el caso del operador Or, si una de las condiciones es verdadera ingresara al If y
ejecutará las instrucciones.
37
4) If (condición1 And condicion2…) Then
Instrucción(es) a ejecutarse si las condiciones son verdaderas
:::::::
Endif
Resto del programa
Ó
If (condición1 Or condicion2…) Then
Instrucción(es) a ejecutarse si alguna de las condiciones es verdadera
::::::::
Endif
Resto del programa
Además de utilizar los operadores lógicos, también se puede recurrir a los

operadores relaciones (<, >, >=, <=), con el fin de evaluar una o más variables para
determinar su valor verdadero para que ingrese al If y se ejecuten las instrucciones
correspondientes.
5) If (condición1 > condicion2) Then

::::::::
Endif
Resto del programa
Ó
If (condición1 > condicion2 And condicion1 > condicion3) Then

::::::::
Endif
Resto del programa
Ó
If (condición1 > condicion2 Or condicion1 > condicion3) Then

::::::::
Endif
Resto del programa
4.1.2 Sentencia If- Else
Es una estructura compuesta que evalúa una condición. Si esta es verdadera realizará las
instrucciones contenidas en el bloque If, en caso contrario ingresará por el bloque Else.
El programa solo tomará una de las dos alternativas y continuará con el resto del
programa. Su formato es el siguiente:
If (condición) Then
::::::::
Else
Instrucción(es) a ejecutarse si la condición es falsa
::::::::
Endif
Resto del programa
Como en el caso de la toma de decisión If simple también se puede utilizar los

operadores lógicos y relaciones, además se pueden anidar varios If – Else.
38
4.1.3 If (operador)
Se utiliza para una toma de decisión múltiple donde se devolverá uno de dos valores al
evaluar una expresión. Su formato es:
If (condición, primer_argumento_por_verdad, segundo_argumento_por_falso)

Ejemplo:
Dim valor As integer
Dim respuesta As String
valor=3
respuesta =If (valor>0,”Positivo”, “Negativo”) ‘Devuelve Positivo
Resto del programa
Dado que la expresión If (operador) utiliza la evaluación de cortocircuito, evalúa

el primer argumento o el segundo argumento, con respecto al valor de la condición. Si
el valor de la condición es True (verdadero) el número no es negativo y es seguro
evaluar el primer argumento y por consiguiente devuelve Positivo. Si el valor de la
condición es False (falso) sólo se evalúa el segundo argumento y se devuelve Negativo.
4.1.4 IIF
Es parecido a la estructura If (operador), la diferencia radica en que la estructura IIF

evalua los dos argumentos sin importar que al evaluar una expresión sea True o False.
IIF (condición, primer_argumento_por_verdad, segundo_argumento_por_falso)

Ejemplo:
Dim valor As integer
valor=3
respuesta =IIF (valor>0,”Positivo”, “Negativo”) ‘Devuelve Positivo
Resto del programa
4.1.5 Ejemplo estructura If-Else
Crear una aplicación Windows Forms llamada EstructuraIfElse que permita a un

usuario capturar en cajas de texto con formato de hora militar las horas, los minutos y
los segundos e imprimir las horas, los minutos y los segundos un segundo después.
OBSERVACIÓN: Se supondrá que el usuario digitara las horas entre 0 y 23, los
minutos y segundos entre 0 y 59.
Ejemplo:
H M S +1 un H M S
segundo
17 15 25 17 15 26
13 44 59 13 45 0
18 59 59 19 0 0
23 59 59 0 0 0
NOTA: a partir de este capítulo se omitirán pasos que se supone que el lector ya maneja
como son: iniciar un nuevo proyecto, escoger los controles y los pasos para ejecutar el
39
proyecto.

Button.
Figura 4.1 Interfaz de usuario inicial (EstructuraIfElse).
Para el caso del ejemplo establezca las siguientes modificaciones a los controles:
Tabla 4.1 Propiedades de los controles del proyecto TomadeDecisiones.

Label1 Name lblhoras
Text Digite la hora:
Label2 Name lblminutos
Text Digite los minutos:
Label3 Name lblsegundos
Text Digite los segundos:
Label4 Name Lblhora
Text Horas:
Label5 Name Lblminuto
Text Minutos
Label6 Name lblsegundo
Text Segundos:
TextBox1 Name hora
Text En blanco
TextBox2 Name minuto
Text En blanco
TextBox3 Name segundo
Text En blanco
TextBox4 Name horas
Text En blanco
40
TextBox5 Name minutos
Text En blanco
TextBox6 Name segundos
Text En blanco
Button1 Name boton
Text Más un segundo
Text Toma de decisiones (If-Else) en Visual Basic .NET
Figura 4.2 Interfaz de usuario final (EstructuraIfElse).
Seleccione el objeto boton, dé doble clic para abrir el editor de código boton_Click y
escriba el siguiente código:
Dim H, M, S As Integer
H = horas.Text
M = minutos.Text
S = segundos.Text
If(H = 23 And M = 59 And S = 59) Then
H=0
M=0
S=0
Else
If (M = 59 And S = 59) Then
H=H+1
M=0
S=0
Else
If (S = 59) Then
M=M+1
S=0
Else
S=S+1
End If
End If
41
End If
hora.Text = H
minuto.Text = M
segundo.Text = S
Se utiliza la sentencia Dim para definir las variables de tipo entero H, M, S y a

dichas variables se les asigna el valor capturado en la propiedad Text de los campos de
texto horas, minutos y segundos. Con una primera estructura If se evalúa si el valor de
H es igual a 23, el de M es igual a 59 y el de S igual a 59, si se cumple la condición se
le asigna a las variables el valor de cero (0). Si no se cumple la condición por falso
(Else) se evaluará los valores de M y S. Si estos son iguales a 59, se incrementará en
uno (+1) el valor de la variable H y a las variables M y S se les asignará el valor cero
(0). Si tampoco la condición es verdadera se evaluará el valor de S. Si esta es igual a 59,
se incrementa en uno (+1) el valor de la variable M y a S se le asignará el valor de cero
(0). Por otro lado, si tampoco se cumple la condición se incrementará S en uno (+1). Al
determinarse los valores de H, M, S se imprimirá en los campos de texto hora, minuto,
segundo en la propiedad Text dichos valores respectivamente.
Al ejecutarse el proyecto en el entorno de desarrollo de Visual Basic.NET y al digitar en

el campo horas 23, en el campo minutos 59, en el campo segundos 59 y después pulsar
el botón Más un segundo, se visualizará la siguiente pantalla:
Figura 4.3 Ejecución aplicación EstructuraIfElse.
4.2 Sentencia Select
Es una toma de decisión con varias opciones, esto es, según sea el valor (entero o
caracter) de una variable escogerá un caso entre varias alternativas. Su formato es:
Select (variable)
Case expresion1
instrucciones1
Case expresion2
instrucciones2
42
...
...
[Case Else]
instruccionesN
End Select
La expresión1, expresion2……expresiónN representan una lista de expresiones

que pueden tener cada Case y se puede expresar de las siguientes formas:
Case Is <y ‘ variable < y

Case 3 ‘ variable =3
Case y to 10 ‘ variable = y, y+1,…..,10
Case 3, x ‘ variable = 3, x
Case -5, w To 5 ‘ variable = -1, w, w+1….,5
Case “dato”, “DATO” ‘ variable =”dato”, “DATO”
Case Is >=200 ‘ variable >=200
Cuando se ejecuta Select, se evalúa la variable y busca el primer caso (Case)

que incluya el valor evaluado. Si no existe un valor igual a la variable, se ejecuta(n)
la(s) instrucción (es) a continuación del Case Else (opcional), si se ha especificado.
4.2.1 Ejemplo estructura Select
Diseñar una aplicación Windows Forms llamada EstructuraSelect que permita a un

usuario digitar en una caja de texto un número e imprimir el nombre del día de dicho
numero.

Button.
Figura 4.4 Interfaz de usuario inicial (EstructuraSelect).
43
Tabla 4.2 Propiedades de los controles del proyecto EstructuraSelect.

Label1 Name lblnumero
Text Digite un número:
Label2 Name lbldia
Text El día de la semana es:
TextBox1 Name numero
Text En blanco
TextBox2 Name dia
Text En blanco
Button1 Name boton
Text Visualizar día
Text Estructura Select
Figura 4.5 Interfaz de usuario final (EstructuraSelect).
Dim valor As Integer
valor = numero.Text
Select Case valor
Case Is = 1
dia.Text = "Lunes"
Case Is = 2
dia.Text = "Martes"
44
Case Is = 3
dia.Text = "Miercoles"
Case Is = 4
dia.Text = "Jueves"
Case Is = 5
dia.Text = "Viernes"
Case Is = 6
dia.Text = "Sábado"
Case Is = 7
dia.Text = "Domingo"
Case Else
dia.Text = "No es un dia de la semana"
End Select
Se define la variable de tipo entero valor, a dicha variable se le asigna el valor

capturado en la propiedad Text del campo de texto numero. Utilizando la estructura
Select se evalúa lo capturado para determinar el nombre del día de la semana. En caso
de que no exista el día de la semana se imprimirá el mensaje “No es un día de la
semana”.
Al ejecutarse el proyecto, si se escribe el número cinco (5) en el campo de texto y se

pulsar el botón Visualizar el día, se mostrará la siguiente pantalla:
Figura 4.6 Ejecución aplicación EstructuraSelect.
4.3 Estructura For-Next
Sirve para repetir una o varias instrucciones, usando una variable que por lo general es
llamada contador; esta estructura inicializa el contador y evalúa su valor por medio de
una condición, si esta es verdadera se ejecutarán las instrucciones del ciclo y aumentará
o disminuirá el contador automáticamente, de lo contrario se finalizará el ciclo. Su
formato es:
For variable =expresion1 To expresión2 [Step expresion3]
Instruccion(es)
::::::::
Next
45
El valor de variable es inicializado con el valor que contenga expresion1.
Expresion2 representa el valor final del ciclo repetitivo. La sentencia Step es opcional,
por defecto sino existe dicha sentencia el incremento será de uno (1), si por el contrario
se utiliza la sentencia Step se pueden realizar incrementos o decrementos diferentes de
uno (1).
4.3.1 Ejemplo estructura For-Next
Elaborar una aplicación llamada EstructuraForNext que permita a un usuario digitar

10 números en una caja de texto. Cada número digitado se debe imprimir en otro campo
de texto. También se debe imprimir la sumatoria de los números capturados.

Button.
Figura 4.7 Interfaz de usuario inicial (EstructuraForNext).
Tabla 4.3 Propiedades de los controles del proyecto EstructuraForNext.

Label1 Name lblnumeros
Text Números capturados
TextBox1 Name numero
Text En blanco
MultiLine True
ScrollBar vertical
Button1 Name boton
Text Capturar 10 números
46
Text Estructura For-Next
Figura 4.8 Interfaz de usuario final (EstructuraForNext).
Dim inicio, valor, suma As Integer
For inicio = 1 To 10
valor = InputBox("Digite numero", "Captura de números")
numero.Text = numero.Text & valor & vbCrLf
suma = suma + valor
Next
numero.Text = numero.Text & vbCrLf & "La sumatoria es: " & suma
Se definen las variables de tipo entero inicio, valor, suma. Se inicializa un ciclo
For que se repetirá 10 veces. En él se le asigna a la variable valor los diferentes
números capturados con la función InputBox (Esta función permite capturar un valor
por teclado; en este caso, solamente se utilizan dos parámetros: el primero para
establecer un mensaje y el segundo para un titulo). Por otro lado, al control numero en
su propiedad Text se le asigna el contenido que tenga en ese momento concatenado con
el valor capturado y un salto de carro (vbcrlf); la variable suma guardará la sumatoria
de los valores capturados. Al salir del ciclo For se imprimirá en el objeto numero el
texto “La sumatoria es:” unido con el valor de la variable suma.
Al ejecutarse el proyecto y pulsar el botón Capturar 10 números se mostrará el cuadro
de captura:
47
Figura 4.9 Cuadro para capturar los números.
Al escribir los números: 3, 15, 6, 8, 23, 5, 14, 9, 1, 10, se visualizará la siguiente

figura:
Figura 4.10 Ejecución aplicación EstructuraForNext.
4.4 Estructura While
Sirve para repetir una secuencia de instrucciones siempre que la condición evaluada sea
verdadera. Si al evaluarse la condición es falsa no ingresará al ciclo y continuará con el
resto del programa. Su formato es:
While (condición)
Instruccion(es)
::::::::
incremento ó decremento
End While
Resto del programa
48
4.4.1 Ejemplo estructura While
Crear una aplicación llamada EstructuraWhile que permita a un usuario digitar 10

números e imprimir el mayor y el menor de dichos números.

Button.
Figura 4.11 Interfaz de usuario inicial (EstructuraWhile).
Tabla 4.4 Propiedades de los controles del proyecto EstructuraWhile.

Label1 Name lbmayor
Text El mayor es:
Label2 Name lblmenor
Text El menor es:
TextBox1 Name mayor
Text En blanco
TextBox2 Name menor
Text En blanco
Button1 Name boton
Text Estructura While
49
Figura 4.12 Interfaz de usuario final (EstructuraWhile).
Dim contador, valor, nmayor, nmenor As Integer
contador = 1
While (inicio <= 10)
valor = InputBox("Digite numero", "Captura de números")
If (contador = 1) Then
nmayor = valor
nmenor = valor
End If
If (nmayor < valor) Then
nmayor = valor
End If
If (nmenor > valor) Then
nmenor = valor
End If
mayor.Text = nmayor
menor.Text = nmenor
contador = contador + 1
End While
En el anterior código se definen las variables contador, valor, nmayor, nmenor

de tipo Integer. Se inicializa la variable contador con un valor de uno (1), luego se crea
un ciclo While que permitirá ejecutar una serie de instrucciones mientras contador sea
menor o igual a 10. Dentro del ciclo a la variable valor se le asigna el número capturado
en la función predeterminada Inputbox (cuadro de captura). Cuando se captura el
primer valor la variable contador tiene un valor de 1, lo cual permite ingresar por única
vez a la primera sentencia de control If donde se le asigna a nmayor y nmenor el valor
de la variable valor. A dicha instrucción solo se ingresará una vez pues más adelante se
incrementa la variable contador y por consiguiente obtendría un valor mayor de 1. En
las siguientes sentencias se evalúa las variables nmayor y nmenor respectivamente con
la variable valor para determinar si a dichas variables se les asigna un nuevo valor. Por
otro lado, se le asigna a los campos de texto mayor y menor en su propiedad Text los
valores de las variables nmayor y nmenor y además se incrementa la variable
50
contador en 1 para que al digitar los 10 valores se pueda salir del ciclo While.
Al ejecutarse el proyecto y pulsar el botón Capturar 10 números se mostrará el cuadro

de captura:
Figura 4.13 Cuadro para capturar los números.
Al escribir los números: 3, 15, 6, 8, 23, 5, 14, 9, 1, 10, se visualizará la siguiente

figura:
Figura 4.14 Ejecución aplicación EstructuraWhile.
4.5 Do-Loop While
Existen muchas situaciones en las que se desea que un ciclo se ejecute al menos una vez
antes de comprobar la condición de repetición. En la estructura While si el valor de la
expresión booleana es inicialmente falso, las instrucciones del ciclo no se ejecutarán;
por ello, se necesitan otros tipos de estructuras repetitivas como Do-Loop While, que se
ejecuta por lo menos una vez. Su formato es:
51
Do
Instrucción(es)
::::::::
incremento ó decremento
Loop While (condición)
4.5.1 Ejemplo estructura Do-Loop while
Escribir una aplicación llamada EstructuraDoLoopWhile que permita a un usuario

capturar N números. El usuario podrá decidir si continua o no capturando números. Al
terminar de digitar se debe visualizar la sumatoria de los números capturados.

Button.
Figura 4.15 Interfaz de usuario inicial (EstructuraDoLoopWhile).
Tabla 4.5 Propiedades de los controles del proyecto EstructuraDoLoopWhile

Text Números capturados
Label2 Name lblsuma
Text La suma de los números fue:
TextBox1 Name camponumeros
Text En blanco
52
MultiLine True
ScrollBar vertical
TextBox2 Name camposuma
Text En blanco
Button1 Name boton
Text Estructura Do – Loop While
Figura 4.16 Interfaz de usuario final (EstructuraDoLoopWhile).
Dim valor, suma As Integer
Do
valor = InputBox("Digite número:", "Capturar números")
camponumeros= camponumeros & valor & vbcrlf
suma = suma + valor
respuesta = MsgBox("Desea Continuar (Si/No):", MsgBoxStyle.YesNo)
Loop While (respuesta = "6")
camposuma.Text = suma
Se crean tres variables: dos de tipo entero valor, suma y una de tipo String
llamada respuesta. Dentro de un ciclo Do – Loop While se le asigna a la variable valor
los diferentes números capturados con la función InputBox, además al objeto
camponumeros en su propiedad Text se le asigna el contenido que tenga en ese
momento concatenado con el valor capturado y un salto de carro (vbcrlf); Por otro
lado, la variable suma guardará la sumatoria de los valores capturados y a la variable
53
respuesta se le asigna el valor retornado por la función MsgBox (El primer parámetro
es un mensaje para el cuadro de diálogo; el segundo parámetro es una expresión
numérica que especifican el número y los botones que se van a mostrar). Si desea
continuar (Si) capturando números el valor que se almacenará en la variable respuesta
es “6”, en caso contrario, se almacenará el valor “7”. Al salir del ciclo Do – Loop
While se imprimirá en el objeto camposuma en su propiedad Text el valor de la
variable suma.
Al ejecutarse el proyecto y pulsar el botón Capturar Números se visualizará la

siguiente figura:
Figura 4.17 Cuadro de diálogo para capturar números.
Al digitarse cualquier número (Ej: 5) y pulsar Enter ó el botón Aceptar, se

muestra el cuadro de mensaje de Continuar (Si/No): como se aprecia en la siguiente
figura:
Figura 4.18 Cuadro de mensaje.
Si se pulsa el botón Sí, se mostrará nuevamente la figura 4.17., para capturar un

nuevo número. Si por el contrario se pulsa el botón No, se visualizará la siguiente
pantalla:
54
Figura 4.19 Ejecución aplicación EstructuraDoLoopWhile.
4.6 Estructura For-Each
Sirve para repetir una o varias instrucciones por cada elemento de una colección. Esta
estructura es útil cuando en una colección no se puede determinar cuántos elementos
existen. Su formato es:
For Each elemento [As tipo_de_dato] In colección
Instruccion(es)
::::::::
Next elemento
El valor elemento se utiliza para recorrer los elementos de la colección. El tipo

de dato es obligatorio si el elemento no se ha declarado con anterioridad. La expresión
colección contiene todos los elementos sobre los que se deben repetir las instrucciones
del For-Next. El valor elemento en el Next no es obligatorio.
4.6.1 Ejemplo estructura For-Each
Hacer una aplicación llamada EstructuraForEach que permita a un usuario digitar una
oración en un campo de texto e imprimir cuantas vocales A contiene dicha oración.
 Crear la interfaz de usuario.

Button.
55
Figura 4.20 Interfaz de usuario inicial (EstructuraForEach).
Tabla 4.6 Propiedades de los controles del proyecto EstructuraForNext.

Label1 Name lblcadena
Text Digite una oración:
Label2 Name lblvocal
Text La cantidad de vocales ‘a’ es:
TextBox1 Name campooracion
Text En blanco
TextBox2 Name campovocal
Text En blanco
Button1 Name boton
Text Contar vocal
Text Estructura For-Each
Figura 4.27. Interfaz de usuario final (EstructuraForEach)
56
Dim cuentavocal As Integer
Dim cadena As String
cadena = campocadena.Text
For Each letra As String In cadena
If letra = "a" Then
cuentavocal = cuentavocal + 1
End If
Next
campovocal.Text = cuentavocal
Se crean dos variables: cuentavocal de tipo entero y cadena de tipo String a la

cual se le asigna el texto digitado en el objeto campocadena. Se inicializa un ciclo For-
Each que recorrerá cada uno de los caracteres que contiene la variable cadena. Con la
estructura If se pregunta que si el valor de la variable letra es igual al caracter ‘a’. Si se
cumple la condición se incrementara en uno (+1) el valor de la variable cuentavocal. Al
terminar el ciclo For-Next se imprimirá en el objeto campovocal el valor de la variable
cuentavocal.
Al ejecutarse el proyecto y escribir en el objeto campocadena el texto “hola mi gente

colombiana” y pulsando el botón Contar vocal, se obtendrá la siguiente figura:
Figura 4.28 Ejecución aplicación EstructuraForEach.
57
4.7 Ejercicios estructuras de control
1. Escribir un programa que pida al usuario digitar dos números e imprima las
operaciones con los operadores aritméticos, los operadores relacionales y los
operadores lógicos.
2. Realizar un programa que pida al usuario digitar dos números enteros e imprima
él número mayor seguido del texto "Es el mayor".
3. Elaborar un programa que capture tres números enteros e imprima él número
mayor, el del medio y el menor.
4. Hacer un programa que convierta una temperatura dada en grados Celsius a
grados Fahrenheit. La formula de conversión es F=9/5c +32.
5. Diseñar un programa que pida al usuario digitar un número e imprima el mes del
año de dicho número. Si el número digitado no es un mes del año se deberá
mostrar el mensaje “No es un mes del año”.
6. Crear un programa que imprima en un campo de texto los números impares que
se encuentren entre 1 y 30, así como su sumatoria.
7. Escribir un programa que permita sumar los números enteros de 1 a 100 usando
las estructuras: for, while, do while.
8. Realizar un programa que imprima todos los números primos entre 2 y 100
inclusive (nota: utilice la propiedad Multiline del control TextBox para imprimir
los resultados).
9. Diseñar un programa que permita capturar N números. Se debe imprimir el
número capturado en cajas de texto dependiendo si es par o impar, así como la
sumatoria de estos.
10. Escriba un programa que dado un número entero, diga si es o no es, un cubo
perfecto. Los números astromg o cubos perfectos, son aquellos que sumados los
cubos de cada uno de sus dígitos da el mismo número. Por ejemplo 153 es un
cubo perfecto, pues (1) elevado a 3 + (5) elevado a 3 + (3) elevado a 3 es igual a
153.
58
5. MÓDULOS Y PROCEDIMIENTOS
A medida que se escriban programas de mayor robustez o complejidad (varios

formularios), es casi seguro, que existan muchos procesos comunes. Para esto se
diseñan subprogramas que realizan una tarea específica denominados procedimientos o
funciones, Por otro lado, a veces es necesario tener variables, constantes o expresiones
que se puedan utilizar en el entorno de desarrollo sin tener que volverlas a definir
(variables globales). Visual Basic .NET permite compartir variables, procedimientos en
varios formularios, para esto, es necesario crear un módulo que permita contener las
variables globales y los procedimientos.
5.1 Módulos
Un módulo es un contenedor que se visualiza de forma independiente en el explorador

de soluciones y solamente se le puede incluir código y no tendrá interfaz de usuario.
Dicho módulo puede contener variables globales ó públicas, procedimientos sub y
function y estos pueden ser compartidos por varios formularios. Cada módulo tiene una
instancia y no necesita ser creado ni asignado a una variable. Dentro de una aplicación
pueden existir varios módulos, sin embargo, al hacer referencia a alguno de sus
miembros (variables, procedimientos, funciones) se debe referenciar con el nombre del
módulo adecuado.
Ejemplo:
Module uno
Public a As integer=6
End Module
Module dos
Public a As integer=5
End Module
Si se necesita utilizar la variable a del módulo llamado dos se debe referenciar

así:
dos.a
Por defecto el primer módulo de un programa tendrá como nombre module1.vb.

Su formato es:
Modificador de acceso (public, friend) Module nombre_módulo
variables, procedimientos
End Module
Por omisión cada vez que se crea un módulo el modificador de acceso es friend.
Para crear un módulo dentro de un proyecto ó aplicación existen varias formas:
1. Seleccionar Agregar Módulo… del menú Proyecto, donde se visualizará un

cuadro de diálogo que le permitirá seleccionar la plantilla módulo y asignarle
un nombre a este.
2. Utilizar el botón agregar nuevo elemento de la barra de herramientas
estándar y seleccionar la opción Agregar Módulo….
3. Desde el explorador de soluciones situarse en el nombre del proyecto y dar clic
derecho del mouse para seleccionar la opción Agregar y después escoger
59
Módulo….
La figura que se visualizará al seleccionar cualquiera de los pasos anteriores es

la siguiente:
Figura 5.1 Agregar un módulo al proyecto.
Al hacer clic en el botón Agregar, Visual Basic .NET agregará al proyecto el

módulo llamado Module1.vb apareciendo el Editor de Texto como se muestra a
continuación:
Figura 5.2 Editor Module1.vb.
Luego se podrá observar en el Explorador de Soluciones , el módulo

agregado al proyecto:
Figura 5.3 Módulo en el Explorador de soluciones.
60
Para declarar una variable pública (aquellas que están disponibles para todos los
procedimientos de la aplicación) en un módulo solo se necesita que al inicio del módulo
se escriba la palabra clave public seguido por el nombre de la variable y el tipo de dato.
Una vez declarada esta variable podrá ser utilizada para leerla, modificarla o
visualizarlA por cualquier procedimiento del programa.
5.2 Procedimientos o funciones
En Visual Basic .NET existen dos tipos de procedimientos: Function y Sub. Los
procedimientos Function pueden ser invocados por su nombre desde otros
procedimientos, pueden recibir argumentos (son datos necesarios para que un
procedimiento trabaje correctamente y deben ir dentro de paréntesis y separados por
comas), y siempre devuelven un valor con el nombre de la función. Los procedimientos
Sub también pueden ser son invocados por su nombre desde otros procedimientos,
pueden recibir argumentos y no devuelven valores. Los procedimientos Function y
Sub se pueden definir en el código de un formulario, pero lo más aconsejable es
definirlos dentro de un módulo para que todos los elementos de un proyecto puedan
utilizarlos.
Un procedimiento Function es un grupo de código localizado entre una

instrucción Function y EndFunction. Se podrá llamar a un procedimiento Function
desde un programa utilizando el nombre asociado al procedimiento junto con los
argumentos necesarios. Su formato es:
[Modificar de acceso] Function nombre_función (argumentos) As tipo de dato

Instrucciones
nombre_function = valor a retornar
End Function
Ó
[Modificar de acceso] Function nombre_función (argumentos) As tipo de dato
Instrucciones
Return = valor a retornar
End Function
Donde el modificador de acceso puede ser public, prívate, protected o friend.

Para llamar al procedimiento Function desde otro procedimiento y suponiendo que se
tiene una etiqueta Label1, sería de la siguiente forma:
Se envía:
Label1.Text =nombre_función (12, “hola”)
Se recibe:
Public Function nombre_función (Byval entero As Integer, Byval cadena As String)
Un procedimiento Sub es similar a un procedimiento Function solo que Sub no

retorna un valor asociado con su nombre pero pueden devolver uno o más valores al
procedimiento que lo llamo. En la llamada al procedimiento el número y el tipo de
argumentos enviados deben ser igual al número y tipo de argumentos del
procedimiento. Su formato es:
[Modificar de acceso] Sub nombre_sub (argumentos)
Instrucciones
End Sub
61
Para llamar al procedimiento Sub desde otro procedimiento se debe especificar
el nombre del procedimiento y el número de argumentos. El ejemplo sería el siguiente:
Se envía:
MiSub (12, “hola”)

Se recibe:
MiSub (Byval entero As Integer, Byval cadena As String)
5.2.1 Ejemplo práctico módulo y procedimientos Sub y Function
Realizar una aplicación llamada MódulosProcedimientos que permita a un usuario

capturar un número y retornar en texto si dicho número es PRIMO ó NO. Utilizando los
procedimientos Function y Sub.

siguientes controles en el formulario en la posición deseada: 2 TextBox, 2 Label, 2
Button. Se omitirá la interfaz inicial del proyecto.
Tabla 5.1 Propiedades de los controles de la aplicación MódulosProcedimientos.

TextBox1 Name txtnumero
Text En blanco
TextBox2 Name txtresultado
Text En blanco
Label2 Name lblresultado
Text El número es:
Button1 Name botonfunction
Text Verificar Numero Primo con Function
Button2 Name botonsub
Text Verificar Numero Primo con Sub
Text Módulos y procedimientos.
62
Figura 5.4 Interfaz de usuario (MódulosProcedimientos).
 Agregar módulo
Para agregar el nuevo módulo se utilizará el icono agregar nuevo elemento de la

barra de herramientas estándar y allí se seleccionara la opción Agregar Módulo…,
donde se visualizará un cuadro de diálogo que le permitirá seleccionar la plantilla de
Módulo y asignarle un nombre al módulo. Por defecto el primer módulo de un
programa tendrá como nombre module1.vb cámbielo por mimódulo.vb.
Figura 5.5 Módulo mimódulo.vb en la aplicación MódulosProcedimientos.
Si se desea cambiar el nombre del módulo, se pueden seleccionar las

propiedades del módulo dando clic sobre el nombre actual de éste. Como los módulos
solo contienen código, las propiedades son mínimas. Una de las propiedades más
importantes es nombre de archivo que permite cambiar el nombre del módulo (tenga
en cuenta que la extensión debe seguir igual a “vb”).
63
 Escribir código en el módulo
En el módulo dé doble clic sobre el nombre de este y entre las instrucciones Module y
End Module escriba el siguiente código:
Module mimódulo
Public incremento As Integer

Public auxiliar As Integer
Public texto As String
‘iniciamos el procedimiento Function
Function primo_Function(ByVal numero As Integer) As String
auxiliar = 0
incremento = 2
If (numero <= 0) Then
primo_Function = "No hay solución"
Else
If (numero >= 1 And numero < 3) Then
texto = "PRIMO"
Else
While (auxiliar = 0)
If ((numero Mod incremento) = 0) Then
texto = "No PRIMO"
auxiliar = 1
Else
incremento += 1
End If
If (numero = incremento) Then
texto = "PRIMO"
auxiliar = 1
End If
End While
End If
primo_Function = texto
End If
End Function
‘Finaliza el procedimiento función
‘Inicia el procedimiento Sub
Sub primo_Sub(ByVal numero As Integer)
auxiliar = 0
incremento = 2
If (numero <= 0) Then
texto = "No hay solución"
Else
If (numero >= 1 And numero < 3) Then
texto = "PRIMO"
Else
While (auxiliar = 0)
If ((numero Mod incremento) = 0) Then
texto = "No PRIMO"
auxiliar = 1
Else
incremento += 1
End If
If (numero = incremento) Then
texto = "PRIMO"
auxiliar = 1
End If
End While
64
End If
End If
End Sub
‘Finaliza el procedimiento Sub
End Module
En el módulo se crean tres variables públicas auxiliar e incremento de tipo

Integer y texto de tipo String, las cuales pueden ser utilizadas por cualquier
procedimiento que este dentro del módulo o por cualquier formulario que pertenezca a
la aplicación. En este caso dichas variables son utilizadas por los procedimientos
primo_Function y primo_Sub. Tanto en el procedimiento primo_Function como en
el procedimiento primo_Sub se reciben un número el cual es evaluado para determinar
si es primo ó no. Por otro lado, en el procedimiento primo_Function se retorna el
contenido de la variable global texto al procedimiento que lo llamó y en el
procedimiento primo_Sub el resultado es asignado a la variable texto.
 Escribir código en los controles Button
a) Seleccione el objeto botonfunction y abra el editor de código y escriba el

siguiente código:
Dim numero As Integer

numero = txtnumero.Text
txtresultado.Text = primo_Function(numero)
El anterior código se define la variable numero de tipo Integer. A dicha

variable se le asigna el valor capturado en el objeto txtnumero. Por último a la
propiedad Text del control txtresultado se le asigna el valor que retorne el
procedimiento primo_Function. Como se puede apreciar, a dicho procedimiento se le
envía como argumento la variable numero que es exactamente el número de
argumentos que recibe primo_Function.
b) Seleccione el objeto botonsub y abra el editor de código y escriba el siguiente

código:
Dim numero As Integer

numero = txtnumero.Text
primo_Sub(numero)
txtresultado.Text = texto
En este código también se define la variable numero de tipo Integer. A dicha

variable se le asigna el valor capturado en el objeto txtnumero. Se llama al
procedimiento primo_Sub y se le envía como argumento la variable numero. Por
último a la propiedad Text del control txtresultado se le asigna el valor de la variable
global texto.
Al ejecutarse el proyecto en el entorno de desarrollo de Visual Basic.NET, si se digitá el

valor 281 y pulsando cualquiera de los dos botones se visualizará la siguiente pantalla:
65
Figura 5.6 Ejecución aplicación MódulosProcedimientos.
5.3 Funciones predeterminadas
En Visual Basic .NET existen funciones predeterminadas o incorporadas que facilitan la

realización de tareas específicas, entre ellas, se pueden encontrar funciones:
matemáticas, de fechas, para manipulación de cadenas de caracteres., etc.
5.3.1 Función de fecha y hora
El objeto Date permite la manipulación de la fecha y la hora. Now y Today son dos
funciones básicas para el manejo del tiempo y la fecha. Now muestra en formato
numérico la fecha y la hora del sistema (Ej: 31/08/2010 16:14:20), mientras que Today
muestra en formato numérico la fecha del sistema (Ej: 31/08/2010). Con la función
Format se puede manejar diferentes formatos de presentación de fecha y hora
utilizando carácteres específicos. En la siguiente tabla se describe algunos caracteres
que permite la creación de formatos de fecha y hora definidos por el usuario:
Tabla 5.2 Caracteres para crear formatos de fecha.
Carácter Descripción
(/) Separador de fecha.
D Muestra una fecha con el formato de fecha larga. Por ejemplo: martes, 31 de
agosto de 2010.
d Muestra una fecha con el formato de fecha corta. Por ejemplo: 31/10/2010.
dd Muestra el día como un número con cero a la izquierda (por ejemplo: 01).
ddd Muestra el día de forma abreviada (por ejemplo: mar).
dddd Muestra el día de forma completa (por ejemplo: martes).
M Muestra el día y el mes de una fecha (por ejemplo: 31 agosto).
MM Muestra el mes como un número con cero a la izquierda (por ejemplo, 09).
MMM Muestra el mes en forma abreviada (por ejemplo, ago).
MMMM Muestra el mes en forma completa (por ejemplo: agosto).
y Muestra el mes y el año (por ejemplo: agosto de 2010).
yy Muestra el año en formato numérico de dos dígitos.
yyy Muestra el año en formato numérico de cuatro dígitos.
F,f Muestra la fecha larga y la hora corta. Por ejemplo: martes, 31 de agosto de
2010 11:07.
66
Tabla 5.3 Caracteres para crear formatos de hora.
Carácter Descripción
(:) Separador de hora.
hh Muestra la hora como un número con ceros a la izquierda y en formato de
12 horas.
HH Muestra la hora como un número con ceros a la izquierda y en formato de
24 horas.
mm Muestra los minutos como un número con ceros a la izquierda.
ss Muestra los segundos como un número con ceros a la izquierda.
t Muestra la hora y los minutos en formato de 24 horas.
5.3.1.1 Ejemplo práctico funciones de fecha y hora
Crear una aplicación llamadas FuncionesFechasHoras que permita a un usuario pulsar

un botón y visualizar en cajas de texto alguno de los formatos de fecha y hora.

Button.
Tabla 5.4 Propiedades de los controles del proyecto FuncionesFechasHoras.

Label1 Name Función Now
Label2 Name Función TODAY
Label3 Name Formato d/MM/y:
Label4 Name Formato D:
Label5 Name Formato d-MMMM-yyy
Label6 Name Formato F:
Label7 Name Formato h:m:s:
Label8 Name Formato hh:mm:ss
Label9 Name Formato HH
Label10 Name Formato HH:mm
Label1….Label10 Text texto1…texto10
TextBox1…TextBox10 Name formato1…formato10
Text En blanco
Button1 Name boton
Text Ver formatos de fecha/hora
Text Formato de fecha/hora
67
Figura 5.7 Interfaz de usuario (FuncionesFechasHoras).
formato1.Text = Date.Now
formato2.Text = Date.Today
formato3.Text = Format(Date.Now, "d/MM/y")
formato4.Text = Format(Date.Now, "D")
formato5.Text = Format(Date.Now, "d-MMMM-yyy")
formato6.Text = Format(Date.Now, "F")
formato7.Text = Format(Date.Now, "h:m:s")
formato8.Text = Format(Date.Now, "hh:mm:ss")
formato9.Text = Format(Date.Now, "HH")
formato10.Text = Format(Date.Now, "HH:mm")
Se utiliza la función Format (fecha actual del sistema, tipo de formato) para dar
un formato específico de fecha u hora a las diferentes cajas de texto en la propiedad
Text. Cuando el usuario pulse el botón Ver formatos fecha/hora en tiempo de
ejecución mostrará en cada caja de texto el formato respectivo.
Al ejecutarse el proyecto en el entorno de desarrollo de Visual Basic.NET, se debería

visualizar la siguiente pantalla:
68
Figura 5.8 Ejecución aplicación FuncionesFechasHoras.
5.3.2 Funciones Matemáticas
La clase Math de Visual Basic .NET contiene una serie de funciones trigonométricas,
logarítmicas y otras funciones matemáticas que sirven para realizar cálculos aritméticos,
en la siguiente tabla se muestran las funciones más comunes:
Tabla 5.5 Funciones matemáticas de Visual Basic .NET.
Método de Visual Basic .NET Descripción

Math.Ceiling(double) Devuelve el número entero más pequeño mayor o
igual que el número especificado.
Math.ceiling(1.6)=2
Math.ceiling(0.8)=1
Math.Floor(double) Devuelve el número entero más grande menor o
igual que el número especificado.
Math.Floor(1.6)=1
Math.Floor(0.8)=0
Math.sqrt(n) Devuelve la raíz cuadrada de un número.
Math.pow(n,p) Devuelve un número especificado elevado a la
potencia especificada.
Math.Abs(n) Sobrecargado. Devuelve el valor absoluto de un
número especificado.
Math.sin(n) Devuelve el seno del ángulo especificado.
Math.cos(n) Devuelve el coseno del ángulo especificado.
Math.tan(n) Devuelve la tangente del ángulo especificado.
Math.Max(n1,n2) Devuelve el mayor de dos números.
Math.min(n1,n2) Devuelve el menor de dos números.
Math.BigMul(n1,n2) Calcula el producto de dos números.
Math.round(double) Devuelve el número más próximo al valor
especificado.
Math.round(10.5)=10
Math.round(10.51)=11
69
5.3.2.1 Ejemplo práctico funciones matemáticas
Hacer una aplicación llamadas FuncionesMatematicas que permita a un usuario pulsar

un botón y visualizar en cajas de texto las funciones aritméticas básicas.

Button.
Tabla 5.6 Propiedades de los controles del proyecto FuncionesMatematicas.

Label1 Name Función Math.Ceiling(8.5)
Text texto1
Label2 Name Función Math.Floor(8.5)
Text texto2
Label3 Name Función Math.Round(10.5)
Text texto3
Label4 Name Función Math.Round(10.51)
Text texto4
Label5 Name Función Math.Max(7,5)
Text texto5
Label6 Name Función Math.Min(7,5)
Text texto6
Label7 Name Función Math.Pow(5,2)
Text texto7
Label8 Name Función Math.Sqrt(3)
Text texto8
Label9 Name Función Math.Sin(1.0)
Text texto9
Label10 Name Función Math.cos(1.0)
Text texto10
Label11 Name Función Math.tan(1.0)
Text texto11
TextBox1…TextBox11 Name campo1…campo10
Text En blanco
Button1 Name boton
Text Ver funciones matemáticas.
Text Funciones matemáticas.
70
Figura 5.9 Interfaz de usuario (FuncionesMatematicas).
campo1.Text = Math.Ceiling(8.5)
campo2.Text = Math.Floor(8.5)
campo3.Text = Math.Round(10.5)
campo4.Text = Math.Round(10.51)
campo5.Text = Math.Max(7, 5)
campo6.Text = Math.Min(7, 5)
campo7.Text = Math.Pow(5, 2)
campo8.Text = Math.Sqrt(3)
campo9.Text = Math.Sin(1.0)
campo10.Text = Math.Cos(1.0)
campo11.Text = Math.Tan(1.0)
El anterior código se le asigna una función matemática a la propiedad Text de cada

caja de texto. Cuando el usuario pulse el botón Ver Funciones matemáticas en tiempo
de ejecución mostrará en cada caja de texto el valor respectivo de la operación que le
fue asignada.
Al ejecutarse el proyecto en el entorno de desarrollo de visual Basic.NET, se debe
visualizar:
71
Figura 5.10 Ejecución aplicación FuncionesMatematicas.
5.3.3 Funciones para cadenas de caracteres
Visual Basic .NET contiene una serie de funciones para la manipulación de cadenas de
caracteres que sirven para realizar diferentes operaciones entre caracteres, en la
siguiente tabla se muestran las funciones más comunes:
Tabla 5.7 Funciones para manipulación de cadenas.
Función Ejemplo
Chars(n): Permite obtener un carácter Dim micadena As String = "ABCDE"
específico de una cadena de Dim micaracter As Char
caracteres. micaracter = micadena.Chars(3)
micaracter = "D"
Length: Permite obtener la longitud Dim micadena As String = "ABCDE"
de de una cadena de caracteres. Dim Entero As Integer
entero=cadena.length
entero=5
Concat(texto1, texto,...., texton): Dim micadena As String = "hola"
Permite unir dos o más cadenas de Dim unircadena As String
caracteres. unircadena= String.Concat(micadena, " ",
"pueblo")
unircadena=” hola pueblo”
ToUpper: Convierte una cadena de Dim micadena As String = "hola"
caracteres de minúscula a mayúscula. micadena= micadena.ToUpper()
micadena=” HOLA”
ToLower: Convierte una cadena de Dim micadena As String = "HOLA"
caracteres de mayúscula a minúscula. micadena= micadena.ToLower()
micadena=” hola”
72
Remove(posición inicial, número de
caracteres): Permite eliminar una Dim micadena As String = "campoalegre"
cantidad determinada de caracteres micadena= micadena.Remove(2,3)
en una posición específica de una micadena=” caalegre”
cadena de caracteres.
Insert (posición de inserción,”cadena
de caracteres”): Permite insertar una Dim micadena As String = "campoalegre"
cantidad determinada de caracteres micadena= micadena.insert(4,” más ”)
en una posición específica de una micadena=” campo más alegre”
cadena de caracteres.
SubString((posición inicial, número
de caracteres): Permite obtener una Dim micadena As String = "campoalegre"
subcadena de una cadena de Dim subcadena As String
caracteres. subcadena= micadena.substring(5,4)
subcadena=”aleg”
Replace(cadena de caracteres,
carácter original, nuevo carácter): Dim micadena As String = "campoalegre"
Permite reemplazar una subcadena Dim Nuevacadena As String
determinada por otra subcadena nuevacadena =replace( m i c a d e n a , "e", "i")
especificada. nuevacadena=”campoaligri”
StrReverse(cadena de caracteres): Dim micadena As String = "campoalegre"
Devuelve una cadena de caracteres Dim Nuevacadena As String
invertida según el orden de los nuevacadena =StrReverse( m i c a d e n a )
caracteres de la cadena especificada. nuevacadena=”ergelaopmac”
Mid (cadena de caracteres, posición Dim micadena As String = "campoalegre"
inicial, numero de caracteres), Dim Nuevacadena As String
Mid (cadena de caracteres, posición nuevacadena =Mid( m i c a d e n a , 1 , 5 )
inicial): Devuelve una subcadena que nuevacadena=”campo”
a su vez contiene un número
especificado de caracteres de una Dim micadena As String = "campoalegre"
cadena de caracteres. Dim Nuevacadena As String
nuevacadena =Mid( m i c a d e n a , 5 )
nuevacadena=”alegre”
Len (cadena de caracteres): Devuelve Dim micadena As String = "ABCDE"
un entero que contiene el número de Dim Entero As Integer
caracteres de una cadena de entero=len(micadena)
caracteres. entero=5
TocharArray: Convierte una cadena Dim micadena As String = "campeon"
de caracteres en un arreglo de Dim arreglo() As char
caracteres. arreglo=mi cadena.ToCharArray()
arreglo={‘c’,’a’,’m’,’p’,’e’,’o’,’n’}
Split (cadena de caracteres, Dim cadena as String=”42,21,50,33”
delimitador): Devuelve un arreglo Dim subcadenas() As String
unidimensional que contiene un Subcadenas=Split(subcadenas,”,”)
número específico de subcadenas. Retorna={”42” “21” “50” “33”}
Trim (cadena): Elimina los espacios Dim cadena As String=” Colombia “
de ambos lados de una cadena de cadena=Trim(cadena)
caracteres.
Asc (carácter): Devuelve el numero Dim numero As Integer
Ascci de un carácter. numero=Asc(“a”) ‘Devuelve 97
Chr (numero): Devuelve el carácter Dim letra As char
Ascci de un número. letra=Chr(97) ‘Devuelve “a”
String.Copy (cadena): Copia una Dim cadena As String=”Hola”
cadena de caracteres. Dim copia as String
copia=String.Copy(cadena)
IndexOf (carácter a buscar): Devuelve Dim cadena as String=”Colombia”
la posición de un carácter específico. Dim posición As Integer
posición=cadena.IndexOf(“m”) ‘Devuelve 4
73
5.3.3.1 Ejemplo práctico funciones de cadena de caracteres
Diseñar una aplicación llamada FuncionesCadenas que permita a un usuario visualizar

en una caja de texto las funciones de manipulación de cadena de caracteres básicas
cuando se pulse un botón específico.

Button.
Tabla 5.8 Propiedades de los controles del proyecto FuncionesCadenas.

Label1 Name lblcadena
Text Cadena origonal
Text Cadena resultante
Button1 Name boton1
Text Chars(n)
Button2 Name boton2
Text Length
Button3 Name boton3
Text ToUpper
Button4 Name boton4
Text ToLower
Button5 Name boton5
Text Remove
Button6 Name boton6
Text Insert
Button7 Name boton7
Text Substring
Button8 Name boton8
Text Mid
Button9 Name boton9
Text StrReverse
Button10 Name boton10
Text Replace
Text Asc
Text Concat
TextBox1 Name txtcadena
Text Esternomáscleoide
Textbox2 Name txtresultante
Text En blanco
Text Funciones de cadenas de caracteres.
74
Figura 5.11 Interfaz de usuario (FuncionesCadenas).
Seleccione el objeto boton1 y abra el editor de código y escriba el siguiente código:

resultado.Text = texto.Text.Chars(5)
resultado.Text = texto.Text.Length
resultado.Text = texto.Text.ToUpper
resultado.Text = texto.Text.ToLower
resultado.Text = texto.Text.Remove(2, 5)
resultado.Text = texto.Text.Insert(5, "NUEVO")
resultado.Text = texto.Text.Substring(2, 5)
resultado.Text = Mid(texto.Text, 2, 5)
75
resultado.Text = StrReverse(texto.Text)
resultado.Text = texto.Text.Replace("e", "x")
resultado.Text = Asc(texto.Text.Chars(5))
resultado.Text = String.Concat(texto.Text, " que palabrita")
En el anterior código se le asigna una función de manipulación de cadenas en la

propiedad Text de cada caja de texto. Cuando el usuario pulse un botón en tiempo de
ejecución mostrará en el objeto resultado el valor respectivo de la operación que le fue
asignada.
Al ejecutarse la aplicación se visualizará la figura 5.11, Se puede pulsar cada uno de los
botones para ver los resultados de la función especificada. Por ejemplo si se pulsa el
botón Concat, se obtendrá la siguiente figura:
Figura 5.12 Ejecución aplicación cadenas_caracteres.
76
5.4 Ejercicios de procedimientos
1. Crear un programa que contenga un método llamado perfecto que reciba un

parámetro entero e imprima si este es o no perfecto. Se dice que un número es
“un número perfecto” si la suma de sus factores, incluido el 1, da como
resultado el número. Por ejemplo, 6 es un número perfecto porque 6=1+2+3.
2. Diseñar un programa que contenga un método llamado Celsius que reciba un
valor representado en grados Celsius y retorne el valor representado en grados
Fahrenheit digitado desde el teclado.
3. Elaborar un programa que contenga un método que reciba un número entero y
retorne el número con sus dígitos invertidos. Ejemplo: dado el número 7631 el
método deberá retornar 1367.
4. Escribir un programa que capture dos números y por medio de un método
imprima la multiplicación de estos por medio de las sumas sucesivas. Ejemplo:
20 es igual a 4+4+4+4+4 ó 5+5+5+5.
5. Realizar un programa con un método que calcule las raíces de una ecuación de
segundo grado.El discriminante es (b^2- 4*a*c). Se deben tener en cuenta todas
las posibles validaciones.
6. Elaborar un programa utilizando un método que determine cuantas cifras posee
un número entero positivo introducido por teclado.
7. Hacer un programa que lea una cadena de caracteres, digitar un carácter que se
quiera eliminar y por medio de un método imprimir la cadena resultante.
8. Diseñar el programa para imprimir la suma de los números impares menores o
iguales que N por medio de un método.
9. Crear un programa que reciba un número entero y por medio de un método
retorne el número con sus dígitos invertidos. Ejemplo: dado el número 7631 el
método deberá retornar 1367.
10. Hacer un programa utilizando métodos que lea un número no mayor de 1000 e
imprima ese número en letras.
77
6. MATRICES Y COLECCIONES
Las matrices y las colecciones son conjuntos de elementos afines. Una matriz es un
grupo de posiciones de memoria contiguas, que almacenan el mismo nombre y tipo de
dato, estas pueden ser de una o más dimensiones. Para referirse a un elemento de la
matriz se debe especificar el nombre de la matriz seguido de uno o más subíndices
encerrados entre paréntesis. Una colección se define por medio del objeto Collection
donde se hace referencia a un grupo de elementos relacionados como un objeto único.
6.1 Matrices de una Dimensión o Unidimensionales
Una matriz de una dimensión se declara de la siguiente forma:

Dim <nombre matriz> (<numero de elementos>) As Tipo de dato;
Dim mercancía (12) As Integer
También se puede inicializar una matriz, de la siguiente manera:
Dim ventas () As Double = {100.0, 254.5, 478.5, 125.8, 458.66}

Dim vendedores () As String = {“Julieta”, “Maria”, “Jenny”, “Sara”, “Lina”}
Para almacenar valores en una matriz se debe utilizar el nombre de la matriz y

un subíndice que indica en qué posición se almacenará el valor especificado. En las
siguientes líneas se creará una matriz de 5 posiciones, (el primer valor se almacenará en
la posición 0) y se le asignarán valores a la matriz. Por lo general para almacenar o
mostrar los valores de una matriz se utilizan las estructuras repetitivas, también
llamadas ciclos.
Dim ventas (5), i, z As Integer

For i= 0 To 4
Ventas (i)= i+3
Next
Para acceder a los valores de una matriz, se debe utilizar un valor de índice
para especificar la posición a la que se desea acceder. También se pueden utilizar ciclos
para recorrer toda la matriz y acceder a todos los valores.
z = ventas (2) ‘a z se le asignará el valor de 5 de acuerdo al ejemplo anterior.
6.1.1 Ejemplo práctico matriz unidimensional
Hacer una aplicación llamada MatricesUnidimensionales que permita a un usuario

capturar 10 números enteros positivos o negativos e imprima los valores en el orden
que se capturan, como también los valores pares e impares ordenados de menor a
mayor.

siguientes controles en el formulario en la posición deseada: 2 TextBox, 2 Label, 1
Button.
78
Después de colocar los controles u objetos en el formulario, establezca las siguientes

propiedades a los controles:
Tabla 6.1 Propiedades de los controles de la aplicación MatricesUnidimensionales.

TextBox1 Name txtoriginal
Text En blanco
TextBox2 Name txtordenada
Text En blanco
TextBox3 Name txtpares
Text En blanco
TextBox4 Name txtimpares
Text En blanco
Label1 Name lbloriginal
Text Matriz Original
Font-Bold True
Label2 Name lblordenado
Text Matriz Original
Font-Bold True
Label3 Name lblpares
Text Números Pares:
Font-Bold True
Label4 Name lblimpares
Text Números Impares:
Font-Bold True
Button1 Name boton
Text Capturar valores
Text Matrices Unidimensionales
Figura 6.1 Interfaz de usuario (MatricesUnidimensionales).
79
Dim datos (10) As Integer

Dim i, j, numero, temporal As Integer
txtoriginal.Text = " "
txtordenada.Text = " "
For i = 0 To 9
numero = InputBox("Digite un núumero entero", "Capturar valores")
datos (i) = numero
txtoriginal.Text = txtoriginal.Text & datos (i) & " , "
Next
For i = 0 To 9
For j = i To 9
If (datos (i) > datos (j)) Then
temporal = datos (i)
datos (i) = datos (j)
datos (j) = temporal
End If
Next
Next
For i = 0 To 9
txtordenada.Text = txtordenada.Text & datos (i) & " , "
If (datos (i) Mod 2 = 0) Then
txtpares.Text = txtpares.Text & datos (i) & " , "
Else
txtimpares.Text = txtimpares.Text & datos (i) & " , "
End If
Next
En el anterior código se define una matriz llamada datos, la cual permitirá

almacenar 10 valores enteros, como también se definen las variables i, j, numero de
tipo Integer. Los controles txtoriginal y txtordenada se inicializan en su propiedad
Text en blanco. Se realiza la programación utilizando cuatro ciclos For: el primero
permite la capturar de cada uno de los valores digitados por teclado y se le asigna a la
variable numero, luego dicho valor es almacenado en la posición i de la matriz y por
último al control txtoriginal en su propiedad Text se le asigna lo que contenía
anteriormente ese control más el valor que ha sido almacenado en datos (i) agregándole
una coma (,). El segundo y tercer ciclo se utilizan para comparar pares de elementos
adyacentes e intercambiarlos cuando se cumpla la condición definida dentro del ciclo
más interno, este método de comparación es conocido como el método de búrbuja. El
cuarto ciclo sirve para recorrer la matriz e ir imprimiendo cada uno de los elementos de
la matriz en el control txtordenada en su propiedad Text. Además se determinar si el
valor datos (i) es par o impar utilizando el operador Mod. Dependiendo de la
evaluación se imprimirá dicho valor en el objeto txtpares o txtimpares.
Al ejecutar el proyecto en el entorno de desarrollo de visual Basic.NET, se debe

visualiza la figura 6.1. Si se pulsa el botón Capturar valores y se digitan los números:
2, 8, 17, 26, 35, 21, 54, 89, 20, 33, se visualizará la siguiente pantalla:
80
Figura 6.2 Ejecución aplicación MatricesUnidimensionales.
6.2. Matrices de más de una Dimensión
Una matriz puede ser definida de dos, tres o más dimensiones, de cualquier tipo de dato.
Para crear una matriz de más de una dimensión en los paréntesis se separa cada
dimensión por medio de comas (,). El formato para declarar una matriz bidimensional
es:
Dim nombre_matriz (filas, columnas) As Integer

Dim notas (2, 3) As Integer
Para almacenar valores en la matriz bidimensional se utilizan dos subíndices, el

primero indica las filas y el segundo las columnas donde se localiza el valor. El primer
valor de las filas y de las columnas es cero (0). En las siguientes líneas se creará una
matriz bidimensional de 2 filas y 3 columnas, y se le asignarán valores a la matriz. Para
almacenar los valores se utilizan dos ciclos.
Dim ventas (2, 3), i, j As Integer

For i= 0 To 1
For j=0 To 2
ventas (i, j) = i+3
Next
Next
Para acceder a los valores de una matriz bidimensionales, se debe utilizar los
dos subíndices, como también dos ciclos para recorrer toda la matriz y acceder a cada
uno de los valores.
Dim ventas (2, 3), i, j, z As Integer

For i= 0 To 1
For j=0 To 2
z=ventas (i, j) ‘A z se le asignará el valor de la posición (i, j).
Next
Next
81
6.2.1 Ejemplo práctico matrices bidimensionales
Elaborar una aplicación llamada MatricesBidimensionales que permita capturar ocho

(8) palabras en una matriz bidimensional. Se deberá imprimir cada palabra digitada en
un campo de texto, como también imprimir en otro campo de texto todas las palabras
que empiecen con CA.

siguientes controles en el formulario en la posición deseada: 2 Label, 2 TextBox, 1
Button.

Tabla 6.2 Propiedades de los controles de la aplicación MatricesBidimensionales.

Label1 Name lblpalabras
Text Palabras Digitadas
Label2 Name lblca
Text Palas que empiezan con CA.
Textbox1 Name txtpalabras
Text En Blanco
Multiline True
TextBox2 Name txtca
Text En Blanco
Multiline True
Button1 Name boton
Text Capturar palabras
Text Matrices Bidimensionales
Figura 6.3 Interfaz de usuario (Matrices Bidimensionales).
82

Dim palabras(2, 4) As String
Dim i, j As Integer
For i = 0 To 1
For j = 0 To 3
palabras(i, j) = InputBox("Digite una palabra:", "Capturar Palabras")
txtpalabras.Text = txtpalabras.Text & palabras(i, j) & vbTab
If (palabras(i, j).Substring(0, 2).Equals("ca")) Then
txtca.Text = txtca.Text & palabras(i, j) & vbCrLf
End If
Next
txtpalabras.Text = txtpalabras.Text & vbCrLf & vbCrLf
Next
En el anterior código se define una matriz de 2 filas x 4 columnas llamada

palabras, la cual permitirá almacenar 8 cadenas de caracteres, también se definen las
variables i, j de tipo Integer. Se utilizan dos ciclos For: el primero realizará el recorrido
por las filas y el segundo lo realizará por las columnas, además en este ciclo se capturan
las palabras digitadas. Cada palabra capturada es asignada a la matriz palabras en su
posición i, j. Al objeto txtpalabras en su propiedad Text se le asigna el texto que
contiene dicho control agregándole la nueva palabra concatenada con una tabulación
(vbtab). Se evalúa si la palabra capturada contiene en las dos primeras posiciones la
silaba CA. Si la condición es verdadera, al objeto txtca en su propiedad Text se le
asigna el texto que contiene dicho control agregándole la palabra con CA concatenada
con una tabulación (vbtab). Al terminar de ejecutarse el segundo For se retorna al
primer ciclo donde al objeto txtpalabras en su propiedad Text se le asigna el texto que
contiene dicho control agregándole dos saltos de línea utilizando la función vbcrlf.
Al ejecutar el proyecto se visualizará la figura 6.3. Al pulsar el botón Capturar

palabras, se mostrará la ventana para la captura de las palabras, como se aprecia en la
siguiente figura:
Figura 6.4 Ventana para capturar palabras.
83
Si se digitan las palabras: ana, dedos, cali, azules, cadena, apoyo, alcanza,
capota, en el objeto txtpalabras se visualizarán las palabras digitadas y en el objeto
txtca todas las palabras que empiezan con CA. Se mostrará la siguiente figura:
Figura 6.5 Matriz bidimensional al capturar las palabras.
6.3 Colecciones
Las colecciones es un objeto único donde se relacionan un grupo de elementos. Los

elementos de una colección no tienen que compartir el mismo tipo de datos. El índice de
los elementos puede ser 0 ó 1. Su formato es:
Dim nombrecoleccion As New Collection
Donde New es el operador para asignar espacio de memoria de tipo Collection.
Cuando se crea una colección, esta se puede manipular con las siguientes funciones:
 Add: permite agregar un nuevo elemento a la colección.
 Remove: permite eliminar un elemento que exista en la colección.
 Clear: quita todos los elementos de una colección.
 Count: cuenta cuantos elementos tiene una colección.
6.3.1 Ejemplo práctico colecciones
Diseñar una aplicación llamada Colecciones que permita adicionar, eliminar, buscar
elementos en una colección. Al realizar la operación de adición o eliminación se debe
visualizar como queda la colección y por la operación de búsqueda se debe mostrar la
posición donde se encuentra el elemento.
84
Button.

Tabla 6.2 Propiedades de los controles de la aplicación Colecciones.

Label1 Name lblelementos
Text Elementos de la Colección
Textbox1 Name txtelementos
Text En Blanco
Multiline True
TextBox2 Name txtbuscar
Text En Blanco
Button1 Name botonadicionar
Text Adicionar elementos
Button2 Name botoneliminar
Text Eliminar elementos
Button3 Name botonbuscar
Text Elemento a Buscar:
Text Objeto Collection
Figura 6.6 Interfaz de usuario (Colecciones).
85
a) Antes de la apertura de la clase declare la colección para que esta sea publica a
cada uno de los procedimientos de la aplicación. Dé doble clic sobre el
formulario y busque Public class formulario y antes de este código escriba:
Dim coleccion As New Collection
b) Seleccione el objeto botonadicionar, abra el editor de código y escriba el

siguiente código:
Dim dato As Integer
dato = InputBox("Digite elemento a Adicionar:", "Adicionar elemento a una coleccion")
coleccion.Add(dato)
elementos.Text = ""
For Each elemento As Integer In coleccion
elementos.Text = elementos.Text & elemento & vbCrLf
Next
Se declara una variable llamada dato de tipo Integer. A dicha variable se le

asigna el elemento digitado por teclado. Utilizando la función Add se adiciona el
elemento a la colección y se limpia el objeto elementos. Con la estructura For-Each se
visualizan cada uno de los elementos existentes en la colección.
c) Seleccione el objeto botoneliminar y abra el editor de código y escriba el

siguiente código:
Dim dato, nroelementos As Integer
nroelementos = coleccion.Count
dato = InputBox("Digite elemento a Eliminar:", "Eliminar elemento de una coleccion")
If ( dato>nroelementos) Then
MsgBox("Elemento no existe", MsgBoxStyle.Information)
Else
coleccion.Remove(dato)
End If
elementos.Text = ""
elementos.Text = elementos.Text & elemento & vbCrLf
Next
A la variable nroelementos se le asigna la cantidad de elementos que tiene la

colección utilizando la función Count. Si el valor de la variable dato es mayor que el
valor de la la variable nroelementos se visualizará el mensaje Elemento no existe. En
caso contrario se eliminará el elemento en la posicion indicada utilizando la función
Remove. Se debe tener en cuenta que se elimina es la posicion de un elemento en la
colección.
d) eleccione el objeto botonbuscar y abra el editor de código y escriba el siguiente

código:
Dim dato, posicion, auxiliar As Integer
dato = InputBox("Digite elemento a Buscar:", "Buscar elementoen a una coleccion")
posicion = 1
auxiliar = 0
If (elemento = dato) Then
86
txtbuscar.Text = "el elemento:" & dato & " existe en la posición:" & posicion
auxiliar = 1
End If
posicion = posicion + 1
Next
If (auxiliar = 0) Then
txtbuscar.Text = "No existe el elemento:" & dato
End If
Se crean tres variables de tipo Integer: dato, posicion, auxiliar. A la variable

dato se le asigna el elemento digitado por teclado; La variable posicion se inicializa en
uno (1) y la variable auxiliar en cero (0). Con la estructura For-Each se recorre cada
uno de los elementos de la colección. Se evalúa si el elemento encontrado es igual al
valor de la variable dato. Si se cumple la condicion se le asigna al objeto txtbuscar el
texto el elemento concatenado al valor de la variable dato junto con el texto existe en
la posición: unido al valor de la variable posicion, además se le asigna a la variable
auxiliar el valor uno (1) . Si no ingresa a la estructura If se incrementará el valor de la
variable posicion. Al terminarse de recorrer la colección, si el valor de la variable
auxiliar es igual a cero ( no se encontró el elemento buscado) se le asignará al objeto
txtbuscar el texto No existe el elemento unido al valor de la variable dato.
Al ejecutar el proyecto se visualizará la figura 6.6. Al pulsar el botón Adicionar

elementos, se mostrará la ventana para la adicionar un elemento a la colección. Se debe
pulsar el botón tantas veces como elementos se desee adicionar. Se apreciaría la
siguiente figura:
Figura 6.7 Ventana para adicionar elementos a la colección.
Si se adicionan los elementos: 2, 5, , 7, 1, se obtendrá la siguiente figura:
87
Figura 6.8 Aplicación con los elementos de la colección.
Al pulsar el botón Eliminar elementos, se mostrará la ventana para la eliminar

un elemento a la colección. Se debe pulsar el botón tantas veces como elementos se
desee eliminar. Se visualizará la siguiente figura:
Figura 6.9 Ventana para eliminar elementos de la colección.
Si se digitá el número 15, se obtendrá la siguiente figura:
Figura 6.10 Mensaje de No existencia de un elemento en la colección.
88
Al pulsar el botón Elemento a Buscar, se mostrará la ventana para realizar la
búsqueda de un elemento en la colección. Se debe pulsar el botón tantas veces como
elementos se desee buscar. Se visualizará la siguiente figura:
Figura 6.11 Ventana para eliminar elementos de la colección.
Si se digitá el número 7, se visualizará la siguiente figura:
Figura 6.12 Aplicación con el elemento encontrado.
89
6.4 Ejercicios Matrices
1. Escribir un programa que permita capturar 10 números e imprima los números

positivos.
2. Realizar un programa que capture 20 números enteros e imprima la cantidad y la
suma de: negativos, cero y positivos.
3. Hacer un programa que imprima la suma de los elementos de las diagonales de
una matriz cuadrada. Se debe capturar la dimensión de la matriz.
4. Elaborar un programa que capture notas de 20 alumnos de una clase. Cada
alumno debe tener tres notas. Se debe imprimir las notas de cada alumno, su
nota definitiva, además, las notas definitivas menores de 6.0
5. Crear un programa que imprima 20 números aleatorios entre 1 y 1000. Además,
se deberá imprimir el valor máximo y la posición que ocupa en la matriz.
6. Escribir un programa que permita insertar o eliminar elementos de un arreglo
(los elementos deben mostrarse como se ingresaron).
7. Diseñar un programa que permita capturar 10 palabras en un arreglo
bidimensional e imprimir dicho arreglo ordenado alfabéticamente.
8. Implementar un programa que capture 10 palabras e imprimir aquellas palabras
que contengan la silaba PE.
9. Hacer un programa que intercambie las filas de una matriz. Los elementos de la
fila 0 deben intercambiarse con los de la fila N, la fila 1 con los de la fila N-1 y
así sucesivamente. Imprimir las dos matrices.
10. Realizar un programa que capture 10 números en una matriz unidimensional e
imprimir el mayor y menor valor.
90
7. CONTROLES PARA INTERFAZ DE USUARIO
Hasta ahora se ha trabajo la interfaz de usuario con controles básicos del cuadro de
herramientas como lo han sido los objetos Label, TextBox y Button. En este capítulo
se programaran algunos de los controles más comunes que se utilizan en el entorno de
desarrollo de Visual Basic.NET. Al arrastrarse cualquier control del cuadro de
herramientas hacia un formulario, Visual Basic .NET crea el código necesario para
interactuar con cada control, esto es transparente para el usuario.
7.1 LinkLabel
El control LinkLabel permite crear un texto con hipervínculo, donde se puede

comportar como un vínculo para acceder a páginas de Internet ó ejecutar programas de
la plataforma Windows.
7.1.1 Ejemplo práctico LinkLabel
Realizar una aplicación llamada LinkLabel que permita a un usuario por medio de
controles LinkLabel conectarse a una página Web ó abrir una aplicación de Windows.
Utilizando el cuadro de herramientas haga clic en siguientes controles y ubíquelos en el

formulario en la posición deseada: 2 Label, 2 LinkLabel.

Tabla 7.1 Propiedades de los controles de la aplicación LinkLabel.

Label1 Name lblgoogle
Text Abrir Google:
Label2 Name lblexcel
Text Abrir Excel:
Name vinculogoogle
LinkLabel1 Text Ir a Google
Name vinculoexcel
LinkLabel2 Text Abrir Excel
Text Control LinkLabel

91
Figura 7.1 Interfaz de usuario (ControlLinkLabel).
a) Seleccione el objeto vinculogoogle, dé doble clic para abrir el editor del

procedimiento vinculogoogle_LinkClicked y escriba el siguiente código:
vinculogoogle.LinkVisited = True
System.Diagnostics.Process.Start("http://www.google.com.co")
En la primera línea de código se asocia el valor True a la propiedad

LinkVisited para cambiar el color del vínculo cuando ya se ha ejecutado dicho vínculo.
En la segunda línea se utiliza el método Start de la clase Process que administra la
ejecución de un programa utilizando el espacio de nombres System.Diagnostics. Al
incluir la dirección del sitio de Internet o la URL4 a continuación del método Start, se le
está diciendo a Visual Basic .NET que se desea ver el sitio Web especificado.
b) Seleccione el objeto vinculoexcel, de doble clic para abrir el editor del

procedimiento vinculoexcel_LinkClicked y escriba el siguiente código:
vinculoexcel.LinkVisited = True
System.Diagnostics.Process.Start("excel")
Una característica del método Start de la clase Process es que se puede utilizar
para ejecutar diferentes aplicaciones, el método Start puede recibir dos argumentos: el
primer argumento se utiliza para ejecutar una aplicación específica sin necesidad de
configurar la ubicación de la aplicación. En el segundo argumento se puede definir la
ruta y el nombre del documento que se quiere abrir. En este caso se busca ejecutar
solamente el programa Excel de Microsoft sin abrir ningún archivo específico.
Al realizar la ejecución del proyecto se visualizará la figura 7.1. Si se dá clic sobre el

vínculo Ir a Google se observará la página inicial de Google.
4
URL significa Uniform Resource Locator, es decir, localizador uniforme de recurso.
Es una secuencia de caracteres, de acuerdo a un formato estándar, que se usa para
nombrar recursos, como documentos e imágenes en Internet, por su localización.
92
Figura 7.2 Ejecución vínculo Ir a Google.
7.2 Controles ListBox y ComboBox
Los controles ListBox y ComboBox permiten definir una lista de elementos.

El control ListBox muestra una lista de elementos de los cuales el usuario puede
seleccionar uno o más. Si el número total de elementos supera el número que se puede
mostrar dentro del control, se agregará automáticamente una barra de desplazamiento al
control. El control ComboBox al igual que el control ListBox permite definir una lista
de elementos donde el usuario puede seleccionar un elemento o más. Al momento de la
ejecución del programa toda la lista de elementos, estarán a la vista del usuario para que
este los seleccione. Para seleccionar un elemento deberá pulsar la flecha que está al lado
derecho del encabezado.
7.2.1 Ejemplo práctico ListBox y ComboBox
Hacer una aplicación llamada ListBoxComboBox que permita a un usuario seleccionar

en un control ListBox un color y de un control ComboBox un tamaño de letra para
poder cambiar de color y/o tamaño de letra de un texto predefinido en un campo de
texto.
Utilizando el cuadro de herramientas haga clic en los siguientes controles y ubíquelos

en el formulario en la posición deseada: 2 Label, 1 ListBox, 1 ComboBox y 1
TextBox.

Tabla 7.2 Propiedades de los controles de la aplicación ListBoxComboBox.

TextBox1 Name texto
Text Texto para cambiar de color y tamaño
Font-Bold True
Label1 Name lblcolor
93
Text Cambiar el color de la letra
Label2 Name lblletra
Text Cambiar el tamaño de la letra
ComboBox1 Name listacolores
ListBox1 Name listaletra
Text Controles ListBox y ComboBox

Figura 7.3 Interfaz de usuario (ListBoxComboBox).
 Agregarle elementos a los controles ListBox y ComboBox
Para agregarle los elementos a los controles ListBox (listacolores) y ComboBox

(listaletra) se puede realizar de las siguientes formas:
1. Seleccionar el control, buscar la propiedad Items y pulsar para ver la ventana

Editor de la colección Cadena.
2. Seleccionar el control, dar clic sobre la flecha que aparece en la parte superior
derecha del control y allí escoger la opción Editar elementos para ver la
ventana Editor de la colección Cadena.
3. Dar doble sobre el formulario para ver la ventana de código del procedimiento
Sub formulario_Load. allí se debe escribir la siguiente línea por cada elemento
que se desee agregar:
nombre_del_control_ListisBox_o_ComboBox.Items.Add("nombre_del_elemento")
Se utilizará la opción 2. Al seleccionar el control listacolores y dar clic sobre la

flecha, se observará la ventana Tareas de ListBox:
94
Figura 7.4 Ventana agregar elementos a un ListBox.
Pulse la opción Editar elementos para ver la ventana del Editor de la colección
Cadena.
Figura 7.5 Ventana Editor de la colección Cadena.
Digite por cada línea el nombre de un color, para el ejemplo escriba: Negro,
Amarrillo, Verde, Azul, Rojo, Café, Rosado y Gris. La ventana del Editor quedaría de la
siguiente forma:
Figura 7.6 Ventana del Editor con los elementos agregados al control ListBox.
95
Al pulsar el botón Aceptar del Editor, el formulario tendrá la siguiente
apariencia:
Figura 7.7 Formulario con los elementos en el objeto ListBox.
Ahora seleccione el control listaletra y dé clic sobre la flecha, se observará la

ventana Tareas de ComboBox:
Figura 7.8 Ventana agregar elementos a un ComboBox.
Pulse la opción Editar elementos para ver la ventana del Editor de la colección
Cadena. Adicione los tamaños de letra de acuerdo a la siguiente figura:
96
Figura 7.9 Ventana del Editor con los elementos agregados al control ComboBox.
a) Seleccione el objeto listaletra, dé doble clic para abrir el editor de código

listaletra_SelectedIndexChanged y escriba el siguiente código:
Select listaletra.SelectedIndex
Case Is = 0
texto.Font = New Font("Microsoft Sans Serif", 8, FontStyle.Bold)
Case Is = 1
Case Is = 2
Case Is = 3
Case Is = 4
Case Is = 5
Case Is = 6
Case Is = 7
End Select
Al adicionar elementos a un control ListBox ó ComboBox, el primer elemento

tendrá como valor de índice cero (0), el segundo el valor de índice uno (1) y así
sucesivamente hasta el elemento n. En el anterior código por medio de la propiedad
SelectedIndex (selecciona el índice) del control listaletra se obtiene el valor del índice
que el usuario ha seleccionado para luego buscar el caso especifico y asignarle el nuevo
tamaño de letra a la propiedad Font del control texto. El nuevo tamaño se obtiene
asignando espacio de memoria (New) de tipo Font que recibe los siguientes parámetros:
tipo de letra, tamaño de letra y estilo de letra.
b) Seleccione el objeto listacolores, dé doble clic para abrir el editor de código

listacolores_SelectedIndexChanged y escriba el siguiente código:
97
Select Case listacolores.SelectedIndex
Case Is = 0
texto.ForeColor = Color.Black
Case Is = 1
texto.ForeColor = Color.Yellow
Case Is = 2
texto.ForeColor = Color.Green
Case Is = 3
texto.ForeColor = Color.Blue
Case Is = 4
texto.ForeColor = Color.Red
Case Is = 5
texto.ForeColor = Color.Brown
Case Is = 6
texto.ForeColor = Color.Pink
Case Is = 7
texto.ForeColor = Color.Gray
End Select
También con la propiedad SelectedIndex del control listacolores se obtiene el

valor del índice que el usuario ha seleccionado para luego buscar el caso específico y
asignarle el nuevo color de letra a la propiedad Forecolor del control texto. El nuevo
color se obtiene de la clase Color.
Cuando se ejecuta el proyecto se visualiza la figura 7.7. Si se selecciona del control

listacolores el color verde y del control listaletra el tamaño 22, se obtendrá la
siguiente figura:
Figura 7.10 Ejecución aplicación ListBoxComboBox.
98
7.3 Checkbox y RadioButton
Un control CheckBox es una casilla de verificación. Un control RadioButton

permite a un usuario escoger una opción entre varias opciones. Ambos controles tienen
dos estados (True, False). Tanto el control CheckBox como el RadioButton para
cambiar su estado se hace a través de la propiedad Checked.
La principal diferencia entre el CheckBox y el RadioButton es que si se tiene un
conjunto de controles CheckBox y un conjunto de RadioButton, en los CheckBox se
puede activar todos al mismo tiempo, mientras los RadioButton solo uno quedara
activado en un momento dado.
7.3.1 Ejemplo práctico Checkbox y RadioButton
Realizar una aplicación llamada CheckBoxRadioButton que permita a un usuario por

medio de controles CheckBox y RadioButton cambiar el tipo de fuente, el color de
fondo y el color del texto en un objeto Label.

en el formulario en la posición deseada: 4 Label, 2 Panel, 3 CheckBox, 3
RadioButton.

Tabla 7.3 Propiedades de los controles de la aplicación CheckBoxRadioButton.

Name txtcheckbox
Label1 Text Uso del control Checkbox
BorderStyle Fixed3D
Name txtradiobutton
Label2 Text Uso del control RadioButton
BorderStyle Fixed3D
Label3 Name lblcheckbox
Text Control CheckBox
Font -Bold True
Label4 Name lblradiobutton
Text Control RadioButton
Font -Bold True
CheckBox1 Name chequeo1
Text Cambiar tipo de letra
Text Cambiar color del texto
Text Cambiar color de fondo
RadioButton1 Name radio1
Text Cambiar color del texto
Checked True
99
Text Cambiar color de fondo
Text Cambiar color de texto
Panel1 Name panelcheckbox
Panel2 Naame panelradiobutton
Text Controles CheckBox - RadioButton

Figura 7.11 Interfaz de usuario (CheckBoxRadioButton).
a) Seleccione el objeto Chequeo1, dé doble clic para abrir el editor de código

Chequeo1_CheckedChanged y escriba el siguiente código:
If (Chequeo1.Checked) Then
txtcheckbox.Font=New Font ("Microsoft Sans Serif", 8.25!, FontStyle.Bold)
Else
txtcheckbox.Font=New Font ("Microsoft Sans Serif", 8.25!, FontStyle.Italic)
End If
La instrucción Chequeo1.Checked en la condición If activa el cuadro de

verificación en estado True. Por verdadero el tipo de fuente del objeto txtcheckbox
cambiará al tipo de fuente Microsoft Sans Serif, el tamaño 8.25! y el estilo de la fuente
a negrilla. Por falso retornará a los valores predefinidos en el control, es este caso el
tipo de fuente Microsoft Sans Serif, el tamaño 8.25! y el estilo de la fuente itálica.
b) Seleccione el objeto Chequeo2, dé doble clic para abrir el editor del

procedimiento Chequeo2_CheckedChanged y escriba el siguiente código:
txtcheckbox.BackColor = System.Drawing.Color.Aquamarine
Else
txtcheckbox.BackColor = System.Drawing.Color.White
End If
100
Por verdadero el texto del objeto txtcheckbox cambiará de color utilizando el
espacio de nombres System.Drawing.Color al cual se le asigna el color deseado. Por
falso se retornará a los valores predefinidos en el control, es este caso el color del texto
volverá a ser negro.
c) Seleccione el objeto Chequeo3, dé doble clic para abrir el editor del

procedimiento Chequeo3_CheckedChanged y escriba el siguiente código:
txtcheckbox.ForeColor = System.Drawing.Color.Red
Else
txtcheckbox.ForeColor = System.Drawing.Color.Black
End If
Por verdadero el objeto txtcheckbox cambiara de color de fondo utilizando el

espacio de nombres System.Drawing.Color al cual se le asigna el color deseado. Por
falso se retornará a los valores predefinidos en el control, es este caso el color de fondo
es blanco.
d) Seleccione el objeto radio1, dé doble clic para abrir el editor del procedimiento
radio1_CheckedChanged y escriba el siguiente código:
If (opcion1.Checked) Then
txtradiobutton.Font= New Font("Microsoft Sans Serif", 8.25!,FontStyle.Bold)
Else
txtradiobutton.Font=New Font("Microsoft Sans Serif" ,8.25!, FontStyle.Italic)
End If
e) Seleccione el objeto radio2, dé doble clic para abrir el editor del procedimiento
txtradiobutton.ForeColor = System.Drawing.Color.Red
Else
txtradiobutton.ForeColor = System.Drawing.Color.Black
End If
f) Seleccione el objeto radio3, dé doble clic para abrir el editor del procedimiento
txtradiobutton.BackColor = System.Drawing.Color.Aquamarine
Else
txtradiobutton.BackColor = System.Drawing.Color.White
End If
Como se puede apreciar, la programación de los controles RadioButton es

exactamente igual a la de los controles CheckBox.
Al ejecutar el proyecto en el entorno de desarrollo de Visual Basic.NET, se visualizará

la figura 7.11. Si se pulsan cada uno de los controles CheckBox y el control
101
RadioButton con el texto Cambiar color de fondo, se obtendrá la siguiente figura:
Figura 7.12 Ejecución aplicación CheckBoxRadioButton.
7.4 VScrollBar, HScroolBar, TrackBar.
Un control VScrollBar es una barra de desplazamiento que permite manipular

rangos de valores numéricos por medio de su propiedad Value, los cuales son
establecidos por las propiedades maximum (máximo valor) y minimum (mínimo
valor). El control HScrollBar realiza la misma función, solo los diferencia la forma
de presentación. Estos controles son utilizados para implementar el desplazamiento en
los contenedores que no proporcionan sus propias barras de desplazamiento, como
PictureBox. El objeto TrackBar es un control desplazable similar al control
ScrollBar. Para configurar los intervalos entre los que se desplaza se utiliza la
propiedad Value de una barra de seguimiento, estableciendo la propiedad Minimum
para especificar el extremo inferior del intervalo y la propiedad Maximum para
especificar el extremo superior del intervalo.
7.4.1 Ejemplo práctico VScrollBar y TrackBar
Diseñar una aplicación llamada ColoresPersonalizados que permita a un usuario por

medio de controles VScrollBar y TrackBar visualizar un color personalizado al
realizar un desplazamiento en cualquiera de los controles.

en el formulario en la posición deseada: 3 Label, 3 Panel, 3 TextBox, 3 VScrollBar, 3
TrackBar.

102
Tabla 7.4 Propiedades de los controles de la aplicación ColoresPersonalizados.

VScrollBar1, Name barra1, barra2, barra3
VScrollBar2, Maximum 255
VScrollBar3. Minimum 0
TrackBar1, Name desplazamiento1, desplazamiento2,
TrackBar2, desplazamiento3
TrackBar3 Maximum 255
Minimum 0
Label1 Name lblrojo
Text Rojo:
Label2 Name lblverde
Text Verde:
Label3 Name lblazul
Text Azul:
TextBox1 Name txtrojo
Text En blanco
Enabled False
TextBox2 Name txtverde
Text En blanco
Enabled False
TextBox3 Name txtazul
Text En blanco
Enabled False
Panel1 Name panelsrcollbar
Panel2 Name paneltrackbar
Panel3 Name panelcolores
Text Controles VScrollBar - TrackBar

Figura 7.13 Interfaz de usuario (ColoresPersonalizados).
a) Seleccione el objeto barra1, dé doble clic para abrir el editor del procedimiento
barra1_Scroll y escriba el siguiente código:
103
panelcolores.BackColor = Color.FromArgb (barra1.Value, barra2.Value, barra3.Value)
txtrojo.Text = barra1.Value
b) Seleccione el objeto barra2, dé doble clic para abrir el editor del procedimiento

txtverde.Text = barra2.Value
c) Seleccione el objeto barra3, dé doble clic para abrir el editor del procedimiento

txtazul.Text = barra3.Value
En el anterior código al control panelcolores se le modifica la propiedad

Backcolor asignándole el método FromArgb de la clase Color, el cual define un color
tomando como parámetros los valores de los controles barra1, barra2, barra3 en su
propiedad Value (rojo, verde, azul) . Cada vez que se realiza un desplazamiento por
cada barra se le asigna a los controles txtrojo, txtverde, txtazul en su propiedad Text
el valor de cada barra de desplazamiento que toma el control en su propiedad Value.
Para los controles TrackBar realice la misma programación, solamente es

necesario cambiar el nombre del control es decir barra? por desplazamiento?.
Al ejecutar el proyecto se visualizará la figura 7.13. Si se realiza un desplazamiento por

cada uno de los controles ScrollBar ó TrackBar se mostrará en el objeto panelcolores
un color. Por ejemplo, si se tiene un valor de 76 para el rojo, 113 para el verde y 211
para el azul se obtendrá un color azul cielo. Esto se puede apreciar en la siguiente
figura:
Figura 7.14 Ejecución aplicación ColoresPersonalizados.
104
7.5 DataGridView
Un control DataGridView permite mostrar datos en una malla o tabla, estos datos
pueden ser con o sin orígen de datos externos (archivos de texto, bases de datos). Sin
especificar un orígen de datos, se pueden crear las columnas y filas que contendrán los
datos y agregarlas directamente al DataGridView. Con orígen de datos se pueden
establecer las propiedades DataSource y DataMember para enlazar el control
DataGridView a un orígen de datos y llenarlo de datos automáticamente.
7.5.1 Ejemplo práctico DataGridView
Crear una aplicación llamada DataGridView que permita a un usuario digitar un

número y al pulsar un botón se muestre en una cuadricula la tabla de multiplicación de
dicho número.

en el formulario en la posición deseada: 2 Label, 1 DataGridView, 1 TextBox, 1
Button.
 Establecer las propiedades de los objetos de la interfaz de usuario.

Tabla 7.5 Propiedades de los controles de la aplicación DataGridView.

Label2 Name lbltabla
Text Tabla de Multiplicar del número N.
Text En blanco
DataGridView1 Name tabla
Button1 Name boton
Text Ver Tabla
Text Control DataGridView.

105
Figura 7.15 Interfaz de usuario (DataGridView).
Seleccione el objeto boton, dé doble clic para abrir el editor del procedimiento
botón_click y escriba el siguiente código:
With tabla
.Columns.Add("Multiplicando", " Multiplicando ")
.Columns.Add("Multiplicador", " Multiplicador ")
.Columns.Add("Producto", "Producto")
.RowCount = 10
For i As Integer = 0 To .RowCount - 1
.Item(0, i).Value = txtnumero.Text
.Item(1, i).Value = i + 1
.Item(2, i).Value = (txtnumero.Text * (i + 1))
Next
End With
Este código sirve para rellenar el objeto tabla con los respectivos datos.
Utilizando el método Add de la propiedad Columns se le adicionan los nombres
Multiplicando, Multiplicador, Producto en la primera fila del objeto tabla y por
medio de la propiedad RowCount se le asigna un valor de 10 filas. Con un ciclo For
que se ejecutará desde una posición i igual a cero (0) hasta el numero de filas -1 del
objeto tabla y por cada fila se visualizarán tres ítems. En la primera columna se
imprimirá el valor digitado en el objeto txtnumero, en la segunda columna se
imprimirá el valor de i+1 y en la tercera columna el producto de multiplicar el valor del
objeto txtnumero por i+1.
Al ejecutar el proyecto se visualizará la figura 7.15. Si se escribe el número 8 en el

objeto txtnumero y se pulsa el botón Ver tabla, se obtendrá la siguiente figura:
106
Figura 7.16 Ejecución aplicación DataGridView.
7.6 ListView
Un control ListView permite visualizar una lista de elementos con texto y

opcionalmente con un icono que identifique al elemento. Los elementos se pueden
mostrar cómo: iconos grandes, iconos pequeños, lista de iconos o detalles. La vista de
detalles (Details) permite mostrar el elemento y sus subelementos en una cuadrícula con
encabezados de columna que identifican la información que se presenta en un
subelemento.
7.6.1 Ejemplo práctico ListView
Crear una aplicación llamada ListView que permita a un usuario seleccionar un tipo de
comida rápida, como también seleccionar un tipo de bebida. El usuario deberá visualizar
en un control ListView un código, el elemento seleccionado, el valor del elemento, así
como la sumatoria de los elementos seleccionados. Por otro lado, el usuario podrá
seleccionar un elemento y eliminarlo del control ListView.

en el formulario en la posición deseada: 4 Label, 1 TextBox, 2 ComboBox, 3 Button,
1 ListView.

107
Tabla 7.6 Propiedades de los controles de la aplicación ListView.

Label1 Name lbltexto
Text Solicitar pedido
Font-Bold True
Label2 Name lblcomida
Text Comida rápida :
Label3 Name lblbebida
Text Bebida:
Label4 Name lbltotal
Text Total Pedido
Font-Bold True
TextBox1 Name txttotal
Text En blanco
ListView1 Name elementospedido
ComboBox1 Name combocomida
ComboBox2 Name combobebida
Button1 Name botoncomida
Text Adicionar Comida
Button2 Name botonbebida
Text Adicionar Bebida
Text Eliminar comida o bebida
Text Control ListView.

Figura 7.17 Interfaz de usuario (ListView).
Ahora se deberá seleccionar el control combocomidas y dar clic sobre la flecha

que aparece en la parte superior derecha, se observará la ventana Tareas de
ComboBox:
108
Figura 7.18 Ventana Tareas de ComboBox.
Escoja la opción Editar elementos y adicione los elementos que se muestran en

la siguiente figura:
Figura 7.19 Editor con los elementos incluidos en el objeto combocomidas.
Al terminar de digitar los elementos del objeto combocomidas, seleccione el

objeto combobebidas, dé clic sobre la flecha para observar la ventana Tareas de
ComboBox, nuevamente escoja la opción Editar elementos y adicione los elementos
que se muestran en la siguiente figura:
Figura 7.20 Editor con los elementos incluidos en el objeto combobebidas.
109
Al finalizar de incluir los respectivos elementos en el objeto combocomidas,
seleccione el objeto ListView elementospedidos dé clic sobre la flecha para observar la
ventana Tareas de Listview, se apreciara la siguiente figura:
Figura 7.21 Ventana Tareas de ListView del objeto elementospedido.
Seleccione el objeto ComboBox al frente del texto Vista y escoja la opción

Details (permite visualizar todos los elementos de un ListView en forma detallada).
Después seleccione la opción Editar Columnas para ver la ventana del Editor de la
colección ColumnHeader. Pulse el botón Agregar para incluir un objeto
ColumnHeader1 en la casilla Miembros. Busque en la casilla Propiedades de
ColumnHeader1 la propiedad Text y escriba Código. Realice esta misma operación
para agregar dos ColumnHeader más en ellos, en la propiedad Text escriba
comida/bebida y valor respectivamente. La siguiente figura visualiza el editor con los
nuevos miembros.
Figura 7.22 Ventana Editor de la colección ColumnHeader.
Pulse el botón Aceptar para visualizar la interfaz de usuario final.
110
Figura 7.23 Interfaz de usuario final de la aplicación ListView.
a) Despúes de la apertura de la clase Public class formulario y antes del primer

procedimiento Sub, declare como publicas las variables llamadas valor, código,
sumar, i de tipo Integer. Dé doble clic sobre el formulario y busque clase
formulario y escriba este código escriba:

Public valor, código, sumar, i As Integer
Se declaran como publicas las variables valor, código, sumar e i. Estas podrán
ser utilizadas por cualquier procedimiento de la clase.
b) Seleccione el objeto formulario, dé doble clic para abrir el editor del

procedimiento Formulario_Load y escriba el siguiente código:
código = 1
Se le asigna a la variable código el valor de uno (1) cuando se carga el

formulario.
c) Seleccione el objeto botoncomidas, dé doble clic para abrir el editor de código y

Dim item As New ListViewItem(código)

item.SubItems.Add(combocomida.SelectedItem)
item.SubItems.Add(valor)
elementospedido.Items.Add(item)
codigo += 1
sumar = 0
For Me.i = 0 To elementospedido.Items.Count - 1
sumar = sumar + CDbl(elementospedido.Items(i).SubItems(2).Text)
Next
txttotal.Text = sumar
111
Inicialmente se crea un objeto ítem al cual se le asigna espacio de memoria
(New) de tipo ListViewItem y recibe como parámetro la variable código. Utilizando la
función Add de la propiedad SubItems se le adiciona al objeto ítem dos nuevos
elementos: lo seleccionado en el objeto combocomida por intermedio de la propiedad
SelectedItem y la variable valor. Al objeto ListView llamado elementospedido se le
adiciona (Add) en la propiedad Items los elementos que contiene el objeto ítem. Por
otro lado, se incrementa el valor de la variable código en uno (1) y a la variable sumar
se le asigna el valor de cero (0). Con un ciclo For que se ejecutará desde una posición i
igual a cero (0) hasta el numero total de Items.count -1 del objeto elementospedido. A
la variable sumar se le asignará el valor de esta más el valor del SubItems (2), o sea el
valor de la comida. Se utilizó la función CDbl para convertir el valor numérico a
caracter. Por último se le asigna a la propiedad Text del objeto txttotal el valor de la
variable sumar.
d) Seleccione el objeto botonbebidas, dé doble clic para abrir el editor de código y

Dim item As New ListViewItem(código)

item.SubItems.Add(combobebida.SelectedItem)
item.SubItems.Add(valor)
elementospedido.Items.Add(item)
codigo += 1
sumar = 0
Next
Basicamente realiza las mismás operaciones que el objeto botoncomidas, lo

unico es que adiciona al objeto elementospedido el nombre de la bebida y el valor de
esta.
e) Seleccione el objeto combobebidas, de doble clic para abrir el editor del

procedimiento Sub combobebida_SelectedIndexChanged y escriba el
siguiente código:
Select Case combobebida.SelectedIndex
Case 0
valor = 4000
Case 1
valor = 2500
Case 2
valor = 1200
Case 3
valor = 3500
Case 4
valor = 3000
End Select
Al adicionar elementos a un control ComboBox, el primer elemento tendrá

como valor de índice cero (0), el segundo el valor de índice uno (1) y así sucesivamente
hasta el elemento n. Por medio de la propiedad SelectedIndex (selecciona el índice)
del control combobebida se obtiene el valor del índice que el usuario ha seleccionado
para luego buscar el caso especifico y asignarle el nuevo valor de la bebida a la variable
valor.
112
f) Seleccione el objeto combocomidas, dé doble clic para abrir el editor del
procedimiento Sub combocomida_SelectedIndexChanged y escriba el
siguiente código:
Select Case combocomida.SelectedIndex

Case 0
valor = 1500
Case 1
valor = 1300
Case 2
valor = 1800
Case 3
valor = 1500
Case 4
valor = 2000
End Select
Por medio de la propiedad SelectedIndex (selecciona el índice) del control

combocomida se obtiene el valor del índice que el usuario ha seleccionado para luego
buscar el caso especifico y asignarle el nuevo valor de la comida a la variable valor.
g) Seleccione el objeto botoneliminar, dé doble clic para abrir el editor y escriba el

siguiente código:
If elementospedido.FocusedItem Is Nothing Then
MsgBox("No hay item seleccionado", MsgBoxStyle.Exclamation)
Exit Sub
Else
Dim respuesta = MsgBox("Desea Eliminar el elemento (Si/No):", MsgBoxStyle.YesNo)
If (respuesta = "6") Then
elementospedido.Items.RemoveAt(elementospedido.FocusedItem.Index)
Else
MsgBox("Elemento No eliminado", MsgBoxStyle.Information)
End If
End If
sumar = 0
Next
Se utiliza la estructura If para determinar si no se ha seleccionado algún ítem del

objeto elementospedido, se valida con la palabra reservada Nothing (vacio). Si esto
ocurre se visualizará en un cuadro de diálogo el mensaje No hay ítem seleccionado, y
se saldrá del procedimiento con la función Exit Sub. En caso contrario, se crea una
variable llamada respuesta a la que se le asignará un cuadro de diálogo con estilo
YesNo y el mensaje “Desea Eliminar el elemento (Si/No):”. Si en dicho cuadro se
pulsa el botón Sí, el valor de la variable respuesta será igual a 6 y por consiguiente se
eliminará el ítem seleccionado utilizando la función RevomeAt, por falso se mostrará
un cuadro de diálogo con el mensaje elemento No eliminado con un estilo de icono de
información.
Al ejecutar el proyecto se visualizará la figura 7.25. Si se selecciona y se adiciona como
113
comida Hamburguesa, empanada (2 veces) y como bebida Jugo, se obtendrá la
siguiente figura:
Figura 7.24 Ejecución aplicación ListView.
Como se puede apreciar, el ítem 2 y 3 tiene como elemento comida empanada.

Si se desea eliminar alguno de estos dos ítems se debe seleccionar el ítem a eliminar,
como muestra la siguiente figura:
Figura 7.25 Seleccionar un item del control elementospedido.
Al pulsarse el botón Eliminar comida o bebida, se visualiza el cuadro de

diálogo de confirmación de eliminación del elemento.
Figura 7.26 Cuadro de diálogo para confirmar la eliminación de un elemento.
114
Al pulsar el botón Si, el formulario se apreciaría de la siguiente forma:
Figura 7.27 Formulario de solicitud de pedido.
7.7 RichTextBox
Un control RichTextBox permite tener un texto en varias líneas. Todo el texto que
se muestra se establece con la propiedad Text. El control RichTextBox sirve para
manipular archivos; los métodos LoadFile y SaveFile pueden mostrar y escribir en
varios formatos de archivo, entre ellos, texto sin formato, texto sin formato Unicode y
formato de texto enriquecido (RTF). Puede utilizar el método Find para buscar cadenas
de texto o caracteres específicos.
7.7.1 Ejemplo práctico RichTextBox
Elaborar una aplicación llamada RichTextBox que permita a un usuario buscar

palabras o frases en un texto. Si se encuentra la palabra o la frase esta se debe resaltar.
Cuando se desee realizar una segunda búsqueda la palabra o frase anterior debe quedar
resaltada con otro color.

en el formulario en la posición deseada: 1 Label, 1 TextBox, 1 RichTextBox, 1
Button.


Label1 Name lblpalabra
Text Palabra o frase a buscar:
115
TextBox1 Name txtpalabra
Text En blanco
RichTextbox1 Name texto
Text Copiar cualquier texto
Text Buscar coincidencias
Text Control RichTextBox

Figura 7.28 Interfaz de usuario (RichTextBox).
a) Seleccione el objeto botonbuscar, dé doble clic para abrir el editor del

procedimiento botonbuscar_click y escriba el siguiente código:
buscar_patron(txtpalabra.Text, texto, Color.Red, Color.Yellow)
Se llama al procedimiento buscar_patron, el cual tiene como parametros: el

texto a buscar (txtpalabra.text), El control RichTextBox (texto), El color para resaltar
el texto encontrado (Color.Red), el color para resaltar el fondo del texto encontrado
(Color.Yellow).
b) Dé doble clic sobre el formulario y cree después de un End Sub y antes del
End Class el siguiente procedimiento Sub.
Private Sub buscar_patron(ByVal textoabuscar As String,

ByVal objetotexto As Windows.Forms.RichTextBox ,
ByVal colortexto As Color, ByVal colorfondo As Color)
Dim coincidencias As MatchCollection
Dim palabra As Match
Try
Dim cadenaabuscar As New Regex(textoabuscar.ToString, RegexOptions.IgnoreCase)
coincidencias = cadenaabuscar.Matches(objetotexto.Text)
116
With objetotexto
.SelectAll()
.SelectionColor = Color.Black
End With
For Each palabra In coincidencias
With objetotexto
.SelectionStart = palabra.Index
.SelectionLength = palabra.Length
.SelectionColor = colortexto
.SelectionBackColor = colorfondo
End With
Next
Catch ex As Exception
MsgBox(ex.Message.ToString)
End Try
End Sub
Se crea el procedimiento buscar_patron el cual recibe como parámetros las

variables: textoabuscar de tipo String, objetotexto de tipo RichTextBox, colortexto y
colorfondo de tipo Color. También se crean las variables coincidencias de tipo
MathCollection (representa un conjunto de palabras o frases encontradas en un texto
especifico) y palabra de tipo Math (representa una palabra o frase encontrada en un
texto especifico). Se define un bloque Try-Catch para atrapar errores y las acciones a
seguir. En el bloque Try se establece el código que realiza una tarea específica y que en
un caso dado pueden generar un error; en el bloque Catch irá el código que realizará las
acciones a seguir en caso de un error. Dentro del bloque Try se crea un objeto llamado
cadenaabuscar a la cual se le asigna espacio de memoria de tipo Regex (representa la
cadena a buscar) y recibe como parametros: el texto a buscar (textoabuscar.ToString),
además, se le indica que ignore las mayúsculas o minúsculas
(RegexOptions.IgnoreCase). Al objeto coincidencias se le asigna una colección de
todas las cadenas coincidentes (Matches) que se encuentren en el objeto RichTextBox
(objetotexto.Text). Por otro lado, si se ha realizado alguna búsqueda anterior se utiliza
la cláusula With para cambiar el color del texto encontrado con anterioridad a negro. Si
se encuentran coincidencias se utiliza la estructura For-Each para recorrer cada una de
las palabras o frases encontradas dentro del texto. Cuando se está recorriendo el
contenido del objeto RichTextBox (objetotexto), al encontrarse una palabra o frase
coincidente (SelectionStart = palabra.Index) , se determina su longitud
(.SelectionLength = palabra.Length) y se cambia el color del texto (.SelectionColor =
colortexto) y el fondo del texto (.SelectionBackColor = colorfondo). Este proceso se
realizará hasta encontrar la ultima coincidencia dentro del control objetotexto. En el
bloque Catch se captura en el objeto ex de tipo Exception el error que se pueda generar
y se mostrará un cuadro de diálogo con el mensaje de error. Por último se cierra el Sub (
End Sub).
Al ejecutar el proyecto se visualizará la figura 7.28. Si se escribe la subcadena “la” y se

pulsa el botón Buscar coincidencias, se obtendrá la siguiente figura:
117
Figura 7.29 Ejecución aplicación RictTextBox con la subcadena “la” encontrada.
Si se realiza una nueva búsqueda, por ejemplo, encontrar la subcadena “al sur
de chile”, el color del texto encontrado anteriormente se volverá nuevamente negro y la
nueva coincidencia quedará de color rojo.
Figura 7.30 Ejecución aplicación RictTextBox con una nueva búsqueda.
7.8 TreeView
Un control TreeView permite mostrar una jerarquía de nodos a usuarios, del

mismo modo como se muestran las carpetas y los archivos en el explorador de
Windows. Cada nodo (nodos primarios) puede contener otros nodos, llamados nodos
secundarios. Los nodos primarios o los nodos secundarios se pueden visualizar como
expandidos o contraídos. También se puede mostrar una vista de los nodos con casillas
de verificación junto a los nodos estableciendo la propiedad CheckBoxes con el valor
True. Por otro lado, es posible activar o desactivar los nodos mediante programación
estableciendo la propiedad Checked del nodo en True o False.
118
Las propiedades principales del control TreeView son Nodes y SelectedNode.
La propiedad Nodes contiene la lista de nodos del nivel superior del los nodos. La
propiedad SelectedNode establece el nodo seleccionado.
7.8.1 Ejemplo práctico TreeView
Elaborar una aplicación llamada TreeView que permita a un usuario visualizar las
unidades lógicas de un computador, además poder desplazarse por las carpetas de cada
unidad lógica.

en el formulario en la posición deseada: 1 Label, 1 TreeView.


Text Explorador de unidades lógicas
TreeView1 Name explorador
Text Control RichTextBox

Figura 7.31 Interfaz de usuario (TreeView).
119
a) Antes de la apertura de la clase se debe importar el espacio de nombres

System.IO. Dé doble clic sobre el formulario, busque Public class formulario
y antes de este código escriba lo siguiente:
imports System.IO
……
End Class
Se importa el espacio de nombres System.IO para poder realizar operaciones

con las unidades logicas del sistema operativo.
b) Dé doble clic sobre el formulario para abrir el editor del procedimiento

formulario_load y escriba el siguiente código:
Dim unidades() As String

unidades = System.Environment.GetLogicalDrives
For Each unidad As String In unidades
explorador.Nodes.Add(unidad)
Next
Se declara una matriz de tipo String llamada unidades a la cual se le asignan las
unidades logicas del equipo donde se este trabajando por medio de la función
GetLogicalDrives de la clase Environment del espacio de nombres System. Se utiliza
la estructura For-Each para recorrer cada una de las unidades lógicas que contiene la
matriz unidades. Cada unidad es adicionada como un nodo al control TreeView
explorador.
c) Seleccione el objeto explorador, dé doble clic para abrir el editor del

procedimiento explorador_AfterSelect y escriba el siguiente código:
Dim directorio As DirectoryInfo

directorio = New DirectoryInfo(e.Node.FullPath)
Dim carpetas() As DirectoryInfo
carpetas = directorio.GetDirectories()
Dim subcarpetas As DirectoryInfo
Dim nodo As TreeNode
For Each subcarpetas In carpetas
nodo = New TreeNode(subcarpetas.Name, 0, 1)
e.Node.Nodes.Add(nodo.Text)
Next
Cuando se selecciona una de las unidades que se muestran en el control

explorador, se crea una variable directorio de tipo DirectoryInfo (permite las
operaciones con carpetas y archivos), a esta se le asigna la ruta de la unidad escogida.
También se crea una matriz llamada carpetas() a la cual se le asigna cada uno de las
carpetas que contiene la unidad seleccionada. Además se crean dos variables:
subcarpetas de tipo DirectoryInfo y la otra llamada nodo de tipo TreeNode. Con una
estructura For-Each se recorre cada una de las subcarpetas de la carpeta escogida. A la
variable nodo se le asigna espacio de memoria de tipo TreeNode y recibe como
parámetros el nombre de la subcarpeta, la imagen que se ha de mostrar cuando el nodo
120
seleccionado(si existe), la imagen que se ha de mostrar cuando el nodo no este
seleccionado (si existe). Por último se adiciona dicho nodo como un nodo secundario.
Al ejecutar el proyecto se visualizará la siguiente figura con las unidades lógicas

encontradas:
Figura 7.32 Ejecución aplicación TreeView.
Si se selecciona la unidad C:\ se mostrarán cada una de las carpetas de dicha

unidad. Si se escoge una de las subcarpetas se visualizarán las subcarpetas de dicha
subcarpeta. Se podría obtener una figura similar:
Figura 7.33 Aplicación TreeView con una unidad seleccionada.
121
7.9 FolderBrowserDialog
Un control FolderBrowserDialog permite mostrar un cuadro de diálogo donde se

pide al usuario que seleccione una carpeta. Tiene la misma apariencia del explorador de
Windows. La carpeta raíz donde se va a empezar a examinar se obtiene con la propiedad
RootFolder, mientras la propiedad SelectedPath permite establecer la ruta
seleccionada por el usuario. Con la propiedad ShowNewFolderButton se establece un
valor (True, False) que indica si el botón Nueva carpeta aparece en el cuadro de
diálogo de examinar carpetas.
7.9.1 Ejemplo práctico FolderBrowserDialog
Elaborar una aplicación llamada FolderBrowserDialog que permita a un usuario

visualizar las unidades lógicas de un computador, además poder desplazarse por las
carpetas de cada unidad lógica.

en el formulario en la posición deseada: 1 Button, 1 FolderBrowserDialog.

Tabla 7.9 Propiedades de los controles de la aplicación FolderBrowserDialog.

Button1 Name boton
Text Ver cuadro de diálogo de las unidades actuales.
FolderBrowserDialog1 Name unidades
Text Control FolderBrowserDialog.

Figura 7.34 Interfaz de usuario (FolderBrowserDialog).
122
Seleccione el objeto boton, dé doble clic para abrir el editor del procedimiento
boton_Click y escriba el siguiente código:
Try
With unidades
.Reset()
.Description = " Seleccionar una unidad y/o carpeta "
.SelectedPath = Environment.GetFolderPath(Environment.SpecialFolder.Personal)
.ShowNewFolderButton = False
.RootFolder = Environment.SpecialFolder.Desktop
Dim vercuadro As DialogResult = .ShowDialog
If vercuadro = DialogResult.OK Then
Dim nroarchivos As ObjectModel.ReadOnlyCollection(Of String)
nroarchivos = My.Computer.FileSystem.GetFiles(.SelectedPath)
MsgBox("Total de archivos en la unidad y/o carpeta seleccionada :" &
nroarchivos.Count, MsgBoxStyle.Information)
End If
.Dispose()
End With
MsgBox(ex.Message, MsgBoxStyle.Critical)
End Try
En el bloque Try se establece una cláusula With donde se realizan las siguientes
operaciones con el control FolderBrowserDialog unidades: .Reset() reinicia el control
unidades; .Description muestra una descripción del control unidades; .SelectPath
selecciona una unidad o carpeta especifica, es este caso la carpeta Personal (My
Documents), .ShowNewFolderButton permite habilitar (True) o deshabilitar (False) la
opcion de creación de nuevas carpetas; .RootFolder determina la unidad o carpeta
inicial a mostrar. Por otro lado, se crea una variable de tipo DialogResult llamada
vercuadro a la cual se le asigna la propiedad ShowDialog del control unidades. Se
valida si en el cuadro de diálogo se pulsa el botón Aceptar. Si se cumple la condición
se crea un objeto nroarchivos de tipo ReadOnlyCollection (crea una colección de solo
lectura) del espacio de nombres ObjectModel, a este, se le asigna una colección de solo
lectura de todos los archivos de la unidad o carpeta seleccionada
(My.Computer.FileSystem.GetFiles(.SelectedPath)) y se muestran el total de
archivos (Count) en un cuadro de diálogo MsgBox. Por último se libera (.dispose()) los
recursos utlizados. En el bloque Catch se captura en el objeto ex de tipo Exception el
error que se pueda generar y se mostrará un cuadro de diálogo con el mensaje de error.
Al ejecutar el proyecto se mostrará el formulario de la figura 7.34. Si se pulsa el botón

Ver cuadro de diálogo de las unidades actuales se visualizará el cuadro de diálogo
del control FolderBrowserDialog unidades:
123
Figura 7.35 Ejecución aplicación FolderBrowserDialog.
Si se escoge el icono Mi PC y se selecciona unidad C:\ se mostrarán cada una

de las carpetas de dicha unidad. Se podría obtener una figura similar:
Figura 7.36 Aplicación FolderBrowserDialog con la unidad C:\ seleccionada.
Al pulsarse el botón Aceptar se mostrará un cuadro de diálogo con el mensaje

“Total de archivos en la unidad y/o carpeta seleccionada: #”, como se observa en la
siguiente figura:
124
Figura 7.37 Cuadro de diálogo con el total de archivos de una unidad seleccionada.
7.10 WebBrowser
Un control WebBrowser permite visualizar páginas Web en las aplicaciones

cliente de los formularios Windows Forms y/o otros documentos tipo HTML. El control
WebBrowser contiene eventos relacionados con la navegación ó exploración: Url
(dirección electrónica de una página web), Navigate (navegar), GoBack (ir atrás),
GoForWard (ir adelante), GoHome (Ir al inicio), GoSearch (Buscar), Stop (Parar),
Refresh (refrescar), etc.
7.10.1 Ejemplo práctico WebBrowser
Elaborar una aplicación llamada WebBrowser que permita a un usuario visualizar

páginas Web específicas desde un control WebBrowser. El usuario debe poder ir al
inicio, ir a la página anterior, ir a la página siguiente, detener la ejecución de una página,
refrescar una ejecución de una página, como también visualizar la página visitada en un
momento dado.

en el formulario en la posición deseada: 6 Button, 1 ComboBox, 1 WebBrowser, 1
Label.

Tabla 7.10 Propiedades de los controles de la aplicación WebBrowser.

Button1 Name botonanterior
Text Anterior
Button2 Name botonsiguiente
Text Siguiente
Button3 Name botoninicio
Text Inicio
Button4 Name botondetener
Text Detener
125
Button5 Name botonrefrescar
Text Actualizar
Button6 Name botonnavegar
Text Navegar
ComboBox1 Name combopaginas
WebBrowser1 Name navegador
Label1 Name textopagina
Text Texto página
Text Control WebBrowse.

Figura 7.38 Interfaz de usuario (WebBrowser).
Ahora se deberá seleccionar el control combopaginas y dar clic sobre la flecha

que aparece en la parte superior derecho, se observará la ventana Tareas de
ComboBox:
Figura 7.39 Ventana Tareas de ComboBox del objeto combopaginas.
126
Escoja la opción Editar elementos y adicione los elementos que se muestran en
Figura 7.40 Ventana Editor con las páginas Web ingresadas.
a) Seleccione el objeto botonanterior, dé doble clic para abrir el editor del

procedimiento botonanterior_Click y escriba el siguiente código:
navegador.GoBack()
Se utiliza el método GoBack() del objeto navegador para ir a la anterior página.
b) Seleccione el objeto botonsiguiente, dé doble clic para abrir el editor del

procedimiento botonsiguiente_Click y escriba el siguiente código:
navegador.GoForward()
Se utiliza el método GoForWard() del objeto navegador para ir a la siguiente

página.
c) Seleccione el objeto botoninicio, dé doble clic para abrir el editor del

procedimiento botoninicio_Click y escriba el siguiente código:
navegador.GoHome()
Se utiliza el método GoHome() del objeto navegador para ir a la página de

inicio.
d) Seleccione el objeto botondetener, dé doble clic para abrir el editor del

procedimiento botondetener_Click y escriba el siguiente código:
navegador.Stop()
127
Se utiliza el método Stop() del objeto navegador para ir detener una página en
ejecución.
e) Seleccione el objeto botonrefrescar, dé doble clic para abrir el editor del

procedimiento botonrefrescar_Click y escriba el siguiente código:
navegador.Refresh()
Se utiliza el método Refresh() del objeto navegador para ir actualizar una

página en ejecución.
f) Seleccione el objeto botonnavegar, dé doble clic para abrir el editor del

procedimiento botonnavegar_Click y escriba el siguiente código:
navegador.Navigate(Trim(combopaginas.SelectedItem))
textopagina.Text = combopaginas.SelectedItem
Se utiliza el método Navigate() del objeto navegador para ejecutar una página.
Recibe como parámetros la página seleccionada en la propiedad SelectedItem del
control combopaginas. Con la función Trim se quitan todos los espacios que existan.
Por otro lado, se le asigna a la propiedad Text del objeto textopagina la página
seleccionada.
Al ejecutar el proyecto se mostrará el formulario de la figura 7.38. Si se selecciona del

objeto combopaginas la página Web http://google.com.co y se pulsa el botón Navegar
se visualizará en el control WebBrowser la página inicial de Google.
Figura 7.41 Ejecución de la página de Google.
128
7.11 Ejercicios interfaz de usuario
1. Escribir un programa que permita a un usuario capturar dos números,

seleccionar un operador aritmético e imprimir en un DataGridView los dos
números, el operador y el resultado de la operación.
2. Realizar un programa que permita a un usuario seleccionar desde un Checkbox
y/o un ComBobox una palabra en español e imprimir dicha palabra en Ingles y
en Francés.
3. Elaborar un programa que permita seleccionar un producto, digitar una cantidad
e imprimir en un DataGridView el producto, la cantidad y el valor unitario y el
valor total del producto, así como la sumatoria de todos los productos escogidos.
4. Hacer un programa que permita por medio de un HScrollBar desplazarse y en un
Label mostrar el valor Ascci asociado a la barra de desplazamiento. El rango de
valores debe estar entre 1 y 255.
5. Diseñar un programa que permita seleccionar entre varias opciones lo siguiente:
un equipo de futbol, una afición, una profesión e imprimir en un cuadro de
diálogo cual equipo de futbol es su favorito, que afición le gusta más y que
profesión le gustaría tener.
6. Crear un programa que permita realizar una búsqueda de un texto en una página
web alojada en un control WebBrowse.
7. Escribir un programa que permita digitar un texto, seleccionar un color de texto,
un fondo de texto e imprimir dicho texto con el color y el fondo seleccionado.
8. Realizar un programa que permita cargar en un control RichTextBox un texto
cualquiera y cambiar de color todas las palabras que contengan la silaba PA.
9. Diseñar un programa que permita capturar 10 números. Se debe imprimir en un
control ListView el número capturado, si es par o impar, si está entre 1 y 300, es
mayor de 301 y menor de 1000, cuantos dígitos contiene dicho número y su raíz
cuadrada.
10. Escriba un programa que permita visualizar en un control TreeView la siguiente
estructura de árbol:
Equipos
Santafe
Barcelona
Inter
Milan
Aficiones
Acuaticas
Buceo
Natación
Profesiones
Ingenierias
Sistemas
Mecanica
Ciencias
Matematicas
Fisica
Mecánica
Electromagnetica
129
8. MENÚS EN FORMULARIOS
Los menús en una aplicación son el medio que tiene el usuario para interactuar con
dicha aplicación. Se pueden crear aplicaciones donde se utilice un menú que interactué
sobre un único formulario, este tipo de aplicaciones son llamadas SDI (Interfaz de
documento sencillo). Algunos programas que manejan esté estilo de interfaz son:
Wordpad, Bloc de notas, Calculadora de Microsoft Windows, etc. También se pueden
crear aplicaciones con menús que interactúen con varios formularios en una ventana,
estas aplicaciones son llamadas MDI (Interfaz de documentos múltiple), los ejemplos
clásicos son el procesador de texto Word ó la hoja de cálculo Excel de Microsoft. Las
aplicaciones MDI se reconocen por incluir menús con submenús para cambiar entre las
distintas ventanas o documentos. La interfaz de menús se trabaja con el control
MenuStrip que representa el contenedor de una estructura de menús de un
formulario conocidos como menús desplegables, además, se le pueden adicionar los
elementos: ToolStripMenuItem, ToolStripTextBox y ToolStripComboBox. El
objeto ToolStripMenuItem representan los comandos de menú individuales de la
estructura del menú. Cada objeto ToolStripMenuItem puede ser un comando de la
aplicación o un menú primario para otros elementos de submenú.
8.1 Creación de Menús con Interfaz de documento sencillo
Los menús y barras de herramientas proporcionan una forma estructurada y accesible

para que los usuarios aprovechen los comandos y las herramientas contenidas en sus
aplicaciones. La preparación y el diseño apropiados de menús y barras de herramientas
garantizarán la funcionalidad en la aplicación.
A menudo los usuarios examinan los menús antes de buscar información sobre
la aplicación en cualquier otro lugar. Si los menús están bien diseñados, los usuarios
podrán comprender la aplicación y desarrollar un modelo mental basado únicamente en
la organización de los menús y su contenido.
La creación de un sistema de menús implica varios pasos independientemente
del tamaño de la aplicación y la complejidad de los menús que pretenda usar, estos
deben ser:
 Preparar y diseñar el sistema: Decida los menús que necesita, dónde deben
aparecer en la interfaz, cuáles requieren submenús, etc.
 Crear los menús y submenús: Defina los títulos, elementos de menú y
submenús mediante el Diseñador de menús.
 Asignar las tareas que desee al sistema: Especifique las tareas que los menús
deben realizar, como mostrar formularios y cuadros de diálogo.
 Generar el programa de menú: Ejecutar el programa para probar el sistema
de menús.
8.1.1 Ejemplo práctico menús con interfaz de documento sencillo
Diseñar una aplicación llamada MenuInterfazSencilla, que permita crear un editor de

texto sencillo en un formulario con menús y submenús, donde el usuario puede abrir y
guardar un archivo de texto, salir de la aplicación, cortar, copiar y pegar texto, además,
pueda cambiar el tipo de fuente, el color del texto y el color de fondo del texto.
130

en el formulario: 1 MenuStrip, 1 RichTextBox, 1 ColorDialog, 1 FontDialog, 1
OpenFileDialog, 1 SavefileDialog.
NOTA: Al agregar los controles seleccione el objeto RichTextBox1 y dé clic sobre la

flecha que aparece al lado derecho superior del control para observar la ventana Tareas
de RichTextBox
Figura 8.1 Interfaz de usuario inicial de la aplicación MenuSencillo.
Allí dé clic sobre la opción Acoplar en contenedor principal para ajustar el

control al formulario. La interfaz de usuario inicial quedaría de la siguiente manera:
Figura 8.2 Interfaz de usuario inicial de la aplicación MenuInterfazSencilla.
131

Tabla 8.1 Propiedades de los controles de la aplicación MenuInterfazSencilla.

RichTextBox1 Name ventana
Colordialog1 Name cuadrodecolores
FontDialog1 Name cuadrodefuentes
OpenFileDialog1 Name cuadroabrirárchivo
SaveFileDialog1 Name cuadroguardarárchivo
MenuStrip1 Name menuprincipal
Text Interfaz de documento sencillo
Figura 8.3 Interfaz de usuario con las propiedades modificadas.
Pulse sobre el control menuprincipal para que aparezca sobre este el texto
Escriba aquí.
Figura 8.4 Objeto menuprincial seleccionado.
132
Allí escriba el nombre del menú &Archivo (Se utiliza el & para subrayar la
letra A y asociarlo a un método de acceso abreviado, más adelante se explicará cómo se
puede definir este tipo de acceso). Cuando empieza a escribir aparecen dos textos
Escriba aquí; uno a la derecha y el otro en la parte inferior.
Figura 8.5 Creación del menú Archivo.
Escriba en el texto inferior Nuevo y en el texto de la derecha Edición y

Formato. El menú tendría la siguiente forma:
Figura 8.6 Menú principal con los menús Archivo, Edición Formato y Nuevo.
Para completar el diseño del menú realice lo siguiente:
 Para el Menú Archivo adicione los submenús necesarios para obtener la siguiente
figura:
Figura 8.7 Menú Archivo con Submenús.
Para colocar la línea separadora, sitúese donde la desea crear y dé clic derecho,
seleccione la opción Insertar y allí escoja Separator, como se muestra en la siguiente
figura:
133
Figura 8.8 Operación para colocar una línea separadora en un Menú.
 Para el Menú Edición adicione los submenús necesarios para obtener la siguiente
figura:
Figura 8.9 Menú Edicion con Submenús.
 Para el Menú Formato adicione los submenús necesarios para obtener la siguiente
figura:
Figura 8.10 Menú Formato con Submenús.
134
 Crear teclas de acceso abreviado o rápido.
Como se dijo anteriormente es posible definir teclas de método abreviado a los

diferentes menús utilizando el teclado. Por ejemplo, sí se quisiera acceder más
rápidamente al menú Nuevo se podría pulsar la tecla Alt y a continuación la letra N.
Para asociar un método abreviado a las opciones del menú se debe anteponer a la letra
que se quiere utilizar como tecla de acceso abreviado el carácter ampersand (&). Para
añadir la tecla de acceso a la opción Nuevo, seleccione dicho menú y en las propiedades
del menú Nuevo busque la propiedad ShortCutKeys.
Figura 8.11 Propiedades del menú Nuevo.
Seleccione la flecha al frente de None, para visualizar la ventana de

modificadores de teclas.
Figura 8.12 Ventana de la propiedad ShortCutKeys.
135
Escoja en el cuadro de verificación Alt y en clave la letra N. La ventana
quedaría de la siguiente forma:
Figura 8.13 Selección tecla de acceso corta Alt +N.
Al dar clic el menú principal quedaría de la siguiente forma:
Figura 8.14 Menú Nuevo con tecla de acceso abreviada Alt+N.
NOTA: Puede crear todas las teclas de acceso abreviado que desee de la misma forma.
Debe tener en cuenta que no pueden definir dos o más teclas de acceso rápido iguales.
Después de completar el diseño del menú se debe seleccionar cada uno de los menús
para agregarle el respectivo código de acuerdo a la operación que va a realizar.
a) Seleccione el menú Nuevo, dé doble clic para abrir el editor del procedimiento
NuevoToolStripMenuItem_Click y escriba el siguiente código:
136
Dim pregunta As String
pregunta = MsgBox("Desea guardar el Archivo actual ?:", MsgBoxStyle.YesNo)
If pregunta = "6" Then
cuadroguardarárchivo.Title = "Cuadro de Diálogo para guardar un archivo"
cuadroguardarárchivo.InitialDirectory = "C:\"
cuadroguardarárchivo.Filter = "Archivo de Texto(*.txt)|*.txt"
cuadroguardarárchivo.ValidateNames = True
cuadroguardarárchivo.ShowDialog()
Dim guardarárchivo As IO.StreamWriter
guardarárchivo = New IO.StreamWriter(cuadroguardarárchivo.FileName)
guardarárchivo.Write(ventana.Text)
guardarárchivo.Close()
ventana.Text = ""
Else
ventana.Text = ""
End If
Se crea la variable pregunta de tipo String a la que se le asigna el valor

retornado por el cuadro de diálogo MsgBox (El primer parámetro es un mensaje para el
cuadro de diálogo; el segundo parámetro es una expresión numérica que especifica el
número y los botones que se van a mostrar). Si desea guardar el archivo actual (Si) se
almacenará en la variable pregunta el valor 6, en caso contrario, se almacenará el valor
7. Si en dicho cuadro se pulsa el botón Sí, se modifican las siguientes propiedades del
control SaveFileDialog cuadroguardarárchivo: Title el cual permite colocarle un
titulo al cuadro de diálogo; InitialDirectory selecciona la carpeta inicial que se
visualizará en el cuadro de diálogo; Filter permite seleccionar los tipos de archivos que
se quieren visualizar; en este caso mostrará los archivos con extensión .txt;
ValidateNames validará que el nombre del archivo sea válido; ShowDialog() el cual
permitirá abrir el cuadro de diálogo del control cuadroguardarárchivo en tiempo de
ejecución. Por otro lado, se crea la variable guardarárchivo de tipo StreamWriter
(clase que se utiliza para escribir información a un archivo de texto estándar) que
guardará el nombre del archivo de texto asignado a la propiedad FileName del control
cuadroguardarárchivo. Utilizando el método Write se guarda el contenido del control
ventana en su propiedad Text. Por último, se cierra el archivo por intermedio del
método close () y se limpia el objeto ventana. En caso contrario únicamente se limpia
el objeto ventana.
b) Seleccione el menú Abrir..., dé doble clic para abrir el editor del procedimiento
y escriba el siguiente código:
ventana.Text = " "

cuadroabrirárchivo.Title = "Seleccione el archivo a abrir..."
cuadroabrirárchivo.InitialDirectory = "C:\"
cuadroabrirárchivo.Filter = "Archivo de Texto(*.txt)|*.txt"
cuadroabrirárchivo.ShowDialog()
If cuadroabrirárchivo.FileName.Length > 1 Then
Dim verarchivo As New IO.StreamReader(cuadroabrirárchivo.FileName)
ventana.Text = verarchivo.ReadToEnd
Else
MsgBox("Archivo no contiene información")
End If
Por medio de la función Length de la propiedad FileName del control

OpenFileDialog cuadroabrirárchivo se determina si el archivo contiene información o
no. Si contiene información se crea una variable llamada verarchivo de tipo
137
IO.StreamReader (clase que se utiliza para leer líneas de información desde un archivo
de texto estándar) que guardará el nombre del archivo de texto asignado a la propiedad
FileName del control cuadroabrirárchivo. A la propiedad Text del objeto ventana se
le asignará el contenido del archivo utilizando el método ReadtoEnd que lee el archivo
desde el principio hasta el final. Si por el contrario no contiene información se mostrará
un mensaje informando que el archivo seleccionado esta vació.
c) Seleccione el menú Guardar, dé doble clic para abrir el editor del

procedimiento y escriba el siguiente código:
If cuadroguardarárchivo.FileName.Length > 0 Then

ventana.SaveFile(cuadroguardarárchivo.FileName,RichTextBoxStreamType.PlainText)
Else
End If
Por medio de la función Length de la propiedad FileName del control

SaveFileDialog cuadroguardarárchivo se determina si el nombre del archivo es mayor
de cero (0), es decir, que ya se había guardado. Si la condición se cumple se guardará el
archivo con el nombre actual utilizando la propiedad SaveFile que recibe como
parámetros: el nombre del archivo actual y el tipo de archivo de texto. En caso
contrario, se realizará el proceso de guardar el archivo por primera vez. Se crea una
variable llamada guardarárchivo de tipo IO.StreamWriter (clase que se utiliza para
escribir líneas de información en un archivo de texto estándar) que guardará el nombre
del archivo de texto asignado a la propiedad FileName del control guardarárchivo.
Utilizando el método Write se escribe en el archivo todo el contenido existente en la
propiedad Text del objeto ventana.
d) Seleccione el menú Guardar como.., dé doble clic para abrir el editor del

Esta opción permitirá guardar un archivo que previamente se había guardado con
un nuevo nombre. Se realiza el mismo proceso utilizado por la estructura Else del menú
Guardar.
138
e) Seleccione el menú Salir, dé doble clic para abrir el editor del procedimiento y
End
La palabra clave End permitirá salir de la aplicación.
f) Seleccione el menú Deshacer, dé doble clic para abrir el editor del

ventana.Undo()
Se utiliza la función Undo del control RichTextBox ventana para deshacer una
operación realizada anteriormente.
g) Seleccione el menú Rehacer, dé doble clic para abrir el editor del procedimiento
If ventana.CanRedo = True Then
If ventana.RedoActionName <> "Delete" Then
ventana.Redo()
End If
End If
Se utiliza la función Redo del control RichTextBox ventana, para rehacer una
operación previamente se habia eliminado. En este caso se valida si anteriormente se
habia eliminado un texto (CanRedo) y si esa operación tenia el nombre de eliminar
(Delete) utilizando la función RedoActionName.
h) Seleccione el menú Cortar, dé doble clic para abrir el editor del procedimiento
ventana.Cut()
Se utiliza la función Cut del control RichTextBox ventana para eliminar un

texto seleccionado.
i) Seleccione el menú Pegar, dé doble clic para abrir el editor del procedimiento y
ventana.Paste()
Se utiliza la función Paste del control RichTextBox ventana para mostrar un

texto que previamente habia sido copiado o cortado.
j) Seleccione el menú Copiar, dé doble clic para abrir el editor del procedimiento
ventana.Copy()
Se utiliza la función Copy del control RichTextBox ventana para copiar un

texto que previamente ha sido seleccionado.
139
k) Seleccione el menú Borrar, dé doble clic para abrir el editor del procedimiento
ventana.Clear()
Se utiliza la función Clear del control RichTextBox ventana para borrar todo el
contenido de la propieda Text del control ventana.
m) Seleccione el menú Seleccionar todo, dé doble clic para abrir el editor del
ventana.SelectAll()
Se utiliza la función SelectAll del control RichTextBox ventana para

seleccionar todo el contenido de la propieda Text del control ventana.
n) Seleccione el menú Fuente, dé doble clic para abrir el editor del procedimiento
cuadrodefuentes.ShowDialog()
ventana.SelectionFont = cuadrodefuentes.Font
Se utiliza el método ShowDialog () para abrir el cuadro de diálogo del control

FontDialog cuadrodefuentes en tiempo de ejecución. En la segunda línea se le asigna a
la propiedad SelectionFont del objeto ventana la fuente seleccionada por intermedio de
la propiedad Font del objeto cuadrodefuentes.
o) Seleccione el menú Color - Texto, dé doble clic para abrir el editor del
cuadrodecolores.ShowDialog()
ventana.SelectionColor = cuadrodecolores.Color

FontDialog cuadrodecolores en tiempo de ejecución. En la segunda línea se le asigna a
la propiedad SelectionColor del objeto ventana el color del texto seleccionado por
intermedio de la propiedad Color del objeto cuadrodecolores.
p) Seleccione el menú Color - Fondo, dé doble clic para abrir el editor del
cuadrodecolores.ShowDialog()
ventana.SelectionBackColor = cuadrodecolores.Color

FontDialog cuadrodecolores en tiempo de ejecución. En la segunda línea se le asigna a
la propiedad SelectionBackColor del objeto ventana el color de fondo del texto
seleccionado por intermedio de la propiedad Color del objeto cuadrodecolores.
q) Seleccione el menú Estilo viñetas, dé doble clic para abrir el editor del
140
ventana.SelectionBullet = True
La función SelectionBullet del control RichTextBox ventana establece un valor

(True, False) para permitir o no aplicar un estilo de viñeta en una selección de texto o
en la inserción de nuevo texto.
 Ejecutar el formulario
Cuando se ejecuta el proyecto en el entorno de desarrollo de Visual Basic.NET y se

escribe el texto Texto de Prueba y se selecciona la palabra Prueba y con el menú
Formato se cambia el color de texto, además se selecciona el texto Texto y se le
cambia el color de fondo y también se escoge la opción Estilo viñetas y se escribe
texto, se podría obtener una figura similar a la siguiente:
Figura 8.15 Ejecución aplicación MenuInterfazSencilla.
En este momento se puede escoger cualquier opción del menú y realizar la

operación seleccionada.
8.2 Creación de Menús con interfaz múltiple
Una aplicación de interfaz múltiple se compone de un formulario principal, denominado

formulario MDI, que actuará como contenedor de otros formularios abiertos en el
transcurso del programa denominados formularios hijos o secundarios MDI.
8.2.1 Ejemplo práctico formularios MDI
Realizar una aplicación llamada MenuInterfazMultiple que contenga un formulario

MDI que permita a un usuario abrir varios formularios cuantas veces quiera, El menú
principal deberá tener las opciones: Nuevo, Guardar, Abrir, Cerrar, Salir, Copiar,
Cortar, Pegar, visualizar los formularios creados, mosaico horizontal, mosaico vertical,
141
cascada, minimizar.
Para crear la interfaz de usuario se utilizarán cinco formularios. Uno de ellos será el
formulario principal o contenedor de los otros cuatro formularios los cuales realizarán
una labor específica cada uno.
 Creación del primer Formulario
Este formulario será el formulario contenedor de los demás formularios. Agréguele un

control MenuStrip y modifique las siguientes propiedades al control respectivo:
Tabla 8.2 Propiedades de los controles del formulario principal MDI.

MenuStrip1 Name menuprincipal
Form1 Name formularioprincipal
IsMdiContainer True (cambia el color del formulario a un gris
oscuro. Permite convertir este formulario es un
contendor de formularios MDI).
WindowState Maximized
Text Interfaz de documentos Múltiple.
Seleccione el control MenuStrip menuprincipal y cree los siguientes menús de

nivel superior: Archivo, Edicion, Mis Formularios, Ventana. Se obtendría una figura
similar a la siguiente:
Figura 8.16 Interfaz de usuario inicial del formulario principal.
Para completar el diseño del menú realice lo siguiente:
142
 Para el Menú Archivo adicione los submenús para obtener la siguiente figura:
Figura 8.17 Menú Archivo con Submenús.
 Para el Menú Edicion adicione los submenús para obtener la siguiente figura:
Figura 8.18 Menú Edicion con Submenús.
 Para el Menú Mis Formularios adicione los submenús para obtener la siguiente
figura:
Figura 8.19 Menú Mis Formularios con Submenús.
143
 Para el Menú Ventana adicione los submenús para obtener la siguiente figura:
Figura 8.20 Menú Ventana con Submenús.
Creación del segundo Formulario
Para crear el segundo formulario y que quede dentro de la aplicación

MenuInterfazMultiple, realice los siguientes pasos:
1. En el menú Proyecto, seleccione Agregar Windows Forms, se visualizará el

siguiente cuadro de diálogo:
Figura 8.21 Agregar un segundo formulario a la aplicación.
2. En el cuadro Nombre, cambie el nombre del formulario por formulariofecha y

a continuación haga clic en Agregar para visualizar el segundo formulario en el
entorno de desarrollo.
En este formulario seleccione los siguientes controles: 2 Label, 1 TextBox y 1

DateTimePicker (control que permite a un usuario seleccionar una fecha de un
calendario) y modifique las siguientes propiedades al control respectivo:
144
Tabla 8.3 Propiedades de los controles del segundo formulario.

Name lblfecha
Label1 Text Seleccione una nueva fecha
Font - Bold True
Name lblformato
Label2 Text La fecha en formato númerico
Font - Bold True
DateTimePicket1 Name controlfecha
TextBox1 Name txtformato
Form1 Name formulariofecha
Text Control DateTimePicker
Figura 8.22 Interfaz de usuario segundo formulario.
Seleccione el objeto controlfecha, dé doble clic para abrir el editor del procedimiento
controlfecha_ValueChanged y escriba el siguiente código:
txtformato.Text = controlfecha.Value
El código anterior permite visualizar en la propiedad Text del control

txtformato la fecha y la hora en formato númerico cuando un usuario escoge una fecha
del objeto DateTimePicker controlfecha.
Creación del tercer Formulario
Para crear el tercer formulario y que quede dentro de la aplicación

MenuInterfazMultiple, se deben realizar los mismos pasos que se realizaron para
agregar el segundo formulario. En el cuadro Nombre del nuevo formulario cambie el
nombre por formulariomeses.

MonthCalendar (control que permite a un usuario seleccionar una fecha de un
calendario) y modifique las siguientes propiedades al control respectivo:
145
Tabla 8.4 Propiedades de los controles del tercer formulario.

Name lblfecha
Label1 Text Fecha seleccionada numérica:
Font - Bold True
MontCalendar1 Name controlcalendario
TextBox1 Name txtformato
Form1 Name formulariomeses
Text Control MonthCalendar
Figura 8.23 Interfaz de usuario tercer formulario.
controlcalendario_DateChanged y escriba el siguiente código:
txtfecha.Text = controlcalendario.SelectionEnd.Date
Se le asigna a la propiedad Text del control txtfecha la última fecha

seleccionada del objeto MonthCalendar controlcalendario en formato númerico por
intermedio de la propiedad SelectionEnd.Date.
Creación del cuarto Formulario
Para crear el cuarto formulario y que quede dentro de la aplicación

nombre por formulariolenguaje.
CheckedListBox (control que permite a un usuario seleccionar una o varias alternativas
de una lista) y modifique las siguientes propiedades al control respectivo:
146
Tabla 8.5 Propiedades de los controles del cuarto formulario.

Text Traductor Animales Español - Ingles
Font - Bold True
Label2 Name lblespañol
Text Español
Font - Bold True
Label3 Name lblingles
Text Ingles
Font - Bold True
TextBox1 Name txtvaca
TextBox2 Name txtabeja
TextBox3 Name txtoso
TextBox4 Name txtpajaro
TextBox5 Name txtperro
TextBox6 Name txtgato
CheckedListBox1 Name listaespañol
CheckOnClick True
Font -Bold True
Form1 Name formulariolenguaje
Text Traductor Animales Español - Ingles
Figura 8.24 Interfaz de usuario cuarto formulario.
listaespañol_SelectedIndexChanged y escriba el siguiente código:
147
If listaespañol.GetItemChecked(0) Then
txtvaca.Text = "COW"
Else
txtvaca.Text = ""
End If
txtabeja.Text = "BEE"
Else
txtabeja.Text = ""
End If
txtoso.Text = "BEAR"
Else
txtoso.Text = ""
End If
txtpajaro.Text = "BIRD"
Else
txtpajaro.Text = ""
End If
txtperro.Text = "CAN"
Else
txtperro.Text = ""
End If
txtgato.Text = "CAT"
Else
txtgato.Text = ""
End If
Utilizando la propiedad GetItemChecked(índice) del objeto CheckedListBox

listaespañol se valida que cuadro de verificación se ha seleccionado o deseleccionado,
con el fin de asignar a la propiedad Text de cada campo de texto el valor
correspondiente.
Creación del quinto Formulario
Para crear el quinto formulario y que quede dentro de la aplicación

nombre por formularioventana. A este formulario adicione un control RichTextBox.
NOTA: Seleccione el objeto RichTextBox1 y dé clic sobre la flecha que aparece al

lado derecho superior del control para observar la ventana Tareas de RichTextBox, allí
dé clic sobre la opción Acoplar en contenedor principal para ajustar el control al
formulario. Modifique las siguientes propiedades al control respectivo:
Tabla 8.6 Propiedades de los controles del quinto formulario.

RichTextBox1 Name ventana
Form1 Name formularioventana
Text Editor de texto básico
148
Figura 8.25 Interfaz de usuario quinto formulario.
En este momento en el explorador de soluciones se observaría una figura

similar a la siguiente:
Figura 8.26 Explorador de soluciones con los formularios.
 Escribir código para los Menús
Antes de escribir el código para cada una de las opciones del menú, arrastre los objetos
OpenFileDialog y SaveFileDialog y cambie la propiedad Name de dichos objetos por
cuadroabrirárchivo y cuadroguardarárchivo respectivamente. Estos dos controles
servirán para realizar los procesos de apertura y guardado de un archivo de texto.
a) Seleccione el menú Nuevo, dé doble clic para abrir el editor del procedimiento
NuevoToolStripMenuItem_Click y escriba el siguiente código:
Dim nuevoformulario As New formularioventana

nuevoformulario.MdiParent = Me
nuevoformulario.Show()
149
En la primera línea se crea un formulario llamado nuevoformulario al cual se le
asigna espacio de memoria de tipo formularioventana, en la segunda línea se asigna a
la propiedad MdiParent del objeto nuevoformulario la instancia actual del formulario
en ejecución (Me) y por último por medio del método Show () se muestra el formulario.
b) Seleccione el menú Abrir…, dé doble clic para abrir el editor del procedimiento
AbrirToolStripMenuItem_Click y escriba el siguiente código:
Dim formularioactivo As Form = Me.ActiveMdiChild

Dim nuevaventana As RichTextBox = CType(formularioactivo.ActiveControl,
RichTextBox)
nuevaventana.Text = " "
cuadroabrirárchivo.Title = "Seleccione el archivo a abrir..."
cuadroabrirárchivo.InitialDirectory = "C:\"
cuadroabrirárchivo.Filter = "Archivo de Texto(*.txt)|*.txt"
cuadroabrirárchivo.ShowDialog()
If cuadroabrirárchivo.FileName.Length > 1 Then
Dim verarchivo As New IO.StreamReader(cuadroabrirárchivo.FileName)
nuevaventana.Text = verarchivo.ReadToEnd
Else
MsgBox("Archivo no contiene información")
End If
Dado que una aplicación MDI puede tener muchas instancias del mismo
formulario secundario, se necesita especificar el formulario activo. Con la propiedad
ActiveMdiChild, se puede obtener el formulario secundario que tiene el foco o que
está activo. Además cuando se tienen varios controles en un formulario se debe
especificar el control que está activo, esto se puede realizar con la propiedad
ActiveControl que establece el control que está activo en el formulario secundario
Se crea un objeto llamado nuevoformulario de tipo Form al cual se le asigna el

formulario activo, por otro lado, se crea una variable llamada nuevaventana de tipo
RichTextBox a la cual se le asignará el control activo del formulario secundario. Se
utilizo la función CType para devolver el resultado de convertir explícitamente una
expresión a un tipo de dato, objeto, estructura o clase. A la propiedad Text del objeto
nuevaventana se le asignará el contenido del archivo utilizando el método ReadtoEnd
que lee el archivo desde el principio hasta el final.
c) Seleccione el menú Guardar, dé doble clic para abrir el editor del

procedimiento GuardarToolStripMenuItem_Click y escriba el siguiente
código:

RichTextBox)
guardarárchivo.Write(nuevaventana.Text)
150
Se crea una variable llamada guardarárchivo de tipo IO.StreamWriter (clase
que se utiliza para escribir líneas de información en un archivo de texto estándar) que
guardará el nombre del archivo de texto asignado a la propiedad FileName del control
guardarárchivo. Utilizando el método Write se escribe en el archivo todo el contenido
existente en la propiedad Text del objeto nuevaventana.
Nota: el menú Guardar como… no se describe, se espera que el usuario realice el

código correspondiente.
d) Seleccione el menú Cerrar, dé doble clic para abrir el editor del procedimiento
Dim cerrarformulario As Form = CType(Me.ActiveMdiChild, Form)
If Not cerrarformulario Is Nothing Then
cerrarformulario.Close()
End If
Se crea un objeto llamado cerrarformulario de tipo Form al cual se le asigna el

formulario activo. Se pregunta si el objeto cerrarformulario no es vacio. Si se cumple
la condición se utiliza la función Close() para cerrar el formulario activo.
e) Seleccione el menú Salir, dé doble clic para abrir el editor del procedimiento y
End
f) Seleccione el menú Deshacer, dé doble clic para abrir el editor del


RichTextBox)
nuevaventana.Undo()
g) Seleccione el menú Rehacer, dé doble clic para abrir el editor del procedimiento

RichTextBox)
nuevaventana.Redo()
h) Seleccione el menú Cortar, dé doble clic para abrir el editor del procedimiento
Dim activeChild As Form = Me.ActiveMdiChild

Dim nuevaventana As RichTextBox = CType(activeChild.ActiveControl, RichTextBox)
nuevaventana.Cut()
i) Seleccione el menú Pegar, dé doble clic para abrir el editor del procedimiento y

151
nuevaventana.Paste()
j) Seleccione el menú Copiar, dé doble clic para abrir el editor del procedimiento

nuevaventana.Copy()
OBSERVACIÓN: Las opciones deshacer, rehacer, cortar, pegar, copiar funcionan

únicamente con el objeto formularioventana.
k) Seleccione el menú Formulario Fecha, dé doble clic para abrir el editor del
Dim formularios As New formulariofecha

formularios.MdiParent = Me
formularios.Show()
m) Seleccione el menú Formulario Meses, dé doble clic para abrir el editor del
Dim formularios As New formulariomeses

formularios.Show()
n) Seleccione el menú Formulario Lenguaje, dé doble clic para abrir el editor del
Dim formularios As New formulariolenguaje

formularios.Show()
 Ejecutar la aplicación MenuInterfazMultiple
Cuando se ejecuta el proyecto en el entorno de desarrollo se visualiza la siguiente

figura:
Figura 8.27 Ejecución de la aplicación MenuInterfazMultiple.
152
Si se pulsa la opción Nuevo del menú Archivo dos veces y se escogen las
opciones Formulario Fecha, Formulario Meses y Formulario Lenguaje, se obtendría
una figura similar a la siguiente:
Figura 8.28 Menú principal con tres formularios abiertos.
8.3 Menú Ventana
En el menú Ventana se añadieron unas opciones que permiten la organización de los

formularios en: cascada, mosaico horizontal y mosaico vertical. Para organizar los
formularios abiertos se debe ejecutar el método LayoutMdi () pasándole como
argumento la opción deseada. También se creó una opción para minimizar los
formularios. Antes de poder realizar operaciones con este menú, seleccione el objeto
menuprincipal y en la propiedad MdiWindwListItems escoja la opción
VentanaToolStripMenuItem.
Figura 8.29 Propiedad MdiWindowListItem modificada.
153
Y programe las opciones del menú Ventana.
a) Seleccione el menú Mosaico Horizontal, dé doble clic para abrir el editor del
Me.LayoutMdi(MdiLayout.TileHorizontal)
b) Seleccione el menú Mosaico Vertical, dé doble clic para abrir el editor del
Me.LayoutMdi(MdiLayout.TileVertical)
c) Seleccione el menú Cascada, dé doble clic para abrir el editor del procedimiento
Me.LayoutMdi(MdiLayout.Cascade)
d) Seleccione el menú Minimizar, dé doble clic para abrir el editor del

For i As Integer = 0 To Me.MdiChildren.Length - 1

Me.MdiChildren(i).WindowState = FormWindowState.Minimized
Next
Se crea un ciclo For donde se inicializa una variable de tipo Integer llamada i
en cero (0) que se ejecutar hasta el total (Length-1) de formularios secundarios abiertos
(MdiChildren) y a la propiedad WindowState de cada formulario abierto se le
asignará la función de minimizar (Minimized).
Continuando con el ejemplo anterior, al seleccionar la opción Mosaico

Horizontal se visualizaría la siguiente figura:
Figura 8.30 Opción Mosaico Horizontal seleccionada.
154
Con la opción Mosaico Vertical se visualizaría la siguiente figura:
Figura 8.31 Opción Mosaico Vertical seleccionada.
Con la opción Cascada se visualizaría la siguiente figura:
Figura 8.32 Opción Cascada seleccionada.
155
8.4 Desactivar las opciones del menú en formularios MDI
En la aplicación que se ha trabajado se puede abrir tantas copias de los formularios

seleccionado como se necesiten. Para conseguir que de un determinado formulario se
pueda abrir una sola instancia, se debe deshabilitar la opción del menú cuando se abre
un formulario especifico, asignándole False a la propiedad Enabled. Entonces para que
se cree una sola instancia del formulario formulariofecha seleccione la opción
Formulario Fecha del menuprincipal y adicione el siguiente código:
Me.FormularioFechaToolStripMenuItem.Enabled = False
En segundo lugar seleccione el formulario formulariofecha dé doble clic sobre

este y en la ventana superior derecha seleccione el evento FormClosed y escriba el
siguiente código:
CType(MdiParent,formularioprincipal).FormularioFechaToolStripMenuItem.Enabled=True
Al ejecutar nuevamente la aplicación MenuInterfazMultiple y seleccionar la

opción Formulario Fecha, se podrá apreciar que esta queda deshabilitada. Se volverá a
Habilitar al cerrar el formulario.
Figura 8.33 Desactivación del menú Formulario Fecha.
8.5 Creación de una barra de herramientas en una aplicación MDI
Siguiendo con el ejemplo que se ha venido trabajando, también es posible añadirle una
barra o más barras de herramientas como se maneja en el entorno Windows, con el fin
de realizar de forma más rápida algunas tareas, como por ejemplo: copiar, pegar, cortar,
guardar, etc. Para añadir una barra de herramientas se utiliza el control ToolStrip .
Agregue dicho control a la aplicación MenuInterfazMultiple y cámbiele el texto de la
propiedad Name por barradeherramientas, se visualizará la siguiente figura:
156
Figura 8.34 Aplicación MenuInterfazMultiple con una barra de herramientas.
Cuando se selecciona la ventana que aparece en la barra de herramientas se

puede agregar los siguientes elementos a la barra: Button, Label, SplitButton,
DropDownButton, Separator, ComboBox, TextBox, ProgressBar.
Figura 8.35 Elementos de la barra de herramientas.
Seleccione el elemento Button y adiciónelo cuatro veces. La figura que se

visualiza es la siguiente:
Figura 8.36 Elementos Button adicionado a la barra de herramientas.
157
Seleccione cada uno de los elementos Button y modifíquele las siguientes
propiedades:
Tabla 8.7 Propiedades de elementos Button de la barra de herramientas.

ToolStripButton1 Name botonnuevo
Text Nuevo
Image Imagen de nueva ventana
ToolStripButton2 Name botoncortar
Text Cortar
Image Imagen de opción cortar
ToolStripButton3 Name botonpegar
Text Pegar
Image Imagen de opción pegar
ToolStripButton4 Name botoncopiar
Text Copiar
Image Imagen de opción copiar
La barra de herramientas con las modificaciones realizadas se podría apreciar de

la siguiente forma:
Figura 8.37 Elementos modificados de barra de herramientas.
 Escribir código para cada elemento Button
a) Dé doble clic sobre el Button botonnuevo y escriba el siguiente código:
Dim nuevoformulario As New formularioventana

nuevoformulario.MdiParent = Me
nuevoformulario.Show()
b) Dé doble clic sobre el Button botoncortar y escriba el siguiente código:

nuevaventana.Cut()
c) Dé doble clic sobre el Button botonpegar y escriba el siguiente código:

nuevaventana.Paste()
d) Dé doble clic sobre el Button botoncopiar y escriba el siguiente código:
158
nuevaventana.Copy()
Al ejecutar nuevamente la aplicación MenuInterfazMultiple y pulsar el botón

Nuevo se visualizará la siguiente figura:
Figura 8.38 Aplicación MenuInterfazMultiple cuando se pulsa el botón Nuevo.
8.6 Crear un menú contextual
Dentro de las aplicaciones Windows Forms también es posible agregarle menús

contextuales. Dichos menús se activan con el botón derecho del mouse y pueden
ejecutar una operación o proceso que se le asigne. Para añadir un menú contextual a una
aplicación se utiliza el control ContextMenuStrip .
Continuando con el ejercicio que se ha venido trabajando agréguele a dicho

control a la aplicación MenuInterfazMultiple y cámbiele el texto de la propiedad
Name por menucontextual, se visualizará la siguiente figura:
Figura 8.39 Menú contextual agregado a la aplicación MenuInterfazMultiple.
159
En el texto Escriba aquí adicione las opciones que desea tenga el menú
contextual. Para el ejemplo, escriba las siguientes opciones: Nuevo, Cortar, Pegar,
Copiar.
Figura 8.40 Menú contextual con las opciones agregadas.
Además si desea agregarle imágenes a cada opción en el espacio delimitado con

color azul, sitúese en la opción desea y de clic derecho del mouse para ver la ventana
con la opción Establecer imagen…:
Figura 8.41 Ventana para establecer una imagen a una opción.
Escoja dicha opción y al agregarle a cada una de las opciones la imagen

correspondiente. Se obtendría una figura similar a la siguiente:
Figura 8.42 Menú contextual con imágenes por cada opción.
160
Antes de poder realizar operaciones con este menú, seleccione el objeto
menuprincipal y en la propiedad ContextMenuStrip adicione el control
menucontextual.
Figura 8.43 Propiedad ContextMenuStrip del objeto menuprincipal modificada.
Dé doble clic sobre cada opción del menú contextual para programar cada
operación. El código es el mismo que se utilizo en el menú principal o en la barra de
herramientas para dichas opciones.
161
9. GRÁFICOS Y ANIMACIÓN
En Microsoft Visual Basic .NET se pueden dibujar diferentes tipos de gráficos como
líneas, rectángulos, óvalos, cuadros, elipses con relleno o sin él. Además se pueden
crear efectos especiales con una secuencia de imágenes o gráficas para dar la sensación
de movimiento. En este capítulo conocerá los tipos de gráficos de Visual Basic .NET,
como también aprenderá a mover los controles o imágenes en forma horizontal, vertical
o diagonal utilizando las propiedades Left y Top, expandir o contraer los controles o las
imágenes manipulando las propiedades Height y Width. Por otro lado, también
conocerá como crear efectos de animación sencillos utilizando los controles
PictureBox, Timer o ImageList.
9.1 El espacio de nombres System.Drawing
Un formulario es como un mantel el cual tiene unas dimensiones las cuales se miden en
pequeños puntos llamados pixeles. Con un sistema de coordenadas se define donde se
coloca cada pixel. Con la coordenada X se mide de izquierda a derecha y con la
coordenada Y se mide de arriba a abajo. Las coordenadas se inician en la esquina
superior izquierda del formulario (x=0, y=0). Los píxeles también se utilizan para
expresar el ancho y el alto de los gráficos. Para definir un cuadrado que tiene 100
píxeles de ancho y 100 píxeles de alto, cuya esquina superior izquierda se encuentra 10
píxeles a la izquierda y 10 píxeles hacia abajo, se expresará en coordenadas como 10,
10, 100, 100.
El espacio de nombres System.Drawing contiene numerosas clases con las que
se pueden crear dibujos en un programa. Las gráficas se pueden crear vacías (prefijo
draw) o con relleno de color (prefijo fill). Para dibujar o utilizar una función gráfica es
necesario crear un objeto Graphics y un objeto Pen (argumento cuando no se rellena
con ningún color) o Brush (cuando se quiere tener un color de relleno). El objeto
Graphics representa una superficie de dibujo y es el objeto que se usa para crear
imágenes gráficas. El objeto Graphics se puede crear en el evento Paint de un
formulario o control, también, llamando al método CreateGraphics, además se pueden
crear objetos Font y Color.
Los objetos Graphics se declaran antes de dibujar.
Dim graficador As Graphics

‘Aquí va el código de la figura a dibujarse
Para crear un objeto Graphics con el método CreateGraphics.

graficador=Me.CreateGraphics
‘Aquí va el código de la figura a dibujarse
Para crear un objeto Graphics a partir de un objeto Image

Dim dibujo As New BitMap ("Midibujo.bmp")
Dim graficador As Graphics = Graphics.FromImage (dibujo)
Se llama al método Graphics.FromImage al cual se le asigna el objeto Image

dibujo de tipo BitMap a partir de la cual se desea crear un objeto Graphics.
162
Crear los objetos Pen para dibujar segmentos de línea, curvas y los contornos de
formas.
Dim lapiz As System.Drawing.Pen
lapiz = New System.Drawing.Pen (System.Drawing.Color.Red)
En la siguiente tabla se muestran algunas de las figuras geométricas de Visual

Basic .NET:
Tabla 9.1 Figuras geométricas de .NET.
Figura Método Descripción

Punto (estructura) Point Representa un par ordenado de coordenadas
x e y de enteros que define un punto en un
plano bidimensional.
Rectangulo (estructura) Rectangle Almacena un conjunto de cuatro enteros que
representan la posición y tamaño de un
rectángulo.
Recta DrawLine Dibuja una línea que conecta los dos puntos
especificados por los pares de coordenadas
Rectangulo DrawRectangle, Dibuja un rectángulo especificado por un par
FillRectangle de coordenadas, un valor de ancho y un valor
de alto.
Circulo / Elipse DrawEllipse, Dibuja una elipse definida por un rectángulo
FillEllipse delimitador especificado por un par de
coordenadas, un valor de alto y un valor de
ancho.
Curva DrawCurve Dibuja una curva a través de una matriz
especificada por la estructura Point.
Arco DrawArc Dibuja un arco especificado por un par de
coordenadas, un valor de ancho y un valor de
alto.
Poligono DrawPolygon, Dibuja un polígono definido por una matriz
FillPolygon especificada por la estructura Point.
Pie DrawPie, FillPie Dibuja una forma circular definida por una
elipse determinada por un par de coordenadas,
unos valores de ancho y alto y dos líneas
radiales.
9.1.1 Ejemplos prácticos de gráficos
1) Escribir una aplicación llamada CrearGraficas que permita a un usuario

graficar una línea desde el evento Paint de un formulario, utilizando control
Button y un control PictureBox.
Utilizando el cuadro de herramientas adicione al formulario los siguientes controles: 1

Label, 2 Button y 1 PictureBox.

163
Tabla 9.2 Propiedades de los controles de la aplicación CrearGraficas.

Name lbltexto
Label1 Text Evento Paint
Button1 Name botonlinea
Text Línea con un Botón
Button2 Name botonpicturebox
Text Línea con un PictureBox
PictureBox1 Name pintura
BorderStyle Fixed3D
Text Crear una Línea
Figura 9.1 Interfaz de usuario CrearGraficas.
a) Dé doble clic sobre el formulario y en la ventana superior derecha seleccione el

evento formulario_Paint y escriba el siguiente código:
Dim lapiz As Pen
lapiz = Pens.Blue
graficador = Me.CreateGraphics
graficador.DrawLine(lapiz, 30, 30, 70, 120)
Se define una variable lapiz de tipo Pen, a dicha variable se le asigna el color
azul (Pens.Blue). Por otro lado, se crea un objeto Graphics llamado graficador al cual
se le asigna el método CreateGraphics. La función DrawLine permite dibujar una
línea, dicho método contiene cinco parámetros: el primero es el color de la línea, el
segundo es la coordenada X inicial, el tercero es la coordenada Y inicial, el cuarto es la
coordenada X final y el quinto es la coordenada Y final.
b) Seleccione el objeto botonlinea, dé doble clic para abrir el editor del

procedimiento botonlinea_Click y escriba el siguiente código:
164
Dim lapiz As New Pen(Color.FromArgb(255, 0, 255, 0), 4)
graficador = Me.CreateGraphics
graficador.DrawLine(lapiz, 100, 30, 170, 150)
Se define una variable lapiz a la cual se le asigna espacio de memoria de tipo

Pen. Al objeto Pen se le asigna un color y el ancho del color. El método FromArgb de
la clase Color recibe cuatro parámetros: la transparencia (255), el color rojo (0), el color
verde (255), el color azul (0). El quinto parámetro del objeto Pen es el ancho del color
del lápiz.
c) Seleccione el objeto botonpicturebox, dé doble clic para abrir el editor del

procedimiento botonpicture_Click y escriba el siguiente código:
pintura.CreateGraphics.DrawLine(Pens.Chocolate, 10, 10, 50, 100)
El método CreateGraphics del objeto pintura sirve para crear gráficas. A la

función DrawLine se le asigna directamente el color chocolate de la clase Pens y los
parámetros Xi, Yi, Xf, Yf.
Al ejecutar el proyecto se visualizará automáticamente la línea que se creó en el método

Paint del formulario. Al pulsarse los botones Línea con un Botón y Línea en un
Picture Box, se obtendrá la siguiente figura:
Figura 9.2. Ejecución aplicación CrearGraficas.
2) Realizar una aplicación llamada FuncionesGraficas que permita a un usuario

graficar: líneas, rectángulos, cuadros, óvalos, círculos, curvas.

MenuStrip y 1 PictureBox.
165

Tabla 9.3 Propiedades de los controles de la aplicación FuncionesGraficas.

MenuStrip1 Name menugraficas
PictureBox1 Name grafica
BorderStyle FixedSingle
Text Funciones Gráficas Visual Basic .NET
Figura 9.3 Interfaz de usuario FuncionesGraficas.
 Para el menú Líneas adicione los submenús para obtener la siguiente figura:
Figura 9.4 Menú Líneas con Submenús.
 Para el menú Rectangulo/Cuadro adicione los submenús para obtener la siguiente

figura:
166
Figura 9.5 Menú Rectangulo/Cuadro con Submenús.
 Para el menú Elipses/Circulo adicione los submenús para obtener la siguiente

figura:
Figura 9.6 Menú Elipses/Circulo con Submenús.
 Para el menú Curvas adicione los submenús para obtener la siguiente figura:
Figura 9.7 Menú Curvas con Submenús.
167
a) Seleccione el menú Línea Normal, dé doble clic para abrir el editor del
grafica.CreateGraphics.Clear(Me.BackColor)
grafica.CreateGraphics.DrawLine(Pens.Red, 10, 10, 220, 80)
Se utiliza el metodo Clear() para limpiar el objeto grafica. Recibe como

parametro el color de fondo actual (Me.BackColor).
b) Seleccione el menú Línea con extremos, dé doble clic para abrir el editor del
Dim lapiz As New Pen(Color.Blue, 6)
lapiz.StartCap = Drawing2D.LineCap.ArrowAnchor
lapiz.EndCap = Drawing2D.LineCap.RoundAnchor
grafica.CreateGraphics.DrawLine(lapiz, 20, 80, 200, 80)
lapiz.Dispose()
Se crea una variable llamada lapiz a la cual se le asigna espacio de memoria de

tipo Pen con un color azul y un ancho del lapiz de 6 pixeles. A la propiedad StartCap
(establece el extremo que se utiliza al inicio de las líneas dibujadas) del objeto lapiz se
le asigna una punta de flecha (ArrowAnchor) que se obtiene de la enumeracion
LineCap del espacio de nombres Drawing2D, además a la propiedad EndCap
(establece el extremo que se utiliza al final de las líneas dibujadas) se le asigna un
extremo redondeado(RoundAnchor). Por último se libera (Dispose) el objeto Pen
lapiz.
c) Seleccione el menú Línea discontinua, dé doble clic para abrir el editor del
Dim recortar As Single() = {3, 4, 10, 2}
lapiz.DashPattern = recortar
grafica.CreateGraphics.DrawLine(lapiz, 20, 100, 400, 100)
lapiz.Dispose()
Se crea una matriz llamada recortar con los valores 3, 4, 10, 2 que representa
los cortes y los espacios al dibujar una línea. En el ejemplo se dibuja una línea
discontinua basada en la matriz {3, 4, 10, 2}. Si se multiplican los elementos de la
matriz por el ancho del lápiz (3), se obtiene {9, 4, 30, 6}. Las líneas que se muestran
alternan sus longitudes entre 9 y 30 y los espacios alternan sus longitudes entre 4 y 6. A
la propiedad DashPattern (patrón de corte) del objeto lapiz se le asigna los valores de
dicha matriz.
d) Seleccione el menú Unión de Líneas, dé doble clic para abrir el editor del
Dim conectar As New Drawing2D.GraphicsPath()
168
conectar.StartFigure()
conectar.AddLine(New Point(100, 30), New Point(200, 30))
lapiz.LineJoin = Drawing2D.LineJoin.Round
grafica.CreateGraphics.DrawPath(lapiz, conectar)
lapiz.Dispose()
Se crea un objeto conectar de tipo GraphicsPath (representa una serie de líneas

y curvas conectadas) del espacio de nombres Drawing2D. Con la función StartFigure
() se inicia una nueva figura sin cerrar la actual y con la función AddLine se le
adicionan líneas al objeto conectar. Se utilizo la estructura Point para crear los puntos
de la línea. A la propiedad LineJoin (establece el estilo de unión de los extremos de dos
líneas dibujadas) se le asigna un estilo de unión redondo (Round). Se utiliza la función
DrawPath para visualizar todas las líneas creadas y conectadas. Recibe como
parámetros el objeto Pen lapiz y la serie de las líneas del objeto conectar.
e) Seleccione el menú Rectángulo sin relleno, dé doble clic para abrir el editor del
grafica.CreateGraphics.DrawRectangle(Pens.Red, 100, 100, 60, 80)
La función DrawRectangle permite dibujar un rectángulo sin relleno. Dicho

objeto contiene cinco parámetros: el primero es el color del rectángulo (se utiliza la
clase Pens para asignar el color), el segundo es la coordenada X, el tercero es la
coordenada Y, el cuarto es el ancho y el quinto es el alto.
f) Seleccione el menú Rectángulo con relleno, dé doble clic para abrir el editor
del procedimiento y escriba el siguiente código:
grafica.CreateGraphics.FillRectangle(Brushes.Red, 100, 100, 60, 80)
Para mostrar un rectángulo relleno se utiliza la función FillRectangule. Dicho

objeto contiene cinco parámetros: el primero es el color del rectángulo (se utiliza la
clase Brushes para asignar el color de relleno), el segundo es la coordenada X, el
tercero es la coordenada Y, el cuarto es el ancho y el quinto es el alto.
g) Seleccione el menú Cuadro sin relleno, dé doble clic para abrir el editor del
grafica.CreateGraphics.DrawRectangle(Pens.Blue, 100, 100, 80, 80)
Con la función DrawRectangule se puede crear un cuadro sin relleno,

solamente se necesita que los valores de ancho y alto sean iguales.
h) Seleccione el menú Cuadro con relleno, dé doble clic para abrir el editor del
grafica.CreateGraphics.FillRectangle(Brushes.Red, 100, 100, 80, 80)
169
Con la función FillRectangule se puede crear un cuadro con relleno, solamente
se necesita que los valores de ancho y alto sean iguales.
i) Seleccione el menú Rectángulo con trama, dé doble clic para abrir el editor del
Dim trama As New Drawing2D.HatchBrush(Drawing2D.HatchStyle.Vertical,Color.Blue,
Color.Green)
Dim trama1 As New Drawing2D.HatchBrush(Drawing2D.HatchStyle.Cross, Color.Blue,
Color.Green)
Dim trama2 As New Drawing2D.HatchBrush(Drawing2D.HatchStyle.
DarkUpwardDiagonal,Color.Blue, Color.Green)
grafica.CreateGraphics.FillRectangle(trama, 10, 80, 60, 40)
grafica.CreateGraphics.FillRectangle(trama1, 100, 80, 60, 40)
grafica.CreateGraphics.FillRectangle(trama2, 200, 80, 60, 40)
Se crean tres objetos trama, trama1, trama2 de tipo HatchBrush (define un

pincel rectangular con un estilo de trama, un color de primer plano y un color de fondo)
del espacio de nombres Drawing2D. Como parámetros recibe: el estilo de la trama
(Vertical, Cross, DarkUpwardDiagonal), el color de primer plano (blue) y el color de
fondo (green). Con la función FillRectangle se dibuja tres rectángulos cada uno con su
respectiva trama.
j) Seleccione el menú Cuadro con degradado, dé doble clic para abrir el editor
Dim rectangulo As Rectangle = New Rectangle(New Point(50, 60), New Point(100,100))
Dim degradado As New Drawing2D.LinearGradientBrush(rectangulo, Color.Blue,
Color.Green, Drawing2D.LinearGradientMode.BackwardDiagonal)
grafica.CreateGraphics.FillRectangle(degradado, rectangulo)
Se crea un objeto triangulo de tipo Rectangle y se le asigna espacio de

memoria con los puntos (Point) 50, 60, 100, 100. También se crea un objeto llamado
degradado al cual se le asigna espacio de memoria de tipo LinearGradientBrush
(define un degradado lineal) del espacio de nombres Drawing2D. Como parámetros
recibe: el rectángulo a dibujarse, los colores de degradado y la dirección del degradado
lineal. La función FillRectangle dibuja el triángulo con el degradado lineal.
k) Seleccione el menú Elipse sin relleno, dé doble clic para abrir el editor del
grafica.CreateGraphics.DrawEllipse(Pens.Blue, 100, 100, 60, 80)
La función DrawEllipse permite dibujar una elipse sin relleno. Dicho objeto
contiene cinco parámetros: el primero es el color de la elipse, el segundo es la
coordenada X, el tercero es la coordenada Y, el cuarto es el ancho y el quinto es el alto.
l) Seleccione el menú Elipse con relleno, dé doble clic para abrir el editor del
grafica.CreateGraphics.FillEllipse(Brushes.Blue, 100, 100, 60, 80)
170
Para mostrar una elipse rellena de un color se utiliza la función FillEllipse.
Dicho objeto contiene cinco parámetros: el primero es el color de la elipse, el segundo
es la coordenada X, el tercero es la coordenada Y, el cuarto es el ancho y el quinto es el
alto.
m) Seleccione el menú Círculo sin relleno, dé doble clic para abrir el editor del
grafica.CreateGraphics.DrawEllipse(Pens.Blue, 100, 100, 80, 80)
Con la función DrawEllipse se puede crear un circulo sin relleno, solamente se

necesita que los valores de ancho y alto sean iguales.
n) Seleccione el menú Círculo con relleno, dé doble clic para abrir el editor del
grafica.CreateGraphics.FillEllipse(Brushes.Blue, 100, 100, 80, 80)
Con la función FillEllipse se puede crear un cuadro con relleno, solamente se

necesita que los valores de ancho y alto sean iguales.
o) Seleccione el menú Curva cerrada sin relleno, dé doble clic para abrir el editor
Dim puntos() As Point = {New Point(30, 30), New Point(90, 50), New Point(70, 80)}
grafica.CreateGraphics.DrawClosedCurve(Pens.Blue, puntos)
Se crea un arreglo llamado puntos de tipo Point al cual se le asigna espacio de

memoria y se le asignan los puntos: 30, 30, 90, 50, 70, 80. La función
DrawClosedCurve permite dibujar una curva cerrada sin relleno. Dicho objeto
contiene siete parámetros: el primero es el color de la curva, el segundo es la
coordenada X, el tercero es la coordenada Y, el cuarto es el ancho, el quinto es el alto,
el sexto es el ángulo inicial y el séptimo el ángulo final. .
p) Seleccione el menú Curva cerrada con relleno, dé doble clic para abrir el
editor del procedimiento y escriba el siguiente código:
Dim puntos() As Point = {New Point(30, 30), New Point(90, 50), New Point(70, 80)}
grafica.CreateGraphics.FillClosedCurve(Brushes.Blue, puntos)
La función FillClosedCurve permite dibujar una curva cerrada con relleno.
q) Seleccione el menú Torta sin relleno, dé doble clic para abrir el editor del
grafica.CreateGraphics.DrawArc(Pens.Aqua, 0, 0, 140, 70, 0,120)
La función DrawPie permite dibujar un grafico circular definida por una elipse
sin relleno. Dicho objeto contiene siete parámetros: el primero es el color de la curva, el
171
segundo es la coordenada X, el tercero es la coordenada Y, el cuarto es el ancho, el
quinto es el alto, el sexto es el ángulo inicial y el séptimo el ángulo final.
r) Seleccione el menú Torta con relleno, dé doble clic para abrir el editor del
grafica.CreateGraphics.FillPie(Brushes.Black, 0, 0, 140, 70,
La función FillPie permite dibujar un grafico circular definida por una elipse
con relleno.
Al ejecutar el proyecto y escoger la opción Rectángulos con trama del menú

Rectangulo/Cuadro, se obtendrá la siguiente figura:
Figura 9.8 Ejecución aplicación FuncionesGraficas.
9.2 Movimiento de un control
Para que un control o una imagen se desplacen en forma horizontal, vertical o diagonal
es necesario modificar las propiedades Top y Left. La propiedad Left permite mover un
control de izquierda a derecha y viceversa. La propiedad Top permite mover un objeto
de arriba abajo y viceversa. La combinación de Left y Top permite el movimiento de un
control en forma diagonal. Existen dos formas de realizar esta operación: manualmente
y automáticamente. De la forma manual se puede realizar haciendo un clic sobre un
botón cada vez que el usuario desea mover la figura. Dicho control contendrá el código
que permitirá realizar un movimiento específico. La forma automática se realiza con un
control Timer que permite manejar intervalos de tiempo y el cual se puede programar
para que realice unas tareas especificas en un determinado intervalo de tiempo.
9.2.1 Ejemplo práctico movimiento de un control
Crear una aplicación llamada MovimientoControl que permita a un usuario por medio
de botones mover una imagen en forma horizontal y vertical en forma manual y
automática.
172
PictureBox, 1 Timer, 7 Button.

Tabla 9.4 Propiedades de los controles de la aplicación MovimientoControl.

Button1 Name botonderecha
Text Mover a la derecha
Button2 Name botonabajo
Text Mover hacia abajo
Button3 Name botondiagonal
Text Mover de forma diagonal
Button4 Name botonderechatimer
Text Mover a la derecha con Timer
Button5 Name botonabajotimer
Text Mover hacia abajo con Timer
Button6 Name botondiagonaltimer
Text Mover de forma diagonal con Timer
Text Detener Reloj
PictureBox1 Name imagen
Image La imagen de un avión
Sizemode StretchImage
Timer1 Name reloj
Interval 1000
Enabled False
Text Funciones Gráficas Visual Basic .NET
Figura 9.9 Interfaz de usuario aplicación MovimientoControl.
173
a) Seleccione el objeto botonderecha, dé doble clic para abrir el editor del

procedimiento botonderecha_Click y escriba el siguiente código:
imagen.left = imagen.left + 10
Se modifica el valor de la propiedad Left del objeto imagen en 10 píxeles, lo

que hace que cuando el usuario de clic sobre el botón la imagen se desplazará hacia la
derecha 10 píxeles. Si se desea que el control imagen se devuelva los mismos 10
píxeles hacia la izquierda modifique la propiedad Left en -10.
b) Seleccione el objeto botonabajo, dé doble clic para abrir el editor del

imagen.top = imagen.top + 10
Se modifica el valor de la propiedad Top del objeto imagen en 10 píxeles, lo

que hace que cuando el usuario de clic sobre el botón la imagen se desplazará 10 píxeles
hacia abajo. Si se desea que el control imagen se devuelva los mismos 10 píxeles hacia
arriba modifique la propiedad Top en -10.
c) Seleccione el objeto botondiagonal, dé doble clic para abrir el editor del

imagen.Top = imagen.Top + 10
imagen.Left = imagen.Left + 10
En este código se modifica los valores de las propiedades Left y Top del
control imagen, esto permitirá que la imagen se desplace 10 pixeles a la derecha y 10
hacia abajo.
d) Seleccione el objeto botonderechatimer, dé doble clic para abrir el editor del

reloj.Enabled=True
Se modifica el valor de la propiedad Enabled del control reloj para que se

active el reloj en el intervalo especificado.
Nota: los objetos botonabajotimer y botondiagonaltimer tienen el mismo código.
e) Seleccione el objeto botondetener, dé doble clic para abrir el editor del

reloj.Enabled=False
Se modifica el valor de la propiedad Enabled del control reloj para detener el

tiempo.
f) Seleccione el objeto reloj, dé doble clic para abrir el editor del procedimiento y
174
If (botonderechatimer.Focused) Then
End If
If (botonabajotimer.Focused) Then
End If
If (botondiagonaltimer.Focused) Then
End If
Un control Timer actua como un reloj que se activa o se desactiva modificando

su propiedad Enabled (True, False). Cuando se activa realizará la (s) tarea (s)
especificada (s) dentro de su procedimiento. Su propiedad Interval determina la
frecuencia en que se realizarán las tareas., está dada en milisegundos. En este caso el
control tiene como valor de la propiedad Interval 1000 o sea que cada segundo se
realizará la tarea especificada. Utilizando la propiedad Focused se determina cual botón
se pulsó. Dependiendo de la respuesta realizará la acción correspondiente.
Al ejecutar el proyecto y pulsando varias veces el botón Mover en forma diagonal, se

podría obtener la siguiente figura:
Figura 9.10 Ejecución aplicación MovimientoControl.
9.3 Expandir y contraer un control
Para que un control se pueda expandir o contraer es necesario modificar las propiedades
del control Width y Height. La propiedad Width permite modificar el ancho del
control y la propiedad Height permite modificar la altura de un objeto. También se
puede realizar esta operación en forma manual y automática.
175
9.3.1 Ejemplo práctico expandir y contraer un control
Realizar una aplicación llamada ExpandirContraerControl que permita a un usuario

por medio de botones expandir y contraer una imagen en forma manual y automática.


Tabla 9.5 Propiedades de los controles de la aplicación ExpandirContraerControl.

Name imagen
PictureBox1 SizeMode StretchImage
Image La imagen del planeta tierra.
Button1 Name botonexpandir
Text Expandir Imagen.
Button2 Name botoncontraer
Text Contraer Imagen.
Button3 Name botonexpandirtimer
Text Expandir Imagen con Timer.
Button4 Name botoncontraertimer
Text Contraer Imagen con Timer.
Text Detener reloj
Form1 Name Formulario
Text Expandir y contraer una imagen
Timer1 Name reloj
Interval 1000
Figura 9.11 Interfaz de usuario ExpandirContraerControl.
176
a) Seleccione el objeto botonexpandir, dá doble clic para abrir el editor del

imagen.Height = imagen.Height + 10
imagen.Width = imagen.Width + 10
En este código se modifica el valor de las propiedades Width y Height en 10

píxeles, lo que hace que cuando el usuario de clic sobre el botón la imagen se vuelva 10
píxeles más ancha y alta.
b) Seleccione el objeto botoncontraer, dé doble clic para abrir el editor del

Imagen.Height = Imagen.Height - 10
Imagen.Width = Imagen.Width - 10
Se modifica el valor de las propiedades Width y Height en -10 píxeles, lo que

hace que cuando el usuario de clic sobre el botón la imagen se vuelva 10 píxeles menos
ancha y alta.
c) Seleccione el objeto botonexpandirtimer, dé doble clic para abrir el editor del

reloj.Enabled = True
En este código se modifica el valor de la propiedad Enabled del control Timer

reloj a un valor boolean True, lo que permite activar dicho control.
d) Seleccione el objeto botoncontraertimer, dé doble clic para abrir el editor del


reloj.Enabled = False
Se modifica el valor de la propiedad Enabled del control Timer reloj a un valor

boolean False, lo que permite desactivar dicho control.
If botonexpandirtimer.Focused Then
imagen.Width = imagen.Width + 10
imagen.Height = imagen.Height + 10
End If
If botoncontraertimer.Focused Then
imagen.Width = imagen.Width - 10
imagen.Height = imagen.Height - 10
End If
177
Utilizando la propiedad Focused del control Button se determina cual botón se
pulsó. Dependiendo de la respuesta realizará la acción correspondiente.
Al ejecutar el proyecto y pulsando el botón Expandir imagen con Timer, la imagen se

expandirá automáticamente, se podría obtener la siguiente figura:
Figura 9.12 Ejecución aplicación ExpandirContraerControl.
9.4 Animación
Incluir animación en un programa lo hace más atractivo a la vista y en Visual Basic

.NET es sumamente fácil hacerlo y allí el control Timer es parte esencial para generar
la animación de los objetos porque están en función del tiempo. Se dice que animar es
dar la sensación de movimiento a una imagen mediante diversas técnicas. Una de tantas
es cambiar varios cuadros por segundo de modo que se aparente un cambio de posición,
de allí que la animación está ligada al tiempo.
9.4.1 Ejemplos prácticos de animación
1) Escribir una aplicación llamada MovimientoLineas que cuando se pulse un botón se

dibujen líneas con coordenadas X, Y igual a 150 y un radio de 100 en un cuadro cada
segundo en el sentido de las manecillas de un reloj.

178
Tabla 9.6 Propiedades de los controles de la aplicación MovimientoLineas.

Name pintura
PictureBox1 BorderStyle FixedStyle
Image La imagen del planeta tierra.
Button1 Name botoniniciar
Text Iniciar
Text Detener
Text Movimiento de una Línea
Timer1 Name reloj
Interval 1000
Figura 9.13 Interfaz de usuario MovimientoLineas.
a) Escriba el siguiente código antes del primer procedimiento Sub y después de la

creación de la clase formulario.
Public class formulario

Dim decima_segundo As Double = 0
Dim xpos, ypos As Integer
Private sub ………..
Se declaran las siguientes variables globales para la clase formulario:

decima_segundo de tipo Double y es inicializada en cero (0); xpos y ypos de tipo
179
Integer.
b) Seleccione el objeto botoniniciar, dé doble clic para abrir el editor del

c) Seleccione el objeto botondetener, dé doble clic para abrir el editor del

d) Seleccione el objeto reloj, dé doble clic para abrir el editor del procedimiento y
xpos = Int(100 * Math.Cos(decima_segundo))
ypos = Int(100 * Math.Sin(decima_segundo))
pintura.CreateGraphics.DrawLine(Pens.Salmon, 100, 100, 100 + xpos, 100 + ypos)
decima_segundo += 0.1
Se calcula la posición de la línea con las funciones trigonométricas x = R*cos

(angulo), y = R*sin (angulo), donde R es el radio de la línea, Sin es el seno y Cos el
coseno que son tomados de la clase Math. Estos valores se asignan a las variables xpos
y ypos respectivamente. El ángulo será la variable decima_segundo que se
incrementara cada segundo en 0.1.
Al ejecutar el proyecto y pulsando el botón Iniciar, dejando que la aplicación se ejecute

durante un minuto, se podría obtener la siguiente figura:
Figura 9.14 Ejecución aplicación MovimientoLineas.
180
2) Diseñar una aplicación llamada RotacionImagenes que cuando se pulse un botón se
realice la rotación de la luna en un cuadro.

PictureBox, 1 Timer, 1 Button, 1 ImageList (permite crear una lista de imágenes).

Tabla 9.7 Propiedades de los controles de la aplicación RotacionImagenes.

Name imagen
PictureBox1 BorderStyle FixedStyle
Sizemode StretchImage
Button1 Name boton
Text Girar
ImageList1 Name listadeimagenes
Images Secuencias de imágenes de la luna.
Text Movimiento con secuencia de imágenes.
Timer1 Name reloj
Interval 500
Enabled True
Figura 9.15 Interfaz de usuario RotacionImagenes.
Ahora seleccione el control listadeimagenes y dé clic sobre la flecha en la parte

superior derecha, se observará la ventana Tareas de ImageList:
181
Figura 9.16 Ventana Tareas de ImageList del control listadeimagenes.
Seleccione la opción Elegir imágenes para visualizar la ventana Editor de la

colección de Imágenes.
Figura 9.17 Ventana Editor de colección de imágenes.
Pulse el botón Agregar y busque las imágenes correspondientes, se podría

obtener una figura similar a la siguiente:
Figura 9.18 Ventana con las imágenes a insertar en el control listadeimagenes.
182
Seleccione la imagen con el nombre MOON01 y pulse el botón Abrir, realice
esta operación hasta obtener la siguiente figura:
Figura 9.19 Ventana con las imágenes de la luna agregadas al Editor.
Pulse el botón Aceptar para volver nuevamente a modo diseño.


Dim y As Integer
Dim interruptor As Integer
Se declaran dos variables globales de tipo Integer para la clase formulario: y e

interruptor.

y=1
imagen.Image = listadeimagenes.Images.Item(0)
y=2
Se inicializa la variable y en uno (1), posteriormente se le asigna a la propiedad

Image del control PictureBox imagen la imagen que se encuentra en la posición cero
(0) de la lista de imágenes del control Imagelist listadeimagenes. Por último se le
asigna a la variable y el valor de dos (2).
c) Después de una instrucción End Sub escriba el siguiente procedimiento:

Private Sub rotar()
y=y+1
183
If y = 7 Then y = 1
imagen.Image = listadeimagenes.Images.Item(y)
End Sub
Este procedimiento permitirá ir incrementando la variable y en 1. Cuando la

variable y tenga el valor de 7, a esta se le asignará el valor de 1, en caso contrario se le
asigna a la propiedad Image del control PictureBox imagen la imagen que se encuentra
en la posición del valor de la variable y.
d) Seleccione el objeto boton, dé doble clic para abrir el editor del procedimiento y
If interruptor = 0 Then
boton.Text = "Parar"
interruptor = 1
Else
boton.Text = "Girar"
interruptor = 0
End If
Se pregunta si el valor de la variable interruptor es igual a cero (0). Si esto es

verdad se le asigna a la propiedad Text del objeto boton el texto Parar y a la variable
interruptor se le asigna el valor de uno (1). En caso contrario, se le asigna a la
propiedad Text del objeto boton el texto Girar y a la variable interruptor se le asigna
el valor de cero (0).
e) Seleccione el objeto reloj, dé doble clic para abrir el editor del procedimiento y
If interruptor = 1 Then
rotar()
End If
Se pregunta si el valor de la variable interruptor es igual a uno (1). Si esto es

verdad se llamara al procedimiento rotar () y realizará las tareas allí programadas.
Al ejecutar el proyecto y pulsando el botón Girar, se simulara la rotación de la luna.

Esto sucede debido a que cada ½ segundo se le asignará al objeto imagen una nueva
figura de la luna es una secuencia diferente.
Figura 9.20 Ejecución aplicación RotacionImagenes.
184
3) Crear una aplicación llamada MoverTextoAleatorio que permita a un usuario al
pulsar un botón visualizar la impresión de un texto en un formulario aleatoriamente.
Además otros dos botones que realicen las siguientes operaciones: el primero debe
permitir limpiar el formulario y el segundo detener la impresión del texto.

Timer, 3 Button.

Tabla 9.8 Propiedades de los controles de la aplicación MoverTextoAleatorio.

Button1 Name botontexto
Text Texto aleatorio.
Button2 Name botonlimpiar
Text Limpiar formulario.
Text Detener impresión
Text Texto aleatorio.
Timer1 Name reloj
Interval 1000
Figura 9.21 Interfaz de usuario MoverTextoAleatorio.
185


Dim grafica As Graphics
Dim valorx, valory As Integer
Dim fuente As New System.Drawing.Font("Arial", 14, FontStyle.Bold)
Se declaran cuatro variables globales: grafica de tipo Graphics, valorx y valory

de tipo Integer y fuente a la cual se le asigna espacio de memoria de tipo Font y recibe
como parámetros: el nombre de la letra, el tamaño de la letra y el estilo de la letra.

grafica = Me.CreateGraphics
Se le asigna la función CreateGraphics a la variable grafica con el fin de poder

crear gráficos.
c) Seleccione el objeto botontexto, dé doble clic para abrir el editor del

d) Seleccione el objeto botonlimpiar, dé doble clic para abrir el editor del

grafica.Clear(Me.BackColor)
Se le asigna la función Clear a la variable grafica para limpiar el formulario con

el fondo actual.

Randomize()
valorx = Int(Rnd() * 200)
valory = Int(Rnd() * 200)
grafica.DrawString("Texto en movimiento aleatorio", fuente, Brushes.Blue, valorx,
valory)
El procedimiento Ramdomize permite generar números aleatorios. A las

variables valorx y valory se les asigna el valor entero de un número aleatorio (Rnd ())
multiplicado por 200 (genera números aleatorios entre 1 0 y 200). Con la función
DrawString se imprime el texto. Recibe como parámetros: el texto a imprimir, la
186
fuente, el color de la fuente y las coordenadas x, y.
Al ejecutar el proyecto y pulsando el botón Texto aleatorio, se imprimirá en el área del

formulario el texto asignado cada segundo. Se podría obtener una figura similar a la
siguiente:
Figura 9.22 Ejecución aplicación MoverTextoAleatorio.
9.5 Ejercicios de gráficos
1. Escribir un programa que dibuje diez círculos concéntricos. Los círculos deben
estar separados por 5 píxeles utilizando DrawEllipse.
2. Realizar un programa que dibuje líneas de longitud y color aleatorio.
3. Diseñar un programa que dibuje un espiral utilizando DrawArc.
4. Hacer un programa que dibuje 10 palabras con fuente aleatoria de diferente
tamaño.
5. Elaborar un programa que capture una palabra e imprima dicha palabra en forma
aleatoria y de diferente color.
6. Escribir un programa que dibuje un tablero de ajedrez.
7. Realizar un programa que dibuje un cubo.
8. Crear un programa que capture el número de triángulos que deben dibujarse.
Dicho triángulos deben ser de diferente color.
9. Diseñar un programa que lea un par de coordenadas, el radio y dibuje el círculo,
además, de imprimir el diámetro, la circunferencia y el área del círculo.
10. Hacer un programa que simule un protector de pantalla. El programa deberá
dibujar 50 líneas al azar y después limpiar la pantalla y viceversa.
187
10. MANEJO DE EVENTOS (MOUSE – TECLADO)
Cuando un control u objeto realiza una acción se genera un evento. En los ejercicios de
los capítulos anteriores donde se ha utilizado el control Button se ha programado
código para que realice una operación específica en el evento clic. Cuando un control
genera un evento, un manejador de eventos vinculado al control se encarga de analizar
que evento ocurrió para responder al mismo ejecutando el método adecuado. El
manejador de eventos suele ser llamando delegado y es un objeto de la clase
EventHandler del espacio de nombres System y para los datos del evento se utiliza la
clase EventArgs del espacio de nombres System. Por ejemplo, si se desea controlar un
evento MouseUp en una aplicación Windows Forms, la clase de datos de evento es
MouseEventArgs y el delegado de evento es MouseEventHandler
Existen eventos estáticos o dinámicos. Los controladores de eventos estáticos

son efectivos durante toda la vida de la clase cuyos eventos controlan. Los controladores
de eventos dinámicos se activan y desactivan durante la ejecución de un programa,
normalmente en respuesta a alguna lógica condicional del programa. El método
AddEventHandler agrega controladores de eventos dinámicos y el método
RemoveEventHandler los desactiva. Cada lenguaje proporciona también sus propias
características para controlar eventos de forma dinámica.
10.1 Eventos del mouse
Un evento de mouse ocurre cuando el usuario interactúa con el mouse (o dispositivo

similar) para interactuar con un objeto. Los eventos mouse ocurren cuando el cursor
entra o sale del área de pantalla de un objeto, o cuando el usuario pulsa o libera el botón
del mouse. La mayoría de los controles de Visual Basic .NET contiene los siguientes
procedimientos para el manejo de eventos del mouse:
 MouseClick: se invoca cuando se da clic con el mouse.

 MouseDoubleClick: se invoca cuando se da doble clic con el mouse.
 MouseDown: se invoca cuando se pulsa el botón del mouse sobre un control.
 MouseEnter: se invoca cuando el mouse entra a límites de un control.
 MouseHover: se invoca cuando el mouse pasa cerca de un control.
 MouseLeave: se invoca cuando el mouse esta por fuera de los límites de un control.
 MouseMove: se invoca cuando el mouse se mueve por un control que tiene el foco.
 MouseUp: se invoca cuando se suelta el botón del mouse sobre un control.
 MouseWheel: se invoca cuando se desplaza la rueda del mouse. Se usa el
argumento Delta. Cuando el desplazamiento de la rueda es hacia arriba tiene un
valor entero de 120 y hacia atrás un valor de -120.
Las propiedades más comunes para el manejo de eventos del mouse son:
 Button: especifica el botón del mouse que fue pulsado.

 Clicks: especifica el número de veces que un botón del mouse fue pulsado y
soltado.
 Location: especifica la localización del mouse.
 X: la coordenada x del clic del mouse.
 Y: la coordenada y del clic del mouse.
188
10.2 Ejercicios de eventos del mouse
1) Elaborar una aplicación llamada MoverBotonMouse que permita a un usuario mover

un botón con el mouse. Al soltar el mouse se debe imprimir las coordenadas X y Y
donde quedo el botón.

Label, 1 Button.

Tabla 10.1 Propiedades de los controles de la aplicación MoverBotonMouse.

Button1 Name boton
Text Control.
Text Texto
Font - Bold True
Text Eventos mouse – mover control.
Figura 10.1 Interfaz de usuario MoverBotonMouse.

Dim mover As Boolean = False
Dim primeravez As Boolean = False
Dim valorx = 0
Dim valory = 0
189
Se declaran cuatro variables globales: mover y primeravez de tipo Boolean
inicializadas en False; valorx y valory de tipo Integer inicializadas en cero (0).
b) Seleccione el objeto boton, dé doble clic y escoja de la ventana superior derecha

el procedimiento boton_MouseDown y escriba el siguiente código:
mover = True
Cuando se pulse el mouse sobre el botón el valor booleano de la variable mover

será True.
c) Seleccione el objeto boton, dé doble clic y escoja de la ventana superior derecha

el procedimiento boton_MouseUp y escriba el siguiente código:
mover = False
primeravez = False
Cuando se suelte el mouse el valor booleano de las variables mover y

primeravez será False.
d) Seleccione el objeto boton, dé doble clic y escoja de la ventana superior derecha

el procedimiento boton_MouseMove y escriba el siguiente código:
If (mover = True) Then

If (primeravez = False) Then
primeravez = True
valorx = e.X
valory = e.Y
End If
lbltexto.Text = "Se arrastro y se solto en X=" & e.X + boton.Location.X - valorx & " Y="
& e.Y + boton.Location.Y - valory
boton.Location = New Point(e.X + boton.Location.X - valorx, e.Y + boton.Location.Y –
valory)
End if
Si se está moviendo el mouse y es la primera vez que se realiza, entonces, la

variable primeravez toma el valor True y con el parámetro e de tipo MouseEventArgs
del procedimiento MouseMove se obtiene el valor de las coordenadas actuales X,Y y se
asignan a las variables valorx, valory respectivamente. En la propiedad Text del objeto
lbltexto se le asigna el texto "Se arrastro y se solto en X=" concatenado con el valor
resultante de la posicion de la coordenada X más el valor de la localizacion del boton en
la posicion X menos el valor de la variable valorx unido con el texto " Y=" y el valor
resultante de la posicion de la coordenada Y más el valor de la localizacion del boton en
la posicion Y menos el valor de la variable valory. Por último, se reposiciona el botón
con las nuevas coordenadas.
Al ejecutar el proyecto y pulsando el botón Control, y arrastrándolo en el formulario a

la posición deseada se imprimirá en el objeto lbltexto las coordenadas X, Y. Se podría
obtener una figura similar a la siguiente:
190
Figura 10.2 Ejecución aplicación MoverBotonMouse.
2) Escribir una aplicación llamada PintarConMouse que permita a un usuario dibujar

al mantener pulsado y mover el mouse.
Solamente se utiliza el formulario de la aplicación Windows Forms.
Tabla 10.2 Propiedades de los controles de la aplicación PintarConMouse.

Text Dibujar con el Mouse.

Dim x,y as Integer
Dim moverraton As Boolean = False
Dim grafica As Graphics=Me.createGraphics
Se declaran cuatro variables globales: x y y de tipo Integer, moverraton de

tipo Boolean inicializadas en False; grafica de tipo Graphics la cual se inicializa para
poder graficar.
b) Seleccione el objeto formulario, dé doble clic y escoja de la ventana superior

derecha el procedimiento formulario_MouseDown y escriba el siguiente código:
191
moverraton = True
Cuando se pulse el mouse el valor booleano de la variable moverraton será

True.
c) Seleccione el objeto formulario, dé doble clic y escoja de la ventana superior

derecha el procedimiento formulario_MouseUp y escriba el siguiente código:
moverraton = False
Cuando se suelte el mouse el valor booleano de la variable moverraton será

False.
d) Seleccione el objeto formulario, dé doble clic y escoja de la ventana superior

derecha el procedimiento formulario_MouseMove y escriba el siguiente código:
If (moverraton = True) Then

x = e.X
y = e.Y
grafica.fillRectangle(Brushes.red,x,y,6,6)
End If
Si el valor de la variable moverranton es igual a True, con el parámetro e de

tipo MouseEventArgs del procedimiento MouseMove se asigna el valor de las
coordenadas actuales X,Y a las variables x, y respectivamente. Por otro lado, se dibuja
una elipse de color rojo en las coordenadas x, y, con un ancho y alto de 6 pixeles.
Al ejecutar el proyecto y pulsando y moviendo el mouse se puede realizar un dibujo

creado por el usuario sobre el formulario. Por ejemplo, se podría dibujar la siguiente
figura:
Figura 10.3 Ejecución aplicación PintarConMouse.
192
10.3 Eventos del teclado
Un evento de teclado ocurre cuando el usuario interactúa con dicho dispositivo. Cada
vez que el usuario pulsa o suelta una tecla se genera un evento de teclado. Los eventos
del teclado son KeyPress, KeyDown y KeyUp. El evento KeyPress recibe la
información en un argumento de tipo System.Windows.Forms.KeyPressEventArgs,
el cual contiene métodos y propiedades para saber si el evento ha sido manejado
(handled) o devuelve el caracter de la tecla pulsada (KeyChar), este evento es útil
cuando se desea obtener el caracter que fue pulsado, por ejemplo, para manejar la tecla
Enter. El evento KeyDown se invoca al pulsar una tecla y el evento KeyUp se invoca
al soltar una tecla, ambos reciben información por medio de un argumento de tipo
System.Windows.Forms.KeyEventArgs, por ejemplo, Alt que indica si se presionó la
tecla "alt" análogamente se comportan las propiedades Control, Shift, etc.
10.4 Ejercicios de eventos del teclado
1) Diseñar una aplicación llamada ColorTeclado que permita a un usuario que al

mantener pulsada una tecla se visualice un color predefinido. Si se pulsa la tecla A se
mostrará el color Azul, la tecla R el color Rojo y la tecla N el color Negro.

Label, 1 PictureBox.

Tabla 10.3 Propiedades de los controles de la aplicación ColorTeclado.

PictureBox1 Name pintura
BorderStyle Fixed3D
Text Texto
Font - Bold True
Text Color al pulsar una tecla.
Figura 10.4 Interfaz de usuario ColorTeclado.
193
a) Seleccione el objeto formulario, dé doble clic y escoja de la ventana superior

derecha el procedimiento formulario_KeyDown y escriba el siguiente código:
If e.KeyCode = Keys.A Then

pintura.BackColor = Color.Blue
lbltexto.Text = "La tecla pulsada fue la: " + Convert.ToChar(e.KeyValue)
End If
If e.KeyCode = Keys.R Then
pintura.BackColor = Color.Red
End If
If e.KeyCode = Keys.N Then
pintura.BackColor = Color.Black
End If
Se utiliza la propiedad KeyCode (obtiene el código de la tecla pulsada) del

argumento e de tipo keyEventArgs para determinar si la tecla pulsada es igual a una
tecla especifica (enumeración Keys.(tecla)). Si se cumple la condición se le asignará al
objeto pintura en su propiedad BackColor el color correspondiente. Por otro lado, se
le asignará a la propiedad Text del control lbltexto el texto “La tecla pulsada fue la:”
unido al nombre de la tecla ( KeyValue obtiene el valor de la tecla). Se utiliza la
función ToChar de la clase Convert para realizar la conversion de la tecla pulsada.
b) Seleccione el objeto formulario, dé doble clic y escoja de la ventana superior

derecha el procedimiento formulario_KeyUp y escriba el siguiente código:
pintura.BackColor = Me.BackColor
Al soltarse la tecla pulsada se le asignará al objeto pintura el fondo actual del

control.
Al ejecutar el proyecto y manteniendo pulsado la tecla N, se obtendría la siguiente

figura:
Figura 10.5 Ejecución aplicación ColorTeclado.
194
2) Crear una aplicación llamada DetectarTecla que permita a un usuario escribir en una
primera caja de texto solo números y en una segunda caja de texto solo letras. Además
se debe permitir eliminar lo tecleado en la respectiva caja de texto, como también al
pulsar la tecla Enter en la primera caja de texto, se deberá enviar el foco a la segunda
caja de texto.

Label, 2 TextBox.

Tabla 10.4 Propiedades de los controles de la aplicación DetectarTecla.

TextBox2 Name txtletra
Text Dígite solo números:
Label2 Name lblletra
Text Dígite solo letras:
Text Detectar tecla pulsada.
Figura 10.6 Interfaz de usuario DetectarTecla.
a) Seleccione el objeto txtnumero, dé doble clic y escoja de la ventana superior

derecha el procedimiento txtnumero_KeyPress y escriba el siguiente código:
If (Asc(e.KeyChar)) >= 48 And (Asc(e.KeyChar)) <= 57

Or (Asc(e.KeyChar)) =Keys.Back Or (Asc(e.KeyChar)) =Keys.Enter Then
e.Handled = False
Else
MsgBox("Solo se pueden digitar números", MsgBoxStyle.Information)
e.Handled = True
195
End If
If (e.KeyChar = Convert.ToChar(Keys.Enter)) Then
txtletra.Focus()
End If
Se utiliza la función Asc para determinar el valor Ascci del carácter pulsado
obtenido de la propiedad KeyChar. Los números de 0 a 9 se encuentran en el rango
Ascci entre 48 y 57. También se determina el valor cuando de pulsa la tecla Back
(retroceso) y Enter. Si la condición es verdadera se establece que se controlo el evento
y por consiguiente se debe procesar (e.Handled = False). En caso contrario no se
procesa el evento y se mostrará en un cuadro de diálogo MsgBox el mensaje “Solo se
pueden dígitar números”. Por otro lado, al pulsarse la tecla Enter se enviará el cursor
al objeto txtletra el cual es realizado con la función Focus().
b) Seleccione el objeto txtletra, dé doble clic y escoja de la ventana superior

derecha el procedimiento txtletra_KeyPress y escriba el siguiente código:
If (Asc(e.KeyChar)) >= 65 And (Asc(e.KeyChar)) <= 90 Or
(Asc(e.KeyChar)) >= 97 And (Asc(e.KeyChar)) <= 122 Or
(Asc(e.KeyChar)) = Keys.Back Then
e.Handled = False
Else
MsgBox("Solo se pueden digitar letras", MsgBoxStyle.Information)
e.Handled = True
End If
Se utiliza la función Asc para determinar el valor Ascci del carácter pulsado
obtenido de la propiedad KeyChar. Las letras minúsculas se encuentran en el rango
Ascci entre 97-122 y las letras mayúsculas en el rango 65 - 90. También se determina el
valor cuando de pulsa la tecla Back. Si la condición es verdadera se establece que se
controlo el evento y por consiguiente se debe procesar (e.Handled = False). En caso
contrario no se procesa el evento y se mostrará en un cuadro de diálogo MsgBox el
mensaje “Solo se pueden dígitar letras”.
Al ejecutar el proyecto y digitarse en el objeto txtnumero un número se obtendrá la

siguiente figura:
Figura 10.7 Ejecución aplicación DetectarTecla.
196
Si a continuación se trata de digitar cualquier tecla diferente de un número se
visualizará el siguiente cuadro de mensaje.
Figura 10.8 Mensaje cuando no se escribe un número en el objeto txtnumero.
También se mostrará un mensaje si se trata de digitar algo diferente de letras en

el objeto txtletras. Cuando se termina de digitar los números y se pulsa la tecla Enter,
se podrá digitar las letras en el control txtletras.
Figura 10.9 Formulario con números y letras.
197
11. PROGRAMACIÓN ORIENTADA A OBJETOS CON VB.NET
La Programación orientada a objetos (P.O.O) es un modelo de programación que utiliza

objetos para simular el mundo real. La P.O.O. encapsula datos (atributos) y métodos
(comportamientos) en objetos. En la P.O.O. se utilizan los siguientes conceptos:
 Objeto: Entidad (forma) provista de datos (propiedades, atributos) y
comportamientos (funcionalidad, programas, métodos). Corresponden a los
objetos reales del mundo que nos rodea.
 Clase: Conjunto de objetos donde se definen atributos para almacenar datos y
crear operaciones para manejar dichos datos. En los ejemplos realizados ya se
han utilizado clases, por ejemplo, cada vez que se ha arrastrado un control
Button hacia un formulario se ha creado una instancia de la clase Button. En
Visual Basic .NET también es posible crear una instancia de un control
utilizando la palabra clave New. Para una instancia de la clase TextBox se
debería escribir el siguiente código:
Dim nuevacajadetexto As New TextBox
 Herencia: Es la capacidad de crear nuevas clases a partir de clases existentes,

en otras palabras, es la capacidad de obtener el comportamiento de una clase
definida. Admite la reutilización de código porque solo se debe codificar el
comportamiento de las nuevas clases.
 Encapsulación: También llamada "ocultación de la información". Asegura que
los objetos no pueden cambiar el estado interno de otros objetos de manera
inesperada; solamente los propios métodos internos del objeto pueden acceder a
su estado. Cada tipo de objeto expone una interfaz a otros objetos que especifica
cómo otros objetos pueden interactuar con él.
 Abstracción: Conjunto de funciones que proporcionan el comportamiento
fundamental de una clase para su utilización. La abstracción se garantiza
mediante la encapsulación.
 Polimorfismo: Es la posibilidad de definir numerosas clases que implementan
los mismos métodos con diferente función.
 Método: Es un programa asociado a un objeto (o a una clase de objetos), cuya
ejecución se desencadena mediante un "mensaje".
 Mensaje: Una comunicación dirigida a un objeto, que le ordena que ejecute uno
de sus métodos con ciertos parámetros.
 Propiedad, atributo o variable: Datos asociados a un objeto o a una clase de
objetos.
Entonces la P.O.O. expresa un programa como un conjunto de objetos, que se

comunican entre ellos para realizar tareas; Siendo un objeto una unidad que contiene
datos y métodos que operan sobre esos datos. Los objetos tienen la propiedad de
ocultamiento de la información, esto significa que los objetos saben comunicarse entre
sí a través de interfaces (normalmente no se permite que un objeto sepa cómo están
implementados otros objetos). Los objetos pueden ser activados mediante la recepción
de mensajes. Un mensaje es simplemente una petición para que un objeto se comporte
de una determinada manera, ejecutando un método. La técnica de enviar mensajes se
conoce como paso de mensajes.
Una clase es un tipo definido por el usuario que determina las estructuras de
datos y las operaciones asociadas con ese tipo. Cada vez que se construye un objeto de
198
una clase, se crea una instancia de esa clase. En general, los términos objetos e
instancias de una clase se pueden utilizar indiferentemente. Una clase es una colección
de objetos similares y un objeto es una instancia de una definición de una clase.
Para declarar una clase se utiliza la palabra reservada Class seguida del nombre
de la clase y el cuerpo de la misma, terminándose con End Class. El cuerpo de la clase
incluye los atributos y los métodos.
Class Alumno
Cuerpo de clase (Atributos y métodos)
End Class
Toda clase debe contener una definición de variables o métodos precedida por
un modificador de acceso a los miembros; los modificadores de acceso a miembros
pueden aparecer varias veces y en cualquier orden en una definición de una clase. Los
modificadores de acceso de Visual Basic.NET son: public (público), private (privado)
y protected (protegido). Cuando un miembro de una clase tiene el especificador public,
ese miembro puede ser accedido por cualquier parte del programa. Cuando un miembro
es protected, ese miembro puede ser utilizado para realizar la herencia. Cuando un
miembro es private, ese miembro sólo puede ser accedido por otros miembros de la
misma clase. Cuando no se utiliza ningún especificador de acceso, por defecto los
miembros de una clase son públicos.
Los datos o variables definidos en una clase se llaman variables de instancias.

El código está contenido en los métodos. Los métodos y las variables de instancias
definidas en una clase son los miembros de la clase.
Class Alumno
‘ variables de instancias
Private nombre_alumno As String
Private asignatura As String
Private curso As integer
‘ métodos o procedimientos
Public Sub obtenerNombre(nombre As String)
Tareas del metodo
End Sub
Public Function obtenerCurso(curso As Integer) As Integer
Tareas del metodo
End Function
…..
End Class
11.1 Constructores
Se llama Constructor a un procedimiento con nombre New el cual se inicializa

automáticamente cuando se crea un objeto de la clase. Los constructores pueden recibir
argumentos pero no pueden devolver valores.
11.1.1 Constructores sin parámetros
En algunos casos es necesario crear varios objetos que se inicialicen siempre con
valores predeterminados, es decir cada vez que se cree un nuevo objeto este se
199
inicializaría con los mismos valores.
Class Alumno
Private curso As integer
Public Sub New()
Nombre_alumno=””
asignatura=””
curso=0
End Sub
Public Function obtenerNombre(nombre As String) As String
return nombre
End Function
return curso
End Function
End Class
11.1.2 Constructores con parámetros
Existen casos en que es necesario crear varios objetos que se inicialicen con diferentes
valores, como se puede apreciar, en el ejemplo anterior cada vez que se crea un nuevo
objeto este se inicializaría con los mismos valores, la solución es crear un constructor
que tenga parámetros.
Class Alumno
Private curso as integer
Public Sub New(nombre As String, asig As String, numero As Integer)
nombre_alumno=alumno
asignatura=asig
curso=numero
End Sub
return nombre
End Function
return curso
End Function
…..
End Class
11.1.3 Sobrecarga de constructores
La sobrecarga de constructores se refiere a la creación de métodos constructores con el

mismo nombre pero con diferente lista de parámetros en la misma clase. Cuando invoca
un constructor sobrecargado, Visual Basic .NET utiliza como apoyo el número de
parámetros como guía para determinar la versión del constructor sobrecargado que
realmente debe llamar. Además, de la sobrecarga de constructores, también es posible
realizar la sobrecarga con otros métodos. De hecho las clases que se implementan en la
realidad, la sobrecarga de constructores es la norma y no la excepción.
200
Class Alumno
Private curso As Integer
Public Sub New(nombre As String, asig As String, numero As Integer)
asignatura=asig
curso=numero
End Sub
Public Sub New(nombre As String, asig As String)
asignatura=asig
curso=0
End Sub
return nombre
End Function
return curso
End Function
…..
End Class
11.2 Herencia y polimorfismo
La herencia es la posibilidad de crear una nueva clase a partir de una clase existente, la
clase nueva hereda todos los atributos y comportamientos de una clase existente. En la
nueva clase se pueden agregar atributos y comportamientos o supeditar los
comportamientos de la superclase a fin de adaptar la clase a las nuevas necesidades.
El polimorfismo permite escribir programas para manejar una amplia variedad
de clases interrelacionadas existentes y por especificar.
Al crear una nueva clase (clase derivada), en lugar de escribir variables y
métodos totalmente nuevos, el programador puede indicar que la nueva clase puede
heredar las variables y los métodos de una superclase (clase base) previamente definida.
Para poder acceder a las variables de la superclase estas previamente deben estar
con el modificador de acceso protected o public:
Estudiante //clase base
Estgraduado Estlicenciado //clases derivadas
En Visual Basic .NET la palabra reservada Inherits permite realizar la herencia

de una clase.
Class Notas
Inherits Alumno
Cuerpo clase…..
End class
El anterior código define la subclase Notas que hereda (Inherits) las

propiedades y atributos de la clase Alumno.
Se utiliza la palabra clave MyBase para llamar a procedimientos de una clase

heredada (base).
201
11.3 Ejemplos prácticos de clases
1) Realizar una aplicación llamada Constructores que permita a un usuario digitar el

ancho, el alto y la profundidad de una caja y obtener su volumen utilizando clases.
Utilizando el cuadro de herramientas agregue al formulario los siguientes controles: 2

Button, 4 TextBox y 4 Label.

Tabla 11.1 Propiedades de los controles de la aplicación Constructores.

Button1 Name botoncsp
Text Constructor sin parámetros
Butto2 Name botonccp
Text Constructor con parámetros
Label1 Name lblalto
Text Alto de la caja:
Label2 Name lblancho
Text Ancho de la caja:
Label3 Name lblprofundidad
Text Profundidad de la caja:
Label4 Name lblvolumen
Text Vólumen de la caja:
TextBox1 Name txtalto
Textbox2 Name txtancho
TextBox3 Name txtprofundidad
TextBox4 Name txtvolumen
Text Vólumen de una caja con clases.
El formulario se visualizaría como muestra la siguiente figura:
Figura 11.1 Interfaz de usuario Constructores.
202
 Agregar nueva Clase
Para crear una nueva clase puede realizar alguno de los siguientes pasos:
1. Del menú Proyecto seleccione Agregar clase…

2. Del icono (Agregar Nuevo Elemento) seleccionar Agregar clase…
3. En el Explorador de soluciones situarse en el nombre del proyecto, dar clic
derecho, seleccionar la opción Agregar y escoger clase…
Con cualquiera de las tres opciones se visualizará la siguiente figura:
Figura 11.2 Ventana para agregar una nueva clase.
En el cuadro de texto Nombre, cambie el nombre a la clase por Miclase, luego

pulse el botón Agregar para visualizar un nuevo módulo de clase en el editor de código
y en la lista del explorador de soluciones aparece un nuevo archivo con el nombre de
la clase.
Figura 11.3 Editor de código de la clase Miclase.
 Escribir código para la clase
a) Entre las instrucciones Public Class Miclase y End Class, escriba el siguiente
código:
Private alto, ancho, profundidad As Double
203
Se declaran tres variables (alto, ancho, profundidad) para guardar los valores
digitados por el usuario respectivamente. Además se declaran como privadas para que
puedan ser modificadas únicamente por la clase.
Public Sub New(ByVal altoc As Double, ByVal anchoc As Double, ByVal profc As
Double)
alto = altoc
ancho = anchoc
profundidad = profc
End Sub
Se crea un constructor con parámetros que recibe los tres valores digitados por el
usuario en los objetos txtalto, txtancho y txtprofundidad y se asignan a las tres
variables privadas de la clase respectivamente.
Public Sub New()
alto = 0
ancho = 0
profundidad = 0
End Sub
Se crea un constructor sin parámetros, este inicializa las tres variables privadas
de la clase en cero (0).
Public Sub iniciarvariables(ByVal altoc As Double, ByVal anchoc As Double, ByVal
profc As Double)
alto = altoc
ancho = anchoc
profundidad = profc
End Sub
Se crea un procedimiento Sub con parámetros que recibe los tres valores
digitados por el usuario en los objetos txtalto, txtancho y txtprofundidad y se asignan
a las tres variables privadas de la clase respectivamente. Este procedimiento es utilizado
por el constructor sin parámetros.
Public Function volumencaja() As Double
Return alto * ancho * profundidad
End Function
Se crea un procedimiento Function sin parámetros que no recibe valores y que

retorna un valor double. En este caso con la palabra clave Return retorna el valor
resultante de multiplicar el alto por el ancho por la profundidad de la caja.
 Escribir código para los botones
a) Seleccione el objeto botoncsp, dé doble clic para abrir el editor del

procedimiento botoncsp_Click y escriba el siguiente código:
Dim instanciaMiclase As New Miclase

instanciaMiclase.iniciarvariables(txtalto.Text, txtancho.Text, txtprofundidad.Text)
txtvolumen.Text = instanciaMiclase.volumencaja
Primero se crea una instancia de tipo Miclase llamada instanciaMiclase. Se

llama al procedimiento iniciarvariables por intermedio de la instancia de la clase y se
le envían los valores digitados en las cajas de texto txtalto, txtancho, txtprofundidad.
204
A la propiedad Text del objeto txtvolumen se le asigna el valor que retorne el
procedimiento volumencaja de la clase Miclase.
b) Seleccione el objeto botonccp, dé doble clic para abrir el editor del

procedimiento botoncsp_Click y escriba el siguiente código:
Dim instanciaMiclase As New Miclase(txtalto.Text, txtancho.Text, txtprofundidad.Text)
txtvolumen.Text = instanciaMiclase.volumencaja
Se crea una instancia de tipo Miclase llamada instanciaMiclase donde se le

envían los valores digitados en las cajas de texto txtalto, txtancho, txtprofundidad. A
la propiedad Text del objeto txtvolumen se le asigna el valor que retorne el
procedimiento volumencaja de la clase Miclase.
Al ejecutar el proyecto y digitar los valores 5, 4, 2 en la respectiva caja de texto y pulsar

el botón Constructores sin parámetros o Constructores con parámetros, se
visualizará la siguiente figura:
Figura 11.4 Ejecución aplicación Constructores.
2) Diseñar una aplicación llamada HerenciaClases que permita a un usuario realizar lo

siguiente en tres páginas: en la primera página para un punto digitar dos valores para las
coordenadas X,Y y mostrar dichos valores; en una segunda página para un circulo
visualizar las coordenadas X,Y y poder digitar un valor para el radio del circulo y
calcular el área; en una tercera página visualizar las coordenadas, X,Y, el radio y poder
digitar la altura y calcular el área y el volumen del cilindro utilizando herencia.
Utilizando el cuadro de herramientas agregue al formulario un control TabControl.
205
Figura 11.5 Formulario con el control TabControl.
Seleccione el objeto TabControl y de clic sobre la flecha que aparece en la

parte superior derecha para ver la ventana de Tareas de TabControl.
Figura 11.6 Ventana Tareas de TabControl.
Pulse la opción Agregar ficha para visualizar la siguiente figura:
Figura 11.7 Control TabControl con una nueva ficha.
Con el objeto TabControl seleccionado busque la propiedad TabPages en el

cuadro de propiedades.
206
Figura 11.8 Propiedad TabPages del control TabControl.
Dé clic sobre al frente de la propiedad TabPages para ver el Editor de la

colección TabPage.
Figura 11.9 Editor de la colección TabPage.
Sitúese en la ficha TabPage1 y busque la propiedad Text en la ventana

propiedades de TabPage1, cambie el texto que allí aparece por Puntos, se visualizaría
207
Figura 11.10 Propiedad Text de TabPage1 modificada.
Realice la misma operación para TabPage2 y TabPage3, en la propiedad Text

escriba Círculo y Cilindro respectivamente. Se obtiene la siguiente figura:
Figura 11.11 Fichas del control TabControl modificadas.
Seleccione la ficha llamada Puntos y agréguele los siguientes controles: 1

Button, 3 TextBox y 3 Label. Después de colocar los controles u objetos en la ficha,
establezca las siguientes propiedades a los controles:
Tabla 11.2 Propiedades de los controles de la ficha Puntos.

Button1 Name botonpuntos
Text Clase Puntos
Label1 Name lblx
Text Dígite la coordenada X:
Label2 Name lbly
Text Dígite la coordenada Y:
Label3 Name lblpuntos
Text Los valores del Punto son (X,Y):
TextBox1 Name txtx
Textbox2 Name txty
TextBox3 Name txtpuntos
208
TabControl1 Name fichas
Text Figuras utilizando Herencia
Figura 11.12 Interfaz usuario Ficha Puntos.
Ahora seleccione la ficha llamada Círculo y agréguele los siguientes controles:

1 Button, 5 TextBox y 5 Label. Después de colocar los controles u objetos en la ficha,
establezca las siguientes propiedades a los controles:
Tabla 11.3 Propiedades de los controles de la ficha Círculo.

Button1 Name botoncirculo
Text Clase Círculo
Label1 Name lblcirculox
Text Nuevo valor de la coordenada X:
Label2 Name lblcirculoy
Text Nuevo valor de la coordenada Y:
Label3 Name lblradio
Text Dígite el valor del radio:
Label4 Name lblradio
Text Las nuevas coordenadas X,Y, y el
radio es:
Label5 Name lblarea
Text El área es:
TextBox1 Name txtcirculox
Textbox2 Name txtcirculoy
TextBox3 Name txtradio
TextBox4 Name txtxyradio
TextBox5 Name txtarea
209
Figura 11.13 Interfaz usuario Ficha Circulo.
Por último seleccione la ficha llamada Cilindro y agréguele los siguientes

controles: 1 Button, 3 TextBox y 3 Label. Después de colocar los controles u objetos
en la ficha, establezca las siguientes propiedades a los controles:
Tabla 11.4 Propiedades de los controles de la ficha Cilindro.

Button1 Name botoncilindro
Text Clase Cilindro
Label1 Name lblcilindrox
Text Nuevo valor coordenada X:
Label2 Name lblcilindroy
Text Nuevo valor coordenada Y:
Label3 Name lblradiocilindro
Text Dígite valor radio:
Label4 Name lblaltura
Text Dígite valor altura:
Label5 Name lblxyradioaltura
Text Las coordenadas X,Y; el radio y la
altura:
Label6 Name lblareacilindro
Text Area Cilindro:
Label7 Name lblvolumen
Text Volumen Cilindro:
TextBox1 Name txtcilindrox
Textbox2 Name txtcilindroy
TextBox3 Name txtradiocilindro
TextBox4 Name txtaltura
TextBox5 Name txtxyradioaltura
TextBox6 Name txtareacilindro
TextBox7 Name txtvolumen
210
Figura 11.14 Interfaz usuario Ficha Cilindro.
 Agregar Clases
a) Agregue una nueva clase, en el cuadro de texto Nombre, cambie el nombre a la

clase por Puntos, luego pulse el botón Agregar para visualizar un nuevo
módulo de clase en el editor de código y en la lista del explorador de
soluciones aparece un nuevo archivo con el nombre de la clase.
 Escribir código para la clase Puntos

Entre las instrucciones Public Class Puntos y End Class, escriba el siguiente código:
Public Class Puntos

Private x, y As Double
Public Sub New(ByVal a As Double, ByVal b As Double)
fijapuntos(a, b)
End Sub
Public Sub fijapuntos(ByVal a As Double, ByVal b As Double)
x=a
y=b
End Sub
Public Function mostrarx() As Double
Return x
End Function
Public Function mostrary() As Double
Return y
End Function
Public Function cadena() As String
Return "[" & x & " : " & y & "]"
End Function
End Class
211
Se declaran dos variables (x, y) de tipo Double para guardar los valores
digitados por el usuario respectivamente. Además, se declaran como privadas para que
puedan ser modificadas únicamente por la clase.
Por otro lado, se definen los siguientes procedimientos:
 Constructor New: que recibe dos parámetros de tipo Double y llama al
procedimiento fijapuntos.
 fijapuntos: recibe dos parámetros de tipo Double y le asigna a las variables
privadas x, y los valores recibidos respectivamente.
 mostrarx: retorna el valor de la coordenada x.
 mostrary: retorna el valor de la coordenada y.
 cadena: retorna un valor String con los valores x, y.
b) Agregue otra nueva clase, en el cuadro de texto Nombre, cambie el nombre a la

clase por Circulo, luego pulse el botón Agregar para visualizar un nuevo
módulo de clase en el editor de código y en la lista del Explorador de
 Escribir código para la clase Circulo
Entre las instrucciones Public Class Circulo y End Class, escriba el siguiente código:
Public Class Circulo

Inherits Puntos
Protected radio As Double
Public Sub New()
MyBase.new(0, 0)
fijaradio(0)
End Sub
Public Sub New(ByVal r, ByVal a, ByVal b)
MyBase.new(a, b)
fijaradio(r)
End Sub
Public Sub fijaradio(ByVal r As Double)
If r > 0.0 Then
radio = r
Else
r = 0.0
End If
End Sub
Public Function obtradio() As Double
Return radio
End Function
Public Function area() As Double
Return 3.14159 * radio * radio
End Function
Overloads Function cadena() As String
Return "Centro=" + MyBase.cadena() & "; Radio= " & radio
End Function
End Class
Se define la clase Circulo y hereda (Inherits) los atributos y comportamientos

de la clase Puntos. También se declara una variable (radio) de tipo Double para
guardar el valor del radio del círculo digitado por el usuario. Además se declara como
protegida para que pueda utilizarse en la herencia.
212
 Un primer constructor New: que no recibe parámetros y que llama al constructor de

la clase Puntos, la cual es la clase que esta heredando (MyBase.New(0,0))
enviándole dos ceros, además se llama al procedimiento fijaradio y se envía como
parámetro un valor cero;
 Un segundo constructor New: que recibe tres parámetros y que llama al constructor
de la clase Puntos (MyBase.New(a,b)) enviándole los valores de a,b, también se
llama al procedimiento fijaradio y se envía como parámetro el valor de c;
 fijaradio: recibe un parámetro de tipo Double. Si el valor de la variable recibida (r)
es mayor de cero se le asigna el valor de r a la variable radio, en caso contrario se le
asigna cero.
 obtradio: retorna el valor de la variable radio.
 area: retorna el valor resultante de multiplicar 3.14159 por radio al cuadrado.
 cadena: retorna un valor String, con el texto “Centro=” unido a los valores de x, y
que se reciben del procedimiento cadena de la clase Puntos (MyBase.cadena)
concatenado con el texto “Radio=” y el valor de la variable radio. Obsérvese que
este procedimiento se declara como Overloads por que este nombre de
procedimiento ya existe en la clase Puntos.
c) Agregue una nueva clase, en el cuadro de texto Nombre, cambie el nombre a la

clase por Cilindro, luego pulse el botón Agregar para visualizar un nuevo
 Escribir código para la clase Cilindro
Entre las instrucciones Public Class Cilindro y End Class, escriba el siguiente código:
Public Class Cilindro
Inherits Circulo
Protected altura As Double
Public Sub New(ByVal h As Double, ByVal r As Double, ByVal a As Double,
ByVal b As Double)
MyBase.new(r, a, b)
fijaaltura(h)
End Sub
Public Sub fijaaltura(ByVal h As Double)
If (h >= 0.0) Then
altura = h
Else
altura = 0
End If
End Sub
Public Function obtaltura() As Double
Return altura
End Function
Overloads Function area() As Double
Return 2 * MyBase.area() + 2 * 3.14159 * radio * altura
End Function
Public Function volumen() As Double
Return MyBase.area() * altura
213
End Function
Overloads Function cadena() As String
Return MyBase.cadena() & ";Altura = " & altura
End Function
End Class
Se define la clase Cilindro y hereda (Inherits) los atributos y comportamientos

de la clase Circulo, pero como la clase Circulo hereda de la clase Puntos, la clase
Cilindro también hereda todo el comportamiento de la clase Puntos. Por otro lado, se
declara una variable (altura) de tipo Double para guardar el valor de la altura del
cilindro digitado por el usuario. Además se declara como protegida para que pueda
utilizarse en la herencia.
 Un constructor New: que recibe cuatro parámetros y que llama al constructor de la

clase Cilindro (MyBase.New(r,a,b)) enviándole los valores de r, a, b, también, se
llama al procedimiento fijaaltura y se envía como parámetro el valor de h;
 fijaaltura: recibe un parámetro de tipo Double. Si el valor de la variable recibida
(h) es mayor de cero se le asigna el valor de h a la variable altura, en caso contrario
se le asigna cero.
 obtaltura: retorna el valor de la variable altura.
 area: retorna el valor resultante de multiplicar 2 por el valor recibido del
procedimiento area de la clase Circulo (MyBase.area ()) más 2*3.14159 * radio *
altura. Este procedimiento se declara como Overloads por que este nombre de
procedimiento ya existe en la clase Circulo.
 volumen: retorna el valor recibido del procedimiento area de la clase Circulo
(MyBase.area ()) multiplicado por el valor de la variable altura.
 cadena: retorna un valor String, con valor devuelto por el procedimiento cadena de
la clase Circulo (MyBase.cadena ()) unido al texto “Altura=” y el valor de la
variable altura. Este procedimiento también se declara como Overloads por que
este nombre de procedimiento ya existe en las clases Circulo y Puntos.
 Escribir código para los botones
a) Seleccione el objeto botonpuntos, dé doble clic para abrir el editor del

procedimiento botonpuntos_Click y escriba el siguiente código:
Dim puntos As Puntos

Dim valorx, valory As Double
valorx = Val(txtx.Text)
valory = Val(txty.Text)
puntos = New Puntos(valorx, valory)
txtpuntos.Text = puntos.cadena()
txtcirculox.Text = puntos.mostrarx
txtcirculoy.Text = puntos.mostrary
Primero se crea una instancia de tipo Puntos llamada puntos. Se declaran las
variables valorx, valory de tipo Double y se le asigna los valores de los objetos txtx y
txty en su propiedad Text respectivamente. Se asigna espacio de memoria (New) al
objeto puntos y se le envía al constructor de la clase Puntos los valores de valorx y
valory. Por otro lado, se le asigna a la propiedad Text de los objetos txtpuntos,
214
txtcirculox y txtcirculoy respectivamente lo que retorna los procedimientos cadena,
mostrarx, mostrary de la instancia puntos.
b) Seleccione el objeto botoncirculo, dé doble clic para abrir el editor del

procedimiento botoncirculo_Click y escriba el siguiente código:
Dim circulo As Circulo
Dim valorx, valory, valorradio As Double
valorx = Val(txtcirculox.Text)
valory = Val(txtcirculoy.Text)
valorradio = Val(txtradio.Text)
circulo = New Circulo(valorradio, valorx, valory)
circulo.fijapuntos(valorx, valory)
circulo.fijaradio(valorradio)
txtxyradio.Text = circulo.cadena()
txtarea.Text = circulo.area()
txtcilindrox.Text = circulo.mostrarx
txtcilindroy.Text = circulo.mostrary
txtradiocilindro.Text = circulo.obtradio
Se crea una instancia de tipo Circulo llamada circulo. Se declaran las variables
valorx, valory y valorradio de tipo Double y se le asigna los valores de los objetos
txtcirculox, txtcirculoy y txtrradio en su propiedad Text respectivamente. Se asigna
espacio de memoria (New) al objeto circulo y se le envía al constructor de la clase
Circulo los valores de valorradio, valorx y valory. Además se le envía al
procedimiento fijapuntos los valores de valorx y valory; a fijaradio el valor de
valorradio. Por otro lado, se le asigna a la propiedad Text de los objetos txtxyradio,
txtarea, txtcilindrox, txtcilindroy y txtradiocilindro respectivamente lo que retorna
los procedimientos cadena, area, mostrarx, mostrary y obtradio de la instancia
circulo.
c) Seleccione el objeto botoncilindro, dé doble clic para abrir el editor del

procedimiento botoncilindro_Click y escriba el siguiente código:
Dim cilindro As Cilindro
Dim valoraltura, valorradio, valorx, valory As Double
valoraltura = Val(txtaltura.Text)
valorradio = Val(txtradiocilindro.Text)
valorx = Val(txtcilindrox.Text)
valory = Val(txtcilindroy.Text)
cilindro = New Cilindro(valoraltura, valorradio, valorx, valory)
txtxyradiocilindro.Text = cilindro.cadena()
txtareacilindro.Text = cilindro.area()
txtvolumen.Text = cilindro.volumen()
Se crea una instancia de tipo Cilindro llamada cilindro. Se declaran las

variables valoraltura, valorradio, valorx y valory de tipo Double y se le asigna los
valores de los objetos txtaltura, txtradiocilindro, txtcirculox, txtcirculoy en su
propiedad Text respectivamente. Se asigna espacio de memoria (New) al objeto
cilindro y se le envía al constructor de la clase Cilindro los valores de valoraltura,
valorradio, valorx y valory. Por otro lado, se le asigna a la propiedad Text de los
objetos txtxyradiocilindro, txtareacilindro, y txtvolumen respectivamente lo que
retorna los procedimientos cadena, area y volumen de la instancia cilindro.
215
Al ejecutar el proyecto y digitar los valores 3, 2 en la ficha Puntos y pulsar el botón

Clase Puntos, se visualizará la siguiente figura:
Figura 11.15 Ejecución aplicación HerenciaClases.
Al pulsarse la ficha Círculo, se deben visualizar los valores de las coordenadas X, Y.
Figura 11.16 Coordenadas X, Y de la clase Puntos.
Si se digita el valor de radio 4 y se pulsa el botón Clase Circulo, se obtendrá la

siguiente figura:
216
Figura 11.17 Valores de la ficha Circulo.
En este momento en la ficha Cilindro se deben visualizar los valores de las

coordenadas X, Y y el radio. Al digitarse 5 como valor de altura y pulsar el botón Clase
Cilindro, se visualizará la siguiente figura:
Figura 11.18 Valores de la ficha Cilindro.
11.4 Interfaces
Las Interfaces definen las propiedades, métodos y eventos que pueden implementar las
clases. Se pueden agregar nuevas características en cualquier momento mediante el
desarrollo de implementaciones e interfaces adicionales. Las definiciones de interfaz se
217
encuentran dentro de las instrucciones Interface y End Interface. Después de la
instrucción Interface, puede agregar una instrucción Inherits opcional que proporcione
una lista de una o varias interfaces heredadas. En la definición de una interfaz deben
existir únicamente instrucciones Event, Sub, Function, Property, Interface, Class,
Structure y Enum. Las interfaces no pueden contener código de implementación. Las
interfaces se pueden definir dentro de clases, módulos, interfaces y estructuras. De
manera predeterminada son públicas (Public), pero también se pueden declarar como
Friend, Protected o Private.
La palabra clave Implements se utiliza para indicar que un miembro de una clase
implementa una interfaz específica. Una instrucción Implements requiere una lista
separada por comas de los miembros de la interfaz que deben implementarse. La
especificación de un miembro de interfaz consiste en el nombre de la interfaz, que debe
especificarse en una instrucción Implements junto con la clase, un punto y el nombre
del evento, propiedad o función que se desea implementar.
.
Ejemplo:
Interface Película
Function video()
End Interface
Public class MisPeliculas implements Película
:::::::::::
Public Function video implements Película.video
<Código…..>
End Function
::::::::::::
End Class
11.5 Ejemplo práctico de interfaces
Elaborar una aplicación llamada Interfaces que permita a un usuario digitar la base y la
altura y obtener el área de un Rectángulo y un Triángulo utilizando interfaces.
Utilizando el cuadro de herramientas agregue al formulario los siguientes controles: 1

Button, 4 TextBox y 4 Label.

Tabla 11.5 Propiedades de los controles de la aplicación Interfaces.

Button1 Name botonarea
Text Calcular Area
Label1 Name lblbase
Text Dígite Base:
Label2 Name lblaltura
Text Dígite Atura:
Label3 Name lblareatriangulo
Text Area del Triángulo (b*a):
218
Label4 Name lblarearectangulo
Text Area del Rectángulo ((b*a)/2):
TextBox1 Name txtbase
Textbox2 Name txtaltura
TextBox3 Name txtareatriangulo
TextBox4 Name txtarearectangulo
Text Interface – Area Triángulo/Rectángulo
Figura 11.19 Interfaz de usuario Interfaces.
 Agregar Interface
Para crear una interface puede realizar alguno de los siguientes pasos:
4. Del menú Proyecto seleccione Agregar nuevo elemento…- Interfaz.
5. Del icono seleccionar Agregar nuevo elemento… – Interfaz.
derecho, seleccionar la opción Agregar nuevo elemento… - Interfaz.
Figura 11.20 Ventana para agregar una Interface.
219
En el cuadro de texto Nombre cambie el nombre a la interfaz por
interfacefigura, luego pulse el botón Agregar para visualizar una nueva interfaz en el
editor de código y en la lista del Explorador de soluciones aparece un nuevo archivo
con el nombre de la interfaz.
Figura 11.21 Editor de código de la Interface interfacefigura.
 Escribir código para la Interface
Entre las instrucciones Public Interface y End Interface, escriba el siguiente código:
Public Interface interfacefigura

Function area()
End Interface
Se define el procedimiento Function area (). Recuerde que no se pueden

implementar el procedimiento.
 Agregar Clases
a) Agregue una nueva clase, en el cuadro de texto Nombre cambie el nombre a la

clase por Rectangulo, luego pulse el botón Agregar para visualizar un nuevo
 Escribir código para la clase Rectangulo
Entre las instrucciones Public Class Rectangulo y End Class, escriba el siguiente
código:
Public Class Rectangulo

Implements interfacefigura
Dim base, altura As Double
Public Sub New(ByVal b As Double, ByVal a As Double)
base = b
altura = a
End Sub
Public Function area() Implements interfacefigura.area
Return base * altura
End Function
End Class
Se define la clase Rectangulo y se implementa la interfaz interfacefigura. Se

declaran dos variables (base, altura) de tipo Double para guardar los valores digitados
por el usuario respectivamente. Por otro lado, se definen los siguientes procedimientos:
220
 Constructor New: que recibe dos parámetros de tipo Double y asigna dichos valores
a las variables base, altura respectivamente.
 area: se implementa el procedimiento area definido en la interfaz interfacefigura
el cual retorna el resultado de multiplicar la base por la altura.
b) Agregue otra nueva clase, en el cuadro de texto Nombre cambie el nombre a la

clase por Triangulo, luego pulse el botón Agregar para visualizar un nuevo
módulo de interfaz en el editor de código y en la lista del Explorador de
soluciones aparece un nuevo archivo con el nombre de la interfaz.
 Escribir código para la clase Rectangulo
Public Class Triangulo

Implements interfacefigura
Public Sub New(ByVal b As Double, ByVal a As Double)
base = b
altura = a
End Sub
Public Function area() Implements interfacefigura.area
Return (base * altura) / 2
End Function
End Class
Se define la clase Triangulo y se implementa la interfaz interfacefigura. Se

declaran dos variables (base, altura) de tipo Double para guardar los valores digitados
por el usuario respectivamente. Por otro lado, se definen los siguientes procedimientos:
 Constructor New: que recibe dos parámetros de tipo Double y asigna dichos valores
a las variables base, altura respectivamente.
 area: se reescribe el procedimiento area definido en la interfaz interfacefigura el
cual retorna el resultado de la operación ((base *altura)/2).
 Escribir código para el botón.
Seleccione el objeto botonarea, dé doble clic para abrir el editor del procedimiento
botonarea_Click y escriba el siguiente código:
Dim triangulo As Triangulo

Dim rectangulo As Rectangulo
base = txtbase.Text
altura = txtaltura.Text
triangulo = New Triangulo(base, altura)
rectangulo = New Rectangulo(base, altura)
txtareatriangulo.Text = triangulo.area
txtarearectangulo.Text = rectangulo.area
Se crean las instancias triangulo de tipo Triangulo y rectangulo de tipo

Rectangulo. Por otro se crean las variables base, altura y se le asignan los valores
digitados en las cajas de texto txtbase, txtaltura. Se asigna espacio de memoria a los
objetos triangulo y rectangulo y se envía a el respectivo constructor los valores de las
variables base y altura. A la propiedad Text de los objetos txtareatriangulo y
txtarearectangulo se le asigna el valor que retorne el procedimiento area de la
respectiva clase.
221
Al ejecutar el proyecto y digitar los valores 8,14 en la respectiva caja de texto y pulsar
el botón Calcular Area, se visualizará la siguiente figura:
Figura 11.22 Ejecución aplicación Interfaces.
11.6 Ejercicios P.O.O
1. Crear un programa que contenga una superclase Figura donde se herede las
figuras de rectángulos, cuadrados, triángulos y círculos. El usuario podrá
escoger la posición, la figura y los caracteres de relleno que se usarán para
dibujar cada figura.
2. Realizar un programa utilizando herencia que decida si dos números son amigos.
Dos números son amigos si la suma de los divisores del primer número,
excluido él, es igual al segundo número y viceversa; es decir, si la suma de los
divisores del segundo número, excluido él es igual al primer número.
3. Escribir un programa que permita capturar la hora, los minutos y los segundos
en formato de 24 horas. En una clase se deben realizar las operaciones para
retornar al programa las horas, los minutos y los segundos un segundo después.
Nota: las horas van entre 0 y 23 y los minutos y segundos entre 0 y 59.
4. Hacer un programa utilizando herencia que lea un número no mayor de 1000 e
imprima ese número en letras.
5. Crear una clase llamada Rectangulo que contenga los atributos longitud y ancho,
cada uno de los cuales debe ser inicializado con 1. Deberá contener métodos
para calcular el perímetro y el área del rectángulo, los métodos deben verificar
que la longitud y la altura sean números flotantes entre 0.0 y 20.0. Deberá
escribir un programa que permita utilizar la clase Rectangulo.
6. Elaborar un programa que dibuje líneas, rectángulos, óvalos al azar. Para este
fin, cree un conjunto de clases que permitan dibujar cada una de las figuras. Se
Puede utilizar instancias o herencia.
7. Diseñar un programa que permita capturar un número y por medio de clases
imprima el factorial de dicho número.
8. Realizar un programa que capture 10 números y utilizando clases imprima el
mayor y el menor de dichos números.
9. Escribir un programa que permita capturar tres valores (a, b, c) e imprima las
raíces de la cuadrática utilizando clases.
10. Hacer un programa utilizando clases que permita capturar tres datos (nombre,
edad, sexo) y los guarde en un archivo de texto.
222
12. ACCESO A BASES DE DATOS CON VB.NET
Una base de datos es un sistema formado por un conjunto de datos relacionados y

almacenados en discos que permiten el acceso directo a ellos y una serie de programas
que manipulan ese conjunto de datos. Cada base de datos se compone de una o más
tablas que guardan la información. Cada tabla contiene una o más columnas y filas. Las
columnas guardan información sobre cada elemento que se quiere almacenar en la tabla,
cada fila conforma un registro. Donde un registro es un o una a serie de campos que
pueden contener un mismo tipo dato o tipos de datos diferentes.
12.1 Tipos de Bases de Datos.
Las bases datos más comunes son las relacionales y existen varios sistemas de
administración de bases de datos de ese tipo, algunos son: SQL Server, Access, Oracle,
MySQL, PostgresSQL, etc.
12.1.1 bases de datos relacionales
Las bases de datos relacionales son un conjunto de tablas relacionadas entre sí, donde
cada tabla está definida por una serie de campos. Los campos forman las columnas de
las tablas. Las filas se denominan registros (tuplas), y cada tipo definido en un registro
es un atributo. Las tablas pertenecientes a una base de datos pueden relacionarse entre sí
utilizando campos clave comunes entre las tablas.
12.1.2 bases de datos orientadas a objetos.
Una base de datos orientada a objetos es un conjunto de clases que definen las
características y el comportamiento de los objetos que desarrollarán la base de datos.
Con una base de datos orientada a objetos, los objetos memorizados en la base de datos
contienen los datos como también las operaciones posibles con dichos datos.
12.2 Lenguaje de consulta estructurado (S.Q.L.)
Es un lenguaje normalizado que es utilizado por diferentes motores de bases de datos

para realizar operaciones sobre los datos o sobre la estructura de los mismos. El
lenguaje SQL está compuesto por comandos, cláusulas, operadores y funciones de
agregado. Estos elementos se combinan en las instrucciones para crear, actualizar filtrar
y eliminar tablas o datos de una base de datos.
12.2.1 Comandos S.Q.L
Los tipos de comandos SQL son:
 DDL: permiten crear y definir nuevas bases de datos, tablas, campos e índices.
 DML: permiten generar consultas para ordenar, filtrar y extraer datos de la base de
datos.
223
Tabla 12.1 Comandos DDL y DML de SQL.
Comandos DDL
Comando Descripción
CREATE Permite crear nuevas bases de datos, tablas, campos e índices.
DROP Elimina bases de datos, tablas e índices.
Modifica las tablas agregando campos o cambiando la definición de los
ALTER
campos.
Comandos DML
Permite consultar registros de una base de datos que cumplan una condición
SELECT
determinada.
INSERT Inserta datos en una base de datos en una única operación.
UPDATE Actualiza o modifica los valores de los campos y registros especificados.
DELETE Elimina registros de una tabla de una base de datos.
12.2.2 Cláusulas S.Q.L
Las cláusulas son operadores de modificación que sirven para definir los datos que se
desean seleccionar o renovar.
Tabla 12.2 Cláusulas SQL.
Cláusula Descripción
Sirve para especificar el orgen de datos (tabla) de la cual se van a
FROM
seleccionar registros.
Permite especificar condiciones que deben cumplir los registros a
WHERE
seleccionar.
GROUP BY Separa los registros seleccionados en grupos específicos.
HAVING Expresa la condición que debe cumplir cada grupo de registros.
ORDER BY Ordena los registros seleccionados.
12.2.3 Operadores lógicos S.Q.L
Los operadores lógicos permiten comprobar si una(s) condición(es) son verdaderas.

Éstos operadores retornan un valor Boolean TRUE o FALSE.
224
Tabla 12.3 Operadores lógicos SQL.
Operador Uso
Evalúa dos condiciones y devuelve un valor de verdad sólo si ambas
AND
son ciertas.
Evalúa dos condiciones y devuelve un valor de verdad si alguna de
OR
las dos es cierta.
NOT Negación lógica. Devuelve el valor contrario de la expresión.
BETWEEN Permite especificar un intervalo de valores.
LIKE Realiza una comparación de un patrón.
IN Se utiliza para describir registros de una base de datos.
Devuelve Verdadero (True) si el conjunto de comparaciones de un
ALL
origen de datos es verdad.
12.2.4 Operadores de comparación S.Q.L
Estos operadores comprueban si dos expresiones son iguales, devolviendo un valor

booleano True o False.
Tabla 12.4 Operadores de comparación SQL.
Operador Uso
< Menor que
> Mayor que
<> Distinto de
<= Menor o igual que
>= Mayor o igual que
= Igual que
12.2.5 Funciones de agregado S.Q.L
Estas funciones realizan un cálculo sobre un conjunto de valores y devuelven un único

valor. Las funciones de agregado se suelen utilizar con la cláusula GROUP BY de la
instrucción SELECT.
Tabla 12.5 Funciones de agregado SQL.
Función Descripción
AVG Calcula el promedio de los valores de un campo determinado.
COUNT Devuelve el número de registros de la selección.
SUM Suma todos los valores númericos de un campo determinado.
225
MAX Obtiene el valor más alto de un campo especificado.
MIN Obtiene el valor más bajo de un campo especificado.
12.3 Sentencias básicas S.Q.L
A continuación se realizarán ejemplos con algunas de las sentencias SQL para la

manipulación de los datos de una tabla. Se supondrá que se tiene creada una tabla
llamada usuarios que esta estructurada como se muestra a continuación:
Tabla 12.6 Estructura de los campos de la tabla USUARIOS.
Campo Tipo de Dato Longitud

identificacion varchar 15
Nombres varchar 20
Apellidos varchar 20
Dirección varchar 25
Teléfono varchar 20
ciudad_nac varchar 20
fecha_nac date
Y que contiene la siguiente información:
Tabla 12.7 Información de la tabla usuarios.
Identificación Nombres Apellidos Dirección Teléfono Ciudad_nac Fecha_nac

100 Carlos Romero Cra 7 # 20-10 4152584 Bogota 01/02/1980
101 María Castro Calle 25 # 25-10 3692581 Cali 15/03/1984
112 José Peláez Av. 35 # 32-45 1234567 Medellín 20/05/1960
114 Cristian Vanegas Cra 7 # 29-58 9874561 Manizales 31/08/1974
116 Rosa Cetina Calle 17 # 21-14 3571596 Buga 15/12/1985
118 Andrés Vanegas Tranvs 48 # 22-10 8527419 Bogotá 10/04/1978
130 Angélica Morales Cra 68 # 21-11 6549518 Medellín 20/06/1981
150 Johana Duarte Cra 2 # 45-38 9637534 Bogotá 12/06/1988
170 Mario Vargas Calle 1 # 99-18 6598743 Medellín 28/08/1980
12.3.1 CREATE DATABASE
CREATE DATABASE permite crear una base de datos. Su formato es:

CREATE DATABASE <nombre_base_de_datos)
12.3.2 DROP DATABASE
DROP DATABASE permite eliminar una base de datos que previamente se había
creado. Su formato es:
DROP DATABASE <nombre_base_de_datos_a_eliminar>
12.3.3 CREATE TABLE
CREATE TABLE permite crear una tabla. Con este comando se especifica el nombre
de la tabla, las columnas y los tipos de datos, sus claves primarias y si es necesario una
226
clave externa. Su formato es:
CREATE TABLE nombre_tabla (campo1 tipodato DEFAULT,., campo2 tipodato, DEFAULT)
La cláusula DEFAULT indica la característica de cada columna: NOT NULL

(no permite valores nulos), UNIQUE (dos filas no pueden tener un mismo valor en la
misma columna), PRIMARY KEY (define una columna como clave principal).
12.3.4 DROP TABLE
DROP TABLE permite eliminar una tabla que previamente se había creado. Su
formato es:
DROP TABLE nombre_tabla
12.3.5 INSERT
INSERT permite insertar datos en una tabla. Su formato es:
INSERT INTO nombre_tabla (campo1, campo2,….) VALUES (valor1, valor2,….)
12.3.6 ALTER
SQL ALTER permite insertar un nuevo campo en una tabla. Su formato es:
ALTER TABLE nombre_tabla ADD nombre_campo tipo_de_dato ()
Para insertar un nuevo campo a la tabla usuarios llamado profesion de tipo

caracter se debería realizar la siguiente sentencia:
ALTER TABLE usuarios ADD profesion varchar (30)
12.3.7 SELECT
La instrucción de selección SELECT permite seleccionar datos de una tabla. Su

formato es:
SELECT campos_tabla FROM nombre_tabla
A continuación se realizan algunos ejemplos:
a. Para visualizar toda la información que contiene la tabla usuarios se puede

incluir con la instrucción SELECT el carácter ‘*’ o cada uno de los campos de la
tabla.
SELECT * FROM usuarios
O
SELECT identificación, nombres,…….. FROM usuarios
b. Para visualizar solamente la identificación del usuario
SELECT identificacion FROM usuarios
227
c. Si se desea obtener los registros cuya identificación sea mayores o iguales a 150,
se debe utilizar la cláusula WHERE que especifica las condiciones que deben
reunir los registros que se van a seleccionar.
SELECT * FROM usuarios WHERE identificación>=’150’
d. Si se desea obtener los registros cuyos apellidos sean Vanegas o Cetina, se debe
utilizar el operador IN que especifica los registros que se quieren visualizar de
una tabla.
SELECT apellidos FROM usuarios WHERE apellidos IN (‘Vanegas,’Cetina’)
O se puede utilizar el operador OR

SELECT * FROM usuarios WHERE apellidos=‘Vanegas’ OR apellidos=’Cetina’
e. Si se desea obtener los registros cuya identificación sea menor de ‘110’ y la

ciudad sea ‘Cali’, se debe utilizar el operador AND.
SELECT * FROM usuarios WHERE identificación<=‘110’ AND ciudad=’Cali’
f. Si se desea obtener los registros cuyos nombres empiecen por la letra ‘A’, se
debe utilizar el operador LIKE que utiliza los patrones ‘%’ (todos) y ‘_’
(carácter).
SELECT * FROM usuarios WHERE nombres LIKE ‘A%’
g. Si se desea obtener los registros cuyos nombres contenga la letra ‘a’.
SELECT * FROM usuarios WHERE nombres LIKE ‘%a%’
h. Si se desea obtener los registros donde la cuarta letra del nombre sea una ‘a’.
i.
SELECT * FROM usuarios WHERE nombres LIKE ___a%’
j. Si se desea obtener los registros cuya identificación este entre el intervalo 110 y
150, se debe utilizar la cláusula BETWEEN, que sirve para especificar un
intervalo de valores.
SELECT * FROM usuarios WHERE identificación BETWEEN ’110’ AND ‘150’
12.3.8 DELETE
La sentencia SQL de eliminación de datos DELETE permite borrar todos o un grupo

especifico de registros de una tabla. Su formato es:
DELETE FROM nombre_tabla
A continuación se realizarán algunos ejemplos:

a. Para eliminar todos los registros de la tabla usuarios.
DELETE FROM usuarios
228
b. Para eliminar solamente los registros cuya identificación sea mayor de ‘180’.
DELETE FROM usuarios WHERE identificación >’180’
c. Para eliminar los registros diferentes del nombre “Rosa”
DELETE FROM usuarios WHERE nombres NOT IN (‘Rosa’)
12.3.9 UPDATE
La sentencia SQL de actualización UPDATE permite actualizar un campo de una tabla.

Su formato es:
UPDATE nombre_tabla SET nombre_campo=valor
A continuación se realizan algunos ejemplos:
a. Para actualizar el campo credito en 100000 para los registros cuyo nombre
empiecen por ‘A’.
UPDATE usuarios SET credito=credito +100000 WHERE nombres LIKE ‘A%’
b. Para actualizar el campo credito en -50000 para los registros cuya ciudad sea
igual a ‘Buga’.
UPDATE usuarios SET credito=credito-50000 WHERE ciudad=’Buga’
12.3.10 INNER JOIN
Permite obtener datos de 2 ó más tablas. Cuando se realiza la concatenación de las

tablas, no necesariamente se deben mostrar todos los datos de las tablas. Su formato es:
SELECT tabla1.campo, tabla2.campo, tabla1.campo2,…. FROM tablaprincipal

INNER JOIN tablasecundaria ON campocomuntabla1=campocomuntabla2
Para realizar algunos ejemplos explicativos se utilizará la tabla usuarios y

además, se supondrá que se tiene otra tabla llamada pedidos, que contendrá la siguiente
estructura:
Tabla 12.8 Estructura de los campos de la tabla PEDIDOS.
Campo Tipo de Dato Longitud

nropedido varchar 15
identificacion varchar 15
fechacompra date 20
fechavence date 25
observacion varchar 30
Y que contiene la siguiente información:
229
Tabla 12.9 Información de la tabla pedidos.
nropedido Identificación fechacompra fechavence observacion

10 100 01/02/2006 01/02/2006 Pago de contado
20 101 15/03/2006 15/03/2006 Descuento del 5%
30 100 20/05/2006 20/06/2006 Descuento del 2%
40 112 31/08/2006 31/10/2006 Pago a sesenta días
50 101 15/12/2006 30/12/2006 Pago de contado
60 118 10/04/2006 10/06/2006 Sin descuento
70 101 20/06/2006 20/07/2006 Descuento del 5%
80 100 12/06/2006 12/09/2006 Pago a noventa días
90 101 28/08/2006 28/09/2006 Pago de contado
a. Para visualizar los campos identificación, nombres, apellidos de la tabla

usuarios y nropedido, fecha de compra, fecha de vencimiento y observación de
la tabla pedidos, se debe realizar la siguiente instrucción:
SELECT usuarios.identificacion, usuarios.nombres, usuarios.apellidos,

pedidos.nropedido, pedidos.fechacompra, pedidos.fechavence,
pedidos.observacion
FROM usuarios INNER JOIN pedidos
ON usuarios.identificacion = pedidos.identificacion
b. Para visualizar todos campos de las tablas usuarios y pedidos donde

identificación sea mayor que 100, se debe realizar la siguiente instrucción:
SELECT usuarios.*, pedidos.*

FROM usuarios INNER JOIN pedidos
ON usuarios.identificacion = pedidos.identificacion
WHERE usuarios.identificacion>100
12.4 Conexión a bases de datos con VB.NET
Visual Basic .NET trabaj con la tecnología ADO.NET (Activex Data Object) para el
el acceso a una base de datos utilizando los proveedores administradores de bases de
datos que funcionan en el entorno .NET. La plataforma .NET incorpora cuatro
proveedores: SQL SERVER, ORACLE, ODBC (Access), OLEDB.
ADO.NET proporciona acceso a orígenes de datos como Microsoft SQL Server

y XML, así como a orígenes de datos OLE DB y ODBC. Se puede utiliza ADO.NET
para conectar a los orígenes de datos y recuperar, manipular y actualizar los datos
contenidos.
ADO.NET es un conjunto de clases que se encuentran en el archivo

System.Data.dll y está integrada con las clases del archivo System.Xml.dll. Cuando se
compila código que utiliza el espacio de nombres System.Data que hace referencia a
dichos archivos.
Sus principales clases son:
 DataSet: conjunto de datos donde se pueden incluir una o más tablas con la
información acerca de las relaciones entre estas, y las restricciones que puedan
tener los datos.
230
 DataTable: permite la manipulación de los datos en la memoria y realiza
operaciones como la exploración, ordenación, edición, filtrado, etc.
 DataView: permite representar los datos de la clase DataTable, creando

múltiples vistas de los mismos.
Los proveedores de datos proporcionan el puente entre las bases de datos y las
aplicaciones. Los principales objetos de un proveedor de datos .NET son:
 Connection: sirve para establecer una conexión con una base de datos. Se utiliza
SqlConnection para una conexión a SQL Server, OleDbConnection para una
conexión a Access y OracleConnection para Oracle.
 Command: sirve para ejecutar sentencias SQL y devolver resultados. Se utiliza

SqlCommand para una conexión a SQL Server, OleDbCommand para una
conexión a Access y OracleCommand para Oracle.
 DataAdapter: es un adaptador de datos, el cual es un conjunto de objetos para

intercambiar datos entre una base de datos y un conjunto de datos. Se utiliza
SqlDataAdapter para una conexión a SQL Server, OleDataAdapter para una
conexión a Access y OracleDataAdapter para Oracle.
12.5 Ejemplos prácticos de bases de datos
12.5.1 Conexión a una base de datos SQL Server por código
Dentro de un proyecto llamado ConexionASQLServer, realizar un programa que

permita realizar una conexión a una base de datos de SQL Server llamada
bdlibrovbnet.mdf y visualizar los registros de la tabla clientes en un control
DataGridView.
NOTA: para este ejemplo el usuario tiene que tener instalado Microsoft SQL
SERVER 2005 o posterior y crear una base de datos llamada bdlibrovbnet y dentro de
ella una tabla llamada clientes (Ver anexo A, SQL Server).

siguientes controles en el formulario en la posición deseada: 1 Button, 2 Label y 1
DataGridView.
Establezca las siguientes modificaciones a los controles:
231
Tabla 12.10 Propiedades de controles proyecto ConexionASQLServer.
DataGridView1 Name datos
Button1 Name botoncargar
Text Cargar registros tabla.
Label1 Name lblbd
Text Conexión a la base de datos bdlibrovbnet.mdf de SQL
SERVER.
Font True
Label2 Name lbltabla
Text Tabla : Clientes
Font True
Text Conexión a una base de datos SQL SERVER.
Figura 12.1 Interfaz de usuario ConexionASQLServer.
a) Antes de la apertura de la clase formulario se debe importar el espacio de
nombres System.Data.SqlClient:
Imports System.Data.SqlClient
Public Class Formulario
….
……
End Class
El espacio de nombres System.Data.SqlClient es necesario para utilizar las

diferentes clases que permitan las operaciones con bases de datos; en este caso, SQL
Server.
b) Seleccione el objeto botoncargar, dé doble clic para abrir el editor de código y

Dim conexion As String
conexion = "Data Source=(local)\SQLEXPRESS;Database=bdlibrovbnet;
Integrated Security=True"
Dim seleccion As String = "SELECT * FROM clientes"
Dim adaptadordedatos As SqlDataAdapter
Dim tabladedatos As New DataTable
232
Try
adaptadordedatos = New SqlDataAdapter(seleccion, conexion)
adaptadordedatos.Fill(tabladedatos)
tabla.DataSource = tabladedatos
MsgBox("Error: " & ex.Message)
End Try
Se crea una variable llamada conexion de tipo String que contendrá la cadena
de conexión a la base de datos bdlibrovbnet.mdf de SQL Server. La cadena de
conexión debe contener como mínimo los siguientes parámetros:
 Data Source: Se le asigna la ruta donde se encuentra el servidor SQL Server; en

este caso, SQL Server se instalo en el computador de trabajo por lo cual el nombre
del servidor es local.
 Database: Se le asigna el nombre de la base de datos a la que se quiere conectar.
 Integrated Security: Se le asigna True o False para determinar si la seguridad es
integrada o no.
Luego se crean los siguientes objetos: seleccion de tipo String a la cual se le

asigna la información que se quiere mostrar; en este caso todos los registros de la tabla
clientes (Select * from Clientes); adaptadordedatos de tipo SqlDataAdapter el cual
será el adaptador de datos para la base de datos a manipular; tabladedatos se le asigna
espacio de memoria de tipo DataTable para guardar los datos en memoria y poder
realizar operaciones con dichos datos. En un bloque Try se le asigna espacio de
memoria de tipo SqlDataAdapter al objeto adaptadordedatos, al cual se le envía
como parámetros los objetos seleccion (datos a mostrar) y conexion (cadena de
conexión), luego se rellena (fill) el adaptador de datos con la tabla de datos
(tabladedatos) y por último al objeto datos en su propiedad DataSource se le establece
el conjunto de datos que se van a mostrar al asignársele la tabla de datos. Por el bloque
Catch se establece un mensaje en caso de que ocurra un error.
Al ejecutarse el proyecto y pulsar el botón Cargar registros tabla, se visualizará el

formulario con los registros de la tabla clientes:
Figura 12.2 Formulario con los registros de la tabla clientes.
233
12.5.2. Conexión a SQL Server utilizando el explorador de servidores
Elaborar un proyecto llamado ConexionBDExploradorServidores y realizar un

programa que permita a un usuario realizar una conexión a una base de datos de SQL
Server y mostrar los registros de una tabla en un objeto DataGridView utilizando el
Explorador de servidores.
NOTA: para este ejemplo se utilizará la base de datos SQL Server llamada
bdlibrovbnet.mdf (Ver anexo A, SQL Server). De está base de datos se utilizará la
tabla clientes.

siguientes controles en el formulario en la posición deseada: 1 Label y 1
DataGridView.
Tabla 12.11 Propiedades de los controles de ConexionBDExploradorServidores.

DataGridView1 Name datos
Label1 Name lblbd
Text Conexión a SQL Server utilizando el
Explorador de servidores.
Font True
Text Conexión a SQL Server - Explorador de
servidores.
Figura 12.3 Interfaz de usuario (ConexionBDExploradorServidores).
234
 Explorador de servidores
Del menú Ver seleccione la opción Explorador de servidores o pulse simultáneamente

las teclas Ctrl+Alt+S, para visualizar la siguiente figura:
Figura 12.4 Ventana del Explorador de servidores.
Pulse el icono conectar con bases de datos , para visualizar la ventana de

Agregar conexión como muestra la figura:
Figura 12.4 Ventana Agregar conexión.
En esta ventana se pueden realizar lo siguiente:
 Elegir proveedor base de datos: se puede elegir el proveedor de la base de datos.

Por omisión se cargar el sistema administrador de base de datos SQL Server.
 Elegir base de datos: permite elegir la base de datos a utilizar.
 Probar la conexión: permite saber si una conexión ha sido exitosa o no.
 Modificar la cadena de conexión: con la opción Avanzadas se puede modificar la
235
conexión a la base de datos.
Para el ejemplo seleccione la base de datos bdlibrovbnet.mdf la cual se

encuentra en la carpeta Data de SQL Server (si la instalación la realizo en c:\ la ruta
sería: C:\Archivos de programa\Microsoft SQL Server\MSSQL.1\MSSQL\Data).
Figura 12.5 Ventana con la base de datos seleccionada.
Pulse el botón Aceptar para visualizar la siguiente figura:
Figura 12.6 Explorador de servidores con la conexión a una base de datos.
Al pulsar en el signo (+) al lado del nombre de la base de datos se visualizará la

estructura definida en la base de datos. Si desea ver las tablas que contiene la base de
datos pulse el signo (+) al lado de Tablas.
236
Figura 12.7 Estructura de la base de datos bdlibrovbnet.mdf.
 Obtener el origen de datos para el DataGridView
Seleccione el objeto DataGridView llamado datos y en la flecha que aparece en el lado

superior derecho, dé clic para visualizar las Tareas de DataGridView:
Figura 12.8 Ventana Tareas de DataGridView.
Escoja la opción Elegir orígen de datos, para visualizar la siguiente figura:
237
Figura 12.9 Ventana Elegir orígen de datos.
Dé clic sobre el link Agregar orígen de datos del proyecto, se visualizará la

siguiente ventana:
Figura 12.10 Asistente para la configuración de orígenes de datos.
Seleccione el objeto Base de datos y pulse el botón Siguiente>, para visualizar

la ventana de elección de la conexión de datos. Seleccione la base de datos
bdlibrovbnet.mdf:
238
Figura 12.11 Ventana Elegir la conexión de datos.
Al Seleccionar la base de datos que se va a trabajar y pulsando el botón

Siguiente> se visualizará el siguiente mensaje:
Figura 12.12 Ventana para copiar el archivo de datos al proyecto.
Pulse el botón Sí para copiar el archivo de datos en la carpeta en donde guardó el

proyecto y se visualizará la ventana de guardar cadena de conexión:
Figura 12.13 Ventana Guardar cadena de conexión.
239
Cambie el nombre de la conexión que allí aparece por cadenaconexion y pulse el botón
Siguiente>, se visualizará la siguiente figura:
Figura 12.14 Ventana de elección de objetos de la base de datos.
Pulse el signo (+) al lado de Tablas para desplegar las tablas de la base de datos
y seleccione la tabla clientes. Por otro lado, cambie el nombre del DataSet que allí
aparece por datosclientes y pulse el botón Finalizar para visualizar la siguiente figura:
Figura 12.15 DataGridView con los campos de la tabla clientes.
Como se puede apreciar, se crearon tres nuevos objetos: el objeto Datosclientes

que contendrá los datos seleccionados, el objeto ClientesBindingSource que en su
propiedad DataSource se le asignará el objeto Datosclientes y en la propiedad
240
DataMember el nombre de tabla seleccionada. Por otro lado, se creó el objeto
ClientesTableAdapter, el cual será el adaptador de datos para la conexión realizada.
Al ejecutarse el proyecto, se visualizará en el formulario los datos de la tabla clientes en

el objeto DataGridView de la base de datos bdlibrovbnet.mdf de SQL Server:
Figura 12.16 DataGridView con los registros de la tabla clientes.
12.5.3 Conexión a una base de datos con DataGridView y BindingNavigator
Diseñar un proyecto llamado ConexionAutomatica y realizar un programa que permita

a un usuario realizar una conexión a una base de datos de SQL Server y mostrar los
registros de una tabla llamada clientes en un objeto DataGridView, además se debe
poder desplazar por los registros de dicha tabla utilizando el control BindingNavigator.
bdlibrovbnet y su tabla clientes (Ver anexo A, SQL Server).
Modifique las siguientes propiedades del formulario:
Tabla 12.12 Propiedades modificadas del formulario.

Text Conexión a una base de datos SQL
Server.
 Conectarse a la base de datos.
Del menú Ver seleccione la opción Explorador de servidores para visualizar la

siguiente figura:
241
Figura 12.17 Ventana Explorador de servidores.
Al pulsar el icono conectar con bases de datos , se visualizará la ventana de

Agregar conexión como muestra la figura:
Seleccione la base de datos bdlibrovbnet.mdf, la cual se encuentra en la carpeta

data de SQL Server (si la instalación la realizó en c:\ la ruta sería: C:\Archivos de
programa\Microsoft SQL Server\MSSQL.1\MSSQL\Data. Pulse el botón Aceptar para
visualizar la siguiente figura:
242
Figura 12.19 Explorador de servidor - conexión a la base de datos SQL Server.
Al pulsar en el signo (+) al lado del nombre bdlibrovbnet.mdf se visualizará la

 Configurar orígen de datos
Del menú Datos seleccione la opción Agregar nuevo orígen de datos…, para

la ventana Elegir conexión de datos. En la ventana se debe seleccionar la base de datos
bdlibrovbnet.mdf:
243
Pulse el botón Siguiente> para visualizar el siguiente mensaje:
Figura 12.22 Ventana para copiar la conexión al proyecto.
Pulse el botón Sí para copiar el archivo de datos en la carpeta donde guardó el

proyecto. Se mostrará la ventana Guardar cadena de conexión en el archivo config de la
aplicación:
Figura 12.23. Ventana Guardar cadena de conexión.
244
Cambie el nombre de la conexión que allí aparece por conexionsqlserver y
pulse el botón Siguiente>, se visualizará la siguiente figura:
Figura 12.24. Ventana de elección de objetos de la base de datos.
aparece por conjuntodedatos y pulse el botón Finalizar para visualizar la siguiente
figura:
Figura 12.25. Proyecto con la base de datos y el orígen de datos agregados.
Nuevamente del menú Datos seleccione la opción Mostrar orígenes de datos,

para visualizar la siguiente figura:
245
Figura 12.26 Proyecto con la base de datos y el orígen de datos agregados.
En la parte izquierda aparece la ventana Orígenes de datos. Allí estará la tabla

que se había seleccionado. Pulse el signo (+) al lado de la tabla clientes para desplegar
los campos.
Dé clic sobre la tabla clientes, pulse el botón izquierdo del mouse y arrastre el
mouse hacia el formulario y automáticamente se crearán los siguientes objetos: un
control DataGridView, un BindingNavigator (ClientesBindingNavigator –
representa una manera normalizada para navegar y manipular los datos en un
formulario), un DataSet (conjuntodedatos – representa un conjunto de datos
recuperados de un orígen de datos), un BindingSource (ClientesBindingsource –
encapsula el orígen de datos y proporciona las funciones de navegación, filtrado,
ordenación y actualización de los datos), un TableAdapter (ClientesTableAdapter –
crea una nueva tabla con los datos devueltos), un AdapterManager
(ClientesAdapterManeger – administrador del adaptador de datos).
Figura 12.27 Aplicación con los objetos creados automáticamente.
246
Al ejecutarse el proyecto, se visualizará en el formulario los datos de la tabla clientes en

el objeto DataGridView de la base de datos bdlibrovbnet.mdf de SQL Server:
Figura 12.28 Ejecución de la aplicación ConexionAutomatica.
Con los iconos del objeto BindingSource se podrá desplazar por cada uno de los
registros de la tabla.
Estando en modo edición se pudo apreciar en la ventana Orígenes de datos que

al pulsar el signo (+) al lado de la tabla clientes se despliegan los campos de está.
También es posible arrastrar cada uno de los campos de la tabla hacia el formulario.
Realice esta operación hasta obtener la siguiente figura:
Figura 12.29 Formulario con los campos de la tabla clientes.
247
Al ejecutarse nuevamente la aplicación y situarse en cualquier registro de la
tabla se visualizará cada registro independiente en la parte derecha del formulario, como
se aprecia en la siguiente figura:
Figura 12.30 Formulario con un registro seleccionado.
12.5.4 Insertar un nuevo registro a una tabla
Escribir un proyecto llamado InsertarNuevoRegistro y realizar un programa que

permita insertar un nuevo registro a la tabla clientes de la base de datos SQL Server
bdlibrovbnet.mdf. El nuevo registro se debe adicionar en un control DataGridView.

siguientes controles en el formulario en la posición deseada: 1 Label, 3 Button, 1
DataGridView.
Tabla 12.13 Propiedades de controles proyecto InsertarNuevoRegistro.

Button1 Name botonver
Text Ver registros tabla
Button2 Name botonnuevo
Text Nuevo registro
Button3 Name botonguardar
Text Guardar nuevo registro
DataGridView1 Name registros
Text Insertar un nuevo registro en la tabla clientes – base
de datos bdlibrovbnet.mdf
Font- Bold True
Text Insertar registro en una tabla de una base de datos.
248
Figura 12.31 Interfaz de usuario (InsertarNuevoRegistro).
a) Antes de la apertura de la clase formulario se debe importar el siguiente espacio
de nombres:
Public Class Form1
….
:::::::
End Class
El espacio de nombres System.Data.SqlClient es necesario para utilizar las

diferentes clases que permitan también las operaciones con la base de datos SQL
Server.
b) Después de la apertura de la clase formulario y antes de los procedimientos

Sub, inicialice las siguientes variables u objetos globales:
Private transaccion As New BindingSource
Private adaptador As SqlDataAdapter
Dim conexion As String = "Data Source=(local)\SQLEXPRESS;Database=
bdlibrovbnet; Integrated Security=True"
…….
…….
End Class
Se inicializan los siguientes objetos: transaccion de tipo BindingSource para

encapsular y manipular el orígen de los datos; adaptador de tipo SqlDataAdapter
para intercambiar datos con una base de datos SQL Server; conexion de tipo String al
que se le asignará la cadena de conexión para SQL Server.
c) Dé doble clic sobre el formulario para abrir el editor de código y cree un nuevo
procedimiento llamado ver_datos:
249
Public Sub ver_datos(ByVal sentenciasql As String, ByVal tabla As DataGridView)
Try
adaptador = New SqlDataAdapter(sentenciasql, conexion)
Dim comando As New SqlCommandBuilder(adaptador)
Dim tabladedatos As New DataTable()
adaptador.Fill(tabladedatos)
transaccion.DataSource = tabladedatos
With tabla
.Refresh()
.FirstDisplayedScrollingRowIndex = transaccion.Position
End With
Catch ex As SqlException
End Try
End Sub
El procedimiento ver_datos recibe como parámetros una variable de tipo String

llamada sentenciassql y un objeto tabla de tipo DataGridView. En un bloque Try se le
asigna espacio de memoria al objeto adaptador de tipo SqlDataAdapter el cual recibe
la sentencia SQL y la cadena de conexión. Por otro lado, se crea un objeto tabladedatos
al cual se le asigna espacio de memoria DataTable (). Se rellena el adaptador de datos
(adaptador) con la tabla de datos (tabladedatos) y a la propiedad DataSource del
objeto transaccion se le asigna la tabla de datos. Por otro lado, se refresca (Refresh ())
la cuadricula para cargar los datos y se obtiene la posición del primer registro de la
cuadricula (FirstDisplayedScrollingRowIndex = transaccion.Position). Utilizando
dos bloques catch se atrapan las excepciones SQLException ( por si existe algún error
en ejecución de las sentencias SQL) y Exception ( por si existe algún problema con el
sistema).
d) Seleccione el objeto botonver, dé doble clic para abrir el editor de código y

registros.DataSource = transaccion
cargar_datos("select * from clientes", registros)
A la propiedad DataSource del objeto registros se le establece el orígen de

datos (transaccion) y se llama al procedimiento ver_datos enviándole la sentencia
SQL “Select * from clientes” y el objeto registros.
e) Seleccione el objeto botonnuevo, dé doble clic para abrir el editor de código y

transaccion.AddNew()
Se utiliza el método AddNew del objeto transaccion para crear un nueva fila en
el objeto registros.
f) Seleccione el objeto botonguardar, dé doble clic para abrir el editor de código

If Not transaccion.DataSource Is Nothing Then
Adaptador.Update(CType(transaccion.DataSource, DataTable))
cargar_datos("Select * From clientes", tabla)
250
Else
MsgBox("No se pudo guardar el registro", MsgBoxStyle.Critical)
End If
Si la fila del objeto registros no es vacía por medio del método Update del
objeto adaptador se guarda la nueva fila en la tabla clientes enviándole el contenido
del DataSource del objeto transaccion y un objeto DataTable. Por otro lado, se llama
al procedimiento ver_datos para mostrar nuevamente los registros de la tabla clientes.
Si la fila es vacía se muestra el mensaje “No se pudo guardar el registro”.
Al ejecutarse el proyecto y pulsar el botón Ver registros tabla se visualizarán los

registros de la tabla clientes, como se aprecia en la siguiente figura:
Figura 12.32 Formulario con los registros de la tabla clientes.
Al pulsar el botón Nuevo Registro, se seleccionara en una nueva fila el primer

campo del objeto registros, el formulario queda de la siguiente forma:
Figura 12.33. Cuadricula con una nueva fila para insertar datos.
251
Si se captura la información en cada campo de la cuadricula (1000, Chicles
Bacan, Cristian Vanegas, Cra 68 # 20-21, 4159854, Bogotá) y luego se pulsa el botón
Guardar nuevo registro, se insertarán los datos en la tabla clientes. En la siguiente
figura se aprecia el registro insertado:
Figura 12.34 Cuadricula con un nuevo registro insertado en la tabla clientes.
12.5.5 Filtrar registros de una tabla
Diseñar un proyecto llamado FiltrarPorCampos y permitir realizar filtrar los registros

de una tabla por cualquier campo de dicha tabla y visualizar todos los registros que
cumplan la condición en un control DataGridView.

Button, 1 DataGridView y 2 ComboBox.
Tabla 12.14 Propiedades de controles proyecto FiltrarPorCampos.

Label1 Text Filtrar los registros de una tabla por cualquier
campo.
Name lblfiltrar
Font /Bold True
Label2 Text Seleccione campo
Name lblcampo
252
Label3 Text Seleccione operador
Name lbloperador
Label4 Text Criterio de filtrado
Name lblcriterio
Label5 Text Su selección:
Name lblseleccion
Label6 Text resultado
Name lblresultado
Font/ Bold True
TextBox1 Name valorcampo
Button1 Name botonfiltrar
Text Filtrar registros
ComboBox1 Name listacampos
ComboBox2 Name listaoperadores
DataGridView1 Name registrosfiltrados
Text Filtrar registros de una tabla.
Figura 12.35 Interfaz de usuario (FiltrarPorCampos).
a) Seleccione el control listacampos, busque la propiedad Items, dé clic en los tres

puntos al lado de Colección y en ventana Editor de la colección Cadena
escriba por cada línea un campo de la tabla clientes y pulse el botón Aceptar.
Otra forma es dar clic sobre la flecha del control en la parte superior derecha y
seleccionar la opción Editar elementos. La ventana de edición deberá quedar
como se muestra en la figura:
253
Figura 12.36 Ventana Editor del objeto listacampos.
b) Seleccione el control listaoperadores, busque la propiedad Items, dé clic en los

tres puntos al lado de Colección y en ventana Editor de la colección Cadena
escriba por cada línea los operadores: <, >=, <, >=, =, <>, luego pulse el botón
Aceptar. La ventana de edición deberá quedar como se muestra en la figura:
Figura 12.37 Ventana Editor del objeto listaoperadores.
c) Antes de la apertura de la clase formulario se debe importar el siguiente espacio

de nombres:
……
End Class
d) Después de la apertura de la clase formulario y antes de los procedimientos

Sub, inicialice la siguiente variable global:
254
Dim texto as String
…….
End Class
La variable texto servirá para guardar el contenido del objeto lblresultado en su

propiedad Text.
e) Seleccione el objeto listacampos, dé doble clic para abrir el editor de código y

lblresultado.Text = listacampos.SelectedItem.ToString
Al objeto lblresultado en su propiedad Text se le asigna el nombre del campo

seleccionado por medio de la propiedad SelectedItem del objeto listacampos;
f) Seleccione el objeto listaoperadores, dé doble clic para abrir el editor de código

lblresultado.Text = lblresultado.Text & listaoperadores.SelectedItem.ToString

texto=lblresultado.text
Al objeto lblresultado en su propiedad Text se le asigna su contenido actual

concatenado con el operador seleccionado por medio de la propiedad SelectedItem del
objeto listaoperadores. A la variable texto se le asigna el contenido del objeto
lblresultado.
g) Seleccione el objeto txtcriterio, dé doble clic para abrir el editor de código y

lblresultado.Text = texto & txtcriterio.text
Al objeto lblresultado en su propiedad Text se le asigna el contenido de la

variable texto concatenado con el valor escrito en el objeto txtcriterio en su propiedad
text.
h) Seleccione el objeto botonfiltrar, dé doble clic para abrir el editor de código y


conexion = "Data Source=(local)\SQLEXPRESS;Database=bdlibrovbnet;
Dim clave = valorcampo.Text
Dim nombre_campo As String = listacampos.SelectedItem.ToString
Dim valoroperador As String = listaoperadores.SelectedItem.ToString
Dim seleccion As String = "SELECT * FROM clientes where " + nombre_campo + " " +
valoroperador + "'" + clave + "'"
Dim adaptador As SqlDataAdapter
Try
adaptador = New SqlDataAdapter(seleccion, conexion)
adaptador.Fill(tabladedatos)
tabla.DataSource = tabladedatos
255
MsgBox("Error: " & ex.Message)
End Try
Se crean las variables: clave que almacenará el valor que este escrito en el objeto
txtcriterio; nombre_campo de tipo String que almacenará el nombre del campo
seleccionado por medio de la propiedad SelectedItem del objeto listacampos;
valoroperador de tipo String que almacenará el operador seleccionado por medio de la
propiedad SelectedItem del objeto listaoperadores; también se crea una variable
seleccion de tipo String que almacenará la instrucción SQL Select. En dicha
instrucción se selecciona todos los campos de la tabla clientes (Select * from clientes)
y se utiliza la cláusula Where para mostrar solo aquellos registros cuya
nombre_campo corresponda al criterio de valoroperador concatenado con clave. En
un bloque Try se le asigna espacio de memoria de tipo SqlDataAdapter al objeto
adaptador al cual se le envía como parámetros los objetos seleccion (sentencia SQL) y
conexion (cadena de conexión), luego se rellena (fill) el adaptador de datos con la tabla
de datos (tabladedatos) y se le asigna al objeto tabla por intermedio de la propiedad
DataSource el objeto tabladedatos.
Al ejecutarse el proyecto en el entorno de desarrollo, se visualizará la figura 12.35. Si se
selecciona del objeto listacampos el campo nit, del objeto listaoperadores el operador
>, se escribe en el objeto txtcriterio 300 y se pulsa el botón Filtrar registros se
visualizará en la cuadricula todos aquellos registros cuyo nit sea mayor que 300, como
se muestra en la siguiente figura:
Figura 12.38 Formulario con los registros cuyo nit es mayor de 300.
12.5.6 Informe de los registros de una tabla
Crear un proyecto llamado InformeDatosTabla, que permita a un usuario visualizar en

un formulario un reporte de todos los registros de la tabla clientes de la base de datos
bdlibrovbnet.mdf.
256

siguientes controles en el formulario en la posición deseada: 1
MicrosoftReportViewer.
Figura 12.43 Interfaz de usuario (InformeDatosTabla).
Para acoplar el control MicrosoftReportViewer1 al formulario, pulse la flecha

del lado superior derecha del objeto para ver la ventana Tareas de ReportViewer.
Figura 12.44 Interfaz de usuario (InformeDatosTabla).
Seleccione la opción “Acoplar en contenedor principal”, se visualizará el

formulario con el control acoplado como se aprecia en la siguiente figura:
257
Figura 12.45 Control MicrosoftReportViewer acoplado al formulario.

Tabla 12.15 Propiedades de controles proyecto InformeDatosTabla.

MicrosoftReportViewer1 Name reporte
Text Reporte de una tabla.
Figura 12.46 Interfaz de usuario modificada (InformeDatosTabla).
 Diseñar el informe
Para diseñar el informe, pulse la flecha del lado superior derecha del objeto reporte
para ver la ventana Tareas de ReportViewer y escoja la opción Diseñar nuevo
informe.
258
Figura 12.47 Seleccionar Diseñar nuevo informe.
Al seleccionar Diseñar nuevo informe, se visualizará la siguiente figura:
Figura 12.48 Asistente para informes.
Dé clic en Siguiente> para ver la ventana del Asistente para la configuración

de orígenes de datos.
259

la ventana de elección de la base de datos:
Dé clic en el botón Nueva Conexión. En la ventana que se visualiza elija como

orígen de datos Microsoft SQL Server y la base de datos bdlibrovbnet.
260
Al pulsar el botón Aceptar se visualizará nuevamente la ventana de elección de

conexión de datos con la base de datos bdlibrovbnett.mdf, como se aprecia en la
siguiente figura:
Figura 12.52 Ventana con la base de datos seleccionada.
Pulse Siguiente> para visualizar el siguiente mensaje:
261
Figura 12.53 Ventana Microsoft Visual Studio.

proyecto y visualizará la ventana de guardar cadena de conexión:
Cambie el nombre de la conexión que allí aparece por conexion y pulse el botón
Siguiente>, se visualizará la siguiente figura:
262
aparece por conjuntodedatos y pulse el botón Finalizar para visualizar la siguiente
figura:
Figura 12.56 Asistente para informes – seleccionar el orígen de datos.
Pulse los signos (+) para desplegar la tabla. Dé clic en Siguiente> para
visualizar la ventana de selección de tipo de informe.
Figura 12.57 Asistente para informes – seleccionar el tipo de informe.
263
Seleccione la opción Tabular o Matriz y dé clic en Siguiente> para visualizar
la ventana de diseño de tabla.
Figura 12.58. Asistente para informes – diseñar la tabla.
Seleccione cada campo y pulse el botón Detalles>. Se obtendrá la siguiente

figura:
Figura 12.59 Diseño de la tabla con los campos seleccionados.
264
Dé clic en Siguiente> para visualizar la ventana de elección de diseño de la
tabla.
Figura 12.60 Asistente para informes – elegir el diseño de la tabla.
Seleccione la opción Escalonado o Bloquear y dé clic en Siguiente> para

visualizar la ventana de estilo de la tabla.
Figura 12.61 Asistente para informes – elegir el estilo de tabla.
265
Seleccione la opción con el estilo que desee y dé clic en Siguiente> para
visualizar la ventana de finalización del asistente de informes.
Figura 12.62 Ventana de finalización del asistente de informes.
Donde aparece el nombre del informe cámbielo por Informe Clientes y dé clic
en Finalizar> para visualizar el diseño final del informe.
Figura 12.63 Diseño final del informe.
266
En este momento se podrán modificar los textos de las etiquetas de los campos,
como también la longitud de los campos. Además, en el explorador de soluciones se
visualizará el informe agregado al proyecto.
Elija la ficha de diseño del formulario y dé clic sobre la flecha del objeto
reporte y seleccione la opción Elegir informe.
Figura 12.64 Seleccionar opción Elegir informe.
Allí escoja InformeDatosTabla.Informe Cliente.rdlc, para visualizar el

formulario con los objetos conjuntodedatos, clientesBindingSource y
clientesTableAdapter.
Figura 12.65 Formulario con los objetos de manejo de datos.
267
Al ejecutarse el proyecto, se visualizará la figura 4.56. Por medio de la barra de

herramientas se podrá desplazar hacia las diferentes hojas del reporte, así como
imprimir el reporte, modificar el diseño del informe, configurar la página, cambiar el
tamaño de visualización del informe y buscar texto dentro del informe.
Figura 12.66 Formulario con el reporte de los registros de la tabla clientes.
12.5.7 Relación de tablas
Realizar un proyecto llamado RelacionConComboBox, que permita a un usuario

seleccionar desde una lista desplegable el nombre de una empresa y visualizar en una
cuadricula los pedidos que dicha empresa ha realizado.

siguientes controles en el formulario en la posición deseada: 1 Label, 1 ComboBox, 1
Button, 1 DataGridView.
Tabla 12.16 Propiedades de controles proyecto RelacionConComboBox.

Label1 Text Seleccione empresa:
name etiquetaclientes
Button1 Text Ver Pedidos
268
name boton
DataGridView1 Name tablapedidos
ComboBox1 Name lista
Name formulario
Form1 Text Relación de tablas con un
ComboBox.
Figura 12.67 Interfaz de usuario (RelacionConComboBox).
 Establecer la conexión
Desde la ficha Datos del cuadro de herramienta arrastre hacia el formulario el adaptador
de datos SqlDataAdapter (Si no aparece el control, dé clic derecho sobre la ficha
Datos y ejecute la orden Elegir elementos, busque el control, selecciónelo en el cuadro
de verificación y pulse el botón Aceptar.). Se visualizará la siguiente figura:
269
Dé clic en el botón Nueva Conexión. En la ventana que se visualiza elija como
orígen de datos Microsoft SQL Server y la base de datos bdlibrovbnet.
Pulse el botón Aceptar, para visualizar nuevamente la ventana de Elegir la

conexión de datos. Allí pulse Siguiente> para ver el siguiente mensaje:

proyecto. Se visualizará la ventana de elección de tipo de comando:
Figura 12.71 Ventana elección tipo de comando.
270
Por omisión esta seleccionada la opción Usar instrucciones SQL. Pulse
Siguiente> para visualizar la ventana de generación de instrucciones SQL.
Figura 12.72 Ventana Generar las instrucciones SQL.
Aquí puede realizar la selección de los datos que debería cargar el adaptador de
datos. Una forma es escribiendo en la ventana instrucciones SQL y la otra es pulsar el
botón Generador de consultas. Para el ejemplo, se pulsará el botón para visualizar la
siguiente figura:
Figura 12.73 Ventana Generador de consultas.
Seleccione la tabla clientes, pulse el botón Agregar y luego el botón Cerrar, se

visualizará la siguiente figura:
271
Figura 12.74 Generador de consultas con la tabla clientes.
En esta nueva ventana seleccione la opción * (todas las columnas) o los campos
que desea visualizar (Si desea visualizar la consulta seleccionada pulse el botón
Ejecutar consulta). Se obtendrá la siguiente figura:
Figura 12.75 Generador de consultas con los campos seleccionados (tabla clientes).
Pulse el botón Aceptar y se visualizará la siguiente figura:
272
Figura 12.76 Generador de consultas con la instrucción SQL.
Al pulsar el botón Finalizar, se crearán los objetos: SqlDataAdapter1 y

SqlConnection1. Cambie el nombre de dichos objetos por datosclientes y
conexioncliente respectivamente.
Ahora seleccione nuevamente el control SqlDataAdapter de la ficha Datos y
realice los mismos pasos que se realizaron anteriormente, pero esta vez seleccione la
tabla pedidos y cambie los nombres de los objetos SqlDataAdapter1 y
sqlConnection1 por datospedidos y conexionpedidos. Se visualizará la siguiente
figura:
Figura 12.77 Formulario con los objetos SqlDataAdapter y sqlConnection.
Seleccione la opción Generar Conjunto de Datos del menú Datos y se

mostrará el siguiente cuadro de diálogo:
273
Figura 12.78 Ventana Generar conjunto de datos.
Elija la opción Nuevo y cambie el nombre DataSet1 por conjuntodedatos,

deshabilite el cuadro de verificación pedidos (datospedidos) y pulse el botón Aceptar
para agregar el conjunto de datos a la aplicación, como muestra la figura:
Figura 12.79 Formulario con el objeto conjuntodedatos.
a) Antes de la apertura de la clase formulario se debe importar el siguiente espacio
de nombres:
:::::::
End Class
b) Después de la apertura de la clase formulario y antes de los procedimientos
274
sub, inicialice las siguientes variables u objetos globales:
Dim vistapedidos As DataView
:::::::::
End class
Se inicializa un objeto global llamado vistapedidos de tipo DataView para

obtener una vista de los datos.
c) Dé doble clic sobre el formulario para abrir el editor de código del

procedimiento formulario_ Load y escriba el siguiente código:
datosclientes.Fill(conjuntodedatos, "clientes")
datospedidos.Fill(conjuntodedatos, "pedidos")
lista.DataSource = conjuntodedatos.Tables("clientes")
lista.DisplayMember = conjuntodedatos.Tables("clientes").Columns(1).ToString
lista.ValueMember = conjuntodedatos.Tables("clientes").Columns(0).ToString
vistapedidos = conjuntodedatos.Tables("pedidos").DefaultView
Se rellenan los objetos datosclientes y datospedidos con el conjunto de datos y

su respectiva tabla. Al objeto lista en su propiedad DataSource se le asigna la tabla
clientes del conjunto de datos; a la propiedad DisplayMember se le asigna el valor del
segundo campo de la tabla clientes (columna uno (1) – empresa) y a la propiedad
ValueMember se le asigna el valor del primer campo de la tabla clientes (columna cero
(0) - nit). Por último al objeto vistapedidos se le asigna la tabla pedidos del conjunto de
datos y utilizando la propiedad DefaultView se personaliza la vista de los datos.
d) Dé doble clic sobre el objeto boton para abrir el editor de código y escriba el
siguiente código:
Dim datoempresa As String = lista.SelectedValue

vistapedidos.RowFilter = "nit = '" & datoempresa & "'"
tablapedidos.DataSource = vistapedidos
Se inicializa una variable llamada datoempresa de tipo String que almacenará

lo seleccionado en el objeto lista por intermedio de la propiedad SelectedValue. Se
utiliza la propiedad RowFilter del objeto vistapedidos para filtrar los registros por el
campo nit de acuerdo al valor de la variable datoempresa. Por último se asigna a la
propiedad DataSource del objeto tablapedidos el contenido del objeto vistapedidos.
e) Dé doble clic sobre el objeto lista para abrir el editor de código del
procedimiento lista_SelectedIndexChanged y escriba el siguiente código:
tablapedidos.DataSource = Nothing
Utilizando la palabra clave nothing se libera en memoria el contenido que tenga

la propiedad DataSource del objeto tablapedidos.
Al ejecutarse el proyecto, se visualizará la figura 12.67, mostrándose en el objeto lista
el primer nombre de empresa de la tabla clientes (Si se desea ver los nombres de
empresas ordenados alfabéticamente cambie el valor de la propiedad Sorted del objeto
275
lista por True). Si selecciona un nombre de empresa y se pulsa el botón Ver Pedidos,
se visualizará en la cuadricula todos los registros que estén relacionados con la tabla
pedidos.
Figura 12.80 Relación de las tablas clientes – pedidos con DataGridView.
12.6 Ejercicios bases de datos
1. Crear un programa que permita realizar una conexión a una base de datos y
mostrar datos de una tabla en un control ListView.
2. Elaborar un programa que permita realizar una conexión a una base de datos y
eliminar registros.
3. Escribir un programa que permita visualizar los registros de una tabla en campos
de texto. El usuario deberá poderse desplazar por cada registro de la tabla
utilizando los botones: Primero, Siguiente, Anterior y Último.
4. Diseñar un programa que permita visualizar los registros de una tabla en un
control DataGridView. El usuario deberá poderse desplazar por cada registro de
la tabla utilizando los botones: Primero, Siguiente, Anterior y Último.
5. Hacer un programa que permita escribir sentencias SQL en un campo de texto y
visualizar los resultados de dicha sentencia en una cuadricula.
6. Realizar un programa que permita visualizar un reporte los registros
relacionados cuyos nit sean mayores que 500.
7. Hacer un programa que permita visualizar un reporte los registros relacionados
cuyas empresas empiecen por la letra C.
8. Realizar un programa que permita hacer una conexión a una base de datos y
visualizar los registros cuyo nit sea menor o igual a 500 en un ListView.
9. Realizar un programa que permita realizar una relación entre tres tablas de una
base de datos en SQL Server.
10. Hacer un programa que permita visualizar en un reporte los registros de una
relación de dos tablas.
276
13. LENGUAJE DE CONSULTA INTEGRADO (LINQ)
LINQ (Language Integrated Query) proporciona funciones de consulta útiles para

manipular diferentes tipos de datos, esta nueva tecnología es incluida en Visual Studio
2008. Se puede utilizar consultas LINQ en proyectos nuevos o proyectos existentes, el
único requisito es que el proyecto se tiene que trabajar con la versión 3.5 o posterior del
.NET Framework. LINQ presenta las consultas como parte del lenguaje de Visual Basic
.NET. Con LINQ se puede consultar datos desde una base de datos SQL Server, XML,
matrices y colecciones en memoria. Como todas las consultas se escriben en el lenguaje
Visual Basic .NET se puede detectar los errores de las consultas en tiempo de
compilación.
13.1 Proveedores LINQ
Un proveedor LINQ realiza una consulta y la traduce en comandos que podrá ejecutar el
orígen de datos, además convierte los datos del orígen en los objetos que obtiene los
resultados de la consulta. Visual Basic .NET tiene los siguientes proveedores LINQ:
 LINQ to Objects: Permite consultar colecciones y matrices en memoria. Se debe

importar el espacio de nombres System.Linq.
 LINQ to XML: Permite consultar y modificar archivos XML. Puede modificar
XML en memoria o cargarlos desde un archivo. Admite crear literales XML, lo que
permite mediante programación la creación de elementos, documentos y fragmentos
XML.
 LINQ to SQL: Permite consultar, modificar, actualizar y eliminar datos de una base
de datos SQL Server. Visual Basic .NET incluye el diseñador relacional de objetos,
el cual permite crear un modelo de objetos en una aplicación que se asigna a objetos
de una base de datos. Es decir, convierte a SQL las consultas en un modelo de
objetos y las envía a la base de datos para su ejecución.
 LINQ to DataSet: Permite consultar, actualizar y agregar los datos de un conjunto
de datos ADO.NET.
13.2 Operadores de Consulta LINQ de VB.NET
El espacio de nombres System.Linq contiene métodos que permiten llamar o depurar

consultas. VB.NET incluye palabras clave para las cláusulas de consulta:
NOTA: para los ejemplos se utilizará la estructura de las tablas de la base de datos SQL
Server llamada bdlibrovbnet (Ver anexo A, SQL Server).
 From: Permite especificar el orígen de datos que se desea consultar. Esta

cláusula debe ser la parte inicial de una consulta. En el siguiente ejemplo la
cláusula From específica el orígen de datos Clientes y una variable de rango
misclientes quien actúa como referencia de cada elemento de la tabla Clientes.
Dim consulta = From misclientes In Clientes
 Select: Especifica la forma y el contenido de los datos que serán devueltos. Por
ejemplo si se desea visualizar solamente el nit y el nombre de la empresa de la
tabla clientes, se debe realizar el siguiente código:
277
Select misclientes.nit, misclientes.empresa
 Where: Se utiliza para filtrar datos de un orígen de datos. En el siguiente

ejemplo se muestran todos los clientes cuya ciudad sea Bogotá.

Where misclientes.ciudad=”Bogotá” Select misclientes
También se pueden utilizar los operadores lógicos And y Or. Si se desea

visualizar todos los clientes que vivan en la ciudad de Bogotá o Cali, el código
sería el siguiente:

Where misclientes.ciudad=”Bogotá” Or misclientes.ciudad=”Cali”
Select misclientes
 Order By: Ordena una consulta de un orígen de datos por uno o varios campos
especificados. Para ordenarlo de A – Z se utiliza Ascending, de Z – A
Descendig, cuando no se especifica se usa Ascending predeterminadamente. Si
se desea ordenar la consulta por el nombre de la empresa de la tabla clientes de
A- Z, el código sería el siguiente:

Where misclientes.ciudad=”Bogotá”
Select misclientes Order By misclientes.empresa
 Join: Combina dos colecciones con un campo común de un orígen de datos. La

consulta puede devolver el total o una parte de los elementos de la colección que
tienen valores coincidentes. Para visualizar todos los clientes (nit, empresa) que
tengan pedidos(nropedido, observación), el código será:
Join pedidos In Pedidos
On clientes.nit Equals pedidos.nit
Select clientes.nit, clientes.empresa,
pedidos.nropedido, pedidos.observacion
 Group By: Agrupa los resultados de una consulta por uno o más campos.
Combina dos colecciones con un campo común de un orígen de datos. Para
visualizar agrupadas y ordenadas las fecha de entrega de los pedidos de la tabla
Pedidos, el código sería:
Dim consulta = From pedidos In Pedidos Order By Pedidos.fechaentrega
Group By fecha = pedidos.fechaentrega
Into orden = Group
 Aggregate: Aplica una o más funciones de agregado a un orígen de datos. Esta

cláusula debe ser la parte inicial de una consulta. Las funciones de agregado son:
o Average: Calcula el promedio de una serie de valores.

o Count: Cuenta los elementos de un orígen de datos, opcionalmente se
puede especificar los elementos a contar.
o Max: Obtiene el valor máximo de los elementos de un orígen de datos.
278
o Min: Obtiene el valor mínimo de los elementos de un orígen de datos.
o Sum: Realiza la suma de los valores de un orígen de datos.
Ejemplos:
Si se tiene el siguiente arreglo:

Dim valores As Integer ={12,15,2,14,78,25}
Para contar los elementos.
Dim cuenta As Integer = Aggregate ctavalores In valores Into Count()
Para contar los elementos mayores de 20.
Dim cuenta As Integer = Aggregate ctavalores In valores Into Count(ctavalores>20)
Para obtener el promedio de los valores.
Dim cuenta As Integer = Aggregate ctavalores In valores Into Average()
Para obtener el valor máximo.
Dim cuenta As Integer = Aggregate ctavalores In valores Into Max()
Para obtener el valor mínimo.
Dim cuenta As Integer = Aggregate ctavalores In valores Into Min()
Para obtener la suma de los valores.
Dim cuenta As Integer = Aggregate ctavalores In valores Into Sum()
13.3 Escribir una consulta con LINQ en VB.NET
Para definir y utilizar consultar con LINQ, deben realizar tres acciones:
 Obtener el orígen de datos: Se debe especificar cuáles serán los datos que se
van a utilizar y donde están.
 Crear la consulta: Se especifica la información que se desea obtener del orígen
de datos, estos, se pueden ordenar, filtrar, agrupar.
 Ejecutar la consulta: La ejecución de la consulta es un proceso independiente
de la creación. Se puede ejecutar cuando este definida (ejecución inmediata) o se
puede guardar y ejecutarse posteriormente (ejecución diferida).
Ejemplo: Realizar una consulta que imprima todos los nombres que empiecen por la
letra R.
- Orígen de datos
Dim nombres() As String = {“Carlos”, “José”, “Cristian”, “Rosa”, “Rocío”, “Mary”}
279
- Creación de la consulta
Dim consultanombres = From misnombres In nombres

Where misnombres.IndexOf(“R”)=0
Select misnombres
- Ejecutar la consulta
For Each nombre In consultanombres

Msgbox (nombre)
Next
13.4 Ejemplos prácticos consultas LINQ
13.4.1 Consulta LINQ a un texto
Hacer una aplicación llamada ConsultaLinqTexto, que permita visualizar un texto en

un campo de texto y obtener la siguiente información del texto: cuantas letras tiene,
cuantas palabras, cuales palabras contienen la letra F, cuantas palabras LINQ existen,
cuales palabras tienen más de 10 letras.

TextBox.
Tabla 13.1 Propiedades de controles proyecto ConsultaLinqTexto.

Button1 Name botonconsulta
Text Ejecutar consulta LINQ
Text Texto original
Text Resultado de la consulta
TextBox1 Name lbltexto
Text Adicione un texto cualquiera.
MultiLine True
TextBox2 Name lblresultado
MultiLine True
Text Consulta LINQ con texto
280
Figura 13.1 Interfaz de usuario (ConsultaLinqTexto).
Seleccione el objeto botonconsulta, dé doble clic para abrir el editor de código y

Dim cadena As String = txttexto.Text
Se asigna a la variable cadena el contenido del objeto txttexto.

Dim contarletras As Integer = Aggregate cantidadpalabras In cadena Into Count()
txtresultado.Text = "El texto contiene:" & contarletras & " letras" & vbCrLf
Se utiliza la función de agregado Count para contar cada una de los caracteres
que contiene el texto del objeto txttexto se incluyen los espacios. La consulta se crea
con la cláusula Aggregate. Al objeto txtresultado se le asigna el valor de contarletras.
Dim palabras() As String
palabras = Split(cadena, " ")
Dim contarpalabras As Integer = Aggregate mispalabras In palabras Into Count()
txtresultado.Text = txtresultado.Text & "Tiene :" & contarpalabras & " Palabras" &
vbCrLf
Se crea una matriz llamada palabras de tipo String. A dicha varible se le asigna
cada una de las palabras que contiene el objeto cadena utilizando la función Split. Con
la función de agregado Count se cuentan cada una de las palabras de la matriz palabras
y se asigna dicha cantidad a la variable contarpalabras. Al objeto txtresultado se le
adiciona el valor de contarpalabras.
Dim palabras_con_F = From letra In palabras Where letra.Contains("F")
txtresultado.Text = txtresultado.Text & "Las palabras que contienen la letra F son:" &
vbCrLf
For Each letraf In palabras_con_F
txtresultado.Text = txtresultado.Text & letraf & vbCrLf
Next
281
Se crea una variable llamada palabras_con_F. A dicha variable se le asigna
cada una de las palabras que contiene la letra F, la cual es retornada por la consulta
(From). Dicha consulta busca en la matriz palabras todas las palabras que cumplan la
condicion (Where letra.Contains(“F”)). Con un ciclo For Each se imprime cada
palabra con F que se encuentre en el objeto palabras_con_F y es adicionada a la
propiedad Text del objeto txtresultado. La consulta se crea con la cláusula From.
Dim palabra_linq As String = "LINQ"

Dim palabras_encontradas = From linq In palabras _
Where linq = palabra_linq
Select linq
Dim nro_palabras_linq As Integer = palabras_encontradas.count()
txtresultado.Text = txtresultado.Text & "La palabra LINQ se encuentra:" &
nro_palabras_linq & " veces" & vbCrLf
Se crea una variable llamada palabras_linq a la cual se le asigna el texto LINQ.

Se crea una consulta que busca en el objeto palabras todas las palabras que sean igual
al contenido de la variable palabra_linq (Where linq= palabra_linq). Con la función
de agregado Count se le agrega a la variable nro_palabras_linq el valor de la cantidad
de palabras obtenidas del objeto palabras_encontradas y es adicionada a la propiedad
Text del objeto txtresultado.
Dim palabras_mas_10_letras = From letras In palabras
Where letras.Length > 10
Select letras
txtresultado.Text = txtresultado.Text & "Las palabras con más de 10 letras son:" &
vbCrLf
For Each letras10 As String In palabras_mas_10_letras
txtresultado.Text = txtresultado.Text & letras10 & vbCrLf
Next
Se crea una variable llamada palabras_mas_10_letras, a la cual se le asigna una

consulta que busca en el objeto palabras todas las palabras que contengan más de 10
caracteres (Where letras.Length>10). Con un ciclo For Each se imprime cada palabra
con más de 10 caracteres que se encontro en la consulta y es adicionada a la propiedad
Text del objeto txtresultado.
Al ejecutarse el proyecto y pulsar el botón Ejecutar consulta LINQ, se visualizará el

formulario con todos las operaciones realizadas.
Figura 13.2 Ejecución de la consulta LINQ sobre un texto.
282
13.4.2 Consulta LINQ a una matriz
Escribir una aplicación llamada ConsultaLinqMatriz, que permita visualizar una

matriz con 10 números en un campo de texto y obtener la siguiente información de la
matriz: suma de los números, el promedio, el número mayor, el número menor, ordenar
los números y los números mayores de 60 o menores de 10.

TextBox.
Tabla 13.2 Propiedades de controles proyecto ConsultaLinqMatriz.

Button1 Name botonconsulta
Text Ejecutar consulta LINQ
Text Valores de la Matriz:
Font - Bold True
Label2 Name lblsuma
Text Suma de los números
Label3 Name lblpromedio
Text Promedio de los números:
Label4 Name lblmayor
Text Número mayor:
Label5 Name lblmenor
Text Número menor:
Label6 Name lblordenados
Text Números ordenados:
Label7 Name lblmayores40
Text Mayores de 40:
Label8 Name lblmayoresmenores
Text Mayores de 60 o menores de 10:
TextBox1 Name txtnumeros
TextBox2 Name txtsuma
TextBox3 Name txtpromedio
TextBox4 Name txtmayor
TextBox5 Name txtmenor
TextBox6 Name txtordenados
TextBox7 Name txtmayores40
TextBox8 Name txtmayoresmenores
Text Consulta LINQ con Matrices
283
Figura 13.3 Interfaz de usuario (ConsultaLinqMatriz).
Seleccione el objeto botonconsulta, dé doble clic para abrir el editor de código y

Dim numeros() As Integer = {20, 80, 15, 14, 2, 6, 7, 33, 50, 69}
For Each numero In numeros
txtnumeros.Text = txtnumeros.Text & numero & ", "
Next
Se crea un arreglo llamado numeros de tipo Integer a la cual se le asignan diez

(10) valores. Con un ciclo For Each se imprime cada número que se encuentre en el
objeto numeros y son adicionados a la propiedad Text del objeto txtnumeros.
Dim suma As Integer = Aggregate sumanumeros In numeros Into Sum()
txtsuma.Text = suma
Se crea una consulta utilizando la función de agregado Sum para sumar los
valores del arreglo numeros y es asignado a la variable suma. Al objeto txtsuma se le
asigna el valor de suma.
Dim promedio As Integer = Aggregate promedionumeros In numeros Into Average()
txtpromedio.Text = promedio
Se crea una consulta utilizando la función de agregado Average para calcular el

promedio de los valores del arreglo numeros y es asignado a la variable promedio. Al
objeto txtpromedio se le asigna el valor de promedio.
Dim mayor As Integer = Aggregate mayornumeros In numeros Into Max()
txtmayor.Text = mayor
Se crea una consulta utilizando la función de agregado Max para obtener el

valor mayor del arreglo numeros y es asignado a la variable mayor. Al objeto
txtmayor se le asigna el valor de mayor.
Dim menor As Integer = Aggregate menornumeros In numeros Into Min()
284
txtmenor.Text = menor
Se crea una consulta utilizando la función de agregado Min para obtener el

valor menor del arreglo numeros y es asignado a la variable menor. Al objeto
txtmenor se le asigna el valor de menor.
Dim ordenados = From numerosordenados In numeros Order By numerosordenados
Ascending
For Each numero In ordenados
txtordenado.Text = txtordenado.Text & numero & ", "
Next
Se crea una variable llamada ordenados, a la cual se le asigna una consulta que
ordena (Order By) todos los valores de menor a mayor (Ascending) del arreglo
numeros. Con un ciclo For Each se imprime los números ordenados en la propiedad
Text del objeto txtordenado.
Dim mayores = From numerosmayores In numeros Where numerosmayores > 40

For Each numero In mayores
txtmayores40.Text = txtmayores40.Text & numero & ", "
Next
Se crea una variable llamada mayores, a la cual se le asigna una consulta que
obtiene todos los valores mayores de 40 del arreglo numeros. Con un ciclo For Each
se imprime los números que cumplen la condición en la propiedad Text del objeto
txtmayores.
Dim mayoresmenores = From numerosmayoresmenores In numeros

Where numerosmayoresmenores > 60 Or numerosmayoresmenores < 10
For Each numero In mayoresmenores
txtmayoresmenores.Text = txtmayoresmenores.Text & numero & ", "
Next
Se crea una variable llamada mayoresmenores, a la cual se le asigna una

consulta que obtiene todos los valores mayores de 60 o menores de 10 del arreglo
numeros. Con un ciclo For Each se imprime los números que cumplen la condición en
la propiedad Text del objeto txtmayoresmenores.
Al ejecutarse el proyecto ConsultaLinqMatrices y pulsar el botón Ejecutar consulta

LINQ, se visualizará el formulario con todos las operaciones realizadas.
Figura 13.4 Ejecución de la consulta LINQ con Matrices.
285
13.4.3 Consultar una base de datos SQL Server con LINQ To SQL
Diseñar una aplicación llamada ConsultaLinqToSQL, que permita visualizar todos los
registros de una tabla perteneciente a una base de datos SQL Server. Dichos datos se
deben mostrar en una cuadricula. Se debe utilizar el componente LINQ to SQL.
bdlibrovbnet (Ver anexo A, SQL Server).

siguientes controles en el formulario en la posición deseada: 1 Button, 1
DataGridView.
Tabla 13.3 Propiedades de controles proyecto ConsultaLinqToSQL.

Control Propie Valor
dad
Button1 Name boton
Text Ejecutar consulta LINQ to SQL
DataGridView1 Name cuadricula
Text Consulta LINQ to SQL.
Figura 13.5 Interfaz de usuario (ConsultaLinqToSQL).
286
 Agregar LINQ to SQL
Para agregar un objeto Clases LINQ to SQL puede realizar alguno de los siguientes
pasos:
1. Del menú Proyecto seleccione Agregar nuevo elemento… y busque la plantilla
Clases LINQ to SQL.
2. Del icono seleccionar Agregar nuevo elemento… y busque la plantilla
Clases LINQ to SQL.
derecho, seleccionar la opción Agregar nuevo elemento… y busque la
plantilla Clases LINQ to SQL.
Figura 13.6 Ventana para agregar una plantilla LINQ to SQL.
Seleccione la plantilla Clases de LINQ to SQL. En el cuadro de texto Nombre

cambie el nombre por MLinqToSQL.dbml (Database Markup Language), luego pulse
el botón Agregar para visualizar un nuevo objeto de datos relacionales LINQ to SQL.
En la lista del explorador de soluciones aparece un nuevo archivo con el nombre
asignado.
287
Figura 13.7 Ventana diseñador relacional de objetos LINQ to SQL.
Pulse el link Explorador de servidores del diseñador relacional de objetos para

ver la siguiente figura:
En dicha ventana pulse el icono conectar con bases de datos , se visualizará

la ventana de Agregar conexión como muestra la figura:
288
Para el ejemplo seleccione la base de datos bdlibrovbnet.mdf, la cual se

encuentra en la carpeta data de SQL Server (si la instalación la realizo en c:\ la ruta
seria: C:\Archivos de programa\Microsoft SQL Server\MSSQL.1\MSSQL\Data). Pulse
el botón Aceptar para visualizar la siguiente figura:
Figura 13.10 Explorador de servidores con la conexión a la base de datos.
Al pulsar en el signo (+) al lado del nombre de la base de datos se visualizará la

Figura 13.11 Estructura de la base de datos bdlibrovbnet.mdf.
Dé clic sobre la tabla clientes y arrástrela hacia el diseñador relacional de objeto,
289
se mostrará la siguiente ventana:
Figura 13.12 Ventana para incluir la conexión al proyecto actual.
Pulse el botón Si, para visualizar la siguiente figura:
Figura 13.13 Diseñador relacional de objetos con la tabla clientes.
Seleccione el objeto boton, dé doble clic para abrir el editor de código y escriba el
siguiente código:
Dim vista As New MiLinqToSQLDataContext
Dim consulta = From misclientes In vista.clientes Select misclientes
cuadricula.DataSource = consulta
Se crea una instancia llamada vista de la clase MiLinqToSQLDataContext. La

clase DataContext corresponde al nombre del archivo .dbml. El archivo LINQ to SQL
es MiLinqToSQL, esta clase contiene métodos y propiedades para la conexión a la
base de datos y para la manipulación de los datos. Se crea una variable llamada
consulta a la cual se le asigna una consulta (From) que permite obtener todos los
registros de la tabla clientes de la base de datos bdlibrovbnet.mdf. Por último se le
asigna a la propiedad DataSource del objeto DataGridView cuadricula el contenido de
la variable consulta.
290
Al ejecutarse el proyecto ConsultaLinqToSQL y pulsar el botón Ejecutar consulta

LINQ to SQL, se visualizará en la cuadricula todos los registros de la tabla clientes.
Figura 13.14 Ejecución de la aplicación ConsultaLinqToSQL.
13.4.4 Operaciones con una tabla de una base de datos SQL Server
Realizar una aplicación llamada OperacionesLinqToSQL, que permita a un usuario

seleccionar el nombre de una empresa y visualizar todo el registro en campos de texto.
Además, el usuario podrá realizar las siguientes operaciones: modificar el registro,
eliminar el registro, crear y guardar un nuevo registro.

siguientes controles en el formulario en la posición deseada: 5 Button, 8 Label, 6
TextBox y 1 ComboBox.
Tabla 13.4 Propiedades de controles proyecto OperacionesLinqToSQL.

Text Mostrar registro
Button2 Name botonmodificar
Text Modificar registro
291
Text Eliminar registro
Button4 Name botonnuevo
Text Nuevo registro
Button5 Name botonguardar
Label1 Name lblcliente
Text Seleccione cliente:
Font - Bold True
Label2 Name lblnit
Text Nit:
Label3 Name lblempresa
Text Empresa:
Label4 Name lblrepresentante
Text Representante:
Label5 Name lblciudad
Text Ciudad:
Label6 Name lbldireccion
Text Dirección:
Label7 Name lbltelefono
Text Teléfono:
Label8 Name lblregistros
Text Registros actuales de la tabla
Font - Bold True
TextBox1 Name txtnit
Enabled False
TextBox2 Name txtempresa
TextBox3 Name txtrepresentante
TextBox4 Name txtciudad
TextBox5 Name txtdireccion
TextBox6 Name txttelefono
ComboBox1 Name listaclientes
Panel1 Name panel
Borderstyle FixedSingle
Text Operación con una base de datos – LINQ to SQL
Figura 13.15 Interfaz de usuario (OperacionesLinqToSQL).
292
 Agregar LINQ to SQL
Del menú Proyecto seleccione Agregar nuevo elemento… y busque la plantilla Clases
LINQ to SQL, se visualizará la siguiente figura:
Figura 13.16 Agregar plantilla Clases de LINQ to SQL.
En el cuadro de texto Nombre cambie el nombre por MisDatos.dbml, luego

pulse el botón Agregar para visualizar un nuevo objeto de datos relacionales LINQ to
SQL. En la lista del explorador de soluciones aparece un nuevo archivo con el nombre
asignado.
Figura 13.17 Vista del diseñador relacional de objetos.
Pulse el link Explorador de servidores del diseñador relacional de objetos y

adicione la base de datos bdlibrovbnet.mdf y arrastre la tabla clientes hacia el
293
diseñador, se debe observar una figura similar a la siguiente:
Figura 13.18 Diseñador relacional de objetos con la tabla clientes.
En el control ComboBox listaclientes se van a mostrar los nombres de las

empresas que actualmente están en la tabla clientes para ello dé clic sobre la flecha
superior derecha de dicho objeto para ver Tareas de ComboBox.
Figura 13.19 Ventana Tareas de ComboBox.
Dé clic sobre el cuadro de verificación Utilizar elementos enlazados a datos y

seleccione la opción orígen de datos.
Figura 13.20 Ventana Orígen de datos.
294
Pulse sobre el link Agregar orígen de datos del proyecto, se mostrará el
Asistente para la configuración de orígenes de datos.
Figura 13.21 Asistente para configurar el orígen de datos.
Seleccione el objeto Base de datos y pulse el botón Siguiente para ver la

ventana de elección de conexión de datos.
Figura 13.22 Ventana para elegir la conexión de datos.
Aparece la conexión a la base de datos bdlibrovbnet.mdf, pulse el botón

Siguiente para elegir los objetos de la base de datos a utilizar.
295
Figura 13.23 Ventana para elegir los objetos de base de datos.
Al pulsar en el signo (+) al lado del texto Tablas se visualizarán las diferentes
tablas de la base de datos, dé clic sobre la tabla clientes, además cambie el Nombre de
DataSet por conjuntodedatos y pulse el botón Finalizar para volver a modo diseño:
Como se puede apreciar, se adicionaron los objetos conjuntodedatos,

clientesBindingSource y ClientesTableAdapter que permitirán obtener los datos de la
tabla clientes. Nuevamente seleccione el control listaclientes y en la opción Mostrar
miembro seleccione el campo empresa y en la opción Miembro de valor el campo
Nit. Esto permitirá visualizar el campo empresa en el control y obtener el campo nit
seleccionado. Se obtendrá la siguiente figura:
296
Figura 13.24 Control listaclientes con los campos empresa y nit seleccionados.
a) Despúes de la apertura de la clase Public class formulario y antes del primer

procedimiento Sub, dé doble clic sobre el formulario y busque clase formulario
y escriba este código escriba:

Dim vista As New MisDatosDataContext
Se crea una instancia llamada vista de la clase MisDatosdataContext. El

nombre de DataContext corresponde al nombre del archivo .dbml. El archivo LINQ to
SQL es MisDatos, esta clase contiene métodos y propiedades para la conexión a la base
de datos y para manipular los datos. Esta instancia podrá ser utilizadas por cualquier
procedimiento de la clase.
b) Despúes de la apertura de la clase Public class formulario cree un

procedimiento Sub llamado datos() y escriba este código escriba:

::::::::::
Private Sub datos()
Dim datos = From actuales In vista.clientes
cuadricula.DataSource = datos
End Sub
End class
Se crea un procedimiento llamado datos que contiene una consulta de los datos
actuales de la tabla clientes, estos son asignados a la propiedad DataSource del objeto
DataGridView cuadricula.
c) Seleccione el objeto botonbuscar, dé doble clic para abrir el editor de código y

297
Dim registroseleccionado As String = listaclientes.SelectedItem(0)
Dim consulta = From miregistro In vista.clientes
Where miregistro.nit = registroseleccionado
For Each campos In consulta
txtnit.Text = campos.nit
txtempresa.Text = campos.empresa
txtrepresentante.Text = campos.representante
txtciudad.Text = campos.ciudad
txtdireccion.Text = campos.direccion
txttelefono.Text = campos.telefono
Next
datos()
Se crea una variable de tipo String llamada registroseleccionado a la cual se le

asigna el valor del campo nit seleccionado del objeto listaclientes (este valor se toma de
la opcion miembro de valor que es el item cero (0)). Por otro lado, se crea una consulta
que cargará el registro que cumpla la condicion de que el nit sea igual al registro
seleccionado. Con un ciclo For Each se le asigna a la propiedad Text de los objetos
TextBox cada uno de los campos del registro encontrado. Por último se llama al
procedimiento datos para que muestre en la cuadricula los registros actualizados de la
tabla clientes.
d) Seleccione el objeto botonmodificar, dé doble clic para abrir el editor de código

Dim respuesta = MsgBox("Desea guardar los cambios realizados",

MsgBoxStyle.YesNo)
If (respuesta = MsgBoxResult.Yes) Then
Try
Dim consulta = From miregistro In vista.clientes
For Each campos In consulta
campos.nit = txtnit.Text
campos.empresa = txtempresa.Text
campos.representante = txtrepresentante.Text
campos.ciudad = txtciudad.Text()
campos.direccion = txtdireccion.Text
campos.telefono = txttelefono.Text
Next
vista.SubmitChanges()
MsgBox("Error en el sistema")
End Try
Else
MsgBox("Registro no modificado", MsgBoxStyle.Information)
End If
datos()
Se crea una variable llamada respuesta a la cual se le asigna un cuadro de

diálogo MsgBox con el mensaje “Desea guardar los cambios realizados” y un estilo
de mensaje Si/No. Si el usuario selecciona el botón Si se le asigna a una variable
llamada registroseleccionado el nit de la empresa seleccionada y se crea un consulta
que guarda el registro que cumpla la condición. Con un ciclo For Each se le asigna a
cada campo del registro actual los valores de los objetos TextBox en su propiedad Text.
298
Utilizando el procedimiento SubmitChanges() se modifican los campos del registro
actual en la tabla. Si se pulsa el botón No se mostrará el mensaje “Registro no
modificado”.
e) Seleccione el objeto botoneliminar, dé doble clic para abrir el editor de código

Dim respuesta = MsgBox("Desea Eliminar el registro seleccionado",
MsgBoxStyle.YesNo)
Try
Dim consultaeliminar = From miregistro In vista.clientes
For Each campos In consultaeliminar
vista.clientes.DeleteOnSubmit(campos)
Next
End Try
Else
MsgBox("Registro no Eliminado", MsgBoxStyle.Information)
End If
datos()
Si el usuario selecciona el botón Si se le asigna a una variable llamada

registroseleccionado el nit de la empresa seleccionada y se crea un consulta que guarda
el registro que cumpla la condición. Con un ciclo For Each se eliminan cada uno de los
campos del registro seleccionado utilizando el procedimiento DeleteOnSubmit() y con
el procedimiento SubmitChanges() se actualiza la tabla. Si se pulsa el botón No se
mostrará el mensaje “Registro no Eliminado”.
f) Seleccione el objeto botonnuevo, dé doble clic para abrir el editor de código y

txtnit.Text = ""
txtempresa.Text = ""
txtrepresentante.Text = ""
txtciudad.Text = ""
txtdireccion.Text = ""
txttelefono.Text = ""
txtnit.Enabled = True
Se asigna un espacio a la propiedad Text de los objetos TextBox. El objeto

txtnit se habilita para poder ecribir en él, modificando a True su propiedad Enabled.
g) Seleccione el objeto botonguardar, dé doble clic para abrir el editor de código

Dim respuesta = MsgBox("Desea Guardar el nuevo registro", MsgBoxStyle.YesNo)
Try
Dim nuevoregistro As New clientes With { _
.nit = txtnit.Text, .empresa = txtempresa.Text, _
.representante = txtrepresentante.Text, _
.ciudad = txtciudad.Text, .direccion = txtdireccion.Text, _
299
.telefono = txttelefono.Text}
vista.clientes.InsertOnSubmit(nuevoregistro)
txtnit.Enabled = False
End Try
Else
MsgBox("Registro no guardado", MsgBoxStyle.Information)
End If
datos()
Si el usuario pulsa el botón Si se crea una instancia de la tabla clientes llamada

nuevoregistro y se le asigna a cada campo de la tabla los valores de la propiedad Text
de los objetos TextBox. Utilizando el procedimiento InsertOnSubmit() se inserta el
nuevo registro a la tabla clientes y con el procedimiento SubmitChanges() se actualiza
la tabla. Por otro lado, se deshabilita el objeto txtnit con False en su propiedad
Enabled. Si se pulsa el botón No se mostrará el mensaje “Registro no guardado”.
Al ejecutarse el proyecto OperacionesLinqToSQL, seleccionando un nombre de

empresa del control listaclientes y pulsar el botón Mostrar registro, se visualizará en
los campos de texto el registro seleccionado y en la cuadricula todos los registros de la
tabla clientes.
Figura 13.25 Ejecución de la aplicación OperacionesLinqToSQL.
Al registro seleccionado lo podrá modificar o eliminar. También se podrá crear y

guardar un nuevo registro.
300
13.4.5 Relación entre dos tablas de una base de datos SQL Server
Diseñar una aplicación llamada RelacionTablasLINQ, que permita a un usuario

seleccionar el nombre de una empresa y visualizar todos los pedidos que dicha empresa
ha realizado.

siguientes controles en el formulario en la posición deseada: 1 Button, 2 Label, 1
DataGridView y 1 ComboBox.

Tabla 13.5 Propiedades de controles proyecto RelacionTablasLINQ.

Button1 Name boton
Text Obtener Pedidos
Label1 Name lblclientes
Text Seleccione Cliente:
Font - Bold True
Label2 Name lblpedidos
Text Pedidos del cliente seleccionado
Font - Bold True
ComboBox1 Name listaclientes
Text Relación tablas – LINQ to SQL
Figura 13.26 Interfaz de usuario (RelacionTablasLINQ).
301
 Agregar clase LINQ to SQL
LINQ to SQL. En el cuadro de texto Nombre cambie el nombre por
DatosRelacionados.dbml, luego pulse el botón Agregar para visualizar un nuevo
objeto de datos relacionales LINQ to SQL.
En la lista del explorador de soluciones aparece un nuevo archivo con el nombre
asignado. Se obtendrá la siguiente figura:
Figura 13.27 Vista del diseñador relacional de objetos DatosRelacionados.dbml.

adicione la base de datos bdlibrovbnet.mdf y arrastre las tablas clientes y pedidos
hacia el diseñador, se debe observar una figura similar a la siguiente:
Figura 13.28 Diseñador relacional de objetos con las tablas clientes y pedidos.
302
En el formulario seleccione el control ComboBox listaclientes para adicionar
los nombre de las empresas de la tabla clientes para ello dé clic sobre la flecha superior
derecha de dicho objeto para ver las Tareas de ComboBox. Dé clic sobre el cuadro de
verificación Utilizar elementos enlazados a datos y escoja la opción orígen de datos.
Figura 13.29 Ventana Orígen de datos del control listaclientes.
Pulse sobre el link Agregar orígen de datos del proyecto, se mostrará el

Asistente para la configuración de orígenes de datos.
Figura 13.30 Asistente para configurar el orígen de datos.
Seleccione el objeto Base de datos y pulse el botón Siguiente hasta encontrar la

ventana para elegir los objetos de la base de datos a utilizar. En dicha ventana al
pulsar en el signo (+) al lado del texto Tablas se visualizará las diferentes tablas de la
base de datos, dé clic sobre la tabla clientes, además cambie el Nombre de DataSet por
conjuntodedatos. En este momento se observaría la siguiente figura:
303
Al pulsar el botón Finalizar se vuelve al formulario y se adicionan los objetos

conjuntodedatos, clientesBindingSource y ClientesTableAdapter que permitirán
manipular los datos de la tabla clientes. En las opciones del objeto listaclientes,
Mostrar miembro escoja el campo empresa y en Miembro de valor el campo nit, se
mostraría la siguiente figura:
Figura 13.32 Formulario con datos enlazados al objeto listaclientes.
Seleccione el objeto botonbuscar, dé doble clic para abrir el editor de código y escriba
el siguiente código:
304
Dim vista As New DatosRelacionadosDataContext
Dim empresaseleccionada As String = listaclientes.SelectedItem(0)
Dim consultajoin = From misclientes In vista.clientes _
Join mispedidos In vista.pedidos _
On misclientes.nit Equals mispedidos.nit _
Where mispedidos.nit = empresaseleccionada _
Select mispedidos.nit, misclientes.ciudad, misclientes.representante,
mispedidos.nropedido, mispedidos.fechaentrega,
mispedidos.observacion
cuadricula.DataSource = consultajoin
Se crea una instancia llamada vista de la clase

DatosRelacionadosDataContext. El nombre de DataContext corresponde al nombre
del archivo .dbml. El archivo LINQ to SQL es DatosRelacionados. También se crea
una variable de tipo String llamada empresaseleccionada a la cual se le asigna el valor
del campo nit seleccionado del objeto listaclientes (este valor se toma de la opcion
miembro de valor que es el item cero (0)). Por otro lado, se crea una consulta
combinada con la clausula Join que realiza la relacion de las tablas clientes, pedidos
por el campo común nit (Equals), con la condicion (Where) de que el nit sea igual al
registro seleccionado, además se seleccionan (Select) los campos de las dos tablas que
se quieren mostrar. Por último se asigna a la propiedad DataSource del objeto
cuadricula el resultado de la consulta (consultajoin).
Al ejecutarse el proyecto RelacionTablasLINQ, seleccionando un nombre de empresa

del control listaclientes y pulsar el botón Obtener Pedidos, se visualizará en la
cuadricula cada uno de los pedidos de dicho cliente.
Figura 13.33 Ejecución de la aplicación RelacionTablasLINQ.
305
13.4.6 Relación tablas con LINQ to SQL y DataGridView
Crear una aplicación llamada RelacionTablasDataGridViewLINQ, que permita a un

usuario seleccionar de una cuadricula un registro de la tabla clientes y visualizar todos
los pedidos que dicho cliente ha realizado en una cuadricula.
 Agregar clase LINQ to SQL
LINQ to SQL. En el cuadro de texto Nombre cambie el nombre por
DatosDataGridView.dbml.
Figura 13.34 Plantilla Clases de LINQ to SQL.
Pulse el botón Agregar para visualizar un nuevo objeto de datos relacionales

LINQ to SQL. En la lista del explorador de soluciones aparece un nuevo archivo con el
nombre asignado. Se obtendrá la siguiente figura:
Figura 13.35 Diseñador relacional de objetos de la clase LINQ to SQL.
306
adicione la base de datos bdlibrovbnet.mdf y arrastre las tablas clientes y pedidos
hacia el diseñador, se debe observar una figura similar a la siguiente:
Figura 13.36 Diseñador relacional de objetos con las tablas clientes y pedidos.
 Crear el orígen de datos.

Para agregar el orígen de datos se deben realizar los siguientes pasos:
1. En el menú Generar, dé clic en Generar RelacionTablasDataGridVieWLINQ.

2. En el menú Datos, dé clic en Mostrar orígenes de datos.
Figura 13.37 Ventana Orígenes de datos.
3. En la ventana Orígenes de datos, dé clic en el link Agregar nuevo orígen de datos

para ver la ventana de elección de un tipo de orígen de datos.
307
Figura 13.38 Ventana para configurar orígen de datos.
4. Seleccione el icono Objeto y pulse el botón Siguiente para ver la ventana de elección
del objeto a enlazar.
Figura 13.39 Ventana para configurar orígen de datos.
Dé clic sobre el signo (+) de los objetos RelacionTablasDataGridViewLINQ,

seleccione el objeto clientes y pulse el botón Finalizar para volver a modo diseño y
visualizar los datos en la ventana Orígenes de datos.
Figura 13.40 Ventana orígen de datos con los datos anexados.
308
Al tener el orígen de datos, seleccione el formulario y dé clic sobre el objeto
clientes del orígen de datos y arrástrelo hacia el formulario. Se obtendrá la siguiente
figura:
Figura 13.41 Formulario con el objeto clientes.
Como se aprecia se agrego al formulario los objetos ClientesBindnigSource y

ClientesBindingNavigator y un control DataGridView que mostrará todos los
registros de la tabla clientes. Ahora seleccione el objeto pedidos del orígen de datos y
arrástrelo hacia el formulario para crear un nuevo objeto DataGridView para los datos
de la tabla pedidos. Modifique los controles hasta obtener una figura similar a la
siguiente:
Figura 13.42 Formulario con los objetos clientes y pedidos en DataGridView.
Nota: si se visualiza alguna advertencia vuelva a generar el proyecto desde el menú

Generar.
309
a) Dé doble clic sobre el formulario y después de la creación de la clase Form1

Public Class Form1

Dim vistadatos As New DatosDataGridViewDataContext
::::::::
::::::::
End Class
Se crea una instancia llamada vistadatos de la clase

DatosDaTaGridViewDataContext. El nombre de DataContext corresponde al
nombre del archivo .dbml. El archivo LINQ to SQL es DatosDataGridView.
b) En el procedimiento Form1_Load del formulario escriba el siguiente código:
ClientesBindingSource.DataSource = vistadatos.clientes
Al orígen de datos ClientesBindingSource en su propiedad DataSource se le

asigna los datos de la tabla clientes.
Al ejecutarse el proyecto RelacionTablasDataGridView, al seleccionar un registro de

la cuadricula donde aparecen los campos de la tabla clientes, en la cuadricula de la tabla
pedidos aparecerán todos los registros relacionados (si existen registros) con la tabla
clientes.
Figura 13.43 Ejecución de la aplicación RelacionTablasDataGridView.
310
13.4.7 Consulta LINQ to DataSet
Elaborar una aplicación llamada ConsultaLinqDataSet, que permita visualizar las

tablas clientes, pedidos y la relación de estas en controles DataGridView, cuyo nit sea
igual a 100 utilizando la consulta LINQ to DataSet.

siguientes controles en el formulario en la posición deseada: 3 DataGridView.
Tabla 13.6 Propiedades de controles proyecto ConsultaLinqDataSet.

Control Propie Valor
dad
DataGridView1 Name datosclientes
DataGridView2 Name datospedidos
DataGridView3 Name tablasrelacionadas
Text Consulta LINQ to DataSet.
Figura 13.44 Interfaz de usuario (ConsultaLinqDataSet).
311
Seleccione el objeto formulario, dé doble clic para abrir el editor del procedimiento
Formulario_Load y escriba el siguiente código:
Dim conexion As String = "Data Source=(local)\SQLEXPRESS; Database=bdlibrovbnet;

Se crea una variable llamada conexion de tipo String que contendrá la cadena
de conexión a la base de datos de SQL Server. La cadena de conexión contiene el orígen
de datos (Data Source), el nombre de la base de datos SQL Server (DataBase) y la
seguridad integrada (True
Dim cargarclientes As New SqlClient.SqlDataAdapter("SELECT * FROM clientes",
conexion)
Dim comandoclientes As New SqlClient.SqlCommandBuilder(cargarclientes)
Dim conjuntodedatos As New DataSet()
cargarclientes.Fill(conjuntodedatos, "clientes")
Dim cargarpedidos As New SqlClient.SqlDataAdapter("SELECT * FROM
pedidos",conexion)
Dim comandopedidos As New SqlClient.SqlCommandBuilder(cargarpedidos)
cargarpedidos.Fill(conjuntodedatos, "pedidos")
Se crean los siguientes objetos: cargarclientes a la cual se le asigna espacio de

memoria de tipo SqlDataAdapter y recibe como parámetros la selección de la tabla
clientes y la cadena de conexión; comandoclientes a la cual se le asigna espacio de
memoria de tipo SqlCommandBuilder (genera comandos para manipular una única
tabla) y recibe como parámetro el objeto cargarclientes; conjuntodedatos de tipo
DataSet que almacenará en memoria caché los datos de las tablas. Utilizando la función
Fill se rellena el objeto cargarclientes con los datos de la tabla clientes y recibe como
parámetros el DataSet y un alias de la tabla. El mismo proceso se realiza para obtener
los datos de la tabla pedidos.
datosclientes.DataSource = conjuntodedatos.Tables("clientes")
datosclientes.Refresh()
datospedidos.DataSource = conjuntodedatos.Tables("pedidos")
datospedidos.Refresh()
Se asigna a la propiedad DataSource de los objetos DataGridView

datosclientes y datospedidos el conjunto de datos respectivo. Con el procedimiento
Refresh() se refresca cada uno de los controles DataGridView.
Dim tabladatosclientes As DataTable = conjuntodedatos.Tables("clientes")
Dim tabladatospedidos As DataTable = conjuntodedatos.Tables("pedidos")
Se crean dos objeto de tipo DataTable ( tabla de datos en memoria)

tabladatosclientes, tabladatospedidos a los cuales se le asignan los datos de las tablas
clientes, pedidos respectivamente.
Dim consultalinqdataset = From filaclientes In tabladatosclientes.AsEnumerable _
Join filapedidos In tabladatospedidos.AsEnumerable _
On filaclientes.Field(Of String)("nit") Equals filapedidos.Field(Of String)("nit") _
Where (filaclientes.Field(Of String)("nit") = 100) _
Select New With { _
.nit = filaclientes.Field(Of String)("nit"), _
.empresa = filaclientes.Field(Of String)("empresa"), _
312
.representante = filaclientes.Field(Of String)("representante"), _
.fechaentrega = filapedidos.Field(Of String)("fechaentrega"), _
.observacion = filapedidos.Field(Of String)("observacion") _
}
tablasrelacionadas.DataSource = consultalinqdataset.ToList
Se crea una consulta combinada con la clausula Join que realiza la relacion de las
tablas clientes, pedidos por el campo común nit (Equals), con la condicion (where) de
que el nit sea igual a 100, además, se seleccionan (Select New With) los campos de las
dos tablas que se quieren mostrar. Por último se asigna a la propiedad DataSource del
objeto tablasrelacionadas el resultado de la consulta (consultalinqdataset). Se utiliza
la función AsEnumerable para obtener una colección de todas las filas de los datos,
como también la función Field para el especificar el tipo de dato de las columnas de
cada fila.
Al ejecutarse el proyecto ConsultaLinqDataSet, se visualizará en el formulario los

controles DataGridView con las tablas clientes, pedidos y la relación de dichas tablas
con los datos relacionados del nit igual a 100.
Figura 13.45 Ejecución de la consulta LINQ to DataSet.
313
13.5 Ejercicios de consulta LINQ
1. Crear un programa que permita realizar una conexión a una base de datos y
mostrar datos de una tabla utilizando una consulta LINQ.
2. Elaborar un programa que permita realizar una consulta que permita eliminar los
registros cuyo nit sea mayor que 500.
3. Escribir un programa que permita por medio de una consulta visualizar los
registros de una tabla cuyo nombre de empresa empiecen por la letra C.
4. Diseñar un programa que permita con una consulta visualizar los nombre de los
productos de la tabla productos en un control DataGridView.
5. Hacer un programa que permita visualizar una consulta de la tabla clientes
ordenada por un campo de dicha tabla especificada por un usuario.
6. Realizar un programa que permita visualizar en una consulta los registros
relacionados de las tablas clientes y pedidos cuya fecha de entrega sea igual o
mayor que “02/23/2008”.
7. Hacer un programa que permita visualizar en una consulta los registros
relacionados de las tablas clientes cuya fecha de vencimiento sea el mes de
agosto.
8. Realizar un programa que permita visualizar en una consulta todos los productos
cuyo valor sea mayor que 5000.
9. Realizar un programa que permita visualizar en una consulta la relación entre
tres tablas de una base de datos en SQL Server.
10. Hacer un programa que permita visualizar en una consulta todos los pedidos que
tengan más de tres productos.
314
14. APLICACIONES WEB ASP.NET
ASP.NET es un marco de trabajo de programación generado en Common Language

Runtime que puede utilizarse en un servidor para generar eficaces aplicaciones Web.
ASP.NET, ofrece varias ventajas importantes, como son:
 Mejor rendimiento. ASP.NET aprovecha las ventajas del enlace anticipado, la

compilación just-in-time, la optimización nativa y los servicios de caché desde
el primer momento.
 Compatibilidad con herramientas de primer nivel. El marco de trabajo de

ASP.NET se complementa con un diseñador y una caja de herramientas muy
completos en el entorno integrado de programación (Integrated Development
Environment, IDE) de Visual Studio.
 Eficacia y flexibilidad. La biblioteca de clases de .NET Framework, la

mensajería y las soluciones de acceso a datos se encuentran accesibles desde el
Web de manera uniforme. ASP.NET es también independiente del lenguaje, por
lo que puede elegir el lenguaje que mejor se adapte a la aplicación o dividir la
aplicación en varios lenguajes.
 Simplicidad. El marco de trabajo de las páginas de ASP.NET permite generar

interfaces de usuario, que separan claramente la lógica de aplicación del código
de presentación y controlar eventos en un sencillo modelo de procesamiento de
formularios de tipo Visual Basic.
 Facilidad de uso. ASP.NET emplea un sistema de configuración jerárquico,

basado en texto, que simplifica la aplicación de la configuración al entorno de
servidor y las aplicaciones Web. Una aplicación ASP.NET Framework se
implementa en un servidor sencillamente mediante la copia de los archivos
necesarios al servidor.
 Escalabilidad y disponibilidad. El motor de tiempo de ejecución de ASP.NET

controla y administra los procesos de cerca, por lo que si uno no se comporta
adecuadamente (filtraciones, bloqueos), se puede crear un proceso nuevo en su
lugar, lo que ayuda a mantener la aplicación disponible constantemente para
controlar solicitudes.
 Posibilidad de personalización y extensibilidad. ASP.NET presenta una

arquitectura bien diseñada que permite a los programadores insertar su código en
el nivel adecuado.
 Seguridad. Con la autenticación de Windows integrada y la configuración por
aplicación, se puede tener la completa seguridad de que las aplicaciones seguras.
Este tutorial se trabaja con el entorno de desarrollo de Microsoft Visual Studio

.NET 2008.
ASP.NET es un entorno de programación que se ejecuta en un servidor Web

para generar y administrar páginas Web. Visual Studio 2008 proporcionar el diseñador
de formularios Web, un editor, controles y un sistema de depuración para facilitar la
creación de aplicaciones que guardadas en un servidor pueden ser accesadas desde un
315
explorador, teléfonos móviles, etc...
Figura 14.1 Página de Inicio de Visual Studio 2008.
14.1 Aplicación Web (ASP.NET)
Crear una aplicación Web ASP.NET utilizando el lenguaje de programación Visual

Basic .NET requiere de unos pasos muy sencillos como son: iniciar un nuevo sitio Web,
crear la interfaz del usuario, establecer las propiedades de los objetos, escribir el código
y ejecutar el sitio Web.
Como ejemplo, se creará un sitio Web llamado PedidoWeb que permita a un

usuario seleccionar comida y bebida en un restaurante y visualizar el valor a pagar por
los productos pedidos. Se debe imprimir el subtotal, el impuesto por valor agregado
(I.V.A. 16%) y el valor neto a pagar.
14.1.1 Crear un nuevo sitio Web
Para iniciar un nuevo sitio Web desde la página de inicio de Visual Studio 2008, se
puede realizar uno de los siguientes pasos:
1. En la ventana proyectos recientes seleccionar la opción Crear: link Sitio Web…
2. Dar clic en el menú Archivo y seleccionar Nuevo sitio Web...
Al escoger una de las dos opciones se visualizará la ventana Nuevo sitio Web,
donde se deberá seleccionar la plantilla SitioWeb ASP.NET.
316
Figura 14.2 Ventana Nuevo sitio Web ASP.NET.
En la opción Ubicación puede crear el sitio web en un Sistema de archivos

(Discos de trabajo), una ubicación HTTP o FTP, escoja Sistema de archivos. Con el
botón Examinar puede buscar la carpeta donde desea guardar el nuevo sitio Web o
simplemente digite la ruta de trabajo y a continuación asigne el nombre del sitio
PedidoWeb. El lenguaje será Visual Basic. Pulse el botón Aceptar para visualizar el
entorno de diseño del sitio Web PedidoWeb.
Figura 14.3 Entorno de diseño de un nuevo sitio Web.
317
Como se puede apreciar, el entorno de desarrollo es parecido al entorno de las
aplicaciones Windows Forms. En él encontrará:
1. Menú principal y la barra de herramientas estándar: Proporcionan acceso a

la mayoría de comandos que controlan el entorno de programación de Visual
Studio .NET.
2. Cuadro de Herramientas: El cuadro de herramientas contiene las fichas:
Estándar, Datos, Validación, Navegación, Inicio de sesión, Elementos Web,
Extensiones Ajax, Informe, HTML. Cada ficha contiene controles que al
añadirse a un formulario Web se convierte en un objeto de la interfaz de usuario
programable en la aplicación.
3. Diseñador formularios Web: Cuando se inicia un sitio Web el diseñador de
formularios de Web se abre en vista Diseño (un formulario tiene vista diseño
cundo se inicia el sitio y está en modo de ejecución cuando se ejecuta la
aplicación), mostrándose el formulario Web Default.aspx. En la parte inferior
del formulario Web se encuentran las pestañas Diseño, Dividir (divide el
formulario Web en dos partes: una en modo diseño y en la otra mitad se
visualiza el código HTML del formulario Web), Código (muestra el código
HTML), como también las pestañas <html>, <body>, <form#form1>, <div>.
En dicho formulario Web se pueden ubicar los controles u objetos necesarios
para la aplicación arrastrándolos desde el cuadro de herramientas para crear la
interfaz de usuario.
4. Explorador de soluciones: Visualiza las carpetas y archivos que se han creado.
Si observa en la carpeta donde guardó el sitio Web se creó la carpeta App_Data
y los archivos Default.aspx, Default.aspx.vb (este archivo contiene el código
fuente que da soporte a la página Default.aspx) y Web.xml (archivo de
configuración xml).
5. Ventana de propiedades: Muestra una lista de las propiedades que facilitan la
configuración de los valores o propiedades del control seleccionado y se pueden
modificar mientras se crea o se edita la aplicación. Una propiedad describe una
característica de un objeto, como el tamaño, título, color, etc.
6. Ventana lista de errores: Muestra una lista de los errores, advertencias o
mensajes que se generan al realizar modificaciones a los controles o al ejecutar
la aplicación.
14.1.2 Crear la interfaz de usuario
Para crear la interfaz de usuario del sitio Web, en primer lugar se deben ubicar los
controles necesarios en el formulario Web desde el cuadro de herramientas. Para el
ejemplo se diseñara la interfaz de usuario utilizando los siguientes controles: 7 Label, 3
TextBox, 1 ListBox 1 DropDownList, 2 Button y 1 GridView (ficha datos).
Cuando existen varios controles del mismo tipo, estos se numeran en el mismo
orden en que son colocados (nombre del control más numero del consecutivo). La
interfaz inicial de usuario del ejemplo debería mostrar el siguiente aspecto:
318
Figura 14.4 Interfaz de usuario inicial sitio Web PedidoWeb.
14.1.3 Establecer las propiedades de los controles
Después de colocar los controles u objetos a un formulario Web, se puede establecer sus
Para modificar las propiedades se selecciona el control en el formulario Web y
se cambia su configuración en la ventana Propiedades. Para el caso del ejemplo
establezca las siguientes modificaciones a cada uno de los siguientes controles:
Tabla 14.1 Propiedades de los controles del sitio PedidoWeb.

Label1 ID lbltitulo
Text Pedidos – Restaurante la FRIKY.
Font - Bold True
Label2 ID lblcomida
Text Seleccione Comida:
Label3 ID lblbebida
Text Seleccione Bebida:
Label4 ID lblpedido
Text Pedido
Font - Bold True
Label5 ID lblsubtotal
Text SubTotal:
Label6 ID lbliva
Text I.V.A.:
Label7 ID lbltotal
Text Neto a Pagar:
TextBox1 ID txtsubtotal
TextBox2 ID txtiva
TextBox3 ID txtsubtotal
ListBox1 ID listacomida
319
AutoPostBack True
DropDownList1 ID listabebida
AutoPostBack True
Button1 ID botoncomida
Text Adicionar Comida
Button2 ID botonbebida
Text Adicionar Bebida
GridView1 ID tablapedido
Form1 ID formulario
Document Title Restaurante la FRIKY
Default.aspx Nombre del archivo pagina.aspx
Ahora seleccione el control ListBox llamado listacomida, dé clic en la flecha de

la parte superior derecha del control para ver las Tareas de ListBox y escoja la opción
Editar Elementos… para ver la ventana Editor de la colección ListItem:
Figura 14.5 Ventana Editor de la colección ListItem del control listacomidas.
Pulse el botón Agregar del Editor de la colección ListItem, busque la

propiedad Text y cambie el texto por Arroz con Pollo. Realice los mismos pasos para
agregar los textos: Pescado, Mondongo, Ajiaco, Carne. Por último pulse el botón
Aceptar.
Figura 14.6 Elementos agregados al objeto listacomida.
320
Luego seleccione el control DropDownList llamado listabebida, dé clic en la
flecha de la parte superior derecha del control para ver las Tareas de DropDownList y
escoja la opción Editar Elementos… para ver la ventana Editor de la colección
ListItem y adicione de la misma forma los siguientes elementos de la misma forma
como se hizo en el control listacomida: Cerveza, Jugo, Limonada, Vino, Gaseosa.
Figura 14.7 Elementos agregados al objeto listabebida

Figura 14.8 Formulario Web final de la interfaz de usuario.
Por último si se desea cambiar el formato del objeto GridView tablapedido,
321
selecciónelo y dé clic en la flecha de la parte superior derecha del control para ver las
Tareas de GridView y escoja la opción formato automático… para ver la ventana
Autoformato y elija el formato que desee. Para el ejemplo, se escogió el formato
Multicolor.
14.1.4 Escribir código
Una vez se hayan establecido las propiedades del formulario Web y sus objetos, se
puede agregar el código que se ejecutará en respuesta a un evento especifico de cada
control.
1. Despúes de la apertura de Partial class _Default y antes del primer

procedimiento Sub, declare como publicas las variables llamadas valor, i,
sumar de tipo Integer. Dé doble clic sobre el formulario y escriba este código
escriba:
Partial Class _Default

Inherits System.Web.UI.Page
Dim datos As New Data.DataTable
Public Shared valor, sumas As Integer
Se declara el objeto datos al cual se le asigna espacio de memoria de tipo

DataTable (tabla de datos). Por otro lado, se establecen como públicas compartidas
(public shared) las variables valor, sumas de tipo Integer. Son declaradas compartidas
porque se está trabajando en un entorno Web.
2. Seleccione el objeto formulario, dé doble clic para abrir el editor del

procedimiento Page_Load y escriba el siguiente código:
If IsPostBack Then
datos.Columns.Add("Producto")
datos.Columns.Add("Precio")
End If
Cuando se cargue la página en el explorador (IsPostBack) se le adiciona al

objeto datos las columnas que se van a mostrar en el GridView.
3. Dé doble clic en el objeto ListBox llamado listacomida, para abrir el editor del
procedimiento listacomida_SelectedIndexChanged y escriba el siguiente
código:
If listacomida.SelectedIndex = 0 Then
valor = 10000
End If
valor = 13000
End If
valor = 8000
End If
valor = 9000
End If
322
valor = 12000
End If
En el anterior código se utiliza la estructura de control If para determinar qué

posición del objeto listacomida se ha seleccionado utilizando la propiedad
SelectedIndex. Dependiendo del index seleccionado se le asignará al objeto valor el
valor correspondiente.
4. Dé doble clic en el objeto DropDownList llamado listabebida, para abrir el

editor del procedimiento listabebida_SelectedIndexChanged y escriba el
siguiente código:
If listabebida.SelectedIndex = 0 Then
valor = 3000
End If
valor = 2000
End If
valor = 1800
End If
valor = 4000
End If
valor = 1500
End If
Con la estructura de control If se obtiene el elemento seleccionado del objeto

listabebida. Dependiendo del index seleccionado se le asignará al objeto valor el valor
correspondiente.
5. Dé doble clic en el objeto Button llamado botoncomida, para abrir el editor del
procedimiento botoncomida_Click y escriba el siguiente código:
Dim nuevafila As Data.DataRow

Dim i As Integer
For i = 0 To tablapedido.Rows.Count - 1
nuevafila = datos.NewRow()
Dim fila As GridViewRow = tablapedido.Rows(i)
nuevafila("Producto") = fila.Cells(0).Text
nuevafila("Precio") = fila.Cells(1).Text
datos.Rows.Add(nuevafila)
Next
nuevafila("Producto") = listacomida.SelectedItem
nuevafila("Precio") = valor
tablapedido.DataSource = datos
tablapedido.DataBind()
sumas = 0
Dim sumafila As GridViewRow = tablapedido.Rows(i)
sumas = sumas + Val(sumafila.Cells(1).Text)
Next
txtsubtotal.Text = Val(sumas)
323
txtiva.Text = Val(txtsubtotal.Text) * 0.16
txttotal.Text = Val(txtsubtotal.Text) + Val(txtiva.Text)
Inicialmente se crea un objeto llamado nuevafila de tipo DataRow (representa

una fila de datos) y la variable i de tipo Integer. En el caso de que ya existan filas en el
objeto GridView, con un primer ciclo For se recorrerá el objeto GridView tablapedido
para guardar en el objeto datos las filas actuales antes de adicionar una nueva. En dicho
ciclo al objeto nuevafila se le asigna una nueva fila (NewRow ()). Utilizando la función
Rows se le asigna a la variable fila de tipo GridViewRow la fila actual del objeto
tablapedido y a nuevafila se le asignan el nombre de las columnas y los valores de
dichas columnas en la posición actual. Por último se adiciona al objeto datos la nueva
fila (Rows.add). Al salir del ciclo al objeto nuevafila se le asigna una nueva fila y se le
adiciona a la columna Producto el texto seleccionado del objeto listacomida y a la
columna Precio el valor de lo seleccionado y luego es adicionado al objeto datos.
Utilizando la propiedad DataSource del objeto tablapedidos se le asigna el objeto
datos y se enlaza al orígen de datos (tablapedido.DataBind ()). En un segundo ciclo
For se recorre cada una de las filas que contenga el objeto tablapedido y se asigna a la
variable suma el valor de ella misma más los valores encontrados en la columna Precio.
Por último se asignan los siguientes valores a los objeto TextBox: txtsubtotal el valor
de la variable sumas; a txtiva el 16 % del valor del objeto txtsubtotal; y a txttotal la
suma de los objetos txtsubtotal y txtiva.
6. Dé doble clic en el objeto Button llamado botonbebida, para abrir el editor del
procedimiento botoncomida_Click y escriba el siguiente código:
Dim nuevafila As Data.DataRow

Dim i As Integer
Dim fila As GridViewRow = tablapedido.Rows(i)
nuevafila("Producto") = fila.Cells(0).Text
nuevafila("Precio") = fila.Cells(1).Text
Next
nuevafila("Producto") = listabebida.SelectedItem
nuevafila("Precio") = valor
tablapedido.DataSource = datos
tablapedido.DataBind()
sumas = 0
Dim sumafila As GridViewRow = tablapedido.Rows(i)
sumas = sumas + Val(sumafila.Cells(1).Text)
Next
txtsubtotal.Text = Val(sumas)
txtiva.Text = Val(txtsubtotal.Text) * 0.16
txttotal.Text = Val(txtsubtotal.Text) + Val(txtiva.Text)
El único cambio que se realiza en el objeto botonbebida con respecto al anterior

código es que al objeto nuevafila se le adiciona a la columna Producto el texto
seleccionado del objeto listabebida.
324
14.1.5 Ejecutar la aplicación Web
Para ejecutar el sitio Web en el entorno de desarrollo de Visual Basic.NET se debe

1. Haga clic en el botón Iniciar depuración de la barra de herramientas estándar.
También puede presionar Ctrl+F5 para ejecutar el sitio Web. Otra forma es la opción
Iniciar depuración del menú Depurar.
2. Cuando termine de ejecutar la aplicación se debe cerrar el formulario Web para
regresar al entorno de programación.
Figura 14.9 Ventana de Ejecución sitio Web PedidoWeb
Cuando se ejecuta el sitio Web se visualizará la ventana de Depuración no

habilitada. Si se ejecuta Modificar el archivo Web.config para habilitar la
depuración se mostrará la página Web en el explorador seleccionado y esta ventana no
se volverá a mostrar al ejecutarse nuevamente el sitio Web, por el contrario, si se
selecciona Ejecutar sin depuración se mostrará inicialmente una página Web en
blanco, la cual deberá cerrar para visualizar el sitio Web ejecutado (cada vez que se
ejecute esta opción se visualizará la ventana de Depuración no habilitada). Seleccione la
primera opción para ver la siguiente figura.
Figura 14.10 Sitio Web PedidoWeb ejecutado.
325
Al seleccionar como comida Arroz con Pollo y Ajiaco y como bebida Vino y
Cerveza, se visualiza la siguiente figura:
Figura 14.11 Sitio Web con comida y bebida seleccionados.
14.1.6 Cerrar y abrir nuevamente un sitio Web
Para cerrar el sitio Web PedidoWeb o cualquier otro sitio web, estando en modo diseño
se pueden realizar los siguientes pasos:
1. En el menú Archivo, hacer clic en la opción Cerrar Proyecto.

2. Si desea cerrar el sitio Web y salir de Visual Studio, en el menú Archivo haga clic en
la opción Salir.
En cada caso se deben guardar los nuevos cambios que se hayan realizado.
Para volver a abrir la aplicación PedidoWeb o cualquier otra aplicación

existente se deberán realizar los siguientes pasos:
1. Abrir Visual Studio .NET.

2. Si en la pantalla inicial de Visual Studio .NET se visualiza el nombre del sitio Web que
se desea abrir haga doble clic para abrir la aplicación. Si por el contrario no se visualiza
la aplicación en el menú Archivo, seleccione Abrir sitio Web..., busque la carpeta
PedidoWeb y pulse el botón Abrir para abrir la aplicación Web en el entorno de
desarrollo de Visual Basic .NET.
14.2 Controles para interfaz de usuario ASP.NET
La mayoría de los controles del cuadro de herramientas son similares a los trabajados en
las aplicaciones Windows Forms, en el ejemplo anterior se utilizaron los objetos Label,
TextBox, Button, ListBox, DropDownList (ComboBox en Windows Forms) y
GridView (DataGridView en Windows Forms) y como se puede apreciar, el diseño y
la programación son muy similares. En este capítulo se realizará una descripción breve
326
y un ejemplo práctico de los siguientes controles: CheckBoxList, ImageMap,
BulletedList, RadioButtonList, HyperLink, MultiView, View y los controles de
validación: RequiredFieldValidator, RangeValidator, CompareValidator,
CustomValidator, RegularExpressionValidator, ValidationSummary.
14.2.1 Control CheckBoxList
Un control CheckBoxList es una lista de casillas de verificación que permite

obtener dos estados: verdadero (True) si esta activada o falso (False) si esta
desactivada. Para obtener el valor de verdadero o falso se hace a través de la propiedad
Selected.
14.2.1.1 Ejemplo práctico control CheckBox List
Realizar un sitio Web llamado ControlWebCheckBoxList que permita a un usuario

seleccionar de una lista frutas e imprimir las frutas seleccionadas en un control ListBox.

siguientes controles en el formulario Web: 1 CheckBoxList, 1 ListBox, 2 Label.

Tabla 14.2 Propiedades de los controles (ControlWebCheckBoxList).

Label1 ID lblfrutas
Text Selección de Frutas
Font - Bold True
ID lblfrutaseleccionadas
Label2 Text Frutas Seleccionadas
Font - Bold True
CheckBoxList1 ID listafrutas
AutoPostBack True
ListBox1 ID listafrutasseleccionadas
AutoPostBack True
Form1 ID formulario
Document Title Control CheckBoxList
Default.aspx Nombre del pagina.aspx
archivo
Ahora seleccione el control CheckBoxList llamado listafrutas, dé clic en la

flecha de la parte superior derecha del control para ver las Tareas de CheckBoxList y
escoja la opción Editar Elementos… para ver la ventana Editor de la colección
ListItem. Pulse el botón Agregar del Editor de la colección ListItem, busque la
propiedad Text y cambie el texto por Manzanas. Realice esta misma operación hasta
327
obtener la siguiente figura:
Figura 14.12 Editor de la colección ListItem con elementos.
Por último pulse el botón Aceptar.

Figura 14.13 Formulario Web final de la interfaz de usuario.
Dé doble clic en el objeto CheckBoxList llamado listafrutas, para abrir el editor del
328
procedimiento listafrutas_SelectedIndexChanged y escriba el siguiente código:
listafrutasseleccionadas.SelectionMode = ListSelectionMode.Multiple
listafrutasseleccionadas.Items.Clear()
Dim i As Integer
For i = 0 To listafrutas.Items.Count - 1
If listafrutas.Items(i).Selected = True Then
listafrutasseleccionadas.Items.Add(listafrutas.Items(i).Text)
End If
Next
Utilizando la enumeración ListSelectionMode.Multiple se le asigna selección

múltiple en su propiedad SelectionMode al objeto listafrutasseleccionadas, como
también se remueven todos los elementos actuales de dicho objeto utilizando la función
Clear de la propiedad Items. Con un ciclo For se leen cada uno de los elementos del
objeto listafrutas y aquel elemento que este seleccionado se adiciona al objeto
listafrutasseleccionadas.
 Ejecutar la aplicación
Al ejecutarse el proyecto y seleccionar las frutas Naranjas, Fresas, Bananos, Mangos

se obtendría la siguiente figura:
Figura 14.14 Ejecución de la aplicación ControlWebCheckBoxList.
14.2.2 Control ImageMap
Un control ImageMap permite que en una imagen se puedan crear zonas activas,
que pueden ser seleccionadas al hacer clic con el mouse. Está formado por dos
329
elementos: El primero es una imagen como un archivo .gif, .jpg, .png, .bmp, etc.; El
segundo es una colección de zonas activas, donde cada zona puede ser definida como un
círculo, un rectángulo o un polígono y unas coordenadas que especifican la ubicación y
el tamaño de la zona activa. Cada zona activa puede ser un hipervínculo o un evento que
devuelve información.
14.2.2.1 Ejemplo práctico control ImageMap
Crear un sitio Web llamado ControlImageMap que permita a un usuario seleccionar

una zona de una imagen entre cuatro zonas activas e imprimir el nombre del objeto
seleccionado. Se debe tener una imagen donde se puedan diferenciar las zonas activas.

siguientes controles en el formulario Web: 2 Label y 1 ImageMap.

Tabla 14.3 Propiedades de los controles (ControlImageMap).

Label1 ID lbltexto
Text Imagen con cuatro dibujos
Font - Bold True
ID lblseleccion
Label2 Text Selección:
Font - Bold True
ImageMap1 ID mapa_imagen
Height 200
Width 200
Form1 ID formulario
Document Title Control ImageMap
Con las modificaciones anteriores el control ImageMap llamado mapa_imagen

tiene un alto (Height) y un ancho (Width) de 200 pixeles. Seleccione el objeto
mapa_imagen, busque la propiedad ImageURL y agregue una imagen (ojala que se
puedan destacar cuatro partes diferentes). Luego busque la propiedad HotSpot para
definir las zonas activas, dé clic en los tres puntos ( ) para ver el Editor
de la colección HotSpot
330
Figura 14.15 Editor de la colección HotSpot.
Pulse en la punta de flecha del botón Agregar y seleccione RectangleHotSpot y

en las siguientes propiedades realice los siguientes cambios para crear la primera zona
activa: Bottom = 100, Left=0, Right=100, Top=0, HotSpotMode (establece el
comportamiento del objeto) = PostBack (genera una devolución de datos al servidor) y
PostBackValue (obtiene el objeto seleccionado) =imagen_portatil.
Figura 14.16 Propiedades modificadas de la primera zona activa.
Realice la misma operación para agregar tres nuevas zonas activas a la imagen,
con los siguientes valores en la respectiva propiedad.
331
Tabla 14.4 Propiedades de zonas activas.
Zonas Propiedades
Bottom Left Right Top HotSpotMode PostBackValue
Segunda 100 100 200 0 PostBack imagen_robot
Tercera 200 0 100 100 PostBack imagen_celular
Cuarta 200 100 200 100 PostBack imagen_bicicleta
Figura 14.17 Objeto mapa_imagen con las cuatro zonas activas.
Por último pulse el botón Aceptar.

Figura 14.18 Formulario Web con interfaz de usuario final.
332
Dé doble clic en el objeto ImageMap llamado mapa_imagen, para abrir el editor del
procedimiento mapa_imagen_Click y escriba el siguiente código:
Dim region As String = ""

Select Case e.PostBackValue
Case "imagen_portatil"
region = "El PORTATIL"
Case "imagen_robot"
region = "El ROBOT"
Case "imagen_celular"
region = "El CELULAR"
Case "imagen_bicicleta"
region = "La BICICLETA"
End Select
lblseleccion.Text = "selecciono:" & region
Inicialmente se crea una variable de tipo String llamada region la cual es

inicializada con un espacio. Utilizando la estructura Select se obtiene la zona
seleccionada (e.PostBackValue). Según sea el caso se le asigna a la variable region el
texto correspondiente y es adicionada a la propiedad Text del objeto lblseleccion.
Al ejecutarse el proyecto y seleccionar la zona dos (el robot) se obtendría la siguiente

figura:
Figura 14.19 Ejecución de la aplicación ControlImageMap.
14.2.3 Control BulletedList
Un control BulletedList permite crear una lista de elementos ordenados y no

ordenados. Los elementos se pueden mostrar como viñetas o números utilizando la
propiedad BulletStyle y éstan pueden ser: Numbered, LowerAlpha, UpperAlpha,
LowerRoman, UpperRoman, Disc, Circle, Square ó CustomImage. Se deben definir
333
las propiedades: Text y Value. Text detalla lo que el control va a mostrar en la página.
Value devuelve un valor deseado al seleccionar un elemento. Este control responde al
evento clic para devolver datos del servidor.
14.2.3.1 Ejemplo práctico control BulletedList
Diseñar un sitio Web llamado ControlBulletedList que permita a un usuario

seleccionar de una lista una página de Internet y abrirla utilizando el control
BulletedList.

siguientes controles en el formulario Web: 1 Label y 1 BulletedList.

Tabla 14.5 Propiedades de los controles (ControlBulletedList).

Label1 ID lbltexto
Text Control Bulletedlist – lista de páginas de Internet
Font - Bold True
ID listapaginas
BulletedList1 DisplayMode HyperLink
BulletStyle UpperAlpha
Form1 ID formulario
Document Title Control BulletedList
Al arrastrarse el objeto BulletedList hacia el formulario, en la ventana Tareas

de BulletedList seleccione Editar elementos… para ver el Editor de la colección
ListItem. Seleccione el botón Agregar y en la propiedad Text escriba ASP.NET, en la
propiedad Value escriba http://www.asp.net.
Figura 14.20 Editor de la colección ListItem con un elemento agregado.
334
Además agregue los siguientes elementos:
Tabla 14.6 Propiedades de los elementos restantes del control listapaginas.
Propiedades
Text Value
MICROSOFT http://www.microsoft.com
GOOGLE http://www.google.com
JAVA http://www.java.sun
El editor quedaría de la siguiente forma:
Figura 14.21 Editor de la colección ListItem con los elementos agregados.
Por último pulse el botón Aceptar. La interfaz de usuario con las modificaciones
respectivas en las propiedades de cada control queda como se muestra en la siguiente
figura:
Figura 14.22 Interfaz de usuario final aplicación ControlBullettedList.
335
Al ejecutarse el proyecto se mostrará la siguiente figura:
Figura 14.23 Ejecución del sitio Web ControlBulletedList.
Al seleccionar el elemento ASP.NET, se visualizará la siguiente figura:
Figura 14.24 Ejecución al seleccionar el elemento ASP.NET.
336
14.2.4 Control RadioButtonList
Un control RadioButtonList permite a un usuario escoger una alternativa entre

varias alternativas. Al igual que el control CheckBoxList puede obtener el valor de
verdadero (True) o falso (False) a través de la propiedad Selected.
14.2.4.1 Ejemplo práctico control RadioButtonList
Escribir una aplicación Web llamada ControlRadioButtonList que permita a un

usuario seleccionar y abrir una página Web utilizando los objetos RadioButtonList y
HyperLink.

siguientes controles en el formulario Web: 1 Label, 1 HyperLink y 1
RadioButtonList.

Tabla 14.7 Propiedades de los controles (ControlRadioButtonList).

Label1 ID lbltexto
Text Control RadioButtonList – lista de páginas de Internet
Font - Bold True
Label2 ID lblhipertexto
Text Ir a la página :
Font - Bold True
ID listapaginas
RadioButton AutoPostBack True
HyperLink1 ID hipertexto
Form1 ID formulario
Document Title Control RadioButtonList
Ahora seleccione el objeto RadioButtonList y dé clic sobre la flecha en la parte

superior derecha del control para ver la ventana Tareas de RadioButtonList, al
seleccionar la opción Editar elementos… se visualizará el Editor de la colección
ListItem. Seleccione el botón Agregar y en la propiedad Text escriba Asp.NET, en la
propiedad Value escriba http://www.asp.net/ES.
337
Figura 14.25 Editor de la colección ListItem con un elemento agregado.
Además agregue los siguientes elementos:
Tabla 14.8 Propiedades de los elementos restantes del control listapaginas.
Propiedades
Text Value
Microsoft http://www.microsoft.com
Google http://www.google.com
Java http://www.java.sun
El editor quedaría de la siguiente forma:
Figura 14.26 Editor de la colección ListItem con los elementos agregados.
Por último pulse el botón Aceptar. La interfaz de usuario con las modificaciones
respectivas en las propiedades de cada control queda como se muestra en la siguiente
figura:
338
Figura 14.27 Interfaz de usuario final aplicación ControlRadioButtonList.
Dé doble clic en el objeto RadioButtonList llamado listapaginas, para abrir el editor

del procedimiento listapaginas_SelectedIndexChanged y escriba el siguiente
código:
Dim i As Integer
For i = 0 To listapaginas.Items.Count - 1
If listapaginas.Items(i).Selected = True Then
hipertexto.NavigateUrl = listapaginas.Items(i).Value
hipertexto.Text = listapaginas.Items(i).Value
End If
Next
Con un ciclo For se leen cada uno de los elementos del objeto listapaginas y al
encontrar el elemento que está seleccionado se asigna a la propiedad Text del objeto
hipertexto el texto de la propiedad Value del objeto listapaginas, como también se le
adiciona dicho valor a la propiedad NavigateUrl.
Al ejecutarse el proyecto y seleccionar la opción Asp.NET se visualiza la siguiente

figura:
339
Figura 14.28 Ejecución de la aplicación ControlRadioButtonList.
Al pulsar el link http://www.asp.net/ES/ se obtendrá la siguiente figura:
Figura 14.29 Ejecución página asp.net.
14.2.5 Control MultiView
Un control MultiView es un contenedor de controles View. El control View

puede contener un grupo de controles. Estos siempre deben especificarse dentro de un
control MultiView y solo se puede tener un control View activo a la vez. Con la
propiedad ActiveViewIndex se puede establecer el control View que está activo ó
también para devolver el índice de la vista activa. El primer control View declarado
dentro del objeto MultiView tiene como índice cero (0).
340
14.2.5.1 Ejemplo práctico control MultiView
Elaborar una aplicación Web llamada ControlMultiView que permita a un usuario

responder una encuesta y visualizar las respuestas seleccionadas utilizando los controles
MultiView y View.
Se realizará la interfaz de usuario de la siguiente forma:
a) Utilizando el cuadro de herramientas ubique los siguientes controles en el

formulario Web: 1 Label y 1 MultiView. Establezca las siguientes propiedades
a los controles:
Tabla 14.8 Propiedades de los controles MultiView y Label.

Label1 ID lbltexto
Text Controles MultiView y View.
Font - Bold True
MultiView1 ID multiplesvistas
ActiveViewIndex 0
Form1 ID formulario
Document Title Controles MultiView y View
La interfaz inicial quedaría de la siguiente forma:
Figura 14.30 Interfaz de usuario controles MultiView y Label.
b) Agregue cuatro (4) controles View y establezca las siguientes propiedades a los
controles:
341
Tabla 14.9 Propiedades de los controles View.

View1 ID primeravista
View2 ID segundavista
View3 ID terceravista
View4 ID cuartavista
La interfaz quedaría de la siguiente forma:
Figura 14.31 Interfaz de usuario con los controles MultiView y View.
c) Seleccione el objeto View llamado primeravista y agregue los siguientes

controles: 1 Label, 1 CheckBoxList y 1 Button, además establezca las
siguientes propiedades a los controles:
Tabla 14.10 Propiedades de los controles del objeto primeravista.

Label1 ID lbldeportes
Text Seleccionen los deportes que te gustan:
Font - Bold True
CheckBoxList1 ID listadeportes
Button1 ID botonsiguiente
Text Siguiente
Seleccione el objeto listadeportes y agréguele los siguientes elementos: Futbol,

Baloncesto, Ciclismo, Natación, Atletismo. El objeto primeravista quedaría de la
siguiente forma:
342
Figura 14.32 Interfaz del objeto primeravista.
d) Seleccione el objeto View llamado segundavista y agregue los siguientes

controles: 1 Label, 1 RadioButtonList y 2 Button, además establezca las
Tabla 14.11 Propiedades de los controles del objeto segundavista.

Label1 ID lblpractica
Text Los prácticas por:
Font - Bold True
RadioButtonList1 ID listapractica
Button1 ID botonsiguiente2
Text Siguiente
Button2 ID botonanterior
Text Anterior
Seleccione el objeto listapractica y agréguele los siguientes elementos: Salud,

Pasatiempo, Estética. El objeto segundavista quedaría de la siguiente forma:
Figura 14.33 Interfaz del objeto segundavista.
e) Seleccione el objeto View llamado terceravista y agregue los siguientes

controles: 1 Label, 1 RadioButtonList y 2 Button, además establezca las
343
Tabla 14.12 Propiedades de los controles del objeto terceravista.

Label1 ID lblsemana
Text Cuantas veces por semana:
Font - Bold True
RadioButtonList1 ID listasemana
Button1 ID botonterminar
Text Terminar
Button2 ID botonanterior2
Text Anterior
Seleccione el objeto listasemana y agréguele los siguientes elementos: 1 – 3

veces, 1 – 5 veces, 1 – 7 veces. El objeto terceravista quedaría de la siguiente forma:
Figura 14.34 Interfaz del objeto terceravista.
f) Seleccione el objeto View llamado cuartavista y agregue los siguientes

controles: 2 Label, además establezca las siguientes propiedades a los controles:
Tabla 14.13 Propiedades de los controles del objeto cuartavista.

Label1 ID lblrespuesta
Text El resultado de la encuesta fue:
Font - Bold True
Label2 ID listasemana
Text Respuesta
El objeto cuartavista quedaría de la siguiente forma:
Figura 14.35 Interfaz del objeto cuartavista.
344
a) Dé doble clic en el objeto Button llamado botonsiguiente del objeto

primeravista, para abrir el editor del procedimiento botonsiguiente_Click y
Dim i As Integer
lblresultado.Text = "Los deportes que prácticas son: "
For i = 0 To listadeportes.Items.Count - 1
If listadeportes.Items.Item(i).Selected Then
lblresultado.Text = lblresultado.Text & " " & listadeportes.Items.Item(i).Value
End If
Next
multiplesvistas.ActiveViewIndex = 1
Con un ciclo For se leen cada uno de los elementos del objeto listadeportes y
aquel elemento que este seleccionado se adiciona al objeto lblresultado. Con la
propiedad ActiveViewIndex se activa la segunda vista.
b) Dé doble clic en el objeto Button llamado botonsiguiente2 del objeto

segundavista, para abrir el editor del procedimiento botonsiguiente2_Click y
Dim i As Integer
lblresultado.Text = lblresultado.Text & " Lo prácticas por: "
For i = 0 To listapractica.Items.Count - 1
If listapractica.Items.Item(i).Selected Then
lblresultado.Text = lblresultado.Text & " " & listapractica.Items.Item(i).Value
End If
Next
Con un ciclo For se leen cada uno de los elementos del objeto listapractica y
aquel elemento que esté seleccionado se adiciona al objeto lblresultado. Con la
propiedad ActiveViewIndex se activa la tercera vista.
c) Dé doble clic en el objeto Button llamado botonanterior del objeto

segundavista, para abrir el editor del procedimiento botonanterior_Click y
If (multiplesvistas.ActiveViewIndex > 0) And (multiplesvistas.ActiveViewIndex <= 2) Then
multiplesvistas.ActiveViewIndex -= 1
ElseIf multiplesvistas.ActiveViewIndex = 3 Then
Else
Throw New Exception("A ocurrido un error.")
End If
Inicialmente se determina si la vista activa es mayor que 0 y menor o igual a 2

para decrementar la propiedad ActiveViewIndex del objeto multiplesvista en -1. En
caso contrario, se valida si la vista activa es igual a 3 para asignar a la propiedad
ActiveViewIndex el valor cero. En caso de que exista algún problema se lanza una
excepción (Throw New Exception) con el mensaje “A ocurrido un error”.
345
d) Dé doble clic en el objeto Button llamado botonterminar del objeto
terceravista, para abrir el editor del procedimiento botonterminar_Click y
Dim i As Integer
lblresultado.Text = lblresultado.Text & " En la semana lo prácticas: "
For i = 0 To listasemana.Items.Count - 1
If listasemana.Items.Item(i).Selected Then
lblresultado.Text = lblresultado.Text & " " & listasemana.Items.Item(i).Value
End If
Next
Con un ciclo For se leen cada uno de los elementos del objeto listasemana y
aquel elemento que esté seleccionado se adiciona al objeto lblresultado. Con la
propiedad ActiveViewIndex se activa la cuartavista.
e) Dé doble clic en el objeto Button llamado botonanterior2 del objeto

terceravista, para abrir el editor del procedimiento botonanterior2_Click y
If (multiplesvistas.ActiveViewIndex > 0) And multiplesvistas.ActiveViewIndex <= 3 Then

multiplesvistas.ActiveViewIndex -= 1
ElseIf multiplesvistas.ActiveViewIndex = 3 Then
Else
Throw New Exception("A ocurrido un error.")
End If
Inicialmente se determina si la vista activa es mayor que 0 y menor o igual a 3

para decrementa la propiedad ActiveViewIndex del objeto multiplesvista en -1. En
caso contrario, se valida si la vista activa es igual a 3 para asignar a la propiedad
ActiveViewIndex el valor uno.
Al ejecutarse el proyecto se visualizará la información de la primera vista:
Figura 14.36 Ejecución de la aplicación ControlMultiView.
346
Seleccione los deportes Baloncesto, Ciclismo y pulse el botón Siguiente para
Figura 14.37 Aplicación ControlMultiView en la segunda vista.
En este momento si desea puede devolverse a la primera vista pulsando el botón

Anterior. Seleccione la opción Pasatiempo y pulse el botón Siguiente. Se obtendrá la
siguiente figura:
Figura 14.38 Aplicación ControlMultiView en la tercera vista.
Si selecciona la opción 1 – 3 veces y se pulsa el botón Siguiente, visualizará la

cuarta vista con la información que fue seleccionada.
Figura 14.39 Aplicación ControlMultiView en la cuarta vista.
347
14.3 Controles para validar datos
En el cuadro de herramientas de una aplicación Web Asp.NET existe una ficha llamada
Validacion que contiene controles que sirven para validar información, es decir, que los
datos proporcionados en un control sean correctos de acuerdo a la información
solicitada. Como ejemplo de validación puede ser dejar en blanco un campo obligatorio,
escribir una contraseña dos veces no coincidentes, teclear un valor en un rango no
especificado. Los tipos de controles de validación son:
 RequiredFieldValidator: Se utiliza para validar que en un campo de texto sea

obligatorio tener información y no se deje vacío.
 RangeValidator: Se utiliza para validar que los datos de un control se
encuentren dentro de un rango de valores especificado. Se utiliza la propiedad
ControlToValidate para especificar el control que se va a validar. Las
propiedades MinimumValue y MaximumValue sirven para especificar los
valores mínimo y máximo de un intervalo determinado.
 CompareValidator: Se utiliza para comparar el valor de un control con un
valor especificado en otro control o con un valor constante. El control
CompareValidator utiliza las siguientes propiedades para validar la
comparación: Operator, ValueToCompare o ControlToCompare.
 RegularExpressionValidator: Se utiliza para validar que lo escrito por un
usuario sea un valor definido por una expresión regular (direcciones de correo,
números de teléfonos, etc.).
 CustomValidator: Se utiliza para validar que lo escrito por un usuario sea un
valor que previamente se ha definido por el usuario.
 ValidationSummary: Se utiliza para resumir los mensajes de error de todos los
controles de validación de una página Web.
14.3.1 Ejemplo práctico controles de validación
Realizar una aplicación Web llamada Controles_de_Validacion que permita a un

usuario digitar: Sus nombres y apellidos, indicar su dominio de ingles en un rango de 1 -
10, el estado civil, su correo electrónico y escribir una contraseña especificada.

siguientes controles en el formulario Web: 7 Label, 6 TextBox, 1
RequiredFieldValidator, 1 RangeValidator, 1 CustomValidator, 1 Button, 1
CompareValidator, 1 RegularExpressionValidator, 1 ValidationSummary.
Modifique las propiedades de los controles según la siguiente tabla:
348
Tabla 12.14 Propiedades controles de la aplicación Controles_de_Validacion.

Label1 ID txttexto
Text Encuesta Personal
Font Bold
Label2 ID lbldatos
Text Digite Nombres y Apellidos:
Label3 ID lblingles
Text Lee ingles (1 – 10);
Label4 ID lblestado
Text Estado civil (S=soltero;
C=casado; U=unión libre; V=
viudo)
Label5 ID lbcontraseña
Text Digite la contraseña 123456
Label6 ID lblcorreo
Text Correo electrónico :
Label7 ID lblerrores
Text Resumen de errores:
TextBox1 ID txtdatos
TextBox2 ID txtingles
TextBox3 ID txtestado
TextBox4 ID txtcontraseña
TextBox5 ID txtcorreo
RequiredFieldValidator1 ID validarcampo
RangeValidator1 ID validarrango
CustomValidator1 ID validarestado
RegularExpressionValidator1 ID validarexpresion
CompareValidator1 ID validarcontraseña
ValidationSummary ID validarerrores
Form1 ID formulario
Document Title Controles de validación
Button1 ID botonenviar
Text Enviar
Figura 14.40 Interfaz de usuario aplicación Controles_de_Validacion.
349
a) Dé doble clic sobre la página Web, para abrir el editor del procedimiento
Page_load y escriba el siguiente código:
If Not Page.IsPostBack Then

validarcampo.ControlToValidate = "txtdatos"
validarcampo.ErrorMessage = "Campo obligatorio, no puede ser vacio"
validarrango.ControlToValidate = "txtingles"
validarrango.Type = ValidationDataType.Integer
validarrango.MinimumValue = 1
validarrango.MaximumValue = 10
validarrango.ErrorMessage = "Debe digitar un valor entre 1 y 10"
validarestado.ControlToValidate = "txtestado"
validarestado.ErrorMessage = "Digite S,C,u o V"
validarexpresion.ControlToValidate = "txtcorreo"
validarexpresion.ValidationExpression = "\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*"
validarexpresion.ErrorMessage = "El formato del correo es:nombre@sitioweb.dominio"
validarcontraseña.ControlToValidate = "txtcontraseña"
validarcontraseña.ValueToCompare = "123456"
validarcontraseña.ErrorMessage = "La contraseña es:123456"
End If
Se utiliza IsPostBack para determinar si se está cargando la página. Con la

sentencia de toma de decisiones If se valida cuando se envía los datos al servidor para
realizar las validaciones correspondientes en cada control. Los métodos que se utilizan
son:
 ControlValidate: Es el objeto que se va a validar
 ErrorMessage: El mensaje que se imprimirá al ocurrir el error de validación.
 Type: es el tipo de dato a validar
 MinimumValue: Es el valor mínimo del control de validación
 MaximumValue: Es el valor máximo del control de validación
 ValueToCompare: Es el valor de comparación a validar.
 ValidationExpression: Es la expresión regular que se válida.
b) Seleccione el objeto botonenviar, dé doble clic para abrir el editor del

procedimiento botonenviar_Click y escriba el siguiente código:
validarcampo.Validate()
validarrango.Validate()
validarestado.Validate()
validarexpresion.Validate()
validarcontraseña.Validate()
Al pulsar el objeto botonenviar se valida cada objeto de validación referente a

la información que se ha escrito en cada uno de los campos de texto con el método
Validate () y se actualiza la propiedad IsValid.
c) Seleccione el objeto validarestado, dé doble clic para abrir el editor del

procedimiento validarestado_ServerValidate y escriba el siguiente código:
If (args.Value = "S") Then
args.IsValid = True
ElseIf (args.Value = "C") Then
args.IsValid = True
350
ElseIf (args.Value = "U") Then
args.IsValid = True
ElseIf (args.Value = "V") Then
args.IsValid = True
Else
args.IsValid = False
End If
Al digitar un valor en el campo de texto txtestado, este es validado con la

estructura de decisión If para determinar que su contenido sea un valor especificado por
el control de validación CustomValidator.
Al ejecutarse el proyecto y digitar 20, S, 2, 54 respectivamente y pulsar el botón

Enviar, se visualizará la siguiente figura:
Figura 14.41 Ejecución aplicación Controles_de_Validacion.
Como se puede apreciar, se muestran los mensajes de error en cada campo validado por
el respectivo control de validación. Si por el contrario se escriben los siguientes valores:
Cristian Vanegas, 8, S, 123456, cavm10@hot.com y se pulsá el botón Enviar, se
obtendría la página sin mensajes de error.
351
Figura 14.42 Ejecución Controles_de_Validacion con datos correctos.
352
15. ACCESO A BASES DE DATOS CON ASP.NET
Con las aplicaciones Web también es posible mostrar información de una base de datos.
En el capítulo 12 se hizo una breve descripción sobre bases de datos, el lenguaje de
consulta estructurado S.Q.L., conceptos que se pueden aplicar en los sitios Web
ASP.NET. En dicho capítulo se crearon aplicaciones Windows Forms donde se trabajo
con la base de datos SQL Server y se realizó la conexión a dicha base de datos, se
consultó y se realizarón operaciones con los registros de una o más tablas de la base de
datos, como también se diseño un informe de los registros de una tabla.
La conexión, la operación con una base de datos desde un formulario Web es

algo similar. Cuando se realiza la conexión por código de Visual Basic .NET es
necesario importar los espacios de nombres System.Data (normalmente denominado
ADO.NET) y System.Data.SqlClient.
15.1 Controles para operaciones con orígenes de datos
ASP.NET contiene controles que permiten realizar operaciones con los orígenes de
datos que administran las tareas que se pueden realizar con una base de datos. Estos no
representan ningúna interfaz de usuario, sino que actúan como intermediarios entre los
datos y los demás controles de la página Web ASP.NET. Dichos controles habilitan un
amplio conjunto de funciones para recuperar y modificar datos, entre las que se incluyen
la conexión, consulta, actualización, eliminación y la inserción. ASP.NET incluye los
siguientes:
Tabla 15.1 Controles para operaciones con orígenes de datos ASP.NET.
Control descripción
OleDbDataAdapter Adaptador de datos para una base de datos Access.
SqlDbDataAdapter Adaptador de datos para una base de datos SQL.
OracleDbDataAdapter Adaptador de datos para una base de datos Oracle.
DataSet Representa un conjunto de datos en memoria.
DataView Representa una vista para enlazar datos.
SqlDataSource Conecta base de datos SQL Server, Oracle u OLEDB
AccesDataSource Conecta una base de datos Access de Microsoft.
XmlDataSource Conecta con un archivo XML.
15.2 Ejemplos prácticos bases de datos con ASP.NET
15.2.1 Conexión a SQL Server por código
Diseñar de un sitio Web llamado ConexionBD_GV_código, que permita realizar una

conexión a una base de datos de SQL Server y mostrar los registros de una tabla
llamada clientes en un objeto GridView utilizando código de Visual Basic .NET.
353
SERVER 2005 o posterior y crear una base de datos llamada bdlibrovbnet y dentro de
ella una tabla llamada clientes (Ver anexo A, SQL Server).

siguientes controles en la página Web en la posición deseada: 3 Label y 1 GridView.
Tabla 15.1 Propiedades de controles proyecto ConexionBD_GV_código.

GridView1 ID cuadriculadatos
Label1 ID lbltexto
Text Conexión por código a una base de datos SQL
SERVER.
Font - Bold True
Label2 ID lblregistros
Text Registros tabla: Clientes
Font - Bold True
Label3 ID lblnumeroregistros
Text Número de Registros:
Font - Bold True
Button1 ID boton
Text Ejecutar Conexión
Form1 ID formulario
Document Title Conexión a SQL Server.
Figura 15.1 Interfaz de usuario ConexionBD_GV_código.
354
a) Antes de la apertura de la clase Default se debe importar los siguientes espacios

de nombres:
Imports System.Data
Partial Class Default
Inherits System.Web.UI.Page
….
……
End Class
Se importan los espacios de nombres System.Data y System.Data.SqlClient los

cuales son necesarios para utilizar las diferentes clases que permitan las operaciones con
bases de datos.
b) Dé doble clic sobre el objeto boton para abrir el editor de código del
procedimiento boton_Click y escriba el siguiente código:

conexion = "Data Source=(local)\SQLEXPRESS;Database=bdlibrovbnet;Integrated
Security=True"
Dim seleccion As String = "SELECT * FROM clientes"
Dim adaptadordedatos As SqlDataAdapter
Try
adaptadordedatos = New SqlDataAdapter(seleccion, conexion)
adaptadordedatos.Fill(tabladedatos)
cuadriculadatos.DataSource = tabladedatos
cuadriculadatos.DataBind()
lblnumeroregistros.Text = "Total de Registros:" & tabladedatos.Rows.Count
MsgBox("Error en la conexión: " & ex.Message)
End Try
Se crea una variable llamada conexion de tipo String a la cual se le asigna la

cadena de conexión a la base de datos SQL Server. Dicha cadena contiene los siguientes
parámetros:
 Data Source: Se le asigna la ruta donde se encuentra el servidor SQL Server; en

este caso, SQL Server se instalo en el computador de trabajo por lo cual el nombre
del servidor es (local)\SQLEXPRESS.
 Database: Se le asigna el nombre de la base de datos a la que se quiere conectar.
 Integrated Security: Se le asigna True o False para determinar si la seguridad es
integrada o no.
Además se crean los siguientes objetos: seleccion de tipo String a la cual se le

asigna la sentencia SQL Select * From Clientes (se van a mostrar en la cuadricula
todos los registros de la tabla clientes); adaptadordedatos de tipo SqlDataAdapter el
cual será el adaptador de datos para manipular la base de datos SQL Server;
355
tabladedatos se le asigna espacio de memoria de tipo DataTable para guardar los datos
en memoria y poder realizar operaciones con dichos datos. En un bloque Try se le
asigna espacio de memoria de tipo SqlDataAdapter al objeto adaptadordedatos, al
cual se le envía como parámetros los objetos seleccion (datos a mostrar) y conexion
(cadena de conexión), luego se rellena (fill) el adaptador de datos con la tabla de datos
(tabladedatos); al objeto cuadriculadatos en su propiedad DataSource se le establece
el conjunto de datos que se van a mostrar al asignársele la tabla de datos, por otro lado,
se enlaza al objeto cuadriculadatos el orígen de datos (DataBind()) y por último se
establece a la propiedad Text del objeto lblnumeroregistros el texto actual del objeto
unido al número total de registros que contenga la tabla (tabladedatos.Rows.Count).
Por el bloque Catch se establece un mensaje en caso de que ocurra un error de
conexión.
Al ejecutarse el sitio Web, se visualizará la siguiente figura:
Figura 15.2 Ejecución aplicación ConexionBD_GV_código.
Al pulsar el botón Ejecutar Conexión, se obtendrá la siguiente figura:
Figura 15.3 Ejecución aplicación ConexionBD_GV_código.
356
15.2.2 Conexión a una base de datos con un control GridView
Crear un sitio Web llamado ConsultaWebGridView, que permita visualizar los

registros de una tabla en un control GridView, además, se puedan ordenar dichos
registros por cualquier campo de la tabla.
SERVER 2005 o posterior y tener creada la base de datos llamada bdlibrovbnet con
sus respectivas tablas. (Ver anexo A, SQL Server).

siguientes controles en la página Web en la posición deseada: 1 Label y 1 GridView.
Tabla 15.2 Propiedades de controles proyecto ConsultaWebGridView.

GridView1 ID datos
Label1 ID lbltexto
Text Consulta de los registros de una tabla con un
control GridView.
Font - Bold True
Form1 ID formulario
Document Title Consulta de registro de una tabla.
Después de modificar las propiedades de los controles, seleccione el objeto

GridView datos y dé clic sobre la flecha en la parte superior derecha del control para
ver la ventana Tareas de GridView:
Figura 15.4 Ventana de Tareas de GridView.
De la opción Elegir orígen de datos, seleccione <Nuevo orígen de datos…>

357
Escoja el objeto Base de datos y especifique como nombre del identificador del
orígen de datos orígendedatos y pulse el botón Aceptar, para visualizar la ventana de
elección de la conexión de datos.
Pulse el botón Nueva conexión… para ver la ventana de Agregar conexión, allí
dé clic sobre el botón Examinar y busque la base de datos bdlibrovbnet.mdf. Se
obtendrá la siguiente figura:
358
Figura 15.7 Ventana Agregar conexión con la base de datos seleccionada.
Pulse el botón Aceptar para mostrar nuevamente la ventana Elegir la conexión

de datos con la base de datos escogida. Al pulsar el signo (+) al lado del texto Cadena
de conexión se podrá ver los parámetros de conexión.
Figura 15.8 Ventana con la base de datos y la cadena de conexión.
Pulsando el botón Siguiente> se visualizará la ventana para guardar la cadena de

conexión en el archivo de configuración de la aplicación. Cambie el nombre de la
cadena de conexión por cadenaconexionbd, se obtendrá la siguiente figura:
359
Pulse el botón Siguiente> para ver la ventana de configuración de la

instrucción Select. En dicha ventana debe estar seleccionada la opción Especificar
columnas de una tabla o vista. En la lista Nombre seleccione la tabla Clientes y en el
cuadro Columnas escoja el cuadro de verificación *. La ventana quedaría de la
siguiente forma:
Figura 15.10 Ventana de configuración de la instrucción Select.
Nuevamente pulse el botón Siguiente> para ver la ventana de Consulta de

prueba. En dicha ventana pulse el botón Consulta de prueba para mostrar los registros
que fueron seleccionados, así como la instrucción Select.
360
Figura 15.11 Ventana Consulta de prueba.
Pulse el botón Finalizar para volver a modo diseño. En la ventana Tareas de

GridView escoja el cuadro de verificación Habilitar Ordenación. El formulario en
modo de edición queda de la siguiente forma:
Figura 15.12 GridView con el orígen de datos.
Figura 15.13 Interfaz de usuario ConsultaWebGridView.
361
Figura 15.14 Ejecución aplicación ConsultaWebGridView.
Al hacer clic sobre el link empresa, se ordenaran alfabéticamente todos los

registros por el campo empresa de la tabla clientes.
Figura 15.15 Registros ordenados por el campo empresa de la tabla clientes.
Si se desea mejorar la presentación de los registros en la cuadricula, en modo

diseño seleccione el objeto datos y en la ventana de Tareas de GridView escoja la
opción Formato Automático y seleccione el esquema que desee.
15.2.3 Consulta una base de datos utilizando el Explorador de servidores
Elaborar un sitio Web llamado ConsultaBDExploradorServidores, que permita

visualizar los registros de una tabla en un control FormView, además se permita la
paginación de los registros.
362
SERVER 2005 o posterior y tener creada la base de datos llamada bdlibrovbnet con
sus respectivas tablas. (Ver anexo A, SQL Server).

siguientes controles en la página Web en la posición deseada: 1 Label y 1 FormView.
Tabla 15.3 Propiedades de controles proyecto ConsultaBDExploradorServidores.

FormView1 ID formulariodatos
Label1 ID lbltexto
Text Consulta una tabla utilizando el Explorador de
servidores.
Font - Bold True
Form1 ID formulario
Document Title Consulta tabla con FormView.
 Explorador de servidores
Del menú Ver seleccione la opción Explorador de servidores, para visualizar la

siguiente figura:
Pulse el icono conectar con bases de datos , para visualizar la ventana de

Agregar conexión. Allí dé clic sobre el botón Examinar y busque la base de datos
bdlibrovbnet.mdf. Se obtendrá la siguiente figura:
363
Figura 15.17 Ventana Agregar conexión con la base de datos bdlibrovbnet.mdf.
Pulse el botón Aceptar para volver al Explorador de servidores. Al pulsar en

el signo (+) al lado del nombre de la base de datos (bdlibrovbnet.mdf) se visualizará la
datos pulse el signo (+) al lado de Tablas y en cada tabla pulse el signo (+) para ver los
campos de la tabla seleccionada.
Figura 15.18 Explorador de servidores con la conexión a la base de datos.
Ahora seleccione el objeto FormView llamado formulariodatos y en la flecha

que aparece en el lado superior derecho, dé clic para visualizar las Tareas de
FormView:
364
Figura 15.19 Ventana de las Tareas de FormView.
De la opción Elegir orígen de datos, seleccione <Nuevo orígen de datos…>

|Escoja el objeto Base de datos y especifique como nombre del identificador del
orígen de datos conexiondedatos y pulse el botón Aceptar para visualizar la ventana de
Elegir la conexión de datos. De la lista que allí aparece escoja la base de datos
bdlibrovbnet.mdf. La ventana quedaría de la siguiente forma:
365

cadena de conexión por cadenaconexion, se obtendrá la siguiente figura:
Figura 15.22 Ventana para guardar el archivo de la cadena de conexión.
Pulse el botón Siguiente para visualizar la ventana de Configurar la

instrucción Select. Seleccione la tabla Clientes y en Columnas pulse el cuadro de
verificación *.
366
Figura 15.23 Ventana Configurar la instrucción Select.
A continuación pulse el botón Siguiente y después el botón Finalizar para

volver a la página Web y visualizar nuevamente el objeto formulariodatos y la ventana
Tareas de FormView. Seleccione el cuadro de verificación Habilitar paginación.
Figura 15.24 Objeto formulariodatos con la opción Habilitar paginación.
Dé clic sobre la opción Formato automático para ver la ventana de

Autoformato.
Figura 15.25 Ventana de Autoformato.
367
Seleccione el esquema Multicolor y pulse el botón Aceptar. La interfaz de
usuario queda como se muestra en la siguiente figura:
Figura 15.26 Interfaz de usuario ConsultaBDExploradorServidores.
Figura 15.27 Ejecución aplicación ConsultaBDExploradorServidores.
368
15.2.4 Insertar un registro en una tabla
Elaborar un sitio Web llamado InsertarRegistrosWeb que permita insertar registros en

una tabla utilizando el control DetailsView.

siguientes controles en la página Web en la posición deseada: 1 Label, 1 DetailsView.
Tabla 15.4 Propiedades de controles del sitio InsertarRegistrosWeb.

Label1 ID lbltexto
Text Insertar registro en una tabla desde un
formulario Web.
Font - Bold True
DetailsView1 ID vistadatos
Form1 ID formulario
Document Title Insertar un registro en una tabla.
Seleccione el objeto DetailsView llamado vistadatos y en la flecha que aparece en el

lado superior derecho, dé clic para visualizar las Tareas de DetailsView:
Figura 15.28 Ventana Tareas de DetailsView.
Seleccione la opción Elegir orígen de datos y <Nuevo orígen de datos…> para

visualizar la ventana Asistente para la configuración de orígenes de datos. Escoja el
objeto Base de datos y especifique como nombre del identificador del orígen de datos
conexionvista.
369
Figura 15.29 Ventana para elegir el orígen de datos.
Pulse el botón Aceptar para visualizar la ventana de Elegir la conexión de

datos. Realice los pasos necesarios para escoger la base de datos bdlibrovbnet.mdf. La
ventana quedaría de la siguiente forma:

cadena de conexión por cadenavista, se obtendrá la siguiente figura:
370
Figura 15.31. Ventana Guardar cadena de conexión.

instrucción Select. Seleccione la tabla Clientes y en la pestaña Columnas pulse el
cuadro de verificación *.
Figura 15.32 Configurar la instrucción Select.
Por otro lado, pulse el botón Avanzadas… para ver la ventana de opciones de
generación de consultas SQL avanzadas. Active las opciones Generar instrucciones
Insert, Update y Delete y Usar concurrencia optimista. Se obtendrá la siguiente
figura:
371
Figura 15.33 Opciones de generación SQL avanzadas.
Pulse el botón Aceptar para ver nuevamente la ventana Configurar instrucción

Select. En dicha ventana pulse el botón Siguiente para ver la ventana de Consulta de
prueba. Por último pulse el botón Finalizar. En la ventana Tareas de DetailsView
seleccione el cuadro de verificación Habilitar inserción. La página Web quedaría de la
siguiente forma:
Figura 15.34 Ventana diseño sitio Web InsertarRegistrosWeb.
372
Figura 15.35 Interfaz de usuario InsertarRegistrosWeb.
Al ejecutarse el sitio Web, se visualizará la página Web mostrando el primer registro de

la tabla clientes en el objeto DetailsView vistadatos.
Figura 15.36 Ejecución aplicación InsertarRegistrosWeb.
Al pulsarse el link Nuevo los campos de texto del objeto vistadatos quedaran en
blanco y se observaran dos nuevos link Insertar y Cancelar, como se aprecia en la
figura.
373
Figura 15.37 Formulario Web para insertar un registro en la tabla.
Escriba en cada campo la información que se muestra en la figura 15.36.
Figura 15.38 Información a insertar en la tabla.
Al pulsarse el link Insertar se guardarán los datos en la tabla clientes y

nuevamente se mostrará el primer registro y el link Nuevo. Al ejecutarse la aplicación
ConsultaWebGridView realizada en el aparte 15.2.2., se visualizará el nuevo registro.
Figura 15.39 Tabla clientes con el nuevo registro.
Registro insertado
374
15.2.5 Modificar un registro de una tabla
Crear un sitio Web llamado ModificarRegistrosWeb que permita modificar registros

en una tabla utilizando el control DetailsView.


Label1 ID lbltexto
Text Modificar registros de una tabla en un
formulario Web.
Font - Bold True
Form1 ID formulario
Document Title Modificar registros en una tabla.
Seleccione el objeto DetailsView llamado vistadatos y en la flecha que aparece

en el lado superior derecho, dé clic para visualizar las Tareas de DetailsView. Realice
cada uno de los pasos para lograr la conexión a la base de datos ejecutados en el
ejemplo 15.2.4, desde la figura 15.26 hasta la figura 15.31. Al pulsar el botón Finalizar
de la ventana Consulta de prueba se volverá a modo diseño de la página Web. Active
los cuadro de verificación Habilitar paginación y Habilitar edición del objeto
vistadatos. El formulario Web quedaría de la siguiente forma:
Figura 15.40 Ventana diseño sitio Web ModificarRegistrosWeb.
375
Ahora dé clic sobre la opción Editar campos para visualizar la ventana
Campos. En la ventana Campos seleccionados escoja el objeto Editar, Actualizar,
Cancelar y en la ventana Propiedades de CommandField busque la propiedad
ButtonType y escoja de la lista la opción Button.
Figura 15.41 Ventana para editar los campos.
Por último pulse el botón Aceptar. La interfaz de usuario queda como se

muestra en la siguiente figura:
Figura 15.42 Interfaz de usuario ModificarRegistrosWeb.
376

la tabla clientes en el objeto DetailsView vistadatos, el botón Editar y los
hipervínculos de paginación.
Figura 15.43 Ejecución aplicación ModificarRegistrosWeb.
Con los link numéricos busque el registro que se inserto en el ejemplo anterior y
pulse el botón Editar. Se observaran dos nuevos botones Actualizar y Cancelar.
Modifique el contenido del campo empresa por el texto Las acacias.
Figura 15.44 Formulario Web listo para modificar un registro en la tabla.
Pulse el botón Actualizar para obtener la siguiente figura:
377
Figura 15.45 Registro modificado de la tabla clientes.
15.2.6 Eliminar un registro de una tabla
Diseñar un sitio Web llamado EliminarRegistrosWeb que permita eliminar registros

en una tabla utilizando el control DetailsView.

Tabla 15.6 Propiedades de controles del sitio EliminarRegistrosWeb.

Label1 ID lbltexto
Text Eliminar registros de una tabla desde un
formulario Web.
Font - Bold True
Form1 ID formulario
Document Title Eliminar registros en una tabla.
Seleccione el objeto DetailsView llamado vistadatos y en la flecha que aparece en el

lado superior derecho, de clic para visualizar las Tareas de DetailsView. Realice cada
uno de los pasos para lograr la conexión a la base de datos ejecutados en el ejemplo
15.2.4, desde la figura 15.26 hasta la figura 15.31. Al pulsar el botón Finalizar de la
ventana Consulta de prueba se volverá a modo diseño de la página Web. Active los
cuadro de verificación Habilitar paginación y Habilitar eliminación del objeto
vistadatos. El formulario Web quedaría de la siguiente forma:
378
Figura 15.46 Ventana diseño sitio Web EliminarRegistrosWeb.
Ahora dé clic sobre la opción Editar campos para visualizar la ventana

Campos. En la ventana Campos seleccionados escoja el objeto Eliminar y en la
ventana Propiedades de CommandField busque la propiedad ButtonType y escoja de
la lista la opción Button.
Figura 15.47 Ventana para editar los campos.
Por último pulse el botón Aceptar. La interfaz de usuario queda como se

muestra en la siguiente figura:
379
Figura 15.48 Interfaz de usuario EliminarRegistrosWeb.

la tabla clientes en el objeto DetailsView vistadatos, el botón Eliminar y los
hipervínculos de paginación.
Figura 15.49 Ejecución aplicación EliminarRegistrosWeb.
Con los link numéricos busque el registro que se inserto y posteriormente se

modifico en ejemplos anteriores.
380
Figura 15.50 Formulario Web con el registro a ser eliminado.
Pulse el botón Eliminar. Se eliminará el registro actual y se observará el

siguiente registro de la tabla clientes en el objeto vistadatos.
Figura 15.51 Formulario Web al ser eliminado el registro con nit 20000.
Al ejecutarse nuevamente la aplicación ConsultaWebGridView realizada en el

aparte 15.2.2., se visualizará todos los registros actuales de la tabla clientes.
Figura 15.52 Registros actuales de la tabla clientes.
381
15.2.7 Filtrar registros de una tabla
Realizar un sitio Web llamado FiltrarRegistrosWeb que permita visualizar registros de

una tabla cuyo nit sea mayor o igual a 500.



Label1 ID lbltexto
Text Filtrar los registros de una tabla con
formularios Web.
Font - Bold True
ListView1 ID vista
Form1 ID formulario
Document Title Filtrar registros de una tabla.
Seleccione el objeto ListView llamado vista y en la flecha que aparece en el lado

superior derecho, de clic para visualizar las Tareas de ListView:
Figura 15.53 Ventana Tareas de ListView.
Seleccione la opción Elegir orígen de datos y <Nuevo orígen de datos…> para

visualizar la ventana Asistente para la configuración de orígenes de datos. Escoja el
objeto Base de datos y especifique como nombre del identificador del orígen de datos
conexionlista.
382
Figura 15.54 Ventana para elegir el orígen de datos.
Pulse el botón Aceptar, para visualizar la ventana de Elegir la conexión de

datos. Realice los pasos necesarios para escoger la base de datos bdlibrovbnet.mdf. La
ventana quedaría de la siguiente forma:
|Pulsando el botón Siguiente> se visualizará la ventana para guardar la cadena

de conexión en el archivo de configuración de la aplicación. Cambie el nombre de la
cadena de conexión por cadenalista, se obtendrá la siguiente figura:
383

Figura 15.57 Configurar la instrucción Select.
Por otro lado, pulse el botón WHERE… para ver la ventana Agregar cláusula
WHERE. Realice lo siguiente: de la lista Columna escoja el campo nit; de la lista
Operador seleccione el operador >=; de la lista Orígen el texto None; y en las
propiedades del parámetro el valor 500. Se obtendrá la siguiente figura:
384
Figura 15.58 Agregar cláusula WHERE.
Luego pulse el botón Agregar. La ventana quedaría así:
Figura 15.59 Agregar cláusula WHERE después de pulsar el botón Agregar.

prueba. Por último pulse el botón Finalizar.
385
Figura 15.60 Ventana diseño sitio Web FiltrarRegistrosWeb.
Nuevamente seleccione el objeto vista y en la ventana de Tareas de ListView

dé clic en la opción Configure ListView. De la lista Select a Layout seleccione Grid y
de la lista Select a Style escoja Professional. La ventana quedaría de la siguiente
forma:
Figura 15.61 Ventana Configure ListView.
Pulse el botón OK para obtener la siguiente figura:
Figura 15.62 Ventana con el objeto vista modificado.
386
Figura 15.63 Interfaz de usuario FiltarRegistrosWeb.
Al ejecutarse el sitio Web, se visualizará la página Web mostrando los registros de la

tabla clientes en el objeto ListView vista cuyo nit es mayor o igual a 500.
Figura 15.64 Ejecución aplicación FiltrarRegistrosWeb.
387
15.2.8 Informe de los registro de una tabla
Elaborar un sitio Web llamado InformeRegistrosWeb que permita visualizar todos los
registros de la tabla clientes de la base de datos bdlibrovbnet.mdf.

siguientes controles en la página: 1 MicrosoftReportViewer.
Tabla 15.8 Propiedades de controles del sitio Web InformeRegistrosWeb.

MicrosoftReportViewer ID informeregistros
Form1 ID formulario
Document Title Informe de los registros de una
tabla.
Figura 15.65 Interfaz de usuario InformeRegistrosWeb.
 Diseñar el informe y establecer la conexión con la base de datos
Para seleccionar la tabla y diseñar el informe, pulse la flecha del lado superior derecha
del objeto informeregistros para ver la ventana Tareas de ReportViewer y escoga la
opción Diseñar nuevo informe.
388
Figura 15.66 Selección Tareas de ReportViewer – Diseñar nuevo informe.
Al dar clic en la opción Diseñar nuevo informe, se visualizará el asistente de

informes.
Figura 15.67 Asistente para informes.
Dé clic en Siguiente> para ver la ventana del asistente para la configuración

de orígenes de datos. Realice la conexión de datos de la base de datos
bdlibrovbnet.mdf. Se obtendrá la siguiente figura:
389
Pulse Siguiente> para visualizar el siguiente mensaje:
Pulse el botón Sí para copiar el archivo de datos en la carpeta donde guardó el

sitio Web y visualizar la ventana de guardar cadena de conexión:
390
Cambie el nombre de la conexión que allí aparece por conexioninforme y pulse
el botón Siguiente>. Se visualizará la ventana elija los objetos de base de datos. Pulse el
signo (+) al lado de Tablas para desplegar las tablas de la base de datos y seleccione la
tabla clientes. Por otro lado, cambie el nombre del DataSet que allí aparece por
conjuntodedatos.
Pulse el botón Finalizar, para visualizar la ventana seleccionar orígenes de

datos. Pulse los signos (+) para desplegar el objeto clientes
Figura 15.72 Asistente para informes – seleccionar el origen de datos.
391
Dé clic en Siguiente> para visualizar la ventana de selección de tipo de
informe. Seleccione la opción Tabular.
Figura 15.73 Asistente para informes – seleccionar el tipo de informe.
Dé clic en el botón Siguiente> para visualizar la ventana Diseñar la tabla.

Seleccione el campo nit y pulse el boton Grupos. Seleccione cada uno de los restantes
campos y pasélos a la ventana Detalles con el botón Detalles>, se obtiene la siguiente
figura:
Figura 15.74 Asistente para informes – diseñar la tabla.
392
Pulse el botón Siguiente> para visualizar la ventana Elegir el diseño de la
tabla. Seleccione la opción Escalonado.
Figura 15.75 Asistente para informes – elegir el diseño de la tabla.
Dé clic en el botón Siguiente> para visualizar la ventana Elegir el estilo de

tabla. Seleccione la opción con el estilo que desee.
Figura 15.76 Asistente para informes – elegir el estilo de tabla.
393
Pulse el botón Siguiente> para visualizar la ventana Finalización del asistente
de informes. En el campo Nombre del informe escriba el texto
informe_registros_clientes.
Figura 15.77 Ventana Finalización del Asistente para informes.
Dé clic en el botón Finalizar> para visualizar el diseño final del informe.
Figura 15.78 Ventana diseño final del informe.
Seleccione nuevamente la página aspx, pulse la flecha en la parte superior

derecha del objeto informeregistros y escoja la opción Elegir informe. Seleccione el
informe informe_registros_clientes.rdlc, se visualizará la siguiente figura:
394
Figura 15.79 Ventana con el informe informe_registros_clientes elegido.
 Ejecutar el sitio Web
Al ejecutarse el sitio Web, se visualizará la página con el informe de los registros que
contiene la tabla clientes. Puede ajustar el tamaño del reporte en la página en modo de
diseño.
Figura 15.80 Página Web con el informe de los registros de la tabla clientes.
395
15.2.9 Visualizar los registros de dos tablas relacionadas
Diseñar un sitio Web llamado RelacionTablasWeb, que permita a un usuario

seleccionar desde un control desplegable el nombre de una empresa y en un control
GridView visualizar cada uno de los pedidos que la empresa seleccionada ha realizado.

siguientes controles en el formulario Web en la posición deseada: 3 Label, 1
DropDownList, 1 GridView.
Tabla 15.9 Propiedades de controles del sitio Web RelacionTablasWeb.

Label1 ID lbltexto
Text Relación de dos tablas desde un Sitio Web
Font - Bold True
Label2 ID lblempresas
Text Seleccione el nombre de la empresa:
Font - Bold True
Label3 ID txtpedidos
Text Registros relacionados.
Font - Bold True
DropDownList1 ID listaempresas
AutoPostBack True
GridView1 ID datospedidos
Form1 ID formulario
Document Title Relación de dos tablas.
Figura 15.81 Interfaz de usuario RelacionTablasWeb.
396
Seleccione el objeto DropDownList llamado listaempresas y en la flecha que aparece

en el lado superior derecho, dé clic en el mouse para visualizar las Tareas de
DropDownList. Seleccione la opción Elegir orígen de datos, para visualizar la
siguiente figura:
Figura 15.82 Ventana para configuración de orígenes de datos.
En la opción Seleccionar un origen de datos escoja <Nuevo origen de

datos…>, para ver la ventana Elija un de tipo de orígen de datos. Escoja el objeto
Base de datos y cambie el identificador para el origen de datos por el texto
conexionrelacion. Se apreciara la siguiente figura:
Figura 15.83 Ventana para elegir tipo de origen de datos.
397
Pulse el botón Aceptar. Se visualizará la ventana Elegir la conexión de datos.
Realice la conexión de datos de la base de datos bdlibrovbnet.mdf. Se obtendrá la
siguiente figura:
Dé clic en el botón Siguiente para ver la ventana Guardar la cadena de

conexión. Cambie el nombre de la cadena de conexión por cadenarelacion, se obtendrá
Figura 15.85 Ventana para guardar la cadena de conexión.
398
Figura 15.86 Ventana para configurar la instrucción Select.
Dé clic en el botón Siguiente para ver la ventana de Consulta de prueba y en

esta ventana pulse el botón Finalizar. Se mostrará una nueva ventana Elegir un orígen
de datos. Cambie en la opción seleccionar un campo de datos para mostrar en
DropDownList nit por empresa. Se observará la siguiente figura:
Figura 15.87 Datos a mostrar en el objeto DropDownList listaempresas.
399
Pulse el botón Aceptar para volver a modo diseño. Ahora seleccione el objeto
datospedidos y pulse en la flecha de la parte superior derecha para ver las Tareas de
GridView. Escoja la opción Elegir origen de datos y seleccione <Nuevo origen de
datos…>. Se visualizará la ventana Elija un tipo de origen de datos, allí seleccione el
objeto Base de datos y cambie el identificador para el origen de datos por
conexionpedidos.
Figura 15.88 Ventana Elija un tipo de origen de datos (objeto datospedidos).
Pulse el botón Aceptar. Se visualizará la ventana Elegir la conexión de datos

de datos. Realice la conexión a la base de datos bdlibrovbnet.mdf. Se obtendrá la
siguiente figura:
Figura 15.89 Ventana elegir la conexión de datos (objeto datospedidos).
400
Dé clic en el botón Siguiente para ver la ventana Guardar la cadena de
conexión. Cambie el nombre de la cadena de conexión por cadenapedidos, se obtendrá
Figura 15.90 Ventana para guardar la cadena de conexión (objeto datospedidos).

instrucción Select. Seleccione la tabla Pedidos y en la pestaña Columnas pulse el
Figura 15.91 Ventana para configurar la instrucción Select (objeto datospedidos).
401
A continuación pulse el botón WHERE para visualizar la ventana de Agregar
cláusula WHERE.Y realice lo siguiente: de la lista Columna escoja el campo nit; de la
lista Operador seleccione el operador =; de la lista Orígen Control; y en las
propiedades del parámetro en Id. De control seleccione listaempresas. Se obtendrá la
siguiente figura:
Figura 15.92 Agregar cláusula WHERE (objeto datospedidos).
Luego pulse el botón Agregar. La ventana quedaría así:
Figura 15.93 Cláusula WHERE agregada (objeto datospedidos).
402
prueba. Por último pulse el botón Finalizar para volver a modo diseño.
Figura 15.94 Ventana diseño sitio Web RelacionTablasWeb.
 Ejecutar el sitio Web
Al ejecutarse el sitio Web, se observan en la página los objetos DropDownList y

GridView. En el objeto DropDownList se puede seleccionar un nombre de una
empresa de la tabla clientes y en el objeto GridView se visualizarán los registros
relacionados con la tabla pedidos.
Figura 15.95 Ejecución de la aplicación RelacionTablasWeb.
403
15.3 Ejercicios bases de datos con ASP.NET
1. Crear un sitio Web que permita realizar una conexión a una base de datos y
mostrar datos de una tabla en un control Repeater
2. Elaborar un sitio Web que permita realizar una conexión a una base de datos y
actualizar un campo númerico por el valor actual más 100000.
3. Escribir un sitio Web que permita visualizar los registros de una tabla en campos
de texto. El usuario deberá poderse desplazar por cada registro de la tabla
4. Diseñar un sitio Web que permita visualizar los registros de una tabla en un
control ListView. El usuario deberá visualizar cinco registros por cada página
5. Hacer un sitio Web que permita escribir sentencias SQL en un campo de texto y
visualizar los resultados de dicha sentencia en un GridView.
6. Realizar un sitio Web que permita visualizar los registros de dos tablas
relacionadas donde la ciudad sea igual a Cali.
7. Hacer un sitio Web que permita visualizar un informe de los registros de una
tabla cuyas empresas empiecen por la silaba CA.
8. Realizar un sitio Web que permita hacer una conexión a una base de datos y
visualizar los registros cuyo nit sea mayor que 300 y menor que 700 en un
ListView.
9. Realizar un sitio Web que permita realizar una relación entre tres tablas de una
base de datos en SQL Server.
10. Hacer un sitio Web que permita visualizar en un informe los registros de una
relación de dos tablas.
404
16. SERVICIOS WEB
Un servicio Web es una interfaz definida que proporciona una determinada

funcionalidad y diversas aplicaciones lo pueden accesar a través de los estándares de
Internet como XML o HTTP. La mayor importancia de un servicio Web es que está
disponible a través de diferentes protocolos de la Web y es compatible con diferentes
lenguajes de programación, equipos y sistemas operativos. Una de las características de
los servicios Web es el grado de abstracción entre la implementación y el uso del
servicio por lo que no se necesita tener información de la ubicación, las entradas o las
salidas del servicio. Los servicios Web se dividen en servicios de transporte (los
protocolos del nivel más bajo, que codifican la información independientemente de su
formato, y que pueden ser comunes a otros servicios), de mensajería, de descripción y
de descubrimiento. En la parte más baja se encuentran los servicios de transporte, que
establecen la conexión y el puerto usado. Generalmente se usa HTTP el mismo
protocolo que la WWW, pero se puede usar también SMTP (protocolo del correo
electrónico), FTP (File Transfer Protocol).
Los servicios Web utilizan el protocolo SOAP (Simple Object Access

Protocol). Un mensaje SOAP está compuesto por encabezados y un cuerpo de mensaje.
Los encabezados contienen información que puede ser procesada por el servidor Web.
El cuerpo del mensaje contiene información que es procesada por una aplicación como
parámetros o la devolución de un valor para un servicio Web.
Los beneficios de los servicios Web son:

 Comunicación entre diferentes aplicaciones y/o sistemas operativos.
 El servicio es reutilizable.
 Su programación es prácticamente sencilla.
 Se puede distribuir su información entre varios clientes.
Para habilitar un servicio web con ASP.NET de debe crear un archivo con una
extensión de nombre de archivo .asmx, declarar un servicio web en ese archivo y
definir los métodos de los servicios web.
16.1 Crear un servicio Web desde Visual Basic .NET
Crear servicios Web desde el entorno de desarrollo de Visual Basic.NET, es algo

similar a la creación de un proyecto Windows Forms o una aplicación ASP.NET. El
único requisito es tener instalado Microsoft Internet Information Services (IIS)
localmente en el equipo de trabajo.
Como ejemplo, se creará un servicio Web llamado

ServicioWebNumerosPrimos que reciba un número digitado por un usuario y retorne
en texto si dicho número es primo o no.
 Crear el servicio web
Desde la página de inicio de Microsoft Visual Studio cree un nuevo proyecto, puede
seguir los siguientes pasos:
1. En la ventana proyectos recientes seleccionar la opción Crear: link Sitio Web.
405
2. Hacer clic en la opción Archivo del menú y seleccionar Nuevo sitio Web…
Selección el menú Archivo y escoja la opción Nuevo sitio Web…, para

visualizar la siguiente ventana:
Figura 16.1 Ventana para crear un servicio Web desde Visual Basic.NET.
Como plantilla escoja Servicio web ASP.NET; En el campo Lenguaje

seleccione Visual Basic, por último, pulse el botón Examinar… Se visualizará la
ventana Seleccionar ubicación (Sistema de archivos). Dicha ventana varía de acuerdo a
los archivos que contenga el equipo de trabajo.
Figura 16.2 Ventana Seleccionar ubicación.
406
Dé clic sobre el icono IIS local y en la ventana derecha seleccione el objeto
Sitio web predeterminado. Se observará la siguiente figura:
Figura 16.3 Ventana Seleccionar ubicación IIS local.
Dá clic en el icono (Crear nueva aplicación Web) que se encuentra en la

parte superior derecha de la ventana. En el nuevo objeto que aparece reemplace en texto
WebSite por ServicioWebNumerosPrimos. Se obtendrá una figura similar a la
siguiente:
Figura 16.4 Creación de una nueva aplicación Web.
Pulse el botón Abrir para visualizar nuevamente el cuadro de diálogo Nuevo

sitio Web, como se muestra en la siguiente figura:
407
Figura 16.5 Nuevo sitio web con la ubicación del servicio Web.
La ubicación incluye el protocolo (http://) y la ubicación (localhost). Esto indica

que está trabajando con un sitio Web de IIS local. Pulse el botón Aceptar para ver el
archivo del servicio web.
Figura 16.6 Archivo de un servicio Web Service1.asmx.vb.
Se crea el archivo Service.vb (servicio web predeterminado) que importa los

espacios de nombres: System.Web, System.Web.services y
System.Web.Services.Protocols. También crea un espacio de nombres NamesSpace
donde se define la dirección HTTP. Además se crea la clase Service que hereda de
System.Web.Services.WebService (proporciona acceso directo a los objeto comunes
de ASP.NET). Por defecto siempre se crea el procedimiento Function HelloWord ().
408
 Escribir código en el servicio Web
El código será la interfaz del servicio Web a los que un usuario tendrá acceso desde una
aplicación Web. Entre Class y End Class se deben declarar cada uno de los
procedimientos que utilizará el servicio Web para realizar una tarea específica. Los
procedimientos de un servicio Web se estructuran de la siguiente manera:
<WebMethod ()>: Entre los paréntesis se puede hacer un comentario del servicio Web,
<WebMethod (Description:=“Servicio Web para consultar una base de datos”)>
La definición normal de un procedimiento Function es:
 Modificador de acceso: public, prívate

 Function: palabra reservada para declarar una función
 Nombre_de la función: ej: HelloWord
 Lista de parámetros: ()
 Tipo de retorno: ej: String
 Cuerpo de la función: Ej: Helloworld =”Hello World” retorna dicho texto.
 Fin de la función : End Function
Como lo que se pretende es que el servicio Web determine si un número

digitado por el usuario es primo o no, se debe crear el procedimiento que realice este
proceso. Si desea puede borrar la función HelloWord y crear una nuevo procedimiento
Function llamado numerosprimos. La clase Service con el procedimiento Function
quedara de la siguiente manera:
Figura 16.7 Servicio Web con el procedimiento numerosprimos.
409
 Ejecutar el Servicio Web
Haga clic en el icono Iniciar depuración de la barra de herramientas estándar o

presione F5 para ejecutar el proyecto. Se visualizará la siguiente figura:
Figura 16.8 Ejecución del Servicio Web Service.
Dé clic sobre el hipervínculo numerosprimos, se visualizará la siguiente

figura:
Figura 16.9 Ejecución del hipervínculo numerosprimos.
410
En el campo de texto escriba el número 7 y dé clic en el botón Invocar para
realizar el proceso del procedimiento numerosprimos.
Figura 16.10 Resultado al invocar el servicio Web.
16.2 Acceder a un Servicio Web
Teniendo ya creados los servicios Web que un usuario considero convenientes

programar, es posible acceder (consumir) a los servicios Web desde una aplicación
ASP.NET. Para esto, es necesario crear una aplicación Web ASP.NET y agregar una
referencia Web para comunicarse con el servicio Web y realizar su ejecución.
16.2.1 Ejemplo práctico para acceder a un Servicio Web desde ASP.NET
Crear un sitio Web llamado NumerosPrimosWeb, que permita capturar un número e

imprima si dicho número es primo o no. Se debe obtener la respuesta de un servicio
Web.

siguientes controles en el formulario Web en la posición deseada: 3 Label, 2 TextBox,
1 Button.
411
Tabla 16.1 Propiedades de controles del sitio Web NumerosPrimosWeb.

Label1 ID lbltexto
Text Formulario Web para determinar si un
número es primo o no con un servicio
Web.
Font - Bold True
Label2 ID lblnumero
Font - Bold True
Label3 ID lblresultado
Text Resultado:
Font - Bold True
TextBox1 ID txtnumero
TextBox2 ID txtresultado
Button1 ID boton
AutoPostBack Evaluar número
Form1 ID formulario
Document Title Página Web que consume un servicio
Web.
Figura 16.11 Interfaz de usuario NumerosPrimosWeb.
 Agregar servicio Web
Para agregar el servicio Web a la aplicación Web seleccione el menú Sitio Web y
escoja la opción Agregar referencia Web…, se obtendrá la siguiente ventana:
412
Figura 16.12 Ventana para agregar un servicio Web.
Dé clic sobre el link Servicios web del equipo local, se visualizará una ventana
similar a la siguiente figura (depende de los servicios que tenga el equipo local):
Figura 16.13 Ventana para seleccionar un servicio Web del equipo local.
En este caso pulse el segundo link Service, el cual tiene una URL
http://localhost:8081/ServicioWebNumerosPrimos/Serv... Se obtendrá la siguiente
figura:
413
Figura 16.14 Funciones del servicio Web.
En esta ventana se muestran todas las funciones que tiene el servicio Web
ServicioWebNumerosPrimos. En el campo Nombre de referencia Web aparece por
omisión el texto localhost (cámbielo si desea), pulse el botón Agregar referencia para
volver a la página Web. En el Explorador de soluciones se podrá visualizar el servicio
Web integrado al proyecto
Figura 16.15 Servicio Web integrado al sitio Web.
Dé doble clic sobre el objeto boton para abrir el editor de código del procedimiento
boton_Click y escriba el siguiente código:
414
Dim servicio As New localhost.Service
txtresultado.Text = servicio.numerosprimos(txtnumero.Text)
Se crea un objeto llamado servicio al cual se le asigna espacio de memoria del

espacio de nombre localhost y de la clase del servicio Web Service. A la propiedad
Text del objeto txtresultado se le asigna el valor que retorne el procedimiento
numerosprimos del servicio Web.
 Ejecutar el Servicio Web
Al ejecutarse la aplicación Web y digitar en el objeto txtnumero el número 11 y luego

pulsar el botón Evaluar número se visualizará en el objeto txtresultado el resultado de
la evaluación del número.
Figura 16.16 Ejecución de la aplicación NumerosPrimosWeb.
415
ÍNDICE
Abs, 69 Count, 279

Abstracción, 198 COUNT, 225
Acceder a un Servicio Web, 413 Creación de Menús, 130
AccesDataSource, 355 Creación de una barra de herramientas,
ActiveMdiChild, 150 156, 159
AdapterManager, 246 CREATE, 224
ADO.NET, 230 CREATE DATABASE, 226
Aggregate, 279 CShort, 31
ALL, 225 Cuadro de Herramientas, 16, 319
ALTER, 224 Curva, 163
And, 33 CustomValidator, 350
AND, 225 Cut, 139
AndAlso, 33 Data Source, 233, 357
Aplicación para Windows Forms, 15 DataAdapter, 231
Aplicación Web ASP.NET, 15 Database, 233, 357
Arco, 163 DataGridView, 105
Asc, 73 DataMember, 241
AsEnumerable, 314 DataSet, 230, 355
ASP.NET, 316 DataSource, 241, 276
ASP.NET AJAX, 13 DataTable, 231
Average, 279 DataView, 231, 355
AVG, 225 Date, 66
BETWEEN, 225 DateTimePicker, 144
BigMul, 69 Default.aspx, 319
BindingSource, 246 DefaultView, 276
BulletedList, 335 DELETE, 224
catch, 117 Diseñador formulario Windows, 16
CBool, 31 Diseñador formularios Web, 319
CByte, 31 DLL, 223
CChar, 31 DML, 223
CDate, 31 Do…Loop While, 51
CDbl, 31 DrawArc, 163
CDec, 31 DrawCurve, 163
Ceiling, 69 DrawEllipse, 163
Chars, 72 DrawLine, 163
CheckBox, 99 DrawPie, 163
CheckedListBox, 146 DrawPolygon, 163
Chr, 73 DrawRectangle, 163, 169
CInt, 31 DROP, 224
Circulo, 163 Editor de código, 21
Clase, 11 El explorador de soluciones, 17, 319
Clases, 198 Elegir base de datos, 235
Class, 199 Elegir proveedor base de datos, 235
Clear, 140 Elipse, 163
CLng, 31 Encapsulación, 198
Colecciones, 84 ErrorMessage, 352
columnas, 223 Espacio de nombres, 11
ComboBox, 93 Estructuras de Control, 37
Command, 231 filas, 223
CompareValidator, 350 fill, 233, 357
Concat, 72 FillEllipse, 163
Conectarse a SQL Server, 422 FillPie, 163
Connection, 231 FillPolygon, 163
Constantes, 26 FillRectangle, 163
Constructores, 199 Floor, 69
ControlValidate, 352 FolderBrowseDialog, 122
Copy, 139 Font - Bold, 355, 356
cos, 69 For, 45, 55
416
From, 278 MonthCalendar, 145
FROM, 224 MouseClick, 188
FromArgb, 104 MouseDoubleClick, 188
Funciones de cadenas de caracteres, 72 MouseDown, 188
Funciones Matemáticas, 69 MouseEnter, 188
Function, 61 MouseHover, 188
GetItemChecked, 148 MouseLeave, 188
GraphicsPath, 169 MouseMove, 188
GROUP, 224 MouseUp, 188
Group By, 279 MouseWheel, 188
HAVING, 224 movenext, 127, 128
Height, 175 MultiView, 342
Herencia, 198, 201 NamesSpace, 410
HotSpotMode, 332 Not, 33
If (operador)., 39 NOT, 225
IIF., 39 Objetos, 198
ImageMap, 331 OleDataAdapter, 231
IN, 225 OleDbCommand, 231
IndexOf, 73 OleDbConnection, 231
InitialDirectory, 137 OleDbDataAdapter, 355
Insert, 73 Operadores de comparación, 225
INSERT, 224 Operadores Lógicos, 33
Integrated, 10 Operadores lógicos S.Q.L, 224
Integrated Security, 233, 357 Operadores Relacionales, 32
Join, 279 Or, 33
KeyCode, 194 OR, 225
KeyDown, 193 OracleCommand, 231
KeyPress, 193 OracleConnection, 231
KeyUp, 193 OracleDataAdapter, 231
Left, 172 OracleDbDataAdapter, 355
Len, 73 ORDER, 224
Length, 72 Order By, 279
Lenguaje de Consulta Estructurado, 223, OrElse, 33
225, 229 Orientada a objetos, 223
LIKE, 225 origen de datos, 354
LinkLabel., 91 Palabras clave, 36
LINQ, 278 Paste, 139
LINQ to DataSet, 278 Pie, 163
LINQ to Objects, 278 Point, 163
LINQ to SQL, 278 Poligono, 163
LINQ to XML, 278 Polimorfismo, 198
ListBox, 93 PostBack, 332
ListView, 107 PostBackValue, 332
Matrices, 78 pow, 69
Max, 69, 279 private, 199
MAX, 226 Probar la conexión, 235
MaximumValue, 352 Procedimientos, 61
MDI, 130 Programación Orientada a Objetos, 198
Mensaje, 198 Propiedad, 198
Menú principal, 15, 319 protected, 199
menú Ventana, 153 public, 199
Menús, 130 Punto, 163
Método, 198 RadioButton, 99
Mid, 73 RadioButtonList, 338
min, 69 RangeValidator, 350
Min, 280 ReadtoEnd, 138
MIN, 226 Recta, 163
MinimumValue, 352 Rectangle, 163
Modificar la cadena de conexión:, 235 Rectangulo, 163
Módulos, 59 Redo, 139
417
RegularExpressionValidator, 350 System.Linq, 278
Remove, 73 TableAdapter, 246
Replace, 73 tan, 69
RequiredFieldValidator, 350 Timer, 172
RichTextBox, 115 Tipos de datos, 26
round, 69 TocharArray, 73
RowFilter, 276 ToLower, 72
SDI, 130 Toma de desiciones, 37
Select, 278 Top, 172
SELECT, 224, 227 ToUpper, 72
Select – case (Seleccionar caso), 42 TrackBar, 102
SelectedItem, 255, 256 TreeView, 118
SelectedValue, 276 Trim, 73
SelectionBullet, 141 Try-Catch, 117
Sentencia If (Si), 37 tuplas, 223
Sentencia If- Else (Si - Sino), 38 Undo, 139
Sentencias básicas S.Q.L, 226 UPDATE, 224
servicio web, 407 Val, 31
sin, 69 ValidationExpression, 352
SOAP, 407 ValidationSummary, 350
Sobrecarga, 200 ValidationType, 352
Split, 73 ValueMember, 276
SqlCommand, 231 ValueToCompare, 352
SqlConnection, 231 variable, 25
SqlDataAdapter, 231 Ventana de depuración de errores, 19, 320
SqlDataSource, 355 Ventana de propiedades, 18, 320
SqlDbDataAdapter, 355 View, 342
sqrt, 69 Visual Basic .NET, 10
Str, 31 Visual Studio .NET, 10
StreamWriter, 137 VScrollBar, 102
String.Copy, 73 WebBrowse, 125
StrReverse, 73 Where, 279
Sub, 61 WHERE, 224
SubString, 73 While, 48
Sum, 280 Width, 175
SUM, 225 Windows Authentication, 422
System.Data.SqlClient, 232, 356 XmlDataSource, 355
System.Drawing, 162 Xor, 33
418
BIBLIOGRAFÍA
 CEBALLOS, Javier. Microsoft Visual Basic .NET Lenguaje y aplicaciones.

México, Editorial Alfaomega Ra-Ma. 2da edición, 2007.
 CHARTE, Francisco. Programación con Visual Basic .NET. México, Editorial
Anaya, 2003.
 HARWRYSZKIEWYCZ, I T. Análisis y diseño de base de datos. Editorial
Megabyte. Noriega Editores. México. 1994.
 JAMSA, Kris. Superutilidades para Visual Basic .NET. Editorial Mc Graw Hill,
1ra. Edición. España. 2003.
INFOGRAFÍA
 http://www.elquintero.net/Manuales.aspx?Cat=2&SubCat=6&jscript=true
 http://www.willydev.net/descargas/Cursos/vbnet/index.html
 http://www.dotnetspider.com/tutorials/AspNet-Tutorials.aspx
 http://www.programacionfacil.com/visual_basic_net/start
 http://www.programacion.com/asp/articulo/datosaspnet/
 http://www.es-asp.net/tutoriales-asp-net/tutorial-61-81/efectuando-acceso-a-
datos.aspx
 http://www.es-asp.net/tutoriales-asp-net/tutorial-61-96/enlazando-a-bases-
de-datos.aspx.
 http://msdn.microsoft.com/es-es/library/y8c0cxey.aspx
 http://msdn.microsoft.com/es-es/library/ya3sah92(VS.80).aspx
 http://msdn.microsoft.com/es-es/library/ff855828(VS.80).aspx
 http://msdn.microsoft.com/es-es/library/a127sbc5(VS.80).aspx
 http://msdn.microsoft.com/es-es/library/h974h4y2(VS.80).aspx
 http://social.msdn.microsoft.com/forums/es-ES/vbes/thread/087a5f2c-9eda-
44a5-9a58-6008b65c9a8e
 http://www.recursosvisualbasic.com.ar/htm/tutoriales/datagrid-dbgrid.htm
 http://www.recursosvisualbasic.com.ar/htm/tutoriales/controles_visual_basic
_menu.htm
419
ANEXO A
SQL Server
Este tutorial utiliza como base de datos SQL Server 2005 Express.
Dicha base de datos se puede instalar independientemente de la versión de Visual
Studio.
A.1 Conectarse a SQL Server.
Cuando se instala SQL Server, en los programas existe una opción para conectarse a la
base de datos seleccione Microsoft SQL Server 2005. Realice los siguientes pasos:
1. Inicio - > Todos los Programas - > Microsoft SQL Server 2005.
2. SQL Server Management Studio Express.
Figura A.1 Opciones para conectarse a SQL Server.
Al pulsar SQL Server Management Studio Express se visualiza la ventana

Connect to Server.
Figura A.2 Ventana Connect to Server.
Deberá digitar lo siguiente:
1. Server Name: Por omisión aparece el nombre del servidor donde fue instalado
SQL Server.
2. Authenticacion: Por omisión aparece Windows Authentication, la otra opción
es SQL Server Authentication. Si selecciona SQL Server Authentication, se
deberá digitar el User Name y el Password creado cuando se realizo la
instalación de SQL Server.
420
3. Pulsar el botón Connect.
Se visualizará el entorno de trabajo de Microsoft SQL Server Management Studio

Express.
Figura A.3 Ventana Microsoft SQL Server Management Studio Express.
A.2 Crear una base de datos
En la ventana Object Explorer seleccione la opción Databases y pulse el botón

derecho del mouse para ver las opciones New Databases, Attach, Restore Databases,
Restore File and FilesGroups y Refresh.
Figura A.4 Opciones de DataBases.
Seleccione la opción New DataBase para ver la siguiente ventana:
421
Figura A.5 Ventana para crear una nueva base de datos.
Escriba el nombre de la base de datos en la opción Database name:

(bdlibrovbnet para los ejemplos del libro) y pulse el botón OK para volver a la
ventana de Microsoft SQL Server. Dé doble clic sobre la carpeta Databases para
desplegar las bases de datos existentes, como se aprecia en la siguiente figura:
Figura A.6 Ventana para crear una nueva base de datos.
Dé doble clic sobre el nombre de la base de datos bdlibrovbnet para desplegar

los elementos que fueron creados. Se obtendrá la siguiente figura:
422
Figura A.7 Base de datos bdlibrovbnet con sus elementos creados inicialmente.
A.3 Crear tablas en la base de datos
Para crear tablas en la base de datos seleccione en cualquiera de las dos ventanas la
carpeta Tables y dé clic derecho para visualizar las opciones: New Tables, Filter y
Refresh.
Figura A.8 Opciones de la carpeta Tables.
423
Seleccione New Table para ver la ventana de diseño de la tabla, como se aprecia
en la siguiente figura:
Figura A.9 Ventana de diseño de una tabla.
Para agregar los campos a la tabla en Column Name escriba nit, en Data Type
seleccione nvarchar (50) (campo alfanumérico).
Figura A.10 Ventana con el campo nit creado.
Realice los mismos pasos para crear los campos: empresa, representante,
direccion, telefono, ciudad (todos con el mismo tipo de datos nvarchar (50)). Por
424
último seleccione el campo nit y pulse el icono para crear la clave primaria ( ), la
figura quedara:
Figura A.11 Ventana con los campos de la tabla y nit como llave primaria.
Ahora se debe guardar la tabla, pulse el signo para visualizar la ventana de

cambios.
Figura A.12 Ventana de cambio de una tabla.
425
Pulse el botón Yes para obtener la ventana para escoger el nombre Choose
Name.
Figura A.13 Ventana para escribir el nombre de la tabla creada.
Escriba como nombre de la tabla clientes y pulse el botón OK. Para trabajar con
algunos de los ejercicios planteados en el libro, cree las tablas pedidos, productos y
ventas con las estructuras que se muestran a continuación:
Figura A.14 Estructura tabla pedidos.
Figura A.15 Estructura tabla productos.
426
Figura A.16 Estructura tabla ventas.
Al finalizar de crear las tablas, la estructura de la base de datos con las tablas
quedaría como se aprecia en la siguiente figura:
Figura A.17 Estructura de la base de datos.
Cuando se selecciona una tabla y se dá clic derecho se visualiza la ventana con las
diferentes opciones que se pueden realizar como son:
1. New Table: Para crear una nueva tabla.

2. Modify: Permite modificar la estructura de una tabla que previamente se había
creado.
3. Open Table: Para abrir una ventana de edición para insertar o visualizar los
datos de una tabla.
4. Script Table as: Para crear, borrar, alterar, seleccionar, insertar, actualizar,
ejecutar una consulta, un archivo o una imagen.
5. View Dependencies: Para visualizar las dependencias (relaciones) de una tabla.
6. Rename: Para renombrar una tabla.
7. Delete: Para eliminar una tabla.
8. Refresh: Para refrescar o actualizar una tabla.
9. Properties: Para visualizar las propiedades de una tabla.
427
Figura A.18 Opciones para la manipulación de una tabla.
Seleccione la tabla clientes y dé clic derecho y escoja la opción Open Table

para insertar información a la tabla.
Figura A.19 Ventana para insertar datos a la tabla clientes.
Inserte la información de acuerdo a la siguiente figura:
Figura A.20 Ventana con datos insertados en la tabla clientes.
428
En este momento se podrá realizar instrucciones SQL para manipular la tabla
clientes. Al pulsarse el icono (Show SQL Pane) se visualizará un panel para digitar
instrucciones SQL. Por omisión se muestra la siguiente ventana:
Figura A.21 Ventana al seleccionar el icono Show SQL Pane.
Si se escribe la instrucción SQL “Select * from clientes where nit>400” y se

pulsa el icono de verificación de sintaxis de instrucciones SQL (Verify SQL sintax)
se visualizará la siguiente ventana:
Figura A.22 Ventana de verificación de sintaxis SQL.
Al pulsarse el botón Aceptar se mostrará la figura:
429
Figura A.23 Ventana al Aceptar la verificación de sintaxis SQL.
Para ejecutar la instrucción SQL deberá dar clic en el icono (Execute SQL),
se vera la siguiente figura:
Figura A.24 Ventana con la instrucción SQl ejecutada.
Ahora se deberán llenar con datos las tablas pedidos, productos y ventas de
acuerdo a las siguientes figuras:
430
Figura A.25 Tabla pedidos con datos insertados.
Figura A.26 Tabla productos con datos insertados.
Figura A.27 Tabla ventas con datos insertados.
A.4 Crear Diagramas de una base de datos
Para crear un diagrama de una base datos seleccione Database Diagrams de la base de
datos bdlibrovbnet, de clic derecho y seleccione la opción New Database Diagram.
Para ver la ventana de adición de tablas:
431
Figura A.28 Ventana Add Table de la opción New Database Diagram.
Seleccione una tabla y pulse el botón Add. Realice esta misma operación con
cada una de las tablas restantes. Al terminar pulse el botón Close para observar la
siguiente figura:
Figura A.29 Ventana Database Diagram con las tablas adicionadas.
Para crear la relaciones entre las tablas seleccione el campo nit de la tabla
cliente, de clic en el mouse y manténgalo pulsado y arrástrelo hacia el campo nit de la
tabla pedidos, suelte el mouse para ver la ventana Tables and Columns.
432
Figura A.30 Ventana Tables and Columns.
En el campo Relationship name escriba el nombre de la relación. Seleccione

como llave primaria (Primary key table) la tabla clientes y el campo nit, como llave
secundaria (Foreign key table) la tabla pedidos y el campo nit. Pulse el botón OK para
visualizar la ventana Foreign Key Relationship.
Figura A.31 Ventana Foreign key Relationship.
En esta ventana se visualizan todas las características de la relación. Pulse el

botón OK para terminar. Realice las demás relaciones hasta obtener la siguiente figura:
433
Fgura A.32 Ventana de diagramás con las relaciones entre tablas.
Ahora se debe guardar el diagrama, pulse el signo para visualizar la ventana

de cambios en un diagrama.
Figura A.33 Ventana de cambios en un diagrama de la base de datos.
Name.
Figura A.34 Ventana para escribir el nombre del diagrama creado.
434
Escriba como nombre del diagrama relaciontablas y pulse el botón OK. Se
visualizará la ventana para guardar los cambios realizados.
Figura A.35 Ventana para guardar los cambios realizados en la base de datos.
Al pulsarse el botón Yes se guardarán los cambios. Seleccionado el diagrama

creado y dar clic derecho se visualizará una ventana donde podrá realizar las siguientes
Tareas: New Database Diagrams (crear un nuevo diagrama), Modify (modificar un
diagrama), Rename (renombrar un diagrama), Delete (eliminar un diagrama), Refresh (
refrescar un diagrama).
Figura A.36 Ventana para manipulacion de los diagramás.
A.5 Crear una vista
Una vista es un espejo de cierta información que contiene una base de datos. Para crear
una vista de una base datos seleccione View de la base de datos bdlibrovbnet, dé clic
derecho y seleccione la opción New View. Para ver la ventana de adición de vistas:
435
Figura A.37 Ventana para adicionar tablas a una vista.
Adicione las tablas clientes y pedidos. Al terminar pulse el botón Close para
Figura A.38 Ventana de la vista con las tablas clientes – pedidos.
Seleccione los campos que desea ver en la vista. Dé clic en el icono

(Execute SQL), para ver la Ejecución de la vista:
436
Figura A.39 Ventana de ejecución de la vista creada.
Ahora se debe guardar la vista creada, pulse el signo para visualizar la

ventana de cambios en una vista.
Figura A.40 Ventana de cambios en una vista.
Name.
Figura A.41 Ventana para escribir el nombre de la vista creada.
437
Escriba como nombre de la vista vista_clientes_pedidos y pulse el botón OK.
Se visualizará la siguiente figura:
Figura A.42 Ventana con la vista guardada.
438

Visual Basic ASP

Transféré par

Informations du document

Description originale:

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Visual Basic ASP

Transféré par

Droits d'auteur :

Formats disponibles

Visual Basic y ASP .

Carlos Alberto Vanegas

Bogotá, enero 2011

Todo el material didáctico del libro se trata de exponer en un lenguaje sencillo,

Debido al enfoque practico, basado en ejercicios y al esfuerzo de síntesis resulta

Capítulos del Libro

Visual Basic y ASP .NET a su alcance contiene 16 capítulos distribuidos de la siguiente

 Capitulo 1, Introducción a Visual Basic .NET: Se realiza una

Como apoyo complementario a esta publicación se ha incluido un CD que

Si al insertar el CD no se ejecuta automáticamente, el usuario deberá abrir el

1.1 Microsoft Visual Studio .NET

Microsoft Visual Studio .NET es un entorno de desarrollo integrado (Integrated

1.2 .NET FrameWork

Es un componente integral de Windows que proporciona un entorno para varios

 Proporcionar un entorno de programación orientada a objetos.

.NET FrameWork se compone de dos partes principales: Common Language Runtime

Common Language Runtime es el motor en tiempo de ejecución, ya que

La biblioteca de clases es una completa colección orientada a objetos de tipos

1.3 Página de Inicio Visual Studio .NET/2008

Al instalarse Microsoft Visual Studio 2008, se crea en el computador una carpeta

En la página de inicio de Visual Studio .NET/2008, encontrará una barra de

Figura 1.1 Página de Inicio Visual Studio 2008.

Las principales características del IDE de Microsoft Visual Studio/2008 se

Tabla 1.1 caracteristicas de programación en Visual Basic .NET.

Microsoft Visual Studio/2008 trabaja con el marco de trabajo .NET FrameWork

 Integración total de LINQ2 (Language Integrated Query) y del reconocimiento

Como ejemplo, se creará un proyecto Windows Forms llamado

2.1 Crear una Aplicación Windows Forms

1. En la ventana proyectos recientes seleccionar la opción Crear: link Proyecto…

Cuando se crea un proyecto por cualquier de las dos opciones se visualiza la

Figura 2.1 Ventana Nuevo proyecto.

2.2 Elegir la plantilla de aplicaciones.

Para el ejemplo como Tipo de proyecto se debe seleccionar Visual Basic -

Figura 2.2 Entorno de desarrollo nuevo proyecto Windows Forms.

Cuando se selecciona una plantilla de aplicaciones, en el entorno de desarrollo

1. Menú principal y la barra de herramientas estándar: Proporcionan acceso a

Figura 2.3 Menu principal y barra de herramientas estándar.

2. Cuadro de Herramientas: El cuadro de herramientas contiene diversos

Figura 2.4 Cuadro de Herramientas.

3. Diseñador formulario Windows (Windows Forms): Cuando se inicia un

o En el Explorador de soluciones , seleccionar el formulario y dé clic en

Figura 2.5 Formulario Windows.

4. Explorador de soluciones : Permite visualizar archivos y realizar tareas de

Figura 2.6 Ventana Explorador de soluciones.

Tabla 2.1 Tipos de Archivos en Visual Basic .NET.

Extensión Nombre Descripción

5. Ventana de propiedades: Muestra una lista de las propiedades que facilitan la

categorías de la ventana Propiedades. Las propiedades para el formulario o

o Para visualizar las propiedades de una categoría: se expande el nodo de la

o Para visualizar las propiedades alfabéticamente, dé clic en el botón Alfabético

6. Ventana de depuración de errores: Muestra una lista de los errores que se

Figura 2.8 Ventana de lista de errores.

2.3 Crear la interfaz de usuario.

1. Cambiar la posición de un control: Hacer clic en el mismo para seleccionarlo, y

2.4 Establecer las propiedades de los controles

Después de colocar los controles u objetos a un formulario, se puede establecer sus

Tabla 2.2 Propiedades de los controles de la aplicación MiProgramaWF.

Control Propiedad Valor

La interfaz de usuario con las modificaciones respectivas en las propiedades de

2.5 Escribir código

1. Seleccionar el control en el que se desea escribir código.

El Editor de código contiene dos listas desplegables en la parte superior de la

Ahora escriba el siguiente código entre Private Sub y End Sub: