Libro Visual Basic y ASP .NET a Su Alcance 2E

1

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

2

3

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

4

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

5

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

6

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

7

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.

8

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.

9

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.

10

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.

11

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.

12

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 Forms

Una superficie de diseño gráfico que permite crear rápidamente la interfaz de usuario de una aplicación. Se puede arrastrar o dibujar controles sobre esta superficie.

Herramientas para Aplicaciones Windows Forms

Se proporciona una plantilla Aplicación Windows Forms, con referencias de proyectos básicos y código de inicio como ayuda para crear aplicaciones Windows Forms estándares.

Herramientas para Web Forms

Se proporciona una plantilla Aplicación Web ASP.NET, con 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 servicios Web XML

Se proporciona una plantilla Aplicación de servicios Web ASP.NET. Esta plantilla construye la estructura de un proyecto de aplicación Web en un servidor Web de desarrollo.

13

Soporte de múltiples lenguajes

Soporta los lenguajes de programación de la plataforma .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.

14

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:

15

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).

16

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.

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

Barra de Herramientas

Menú Principal

17

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.

18

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 Studio

Organiza proyectos, elementos de proyectos y elementos de soluciones en una solución proporcionando al entorno referencias a sus ubicaciones en disco.

.suo Solution user options

Registra todas las opciones que podemos asociar a nuestra solución de forma que cada vez que abramos la solución incluya las personalizaciones que hayamos realizado.

.vb Proyecto Visual Basic

Representa los archivos de formularios, controles de 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 Basic

Representa los archivos de formularios, controles de 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

.asmx

.asax

Elementos de proyecto Web

Los elementos de proyecto Web incluyen archivos Web específicos como .aspx para Web Forms, .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.

19

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.

20

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:

21

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.

22

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:

23

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

24

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.

25

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

26

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 +/- 7,9228162514264337593543950335.

12 bytes

Double Representa un valor en coma flotante de 64 bits. De -1,79769613486231570E+308 a -4,94065645841246544E-324 para valores negativos; 4,94065645841246544E-324 a 1,79769613486231570E+308 para valores positivos.

8 bytes

Integer Representa un valor entre un rango de +/-2,147,483,698 4 Bytes

Long Representa un valor entre un rango de +/- 9.223.372.036.854.775.807

8 Bytes

Short Representa un valor entre un rango de +/- 32.677 2 Bytes

Single De -3,4028235E+38 a -1,401298E-45 para los valores negativos; 1,401298E-45 a 3,4028235E+38 para los valores positivos.

4 bytes

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.

27

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:

28

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

29

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

30

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:

31

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.

32

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 Basic .NET

Operador Expresión

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 Relacionales

Operador Expresión

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 Igualdad

Operador Expresión

Diferente <> variable1<>variable2

De asignación ó Igual a

= variable1=valor variable1=variable2

33

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

lógicos Operador Expresión

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:

34

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).

35

Escribir código

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 .

36

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

37

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 Instrucción(es) a ejecutarse si la condición es verdadera ::::::: If (condición) Then Instrucción(es) a ejecutarse si la condición es verdadera :::::::: 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.

38

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

Instrucción(es) a ejecutarse si las condiciones son verdaderas :::::::: Endif Resto del programa Ó If (condición1 > condicion2 And condicion1 > condicion3) Then Instrucción(es) a ejecutarse si las condiciones son verdaderas :::::::: Endif Resto del programa Ó If (condición1 > condicion2 Or condicion1 > condicion3) Then Instrucción(es) a ejecutarse si las condiciones son verdaderas :::::::: 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 Instrucción(es) a ejecutarse si la condición es verdadera :::::::: 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.

39

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 Dim respuesta As String 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

segundo H M S

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

40

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

41

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).

Escribir código

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

42

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

43

... ... [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).

44



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).

Escribir código



Dim valor As Integer valor = numero.Text Select Case valor Case Is = 1 dia.Text = "Lunes" Case Is = 2 dia.Text = "Martes"

45

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

46

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

47


Text Estructura For-Next


Figura 4.8 Interfaz de usuario final (EstructuraForNext).

Escribir código


escriba el siguiente código: 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:

48

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

49

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


50

Figura 4.12 Interfaz de usuario final (EstructuraWhile).

Escribir código


escriba el siguiente código: 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

51

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:

52

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

53

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).

Escribir código


escriba el siguiente código: Dim valor, suma As Integer Dim respuesta As String 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

54

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:

55

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.

56

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)

57

Escribir código


escriba el siguiente código: 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.

58

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.

59

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

60

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.

61

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

62

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.


63

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”).

64

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

65

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:

66

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.

67

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


68

Figura 5.7 Interfaz de usuario (FuncionesFechasHoras).

Escribir código


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:

69

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

70

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.


71

Figura 5.9 Interfaz de usuario (FuncionesMatematicas).

Escribir código


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:

72

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 específico de una cadena de caracteres.

Dim micadena As String = "ABCDE" Dim micaracter As Char micaracter = micadena.Chars(3) micaracter = "D"

Length: Permite obtener la longitud de de una cadena de caracteres.

Dim micadena As String = "ABCDE" Dim Entero As Integer entero=cadena.length entero=5

Concat(texto1, texto,...., texton): Permite unir dos o más cadenas de caracteres.

Dim micadena As String = "hola" Dim unircadena As String unircadena= String.Concat(micadena, " ", "pueblo") unircadena=” hola pueblo”

ToUpper: Convierte una cadena de caracteres de minúscula a mayúscula.

Dim micadena As String = "hola" micadena= micadena.ToUpper() micadena=” HOLA”

ToLower: Convierte una cadena de caracteres de mayúscula a minúscula.

Dim micadena As String = "HOLA" micadena= micadena.ToLower() micadena=” hola”

73

Remove(posición inicial, número de caracteres): Permite eliminar una cantidad determinada de caracteres en una posición específica de una cadena de caracteres.

Dim micadena As String = "campoalegre" micadena= micadena.Remove(2,3) micadena=” caalegre”

Insert (posición de inserción,”cadena de caracteres”): Permite insertar una cantidad determinada de caracteres en una posición específica de una cadena de caracteres.

Dim micadena As String = "campoalegre" micadena= micadena.insert(4,” más ”) micadena=” campo más alegre”

SubString((posición inicial, número de caracteres): Permite obtener una subcadena de una cadena de caracteres.

Dim micadena As String = "campoalegre" Dim subcadena As String subcadena= micadena.substring(5,4) subcadena=”aleg”

Replace(cadena de caracteres, carácter original, nuevo carácter): Permite reemplazar una subcadena determinada por otra subcadena especificada.

Dim micadena As String = "campoalegre" Dim Nuevacadena As String nuevacadena =replace(m icadena , "e", "i") nuevacadena=”cam poal ig r i ”

StrReverse(cadena de caracteres): Devuelve una cadena de caracteres invertida según el orden de los caracteres de la cadena especificada.

Dim micadena As String = "campoalegre" Dim Nuevacadena As String nuevacadena =StrReverse(m icadena ) nuevacadena=”erge laopm ac ”

Mid (cadena de caracteres, posición inicial, numero de caracteres), Mid (cadena de caracteres, posición inicial): Devuelve una subcadena que a su vez contiene un número especificado de caracteres de una cadena de caracteres.

Dim micadena As String = "campoalegre" Dim Nuevacadena As String nuevacadena =Mid(m icadena,1 ,5 ) nuevacadena=”cam po” Dim micadena As String = "campoalegre" Dim Nuevacadena As String nuevacadena =Mid(m icadena,5 ) nuevacadena=”a legre ”

Len (cadena de caracteres): Devuelve un entero que contiene el número de caracteres de una cadena de caracteres.

Dim micadena As String = "ABCDE" Dim Entero As Integer entero=len(micadena) entero=5

TocharArray: Convierte una cadena de caracteres en un arreglo de caracteres.

Dim micadena As String = "campeon" Dim arreglo() As char arreglo=mi cadena.ToCharArray() arreglo={‘c’,’a’,’m’,’p’,’e’,’o’,’n’}

Split (cadena de caracteres, delimitador): Devuelve un arreglo unidimensional que contiene un número específico de subcadenas.

Dim cadena as String=”42,21,50,33” Dim subcadenas() As String Subcadenas=Split(subcadenas,”,”) Retorna={”42” “21” “50” “33”}

Trim (cadena): Elimina los espacios de ambos lados de una cadena de caracteres.

Dim cadena As String=” Colombia “ cadena=Trim(cadena)

Asc (carácter): Devuelve el numero Ascci de un carácter.

Dim numero As Integer numero=Asc(“a”) ‘Devuelve 97

Chr (numero): Devuelve el carácter Ascci de un número.

Dim letra As char letra=Chr(97) ‘Devuelve “a”

String.Copy (cadena): Copia una cadena de caracteres.

Dim cadena As String=”Hola” Dim copia as String copia=String.Copy(cadena)

IndexOf (carácter a buscar): Devuelve la posición de un carácter específico.

Dim cadena as String=”Colombia” Dim posición As Integer posición=cadena.IndexOf(“m”) ‘Devuelve 4

74

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.


75

Figura 5.11 Interfaz de usuario (FuncionesCadenas).

Escribir código

Seleccione el objeto boton1 y abra el editor de código y escriba el siguiente código: resultado.Text = texto.Text.Chars(5)

Seleccione el objeto boton2 y abra el editor de código y escriba el siguiente código:

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)

76


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.

77

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.

78

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.

79


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).

80

Escribir código


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:

81

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

82

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).

83

Escribir código


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.

84

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.



85


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).

86

Escribir código

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 = "" For Each elemento As Integer In coleccion 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 For Each elemento As Integer In coleccion If (elemento = dato) Then

87

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:

88

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.

89

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.

90

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.

91

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:

LinkLabel1

Name vinculogoogle

Text Ir a Google

LinkLabel2

Name vinculoexcel

Text Abrir Excel


Text Control LinkLabel



92

Figura 7.1 Interfaz de usuario (ControlLinkLabel).

Escribir código

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.

93

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

94

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:

95

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.

96

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:

97

Figura 7.9 Ventana del Editor con los elementos agregados al control ComboBox.

Escribir código

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 texto.Font = New Font("Microsoft Sans Serif", 12, FontStyle.Bold) Case Is = 2 texto.Font = New Font("Microsoft Sans Serif", 16, FontStyle.Bold) Case Is = 3 texto.Font = New Font("Microsoft Sans Serif", 20, FontStyle.Bold) Case Is = 4 texto.Font = New Font("Microsoft Sans Serif", 22, FontStyle.Bold) Case Is = 5 texto.Font = New Font("Microsoft Sans Serif", 24, FontStyle.Bold) Case Is = 6 texto.Font = New Font("Microsoft Sans Serif", 26, FontStyle.Bold) Case Is = 7 texto.Font = New Font("Microsoft Sans Serif", 28, FontStyle.Bold) 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:

98

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.

99

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.


Label1

Name txtcheckbox

Text Uso del control Checkbox

BorderStyle Fixed3D

Label2

Name txtradiobutton

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


100

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).

Escribir código

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:

If (Chequeo2.Checked) Then txtcheckbox.BackColor = System.Drawing.Color.Aquamarine Else txtcheckbox.BackColor = System.Drawing.Color.White End If

101

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:

If (Chequeo3.Checked) Then 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


If (opcion2.Checked) Then 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


If (opcion3.Checked) Then 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

102

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.




http://msdn.microsoft.com/library/SPA/cpref/html/frlrfsystemwindowsformsscrollbarclasstopic.asp

http://msdn.microsoft.com/library/SPA/cpref/html/frlrfsystemwindowsformstrackbarclassvaluetopic.asp

http://msdn.microsoft.com/library/SPA/cpref/html/frlrfsystemwindowsformstrackbarclassminimumtopic.asp

http://msdn.microsoft.com/library/SPA/cpref/html/frlrfsystemwindowsformstrackbarclassmaximumtopic.asp

103

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


VScrollBar1, VScrollBar2, VScrollBar3.

Name barra1, barra2, barra3

Maximum 255

Minimum 0

TrackBar1, TrackBar2, TrackBar3

Name desplazamiento1, desplazamiento2, desplazamiento3

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).

Escribir código

a) Seleccione el objeto barra1, dé doble clic para abrir el editor del procedimiento

barra1_Scroll y escriba el siguiente código:

104

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


panelcolores.BackColor = Color.FromArgb (barra1.Value, barra2.Value, barra3.Value) txtverde.Text = barra2.Value

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


panelcolores.BackColor = Color.FromArgb (barra1.Value, barra2.Value, barra3.Value)

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.

105

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.



106

Figura 7.15 Interfaz de usuario (DataGridView).

Escribir código

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:

107

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.




108

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:

109

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.

110

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.

111

Figura 7.23 Interfaz de usuario final de la aplicación ListView.

Escribir código

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 Class formulario 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

112

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 For Me.i = 0 To elementospedido.Items.Count - 1 sumar = sumar + CDbl(elementospedido.Items(i).SubItems(2).Text) Next txttotal.Text = sumar

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.

113

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 For Me.i = 0 To elementospedido.Items.Count - 1 sumar = sumar + CDbl(elementospedido.Items(i).SubItems(2).Text) Next txttotal.Text = sumar

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

114

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.

115

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:

116

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).

Escribir código

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)

117

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:

118

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.

119

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).

120

Escribir código

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 Public Class formulario …… 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

121

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.

122

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).

123

Escribir código

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 Catch ex As Exception 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:

124

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:

125

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

126

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.

127

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.

Escribir código

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()

128

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.

http://google.com.co/

129

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

130

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.

131



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.

132




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.

133

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:

134

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.

135

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.

136

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.

Escribir código

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:

137

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

138

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 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() 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


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()

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.

139

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

y escriba el siguiente código: 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.

140

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


141

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,

142

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:

143

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.

144

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:

145

Tabla 8.3 Propiedades de los controles del segundo formulario.


Label1

Name lblfecha

Text Seleccione una nueva fecha

Font - Bold True

Label2

Name lblformato

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.

Escribir código

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:

146

Tabla 8.4 Propiedades de los controles del tercer formulario.


Label1

Name lblfecha

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.

Escribir código


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:

147

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.

Escribir código


listaespañol_SelectedIndexChanged y escriba el siguiente código:

148

If listaespañol.GetItemChecked(0) Then txtvaca.Text = "COW" Else txtvaca.Text = "" End If If listaespañol.GetItemChecked(1) Then txtabeja.Text = "BEE" Else txtabeja.Text = "" End If If listaespañol.GetItemChecked(2) Then txtoso.Text = "BEAR" Else txtoso.Text = "" End If If listaespañol.GetItemChecked(3) Then txtpajaro.Text = "BIRD" Else txtpajaro.Text = "" End If If listaespañol.GetItemChecked(4) Then txtperro.Text = "CAN" Else txtperro.Text = "" End If If listaespañol.GetItemChecked(5) Then 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

149

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()

150

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:

Dim formularioactivo As Form = Me.ActiveMdiChild Dim nuevaventana As RichTextBox = CType(formularioactivo.ActiveControl, RichTextBox) 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(nuevaventana.Text) guardarárchivo.Close()

151

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


Dim formularioactivo As Form = Me.ActiveMdiChild Dim nuevaventana As RichTextBox = CType(formularioactivo.ActiveControl, RichTextBox) nuevaventana.Undo()

g) Seleccione el menú Rehacer, dé doble clic para abrir el editor del procedimiento


Dim formularioactivo As Form = Me.ActiveMdiChild Dim nuevaventana As RichTextBox = CType(formularioactivo.ActiveControl, 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


Dim activeChild As Form = Me.ActiveMdiChild Dim nuevaventana As RichTextBox = CType(activeChild.ActiveControl, RichTextBox)

152

nuevaventana.Paste()

j) Seleccione el menú Copiar, dé doble clic para abrir el editor del procedimiento


Dim activeChild As Form = Me.ActiveMdiChild Dim nuevaventana As RichTextBox = CType(activeChild.ActiveControl, RichTextBox) 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.MdiParent = Me formularios.Show()

n) Seleccione el menú Formulario Lenguaje, dé doble clic para abrir el editor del


Dim formularios As New formulariolenguaje formularios.MdiParent = Me 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.

153

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.

154

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.

155

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.

156

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:

157

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.

158

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: Dim activeChild As Form = Me.ActiveMdiChild Dim nuevaventana As RichTextBox = CType(activeChild.ActiveControl, RichTextBox) nuevaventana.Cut()

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

Dim activeChild As Form = Me.ActiveMdiChild Dim nuevaventana As RichTextBox = CType(activeChild.ActiveControl, RichTextBox) nuevaventana.Paste()

d) Dé doble clic sobre el Button botoncopiar y escriba el siguiente código:

159

Dim activeChild As Form = Me.ActiveMdiChild Dim nuevaventana As RichTextBox = CType(activeChild.ActiveControl, RichTextBox) 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.

160

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.

161

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.

162

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. Dim graficador As Graphics 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.

163

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, FillRectangle

Dibuja un rectángulo especificado por un par de coordenadas, un valor de ancho y un valor de alto.

Circulo / Elipse DrawEllipse, FillEllipse

Dibuja una elipse definida por un rectángulo 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, FillPolygon

Dibuja un polígono definido por una matriz 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.




http://msdn2.microsoft.com/es-es/library/system.drawing.point.aspx

http://msdn2.microsoft.com/es-es/library/system.drawing.point.aspx

164

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


Label1

Name lbltexto

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.

Escribir código

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 Dim graficador As Graphics 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:

165

Dim lapiz As New Pen(Color.FromArgb(255, 0, 255, 0), 4) Dim graficador As Graphics 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.

166




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:

167

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.

168

Escribir código

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


grafica.CreateGraphics.Clear(Me.BackColor) 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

procedimiento y escriba el siguiente código: grafica.CreateGraphics.Clear(Me.BackColor) Dim recortar As Single() = {3, 4, 10, 2} Dim lapiz As New Pen(Color.Blue, 3) 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


grafica.CreateGraphics.Clear(Me.BackColor) Dim conectar As New Drawing2D.GraphicsPath() Dim lapiz As New Pen(Color.Blue, 8)

169

conectar.StartFigure() conectar.AddLine(New Point(100, 30), New Point(200, 30)) conectar.AddLine(New Point(100, 200), New Point(200, 30)) conectar.AddLine(New Point(100, 200), New Point(200, 200)) 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.Clear(Me.BackColor) 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.Clear(Me.BackColor) 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.Clear(Me.BackColor) 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.Clear(Me.BackColor) grafica.CreateGraphics.FillRectangle(Brushes.Red, 100, 100, 80, 80)

170

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


grafica.CreateGraphics.Clear(Me.BackColor) 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


grafica.CreateGraphics.Clear(Me.BackColor) 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

procedimiento y escriba el siguiente código: grafica.CreateGraphics.Clear(Me.BackColor) 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

procedimiento y escriba el siguiente código: grafica.CreateGraphics.Clear(Me.BackColor) grafica.CreateGraphics.FillEllipse(Brushes.Blue, 100, 100, 60, 80)

171

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.Clear(Me.BackColor) 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

procedimiento y escriba el siguiente código: grafica.CreateGraphics.Clear(Me.BackColor) 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


grafica.CreateGraphics.Clear(Me.BackColor) 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:

grafica.CreateGraphics.Clear(Me.BackColor) 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.Clear(Me.BackColor) 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

172

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.Clear(Me.BackColor) 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.

173



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.

174

Escribir código

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


175

If (botonderechatimer.Focused) Then imagen.Left = imagen.Left + 10 End If If (botonabajotimer.Focused) Then imagen.Top = imagen.Top + 10 End If If (botondiagonaltimer.Focused) Then imagen.Top = imagen.Top + 10 imagen.Left = imagen.Left + 10 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.

176

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.


PictureBox1

Name imagen

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.

177

Escribir código

a) Seleccione el objeto botonexpandir, dá doble clic para abrir el editor del

procedimiento y escriba el siguiente código: 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

procedimiento y escriba el siguiente código: 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




procedimiento y escriba el siguiente código: 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.


escriba el siguiente código: 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

178

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.






179


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


PictureBox1

Name pintura

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.

Escribir código

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

180

Integer.

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

procedimiento y escriba el siguiente código: reloj.Enabled = True

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


reloj.Enabled = False

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.

181

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.


PictureBox1

Name imagen

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:

182

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.

183

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.

Escribir código



Public class formulario Dim y As Integer Dim interruptor As Integer Private sub ………..

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

184

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.

185

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.

186

Escribir código



Public class formulario Dim grafica As Graphics Dim valorx, valory As Integer Dim fuente As New System.Drawing.Font("Arial", 14, FontStyle.Bold) Private sub ………..

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.



reloj.Enabled = False



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

187

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.

188

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.

189

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.

Escribir código


creación de la clase formulario. Public class formulario Dim mover As Boolean = False Dim primeravez As Boolean = False Dim valorx = 0 Dim valory = 0 Private sub ………..

190

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:

191

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.

Escribir código


creación de la clase formulario. Public class formulario Dim x,y as Integer Dim moverraton As Boolean = False Dim grafica As Graphics=Me.createGraphics Private sub ………..

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:

192

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.

193

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.

194

Escribir código

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 lbltexto.Text = "La tecla pulsada fue la: " + Convert.ToChar(e.KeyValue) End If If e.KeyCode = Keys.N Then pintura.BackColor = Color.Black lbltexto.Text = "La tecla pulsada fue la: " + Convert.ToChar(e.KeyValue) 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.

195

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.

Escribir código

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

196

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.

197

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.

198

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

http://es.wikipedia.org/wiki/Herencia_en_programaci%C3%B3n_orientada_a_objetos

http://es.wikipedia.org/wiki/Encapsulaci%C3%B3n_en_programaci%C3%B3n_orientada_a_objetos

199

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

200

inicializaría con los mismos valores.

Class Alumno Private nombre_alumno As String Private asignatura As String 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 Public Function obtenerCurso(curso As Integer) As Integer 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 nombre_alumno As String Private asignatura As String 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 Public Function obtenerNombre(nombre As String) As String return nombre End Function Public Function obtenerCurso(curso As Integer) As Integer 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.

201

Class Alumno Private nombre_alumno As String Private asignatura As String 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 Public Sub New(nombre As String, asig As String) nombre_alumno=alumno asignatura=asig curso=0 End Sub Public Function obtenerNombre(nombre As String) As String return nombre End Function Public Function obtenerCurso(curso As Integer) As Integer 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).

202

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.

203

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

204

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.

205

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.

206

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.

207

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


208

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

209

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

210

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

211

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

212

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.

213


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

214

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,

215

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.

216


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:

217

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

218

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):

219

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.

6. En el Explorador de soluciones situarse en el nombre del proyecto, dar clic

derecho, seleccionar la opción Agregar nuevo elemento… - Interfaz.


Figura 11.20 Ventana para agregar una Interface.

220

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:

221

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 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) / 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 Dim base, altura As Double 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.

222


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.

223

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.

http://www.monografias.com/trabajos16/comportamiento-humano/comportamiento-humano.shtml

224

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.

ALTER Modifica las tablas agregando campos o cambiando la definición de los campos.

Comandos DML

SELECT Permite consultar registros de una base de datos que cumplan una condición 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

FROM Sirve para especificar el orgen de datos (tabla) de la cual se van a seleccionar registros.

WHERE Permite especificar condiciones que deben cumplir los registros a 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.

225

Tabla 12.3 Operadores lógicos SQL.

Operador Uso

AND Evalúa dos condiciones y devuelve un valor de verdad sólo si ambas son ciertas.

OR Evalúa dos condiciones y devuelve un valor de verdad si alguna de 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.

ALL Devuelve Verdadero (True) si el conjunto de comparaciones de un 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.

226

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

227

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

228

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

229

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:

230

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.

231

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:

232

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.

Escribir código

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

233

Try adaptadordedatos = New SqlDataAdapter(seleccion, conexion) adaptadordedatos.Fill(tabladedatos) tabla.DataSource = tabladedatos Catch ex As Exception 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.

234

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).

235

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

236

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.

237

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:

238

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:

239

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.

240

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

241

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:

242

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:

243

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:

244


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.

245

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:

246

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.

247


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.

248

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.

249


Figura 12.31 Interfaz de usuario (InsertarNuevoRegistro).

Escribir código

a) Antes de la apertura de la clase formulario se debe importar el siguiente espacio

de nombres:

Imports System.Data.SqlClient 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:

Imports System.Data.SqlClient Public class formulario 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:

250

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 MsgBox(ex.Message.ToString) Catch ex As Exception MsgBox(ex.Message.ToString) 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)

251

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.

252

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

253

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).

Escribir código

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:

254

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:

Imports System.Data.SqlClient Public Class formulario

…… End Class

d) Después de la apertura de la clase formulario y antes de los procedimientos

Sub, inicialice la siguiente variable global:

255

Public class formulario 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


Dim conexion As String conexion = "Data Source=(local)\SQLEXPRESS;Database=bdlibrovbnet; Integrated Security=True" 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 Dim tabladedatos As New DataTable Try adaptador = New SqlDataAdapter(seleccion, conexion) adaptador.Fill(tabladedatos) tabla.DataSource = tabladedatos Catch ex As Exception

256

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.

257



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:

258

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.

259

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.

260



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.

261


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:

262

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:



263


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.

264

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.

265

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.

266

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.

267

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.

268


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

269

name boton

DataGridView1 Name tablapedidos

ComboBox1 Name lista

Form1

Name formulario

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:


270

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.

271

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:

272

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:

273

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:

274

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.

Escribir código

a) Antes de la apertura de la clase formulario se debe importar el siguiente espacio

de nombres:

Imports System.Data.SqlClient Public Class formulario :::::::

End Class

b) Después de la apertura de la clase formulario y antes de los procedimientos

275

sub, inicialice las siguientes variables u objetos globales: Public class formulario 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

276

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.

277

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:

278

Dim consulta = From misclientes In Clientes 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á.

Dim consulta = From misclientes In Clientes 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:

Dim consulta = From misclientes In Clientes 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:

Dim consulta = From misclientes In Clientes 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á: Dim consulta = From misclientes In Clientes 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.

279

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”}

280

- 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


281

Figura 13.1 Interfaz de usuario (ConsultaLinqTexto).

Escribir código

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

282

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.

283

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


284

Figura 13.3 Interfaz de usuario (ConsultaLinqMatriz).

Escribir código

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()

285

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.

286

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 Propiedad

Valor

Button1 Name boton

Text Ejecutar consulta LINQ to SQL

DataGridView1 Name cuadricula


Text Consulta LINQ to SQL.


Figura 13.5 Interfaz de usuario (ConsultaLinqToSQL).

287

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. 3. En el Explorador de soluciones situarse en el nombre del proyecto, dar clic

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.

288

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:

289


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,

290

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.

Escribir código

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.

291


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

292


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).

293

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

294

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.

295

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.

296

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:

297

Figura 13.24 Control listaclientes con los campos empresa y nit seleccionados.

Escribir código

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:

Public Class formulario 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:

Public class formulario

:::::::::: 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


298

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 registroseleccionado As String = listaclientes.SelectedItem(0) Dim consulta = From miregistro In vista.clientes Where miregistro.nit = registroseleccionado 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() Catch ex As Exception 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.

299

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

y escriba el siguiente código: Dim respuesta = MsgBox("Desea Eliminar el registro seleccionado", MsgBoxStyle.YesNo) If (respuesta = MsgBoxResult.Yes) Then Try Dim registroseleccionado As String = listaclientes.SelectedItem(0) Dim consultaeliminar = From miregistro In vista.clientes Where miregistro.nit = registroseleccionado For Each campos In consultaeliminar vista.clientes.DeleteOnSubmit(campos) Next vista.SubmitChanges() Catch ex As Exception MsgBox("Error en el sistema") 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) If (respuesta = MsgBoxResult.Yes) Then Try Dim nuevoregistro As New clientes With { _ .nit = txtnit.Text, .empresa = txtempresa.Text, _ .representante = txtrepresentante.Text, _ .ciudad = txtciudad.Text, .direccion = txtdireccion.Text, _

300

.telefono = txttelefono.Text} vista.clientes.InsertOnSubmit(nuevoregistro) vista.SubmitChanges() txtnit.Enabled = False Catch ex As Exception MsgBox("Error en el sistema") 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.

301

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).

302

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.

303

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:

304


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.

Escribir código

Seleccione el objeto botonbuscar, dé doble clic para abrir el editor de código y escriba

el siguiente código:

305

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.

306

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.

307


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.

308

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.

309

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.

310

Escribir código

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.

311

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 Propiedad

Valor

DataGridView1 Name datosclientes

DataGridView2 Name datospedidos

DataGridView3 Name tablasrelacionadas


Text Consulta LINQ to DataSet.


Figura 13.44 Interfaz de usuario (ConsultaLinqDataSet).

312

Escribir código

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; Integrated Security=True"

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"), _

313

.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.

314

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.

315

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

316

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.

317

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.

318

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:

319

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

320

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.

321

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,

322

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 If listacomida.SelectedIndex = 1 Then valor = 13000 End If If listacomida.SelectedIndex = 2 Then valor = 8000 End If If listacomida.SelectedIndex = 3 Then valor = 9000 End If

323

If listacomida.SelectedIndex = 3 Then 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 If listabebida.SelectedIndex = 1 Then valor = 2000 End If If listacomida.SelectedIndex = 2 Then valor = 1800 End If If listabebida.SelectedIndex = 3 Then valor = 4000 End If If listabebida.SelectedIndex = 3 Then 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 = datos.NewRow() nuevafila("Producto") = listacomida.SelectedItem nuevafila("Precio") = valor datos.Rows.Add(nuevafila) tablapedido.DataSource = datos tablapedido.DataBind() sumas = 0 For i = 0 To tablapedido.Rows.Count - 1 Dim sumafila As GridViewRow = tablapedido.Rows(i) sumas = sumas + Val(sumafila.Cells(1).Text) Next txtsubtotal.Text = Val(sumas)

324

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 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 = datos.NewRow() nuevafila("Producto") = listabebida.SelectedItem nuevafila("Precio") = valor datos.Rows.Add(nuevafila) tablapedido.DataSource = datos tablapedido.DataBind() sumas = 0 For i = 0 To tablapedido.Rows.Count - 1 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.

325

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.

326

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

327

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

Label2

ID lblfrutaseleccionadas

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 archivo

pagina.aspx

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

328

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.

Escribir código

Dé doble clic en el objeto CheckBoxList llamado listafrutas, para abrir el editor del

329

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

330

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

Label2

ID lblseleccion

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

331

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.

332

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.

333

Escribir código

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

334

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

BulletedList1

ID listapaginas

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.

335

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.

336


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.

337

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

RadioButton

ID listapaginas

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.

http://www.asp.net/ES

338

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:

339

Figura 14.27 Interfaz de usuario final aplicación ControlRadioButtonList.

Escribir código

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:

340

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).

http://www.asp.net/ES/

341

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:

342

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:

343

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


344

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.

345

Escribir código

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 multiplesvistas.ActiveViewIndex = 2

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

escriba el siguiente código: If (multiplesvistas.ActiveViewIndex > 0) And (multiplesvistas.ActiveViewIndex <= 2) Then multiplesvistas.ActiveViewIndex -= 1 ElseIf multiplesvistas.ActiveViewIndex = 3 Then multiplesvistas.ActiveViewIndex = 0 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”.

346

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 multiplesvistas.ActiveViewIndex = 3

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 multiplesvistas.ActiveViewIndex = 1 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.

347

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.

348

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:

349

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.

350

Escribir código

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:[email protected]" 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

351

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, [email protected] y se pulsá el botón Enviar, se

obtendría la página sin mensajes de error.

352

Figura 14.42 Ejecución Controles_de_Validacion con datos correctos.

353

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.

354


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.

355

Escribir código

a) Antes de la apertura de la clase Default se debe importar los siguientes espacios

de nombres:

Imports System.Data Imports System.Data.SqlClient 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: 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 Try adaptadordedatos = New SqlDataAdapter(seleccion, conexion) adaptadordedatos.Fill(tabladedatos) cuadriculadatos.DataSource = tabladedatos cuadriculadatos.DataBind() lblnumeroregistros.Text = "Total de Registros:" & tabladedatos.Rows.Count Catch ex As Exception 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;

356

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.

357

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…>


358


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:

359

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:

360


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.

361

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.

362



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.

363


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:

364

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:

365

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:

366




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 *.

367

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.

368

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.

369

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.

370

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:

371

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:

372

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.


373

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.

374

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

375

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.

376

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.

377



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:

378

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:

379

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:

380

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.

381

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.

382

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.

383

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:

384





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:

385

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.

386

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.

387


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.

388

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.

389

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:

390


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:


391

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.

392

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.

393

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.

394

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:

395

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.

396

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.

397


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.

398

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.

399




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.

400

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).

401

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).

402

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).

403



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.

404

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.

405

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.

406

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.

407

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:

408

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 ().

409

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.

410

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.

411

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.



412

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:

413

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:

http://localhost:8081/ServicioWebNumerosPrimos/Serv

414

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.

Escribir código

Dé doble clic sobre el objeto boton para abrir el editor de código del procedimiento

boton_Click y escriba el siguiente código:

415

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.

416

ÍNDICE

Abs, 69 Abstracción, 198 Acceder a un Servicio Web, 413 AccesDataSource, 355 ActiveMdiChild, 150 AdapterManager, 246 ADO.NET, 230 Aggregate, 279 ALL, 225 ALTER, 224 And, 33 AND, 225 AndAlso, 33 Aplicación para Windows Forms, 15 Aplicación Web ASP.NET, 15 Arco, 163 Asc, 73 AsEnumerable, 314 ASP.NET, 316 ASP.NET AJAX, 13 Average, 279 AVG, 225 BETWEEN, 225 BigMul, 69 BindingSource, 246 BulletedList, 335 catch, 117 CBool, 31 CByte, 31 CChar, 31 CDate, 31 CDbl, 31 CDec, 31 Ceiling, 69 Chars, 72 CheckBox, 99 CheckedListBox, 146 Chr, 73 CInt, 31 Circulo, 163 Clase, 11 Clases, 198 Class, 199 Clear, 140 CLng, 31 Colecciones, 84 columnas, 223 ComboBox, 93 Command, 231 CompareValidator, 350 Concat, 72 Conectarse a SQL Server, 422 Connection, 231 Constantes, 26 Constructores, 199 ControlValidate, 352 Copy, 139 cos, 69

Count, 279 COUNT, 225 Creación de Menús, 130 Creación de una barra de herramientas,

156, 159 CREATE, 224 CREATE DATABASE, 226 CShort, 31 Cuadro de Herramientas, 16, 319 Curva, 163 CustomValidator, 350 Cut, 139 Data Source, 233, 357 DataAdapter, 231 Database, 233, 357 DataGridView, 105 DataMember, 241 DataSet, 230, 355 DataSource, 241, 276 DataTable, 231 DataView, 231, 355 Date, 66 DateTimePicker, 144 Default.aspx, 319 DefaultView, 276 DELETE, 224 Diseñador formulario Windows, 16 Diseñador formularios Web, 319 DLL, 223 DML, 223 Do…Loop While, 51 DrawArc, 163 DrawCurve, 163 DrawEllipse, 163 DrawLine, 163 DrawPie, 163 DrawPolygon, 163 DrawRectangle, 163, 169 DROP, 224 Editor de código, 21 El explorador de soluciones, 17, 319 Elegir base de datos, 235 Elegir proveedor base de datos, 235 Elipse, 163 Encapsulación, 198 ErrorMessage, 352 Espacio de nombres, 11 Estructuras de Control, 37 filas, 223 fill, 233, 357 FillEllipse, 163 FillPie, 163 FillPolygon, 163 FillRectangle, 163 Floor, 69 FolderBrowseDialog, 122 Font - Bold, 355, 356 For, 45, 55

417

From, 278 FROM, 224 FromArgb, 104 Funciones de cadenas de caracteres, 72 Funciones Matemáticas, 69 Function, 61 GetItemChecked, 148 GraphicsPath, 169 GROUP, 224 Group By, 279 HAVING, 224 Height, 175 Herencia, 198, 201 HotSpotMode, 332 If (operador)., 39 IIF., 39 ImageMap, 331 IN, 225 IndexOf, 73 InitialDirectory, 137 Insert, 73 INSERT, 224 Integrated, 10 Integrated Security, 233, 357 Join, 279 KeyCode, 194 KeyDown, 193 KeyPress, 193 KeyUp, 193 Left, 172 Len, 73 Length, 72 Lenguaje de Consulta Estructurado, 223,

225, 229 LIKE, 225 LinkLabel., 91 LINQ, 278 LINQ to DataSet, 278 LINQ to Objects, 278 LINQ to SQL, 278 LINQ to XML, 278 ListBox, 93 ListView, 107 Matrices, 78 Max, 69, 279 MAX, 226 MaximumValue, 352 MDI, 130 Mensaje, 198 Menú principal, 15, 319 menú Ventana, 153 Menús, 130 Método, 198 Mid, 73 min, 69 Min, 280 MIN, 226 MinimumValue, 352 Modificar la cadena de conexión:, 235 Módulos, 59

MonthCalendar, 145 MouseClick, 188 MouseDoubleClick, 188 MouseDown, 188 MouseEnter, 188 MouseHover, 188 MouseLeave, 188 MouseMove, 188 MouseUp, 188 MouseWheel, 188 movenext, 127, 128 MultiView, 342 NamesSpace, 410 Not, 33 NOT, 225 Objetos, 198 OleDataAdapter, 231 OleDbCommand, 231 OleDbConnection, 231 OleDbDataAdapter, 355 Operadores de comparación, 225 Operadores Lógicos, 33 Operadores lógicos S.Q.L, 224 Operadores Relacionales, 32 Or, 33 OR, 225 OracleCommand, 231 OracleConnection, 231 OracleDataAdapter, 231 OracleDbDataAdapter, 355 ORDER, 224 Order By, 279 OrElse, 33 Orientada a objetos, 223 origen de datos, 354 Palabras clave, 36 Paste, 139 Pie, 163 Point, 163 Poligono, 163 Polimorfismo, 198 PostBack, 332 PostBackValue, 332 pow, 69 private, 199 Probar la conexión, 235 Procedimientos, 61 Programación Orientada a Objetos, 198 Propiedad, 198 protected, 199 public, 199 Punto, 163 RadioButton, 99 RadioButtonList, 338 RangeValidator, 350 ReadtoEnd, 138 Recta, 163 Rectangle, 163 Rectangulo, 163 Redo, 139

418

RegularExpressionValidator, 350 Remove, 73 Replace, 73 RequiredFieldValidator, 350 RichTextBox, 115 round, 69 RowFilter, 276 SDI, 130 Select, 278 SELECT, 224, 227 Select – case (Seleccionar caso), 42 SelectedItem, 255, 256 SelectedValue, 276 SelectionBullet, 141 Sentencia If (Si), 37 Sentencia If- Else (Si - Sino), 38 Sentencias básicas S.Q.L, 226 servicio web, 407 sin, 69 SOAP, 407 Sobrecarga, 200 Split, 73 SqlCommand, 231 SqlConnection, 231 SqlDataAdapter, 231 SqlDataSource, 355 SqlDbDataAdapter, 355 sqrt, 69 Str, 31 StreamWriter, 137 String.Copy, 73 StrReverse, 73 Sub, 61 SubString, 73 Sum, 280 SUM, 225 System.Data.SqlClient, 232, 356 System.Drawing, 162

System.Linq, 278 TableAdapter, 246 tan, 69 Timer, 172 Tipos de datos, 26 TocharArray, 73 ToLower, 72 Toma de desiciones, 37 Top, 172 ToUpper, 72 TrackBar, 102 TreeView, 118 Trim, 73 Try-Catch, 117 tuplas, 223 Undo, 139 UPDATE, 224 Val, 31 ValidationExpression, 352 ValidationSummary, 350 ValidationType, 352 ValueMember, 276 ValueToCompare, 352 variable, 25 Ventana de depuración de errores, 19, 320 Ventana de propiedades, 18, 320 View, 342 Visual Basic .NET, 10 Visual Studio .NET, 10 VScrollBar, 102 WebBrowse, 125 Where, 279 WHERE, 224 While, 48 Width, 175 Windows Authentication, 422 XmlDataSource, 355 Xor, 33

419

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

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-81/efectuando-acceso-a-datos.aspx

http://www.es-asp.net/tutoriales-asp-net/tutorial-61-96/enlazando-a-bases-de-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

420

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.

421

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:

422

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:

423

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.

424

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

425

ú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.

426

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.

427

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.

428

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.

429

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:

430

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:

431

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:

432

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.

433

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:

434

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.

435

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:

436

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:

437

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.

438

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.