Aprenda Visual Basic 2012

ren
Aprenda Practicando VIsual

Baslc usando VIsual Studlo
2012
Aprenda Practicando Visual
Basic usando Visual Studio
2012
Felipe Ramírez
Facultad de Contadurfa Pública y Administración,
Universidad Autónoma de Nuevo León, México.
Revisión técnica:
Francisco Salazar
Facultad de Contaduría Pública y Administración,
Universidad Autónoma de Nuevo León, México.
Datos catalográficos
Ramírez, Felipe
Aprenda Practicando Visual Basic usando Visual
Studio 2012
Primera Edición
Alfaomega Grupo Editor, S.A. de C.V., México
ISBN: 978-607-707-717-6
Formato: 17 x 23 cm Páginas: 372
Aprenda Practicando Visual Basic usando Visual Studio 2012

Felipe Ramírez
Derechos reservados ©Aifaomega Grupo Editor, S.A. de C. Y., México.
Primera edición: Al faomega Grupo Editor, México, junio 2013
© 2013 Alfaomega Grupo Editor, S.A. de C.V.

Pitágoras 1139, Col. Del Valle, 03100, México D.F.
Miembro de la Cámara Nacional de la Industria Editorial Mexicana

Registro No. 23 17
Pág. Web: http://www.alfaomega.com.mx

E-mail: atencionalcliente@alfaomega.com.mx
ISBN: 978-607-707-717-6
Derechos reser vados:

Esta obra es propiedad intelectual de su autor y los derechos de publicación en lengua
española han sido legalmente transferidos al editor. Prohíbida su reproducción parcial o total
por cualquier medio sin permiso por escrito del propietario de los derechos del copyright.
Nota importante:
La información contenida en esta obra tiene un fin exclusivamente didáctico y, por lo tanto, no está
previsto su aprovechamiento a nivel profesional o industrial. Las indicaciones técnicas y programas
incluidos, han sido elaborados con gran ctúdado por el autor y reproducidos bajo estrictas normas
de control. ALFAOMEGA GRUPO EDITOR, S.A. de C.V. no será jurídicamente responsable
por: errores u omisiones; daños y perjuicios que se pudieran atribuir al uso de la información
comprendida en este libro, ni por la utilización indebida que pudiera dársele.
Edición autorizada para venta en México y todo el continente americano.
Impreso en México. Printed in Mexico.
Empresas del grupo:

México: Alfaomega Grupo Editor, S.A. de C.V.- Pitágoras 1139, Col. Del Valle, México, D.F. - C.P. 03100.
Tel.: (52-55) 5575-5022 - Fax: (52-55) 5575-2420 / 2490. Sin costo: O1-800-020-4396
E-mail: atcnciona le! iente@al faomega.com.mx
Colombia: Alfaomega Colombiana S.A.- Calle 62 No. 20-46, Barrio San Luis, Bogotá, Colombia,
Tels.: (57-1) 746 O102 / 21 O0415 - E-mail: cliente@alfaomega.com.co
C hile: Alfaomcga Grupo Editor, S.A. - Av. Providencia 1443. Oficina 24, Santiago, Chile
Tel.: (56-2) 2235-4248 Fax: (56-2) 2235-5786 - E-mail: agechilc@alfaomcga.cl
Argentina: Alfaomcga Grupo Editor Argentino, S.A.- Paraguay 1307 P.B. Of. 11 , C.P. 1057, Buenos Aires.
Argentina, - TciJFax: (54-11) 4811-0887 y 4811 7183 - E-mail: ventas@alfaomcgaeditor.com.ar
Contenido
Contenido
Generales
Acerca del autor ............................................................................................................................................ XV
..
Dedicatoria ...................................................................................................................................................... XVll
Contex·to del curso ....................................................................................................................................... .XVlll
Requerimientos del curso ......................................................................................................................... XIX
Descripción de las unidades .................................................................................................................... . XX
Resumen de Unidades ................................................................................................................................. XXI
Cómo utilizar el libro .................................................................................................................................. . XXll
1: La plataforma Microsoft .NET

1.1 Definiendo a ]a p1atafor·ma .N ET ............................................................................................................... 3
1.1.1 ¿Qué es Microsoft .NET? ....................................................................................................................... 3
1.1.2 Historia de versiones de .NET............................................................................................................ 3
1.1.3 Instalaciones de .NET ............................................................................................................................ 4
1.1.4 ¿Cómo funciona .NET? .......................................................................................................................... S
1.1.5 Principales capas de Microsoft. NET Framework ........................................................ ............. 6
1.2 Entendiendo a los lenguajes .N ET ............................................................................................................ 9
1.2.1 ¿Qué es un lenguaje .NET? ................................................................................................................... 9
1.2.3 Capacidad multilenguaje de .NET..................................................................................................... 9
1.3 Determinando la plataforma .N ET requerida ................................................................................... 11
~ Lab.01.01: Exponiendo Microsoft .NET como producto................................................................. 13
~ Lab.01.02: Determinando la plataforma .NET para desarrollo .................................................... 14
Alfaomega V
2: Ambiente de trabajo usando Visual Studio 2012

2.1 Organización del trabajo en Visual Studio ......................................................................................... 19
2.1.1 Soluciones, proyectos, e1ementos ..................................................................................................19
2.1.2 ¿Dónde almacena Visual Studio el trabajo? .............................................................................. 20
2.1.3 Tipos de proyecto disponibles en Visual Studio ..................................................................... 21
2.1.4 Proceso de construcción (Build) .................................................................................................... 22
2.2 Herramientas en Visual Studio ............................................................................................................... 24
2.2.1 Diseñadores ........................................................................................................................................... 25
2.2.2 Ventanas .................................................................................................................................................. 26
2.2.3 Editores ................................................................................................................ .................................... 27
2.3 Un adelanto: Sintaxis en Visual Basic................................................................................................... 28
~ Lab.02.01: Manejando soluciones y proyectos ...................................................................................29
a) Creando una solución en blanco .......................................................................................................29
b) Agregando proyectos a una solución .............................................................................................. 31
e) Trabajando con varios proyectos en una solución ...................................................................... 32
d) Comprobando Auto-Hide..................................................................................................................... 34
e) Agregando y eliminando elementos de proyecto ........................................................................ 34
fJ Guardando el trabaJ·o ............................................................................................................................ 35
~ La·b.02.02: Manejo de Code Editor .......................................................................................................... 35
a) Creando una aplicación de Conso/a ................................................................................................. 35
b) Utilizando herramientas de Code Editor ....................................................................................... 37
e) Depurando aplicaciones ...................................................................................................................... 38
~ Lab.02.03: Creando una solución, un proyecto y un programa ...................................................40
3: Variables, Arreglos y Tipos de datos

3.1 ¡Qué son las Variables de memoria? ..................................................................................................... 43
3.2 Identificadores (Identifiers) .................................................................................................................... 43
3.3 Tipos de dato (Datacypes) ........................................................................................................................ 44
3.3.1 Conversión de datos ............................................................................................................................ 46
3.3.2 Conversión implícita (Casting) ....................................................................................................... 46
3.3.3 Conversión explícita ........................................................................................................................... 46
3.3.4 Conversión por método ..................................................................................................................... 4 7
3.4 Manejo elemental de variables ............................................................................................................... 4 7
•
VI Alfaomega
Contenido
3.4.1 Declaración de variables ................................................................................................................... 47

3.4.2 Constantes .............................................................................................................................................. 49
3.4.3 Literales ................................................................................................................................................... 49
3.4.4 Valores por omisión ............................................................................................................................ SO
3.5 Alcance de las variables (Scope) ............................................................................................................ 50
3.6 Accesibilidad de las variables (Accesibility) ..................................................................................... 51
3. 7 Arreglos ........................................................................................................................................................... 53
3. 7.1 Arreglos unidimensionales .............................................................................................................. 54
3.7.2 Arreglos multidimensionales .......................................................................................................... SS
3.7.3 Arreglos escalonados ......................................................................................................................... 57
3.8 Dando formato con String.Format ........................................................................................................ 58
~ Lab.03.01: Variables, constantes y conversiones.............................................................................. 60
~ Lab.03.02: Comprobación de alcance .................................................................................................... 62
~ Lab.03.03: Arreglos unidimensionales, multidimensionales y escalonados .......................... 66
~ Lab.03.04: Creando programa strong typing con manejo de arreglos ..................................... 71
~ Lab.03.05: Especificando el alcance y la accesibilidad adecuadas............................................. 72
4: Namespaces y librerías
4.1. Espacios de nombres (Namespaces) ................................................................................................... 77
4.1.1 Sistema de nomenclatura para los espacios de nombres .................................................... 78
4.1.2 Uso de espacios de nombres ........................................................................................................... 79
4.1.3 Creación de espacios de nombres ................................................................................................. 80
4.1.4 Estableciendo alias para los espacios de nombres ................................................................. 81
4.1.5 Estableciendo referencias a una librería .................................................................................... 82
~ Lab.04.01: Creación y consumo de una librería (DLL) basada en Namespace ...................... 83
a) Creando una librería DLL ................................................................................................................... 84
b) Estableciendo una referencia a una librería desde Solution Explorer ................................ 85
e) Consumiendo una librería programáticamente .......................................................................... 86
~ Lab.04.02: Tareas de depuración con Visual Studio ........................................................................ 87
a) Estableciendo un punto de interrupción (breakpoínt) ............................................................. 88
b) Ejecución línea por línea (Code Stepping) .................................................................................... 88
e) Modificación de programas en tiempo de ejecución .................................................................. 91
d) Habilitando e inhabilitando puntos de interrupción ................................................................. 91
e) Eliminando los puntos de interrupción (breakpoint) ................................................................ 91
f) Puntos de interrupción condicionales .............................................................................................. 92
••
Alfaomega VIl
~ Lab.04.03: Inspección de código y variables ....................................................................................... 93

a) Locals Window........................................................................................................................................ 94
b) Cal/ Stack Window................................................................................................................................. 95
e) ·watch Window........................................................................................................................................ 95
e) lntelliTrace ................................................................................................................................................. 96
~ Lab.04.04: Creando y depurando librerías .......................................................................................... 97
a) Creando Namespace ............................................................................................................................. 98
b) Creando aplicación que consume Namespace ............................................................................. 99
e) Usando herramientas de depuración de Visual Studio.............................................................. 99
5: Manejo de Operadores
5.1 Operadores aritméticos ........................................................................................................................... 103
5.2 Operadores de asignación ...................................................................................................................... 104
5.2.1 Expresión .............................................................................................................................................. 104
5.2.2 Operadores de asignación incluyente ........................................................................................ 105
5.3 Operadores comparativos ...................................................................................................................... 106
5.3.1 Consideraciones relativas al código ASCII ............................................................................... 107
5.3.2 Option Compare ................................................................................................................................. 108
5.3.3 Operadores l s~ IsNot y Type0f...................................................................................................... l09
5.3.4 Operador Like ..................................................................................................................................... 11 O
5.4 Operadores lógicos .................................................................................................................................... l ll
5.4.1 Operadores lógicos de circuito corto ......................................................................................... 114
5.5 Prioridad entre operadores ................................................................................................................... 115
5.5.1 Uso de paréntesis para otorgar preferencia de ejecución ................................................. 117
~ Lab.OS.01: Utilización general de operadores de Visual Basic ................................................... 117
a) Comentando bloques de código ...................................................................................................... 119
b) Uso de C/ípboard Ríng ........................................................................................................................ 119
e) Selección basada en bloques de código (Block Selection) ...................................................... 120
~ Lab.OS.02: Representando con operadores casos de la vida real. ............................................ 121
6: Estructuras de Decisión y Control

6.1 Estructuras de decisión .......................................................................................................................... 127
...
VIII Alfaomega
Contenido
6.1.1 Estatuto IfThen Else (condicional) ........................................................................................... 127

6.1.2 Select Case ............................................................................................................................................ 129
6.2 Estructuras de control ............................................................................................................................ 130
6.2.1 For Next ................................................................................................................................................ 131
6.2.2 w ·hile ...................................................................................................................................................... 132
6.2.3 Do Loop ................................................................................................................................................. l33
6.3 Estr·ucturas envolventes y anidadas ................................................................................................. 135
6.3.1 Reglas para el anidado de estructuras ..................................................................................... 135
~ Lab.06.01: Uso de estructuras de decisión ....................................................................................... 136
~ Lab.06.02: Uso de For Next ..................................................................................................................... 139
a) Agregando tareas a Task List......................................................................................................... 143
b) Agregando comentarios de tarea a un programa ................................................................... 144
~ Lab.06.03: Identificando errores en estructuras anidadas ........................................................ 145
~ Lab.06.04: Decidiendo el uso de estructuras de decisión y de control... ............................... 146
7: Manejo Estructurado de Excepciones

7.1 Errores versus Excepciones .................................................................................................................. 151
7.2 Manejo estructurado de excepciones ................................................................................................ 151
7.3 Try...Catch... Finally .................................................................................................................................... 152
7.3.1 Bloque Try ............................................................................................................................................ 152
7.3.2 Bloque Catch ........................................................................................................................................ 152
7.3.3 Bloque FinalJy ..................................................................................................................................... 153
7.3.4 Clase System.Exception ................................................................................................................... 153
7.4 Filtrado de excepciones........................................................................................................................... 155
7.4.1 Calificadores de excepción ............................................................................................................. ! SS
7.4.2 Objeto Err ............................................................................................................................................. 155
7.4.3 Tipos de filtrado de excepciones ................................................................................................. 156
7.5 Lanzando nuestras propias excepciones .......................................................................................... 156
~ Lab.07.01: Manejo estructurado de excepciones ............................................................................ 156
a) Manejo preventivo de excepciones usando Error Líst ............................................................. 159
b) Actualizaciones preventivas en cascada ...................................................................................... 161
~ Lab.07.02: Filtrado de excepciones ...................................................................................................... 161
~ Lab.07.03: Lanzamiento de excepciones definidas por el usuario ........................................... 165
~ Lab.07.04: Proporcionando manejo estructurado de excepciones a los programas........ 167
•
Alfaomega IX
SYNAPS PREMIUM
8: Procedimientos y Funciones
8.1 Procedimientos ........................................................................................................................................... 171
8.1.1 ¿Cuándo definir procedimientos y funciones? ....................................................................... 171
8.1.2 Forma de agregar procedimientos a un programa ............................................................... 172
8.1.3 Forma de mandar llamar a ejecución un procedimiento ................................................... 173
8.1.4 Argumentos .......................................................................................................................................... 173
8.1.4.1 Especificación ByVa/ .................................................................................................................. 173
8.1.4.2 Especificación ByRef .................................................................................................................. l7 4
8.1.5 Valores de retorno ............................................................................................................................. 174
8.2 Codificación de procedimientos y funciones .................................................................................. 174
8.2.1 Procedimientos ................................................................................................................................... 174
8.2.2 Funciones .............................................................................................................................................. l75
~ Lab.08.01: Procedimiento que no utiliza argumentos .................................................................. 177
~ Lab.08.02: Procedimiento que declara argumentos pero no retorna valores ..................... 179
~ Lab.08.03: Procedimiento que declara argumentos y retorna valores................................... 182
~ Lab.08.04: Uso de ByVal y ByRef ...........................................................................................................185
~ Lab.08.05: Procedimientos multihilos y procesamiento asíncrono......................................... 187
~ Lab.08.06: Decidiendo el uso de procedimientos y funciones ................................................... 191
9: Programación Orientada a Objetos

9.1 Términos básicos de POO .......................................................................................................................197
9.1.1 Clases y objetos ................................................................................................................................... l97
9.1.2 Campos, propiedades, métodos y eventos ............................................................................... 197
9.1.3 Encapsulamiento, herencia y polimorfismo ............................................................................ 198
9.1.3.1 Encapsulamiento .........................................................................................................................199
9.1.3.2 Herencia ......................................................................................................................................... 199
9.1.3.3 Polimorfismo .................................................................................................................................200
9.2 Elementos esenciales de los objetos .................................................................................................. 200
9.2.1 Identidad ............................................................................................................................................... 200
9.2.2 Estado ..................................................................................................................................................... 201
9.2.3 Comportamiento ................................................................................................................................ 201
9.3 Clases~ Métodos y Propiedades ............................................................................................................ 202
9.3.1 Definición de una clase .................................................................................................................... 202
X Alfa omega
SYNAPS PREMIUM
Contenido
9.3.2 Definición de propiedades ............................................................................................................. 203

9.3.3 Modificadores de Acceso ................................................................................................................ 205
~ Lab.09.01: Creando una clase con propiedades y métodos ........................................................ 206
a) Uso de Code Snippets .......................................................................................................................... 206
b) C/QSS Diagram ••••••••••••••••••••••••••••••oa•••••••••••••u•••••••••u••••••••u••••u•••u•••••••••••••••••••••••••••••••••••••••••••••u•••••••••209
e) Class View ............................................................................................................................................... 212
d) Selector de documentos activos {Active Documents) .............................................................. 212
e) Agregando resumen a los miembros ............................................................................................. 213
fl Consumiendo la clase .......................................................................................................................... 215
~ Lab.09.02: Haciendo un programa class-based ............................................................................... 216
10: Herencia y Polimorfismo de Clases

10.1 Herencia y Polimorfismo ..................................................................................................................... 221
10.1.1 Herencia .............................................................................................................................................. 221
10.1.2 ¿Cuándo se debe utilizar la herencia? ..................................................................................... 221
10.1.3 Overloading, Overriding, y Shadowing ................................................................................... 222
10.1.3.1 Overloaded .................................................................................................................................. 222
10.1.3.2 Overriden ..................................................................................................................................... 222
10.1.3.3 Shadowed .................................................................................................................................... 223
10.1.4 Fo·rmas de herencia ........................................................................................................................ 223
10.1.4.1/nherits (Heredar) .................................................................................................................... 223
10.1.4.2 Notlnheritable (No Heredable) ............................................................................................ 223
10.1.4.3 Mustlnherit (Debe Heredar) ................................................................................................. 224
10.2 Polimorfismo ............................................................................................................................................. 224
10.2.1 Estatutos auxiliares de polimorfismo ..................................................................................... 225
10.2.1.1 NotOverridable (No Remplazable) ..................................................................................... 226
10.2.1.2 Overrida ble (Remplazable) ................................................................................................... 2 26
10.2.1.3 MustOverride (Debe Remplazarse) .................................................................................... 226
10.2.1.4 Overrides (Remplaza) ............................................................................................................. 227
10.2.1.5 Overloads (Sobrecarga/Sustituye) ..................................................................................... 227
10.2.2 My Base y MyClass ........................................................................................................................... 227
~ Lab.lO.Ol: Herencia entre clases ........................................................................................................... 228
~ Lab.10.02: Polimorfismo basado en herencia .................................................................................. 230
a) Clase base ............................................................................................................................................... 232
b) Clase derivada con remplazamiento ............................................................................................. 233
Alfa omega xi
SYNAPS PREMIUM
e) Clase derivada con sustitución .........................................................................................................236

~ Lab.10.03: lteradores ................................................................................................................................. 239
~ Lab.10.04: Implementación de herencia y polimorfismo ............................................................ 243
11: Interfaces de Usuario con Windows Applications

ll.llnterfaz de usuario ................................................................................................................................. 247
11.2 Controles .................................................................................................................................................... 248
11.2.1 Toolbox................................................................................................................................................ 248
11.2.2 Formas de agregar controles a una interfaz ......................................................................... 249
11.2.3 ¿Cómo aprender a usar los Controles? .................................................................................... 249
11.2.3.1 Piense en términos de clases ................................................................................................. 249
11.2.3.2 Piense en su necesidad ............................................................................................................ 249
11.2.3.3 Propósito de la clase ................................................................................................................ 250
11.2.3.4 Conozca los miembros de una clase ................................................................................... 250
11.2.4 Relación de controles..................................................................................................................... 252
11.2.4.1 De estructura ............................................................................................................................. 252
11.2.4.2 Para introducción y especificación de datos ................................................................... 253
11.2.4.3 Para definir layout ................................................................................................................... 255
11.2.4.4 Para desencadenar acciones................................................................................................. 257
11.2.4.5 Para manipulación de datos ................................................................................................. 258
11.3 Desarrollo de interfaces basadas en objetos ................................................................................ 258
11.3.1 Entendiendo el propósito de la interfaz ................................................................................. 258
11.3.2 Determinación de datos involucrados .................................................................................... 259
11.3.4 Determinación de objetos recomendados ............................................................................. 259
11.3.5 Validaciones ...................................................................................................................................... 261
~ Lab.11.01: Uso de ayuda msdn y .NET Framework ........................................................................ 262
a) Ingresando a MSDN ........................................................ .................................................................... 262
b) Buscando información de clases .....................................................................................................263
~ Lab.11.02: Investigando clases básicas ............................................................................................... 266
a) Labe/......................................................................................................................................................... 266
b) TextBox.................................................................................................................................................... 266
e) MaskedTextBox ..................................................................................................................................... 26 7
d) Button ...................................................................................................................................................... 267
~ Lab.11.03: Creando una interfaz con Windows Applications ..................................................... 267
xii Alfa omega

SYNAPS PREMIUM
Contenido
a) Seleccionando los controles adecuados ....................................................................................... 269

b) Agregando objetos a la interfaz ..................................................................................................... 269
e) Estableciendo el orden de tabulación (TabOrder) ................................................................... 270
d) Estableciendo propiedades a los objetos ..................................................................................... 270
e) Programando comportamientos .................................................................................................... 273
~ Lab.11.04: Creando su propia interfaz ................................................................................................ 276
12: Explotación de Datos usando ADO.NET

12.1 Modelo de objetos de ADO.NET .......................................................................................................279
12.1.1 Data Provider Objects ................................................................................................................. 279
12.1.2 DataSet Objects ............................................................................................................... ............... 281
12.2 Enfoques de enlace a datos ............................................................................................................... 283
12.2.1 Bases d.e datos conectadas ........................................................................................................ 283
12.2.2 Bases de datos desconectadas ................................................................................................. 285
12.3 Espacios de nombres relacionados con ADO.NET ................................................................... 286
12.4 Conexiones a bases de datos específicas ..................................................................................... 287
12.4.1 Conexión basada en Access ....................................................................................................... 287
12.4.2 Conexión basada en SQL Server 7.0 o superior ................................................................. 288
12.4.3 Conexión basada en Oracle ....................................................................................................... 288
12.5 Enlazado de datos (Data Binding) .................................................................................................. 289
12.5.1 Enlazado simple............................................................................................................................. 289
12.5.2 Enlazado complejo ....................................................................................................................... 289
~ Demo.12.01: La base de datos Pubs ................................................................................................... 290
~ Lab.12.01: Conexión a bases de datos con Visual Studio ........................................................... 292
a) Información preliminar de la base de datos ............................................................................. 292
b) Creando una conexión en Visual Studio ..................................................................................... 292
e) Creando un DataSet para consumo de datos ............................................................................ 293
d) Definiendo BindingSource e interfaz de datos con TableAdapter .................................... 295
e) Enlazado complejo con BindingSource y BindingNavigator............................................... 296
f) Enlazado simple con TextBox ......................................................................................................... 297
~ Lab.12.02: Conexión a bases de datos por programa .................................................................. 298
a) Habilitando el acceso a los archivos de configuración ......................................................... 299
b) Obteniendo información de App.config ...................................................................................... 300
e) Conectando a la base de datos de forma programática ....................................................... 300
d) Códlgo de conexión simplificado................................................................................................... 301
~ Lab.12.03 Listas desplegables dependientes, en modo desconectado ................................. 302
~ Lab.12.04 Visor de registros .................................................................................................................. 306
Alfa omega xiii

SYNAPS PREMIUM
13: Multicapa con Visual Basic, Windows Applications y SQ_l Server

13.1 Modelo de desarrollo Multicapa ..................................................................................................... 309
13.1.1 Capa de presentación (Presentation Tier) ......................................................................... 309
13.1.2 Capa de procesamiento (Processing Tier) ......................................................................... 310
13.1.3 Capa de datos (Data Tier) ......................................................................................................... 311
13.2 Implementación de Multicapa con Windows Applications y SQL Server ...................... 311
13.2.1 Secuencia de implementación ................................................................................................. 311
13.2.2 Conocimientos requeridos ....................................................................................................... 312
13.3 Objeto Command ........................................................ .......................................................................... 313
13.3.1 Tipos de comandos ...................................................................................................................... 314
13.3.2 Tipos de ejecución de los comandos ..................................................................................... 315
~ Lab.13.01: Desarrollando la capa de datos ..................................................................................... 315
a) Conocimiento de la base ............................................................................................................... .. 315
b) Conocimiento de la tabla a manipular ...................................................................................... 316
e) Creando stored procedures en SQL Server usando Server Explorer ................................ 317
d) Probando stored procedures desde Visual Studio .................................................................. 319
e) Realizando consultas desde Visual Studio ................................................................................ 323
~ Lab.13.02: Desarrollando la capa de procesamiento .................................................................. 325
a) Creación de una clase ...................................................................................................................... 325
b) Agregando propiedades usando Code Snippets ...................................................................... 326
e) Agregando métodos que usan Command y DataReader...................................................... 329
d) Agregando métodos que usan Command con ExecuteScalar ............................................ 331
~ Lab.13.03 Desarrollando la capa de presentación ....................................................................... 332
a) Agregando proyectos existentes a una solución ..................................................................... 333
b) Agregando imágenes y barras de status ................................................................................... 334
e) Referenciando la clase de capa de procesamiento ................................................................. 336
d) Instanciando la clase de capa de procesamiento ................................................................... 337
e) Recuperando la cadena de conexión de App.config ............................................................... 338
f) Buscando información en la base de datos ............................................................................... 339
g) Agregando y modificando información en la base de datos ............................................... 340
h) Eliminando información en la base de datos .......................................................................... 341
~ Lab.13.04 Realizando su propia aplicación .................................................................................... 342
xiv Alfaomega
SYNAPS PREMIUM
Acerca del autor

El Dr. Felipe Ramírez es Licenciado en Informática Administrativa por
la Facultad de Contaduría Pública y Administración, en la Universidad
Autónoma de Nuevo León (FACPyA 1 UANL, México), especializándo-
se en bases de datos y lenguajes de programación; también es Licen-
ciado en Derecho por la Facultad de Derecho y Criminología (FACDyC
1 UANL), especializándose en contratos de tercerización de servicios
de TI y delitos informáticos. Cuenta con una Maestría en Informática y
además obtuvo el grado de Doctor en Filosofía con especialidad en
Administración (FACPyA 1 UANL), siendo distinguido con mención honorífica Magna Cum
Laude.
Es un experto en transferencia de conocimientos en materia tecnológica y de procesos.
Es instructor certificado de ITIL, catedrático a nivel licenciatura y postgrado en la Facultad
de Contaduría y Administración (FAPCyA, UANL). Es Director de contenidos de Apren-
da.mx, en donde desarrolla conocimiento para su consumo en instituciones educativas y
organizaciones dedicadas a la capacitación profesional en el ramo de las tecnologías de la
información, la gestión de servicios y procesos, así como administración de proyectos.
Conferencista internacional, tiene publicados más de una decena de libros relacionados
con bases de datos y programación de aplicaciones en plataformas de Microsoft. Además,
participó como co-autor para el libro Introducción a los modelos de análisis multivariante.
Son de su autoría el Modelo de Árbol de Valores Ponderados (AVP), el Modelo de Gestión de
Servicios Internos (MGSI), así como el modelo de Alto Rendimiento Positivo (ARP), utilizado
en las organizaciones para fomentar la productividad.
Alfa omega XV
SYNAPS PREMIUM
1
Generales
Dedicatoria
Este libro va dedicado a Don Gilberto, mi padre, a quien quiero enormemente porque
ha sabido estar con las palabras adecuadas en los momentos de más necesidad.
Me enseñó que en la vida va a pasar lo que tiene que pasar, y que un hombre, más allá
de arropar en su conciencia la certeza de haber actuado siempre correctamente, al menos
debe tener la claridad y la obstinación en sus decisiones, en la inteligencia de que bastante
pronto llegarán las consecuencias de sus actos y palabras.
Alfaomega xvii
SYNAPS PREMIUM
Contexto del curso

Este libro contiene temas del curso Fundamentos de.NET Framework y Vi-
sual Studio, y del curso Programadón en Microsoft Visual Basic, de Apren-
da Practicando. Es básico j intermedio, pues cubre desde los aspectos genera-
les de la plataforma, los elementos básicos del lenguaje y la programación
orientada a objetos, y culmina con el desarrollo de aplicaciones multicapa
usando clases en Visual Basic y procedimientos almacenados en SQL Server.
Cubrir los temas del presente libro contribuye a la preparación de la certifica-
ción APCP: Microsoft .NET Developer, con la cual es posible acreditar los co-
nocimientos necesarios para ser un desarrollador en .NET de alta productivi-
dad. Aprenda garantiza que las personas certificadas como APCP: Microsoft
.NET Developer consiguen trabajo como desarrolladores en el corto plazo.
APCP: Microsoft .NET Developer
Fundamentos de .NET Framework y Visual Studio
Desarrollo de aplicaciones con acceso a datos usando

ADO.NET
...
XVIII Alfaomega
SYNAPS PREMIUM
Generales
Requerimientos del curso

Para aprovechar de la mejor manera el curso, es necesario tener instalado el
siguiente software:
1. Indispensables:
a. Sistema Operativo Microsoft Windows 7 o de mayor presta-
ciones, en ediciones profesionales. El lenguaje es indistinto.
b. Microsoft Visual Studio 2012, en versiones Professional o Ex-
press, en idioma inglés.
c. Microsoft SQL Server 2008 o superior, en idioma inglés.
d. Internet Explorer 9, o superior.
2. Deseables, más no necesarios.
a. Mozilla Firefox 4.0, Opera o Chrome.
El libro se acompaña con un CD de compañía, mismo que puede descargarse a

través de los vínculos que están disponibles en:
http://libroweb.alfaomeg a.com.mx
El libro no acompaña la media física. Si desea tener un disco físico, puede

. - - - - - - - - _ _ __
quemarlo a artir de la descarg,.=a_,_
Este CD de compañía contiene lo siguiente:

a) Archivos complementarios utilizados en los ejercicios.
b) Videos explicativos.
e) Código fuente de algunos ejercicios.
Para docentes, contamos con recursos adicionales, como presentaciones en

Power Point, capítulos y ejercicios adicionales.
Alfa omega xix

SYNAPS PREMIUM
Descripción de las unidades

El libro se divide en Unidades de Aprendizaje, mismas que están prepara-
das para el aprendizaje de competencias relacionadas con Visual Basic.
Cada Unidad de Aprendizaje contiene lo siguiente:
l. Representación gráfica. Es un esquema que describe de manera bre-
ve pero contundente, qué es lo que se espera aprender con la unidad.
Siempre se conocerá: a) el objetivo general de aprendizaje de la uni-
dad; b) las competencias que la persona va a adquirir si lee a concien-
cia la teoría, y si desarrolla personalmente los ejercicios; e) la eviden-
cia de aprendizaje, a través de la cual se pueda comprobar que el estu-
dio se llevó a cabo; y d) pistas de evaluación, que nos lleven a concluir
que no sólo se realizaron esfuerzos de aprendizaje, sino que se hicie-
ron bien.
,
2. lndice esquemático. Es un índice por unidad, que muestra de forma
numerada Jos temas a desarrollar, indicando de manera precisa los la-
boratorios y demostraciones que es necesario cubrir para el aprendi-
zaje. Este índice permite conocer a detalle los temas a cubrir, y ofrecen
una secuencia lógica ideal para el aprendizaje de los temas.
XX Alfaomega
SYNAPS PREMIUM
Generales
3. Contenido teórico. Es el marco teórico de conocimientos que nos

permitirán enfrentar la práctica con conocimiento de causa. Se procu-
raron explicaciones claras pero no extensas: la idea es que en pocas
páginas pueda cubrirse la teoría esencial, y que sean las prácticas las
que nos lleven a entender los temas de forma definitiva.
4. Laboratorios. Son prácticas detalladas que demuestran el conoci-
miento teórico cubierto.
5. Videos. En el transcurso del curso, aprenderá a amar este símbolo:
DI WBVBVS2012.XX.YY- Descripción.wmv
Indica que hay en el CD de compañía un video clip que muestra la eje-

cución del ejercicio, para que usted pueda reproducir los pasos. Cree-
mos que ver cómo se hacen las cosas es más efectivo que leer una ex-
plicación, por más detallada que sea.
6. Examen de la Unidad. Es una evaluación de reacción que permite
comprobar los conocimientos adquiridos.
Resumen de Unidades
Las unidades de este libro hacen que tenga un grado de complejidad que va
de un grado básico a uno avanzado:
1 Parte Nivel / habilidades requeridas Unidades correspondientes a la parte

Fundamentos de Básico 1. La plataforma Microsoft .NET.
la plataforma • Conocimiento de 2. Ambiente de trabajo usando Visual
ambiente Windows. Studio 2012.
Fundamentos del Básico 3. Variables, Arreglos y Tipos de
lenguaje • Fundamentos de datos.
.'
programacwn. 4. Namespaces y Librerías.
5. Manejo de Operadores.
6. Estructuras de Decisión y Control.
7. Manejo Estructurado de
Excepciones.
8. Procedimientos y Funciones.
Alfa omega xxi

SYNAPS PREMIUM
Programación Intermedio 9. Programación Orientada a Objetos.

Orientada a • Fundamentos de 10. Herencia y Polimorfismo de Clases.
Objetos .'
programacwn.
• Fundamentos de
programacwn.'
orientada a objetos
Desarrollo de Avanzado 11. Interfaces de usuario con Windows
aplicaciones con l. Programación Applications.
acceso a datos orientada a objetos. 12. Explotación de datos usando
2. Desarrollo de software. ADO.NET.
13. Multicapa con Visual Basic,
Windows Applications y SQL
Server.
Cómo utilizar el libro

La estrategia que sugerimos para mejorar el aprendizaje es la siguiente:
1. Ambientación. Asegúrese que tiene instalado todo el software que
requiere para poder practicar los ejercicios.
2. Defina el alcance de la unidad. Lea la representación gráfica y di-
mensione el alcance del aprendizaje que se puede lograr con el estudio
de la unidad.
3. Lea el marco teórico. Estudie Jos conceptos descritos en el marco
teórico, al grado de haber comprendido la totalidad de los conceptos;
no es necesario que se comprenda aquellos detalles prácticos, pues se
comprenderán al hacer los laboratorios.
4. Desarrolle los laboratorios. Realice los laboratorios, varias veces. La
primera vez, aplicando toda la concentración posible, cuidando cada
detalle, viendo todos los video-clips, aunque sean demasiado obvios.
No se conforme con hacer los ejercicios una sola vez: repítalos hasta
que sea más rápido y efectivo. El nirvana es cuando hace los ejercicios
sin ver el libro, de manera correcta y suficiente.
S. Examínese. Antes de pasar a la siguiente unidad, verifique que es ca-
paz de realizar los laboratorios de una manera rápida y efectiva, sin
tener que seguir las instrucciones detalladas, y sin necesidad de revi-
sar los videos de apoyo. Fíjese una meta de eficiencia, y mejórese a Us-
ted mismo.
..
XXII Alfaomega
SYNAPS PREMIUM
Generales
a. Sugerimos que los laboratorios con instrucciones detalladas los

haga tres veces: a) Primero, leyendo detenidamente el ejercicio
y prestando toda la atención posible a lo que se está haciendo y
lo que se está explicando. Tome el tiempo que le toma realizar
el ejercicio. b) Segundo, intente el ejercicio a una mayor veloci-
dad, aunque apoyándose en las instrucciones y los videos, en
caso de ser necesario. Tome el tiempo que le toma realizar el
ejercicio. e) Tercero, intente realizar el ejercicio sin apoyo al-
guno. Tome tiempo.
b. Al final, compare sus tiempos, y mejórelos.
c. Generalmente, habrá un ejercicio acumulativo, y con instruc-
ciones no tan detalladas. Este ejercicio será el máximo reto,
pues usted tendrá que utilizar los conocimientos adquiridos,
dado que se hace énfasis en lo que se quiere, pero no se detalla
tanto el cómo. Cuando pueda resolver este ejercicio, podrá
avanzar sin problemas a la siguiente unidad.
•••
Alfa omega XXIII
SYNAPS PREMIUM
Unidad de aprendizaje 1
La Plataforma Microsoft .NET
Competencias:
l. Saber qué es Microsoft .NET y cómo ha
ido evolucionando con el paso del
tiem po.
2. Conoce r la forma en que .NET
interpreta, compila y ejecuta los
programas.
3. Conocer las pa rticularidades de la
biblioteca de clases de .NET y la form a
en que se organiza.
4. Conocer en qué consiste la capacidad
mult ilenguaje de la plataforma .NET.
1. Exposición que
convenza a un staff
técnico de cambiar, de Evidencia de
otro ambiente de aprendizaje:
desarrollo, a 1. Capacidad de explicar a
Microsoft .NET. Microsoft .NET como
2. Analizar un caso producto y como sistema,
práctico en donde se haciendo hincapié en sus
requieran diferentes elementos fundamentales y
aplicaciones y se en el proceso que lleva del
tengan diversos código fuente al código
ambientes, y hacer un ejecuta ble.
diagnóstico en donde 2. Capacidad de evaluación de
se sugiera los una situación del mundo rea l,
productos .NET a y sugerir una adecuada
instalar y adquirir. ambientación en productos
Microsoft.NET
SYNAPS PREMIUM
1: La Plataforma Microsoft .NET

1.1 Definiendo a la plataforma .NET ............................................................................................................... 3
1.1.1 ¿Qué es Microsoft .NET? .......................................................................................................................3
1.1.2 Historia de versiones de .N ET ............................................................................................................3
1.1.3 Instalaciones de .NET ............................................................................................................................4
1.1.4 ¿Cómo funciona .NET? .......................................................................................................................... 5
1.1.5 Principales capas de Microsoft. NET Framework ..................................................................... 6
1.2 Entendiendo a los lenguajes .NET ............................................................................................................ 9
1.2.1 ¿Qué es un lenguaje .N ET? ................................................................................................................... 9
1.2.3 Capacidad multilenguaje de .NET ..................................................................................................... 9
1.3 Determinando la plataforma .NET requerida ................................................................................... 11
~ Lab.01.01: Exponiendo Microsoft .NET como producto . ................................................................ 13
~ Lab.01.02: Determinando la plataforma .NET para desarrollo.................................................... 14
2 Alfa omega
SYNAPS PREMIUM
Unidad 1: La Plataforma Microsoft .NET
1.1 Definiendo a la plataforma .NET
1.1.1 ¿Qué es Microsoft .NET?
La plataforma Microsoft .NET es la alternativa que Microsoft propone al mercado para el

desarrollo, liberación y ejecución de aplicaciones.
La plataforma se compone de dos grandes componentes: a) Microsoft .NET Framework, que
es la plataforma en sí, y que generalmente se incluye ya en forma de componente de los sis-
temas operativos de Windows de última generación; y b) Microsoft Visual Studio, que es el
entorno integrado de desarrollo que permite automatizar el proceso de desarrollo de apli-
caciones con Microsoft .NET Framework A partir de este momento, nos referimos a la pla-
taforma (Microsoft .NET Framework + Microsoft Visual Stu dio) como .NET.
1.1.2 Historia de versiones de .NET
Cada vez que Microsoft libera o actualiza un sistema operativo, éste aporta nuevas capaci-
dades de funcionamiento y desempeño. Con cada una de estas liberaciones o actualizacio-
nes, Microsoft .NET Framework se actualiza también, a fin de poder brindar mecanismos
que permitan aprovechar las mejoras que fue ron hechas al sistema operativo; recordemos
que Microsoft .NET Framework generalmente se preinstala como un componente del siste-
ma operativo. Obviamente, al haber una nueva versión de Microsoft .NET Framework, se
requiere también una versión nueva de Microsoft Visual Studio que permita aprovechar las
nuevas características del Framework En resumen, un nuevo sistema operativo nos lleva a
un nuevo Framework, que a su vez nos lleva a un nuevo Visual Studio.
Esta es la historia:
13 Febrero 2002 Visual Studio .NET Tablet Media Center Editions

1.1 24 Abril 2003 Visual Studio .NET Windows Server 2003
2003
2.0 7 Noviembre 2005 Visual Studio 2005 Windows Server 2003 R2
3.0 6 Noviembre 2006 Visual Studio 2005 Windows
.----------------1
Windows Server 2008
3.5 19 Noviembre 2007 Visual Studio 2008 Windows 7 Windows Server 2008 R2
4.0 12 Abril 2010 Visual Studio 2010 Windows 7 Windows Server 2008 R2
._4..;.:..5;:;.___ ____;1:..;:5...;.: 2o12 Visual Studio 2012 Windows 8, Windows Server 2012
Nótese cómo en algunas ocasiones el cambio de un producto no implicó el cambio de otro:

Microsoft Visual Studio 2005, fue útil para las versiones 2.0 y 3.0 de Microsoft .NET Frame-
Alfaomega 3
SYNAPS PREMIUM
work; el otro caso es que las versiones 3.5 y 4.0 de Microsoft .NET Framework fueron dis-
tribuidas para los mismos sistemas operativos (Windows 7, Windows Server 2008 R2).
¿Para qué nos puede servir conocer estos datos históricos? Para dos cosas: a) Estar cons-
cientes que un cambio en sistema operativo puede conducir a un cambio en nuestro Micro-
soft .NET Framework y nuestro Microsoft Visual Studio, y que podemos experimentar pro-
blemas de compatibilidad, y b) Estar conscientes de que las nuevas versiones permiten
aprovechar nuevas características del entorno operativo; en ese sentido, actualizar las ver-
siones de Microsoft .NET Framework y Microsoft Visual Studio tiene sentido si las aplica-
ciones creadas funcionarán en un entorno operativo capaz de aprovechar las nuevas capa-
cidades.
Las versiones de .NET son acumulativas, es decir, cada nueva versión tiene la funcionalidad
de la anterior, más nuevas características adicionales.
1.1.3 Instalaciones de .NET
Conocer las versiones de .NET nos lleva a preguntarnos, ¿qué necesitamos instalar, para
tener un ambiente adecuado a nuestras necesidades?
Primeramente debe preguntarse si realizará labores de desarrollo o no: En caso de que en
la empresa se desarrollen aplicaciones, es altamente conveniente que cada desarrollador
posea una instalación de Microsoft Visual Studio; es importante mencionar que Microsoft
Visual Studio tiene costo.
En caso de que no realice labores de desarrollo, no requiere de Microsoft Visual Studio. Tan
solo requiere tener instalado Microsoft .NET Framework en el equipo que ejecute los pro-
gramas .NET. Generalmente estará preinstalado como parte del sistema operativo, aunque
deberá asegurarse de que tiene la versión correcta de Microsoft .NET Framework, en fun-
ción a la versión utilizada para desarrollar las aplicaciones que ha de utilizar.
Por ejemplo, si tiene una máquina que tiene preinstalado Microsoft .NET Framework 3.0,
pero le instalan una aplicación que fue desarrollada con la versión 4.0, deberá instalar esta
última. No hay problema por tener las dos versiones instaladas en su equipo: .NET sabrá
diferenciar las versiones, y subordinará las aplicaciones a la versión que les corresponda.
La buena noticia es que Microsoft .NET Framework no tiene costo.
En el caso de aplicaciones Windows, cada cliente deberá tener instalado Microsoft .NET
Framework, a fin de que los programas .NET puedan ser ejecutados. Tome en cuenta que
puede haber servidores de procesamiento o de datos que, aún y cuando no sean operados
directamente, brindan servicio a ciertas aplicaciones, y por tanto requieren ejecutar módu-
los o clases.
En el caso de aplicaciones Web, Microsoft .NET Framework sólo debe estar instalado en el
servidor Web: los clientes no necesitan instalar nada.
4 Alfa omega
SYNAPS PREMIUM
Es importante que sepa que, en el caso de Jos smartphones, se ofrecen versiones compact de
Microsoft .NET Framework para cada versión, a fin de que puedan invocar aplicaciones y
ejecutarlas desde dichos dispositivos. Tal vez no sobra decir que las versiones compact son
considerablemente más limitadas, por lo que deberá investigarse cuál es la funcionalidad
que soportan.
1.1.4 ¿Cómo funciona .NET?
Para entender bien Jos componentes de Microsoft .NET Framework es altamente recomen-
dable conocer, de una manera simplificada, cómo es que trabaja la plataforma.
Partamos del supuesto que todos Jos esfuerzos de desarrollo tienen como objetivo desarro-
llar programas de código fuente que, después de pasar por un proceso, terminan siendo
código máquina que el sistema operativo podrá interpretar como órdenes. Siendo así, con
.NET tendríamos lo siguiente:
Figura 01.01
Proceso en .NET,
del código a los x.vb~ Vbc.exe
ejecutables.
119119
1 191991
x.cs Csc.exe
1. Utilizando Microsoft Visual Studio, generamos gráficamente programas de código fuen-

te, como podrían ser programas de extensión . vb para el caso de programas en Visual
Basic, o de extensión . es, para el caso de C#. Obvio, es posible que se trate de otro len-
guaje .NET.
2. Utilizando programas compiladores, en este caso vbe . exe para Visual Basic, y
ese . exe, para C#, se genera un código intermedio de extensión . exe. Nótese que es
irrelevante en qué lenguaje estaba codificado el programa fuente: la función de los
compiladores es esa precisamente, traducir el código fuente de cualquier lenguaje a un
código estandarizado equivalente. Obviamente, cada lenguaje deberá tener su propio
compilador.
3. Este código intermedio, al ser llamado a ejecución, es tomado por Microsoft .NET Fra-
mework, que se encarga de generar para el programa su código máquina equivalente,
mismo que será interpretado por el sistema operativo, traduciéndolo en acciones.
Alfaomega 5
SYNAPS PREMIUM
Una vez que conocemos a grandes rasgos el funcionamiento de la plataforma, no nos serán
extraños sus componentes.
1.1.5 Principales capas de Microsoft . NET Framework
Entender las capas internas de Microsoft .NET Framework puede intimidar un poco, dado
que hay muchos conceptos por entender, pero nada que no se pueda entender si se analiza
con la mente abierta.
Cuando vea una referencia como la que sigue, significa que es altamente recomendable que
revise el video que se encuentra en su CD de compañía, para la mejor comprensión de los
temas.
,.....
DI WBVBVS2012.01.01 - La composición de la plataforma .NET.wmv
Las principales capas de Microsoft .NET Framework son las siguientes:
Figura 01.02
Capas de la
plataforma .NET.
ASP.NET Windows ADO.NET

Services Application Services Services
6 Alfa omega
SYNAPS PREMIUM
l. Capa de lenguajes. La capa de lenguajes es la capa compuesta por el CLS y todos

los lenguajes de programación que son compatibles con CLS.
a. CLS (Common Language Specification) es un convencionalismo de elementos que
deben cumplir todos los lenguajes que deseen ser considerados lenguajes .NET.
b. Actualmente, Microsoft ha liberado varios lenguajes y sus correspondientes compi-
ladores: Visual Basic, C#, C++, J#, JScript, etcétera. Por supuesto, todos estos lengua-
jes cumplen con CLS.
c. Otros fabricantes pueden implementar sus propios lenguajes .NET, siempre y cuan-
do respeten los lineamientos de CLS y proporcionen los compiladores correspon-
dientes.
2. . NET Framework {Infraestructura y servicios). Se conoce como .NET Frame-

work a la capa compuesta por el núcleo de servicios y recursos de la plataforma .NET.
Se compone de los siguientes elementos:
a. Capa de servicios {Services). La capa de servicios incluye de aquellos ser-
vicios que permiten la intercomunicación entre los programas desarrollados en
un lenguaje .NET y el resto de los elementos de Microsoft .NET Framework. Se
tienen tres servicios principales:
1. ASP.NET Application Services, apoyan a las aplicaciones de interfaz
gráfica basados en la Web, servicios basados en Internet, y aplicacio-
nes de cómputo móvil, de tal manera que puedan utilizar Microsoft
.NET Framework y el motor de ejecución Web del sistema operativo,
que en el caso de sistemas operativos Windows se llama Internet In-
formation Server (liS).
ii. Windows Application Services, apoyan a las aplicaciones de interfaz
gráfica estilo Windows y a las aplicaciones de consola, en su diálogo
con Microsoft .NET Framework y las API de sistema operativo Win-
dows.
iii. ADO.NET Services, apoyan la interacción de la plataforma Microsoft
.NET Framework con los manejadores de bases de datos (Microsoft
SQL server, Oracle, MySQL, etcétera), incluyendo gestión de paquetes
de datos, transformaciones a XML, protocolos de comunicación y
gestión de puertos.
b. Biblioteca de clases base {BCL 1 Base Class Llbrary). La biblioteca
de clases base (BCLjBase C/ass Library) es una extensa biblioteca de clases que
ponen a disposición de los lenguajes de programación un conjunto de funciones
que podrán ser utilizadas como funciones nativas del lenguaje.
Alfaomega 7
SYNAPS PREMIUM
i. Es importante mencionar que la gran cantidad de clases están orga-

nizadas jerárquicamente en base a su funcionalidad, de tal manera
que sea fácil ubicarlas y utilizarlas.
ii. La jerarquía se representa a través de nombres significativos, llama-
dos espacios de nombres (namespace); un ejemplo, el namespace
System . Data . SQLClient, permitirá llegar a todas las clases que
nos sirven para interactuar con datos de SQL Server.
iii. Las clases no están ligadas a los lenguajes, es decir, las mismas clases
que se pueden utilizar en un programa Visual Basic, pueden ser
usadas en un programa C#.
c. Motor común de ejecución (CLR 1 Common La nguage Runtime). El
motor común de ejecución (CLR/ Common Language Runtime) es la plataforma co-
mún de ejecución de los programas desarrollados en cualquier lenguaje .NET.
.
J. CLR agrupa compiladores de línea de comando que permiten la crea-
ción de código intermedio, libre de ambigüedades, conocido como
ensamblado (assembly).
..
11. A la especificación que indica de forma precisa cómo debe estar
compuesto un ensamblado, se le llama CLI (Common Language Infra-
estructure).
...
lll. Contiene además los compiladores j/T Uust in time compilers), que se
encargan de generar código máquina a partir de los ensamblados,
cuando estos son llamados a ejecución.
iv. CLR se encarga de la gestión de errores, uso de recursos y diálogo
con el sistema operativo en tiempo de ejecución.
V. A todo lo que requiere de la intervención de CLR para funcionar se le
da el calificativo de administrado (managed).
3. Soporte operativo. La capa de soporte operativo es la capa compuesta por las he-
rramientas que se integran al sistema operativo al momento de instalar Microsoft
.NET Framework en un equipo, con lo cual el sistema operativo se ve modificado para
ser capaz de interpretar y ejecutar aplicaciones .NET de forma nativa. Esta capa per-
mite que el sistema operativo detecte cuando un programa de extensión .exe es en
realidad código intermedio, cediéndole el control a Microsoft .NET Framework para
que realice la compilación en tiempo de ejecución, y genere código máquina, y pro-
duzca realmente resultados.
8 Alfa omega
SYNAPS PREMIUM
1.2 Entendiendo a los lenguajes .NET
1.2.1 ¿Qué es un lenguaje .NET?
La definición de un Lenguaje .NET es simple: todo aquel lenguaje de programación y sus

herramientas de análisis y compilación, que cumplen con la especificación CLS.
Los lenguajes .NET requieren someterse a un proceso de compilación, y el resultado de la
compilación debe ser un programa intermedio, que llamamos ensamblado (assembly); los
ensamblados sólo pueden ejecutarse en colaboración con el motor de ejecución de .NET
(CLR), lo cual obliga a que, si se desea ejecutar un ensamblado en un equipo, éste debe tener
instalado Microsoft .NET Framework.
Todo programa que se ejecuta en colaboración con el motor común de ejecución (CLR) se le
da el calificativo de administrado (managed), por lo cual, a los lenguajes de .NET también se
les conoce como lenguajes administrados (managed languages). En esencia, son adminis-
trados aquellos elementos que son ejecutados por el motor común de ejecución, en lugar de
ser ejecutados directamente por el sistema operativo.
Al ser administrados, los elementos disponen de servicios propios del motor común de eje-
cución, como lo son la recolección de basura (garbage col/ection), verificación de tipos en
tiempo de ejecución (runtime type checking), administración de la memoria (memory mana-
gement), y soporte de seguridad (security support), entre otros servicios.
_, WBVBVS2012.01.02- Tiempos de compilación del CLR.wmv
1.2.3 Capacidad multilenguaje de .NET
A continuación ilustramos el típico programa Hola mundo, que generalmente se utiliza para
mostrar la estructura básica de un programa en un lenguaje determinado, mostrando un
mensaje cualquiera.
El programa Hola Mundo en C# sería de la siguiente manera (HolaMundo. es):
1 using System;
2 class HolaMundo
3 {
4 static void Main()
5 {
6 Console.WriteLine{"Hola Mundo");
8 }
9 }
Alfaomega 9
SYNAPS PREMIUM
Así sería el mismo programa en Visual Basic (HolaMundo . vb):
1 Imports System
2 CliiSS HoliiMundo
3 Sub Mili n()
4 Console.Writeline("Hola Mundo")
5 End Sub
6
End CliiSS
Vea cómo el código es sorprendentemente parecido. Todos los lenguajes en .NET compar-
ten el mismo origen (CLS), y difieren solamente en la forma estructural de la codificación,
determinada por el estilo del lenguaje.
Por otra parte, ninguno de los lenguajes tiene uso exclusivo de la librería de objetos de
.NET: está disponible para todos. Este hecho es bastante significativo ya que todos los
lenguajes pueden hacer uso de las mismas clases, y por tanto, podrán servir para lo mismo.
Anteriormente, los programadores de C++ podían presumir de conocer un lenguaje que les
permitía manejar los recursos de la computadora de una manera más profunda, y subesti-
maban a los programadores de Visual Basic por utilizar una herramienta "tan limitada"; si
un programador de Visual Basic 6.0 deseaba desarrollar programas con la misma funciona-
lidad que C++, era necesario que aprendiera el manejo del API (Application Programming
Interface) de Windows, y dicha opción podía ser bastante compleja. Ahora eso ha cambia-
do, ya que con todos los lenguajes en .NET se podrán hacer las mismas cosas.
Uno de los mayores beneficios que se obtiene al disponer de una misma biblioteca de clases
para su uso en varios lenguajes, es que el programador aprende un solo lenguaje, y al mis-
mo tiempo aprenderá todos los demás, en términos generales.
Compare el código HolaMundo.cs (C#) y HolaMundo.vb (Visual Basic); estando codifica-
dos en diferentes lenguajes, ambos utilizan un mismo espacio de nombres System, una
misma clase Console, y un mismo type (método de la clase), llamado Writeline(). La
forma de invocar a las clases y los types en todos los lenguajes .NET es uniforme, obede-
ciendo una sintaxis de separación punteada ( dotted), que diferencia espacios de nombres,
clases y types (estos últimos, opcionales en algunos casos):
Namespace.Class[ .Type]
Además, todos los lenguajes de desarrollo son soportados por un mismo entorno integrado
de desarrollo: Microsoft Visual Studio, con el cual podremos estar codificando al mismo
tiempo múltiples proyectos en múltiples lenguajes.
10 Alfa omega
SYNAPS PREMIUM
Realizar esto antes de .NET era impensable. El desarrollador debía aprender las palabras
reservadas de cada uno de los lenguajes que aprendiera. Cada lenguaje poseía su propia
biblioteca de clases (C/ass Foundation), tenía sus propias jerarquías y su propia sintaxis de
invocación. La experiencia que ganaba con un lenguaje no le servía de mucho al intentar
desarrollar en otro. Si a eso le sumamos que cada lenguaje tenía su propia herramienta de
desarrollo, llegaríamos a la conclusión de que el programador consumía todo su tiempo en
aprender las herramientas de desarrollo y las diferencias en Jos lenguajes, quedándote muy
poco tiempo para ocuparse de los problemas reales de programación, como sería la lógica
de negocios.
La plataforma .NET reduce la curva de aprendizaje y favorece los equipos de desarrollo, ya
que la especialización se dará ahora sobre las ramas del conocimiento involucrados en los
problemas que se pretenden resolver, y no en las herramientas de desarrollo para resolver-
los; con ello se aumenta la rentabilidad de los programadores y el retorno de la inversión en
programas y en capacitación.
1.3 Determinando la plataforma .NET requerida

La primer pregunta que debemos responder es ¿para qué queremos tener la plataforma
.NET en nuestros equipos?
La plataforma .NET cubre una gama sorprendente de aplicaciones; dependiendo Jo que que-
remos hacer es el producto .NET que debemos instalar, los requerimientos de hardware y
software que debemos cumplir, y el precio que hay que pagar.
¿Necesita instalar Microsoft .NET Framework? ¿Necesita instalar Microsoft Visual Studio?
¿De ser así, qué versión es la recomendada? Todo depende: piense en la ambientación que
tendrán las personas que utilizarán las aplicaciones, y decida con base en ello. Tome en
cuenta que lo ideal es que seleccione la versión más avanzada que pueda, aplicable para el
sistema operativo que posee.
Usted requerirá instalar Microsoft .NET Framework si requiere utilizar el CLR para inter-
pretar un ensamblado y traducirlo a código máquina. Este será su escenario si ejecuta pro-
gramas basados en Windows o si proporciona servicios basados en clases y componentes, o
si se trata de un servidor Web. Usted requerirá, por otra parte, Microsoft Visual Studio, en
caso de desarrollar aplicaciones.
Tome en cuenta que al instalar .NET Framework, el sistema experimenta cambios sustan-
ciales a nivel sistema operativo, que le permitirán reconocer ejecutables .NET, diferenciar-
los de los que no lo son, y poder producir resultados.
!DI WBVBVS2012.01.03- El Sistema Operativo y los Ej ecutables .NET.wmv
Alfaomega 11
SYNAPS PREMIUM
Sí usted consume páginas Web desarrolladas en .N ET, usted no necesita instalar nada en su
equipo, pues el procesamiento de programas y páginas no sucede en el equipo cliente, sino
en el servidor.
La siguiente figu ra pone en perspectiva qué versión es la más recomendable para los am-
bientes que posee.
Finura 01.03
Versiones de .NET y ASP.NET Windows ADO.NET
tecnologías incluidas.
Services Application Services Services
Cll
2.0 ~
Card
WPF WCF WF 3.0 1
Space
ADO.NET Entity
LINQ 3.5
Framework
~ ~
Task Parallel
Parallel LINQ 4.0
library
~
z•
.NET API for
Metro Style 4.5
Tome en cuenta que lo mínimo que debe esperar es utilizar la parte core de la plataforma,
cosa que se obtiene trabajando con la versión 2.0 o posterior de Microsoft .NET Framework.
Posteriormente, dependiendo de los modelos de programación que desee utilizar, así como
su plataforma operativa, deberá seleccionar la versión más adecuada.
12 Alfa omega
SYNAPS PREMIUM
En caso de que tenga ambientes heterogéneos (diferentes sistemas operativos, diferentes

necesidades), le recomendamos que opte por la versión de producto que menos perfil re-
quiera, pues puede asegurarse de que lo que desarrolla funcionará en todos los ambientes.
~ lab.Ol.Ol: Exponiendo Microsoft .NET como producto.
En la compañía Aceros y Minerales del Norte acaban de sustituir al anterior Ge-

rente de Sistemas. Dicho gerente era un creyente de las plataformas de free-
software, por lo cual los desarrollos se hacían en PHP, para Web, y en Java, para
aplicaciones de escritorio.
El nuevo Gerente tiene otra visión: piensa que el free-software es económico en
materia de productos, pero que no hay verdaderos expertos que brinden soporte
y consultoría, y que además no hay una empresa responsable de su estabilidad.
Ha decidido adoptar como plataforma de desarrollo en la compañía a Microsoft
.NET, y se ha enterado de que Usted tiene conocimientos respecto al tema. Le pi-
de que haga dos presentaciones: a) una ejecutiva, que le será expuesta a él y al
resto de los Gerentes de la empresa, en donde resaltará los beneficios de estabi-
lidad y flexibilidad de Microsoft .NET, así como las ventajas que obtendrá dese el
punto de vista de negocios; b) una técnica, que le será expuesta a los equipos de
desarrollo actuales, en donde les explicará la arquitectura de Microsoft .NET, có-
mo funciona, y las semejanzas y discrepancias con Jo que se ha estado trabajando
actualmente.
El Gerente le dice que, si las presentaciones son exitosas, no tendría objeción en
subirlo de puesto y adoptarlo como su mano derecha para la dirección de la Ge-
rencia de Sistemas.
Elabore ambas presentaciones.
Deberá apoyarse en algunos artículos de Internet, por lo cual le sugerimos las si-
guientes palabras de búsqueda:
l. Comparación Java y .NET
2. Comparación PHP y ASP.NET
3. Software libre vs software propietario
Encontrará versiones encontradas de todo lo que busque. Elabore la presenta-

ción que más le conviene.
FIN DEL EJERCICIO *
Alfaomega 13
SYNAPS PREMIUM
~ lab.01.02: Determinando la plataforma .NET para

desarrollo.
Se tiene un escenario compuesto como sigue.
Desarrollador
SIO Desarrollador
SICOM
Servidor de Aplicaciones y
Objetos de Negocios Servidor Web
••
Servidor de Bases
de Datos
Usuario SICOM
UsuarloSIO UsuanoSlO UsuarioSIO Usuario SICOM UsuariO SICOM
Las aplicaciones de una empresa se encuentran en una distribución multicapa, de

la siguiente manera: Se tienen tres servidores. a) Uno de ellos es el servidor de
bases de datos, que le da servicio de almacenamiento de datos a las aplicaciones
y objetos de negocios; este servidor trabaja sobre Windows Server 2008, Data-
center x64 Edition, y utiliza el motor de base de datos Microsoft SQL Server 2008.
b) Otro de los servidores es de aplicaciones, y hospeda todos los objetos de lógica
de negocio, así como las aplicaciones de escritorio basadas en interfaz Windows;
este servidor trabaja sobre Windows Server 2003 R2, Enterprise x64 Edition. e)
El último servidor es el servidor Web, que consume datos y funcionalidad de los
otros dos servidores; este servidor trabaja en un equipo Windows Server 2012.
Se tienen dos aplicaciones principales, construidas en casa. a) SIO (Sistema In-
tegral de Operaciones), que proporciona todo el control de los procesos de pro-
ducción. Por lo complejo de las interfaces, se decidió que fuera una aplicación
14 Alfa omega
SYNAPS PREMIUM
Windows Forms. b) La otra aplicación importante es SICOM (Sistema de Comer-

cialización), que proporciona información de ventas y pronósticos de ventas, así
como información relevante para la administración financiera del negocio. Co-
mo la información puede ser consultada tanto dentro como fuera de la empresa,
se decidió que fuera un desarrollo Web.
Por el momento sólo 3 usuarios utilizan SIO, y sus equipos trabajan bajo Win-
dows 7. Por otro lado, 2 personas utilizan SICOM, y se enlazan desde sus equi-
pos con Windows Vista; uno de ellos es el director general, que puede enlazarse
desde su equipo, cuando está en la empresa, o desde su PDA, cuando anda fuera
de la empresa.
Se tienen dos desarrolladores en la empresa, que por el trabajo que desarrollan,
tienen instalados equipos de última generación, funcionando bajo Windows 8.
Uno de ellos se encarga del desarrollo y mantenimiento de SIO, y otro que se en-
carga del desarrollo y mantenimiento de SICOM. Los tiempos de desarrollo que
tienen son muy estrechos. SIO es crítica y compleja, mientras que SICOM es un
poco más sencilla.
¿Qué cantidad de cada producto es necesaria para soportar la operación de la
empresa? Cuide el mayor aprovechamiento de los recursos de cómputo y el
menor costo.
•
Producto Cantidad Vers ión
FIN DEL EJERCICIO*
Alfaomega 15
SYNAPS PREMIUM
Ambiente de trabajo usando

Visual Studio 2012
Competencias:
1. Conocer el concepto de organización
de trabajo en Visual Studio, basado
en soluciones y proyectos.
2. Conocer la mecánica para la creación
de aplicaciones usando Visua l
Studio.
3. Conocer el uso de las herramientas
¡ básicas de partida: Solution Explorer,
los diseñadores, y Cede Editor.
4. Conocer el proceso de construcción
y depuración de aplicaciones en
Visual Studio.
Evaluacl6n:
l . Proporcionar un
algoritmo en donde
sólo se muestre Evidencia de
información, y aprendizaje:
verificar que se es l. Capacidad de crear una
capaz de crear una Solución, e integrarle
solución y un diferentes tipos de proyectos
proyecto para usando Visual Studio.
manejarla; se 2. Capacidad para crear una
verificará también aplicación, desde la creación
que se utilizan las de una solución y un
herramientas de Code proyecto, pasando por la
Editor, y que se codificación usando Code
depura la aplicación. Editor, y la depuración del
programa en Visual Studio.
SYNAPS PREMIUM
2: Ambiente de trabajo en Visual Studio 2012

2.1 Organización del trabajo en Visual Studio .................................................................................................... 19
2.1.1 Soluciones, proyectos, elementos ............................................................................................................. 19
2.1.2 ¿Dónde almacena Visual Studio el trabajo? ......................................................................................... 20
2.1.3 Tipos de proyecto disponibles en Visual Studio ................................................................................ 21
2.1.4 Proceso de construcción (Build) ............................................................................................................... 22
2.2 Her·ramientas en Visual Stu dio .......................................................................................................................... 24
2.2.1 Diseñadores ...................................................................................................................................................... 25
2.2.2 Ventanas ............................................................................................................................................................. 26
2.2.3 Editores .......................................................... ..................................................................................................... 27
2.3 Un adelanto: Sintaxis en Visual Basic.............................................................................................................. 28
~ Lab.02.01: Manejando soluciones y proyectos .............................................................................................. 29
a) Creando una solución en blanco .................................................................................................................. 29
b) Agregando proyectos a una solución ......................................................................................................... 31
e) Trabajando con varios proyectos en una solución ................................................................................. 32
d) Comprobando Auto-Hide................................................................................................................................ 34
e) Agregando y eliminando elementos de proyecto ................................................................................... 34
f) Guardando el trabajo ....................................................................................................................................... 35
~ Lab.02.02: Manejo de Code Editor ..................................................................................................................... 35
a) Creando una aplicación de Consola ............................................................................................................ 35
b) Utilizando herramientas de Code Editor .................................................................................................. 37
e) Depurando aplicaciones ................................................................................................................................. 38
~ Lab.02.03: Creando una solución, un proyecto y un programa .............................................................. 40
18 Alfa omega
SYNAPS PREMIUM
Unidad 2: Ambiente de trabajo usando Visual Studio 2012
2.1 Organización del trabajo en Visual Studio
2.1.1 Soluciones, proyectos, elementos

Entendamos algo: Visual Studio es un Entorno Integrado de Desarrollo (!DE j lntegrated Develo-
pment Environment, por sus siglas en inglés); como todo IDE, su función es proveer herramientas
gráficas y sofisticadas para automatizar y facilitar al máximo el proceso de desarrollo de softwa-
re: planeación, diseño, codificación, interacción con otras tecnologías, integración de producto,
testing, empaquetado, liberación, entre otras cosas, todo desde una misma herramienta.
Sólo para disipar la duda que pudieran tener algunos despistados: Visual Studio y .NET Frame-
work no son lo mismo. No es indispensable utilizar Visual Studio para desarrollar aplicaciones
utilizando .NET Framework, ya que pueden ser desarrolladas sin utilizar herramienta alguna, o
utilizando alguna herramienta de otros fabricantes, como puede ser CodeSmith, CodeGenerator-
Pro, e incluso versiones Express de Visual Studio que Microsoft ofrece de manera gratuita. Lo
que sí podemos decir es que Visual Studio es eliDE más sofisticado que existe para el desarrollo
de aplicaciones .NET, y los desarrolladores profesionales deberían tenerlo; el costo del producto
se paga solo, considerando el número de horas de desarrollo que nos ayuda a evitar.
Como toda herramienta de automatización, tiene su propio sistema de organización de conteni-
dos, mismos que son ajenos a la aplicación que se va a generar. Visual Studio organiza el trabajo
en soluciones, proyectos y elementos de proyecto, que permiten seccionar y administrar el traba-
jo de una manera jerárquica e intuitiva.
Una solución (solution) es un conjunto de uno o más proyectos que aportan funcionalidad para
crear una aplicación. Las soluciones almacenan información respecto a los proyectos que agru-
pan, las dependencias entre estos, y especificaciones pertinentes relacionadas con el medio am-
biente de desarrollo que se está utilizando.
Las soluciones contienen proyectos. Los proyectos (projects) son contenedores utilizados por los
desarrolladores para organizar código fuente y otros archivos de trabajo. Generalmente, los pro-
yectos terminan convirtiéndose en productos utilizables, ya sea por el usuario final o por otros
programas, como es el caso de los ensamblados (.exe), las librerías (. dll), entre otros tipos de
productos que pueden generarse.
Los archivos fuente que son contenidos en los proyectos reciben el nombre de elementos de pro-
yecto (project items, o simplemente items).
Alfaomega 19
SYNAPS PREMIUM
Gráficamente, la jerarquía puede ser representada de la siguiente manera:
Solution 1
, - - Project 1 ----------¡::::::= --=---=::¡----.,

..---~ j::gj Yltndows Form
~·~ Windows Forrns Apphcatton
L...J
1-~ j::gj Wtndows Form
Figuro 02.01
Jerarquía de
1-~ j:gj Wtndows Form
Soluciones y
Proyectos.
IDJ WBVBV$2012.02.01 - Organización d el trabajo en Visual Studio.wmv
2.1.2 ¿Dónde almacena Visual Studio el trabajo?

Cuando usted instala Visual Studio 2012, en su biblioteca \Mi s Document os se generará un fol-
der llamado \Vi sual Studio 2012, dentro del cual se encuentran otros dos directorios parti-
cularmente importantes: \ Pr ojects y \ WebSites.
Cuando usted crea un nuevo proyecto tiene que especificar el nombre de la solución que lo con-
tendrá; al hacerlo se generará en el folder \ Proj ects un folder con el mismo nombre que asignó
a la solución (lo que se conoce como solution folder). En ese folder se almacenará el archivo que
contiene la información de la solución, y tendrá la extensión • s ln; además se generará un archi-
vo de extensión • suo, que se encarga de almacenar información de opciones de usuario para la
solución.
Dentro de ese folder, se generará otro folder con el mismo nombre del proyecto, en el cual se al-
macenarán los archivos fuente de los elementos de proyecto (lo que se conoce como project fol-
der).
En el caso particular que el proyecto se trate de un sitio web, el project folder se almacenará en el
folder \ WebSi t es contenido en \Visual Studio 2012, y no en solution jo/der. Esta separación
tiene que ver con el hecho de que las aplicaciones Web manejan un esquema de virtualización de
folders que permite el control de permisos por parte del servidor web, por lo cual se recomienda
aislar las aplicaciones web del resto de las aplicaciones, con fines de seguridad.
20 Alfa omega
SYNAPS PREMIUM
2.1.3 Tipos de proyecto disponibles en Visual Studio

Una de las grandes ventajas de utilizar Visual Studio es que incluye plantillas, llamadas también
templates, a partir de las cuales podemos comenzar a desarrollar aplicaciones sin partir desde
cero.
Se tienen dos fuentes de templates: a) Instalados (installed), que son los que se instalan en nues-
tro equipo al momento en que se instala Visual Studio, y b) En línea (Online), que son aquellos
que están disponibles en Internet para su consumo.
Recomendamos que utilice los templates instalados en su computadora, y a menos que no en-
cuentre una plantilla adecuada en su equipo, entonces decida usar una plantilla en línea. La razón
es que los templates instalados son consistentes, mientras que los disponibles en línea pueden
variar, Jo que nos obliga a revisar temas de compatibilidad.
Dentro de cada una de las fuentes de templates (Installed 1 OnLine) hay una jerarquía relacionada
con los lenguajes que es posible utilizar (Visual Basic 1 C# 1 C++ 1 F#, etcétera), y dentro de esta
jerarquía aparecen las diferentes plataformas aplicativas (Windows 1 Web 1 Cloud, etcétera). Ha-
biendo seleccionado lo anterior, aparecerán todas las plantillas relacionadas, de entre las cuales
podremos elegir una.
1 ..... :::::J ... r:'l

·~ l!.:J P-
.......... ......... 1'we,..,.a..c:

A,...cliof t~ ~• ..... 4wn_., •
Figuro 02.02
Agregando un
4 ~$,~;. ÑIK
Wrdowt
,..........
_._ "'~"** IJIWfoK~
nuevo proyecto a
una solución.
...-"11
....
~ ~;¡ o.u ""'"
WCF ~~· '""""',........."Y
v.~u.~ C1t
Vt,WIC••
Visu.lf1
_..
&_ J
.
EMpty PrOJEct
SQl Str.~
L•glttSto.llkh
Ot!\cr ltfOJtd l)'ptS
Modt .,9 Pro,tets
~i WPf Curtom Conbolllbwy
Sampfft
...
6!'
c::l WPFUsa C011trolli!Yttl)' Vi'$11.11Btslc
liJ Window$ F~ Conholl1bt-al)'
-.. 1
·]
./ Cl\ftl._ .,eruwyfonetklbort
Add 10 lOU'C:f: CO'Itrol
1 0K (e-,¡
Alfaomega 21
SYNAPS PREMIUM
Dependiendo lo que hayamos seleccionado, Visual Studio nos generará de forma automática un
conjunto de archivos fuente a partir de los cuales podremos comenzar a trabajar.
2.1.4 Proceso de construcción (Build)

Una vez que se han concluido las labores de desarrollo, es necesario preparar el producto para su
liberación en ambientes productivos Qo que se conoce como release). Que se libere un aplicativo
no quiere decir que ya se haya instalado en algún lugar: cuando finalmente se instala en un am-
biente determinado, entonces hablamos de que se ha realizado la implementación (deployment).
Es pertinente hacer la diferenciación: no todo software liberado puede ser implementado; por
ejemplo, una aplicación desarrollada para Metro (Windows 8) puede liberarse, pero no pude ser
implementada en equipos con Windows 7.
Visual Studio tiene un proceso denominado construcción (Build), que consiste en analizar todos
los proyectos de una solución, revisar la sintaxis de sus códigos fuente, verificar el correcto uso
de tipos, verificar la disponibilidad de recursos referidos, analizar los parámetros de configura-
ción, y con todo ello, generar una aplicación que pueda ser utilizada, ya sea por los usuarios fina-
les o por otros programas, dependiendo de la naturaleza del aplicativo.
El resultado del proceso de construcción se almacena generalmente en un folder denominado
\ Bin que se encuentra en solution folder, de donde puede ser tomado para realizar la implemen-
.'
tacwn.
El proceso de construcción tiene dos finalidades: a) Depuración (debug), cuando lo que se desea
es identificar errores de sintaxis, de tipos, o de integración de elementos, con la finalidad de co-
rregirlos; y b) Liberación (release ), cuando se desea generar la aplicación para darla por liberada.
Seleccionar el modo Debug o Release es importante, pues cuando la construcción se hace con fi-
nes de depuración, Visual Studio agrega a los programas y archivos de trabajo información deta-
llada relacionada con pistas de seguimiento, flujos de proceso, entre otras cosas, con la finalidad
de que, en caso de problemas, se tengan más elementos para poder solucionarlos. En cambio,
cuando la finalidad es de liberación, se asume que la aplicación ya se depuró; en ese sentido Vi-
sual Studio genera programas ejecutables optimizados y preparados para su distribución final,
omitiendo pistas e información que sería útil para la solución de problemas que en teoría ya no
deberían de existir.
¿Y qué tienen que ver las soluciones y proyectos con el proceso de construcción? Bastante: el
proceso de construcción puede realizarse tanto a nivel solución como a nivel proyecto, e incide
en la decisión de cuántas soluciones y proyectos deberemos de crear. Tome en cuenta lo siguien-
te: Cuando construye un proyecto, la verificación de código y recursos se realiza sólo sobre los
elementos del proyecto procesado, lo cual deja fuera de revisión la convivencia del proyecto con
otros proyectos. Además, mientras se realiza el proceso de construcción, no se pueden estar rea-
lizando modificaciones.
22 Alfa omega
SYNAPS PREMIUM
Imagine que está desarrollando una aplicación que contiene lo siguiente: a) Un módulo basado
en Windows Forms Application, que permitirá la captura de información (WIN); b) Un módulo
basado en ASP.NET Web Forms Application, que permitirá consultar la información capturada
(WEB), y e) Una librería de clases que permitirá el registro y la explotación de los datos captura-
dos (CLASS), y es utilizada tanto por WIN como por WEB.
Suponga que un equipo de desarrolladores (E1) se encargará del desarrollo de WIN y también de
CLASS; de hecho, comprobará el funcionamiento de CLASS utilizando la clase desde WIN; por
otro lado, otro equipo de desarrolladores (EZ) se encargará de generar WEB.
Si E1 quiere desarrollar y construir WIN y CLASS juntos, sin que ello afecte el trabajo que realiza
EZ, pero al final se desea construir toda la aplicación (WIN, WEB y CLASS juntas) para garantizar
su convivencia ¿Cuál sería una buena estrategia de construcción?
Tome en cuenta algo importante: un proyecto puede formar parte de varias soluciones, por lo
que es posible organizar la forma en que se depuran y construyen los proyectos a través del uso
de varias soluciones. Una posible solución sería la siguiente:
, - - WIN - - -- - - - - - . . , .
Figura 02.03
,...,
l-.J \•,~ndows Forms Appliutton
Solution M
Organización de
proyectos en una
o varias
soluciones.
CLASS
r - WEB - -- - - - - - - . ,
Solution E2 1S"j ASP.NET Wtb fO<m< Applo<obon l
En este escenario, se desarrollan 3 proyectos. Los proyectos WIN y CLASS se asocian a Solution
E1, mientras que el proyecto WEB queda en Solution EZ. Cada equipo hace su trabajo y depura
los desarrollos sin afectar al otro; el equipo E1, al tener a WIN y CLASS en la misma solución,
puede construir la solución completa, con lo cual se pueden hacer revisiones de convivencia en-
tre el exe que generará WIN y el dll que generará CLASS. Por otro lado, EZ trabaja de manera
o o
autónoma, sin verse afectado por los trabajos de depuración de E1. Cabe aclarar que al construir
Alfaomega 23
SYNAPS PREMIUM
Solution El y Solution E2, se hace en modo Debug, y se deberán corregir Jos proyectos hasta que
no existan errores.
Cuando finalmente todos los proyectos están validados, se genera una nueva solución, que actua-
rá como solución maestra (Solution M). A esta solución se asociarán todos los proyectos. Prime-
ramente se construye en modo Debug, a fin de garantizar la convivencia; en caso de errores, se
corrigen. Cuando ya no hay errores, se procede a construir Solution Men modo Release, y nues-
tro aplicativo quedará listo para su implementación.
Las decisiones relacionadas con el número adecuado de soluciones y la manera en cómo deben
ser realizados los procesos de Build, dependen de la distribución del trabajo entre los equipos de
desarrollo, así como las verificaciones de convivencia que se deseen entre los proyectos.
2.2 Herramientas en Visual Studio

En Visual Studio las herramientas podemos encontrarlas, principalmente, en forma de diseñado-
res, ventanas y editores.
No olvidemos que el objetivo de un !DE es automatizar Jo más posible el proceso de desarrollo, lo
cual se logra de la siguiente manera en el caso de Visual Studio.
1. Se elije un tipo de proyecto, lo cual nos proporciona un marco de trabajo base a fin de que
no partamos desde cero. La herramienta pre-construye las partes generales de lo que que-
remos hacer, dejando bajo nuestra responsabilidad los detalles particulares.
2. Interactuamos con diseñadores que nos permiten, de manera visual e intuitiva, agregar los
detalles particulares de nuestra aplicación. A través de la herramienta es sencillo agregar
elementos, manejar su posición y organización, definir sus dimensiones.
3. Interactuamos con ventanas, que nos permiten establecer valores precisos que sería más
complicado establecer con los diseñadores. Las ventanas nos permitirán establecer el as-
pecto y las limitantes de comportamiento de los elementos que componen nuestra aplica-
.'
CIOn.
4. Finalmente, lo que no podamos establecer de forma más sencilla con los diseñadores y las
ventanas, podemos especificarlo mediante código a través de los editores. También los
editores nos permitirán codificar rutinas para permitir que nuestro aplicativo realice ac-
ciones específicas requeridas por el usuario.
La idea central es que al momento de llegar a los editores, casi todo esté hecho.
A continuación se explican brevemente cada uno de los tipos de herramienta, a reserva de que se
comprenderán mejor al momento de realizar ejercicios que los utilicen.
24 Alfa omega
SYNAPS PREMIUM
2.2.1 Diseñadores
En Visual Studio los diseñadores son herramientas que permiten crear interfaces y elementos de
aplicativo de forma gráfica, logrando que la herramienta codifique por nosotros lo que visual-
mente estamos diseñando de manera sencilla e intuitiva.
Los diseñadores permiten elaborar interfaces de todo tipo (Windows, Web, Mobile, etcétera), y se
apoyan mucho en Toolbox, que provee los elementos que pueden agregarse en la interfaz (lla-
mados controles, o controls), y de Properties Window, que permite modificar el comportamien-
to y apariencia de los elementos que son diseñados.
Prácticamente hay tantos diseñadores como tipos de aplicativo: Windows Designer , para aplica-
ciones Windows; Web Designer, para aplicaciones Web; WPF Design er , para aplicaciones WPF,
,
y ast.
Dentro de las operaciones más importantes que se pueden hacer con los diseñadores está la de
agregar elementos. Esto se hace en conjunto con Toolbox, de la siguiente manera:
1. Modo inserción. Se hace doble die sobre un control en Toolbox, con lo cual un objeto
se agregará al área de diseño.
2. Modo arrastre. Se arrastra un control, de Toolbox, al área de diseño, y el objeto se
agrega.
3. Modo de trazo. Se hace un die sobre un control en Toolbox, y luego se traza el espa-
cio que deberá ocupar el control dentro del área de diseño, y este se agrega.
Se debe tomar en cuenta que, cuando se agregan elementos a un área de diseño, todo lo que agre-
guemos se convierte en un objeto, mismo que tiene un identificador y que podrá ser manipulado
de manera individual a través de las ventanas.
En Visual Stu dio los diseñadores varían bastante, dependiendo lo que nos ayuden a diseñar: crear
una interfaz Windows puede ser muy distinto a diseñar una clase abstracta. Más allá de eso, po-
demos ver un diseñador de forma muy similar a esta:
Alfaomega 25
SYNAPS PREMIUM
Toolbox
-
fock
•
f
.
So-«01. -
Figura 01.04
Herramientas de
;
\ ,_
4 AIW~foes • • tl
diseño de Visual
r "'',_.._
" ~..'l.... Área de
=._
i
Studio. 101 ~
diseño
Co_n_tr_o_le-s ""'r-~- ~
(í-
!f.1 Colodloolog
il , _
El C....-...&op
.Q'! D•taGnd'llrw
iJ D•tolc!
i5 04tduncP!(k.cf
rn o,rtct()()'(tltl)'
P D•rKtorySurchtt
[] D"'"•~UpOow"
O EnotPtov•c:kt
1!1 !w>t1ccJ
m filtSystcm'Wftchtr
!j fb..t.tyoi4Ptl\rl
¡;] fold<ts.-!l•log
Gl f<otllwlog
CJ GroopBoet
2.2.2 Ventanas
En Visual Studio las ventanas son herramientas que permiten modificar los elementos sobre los
que estamos trabajando, o crear nuevos elementos. Las más típicas son las siguientes:
1. Solution Explorer (CTRL+ALT+L). Permite administrar los proyectos y elementos de
proyecto que componen una solución.
2. Server Explorer (CTRL+ALT+S). Permite visualizar los servidores con los cuales se
puede interactuar desde la aplicación. Generalmente se trata de servidores de base de
datos con los cuales se pueden establecer conexiones.
3. Object Browser (CTRL+ALT+J). Permite explorar y analizar los elementos que com-
ponen los objetos definidos en nuestro desarrollo.
4. ToolBox (CTRL+ALT+X). Permite ver los controles gráficos que pueden ser incluidos
en una interfaz de usuario. Muy útil al diseñar aplicaciones Windows y Web.
5. Properties Window (F4). Permite modificar las propiedades de elementos incluidos
en una interfaz de usuario.
Hay muchas más, pero estas son las fundamentales.
26 Alfa omega
SYNAPS PREMIUM
Es común que las ventanas tengan encabezado, y generalmente tienen los siguientes elementos:
Auto·
M en u
Figura 02.05 TooiBar

Elementos
Close
comunes de las
venta nas de 'e ·otéi }l B
herramientas. ~arth SolutJovn Exploror (Ctrf· 1 P·
Search
1. Toolbar. Permite seleccionar diversas tareas de la ventana, disponibles en un solo dic.

2. Menú. Permite establecer el comportamiento de la ventana, de tal manera que sea flo·
tan te, tenga una ubicación fija, se muestre y oculte automáticamente, y así.
3. Auto-Hide. Es una característica que indica si la ventana estará visible todo el tiempo, o
si al hacer die en la Pestaña perímetral aparecerá o desaparecerá. Basta hacer die en el
icono para cambiar de un modo a otro.
a. indica que la ventana estará siempre visible.
b. indica que la ventana se ocultará usando las pestañas perimetrales.
4. Search. Permite hacer búsquedas de algo dentro de la ventana.
Es importante mencionar también que dentro de las ventanas hay un tipo especial, que son las
ventanas informativas; su característica principal es que sólo aparecen cuando se está realizando
un proceso determinado, y permiten observar evidencia de Jo que Visual Studio está haciendo.
Este es el caso de Output Window, Task List, etcétera.
2.2.3 Editores
En Visual Studio los editores son editores especializados que permiten crear documentos aten·
diendo reglas sintácticas específicas. Por ejemplo, XML Editor está preparado para detectar si un
documento está siendo construido adecuadamente, atendiendo las reglas de XML; por otro lado,
Code Editor vigilará si las reglas de sintaxis del lenguaje elegido se están cumpliendo, y así.
Dentro de algunas funcionalidades que Jos editores proporcionan, están los siguientes:
1. Branching. Identifica bloques de código que tienen inicio y fin, y permite extenderlos o
colapsarlos.
2. Auto-Complete. Agrega de forma automática líneas de código que por sintaxis deben
incluirse.
Alfaomega 27
SYNAPS PREMIUM
3. Coloring. Permite distinguir diferentes tipos de contenidos editados, en base a colores.

Por ejemplo, diferencia las palabras reservadas, nombres de elementos, comentarios,
etcétera, haciéndolos reconocibles visualmente.
4. Error detection. Capacidad de identificar errores en código y señalarlos subrayando el
contenido que provoca el error, de la misma forma que Word identifica los errores de
ortografía.
S. Intellisense. Es la capacidad de los editores de sugerir escritura dese el momento en
que se comienza a escribir algo.
6. Error correction options. Capacidad del editor de sugerir posibles soluciones a los
errores detectados.
2.3 Un adelanto: Sintaxis en Visual Basic

Comenzaremos a hacer algunos ejercicios utilizando código en Visual Basic, por lo cual es necesa-
rio adelantarnos un poco y exponer algunos fundamentos del lenguaje. Esto nos permitirá enten-
der mejor la forma en que Visual Studio asiste el desarrollo de aplicaciones:
1. El uso de mayúsculas y minúsculas en Visual Basic no es relevante, dado que se trata de
un lenguaje no sensitivo a mayúsculas y minúsculas (non case sensitive).
2. Las líneas de código en Visual Basic terminan al encontrarse un salto de línea (CR/LF).
No es necesario ningún tipo de símbolo para dar por concluida una línea de código.
3. El continuador de línea es un guión bajo U; el continuador de línea no debe interrum-
pir expresiones, y además, antes de colocarlo debe haber un espacio en blanco, y des-
pués de él no debe escribirse nada.
4. Un bloque de código es el conjunto de líneas que deben ser tratadas como unidad de
ejecución. Los bloques de código generalmente se delimitan por estructuras con inicio
y fin, en donde el inicio indica el tipo de bloque del que se trata, mismo que debe con-
cluirse con el estatuto End:
a. Ejemplos: Module-+ End Module, Sub-+ End Sub, etc.
b. Todo bloque de código que se inicie debe cerrarse.
c. El último bloque de código en abrirse debe ser el primero en cerrarse.
S. Las bibliotecas a utilizarse en un programa se declaran al inicio del mismo, utilizando la
palabra reservada Imports.
6. Se utilizan paréntesis para delimitar expresiones que deban resolverse, o para delimi-
tar argumentos.
7. Las variables que se utilicen en un programa deben estar definidas de manera explícita.
28 Alfa omega
SYNAPS PREMIUM
8. Aunque no es relevante para el compilador, evite la codificación de todo mayúsculas o

todo minúsculas. Procure iniciar las palabras reservadas con mayúsculas.
~ Lab.02.01: Manejando soluciones y proyectos
En este ejercicio generará una solución en Visual Studio y verá la manera en que se pueden
agregar proyectos y elementos de proyecto para el desarrollo de una aplicación.
a) Creando una solución en blanco

1. Ingrese a Visual Studio.
o4 >'•",,.. ·M>Cf'fiCIII\ V"" 11 ~..... Q~~t<\ l•un•t! J(t( •Q) p - C 1<
fU 00 V1lW DliUG Tf.AM ~ TOQ.$ TtSl .trro-m:CTURl .rN.lVZl ~DOW HElP
·-·-•c.--
Q • lól tJ' • MKh- • Jfi
,.._,_ •••
p.
• 1 X
.-.,...o-.,.,_ ....
"'ft•,.-~*~·
........................
2. A esta página inicial se le llama Start Page, y es la página de inicio para los trabajos.
Desde ella se pueden crear nuevos desarrollos, abrir desarrollos existentes, además de
obtener información reciente relacionada con el producto, misma que es obtenida
desde Internet.
3. En Start Page haga die en New Project, y aparecerá la ventana New Project, que
permite la creación de un nuevo proyecto.
Alfaomega 29
SYNAPS PREMIUM
~~::~~=====:.ill~"""'-T....-
... J:j \\W•n ' t•••

,,. v....a..c
-- ....................
P·
•,...,.a*c•......,,.....,.,__....-•
,........,...,., li c....._,,. 7 ' .........

"'-
'"'
..........
W(f
Y....... C.
.........
V~tWIC••
\!Wflf•
IQI.S...•
l..,.S..-tcft :! D•• .,,ftdrowl Ser...u
-
Othtt 'IOJt« l)'ptf
lductt~NJ ~IKb
g1."J Y.WCustomC«~t~ollb.-y
••!.
o -. ..~· 'lt'Pf u~ COI'Itrolltbr"'Y
•
•••
VIWOII811ftC
4. En la extrema izquierda aparece el Árbol de Tipo de Plantilla, que permite organizar

en forma de jerarquía los diferentes tipos de plantillas disponibles. De forma general, se
tiene:
a. Recent, que mostrará las plantillas que se han usado más recientemente.
b. lnstalled, que contiene las plantillas instaladas en su equipo.
c. Online, que contiene las plantillas disponibles en Internet.
S. Seleccione Online, y luego explore un poco qué diferentes plantillas se pueden utilizar.
Como podrá ver, en línea aparecen incluso plantillas desarrolladas por terceros, para
simplificar el desarrollo de aplicaciones específicas.
,
6. Seleccione en Arbol de Tipo de Plantilla la opción lnstalled - Other Project Types -
Visual Studio Solution.
a. En Plantillas aparecerá Blank Solution.
b. Haga die en Blank Solution.
c. En Name escriba Ejercicios.
d. Haga die en Ok. Esto provocará que se genere una nueva solución de Visual Studio en
su equipo.
30 Alfa omega
SYNAPS PREMIUM
b) Agregando proyectos a una solución
1. En el ambiente de trabajo, en la extrema derecha, aparecerá la ventana Solution

Explorer con un nodo, indicando la presencia de una solución llamada Ejercicios
que contiene Oproyectos.
2. En Solution Explorer haga die en el nodo de la solución Ejercicios.
3. Utilizando el botón derecho del ratón, haga die e invoque el menú de contexto sobre el
nodo, con lo cual aparecerán algunas acciones que es posible realizar con una solución.
4. Seleccione Add - New Project, con lo que aparecerá la ventana Add New Project, que
nos permite agregar un nuevo proyecto a la solución. Como puede darse cuenta, es muy
similar a la ventana New Project, con la diferencia que no permite la creación de una
solución, pues ya se está dentro de una.
,
S. Seleccione en el Arbol de Tipo de Plantilla la opción lnstalled - Visual Basic, y
seleccione la plantilla Windows Forms Application.
e. En Name coloque HolaMundoWi n.
f. Presione Ok para agregar a la solución un proyecto basado en la plantilla Windows
Forms Application.
6. Suceden varias cosas:
a. Se muestra el diseñador Windows Designer.
Barra de herramientas
114 ~~ l(.w..Q P - e •
_. tr11 ..., NCIIkt M.t llliWG """ SQL fc:.et~ ;ccu rm ........a¡cna ..,.,as ....,. ..,
-......• . .;;:. .
d· ~Ww" • -· 4.~ 01eo.t • ,
. ...........
.....
•• • ¡,_,..,._ •. .,
p.
=--~~ --·t.-_.
• ...... ' 'M
.." .....
r ...,••, *'"
~ .... "'ff'' ...
.............
CZI CNOb
( ............
"" '-
11 ·
11 -"OIIIr9
( .........
1ft r.••t.Mfto ...
Ql C'olfSC
a Or.lo1....,d•
~·"""'
p ....
Cl _
a .......- •••-
o ........
• lotNl...
Q ·-~'"'""......
" floool.~..,tf
Windows Designer
"·-
;, ........o...
b. En Toolbox se colocan todos los controles que pueden ser integrados a una aplicación
de interfaz de usuario Windows.
Alfaomega 31
SYNAPS PREMIUM
c. En Solution Explorer desaparece el nodo de la solución y aparece como nodo principal

el nuevo proyecto creado.
e) Trabajando con varios proyectos en una solución
7. Visto así, parecería que sólo se puede trabajar con un proyecto al mismo tiempo, lo cual
no es cierto. Haga lo siguiente:
a. En la barra Search de Solution Explorer, escriba «Sol».
b. Vea cómo se realiza la búsqueda dinámica, mostrando los elementos que cumplen con
el texto de búsqueda.
c. En este caso, aparece el nodo que se ocultó al momento de crear el proyecto Windows.
d. Seleccione el nodo, y utilizando el menú de contexto, seleccione Add - New Project.
,
e. En Add New Project, en el Arbol de Tipo de Plantillas seleccione Installed - Visual
Basic - Web.
f. En Plantillas, seleccione ASP.NET Empty Web Application.
g. En Name asigne HolaMundoWeb.
h. Presione Ok.
1. Elimine lo que escribió en la barra Search de Solution Explorer, a fin de que el
contenido de la ventana no se filtre.
j. Aparecerán entonces los dos proyectos que están contenidos en la solución.
8. '@ En la Barra de herramientas de Solution Explorer seleccione el icono Show All

Files.
a. En el caso de Windows, se agregó como elemento de proyecto un formulario Windows,
de nombre Forml. vb. Si extendemos el nodo, podremos ver que tiene su propia
estructura y componentes.
b. En el caso de Web, no se agregó elemento alguno al proyecto, dado que se eligió una
aplicación vacía.
9. Estos proyectos son muy pequeños y casi no contienen elementos, pero no siempre es
así: en ocasiones contienen una gran cantidad de elementos y resulta impráctico estar
navegando en Solution Explorer a fin de ver uno u otro proyecto.
10. Para evitar esto, la herramienta proporciona una manera de visualizar cada uno de los
proyectos en su propia ventana.
32 Alfa omega
SYNAPS PREMIUM
a. Seleccione el nodo principal del proyecto HolaMundoWin, y utilizando el menú de

contexto seleccione New Solution Explorer View, con lo que aparecerá una nueva
ventana Solution Explorer, dedicada únicamente a dicho proyecto.
b. Ahora seleccione el nodo principal del proyecto HolaMundoWeb, y utilizando el menú
de contexto seleccione New Solution Explorer View.
c. Las ventanas nuevas las puede distribuir en cualquier parte del ambiente de trabajo, de
tal manera que resulte cómodo accederlas.
d. 13 Cierre las ventanas nuevas que ha abierto, dejando sólo el Solution Explorer
original. Para cerrarlas sólo tiene que hacer die en el ícono correspondiente.
11. Vea cómo al agregar un nuevo elemento al proyecto, el diseñador permite seleccionar
sobre qué elemento queremos trabajar. En la parte superior del diseñador, aparece la
Barra de pestañas de archivo:
...
12. Cuando se selecciona una pestaña, el diseñador o editor correspondiente toma control
del espacio de trabajo.
13. Cuando no se quiera tener un elemento disponible en el área de trabajo, basta con
hacer die en el ícono de cerrado. En cualquier momento que necesitemos nuevamente
el elemento, podemos agregarlo haciendo die sobre él en Solution Explorer.
a. En la Barra de pestañas de archivo, seleccione Forml. vb, haciendo die sobre la
pestaña que tiene su nombre.
b. 13 Cierre ese elemento, haciendo die en el ícono de cerrado.
c. En Solution Explorer identifique el nodo de Forml. vb, y haga doble die en él, para
que se cargue el elemento en el espacio de trabajo.
14. Ciertamente, el nombre del programa Forml. vb no es muy ilustrativo. Para renombrar
el nombre del elemento desde Solution Explorer, lo que debe hacer es lo siguiente:
a. Seleccione el nodo Forml. vb que se encuentra en el proyecto HolaMundoWin.
b. Seleccione la opción Rename del menú de contexto.
c. Coloque como nuevo nombre HolaMundoWinForm. vb
d. Aparecerá un mensaje preguntando si desea actualizar las referencias al nombre de
elemento, a lo que contesta afirmativamente.
Alfaomega 33
SYNAPS PREMIUM
d) Comprobando Auto-Hide
15. En monitores que no son muy grandes el espacio de trabajo puede volverse crítico. En
algún momento se puede desear que una ventana que no está siendo ocupada
desaparezca de nuestra vista. Esto es posible a través de la capacidad de Auto-Hide de
las ventanas de Visual Studio.
16. lil En Solution Explorer, haga die en el ícono de Auto-Hide, hasta que aparezca
apaisado o acostado. Podrá darse cuenta que la ventana desaparece.
17. Al mismo tiempo, en el área de pestañas perimetrales, aparece una pestaña para
Solution Explorer. Haga die en dicha pestaña en múltiples ocasiones, y vea cómo la
ventana aparecerá y desaparecerá. Si ocupa más espacio, basta con que haga
desaparecer la ventana, y ya está.
18. IJ Para que la ventana esté permanentemente en su espacio de trabajo, haga die en
Auto-Hide hasta que el ícono aparezca en modo vertical.
e) Agregando y eliminando elementos de proyecto
19. Agregar elementos de proyecto es muy sencillo. Basta seleccionar el nodo principal del
proyecto, y en el menú de contexto elegir Add - New Item, o presionando
CTRL+SHIFT+A.
a. Seleccione el nodo principal de HolaMundoWeb.
b. Presione CTRL+SHIFT +A, con lo que aparecerá la ventana Add New /te m.
,
c. En el Arbol de Tipo de Plantilla, seleccione lnstalled- Visual Basic - Web.
d. En Plantillas seleccione Web Form .
e. En Name escriba HolaMundoWebForm. aspx
f. Presione Ok.
g. Con ello aparecerá Web Designer permitiéndonos editar la página Web que acabamos
de crear.
20. De esta forma es posible agregar elementos a cualquier proyecto, obviamente, variando
el tipo de elemento de acuerdo a lo que necesitemos agregar a nuestros proyectos, y
tomando en cuenta que hay algunos elementos de proyecto que no tienen cabida en
ciertos proyectos, como podría ser una Windows Form en un proyecto Web, que Visual
Studio no podría resolver.
21. Pruebe sus conocimientos: Agregue al proyecto HolaMundoWin, un elemento de
proyecto basado en la plantilla Windows Form, que se llame Nuevo. vb
34 Alfa omega
SYNAPS PREMIUM
22. Es probable que en un momento dado no sólo quiera agregar elementos, sino
eliminarlos. Para ello, basta seleccionarlos en Solution Explorer, y elegir la opción
Delete del menú de contexto.
a. En Solution Explorer seleccione el nodo Nuevo. vb del proyecto HolaMundoWin.
b. Elija la opción Delete del menú de contexto.
c. Confirme la eliminación permanente del archivo.
f) Guardando el trabajo
23. Para guardar nuestro trabajo tenemos las siguientes opciones:
a. li Si deseamos guardar sólo lo que hemos hecho en el elemento de proyecto donde

nos encontramos, hacemos die en el icono Save de la Barra de herramientas, o
presionamos CTRL+S.
b. .JA Si deseamos guardar todo Jo que no esté guardado, hacemos die en el icono Save
All de la Barra de herramientas, o presionamos CTRL+SHIFT+S.
24. Guarde todas las modificaciones que haya realizado hasta el momento en sus proyectos.
FIN DEL EJERCICIO*
~ lab.02.02: Manejo de Code Editor

En este ejercicio generará un proyecto que nos ayudará a comprobar algunas capacidades de
Code Editor, el sorprendente editor de código de Visual Studio. La idea es elaborar un programa
que solicite presionar INTRO, y que al hacerlo, nos muestre el mensaje «Hola Mundo». Para
ponerle un poco de emoción, haremos que tenga un procedimiento.
Lo que queremos aprender es el lenguaje Visual Basic, y en este momento meternos con temas de
interfaz de usuario basadas en Windows o Web sería mezclar temas por aprender, lo que no es
muy didáctico.
Por esa razón esta aplicación, y muchas más donde colocar una interfaz de usuario no aporte al
conocimiento que pretendemos, será una aplicación de consola.
Se utilizará lo realizado en el ejercicio anterior.
a) Creando una aplicación de Consola
1. Agregue un proyecto a la solución.

a. Seleccione el nodo principal de la solución Ejercicios.
Alfaomega 35
SYNAPS PREMIUM
b. Usando el menú de contexto, seleccione Add- New Project.

c. Seleccione lnstalled - Visual Basic - Windows - Console Application.
d. En Name, asigne HolaMundoCon. vb
e. Con ello aparecerá un programa básico de consola, dentro Code Editor.
Selector de sub-elementos
•
iiCG..-Q o·~·..,,
Module "uduld + D1visor de
• páneles
Sub Main(}
End Sub
1End ~ ule
1 •
Divisiun de prucedunienlus
Colorinq
Herramienta Para qué sirve Cómo se usa
Branching Para mostrar y ocultar partes de código. Al ocultar partes del código que no queremos ver,
podemos concentrarnos en los contenidos que si
queremos modificar.
Barras de Para desplazarnos rápidamente dentro del contenido Se arrastran las barras de desplazamiento en el
desplazamiento editado. sentido que queremos mostrar.
Coloring Para diferenciar los contenidos de forma visual. Ver los colores que asigna el editor nos ayuda a
distinguir cómo es que están siendo interpretadas las
palabras que colocamos, o si estamos utilizando
indebidamente palabras reservadas.
División de Para identificar claramente dónde comienza un En códigos muy largos resulta muy útil para
procedimientos procedimiento y donde termina otro. diferenciar divisiones importantes en el código.
Divisor de Para dividir la pantalla en dos, y poder estar viendo Se arrastra el Divisor de páneles hacia el centro, con
páneles dos partes diferentes del código, en forma simultánea. lo cual divide el área de edición, haciéndolas
independientes.
36 Alfa omega
SYNAPS PREMIUM
Selector de Permiten seleccionar de forma jerárquica los Se selecciona en el Selector de elementos un objeto
elementos y sub· contenidos, a fin de trasladar el cursor a las partes contenedor o base, y posteriormente se selecciona en
elementos. seleccionadas sin tener que identificarlas visualmente. el Selector de sub-elementos, el elemento asociado a
él que queremos ubicar.
lntellisense Capacidad del editor de intuir y autocompletar lo que Al estar escribiendo una palabra que el editor detecta
queremos escribir. como objeto o palabra reservada, la propone en
forma de menú. Si vemos que ha adivinado lo que
queremos escribir, no nos molestamos en escribir el
resto de la palabra, sino el carácter que le seguiría.
Sugerencia de En el caso de funciones y métodos que tienen Al tener una función o método con diferentes
parámetros polimorfismo y aceptan diferentes parámetros y implementaciones, al intentar proporcionarle
dependiendo de ello realizan diferentes cosas, el parámetros, nos sugiere el escenario más común, los
editor sugiere los diferentes escenarios de uso, con tipos de dato requeridos, y la acción que se realizara.
una breve explicación de tipos y utilidad. Usando flechas hacia arriba y hacia abajo, podemos
explorar los diferentes escenarios posibles que
permite la función o método.
Auto-Complete Cuando el editor detecta que se está utilizando una Escriba el código de inicio de un bloque o estructura
estructura o instrucción de bloque, completa el código de código, y el editor automáticamente proporciona
automáticamente. el código que falta.
Error Detection Señala visualmente las partes de código que causan Prestar atención en código subrayado por el editor,
error. Si se pone el cursor sobre el código señalado revisar el mensaje de error, y corregirlo.
con error, se muestra una descripción del error
detectado.
Error Correction El editor sugiere acciones correctivas para los errores

-
O Hacer die en el ícono de error, y seleccionar la
Options detectados. solución que más sentido nos haga.
b) Utilizando herramientas de Code Editor
2. Edite el código en orden, de tal manera que quede como sigue. Trate de utilizar las
funcionalidades de Code Editor, prestando atención en los siguientes momentos:
a. En la línea 4, cuando haya escrito «Con so», lntellisense le sugerirá la palabra completa,
que es «Consol e». En lugar de escribir la «1», escriba el «.» que es Jo que seguiría de la
palabra completa. lntellisense le sugerirá «Wri teline», por lo cual usted ya no se
molesta en escribirla, y escribe lo que seguiría, que es « ( ».
b. En la misma línea 4, al escribir el paréntesis, aparecerá un tool tip de sugerencia de
parámetros. Utilizando la flecha hacia abajo del teclado, busque la implementación en
donde value sea String. Analice la explicación, y termine de escribir la línea.
c. Cuando escriba la línea 7 se generará un error, porque se está invocando un
procedimiento que no existe. Vea cómo al poner la línea, el editor pone en
funcionamiento su característica de Error Detection, y subraya la línea de código
Alfaomega 37
SYNAPS PREMIUM
indicando un error. Coloque el puntero del ratón sobre la línea que marca error y vea el
mensaje de error que aparece en forma de tool ti p.
d. Utilice la funcionalidad de Error Correction Options, haciendo die en el ícono de error.
Aparecerán las soluciones propuestas. Seleccione una haciendo die (aparecerá un tool
tip que dice Apply Fix), con lo que se agregará el procedimiento que hace falta.
e. Modifique el código para que quede exactamente como sigue.
1 Module Module1
2
3 Sub Main ( )
4 Console .Write li ne( "Presione INTRO" )
S Console .Readl i ne()
6 Console . Wr ite l i ne( ''Hola Mundo'' )
7 Espera()
8
9 End Sub
1€1
11 Sub Espera()
12 Console .Writeline( " ... " )
13 Console .Readline()
14 End Sub
15 End Module
f. Juegue un poco con Code Editor. Compruebe Branching, analice Coloring, Divida en
páneles el área de trabajo, vea las divisiones de procedimientos, seleccione elementos y
sub-elementos, etcétera.
e) Depurando aplicaciones
3. Guarde su trabajo (CTRL+SHIFT+S)

4. Seleccione el nodo principal de HolaMundoCon.
a. Dado que la solución tiene varios proyectos, se recomienda que se especifique cuál de
los proyectos es el principal, o al menos con el que se debe iniciar las pruebas. Esto se
hace seleccionando la opción Set as Startup Project, en el menú de contexto.
38 Alfa omega
SYNAPS PREMIUM
b. Se construye el proyecto, seleccionando la opción Build del menú de contexto. Al hace

esto, se ejecuta la compilación del programa y el resultado aparecerá en Output
Window.
Output • J X
Show output from: 81.1ld •
·····- 8ulld started: Project: HolaMUndoCon, Confi¡uration: Debuc Any CPU ······ •
Hol~ndoCon ·> C:\Ustrs\ft~pe\docuoents\visual studio 2912 ,Projects\Ejtrclclos\1
•••••••••• Build: 1 succeeded 1 e f ailed 1 e up-to-date 1 e skipped ••••••••••
¡;
•
•
"' •
c. Si todo salió satisfactoriamente, se habrá creado el ensamblado del programa.
d. ~~ En la Barra de herramientas de Solution

Explorer, haga die en el ícono Show All Files,
para que se vea todo el contenido del proyecto. Surc.h S. lutiQI f ,..lorer f(trt ... )
e. Vea cómo en el directorio \Bin del proyecto, ya My PtCf«l

hay un programa de extensión . exe, que es el •
A
•1
-
Rcfcrcnca
b.n
ensamblado del programa. • !ltbuc¡
Ho&lt.lundoCon.txuorl'9
HoloMundoCol\l(lb
Holot.lundoCon.Y1ho>t.cn
f. Se ejecuta en modo de depuración, seleccionando HoliMundoCon."host eu.coofig
HoloMundoCon."'hosi,.•.J!Wlilat
Debug - Set new instance. HoloMundoCo""""l
~ --- oOj
O App~onfog
g. Con ello el programa se ejecuta. ~ .w Modulcl.vb
h. Presione INTRO dos veces, y vea lo que hace el

programa.
5. Es probable que después de depurar no encuentre Solution Explorer. No se preocupe,
puede ver la ventana presionando CTRL+ALT+L, o bien, haciendo die en la Pestaña
periférica correspondiente.
FIN DEL EJERCICIO *
Alfaomega 39
SYNAPS PREMIUM
~ Lab.02.03: Creando una solución, un proyecto y un programa.

En este ejercicio comprobará que ha aprendido a manejar soluciones y proyectos en Visual
Studio, que sabe codificarlo y probarlos.
1. Genere una solución llamada Mensaje.
2. A dicha solución, agréguele un proyecto de tipo Consola, llamado Espera.
3. Establezca el proyecto como proyecto de inicio.
4. Codifique lo necesario para que el programa muestre el mensaje «Esperando que se presione
una tecla», y que espere a que el usuario presione una tecla para continuar.
S. Depure su aplicación y asegúrese de que no se producen errores.
FIN DEL EJERCICIO *
40 Alfa omega
SYNAPS PREMIUM
Variables, arreglos y tipos de datos
Competencias:
1. Conocer qué son las variables y
los arreglos de memoria, y cómo
funcionan en .NET.
2. Conocer cómo se declaran las
variables de memoria,
especificando su alcance y
accesibilidad.
3. Conocer los tipos de datos
soportados por la plataforma
.NET y la forma en que se
realizan conversiones entre
datos.
Evaluaci6n:
l. Proporcionar un
algoritmo en donde se
plantee un problema Evidencia de
que requiera el uso de aprendizaje:
variables y arreglos, y 1. Capacidad de crear
validar que se está en aplicaciones en donde se
condiciones de utilizan arreglos y variables de
desarrollar el programa memoria, con un manejo de
correspondiente, tipos adecuado.
considerado strong -.-~......, 2. Capacidad de especificar
typing. alcances y accesibilidad, de tal
2. Proporcionar un manera que las variables
programa que deberá estén disponibles en el
ser analizado, para momento que son requeridas,
efecto de especificar el sin causar conflictos de
alcance y accesibilidad colisión.
adecuados para no
provocar error.
SYNAPS PREMIUM
3: Variables, arreglos y tipos de datos

3.1 ¡Qué son las Variables de memoria? ..................................................................................................... 43
3.2 Identificadores (Identifiers) .................................................................................................................... 43
3.3 Tipos de dato (Datatypes) ........................................................................................................................ 44
3.3.1 Conversión de datos ............................................................................................................................ 46
3.3.2 Conversión implícita (Casting) ....................................................................................................... 46
3.3.3 Conversión explícita ........................................................................................................................... 46
3.3.4 Conversión por método ..................................................................................................................... 4 7
3.4 Manejo eJe·mental de variables ............................................................................................................... 4 7
3.4.1 Declaración de variables ................................................................................................................... 47
3.4.2 Constantes .............................................................................................................................................. 49
3.4.3 Literales ................................................................................................................................................... 49
3.4.4 Valores por omisión ............................................................................................................................ SO
3.5 Alcance de las variables (Scope) ............................................................................................................ SO
3.6 Accesibilidad de las variables (Accesibility) ..................................................................................... 51
3.7 Arreglos ........................................................................................................................................................... 53
3.7.1 Ar·reglos unidimensionales .............................................................................................................. 54
3.7.2 Ar·reglos multidimensionales .......................................................................................................... SS
3.7.3 Arreglos esc.alonados ......................................................................................................................... S7
3.8 Dando formato con String.Format ........................................................................................................ 58
~ Lab.03.01: Variables, constantes y conversiones .............................................................................. 60
~ Lab.03.02: Comprobación de alcance .................................................................................................... 62
~ Lab.03.03: Arreglos unidimensionales, multidimensionales y escalonados .......................... 66
~ Lab.03.04: Creando programa strong typing con manejo de arreglos ...................................... 71
~ Lab.03.05: Especificando el alcance y la accesibilidad adecuadas .............................................. 72
42 Alfa omega
SYNAPS PREMIUM
Unidad 3: Variables, Arreglos y Tipos de Datos
3.1 ¡Q_ué son las Variables de memoria?

La memoria de las computadoras tiene un sistema de organización basado en posiciones de
memoria (memory locations), en las cuales se pueden almacenar programas y datos; cada
posición en memoria tiene una dirección física (physical address), la cual puede ser referida
para para recuperarlos contenidos.
Una variable de memoria es la referencia lógica a una posición física de memoria RAM. Por
medio de las variables podemos almacenar valores en la memoria, asignarles un nombre
determinado, y luego disponer del valor almacenado cuando lo necesitemos.
Las variables tienen las siguientes características:
1. Identificador (identifier). Es el atributo que identifica lógicamente las posiciones
en memoria, permitiendo además distinguir a una variable de otra.
2. Tipo de dato (datatype). Es el tipo de valor que podrá almacenar la variable,
mismo que determina el tratamiento interno que tendrá el valor, la cantidad en
bytes que consumirá en memoria, entre otras cosas.
3. Alcance (scope). Es el atributo que define la cantidad de código en que una varia-
ble puede ser utilizada, sin utilizar calificador; es el estado de existencia y la per-
sistencia del valor de la variable, en tiempo de ejecución.
4. Accesibilidad (accessibility). Es el permiso que se proporciona al código para
leer la variable o para escribir en la variable.
S. Tiempo de vida (lifetime). Es el periodo de tiempo de ejecución en el cual la va-
riable está disponible.
3.2 Identificadores (ldentifiers)

Se le llama identificador (identifier) al nombre lógico de un elemento de programación, por
medio del cual podrá ser referido.
Los identificadores deben cumplir con las siguientes reglas, al menos:
1. Deben iniciar con un caracter alfabético o con una línea baja ( _ ).
2. Sólo pueden contener caracteres alfabéticos, dígitos decimales, o línea baja.
3. Si inician con línea baja, al menos deben contener un dígito decimal o un caracter
alfabético.
4. No pueden contener espacios intermedios.
Alfaomega 43
SYNAPS PREMIUM
Recomendamos ampliamente que busque que el identificador de las variables sea: a) lo más
corto posible, b) significativo, y e) poco propenso a ambigüedades. Por ejemplo, si desea
guardar un número de mes, el nombre nm puede ser demasiado corto y ambiguo, Numero-
DeMes puede ser innecesariamente largo, mientras que NumMes es bastante balanceado.
3.3 Tipos de dato (Datatypes)

Las variables pueden almacenar cualquier tipo de dato.
El tipo de dato (Datatype) es el tipo de valor que podrá almacenar la variable, mismo que
determinará el tratamiento interno que tendrá el valor, la cantidad en bytes que consumirá
en memoria, y las operaciones que se podrán realizar con el mismo.
Al hablar de tipos de datos es necesario hablar de un concepto importante: se le llama do-
minio al conjunto de valores válidos para un dato. Para explicar el concepto, imagine que
deseamos almacenar el número de piso que se tiene en un hotel de 20 pisos.
Los tipos de dominio son 2:
1. Domino de tipo. Es el límite de valores determinado por el datatype seleccionado
para almacenar el dato. Para nuestro ejemplo, seleccionar un tipo de dato Byte, es
suficiente, ya que nos da un rango de O a 255 sin signo, donde claramente pode-
mos almacenar lo que queremos.
2. Dominio de regla de negocio. Son las reglas que la aplicación impone, y no son
inherentes al tipo de dato. En nuestro ejemplo, no obstante que podríamos alma-
cenar el valor 50 en un dato Byte, sería inexacto porque el hotel sólo tiene 20 pi-
sos; otro ejemplo de este tipo de regla es el siguiente: los hoteles no asignan el
número 13 a ningún piso, por cuestiones de superstición.
Siendo así, para nuestro ejemplo, el dominio de tipo sería números enteros sin signo, entre
O y 255, mientras que el domino de regla de negocio sería entero mayor a cero y menor o
igual a 21, y además, que no sea 13.
Al momento de crear variables, deberá seleccionar un tipo de dato, cuidando que el tipo
seleccionado tenga un dominio de tipo suficiente para almacenar sus datos con el menor
consumo de memoria.
44 Alfa omega
SYNAPS PREMIUM
Para una adecuada selección del tipo de dato, consulte la siguiente tabla que muestra Jos
tipos de datos que Visual Basic soporta:
Boolean Boolean Depende de la True 1 False

~lataforma {x86Lx64)
Byte Byte 1byte Oa 255
Char Char 2 bytes Oa 65535
Date DateTime 8 bytes 0:00:00 del1 de Enero de 0001 a

11:59:59 del 31 de Diciembre de 9999
Decimal Decimal 16 bytes Oa +/-79,228,162,514,2 7,593,543,950,335
(sin decimales)
Oa +/-7.9228162514264337593543950 335
Double Double 8 bytes Doble punto flotante.

-1.79769313486231570E+308 a-
4.94065645841246544E-324
(valores negativos)
4.94065645841246544E-324 a
1.79769313486231570E+308
lnteger Int32 4 bytes -2,147,483,648 a 2,147,483,647
Long Int64 8 bytes Entero largo.

-9,223,372,036,854,775,808 a
9,2
Object Object 4 bytes en plataforma Cualquier tipo.
x86,
8 bytes en plataforma
x64
SByte SByte 1byte -128 a 127
Short lnt16 2 bytes Entero corto.

-32,768 a 32,767
Single Single 4 bytes Punto flotante de precisión simple.

-3.4028235E+38 a -1.401298E-45
(valores negativos)
1.401298E-45 a 3.4028235E+38
(valores eosltivos)
String String Depende de la Oa 2 mil millones de caracteres
plataforma (x86fx64)
Ulnteger Ulnt32 4 bytes Oa 4,294,967,295
ULong Ulnt64 8 bytes Oa 18,446,744,073,709,551,615
User-Defined (Herencia de Depende de la La suma de los miembros que compongan

dato.
UShort Ulnt16 2 bytes Oa 65,535
(sin signo)
Alfaomega 45
SYNAPS PREMIUM
3.3.1Conversión de datos
En muchas ocasiones requerirá realizar conversiones de tipos de datos, principalmente de
datos String a otros tipos. Se conoce como conversión de datos al hecho de cambiar el tipo
de dato de un valor por otro. Se tienen tres formas de conversión de datos en Visual Basic.
3.3.2 Conversión implícita (Casting)

La conversión implícita, conocida como casting, se presenta cuando el CLR es capaz de reali-
zar la conversión en tiempo de ejecución, sin que el programa lo especifique. Este tipo de
conversión es común en los tipos de datos numéricos.
Hay un fenómeno que se conoce como narrowing, cuando la conversión se realiza de un tipo
con mayor dominio a uno de menor dominio (Integer pasando a Byte, por ejemplo); por
otro lado, se conoce como widening cuando la conversión se realiza de un tipo de menor
dominio a uno de mayor (Byte pasando a lnteger, por ejemplo). En el caso de narrowing,
hay que prestar mucha atención en no proporcionar datos que exceden el dominio de tipo,
por ejemplo, tratar de pasar 100000 (Integer) a 100000 (Short), dado que los datos pue-
den truncarse, e incluso provocar excepciones.
3.3.3 Conversión explícita

Se presenta conversión explícita cuando mediante código se aplican funciones específicas
que realizan la conversión. Principalmente se utiliza para convertir tipos StringjChar a
otros tipos. Las principales funciones específicas utilizadas son las siguientes.
Función Consecuencia
CBool (Expresión) Convierte Expresión a Boolean.
CByte (Expresión) Convierte Expresión a Byte.
CChar(Expresión) Convierte Expresión a Char.
COa te (Expresión) Convierte Expresión a Date.
CDbl (Expresión) Convierte Epesión a Double.
CDec (Expresión) Convierte Epesión a Decimal.
Cint (Expresión) Convierte Expresión a lnteger.
CLng (Expresión) Convierte Expresión a Long.
CObj (Expresión) Convierte Expresión a Object.
CShort (Expresión) Convierte Expresión a Short.
CStr(Expresión) Convierte Expresión a String.
46 Alfa omega
SYNAPS PREMIUM
La principal función de conversión genérica es CType, cuya sintaxis es la siguiente.
CType (Expresión, NombreTípoDato)
Donde Expresión es la expresión a convertir, y NombreTipoDato es el nombre del tipo de

dato al que se desea convertir la expresión.
Ejemplo.
CType C(4", Integer)
3.3.4 Conversión por método

Algunos tipos de datos, por ejemplo la mayoría de los numéricos, tienen implícito un méto-
do que permite hacer una conversión de datos. El más común de estos métodos es el méto-
do ToString, que permite convertir a la representación String un valor dado.
Ejemplo.
Dim Edad As Integer = 38
Dim EdadTexto As String = Edad.ToString()
En este caso, se declara una variable llamada Edad, de tipo Integer, a la cual se le asigna el
valor de 30. Después se declara una variable llamada EdadTexto que tomará la representa-
ción String de la variable Edad, es decir "30".
3.4 Manejo elemental de variables
3.4.1 Declaración de variables

Para poder utilizar una variable, es necesario declararla; declarar una variable es el proceso
mediante el cual se establece un identificador, que será reconocido en tiempo de ejecución,
para almacenar uno o más valores de un determinado tipo.
No se pueden utilizar variables que no hayan sido declaradas previamente.
La declaración de una variable se lleva a cabo a través de la instrucción de declaración: Dim.
Alfaomega 47
SYNAPS PREMIUM
La sintaxis más sencilla de Dim es la siguiente:
Dim Identificador [As TipoDato] [ = Valorlnicial]
Donde Identificador es el nombre que se desea asignar a la variable, y TipoDato es el tipo de

dato que corresponde al valor que almacenaremos en la variable. En .NET es posible asignar
un valor al momento de la declaración (Valorlnicial).
La especificación del tipo de dato a través de la palabra reservada As es opcional; si se omi-
te la especificación de tipo de dato, la variable se declara automáticamente bajo el tipo Ob-
ject. Esta declaración automática garantiza que no se utilice una variable que no ha sido
declarada, sin embargo, es lo más ineficiente, ya que todo el tiempo CLR tendrá que invertir
tiempo en determinar qué tipo de valor es el que está almacenado en la variable.
A continuación se muestran ejemplos de declaración de variables:
1 Dim Edad
2 Di m Edad As Integer
3 Di m Edad As System . Int32
4 Di m Edad As Integer = 58
5 Di m Nombre, Apellido As String
6 Di m Nombre, Apellido As String, Edad As Integer
Hacen lo siguiente:
1. La línea 1 declara una variable Object.
2. La línea 2 declara una variable lnteger.
3. La 3 es exactamente igual a la línea 2, ya que Integer es la referencia a Sys-
tem.Int32 de .NET Framework.
4. La línea 4, además de declarar la variable, le asigna un valor de inicio.
S. La línea S demuestra que se pueden declarar varias variables de un mismo tipo,
separando los identificadores por comas.
6. La línea 6 demuestra que Dim soporta la declaración de dos o más variables de un
mismo tipo, y de dos o más tipos.
48 Alfa omega
SYNAPS PREMIUM
3.4.2 Constantes
Se conoce como constantes a las variables que sólo cambiarán su valor una vez en su tiempo
de vida. Para definirlos se utiliza la siguiente sintaxis.
Const Identificador [As TipoDato] - Va/orinicial
Donde Identificador es el identificador de la constante, TipoDato es el tipo de dato que ten-

drá la constante, y Valorinicial es el valor que tendrá la constante durante todo su tiempo de
vida.
Ejemplo de uso:
Const PI As Single - 3.1416
3.4.3 literales
Si se menciona un número 4, no tenemos suficiente información para saber si el número es
Byte, Integer, Double, Decimal, dado que 4 puede ser de cualquiera de esos tipos. Lo mis-
mo ocurriría con "A", dado que no sabríamos si se trata de un dato String o Char.
Se tienen literales que permiten definir un valor, liberándolo de las ambigüedades de tipo
que pudiera tener.
Las literales son las siguientes:
Type Literal ~emplo de uso
Boolean True True
False False
Char e "AJJC
Decimal D 3.14160
Double R 3.1416R
Integer I 18I
Long L 18L
Short S 185
Single F 3 .14F
String u u
"AJJ
Alfaomega 49
SYNAPS PREMIUM
3.4.4 Valores por omisión

Cada variable, en caso de que no se le asigne un valor, tendrá un valor por omisión. A conti-
nuación se muestra una relación de los valores por omisión para los tipos de datos.
Tipo de dato Valor por omisión
Tipos de datos numéricos e
Boolean False
Date e11el/eee1 12:ee A.M .
Decimal e
Object Nothing
( (JJ
String
3.5 Alcance de las variables (Scope)

El alcance (scope) de las variables determina en qué partes del código podrá ser utilizada
una variable sin utilizar un calificador.
Para entender el alcance debemos entender antes el concepto de bloque de código: Un blo-
que de código (code block) es el conjunto de líneas de código que constituyen una unidad de
ejecución. Generalmente se encuentran delimitados por una línea de inicio y una línea de
conclusión, a lo que se conoce como branching; todas las instrucciones que culminen con
End son delimitadores de bloque de código (Module - End Module, Sub - End Sub, If -
End If, etcétera).
Existen otras instrucciones, como For - Next y Do - Loop, que aunque no concluyen con
End, también contienen bloques de código. Los bloques pueden ser condicionales y no con-
dicionales. Son bloques condicionales cuando su ejecución depende de el valor obtenido al
resolver una expresión lógica (If - End If, Do - Loop, por ejemplo), mientras que son
bloques no condicionales aquellos que no dependen de una evaluación para ejecutarse (Mo-
dule - End Module, Namespace - End Namespace, por ejemplo).
Un aspecto importante a tomar en cuenta es que un bloque de código puede formar parte
de otro bloque de código.
Se tienen los siguientes alcances:
1. Al can ce d e bl o que (Block scope). El alcance de bloque se presenta cuando la
variable sólo está disponible en el bloque de código en el que está declarada. El al-
cance de bloque es el más estrecho, en el sentido de que la variable tiene la menor
vigencia posible. Cómo se define : declarando la variable dentro de un bloque de
código.
50 Alfa omega
SYNAPS PREMIUM
Este tipo de alcance aplica para los siguientes estatutos.

• Do-Loop
• For [Each]-Next
• If-End If
• Select-End Select
• Synclock-End Synclock
• Try-End Try
• While-End While
• With-End With
2. Al ca n ce d e pr oce dimiento (Procedure scope). El alcance de procedimiento

se presenta cuando la variable está sólo disponible para el procedimiento en el
que está declarada. Cuando las variables sólo pueden ser utilizadas dentro del
procedimiento que las declara, reciben el nombre de variables locales. Cómo se
define: declarando la variable dentro de un procedimiento, pero no dentro de un
bloque; se recomienda declarar al inicio del procedimiento, antes de cualquier
bloque de código.
3. Al ca n ce d e m ó dulo (Module scope). El alcance de módulo se presenta cuando
la variable está disponible para todos los procedimientos de un determinado mó-
dulo, clase o estructura en la que está declarada. Cómo se defin e: declarando la
variable dentro del capítulo, clase o estructura, antes de declarar cualquier proce-
dimiento.
4. Al ca n ce d e es p ac i o d e n o mbre s (Namespace scope). El alcance de espacio
de nombres se presenta cuando la variable está disponible para todos los módu-
los, clases o estructuras contenidas en un espacio de nombres. Este alcance es el
de mayor amplitud. Cómo se define: declarando una variable a nivel módulo, con
accesibilidad Friend o Public (que verá más adelante).
3.6 Accesibilidad de las variables (Accesibility)

La accesibilidad (accesibility) de una variable es el permiso que se proporciona al código
para leer o modificar el contenido de una variable. El concepto de accesibilidad, junto con el
concepto de alcance, determinan la disponibilidad real de una variable para su uso a través
de código.
Los diferentes modificadores que se tienen de accesibilidad son:
Alfaomega 51
SYNAPS PREMIUM
1. Pu blic. Conocidas como variables públicas. Proporciona acceso público a la va-

riable; no hay restricciones de uso de la variable cuando se define como pública.
Sólo se puede definir a nivel módulo, espacio de nombres, o archivo físico; nunca a
nivel procedimiento. Estas variables pueden ser utilizadas por clases diferentes a
la clase en la que están declaradas.
2. Protected. Conocidas como variables protegidas. Proporcionan acceso protegi-
do a la variable, es decir, sólo pueden ser utilizadas por la clase en que se declaró
la variable, o en aquellas clases derivadas de ésta. Sólo se puede definir a nivel
clase, nunca a nivel procedimiento.
3. Friend. Proporcionan acceso que asume confianza hacia el usuario (de ahí lo
"amistoso"); pueden ser utilizadas por el programa que la declara, y por todos
aquellos que se encuentren en el mismo ensamblado. Sólo se puede definir a nivel
módulo, espacio de nombres, o archivo físico; nunca a nivel procedimiento.
4. Protected Friend. Proporciona la unión de restricciones de Protected y de
Friend.
S. Private. Conocidas como variables privadas. Proporciona acceso privado a una
variable. Sólo están disponibles para el alcance en el que fueron declaradas. Sólo
se puede definir a nivel módulo, espacio de nombres, o archivo físico; nunca a ni-
vel procedimiento. Sólo pueden ser utilizadas en las clases en las que son declara-
das.
6. Static. Conocidas como variables estáticas. Permite incrementar la persistencia
del valor de las variables, manteniendo el último valor que haya asumido, aún
después de la terminación del procedimiento que la declaró. Sólo se puede definir
a nivel procedimiento. No se pueden declarar variables estáticas en Jos procedi-
mientos de una estructura; sólo aplican para los procedimientos de clases. Sta-
tic es muy similar a una variable Public; se diferencian en el lugar en donde se
declaran. En cierta forma, las variables Static serían como variables públicas de-
claradas en los procedimientos.
7. Shared. Conocidas como variables compartidas. Indica que la variable es com-
partida, lo que significa que no está asociada con la instancia de una clase o es-
tructura determinada. Se puede acceder a una variable compartida a través de un
calificador (anteponer al nombre de la variable el nombre de la clase en donde se
declaró inicialmente, más un punto separador). Sólo se puede definir a nivel capí-
tulo, espacio de nombres, o archivo físico; nunca a nivel procedimiento. Las varia-
bles compartidas (shared variables) identifican una sola unidad de almacenamien-
to, sin importar cuántas instancias de la clase que la declara hayan sido creadas;
cuando una variable no es definida como compartida, se dice que es una variable
de instancia (instance variable), y cada instancia mantendrá la referencia de su
propio valor. Este tipo de variables son especialmente útiles para trasladar valo-
52 Alfa omega
SYNAPS PREMIUM
res de un formu lario a otro, en aplicaciones de formularios múltiples, ya que no

basta con que las variables sean públicas.
8. Rea dOnl y. Especifica que se trata de una variable de sólo lectura.
Si no se especifica alguna opción de accesibilidad, las variables serán variables de instancia

y privadas (instance variable, prívate).
En caso de que se desee asignar alguna opción de accesibilidad, la especificación pasa a ser
el estatuto de declaración, y puede sustituir a Dim.
Ejemplo.
Static Dim Edad As Integer
Es lo mismo que:
Static Edad As I nteger
3.7 Arreglos
Se conoce como arreglos (arrays), también llamados matrices en algunos casos, a un conjun-
to de posiciones en memoria que son referidas por un mismo identificador.
La forma de acceder a un dato almacenado en una posición de memoria dentro de un arre-
glo es a través de un subíndice, que es la posición secuencial de cada elemento dentro de la
colección. Los subíndices, como en todos los lenguajes de .NET, son de base cero, es decir,
que inician de cero en adelante.
En Visual Basic, los arreglos tienen un tratamiento de colecciones, por lo cual los subíndices
siempre se especifican entre paréntesis. Las colecciones son conjuntos de objetos lógica-
mente relacionados, diferenciados por un subíndice.
En su calidad de colecciones, pueden ser explorados con la instrucción For Each, cuya sin-
taxis es la siguiente.
For Ea eh Elemento [As TipoDato] I n Colección

BloqueCódigo
[Exit For]
Next
Alfaomega 53
SYNAPS PREMIUM
Donde Elemento es la variable de trabajo en donde se almacenará el elemento (TipoDato),

que de no especificarse asumirá el mismo tipo de dato que tengan los elementos de la colec-
ción. Colección es la colección de objetos que podrán ser leídos de forma secuencial utili-
zando For Each. BloqueCodigo es el bloque de código que se ejecutará de forma iterativa
para cada elemento de la colección explorado. Al encontrar Next el proceso iterativo co-
mienza nuevamente; es posible interrumpir el ciclo en cualquier momento, utilizando Exi t
For.
3.7.1 Arreglos unidimensionales

Los arreglos unidimensionales se conocen simplemente como arreglos, y requieren de un
sólo subíndice para tener acceso a un elemento del arreglo. La forma de declarar un arreglo
en Visual Basic es la siguiente.
Dim Arreglo(MáximoSubíndi ce) As TipoDato
Donde Arreglo es el identificador del arreglo; su nombrado sigue las mismas reglas que las
variables. MáximoSubíndice es el número mayor de subíndice del arreglo, y TipoDato es el
tipo de dato de los elementos del arreglo.
Ejemplo.
Dim VentaMensual(ll) As Integer
En este caso se tiene un arreglo de 12 posiciones (O a 11), donde los elementos son de tipo
Integer.
En caso de que no se especifique un número determinado de elementos, el arreglo será de
un número indeterminado de elementos.
Dim VentaMens ual() As I nteger
A este tipo de arreglos se les llama arreglos unidimensionales, pues únicamente es necesario
especificar un subíndice para tener acceso a una posición en memoria del arreglo.
También es posible asignar valores al momento de declarar un arreglo. En ese caso, no se
deberá especificar número de elementos, ya que el número de elementos se calculará au-
54 Alfa omega
SYNAPS PREMIUM
tomáticamente considerando el número de valores que se especifiquen entre llaves ({ }),

separados por comas (,). La sintaxis sería la siguiente.
Dim Arreglo() As TipoDato - {SerieValores}
Donde Arreglo es el nombre del arreglo, TipoDato es el tipo de dato de los elementos, y Se-
rie Valores es la serie de valores que asumirán los elementos; los valores deberán estar se-
parados por comas.
Ejemplo.
Dim Numeras() As Int eger - {1e,2e,4e,1ee}
Numeros
En este caso, Numeros( l ) tendrá el valor de 2e.
3.7.2 Arreglos multidimensionales

Se conoce como arreglos multidimensionales, a un conjunto de posiciones en memoria que
son referidas por un solo identificador, a través de dos o más subíndices.
Al número de subíndices que es necesario especificar para tener acceso a una posición de
memoria de un arreglo se le llama dimensionalidad (dimensionality), o rango (rank); Visual
Basic acepta hasta 32 dimensiones.
A los arreglos de dos dimensiones (dimensionalidad 2), que son los multidimensionales
más utilizados, se les da el nombre de arreglos rectangulares. La sintaxis para definirlos es
la siguiente.
Dim Arreglo(MSl, MS2, . . . ,MSn) As Ti poDato
variables. MSl es el número mayor de subíndice para la dimensión 1, MS2 es el número ma-
Alfaomega 55
SYNAPS PREMIUM
yor de subíndice para la dimensión 2, y así hasta definir todas las dimensiones. TipoDato es
el tipo de dato de Jos elementos del arreglo.
Ejemplo.
Dim VentaTrim(2,3) As Integer
En este caso se tiene un arreglo de 12 posiciones (de Oa 2, 3 posiciones; de Oa 3, 4 posicio-

nes; 3 posiciones x 4 posiciones=12), donde Jos elementos son de tipo lnteger.
En caso de que no se especifique un número determinado de elementos, el arreglo será de
un número indeterminado de elementos.
Dim VentaTrim(,) As Integer
A este tipo de arreglos se les llama arreglos multidimensionales, pues sólo es necesario es-
pecificar un subíndice para tener acceso a una posición en memoria del arreglo.
También es posible asignar valores al momento de declarar un arreglo. En ese caso, no se
deberá especificar número de elementos, ya que el número de elementos se calculará au-
tomáticamente considerando el número de valores que se especifiquen entre llaves ({}),
separados por comas (,). Cada llave constituye la serie de valores para una dimensión. La
sintaxis sería la siguiente.
Dim Arreglo(,) As TipoDato = {{SerieValores1}, {SerieValores2}}
Donde Arreglo es el nombre del arreglo, TipoDato es el tipo de dato de los elementos, y Se-
rieValores1 y SerieValores2 es la serie de valores que asumirán los elementos; los valores
deberán estar separados por comas.
Ejemplo.
Dim VentaTrim(,) As Integer- {{1eee,2eeee,1eeee,se ee}, _

{2eee,3eeee,1seee,2eee }}
56 Alfaomega
SYNAPS PREMIUM
VentaTrim
30000
En este caso, VentaTrim(lJ 2) tendrá el valor de 1seee.
3.7.3 Arreglos escalonados

Se conoce como arreglos escalonados Uagged arrays) a un arreglo que almacena arreglos. La
sintaxis para su definición sería la siguiente.
Dim Arreglo () () As Tipo Dato
variables. Dependiendo el número de arreglos que se desee incluir, se deberán agregar pa-
res de paréntesis con posterioridad al nombre de variable. TipoDato es el tipo de dato que
tienen los elementos en los arreglos.
Ejemplo.
Dim Numeras()() As Byte
En este caso se tiene un arreglo que almacenará dos arreglos, donde los elementos son de
tipo Byte.
También es posible asignar valores al momento de declarar un arreglo. En ese caso, los va-
lores son definiciones de arreglos.
Dim Arreglo()()As TipoDato = {ArreglolJArreglo2}
Donde Arreglo es el nombre del arreglo, TipoDato es el tipo de dato de los elementos, y
Arreglol y Arreglo2 son arreglos con elementos que son TipoDato; los arreglos deberán es-
tar separados por comas.
Ejemplo.
Alfaomega 57
SYNAPS PREMIUM
Dim Numeras()() As Byte - { Byte(){le, 15,12, 11}, _

Byte() {4e, se,Ge} }
Numeros
Numeros1
En este caso, Numeras (e) ( 3) tendrá el valor de 11. Estaríamos extrayendo, del arreglo O, el
elemento 3. El primer subíndice proporcionado indica el número de arreglo del que se trata,
mientras que el segundo subíndice indica el o los subíndices del elemento que queremos
extraer. Un arreglo escalonado puede contener arreglos unidimensionales o multidimen-
sionales.
Los arreglos escalonados no son lo mismo que los arreglos multidimensionales; estos últi-
mos pueden llegar a consumir cantidades muy grandes de memoria. Por ejemplo, si se quie-
re almacenar en un arreglo el número de identificación de 1000 empleados y S números de
categorías de empleados, un arreglo multidimensional ocuparía 1000 x S posiciones de
memoria, es decir, SOOO; un arreglo escalonado, por el contrario, requeriría sólo 1000 + S,
es decir, 100S. Si el arreglo fuera de datos Long (8 bytes), la diferencia en consumo de me-
moria sería de 31,960, que bien podría economizar.
Una cosa importante a tomar en cuenta es que los arreglos escalonados no forman parte de
CLS, por lo que sólo trabajarán adecuadamente en implementaciones Microsoft, y no en
otras plataformas que implementen considerando CLS como base.
3.8 Dando formato con String.Format

En muchas ocasiones tendremos datos que queremos mostrar de alguna manera, general-
mente en formato String.
Imagine que tiene una cantidad de 404S67.00, que quiere expresar en formato de moneda
($404,S67.00) ¿Cómo le haría? Ahora imagine una fecha en sus diferentes variantes, y la
cosa puede ponerse difícil.
58 Alfa omega
SYNAPS PREMIUM
Afortunadamente, .NET provee una clase denominada String, que posee el método For-
mat.
Su sintaxis básica es la siguiente:
String.Format("{0:formato} », v)
El número entre llaves es un índice de valor, formato es un carácter que indica el formato
deseado, mientras que ves el valor a darle formato. En nuestro ejemplo:
String.Format("{0:C}», 404567.00) -+ $484,567.08
Los índices de valor nos permiten hacer salidas más complicadas:

String.Format("Saldo: {0:C}», 404567.08) -+ $484, 567.00
Es posible manejar varios valores. Sólo basta colocar después de la expresión inicial, la serie
de valores separados por comas. El primer valor de la lista será el índice O, el segundo 1, y
así. Cabe aclarar que el orden de los valores no necesariamente implica el orden en el que
los índices de valor deben aparecer.
String.Format("{l:C} de {0:C} es el {2:P}», 200, 20, (20/200) )
-+ $20.00 de $200.00 es el 10.00%
Los códigos más comunes de formato son los siguientes (para expresiones de tipo numéri-
co):
e Currency
D Decimal
E Scientific
F Fixed point
G General (Default, si se omite formato {v})
N Number
p Percent
R Round-trip
X Hexadecimal
Alfaomega 59
SYNAPS PREMIUM
Los códigos más comunes de formato son los siguientes (para expresiones de tipo fecha):
d Short date
D Long date
t Short time
T Long time
f Full date/short time
F Full date/long time
g General date/short time (Default, si se omite formato {v})
G General date/long time (Default, si se omite formato {v})
M Month
R RFC1123
S Sortable
u Universal sortable
u Universal sortable
y Year
~ lab.03.01: Variables, constantes y conversiones.

En este ejercicio se utilizará una aplicación de consola para comprobar la declaración y uso
de variables en un proceso.
1. Trabaje sobre la solución Ejercicios.
2. Agregue a su solución un nuevo proyecto: lnstalled - Visual Basic - Windows -
Console Application.
3. Asigne como nombre AreaRectangulo
4. Edite el programa de tal forma que aparezca como sigue.
60 Alfa omega
SYNAPS PREMIUM
1 Module Module1
2
3 Sub Main()
4 Const Titulo As String = " Rectángulo "
5 Dim Base As Integer
6 Dim Altura As Single = 0
7 Dim Resultado As Single , Entrada As String
8
9 Console .Writeline(Titulo)
10 Console .Write( ''Base: '' )
11 Entrada = Console .Readline()
12 Base = Cint (Entrada)
13 Console .Write( ''Altura: '' )
14 Entrada = Console .Readline()
15 Altura = CType(Entrada, Single )
16
17 Resultado = (Base * Altura)
18 Console .Writeline( ''Resultado: '' & Resultado.ToString())
19
20 Console .Writeline( ''Pulse Intro'' )
21 Console .Readline() End Sub
22
23 End Module
S. Seleccione el nodo principal de AreaRectangulo en Solution Explorer, y

establezca el proyecto como proyecto de inicio, seleccionando Set as StartUp
Project en el menú de contexto. Cuando lo haga, podrá percatarse del cambio que
ha realizado, pues el nodo principal del proyecto aparecerá en negritas.
6. Inicie la depuración para comprobar el comportamiento de su programa (FS).
7. La línea 4 declara una constante, a la cual se le asigna como valor el mensaje que
ha de aparecer como encabezado del programa (línea 9); en la línea S se muestra
una declaración de variable, en su forma más sencilla; en la línea 6 se comprueba
que es posible asignar un valor inicial al momento de la declaración; en la línea 7
se comprueba la posibilidad de declarar múltiples variables de múltiples tipos en
una misma línea; esta última práctica no se recomienda, por cuestiones de
claridad en el código.
8. En la línea 9 se muestra el título del programa en la consola. En la línea 10 se
muestra el mensaje que pregunta la base del rectángulo, y en la línea 11 se asigna
a la variable Entrada el valor que el usuario ingresa desde la consola.
9. Como el dato se recibe en formato String desde la consola, la línea 12 se encarga
de convertir el dato String en Integer, utilizando para ello la función específica
Cint; el resultado es asignando a la variable Base. La misma mecánica se seguirá
Alfaomega 61
SYNAPS PREMIUM
para preguntar y convertir la altura del rectángulo, con la diferencia que se

utilizará para la conversión la función genérica CType.
10. La línea 17 calcula el área del rectángulo, asignando el valor a la variable
Resultado. Como resultado es de tipo Single, posee de forma intrínseca el
método ToString, que es utilizado en la línea 18 para mostrar los resultados.
11. Todas las conversiones que realizamos en este programa pudieron haberse
obviado, dado que el programa no es type saJe. En caso de no haber nosotros
resuelto las conversiones de manera explícita, CLR hubiera realizado el casting.
12. Proporcione un valor de 10 para la base y un 15 para la altura, y vea los
resultados.
Si todo ocurrió como se esperaba, la salida será la siguiente:
FIN DEL EJERCICIOJ*
~ lab.03.02: Comprobación de alcance

En este ejercicio se comprobará la forma en que funcionan los alcances de variables en
Visual Basic, y la forma en que podemos aprovechar su manejo para preservar valores en
memoria con eficiencia.
62 Alfa omega
SYNAPS PREMIUM
3. Asigne como nombre Alcance

1 Option Explicit On
2 Option Strict On
3
4 Module Modulel
S Dim Textol As String - "Alcance módulo"
6
7 Sub Main()
8 Console .Writeline(Textol)
9 Dim Texto2 As String = ''Alcance procedimiento''
19 If Texto2 <> '''' Then
11 Console .Writeline(Texto2)
12 Dim Texto3 As String = ''Alcance block''
13 Console .Writeline(Texto3)
14 End If
15 Procedimiento!{)
16 Procedimiento!{)
17 Procedimiento!{)
18 Procedimiento2{)
19 Console .Writeline( '' '' )
29 Console .Write{ "Pulse INTRO para continuar" )
22 End Sub
23
24 Sub Procedimiento!()
25 Static Texto4 As String
26 Texto4 = "Valor + " & Texto4
27 Dim TextoS As String = "Texto 5"
28 Console .Writeline( ''--Procedimiento 1 ----'' )
29 Console .Writeline( "Texto 1: " & Textol)
39 Console .Writeline( "Texto 4: " & Texto4)
31 Console .Writeline( "----------------------" )
32 End Sub
33
34 Sub Procedimiento2{)
35 Console .Writeline( ''--Procedimiento 2 ----'' )
36 If Texto1 <> '''' Then
37 Dim Textol As String = "Shadow"
39 End If
41 Console .Writeline( ''----------------------'' )
42 End Sub
43
44 End Module
Alfaomega 63
SYNAPS PREMIUM
S. Seleccione el nodo principal de Alcance en Solution Explorer, y establezca el

proyecto como proyecto de inicio.
7. Este programa es type safe, dado que todas las variables deberán declararse antes
de ser utilizadas (Option Explicit) y las conversiones tienen que hacerse de
forma explícita (Option Strict). Esto se logra agregando las líneas 1 y 2, antes
de hacer la definición del módulo.
8. Se declaran variables con diferente alcance en las líneas S, 9, y 12. En la línea S se
declara la variable Textol; esta variable tiene un alcance a nivel módulo, debido a
que se declara dentro del módulo, fuera de cualquier procedimiento.
Esta variable podrá ser utilizada por todos los procedimientos del módulo, es
decir, Main(), Procedimientol (), y Procedimiento2(); esto se comprueba
en la líneas 8 y 29, pues se despliega en la consola una variable no definida en
esos procedimientos.
En la línea 9 se declara la variable Texto2, que tiene un alcance a nivel
procedimiento, por estar declarada dentro de un procedimiento específico, pero
fuera de un bloque de código; por esa razón se trata de una variable local. Esta
variable estará disponible sólo para Ma in (), pero no para otros procedimientos.
En la línea 12 se declara la variable Texto3, que tiene un alcance a nivel bloque de
código, y estará disponible desde que se declara (línea 12) hasta que se encuentre
el estatuto que marca el final del bloque de código, en este caso End If, en la
línea 14.
Si se trata de utilizar la variable Texto3 después de la línea 14, pensando que es
una variable local (de alcance a nivel procedimiento), nuestro programa generará
error, ya que la variable sólo existe declarada para el bloque en que se declara.
9. Comprobando la variable estática. En la línea 1S se manda ejecutar
Procedimientol (); en dicho procedimiento se define una variable estática
llamada Texto4 (línea 2S). Esta variable tendrá un tiempo de vida que excede el
tiempo de vida del procedimiento que la declara, ya que por ser estática,
mantendrá los valores en memoria aun concluida la ejecución del procedimiento.
En la línea 26 se asigna a Texto4la constante String Valor+ que se concatenará
con el valor que tenga la misma Texto4; en virtud de que la variable es estática, el
valor que va adoptando se comporta como un acumulador, que nunca pierde el
valor que tenía, obtenido de procesamientos anteriores.
64 Alfa omega
SYNAPS PREMIUM
Las líneas 16 y 17 mandan ejecutar Procedimientol(), a fin de que se

compruebe que efectivamente la variable mantiene su valor al correr de las
múltiples ejecuciones del procedimiento.
10. Es posible definir dos variables con el mismo identificador en un mismo
programa, siempre y cuando no tengan el mismo alcance; a esta capacidad se le
llama shadowing. Ya vimos que en la línea S Textol se definió con un alcance a
nivel módulo, y al momento de declarar la variable se le asignó el valor Alcance
módulo. En Procedimiento2( ), se vuelve a definir la variable Textol (línea 37),
y se le asigna al momento de declaración el valor Shadow.
11. a) ¿Qué alcance tiene la variable Textol, declarada en la línea 37?
b) ¿Qué valor posee Textol, cuando es desplegada en la consola en la línea 38?
e)¿ Qué valor posee Textol, cuando es desplegada en la consola en la línea 40?
Como podrá darse cuenta, el programa no genera conflicto con la doble

declaración de la variable; simplemente utiliza aquella que tenga menor alcance.
Alfaomega 65
SYNAPS PREMIUM
12. Modifique la línea 21, sustituyendo el estatuto de declaración Static por Dim.
Ejecute el programa nuevamente, y explique qué sucede:
FIN DEL EJERCICIO *
~ lab.03.03: Arreglos unidimensionales, multidimensionales

y escalonados.
En este ejercicio se comprobará la forma en que funcio nan los alcances de variables en
3. Asigne como nombre Arreglos
66 Alfa omega
SYNAPS PREMIUM
2 Option Strict On
3
4 Module Module1
S
6 Sub Main()
7 Dim i As Integer
8
9 Console .Writeline( ''Arreglo unidimensional 1:'' )
10 Dim Uni1() As Integer = {22, 49, 2e, 4e}
11 For Each i In Uni1
12 Console .Writeline(i)
13 Next
14 Console .Writeline( ''Arreglo unidimensional 2:'' )
15
16 Dim Uni2() As Integer = {55, 66, 77}
17 For Each i In Uni2
18 Console .Writeline(i)
19 Next
20
21 Console .Writeline( ''Arreglo multidimensional:'' )
22 Dim Multi(,) As Integer = {{92, 49}, {44, 2e}, {10, 48}}
23 Console .Writeline( _
24 String .Format( ''Fila e: {e},{1} '' , Multi{e, e), Multi{e, 1)))
26 String .Format( ''Fila 1: {e},{1} '' , Multi{1, e), Multi{1, 1)))
28 String.Format( ''Fila 2: {e},{1} '' , Multi{2, 0), Multi{2, 1)))
29
30 Console .Writeline( ''Arreglo escalonado:'' )
31 Console .Writeline( ''Arreglo 1, posición 2'' )
32 Dim Esca()() As Integer = {Uni1, Uni2}
33 Console .Writeline(Esca(1)(2))
34
35 Console .Write( ''Presione INTRO'' )
37 End Sub
38
39 End Module
S. Seleccione el nodo principal de Arreglos en Solution Explorer, y establezca el

proyecto como proyecto de inicio.
Alfaomega 67
SYNAPS PREMIUM
7. En la línea 10 se declara un arreglo unidimensional, llamado Unil, y al mismo

tiempo que se declara se le asignan valores a las posiciones de memoria del
arreglo. Se trata de un arreglo de 4 posiciones de memoria, por lo que sus
subíndices irán de Oa 3.
~~---·----· ·······-· -·,
22 1
~-- -··-· ....··-· ..··-·- · .. -1
¡
1
1 49 1
•........................................................ ""l•
20 1
........................... l
40 1
1
......................................... ......... _.o
En la línea 11 se inicia una estructura For Each que permitirá hacer una lectura
de los valores almacenados en el arreglo. La estructura utilizará la variable i que
es de tipo lnteger, para trabajar cada uno de Jos elementos del arreglo Unil. La
estructura For Each comenzará una lectura secuencial de todos los elementos,
desde el subíndice O hasta el 3; i asumirá el valor del elemento que se esté
leyendo en el momento, por Jo que trabajar con i es como estar trabajando con el
elemento del arreglo. La línea 12 provoca que se vea en la consola el contenido de
cada una de las posiciones en memoria.
8. La línea 16 declara un arreglo unidimensional de tres posiciones, llamado Uni2,
que será utilizado junto con Unil más adelante. El proceso para el mostrado de
contenido se repite con Uni2. Sus valores son los siguientes.
··--·- ---····-·----·,
SS j
....·····-- ............................................._.
66 1
. . . . . . . . . . . . . . . . . . . . . . . . . . . . .J
! 77 ¡'
1
''
I ....................................................... ..J ''
9. En la línea 22 se declara un arreglo multidemensional, llamado Mul ti, constituido

por dos dimensiones. Se asignan valores al momento de la declaración, que nos
indican que el arreglo será de dos columnas y tres filas. Vea cómo el número de
series de valores determina el número de filas, mientras que el número de
elementos de cada serie de valores determina el número de columnas.
,---···-················9-z-r--------- 49-l
...................................................
'
_.__
.
1 ___________________
1
441 20 1
¡··-······-············-·····-+-----------~
1
1
!1............_ .. ___________________:.__
10 i 48 •i:
68 Alfa omega
SYNAPS PREMIUM
Las líneas de la 23 a la 28 se encargan de mostrar los valores que componen cada

fila. Para ello nos apoyamos de la función String. Format, que hace una
sustitución directa de parámetros; vea cómo funciona.
String . Format("Primer valor {e} segundo valor {1}" 1 le 1 2e)
Generaría como resultado:
((Primer valor le segundo valor 2e"
Los parámetros se incluyen con base O, y deberá proporcionarse una serie de

valores separados por comas después del String que queremos construir. El
primer valor de la serie toma ella primera posición ({0}), el segundo la segunda
({1}), y así.
Los subíndices en los arreglos indican la fila y la columna, considerando una base
cero.
10. La línea 32 define un arreglo escalonado, llamado Esea, que almacena los arreglos
Unil y Uni2.
L
.
22 !
~
ss j
.
¡ 49 ¡ 66 ¡
! ¡ :
1-- - -- - - t - - - - - - -- -l
1
77 ji
20 li___________
[_________
l 40 j1
___________
La línea 33 muestra, del segundo arreglo almacenado (subíndice 1), el tercer

elemento almacenado (subíndice 2). Entre los primeros paréntesis irá el
subíndice del arreglo escalonado, es decir, permite seleccionar al arreglo a
inspeccionar. En los siguientes paréntesis se coloca el subíndice (o subíndices) del
arreglo seleccionado.
A diferencia de un arreglo multidimensional, en donde todas las filas tienen igual
número de columnas, en un arreglo escalonado la forma y dimensiones dependen
de los arreglos almacenados.
Alfaomega 69
SYNAPS PREMIUM
11. Vea el siguiente ejemplo, y coloque las referencias que hacen falta.
a. Utilizando Unil. 49 = Unil{l)
b. Utilizando Uni2. 55 =________
c. Utilizando Multi.10 = _ _ _ _ _ _ __
d. Utilizando Ese a. 66 =________
FIN DEL EJERCICIO~*
70 Alfa omega
SYNAPS PREMIUM
~ lab.03.04: Creando programa strong typing con manejo de

arreglos.
En este laboratorio se demostrará que es capaz de utilizar variables y arreglos, que maneja
adecuadamente los tipos, y que sabe presentar información utilizando formatos específicos.
Una empresa que comercializa boletos para espectáculos calcula el monto a pagar por los
clientes. Primero, debe saber cuánto cuesta el boleto a un determinado espectáculo;
después, debe saber cuántos boletos desea el cliente. Con esa información, debe calcular el
monto a pagar.
Un detalle adicional, es que debe conocerse el desglose de impuestos.
Ejemplo:
Precio por boleto (incluye 16% de Impuesto): 400 . 00
Boletos requeridos: 1
Resumen de la operación.
(A) Boletos : $1,834 . 48
(B) Impuestos: $165.52
(e) Total: $1,288.88
Los datos subrayados son los que deberán capturarse.

l. La primer variable (PrecioBoleto) ¿De qué tipo de dato debe ser?
2. La segunda variable (BoletosReq) ¿De qué tipo debe ser?
3. Suponga que le piden que genere un arreglo que se llame Cantidades.

a . En el subíndice O se almacenaría el total de la operación (concepto C).
Esto se calcula de la siguiente manera: ( PrecioBoleto *
BoletosReq)
b. En el subíndice 1 se almacenaría el monto de los boletos (concepto A).
Esto se calcula de la siguiente manera: (Cantidades(8) 1 1.160)
c. En el subíndice 2 se almacenaría el monto de los impuestos (concepto
B). Esto se calcula de la siguiente manera: (Cantidades(1) *
8.160)
Alfaomega 71
SYNAPS PREMIUM
4. El arreglo (Cantidades) ¿De qué tipo debe ser?
S. ¿Cómo sería la línea de código para declarar el arreglo?
6. Agregue a su solución Ejercicios un proyecto de consola llamado Boletos,

que se encargue de realizar las tareas que requiere el programa. Tome en
cuenta lo siguiente.
a. Realice las especificaciones para que el programa sea Strong Typing.
b. Se declaran PrecioBoleto y BoletosReq, y se les asignará lo que el
usuario capture en la interfaz de consola.
c. Tome en cuenta que lo que se recibe en consola es de tipo String, por
lo que deberá hacerse la conversión explfcita correspondiente al
momento que se recibe el dato en la interfaz.
d. La salida deberá ser manejada con String . Format, para controlar el
formato moneda (Currency).
FIN DEL EJERCICIO *
~ lab.03.05: Especificando el alcance y la accesibilidad ade-

cuadas.
En este laboratorio demostrará que entiende el concepto de alcance y accesibilidad. Analice
el siguiente código.
1 Public Class Classl
2 Sub Procl
3 If X=l Then
4 Z = X*Y
S End If
6 End Sub
7 Sub Proc2
8 If X=2 Then
9 z =e
1e End
11 End Sub
12 End Class
72 Alfaomega
SYNAPS PREMIUM
l. Tome en cuenta que:

a. La variable X estará disponible para otros programas además de este.
b. La variable Z sólo estará disponible para este programa.
2. Elabore su propia versión del programa.
a. Todas las variables deben estar declaradas.
b. El programa deberá ser strong typing.
c. Las variables deberán tener el mínimo de alcance.
d. Las variables deberán tener el mínimo de accesibilidad.
---··---------------- -------------------- --------------------
---··---------------- -------------------- --------------------
---·---------------- -------------------- --------------------
FIN DEL EJERCICIO *
Alfaomega 73
SYNAPS PREMIUM
Namespaces y librerías
Competencias:
l. Conocer qué son los
Namespaces.
2. Conocer el sistema jerárquico
de Namespaces nativos de la
plataforma.
3. Conocer el concepto de
nombres ca lificados y su
utilización.
4. Conocer la forma de crear
Namespaces propios y la
manera de consumirlos desde
programas.
5. Conocer las técnicas y
herramientas de depuración
Evaluacl6n: disponibles en Visual Studio.
1. Proporcionar
diferentes clases de
.NET Framework, y
verificar que se puede
determinar su
jerarqufa y el Evidencia de
Namespace para su aprendizaje:
l. Capacidad de ubicar clases de .NET
utilización.
Framework dentro de la jerarquía de
2. Proporcionar un caso clases de BCL.
de desarrollo de 2. Capacidad de programar
Namespace, Namespaces de usuario, y
validando que se consumirlos como librerías desde
otros programas.
utilizan en el proceso 3. Capacidad de depurar programas
de depuración las usando las herramientas de Visual
herramientas de Studio.
Visual Studio para tal
efecto.
SYNAPS PREMIUM
4: Espacios de nombres y desarrollo de librerias

4.1. Espacios de nombres (Namespaces) ................................................................................................... 77
4.1.1 Sistema de nomenclatura para Jos espacios de nombres ..................................................... 78
4.1.2 Uso de espacios de nombres ............................................................................................................ 79
4.1.3 Creación de espacios de nombres ................................................................................................. 80
4.1.4 Estableciendo alias para los espacios de nombres ................................................................. 81
4.1.5 Estableciendo referencias a una librería .................................................................................... 82
~ Lab.04.01: Creación y consumo de una librería (DLL) basada en Namespace ...................... 83
a) Creando una librería DLL ................................................................................................................... 84
b) Estableciendo una referencia a una librería desde Solution Explorer ................................ 85
e) Consumiendo una librería programáticamente .......................................................................... 86
~ Lab.04.02: Tareas de depuración con Visual Studio ........................................................................ 87
a) Estableciendo un punto de interrupción (breakpoint) ............................................................. 88
b) Ejecución línea por línea (Code Stepping) .................................................................................... 88
e) Modificación de programas en tiempo de ejecución .................................................................. 91
d) Habilitando e inhabilitando puntos de interrupción ................................................................. 91
e) Eliminando los puntos de interrupción (breakpoint) ................................................................ 91
f) Puntos de interrupción condicionales.............................................................................................. 92
~ Lab.04.03: Inspección de código y variables ....................................................................................... 93
a) Locals Window ........................................................................................................................................ 94
b) Cal/ Sta ek Window................................................................................................................................. 95
e) Watch Window ........................................................................................................................................ 95
e) lntelliTrace ............................................................................................................................................... 96
~ Lab.04.04: Creando y depurando librerías .......................................................................................... 97
a) Creando Namespace ............................................................................................................................. 98
b) Creando aplicación que consume Namespace ............................................................................. 99
e) Usando herramientas de depuración de Visual Studio.............................................................. 99
76 Alfa omega
SYNAPS PREMIUM
Unidad 4: Namespaces y Librerías
4.1. Espacios de nombres (Namespaces)

La Biblioteca de clases de .NET Framework (BCL) es una biblioteca de clases, interfaces y
tipos de valor que proporcionan acceso a la funcionalidad del sistema. Es la base sobre la
que se compilan aplicaciones, componentes y controles de .NET Framework
Como toda buena biblioteca, debe tener un sistema de organización que permita encontrar
las cosas. Por definición, un Espacio de nombres (Namespace) es un esquema lógico que
permite organizar la BCL en base a su funcionalidad, relacionando los recursos de funciona-
lidad relacionada a través de un nombre.
Las librerías, como seguramente ya sabe, son archivos binarios ejecutables, preferentemen-
te de extensión .DLL, que contienen procedimientos de uso común (en forma de clases), dis-
ponibles para que los programas los utilicen.
En tiempo de ejecución, los programas se apoyan en las librerías para poder funcionar. Los
espacios de nombres sólo hacen que la identificación, localización y uso de las librerías se
realice de manera sencilla y lógica.
Por ejemplo, para poder abrir una conexión con SQL Server, .NET Framework pone a dispo-
sición de los desarrolladores una clase llamada SqlConnection, que se encuentra física-
mente en un archivo llamado System. Data. DL L, que se encuentra en alguna parte de su
equipo, si es que ya instaló .NET Framework Dependiendo de la versión de .NET Frame-
work, además de las características físicas de almacenamiento de su equipo y la versión de
sistema operativo que esté utilizando, la ubicación física de dicho archivo podrá variar, y
con ello, la dificultad de referirlo de manera dura en los programas. Para utilizar esa clase
tendría que ubicar exactamente el archivo, establecer una referencia desde su programa a
fin de que lo puedan encontrar, y luego, utilizar la clase; obviamente, si su programa se eje-
cuta en un equipo diferente, sería necesario hacer todo el trabajo de referencias nuevamen-
te. Para simplificar esto, .NET Framework asigna nombres lógicos: Sys-
tem . Data . SQLClient . SqlConnection quiere decir, «usa la clase SqlConnection que se
encuentra en System. Data. DL L, donde quiera que se encuentre en el equipo».
Como puede ver, los espacios de nombre nos eliminan la necesidad de estar ubicando libre-
rías de manera física. Por otro lado, Visual Studio se encarga de establecer las referencias
con las librerías, de tal manera que sólo nos debemos preocupar por la lógica del programa,
y no por los detalles técnicos de enlazado de recursos.
Buscando la simplificación, Microsoft creó un sistema lógico que permite organizar y cate-
gorizar las clases: los espacios de nombres (namespaces). Los espacios de nombres propor-
cionan una estructura que organiza y simplifica la referencia a las clases a través del .NET
Framework; los espacios de nombres aplican de la misma manera para todos los lenguajes
.NET, ya que realmente conviven con el CLR, y no con los lenguajes.
Alfaomega 77
SYNAPS PREMIUM
Un espacio de nombres es dos cosas: (a) un convencionalismo de nomenclatura, y (b) un

esquema lógico de organización de clases de .NET Framework.
Los espacios de nombres organizan colecciones de clases y previenen la ambigüedad al
momento de hacer referencias a ellas. Un mismo espacio de nombres puede hacer referen-
cia a diferentes archivos DLL que contengan clases de funcionalidad similar.
Los espacios de nombres parten de dos súper grupos: System y Microsoft. A partir de ahí
se generan subgrupos especiales, de acuerdo a la funcionalidad.
Al hablar de jerarquía podríamos pensar que es posible generar un mapa de clases, méto-
dos, types y estructuras que componen la jerarquía, aunque es tan alto el número de clases
-más de 10,000-, y varían dependiendo de la plataforma y la versión, que no tiene mucho
sentido tratar de relacionarlas.
Si desea conocer la biblioteca, la referencia más actualizada será s iempre la documentación
en línea de Microsoft (msdn /Microsoft Developers Network):
http://msdn.microsoft. com/es-es/library/gg14 5045 . aspx
O ingrese a msdn y busque «Biblioteca de clases de . NET Framework», cuidando

de seleccionar la versión que desee explorar.
4.1.1 Sistema de nomenclatura para los espacios de nombres
La nomenclatura de los espacios de nombres se basa en la notación Pascal Casing, es decir,

que las primeras palabras van en mayúsculas y el resto en minúsculas. Por nomenclatura, la
división de palabras está basada en puntos, entendiendo que los elementos de la jerarquía
van del más general al más particular.
En el caso de System. Con so le. Wri teLine que ya hemos utilizado, tenemos que System
es el espacio de nombres, Console es la clase que se está utilizando, y Wri teLine es el mé-
todo de la clase que estamos utilizando. Generalmente el último elemento del nombre es un
type, entendiéndolo como un método, propiedad, campo, etcétera, que puede representarse
como una acción o valor; el penúltimo elemento generalmente es una clase de BCL, y todo lo
que anteceda será la jerarquía de espacios de nombres para llegar a la clase.
Es importante mencionar que nosotros podemos crear nuestras propias jerarquías de espa-
cios de nombres, mismas que se regirán por las mismas reglas de nomenclatura.
_, WBVBVS2012.04.01- Arquit ectura de clases en .NET.avi
78 Alfa omega
SYNAPS PREMIUM
4.1.2 Uso de espacios de nombres

Las aplicaciones desarrolladas en .NET pueden disponer de todas las clases y objetos del
.NET Framework, es decir, todos los recursos de .NET Framework; lo único que hay que ha-
cer es referir los recursos adecuadamente.
Si queremos hacer uso de cualquier clase de BCL es necesario que proporcionemos el nom-
bre adecuado de la clase. Una forma en que se pueden referir los recursos de BCL es a tra-
vés de lo que se conoce como nombres calificados (Fully Qualified Name), que son la especi-
ficación textual de la jerarquía de espacios de nombres que permite ubicar una clase o type:
Namespace . Clase • Type
Es posible que utilice todas las clases disponibles de .NET Framework a través de sus nom-
bres calificados, pero eso no es del todo práctico en ocasiones, pues sus nombres pueden
ser bastante largos.
Una forma de obviar la escritura del nombre calificado completo es importando los espacios
de nombres. Para ello se utiliza la instrucción Imports.
Basta con que coloque al principio de su programa, lo siguiente:
Imports EspacioNombre
Donde EspacioNombre es la parte del nombre calificado que desea estar obviando al mo-
mento de programar. En Visual Basic se puede incluir hasta el nombre de la clase de BCL,
con lo que el código puede llegar a simplificarse bastante.
Puede darse el caso de que en dos o más ensamblados se repita el nombre de clases, refe-
rencias o métodos; en ese caso, la ambigüedad debe eliminarse a través de nombres califi-
cados, ya que no podríamos saber a qué origen de los recursos nos referimos.
Los siguientes dos programas funcionarían de la misma forma.
Sin uso de instrucción Imports.
Module Modulel
Sub Main()
System.Console.Write( "Presione INTRO" )
System.Console.Readline()
System. Console.Writeline( ''Hola mundo." )
End Sub
End Module
Alfaomega 79
SYNAPS PREMIUM
Con uso de instrucción Imports.
Imports System.Console
Module Modulel
Sub Main()
Write( "Presione INTRO" )
Readline()
Writeline( ''Hola mundo." )
End Sub
End Module
Salvo casos muy excepcionales, no deberá preocuparse por colocar las sentencias Import si
desarrolla con Visual Studio. La herramienta se encarga de invocar los elementos más usua-
les de manera automática.
DI WBVBVS2012.04.02- Importando Namespaces.wmv
4.1.3 Creación de espacios de nombres

.NET Framework proporciona una cantidad impresionante de clases, accesibles a través de
sus muchos espacios de nombres. Eso no es suficiente, pues todo lenguaje que presuma de
ser extensible debe permitir a los desarrolladores agregar funcionalidad específica que no
está presente de manera genérica.
Es posible agregar espacios de nombres adicionales a los contenidos de origen en .NET
Framework, los pasos para hacerlo son los siguientes:
1. Desarrollar el código de una librería, delimitando el contenido de la librería a tra-
vés del estatuto Namespace.
2. Debe compilarse el código de la librería, como tipo library, con lo cual no se gene-
raría un archivo ejecutable (.EXE), sino una librería de vínculos dinámicos (.DLL).
3. Para hacer uso de la funcionalidad de una librería, es necesario hacer referencia a
la misma; eso se puede hacer desde Visual Studio con la opción de menú Project -
Add Reference.
80 Alfa omega
SYNAPS PREMIUM
4. Es opcional utilizar nombres calificados o no, una vez que se establece la referen-
.
c1a.
La sintaxis para crear un espacio de nombres es la siguiente:
Namespace EspacioNombre
'Codigo de elementos
End Namespace
Donde EspacioNombre es el nombre a través del cual se referirán los elementos contenidos
en espacio de nombres que se genera.
Una cosa importante a tomar en cuenta es que para crear una jerarquía dentro de un espa-
cio de nombres es posible anidarlos, por lo cual una declaración Namespace puede estar
definida dentro de otra, creando el efecto EspacioNombrel. EspacioNombre2. Type.
4.1.4 Estableciendo alias para los espacios de nombres

Codificar utilizando nombres calificados puede ser muy complicado debido a que los espa-
cios de nombres no son muy cortos en ocasiones; de ahí que recurriéramos a importarlos, a
fin de no tener la necesidad de especificar el nombre de espacio de nombres cada vez que
hacemos uso de una clase o elemento que se encuentra dentro de él.
Esto plantea un nuevo problema: nos quedamos sin información con relación a qué espacio
de nombres contiene qué elementos.
Un escenario ideal sería que los espacios de nombres no tuvieran el nombre muy largo, a fin
de poder integrarlos al código sin necesidad de mucho esfuerzo; con ello obtendríamos in-
formación con relación al espacio de nombres de origen, y al mismo tiempo la comodidad al
codificar. En pocas palabras, queremos espacios de nombres con nombres no muy largos,
pero tampoco de nombre inexistente.
Esto es posible si asignamos un alias al espacio de nombres. Un alias de importación es la
equivalencia en nombre que le damos a un espacio de nombres al momento de importarlo.
Vea la sintaxis para establecer un alias de espacio de nombres.
Imports Alias = EspacioNombres
Alfaomega 81
SYNAPS PREMIUM
Donde EspacioNombres será el nombre del espacio de nombres que será referido a través
de Alias.
4.1.5 Estableciendo referencias a una librería

Una referencia puede definirse como la especificación de enlazado entre un programa y una
librería, en donde la librería pone su funcionalidad a disposición del programa, hasta donde
la accesibilidad lo permite.
. . . . . ¡_ - - - -
. )(
~
P·
• [!) "''09'"'
• [iJ HolloV.PfApp
Figura 04.01
• [01 HoloM.JndoCOfl
Solution Explorer • ti Hoi>MundoW<b
• [. Hoi>MundoW"'
• }> My P-cj«<
~ Q Refete11t.H
•• S)it.n
•. Sylltm (ON
~· Syslwn-0...
•• ,.~em.o ... o.-.~
•• ~('fft~
•• ,. tf'fft.Or"""t
• • ~!ctn, \\ 1ncicMVorms
.. ""'•• s, ..-
....,~
··
ó) App <onl!g
• ..-.~~"""""'b
Las referencias pueden establecerse fácilmente desde Visual Studio. Lo primero que hay
que saber es que cada proyecto tiene sus propias referencias. Al crear un proyecto desde
Visual Studio, la herramienta establece las referencias más usuales para el tipo de aplica-
o ,
CIOn.
En el Solution Explorer pueden observarse claramente, ya que bajo el nodo de un proyecto

siempre hay un nodo References.
Si requerimos hacer una nueva referencia, es necesario colocarnos sobre el nodo Referen-
ces del proyecto al que queremos agregarle la referencia, y desde el menú de contexto se-
leccionar Add Reference.
82 Alfa omega
SYNAPS PREMIUM
Con esto aparecerá la ventana Ref erence Manager.
_1 il-¡
Figura 04.02 ~~i~~~~~~~~---ji.T~~Kfl~ti
1 ¡t 11:1 :,1 Vtn.on •
-
N¡me
Reference b:msoons
e
A<<<SSibióy <.MJI
Manager (urtt)mt.ll~ <.M O
• SoUK!n
~ .... <Jl.Oj) 1
11
.""""'
Mtcroscft.Aaiviies.Buld <.MJI
• co.., """0\Cft.&ild <J)j)j) '-"
Mtc:ro$Cit.&,.id.C~.Y4D <J)j)j)
Microsoft.Build.Engin.e U.OJI
Mktosoft.&Jiild.Franwwoott •D.DD
Mic:r~;~~.BfJIIId.losb.v4.0 <II.DD
Mk:rosoft.&.ld.Utilit•e:s,\-4.0 <J)IJj)
Microsoft.CSharp •.OJJJ)
Mi<rcJ.Oft.JSc:ript IOD-0.0
Microsoft.V.sua!BaSK IOJIJI.O
Microsoft.V.sua!Baúc.CompatitHiity IODD.O
Micro~.Vi-su~IB.mc:.Complllib.lity 011t• IOJIM
Micros.ott.Visual( IOJI.O.O
Microsoft.Visua!C.STLCLR l.O.OJI
mscodib 'O.OD
Preserrt11bon8ulldt.nks 4.0.0.0
PresentationCore UOJI
Pr~~ntationftaml'work •O.OD
Pr~tSC:ntlbonfr¡~mcwolt.AtrO <OJIJI
Presentationframework.Aero1 <JIJ)j)
Pres;entationframewOtk..Aetolite •ODD
PresentiltJOnfrilmcwork.Cins•c <ODD
Preserrtat10nframe.wortc.Lun• <.OJIJ)
r ··-.. lL 01( =:J Co<Kel
La ventana muestra una jerarquía de opciones. En Assemblies pueden ubicarse las librerías
de .NET Framework, tanto nativas como extensiones que hayan sido instaladas. También se
pueden buscar las librerías contenidas en la solución donde estamos trabajando (Solution),
en recursos COM (COM 1 Component Object Model), o sencillamente examinar diferentes
fuentes (Browse), como pueden ser librerías . DLL puestas a disposición por terceros para la
interacción con otros recursos.
En cualquiera de las pestañas se pueden seleccionar los componentes, posicionándonos en
la librería que queremos referir y haciendo die en el botón Ok, a fin de que las referencias
queden establecidas.
~ Lab.04.01: Creación y consumo de una librería (DLL)

basada en Namespace
En este ejercicio se comprobará la forma en que funcionan los alcances de variables en
l. Trabaje sobre la solución Ejercicios.
Alfaomega 83
SYNAPS PREMIUM

Class Library.
3. Asigne como nombre MisUtilerias
a) Creando una librería DLL

1 Imports System. Console
2
3 Namespace Funciones
4 Public Class Continuar
S Public Shared Sub EsperaiNTRO()
6 Writeline()
7 Writeline( ''Pulse INTRO para continuar'' )
8 Readline()
9 End Sub
le End Class
11 End Namespace
S. Al compilar este programa no se generará un ensamblado ( . EXE), sino una

librería (. DLL). Posee un espacio de nombres denominado Funciones, que a su
vez contiene una clase llamada Continuar, que tiene definido un método llamado
EsperariNTRO. El método se encarga de mostrar un mensaje y esperar a que se
pulse INTRO para continuar. Si recuerda, hemos estado utilizando código similar
en los últimos ejercicios, por Jo que en este ejercicio vemos la forma de
automatizar esa labor tan común.
6. Es muy importante notar que la clase es pública (Public) dado que le daremos un
uso de librería, y deseamos que sea utilizable por cualquier proyecto, incluso
aquellos que no pertenecen a la solución. También es importante ver que el
método es público y aparte compartido (Shared), lo que indica que está
disponible para uso externo a la clase.
,
7. Guarde todos los archivos de la solución (CTRL-MAYUS-S), y construya la librería,
seleccionando el nodo principal del proyecto y haciendo die en la opción Build del
menú de contexto.
1
a. @ En Solution Explorer, asegúrese de ver todos Jos archivos.
,
b. Expanda el nodo de References en el proyecto MisUtilerias, y vea que
referencias estableció Visual Studio en automático.
c. Vaya a msdn e investigue cuál es el propósito de cada una, como simple
información.
84 Alfaomega
SYNAPS PREMIUM
d. Expanda el nodo bin del proyecto MisUtilerias, Juego expanda Debug, y vea
cómo ya ha sido generada la librería físicamente.
~ :!!f Mrslt!itNs
• 1- My Pro¡•a
~ ~ Rtferences
.. Sy<tem
. . System.Oitl.
H System.D.~taDataSEtblensions
•.• System.Xml
•·• S)lstem-Xmll•nq
4 e bln
4 tJ Oebug
:::: MisUtilerias.dn
:.. MisUtilenas.pdb
¡-· M1slhilerias.xml
1> 1' " obJ
~...
1> w Classl.vb
b) Estableciendo una referencia a una librería desde Solution Explorer

8. Agregue a su solución un nuevo proyecto: Installed - Visual Basic - Windows -
9. Asigne como nombre ConsumeUtilerias
10. Establezca este nuevo proyecto como proyecto de inicio.
11. En Solution Explorer revise el proyecto ConsumeUtilerias.
a. Haga die en el botón Show All Files de la barra de herramientas de Solution
Explorer, si es que no está viendo todos los archivos aún. Vea el árbol jerárquico
de recursos asociados a su proyecto y compruebe que en References no se tiene
aún la referencia a la librería que nosotros desarrollamos.
12. Ahora estableceremos la referencia con nuestra librería:
a. Seleccione el nodo principal del proyecto ConsumeUtilerias en Solution
Explorer.
b. Invoque el menú con textual y seleccione Add Reference.
c. Seleccione en el árbol la opción Solution - Projects, y seleccione MisUtilerias,
asegurándose que queda marcada con una palomita.
d. Presione Ok, y con eso la funcionalidad que ofrece la librería estará disponible
para sus desarrollos.
Alfaomega 85
SYNAPS PREMIUM
P·
Mame Polith NMnr.
Alance C,\lkM\fftptldoc_ _ _ lOI M~
~J'(ts
Attai!«tingulo C,\lktn\Fttip<'.- ..."·""" <luello 201
t COM An«jlos C:\Usm'J tiipe' docl.Wienb\~ISWI 1>lu6o 201
HdaMunclc>ú>n C,\U>m\fdP<'docum_l_,., >tudoo 201
's._.. HolaMundoWeb C.'\U>m\fdoP<' documenb1'1Suol m.doolOI
HolaMundo\\lr~ C.'\lkm'J••P<'·documeom\"'uol audoolOl
' --------~
'L---------~"~ •
1 Brow•¡::-)1 01( J[ Cone<l J
13. Vea cómo al agregar la referencia, Solution Explorer actualiza el árbol de

elementos del proyecto, incluyendo nuestra librería.
DI WBVBVS2012.04.03 - References.wmv
e) Consumiendo una librería programáticamente

14. Ahora codifique el programa que consume la librería.
1 Imports System.Console
2 Imports MisUtilerias.Funciones
3
4 Module Module!
S
6 Sub Main()
7 Writeline( ''Mensaje desde el programa'' )
8 Continuar.EsperaiNTRO()
9 End Sub
10
11 End Module
86 Alfaomega
SYNAPS PREMIUM
15. Vea cómo al editar las líneas de importación de espacios de nombres, ya

teníamos disponible nuestro espacio de nombres en Jntellisense, junto con su
funcionalidad.
_, WBVBV$2012.04.04- lntellisense con libreria.wmv
16. Se importa el nombre de la librería y el espacio de nombres (línea 2). Ya en el

código, sólo es necesario invocar el nombre de la clase y el type (línea 8).
17. Establezca el nuevo proyecto como proyecto de inicio, guarde todos los
cambios que ha realizado en la solución e inicie la depuración.
18. Si todo salió bien, el programa debe arrojar lo siguiente.
19. Con este pequeño ejemplo ya comprobó cómo se generan bibliotecas de

clases en .NET y cómo se consumen desde otros proyectos.
FIN DEL EJERCICio:•
~ lab.04.02: Tareas de depuración con Visual Studio

En este ejercicio se demostrarán algunas de las capacidades de depuración que
tiene Visual Studio. Se agregarán puntos de interrupción a una aplicación, y se
revisarán las opciones de ejecución línea a línea, entre otras cosas.
Alfaomega 87
SYNAPS PREMIUM
1. Seguiremos trabajando con el proyecto Consumelibreria de la solución

Ejercicios; el proyecto debe estar actualmente como proyecto de inicio.
a) Estableciendo un punto de interrupción {breakpoint)
2. Edite Module!. vb.

3. Seleccione la línea Sub Main( ), y establezca un punto de interrupción con la
opción Debug - Toggle Breakpoint (F9), o bien, haciendo die en el borde
externo izquierdo de Code Editor, junto a la línea en la que queremos
agregar un punto de interrupción. Aparecerá una marca en el borde externo
izquierdo de Text Editor, indicando que la línea tiene un punto de
interrupción.
·rModule llodule1
• .=. ~ub Main()

Writeline( ''mensaje desde el programa'' )
Continuar .EsperaiNTRO()
4. Guarde los archivos de la solución, e inicie la depuración presionando FS.

Cuando presionamos FS se dice que entramos en modo Debug.
b) Ejecución línea por línea (Code Stepping)
S. Al momento de llegar a la línea que posee el punto de interrupción el

programa se detendrá, y aparecerán algunas herramientas que sólo están
disponibles en modo debug.
88 Alfa omega
SYNAPS PREMIUM
D4l •uos ~ · Micro~,... '-1 .(),k r l.-.1\((tl't• Q)

fU Ellll VIW IIIIOIICl -D DUUCi TIAM SQl TOOLS nst ARCHTICTIJIII ANAlVZI - 1-«l.P
o. · Gil lil 11' ., lf;> ? · · • ,...,..... · • "· ee
'·'
" -'
1 ~ •
tooports SystN .
.. •
~ <,j!.:
O.::!
·e -
I.ports MisUtíl•rías.Funciones
"~ t •.. l t ~
··~~'"~-J!.~~-~~~--....!
"'~--!!
g ·.; O
. .... _ • 1 X
p
1llodul• o Drbt IJ ff': . .91"• .,.. ~lbOft;. "'""' Mocbd
&:> .... ,_ ......_...,.....,. .............. ,
o ~ub Mlin()
Wríttlint( "..nsajt dtsd• •1 procr.-.")
. EspordNTRO()
1
End Sub
End Modult •
IDO" • • ..------~--- ,. ----------.,
,,..• .
6. Tenemos los siguientes apoyos:

a. Breakpoints. Son los puntos de interrupción con los cuales podemos
indicar. , a partir de qué línea deseamos la supervisión detallada de la
.
eJeCUCIOn.
b. Locals. Ventana que muestra las variables dentro del alcance y el valor
que almacenan al momento.
c. IntelliTrace. Herramienta que registra toda el historial de ejecución, de
tal manera que no se tenga que ejecutar muchas veces el mismo programa
para analizarlo. Se puede navegar dentro de los momentos de la ejecución,
incluso anteriores al momento en que nos encontramos, con plena
disponibilidad de los datos que se tenían en el evento.
7. En la barra de herramientas se agregan también algunos iconos interesantes:
Alfaomega 89
SYNAPS PREMIUM
~ Continue •
a. Continuar depuración. Permite reanudar la ejecución del programa.

b. Pausar depuración. Permite pausar la ejecución, sin requerir la
existencia de un breakpoint.
c. Detener depuración (SHIFT+FS). Permite detener el proceso de
depuración.
d. Step Into (F11). Ejecución línea a línea, que en caso de que encuentre una
llamada a una función, entra al código de la función para su depuración.
e. Step Over (F10). Ejecución línea a línea, que en caso de que encuentre
una llamada a una función, no entra a revisar la codificación de la función,
sino que la trata como una línea más.
f. Step Out (SHIFT+Fll). Estando dentro de el código de una función que
está revisando, nos permite salir del código de la función, y seguir la
depuración en el código que mandó llamarla.
8. Seleccione Step Over (F10), hasta terminar la ejecución del programa. La
ejecución continuará en modo línea a línea. Al encontrar un llamado a un
recurso externo al programa (clases, librerías, funciones, etcétera), las tomará
como una sola línea, es decir, no profundizará en lo que pasa dentro del
recurso externo al programa. Las líneas que se vayan ejecutando aparecerán
señaladas con una flecha amarilla en el borde izquierdo de Code Editor.
9. Inicie la depuración nuevamente (FS). Seleccione repetidamente Step Jnto
(Fll), hasta terminar la ejecución del programa. La ejecución continuará en
modo línea a línea. Al encontrar un llamado a un recurso externo al programa
(clases, librerías, funciones, etcétera), realizará también una inspección línea
a línea de dichos recursos. Las líneas que se vayan ejecutando aparecerán en
amarillo.
90 Alfa omega
SYNAPS PREMIUM
10. Inicie la depuración nuevamente (FS). Seleccione repetidamente Debug -

Step lnto (F11), hasta que esté viendo las líneas de código de la librería de
MisUtilerias. Cuando eso suceda, seleccione Step Out (SHIFT+F11), para
terminar de ver el contenido de la librería, y continuar con la ejecución en el
programa que mandó llamar la librería.
e) Modificación de programas en tiempo de ejecución
11. Inicie la depuración nuevamente (FS). Al llegar al punto de interrupción,

continúe la ejecución con Step Over (F10). Al llegar a la línea 7, que despliega
Mensaje desde el programa, cambie en ese momento el mensaje por
Mensaje editado en tiempo de depuración. Siga ejecutando con Step
Over. Compruebe en la consola que se ha escrito el nuevo mensaje, lo que
indica que tomó como buenos nuestros cambios realizados en tiempo de
depuración.
d) Habilitando e inhabilitando puntos de interrupción
l. En ocasiones queremos iniciar la depuración de un programa sin tener que

estar lidiando con los puntos de interrupción. Una alternativa para que la
depuración no se detenga es eliminar los puntos de interrupción, pero esa
solución es definitiva y drástica; si queremos que los puntos de interrupción
no detengan la depuración en un momento dado, pero no queremos
perderlos, la opción más recomendable es inhabilitarlos.
2. Seleccione la opción Debug - Disable All Breakpoints. Inicie la depuración y
vea cómo la depuración no se detiene donde se encuentra el breakpoint.
3. Seleccione la opción Debug - Enable All Breakpoints. Inicie la depuración y
vea cómo el punto de interrupción ha vuelto a su comportamiento normal.
e) Eliminando los puntos de interrupción (breakpoint)
4. Para eliminar un punto de interrupción que hemos agregado, basta hacer die
en el punto rojo que se agregó en el lado izquierdo de Code Editor, con lo cual
desaparecerá dicho punto, y con ello el punto de interrupción.
S. Si deseamos eliminar todos los puntos de interrupción agregados, hay que ir
al menú Debug - Delete All Breakpoints (CRTL-SHIFT -F9). Aparecerá una
ventana de confirmación, que debe responder afirmativamente en caso de
que desee eliminar los puntos de interrupción.
6. Elimine todos los puntos de interrupción que tiene su programa.
Alfaomega 91
SYNAPS PREMIUM
f) Puntos de interrupción condicionales
7. En ocasiones queremos que un punto de interrupción sólo detenga la

depuración en caso de que sea necesario. La necesidad de interrupción debe
estar expresada en términos de una condición lógica. A los puntos de
interrupción que sólo detienen la depuración en base a una condición se les
llama puntos de interrupción condicionales.
8. Ahora trabajaremos con el proyecto AreaRectangulo que se encuentra en la
solución Ejercicios. Usando Solution Explorer:
a. Establezca dicho proyecto como proyecto de inicio.
b. Edite el programa Module l. vb del proyecto.
9. Coloque un punto de interrupción en la línea que dice
Base=Cint(Entrada) .
10. Coloque el puntero del ratón sobre el punto de interrupción, invoque el menú
de contexto y seleccione Condítíon ....
11. Aparecerá la ventana Breakpoint Condition, en donde se podrá especificar la
condición que provocará que el punto de interrupción detenga la depuración.
Especifique que si el dato proporcionado es menor o igual a cero, detenga la
depuración ( Ci nt ( Entrada ) <=e ).
Srealcpo<nt Condobon
When the breakpoint location tS re.ached, the expresS<on IS evaluated and the breakpoont
os hot only if the expression is true or has changed.
J Condítion;
da...,.
Clnt(Entra-, )< , -- - - -
- =70 1-
o ls true
• Haschanged
OK jL Cancel ~
--
gl WBVBVS2012.04.05 - Breakpoint condicional.wmv
12. Inicie la depuración de la solución (FS). Cuando el programa le pregunte la

base, proporcione el número le. Proporcione una altura de 15, y vea cómo el
programa no detiene la depuración en ningún momento.
92 Alfa omega
SYNAPS PREMIUM
13. Inicie la depuración de la solución nuevamente (FS). Cuando el programa le

pregunte la base, proporcione el número e. Al cumplirse la condición, el
programa se detiene.
14. Guarde todos los cambios en la solución.
FIN DEL EJERCICIO *
~ lab.04.03: Inspección de código y variables

En este ejercicio utilizaremos las herramientas de Visual Studio para darle
seguimiento a la ejecución del código y a los valores que adquieren las variables.
1. Trabajaremos con el proyecto Alcance de la solución Ejercicios.
a. Establezca el proyecto como proyecto de inicio.
b. Edite el programa Module l. vb del proyecto.
2. Visual Studio proporciona una serie de herramientas que permiten ver los
cambios que las variables experimentan en tiempo de depuración.
3. Establezca un breakpoint en la línea que abre el módulo.
a. Colóquese en la línea Module Modulel
b. Presione F9
4. Inicie la depuración (FS).
S. En la parte inferior del Code Editor aparecen ventanas que apoyan el
proceso de depuración.
locals Cal! Stack Data Tools Operations Immediate Window Command Window Output Errar L1st
6. No aparecen todas al mismo tiempo, pero están disponibles a través de su

correspondiente pestaña perimetral. Las que nos interesan son las siguientes:
a. Locals. Muestra las variables que están dentro del alcance inmediato,
junto con su tipo y su valor.
b. Call Stack. Muestra el llamado de procedimientos principales
realizados en el programa.
Alfaomega 93
SYNAPS PREMIUM
c. Output. Muestra el resultado de las operaciones de compilación y

procesamientos de CLR.
a) Loca/s Window
7. Seleccione Locals en las pestañas perimetrales.

8. Continúe la ejecución, línea por línea, con Step Into (F11).
9. Vea lo que va apareciendo en la ventana Locals.
a. Cuando llega a la línea Sub Main(), detecta que hay una variable
llamada Texto2, así que la reporta.
b. Como aún no llega a la línea que le asigna valor, muestra el valor
Nothing.
c. Vea cómo, siendo que Texto3 también está en el procedimiento, no se
reporta, por estar dentro de otro bloque (If - End If).
10. Siga con Step lnto hasta entrar al bloque que inicia con la instrucción If.
a. Ahora sí aparecen ambas variables: Texto2 y Texto3.
Option Explicit On
Option Strict On
EModule Modulel •
• J Public Textol As String = "Alcance módulo"
8 Sub ~lain()
Console .Writel ine(Textol)
Oim Texto2 As String = "Alcance procedimiento"
If Texto2 <> "" Then
o ~onsole .~rriteline(Texto2)
Oi11 Texto3 As String = "Alcance block"
Con so le . ~rri teline(Texto3)
End If
Procedimientol()
Procedimiento1()
ProrPdimiPotn1()
UlO o/. • ~
louls • Q X
Value Type ,.
"Aic6nc~ prou:dimu:nto' ~. Strin9
Nothing Q, • Strin9
l ocals Call Stadc: Data Tools Operations Immediate Windo·11 <ommand Wiodow Ot.rtput Ertcr lirt
94 Alfa omega
SYNAPS PREMIUM
b) Cal/ Stack Window
11. Siga con Step Into, y cuando llegue a la línea End If, seleccione la
herramienta Call Stack que se encuentra en las pestañas perimetrales.
12. Vea cómo por el momento aparece como única llamada la del procedimiento
Main().
13. Siga con Step lnto, hasta que se traslade la ejecución a la línea donde inicia la
declaración del procedimiento Procedimientol ().
14. Vea cómo Call Stack detecta la llamada a un nuevo procedimiento, y lo
reporta como el principal, sin olvidar de dónde ha venido, que es Main ( ) .
~ ~~~--------~~-----
.. 6> -----~· Pfocedlmlento l
Procedimientol()
Procedimientol{) •
Procedimient o2()
( on>ole . ~Jriteline( " ")
C.onsole: .l-Jrite( ·Pulse ItHRO para continuar•)
Console . Readline()
fnd Sub
•
o ~ Sub PI'OCedi•ientol ()
Static Texto4 As String
Texto4 ~ "Valor + • & Texto4
¡¡¡. TextoS As String : "Texto S"
r 1 --~~ - )
.o1e .Writeline( · --Prc<ed~ iento
( .Writeline("Texto 1: • & Textot)
.Writeline("Texto 4: • &Texto4)
l . •ole .Writeline("---- ---- --- ----- ------ ")
End Sub
<> Ak..nc.e._or.Ak..tttc.~,,oc.tólttl,tntclO LM le
Alunc:~nt-"u:rct.lrl1oct..d.Mall'l() l~n~r U .. OJó bytes
((rtt-.~ Codc:l
e) Watch Window
15. Como pudo ver, Locals muestra variables de forma dinámica, en función a su
alcance. Sin embargo, en ocasiones deseamos darle seguimiento particular a
una variable o elemento, sin perderle la pista en ningún momento.
16. Para esto utilizamos la herramienta Watch.
a. Invoque la herramienta, seleccionando la opción de menú Debug -
Quick Watch, o presionando SHIFT+F9.
b. En Expression, escriba Textol
Alfaomega 95
SYNAPS PREMIUM
c. Presione Add Watch.

d. Presione Close.
17. Se habrá agregado en las pestañas perimetrales la ventana Watch, que en
todo momento sabrá qué pasa con Textol.
18. Siga con Step Into, hasta que ingrese a Procedimiento2(), en la línea que
asigna el valor «Shadow» a Textol.
19. Vea como, mientras no se pasa por esa línea Watch sigue mostrando el último
valor de Textol, sin importar si está o no dentro del alcance.
_, WBVBVS2012.04.06- Watch.wmv
e) lnte/liTrace
20. Anteriormente, si se deseaba analizar el comportamiento de un programa,
era necesario depurarlo una y otra vez. Lo ideal era poder regresar a ver algo
que ya había pasado. Sin embargo, la forma secuencial en la que trabajaban
las herramientas de depuración no lo permitían.
21. Ahora con lntelliTrace, es posible que volvamos sobre nuestros pasos.
a. En lntelliTrace, seleccione la tercer entrada Debugger (hace
referencia a la línea 7) .
Modufel.\-b 1:1 )( Modulel.vb • [ntellilrace • íl X 1

•• Module!
-. • Ci) Main
Option Explicit On
Option Strict On *• All Categories
Search
• AJI Threads
p
O Oelxlgger. Beginning of Application: .cctor, Modulel.• n•
•11 ~ Module Modulel
Publk Textol As String = "Alcance módulo"
~
O Oebugger. Breakpoint Hit .cctor, Modulel.vb line 5
O Oebugger. St..p Recorded: Main, Modulel.vb fone 7
A use.t performed a st~ u\ the debugget.
o .:. Sub Main() Thre.d: Main Thread (7924)
Consol e.Wr iteline(Textol ) RS~ ted vkews! lo<als Cal Stack
Dim Texto2 As String = "Alcance procedimiento" O Deb<Jgger. Step Recorded: Main, Modulel.vb line8
If Texto2 <> "" Then O Deb<Jgger. Step Recorded: Main, Modulel.vb line 9
Console .Writeline{Texto2) lntelliTface Solution Explorer
b. El control de la ejecución se traslada a esa línea.
96 Alfa omega
SYNAPS PREMIUM
c. Seleccione Locals. Vea cómo aparece un elemento llamado Step

Recorder , que nos indica qué se veía en Locals cuando se pasó por esa
línea.
• ~ X
~..... lypc ..
e M•.n Modulel.Mall'l0
G f St<p R«ord•d Toto2 : Nott.ing
~ TMo2 Noth•ng
•
locals Watch 1 Cal! St•ck. Brukpo.nts Ott. To<:~ls OpcrttiCns lmmcdiate: w·mdow Ccmmand Win-dow Output E.tror L,st
d. Esta herramienta es poderosísima, porque evita la ejecución del

programa muchas veces. Sobre todo, cuando tenemos problemas para
reproducir un error, ¿qué mejor que tenerlo grabado?
e. En la barra de herramientas de IntelliTrace, nos da la oportunidad de
guardar el historial de ejecución.
f. Haga die en guardar, y guarde su historial de ejecución.
22. Detenga la depuración y guarde su trabajo.
FIN DEL EJERCICIO *
~ lab.04.04: Creando y depurando librerías

En este ejercicio creará su propio Namespace, y utilizará las herramientas de
Visual Studio para hacer la depuración de su programa.
Tome en cuenta que .NET Framework tiene varias funciones intrínsecas, dentro
de las cuales se encuentran las siguientes:
Now Retorna la fecha y hora.
Hour() Retorna la hora de una fecha/ hora dada.
Siendo así, si son las 4:00PM., entonces Hour(Now) es igual a 16.
Aunque más adelante verá el estatuto condicional If, aquí lo usaremos para
ejecutar una sola línea.
Alfaomega 97
SYNAPS PREMIUM
Su sintaxis es:
If (Condición) Then Línea
Donde Condición es una condición lógica, y Línea, una línea común del lenguaje.
a) Creando Namespace
1. Se pide que agregue en su solución Ejercicios un proyecto de tipo Class

Library, que será codificada como Namespace.
2. El Namespace se llamará Ambiente.
3. Dentro del Namespace se colocará una clase llamada SaludosDia.
4. Dentro de SaludosDia, se tendrá un método que se llamará Saludar().
S. Dentro de Saludar() se evaluará la hora del día, y se lanzará el método que
corresponda, que a su vez mandaran un saludo a la consola.
If (x <= 11) Then Manana()

If (x > 11 ) And (x <= 19) Then Tarde( )
If (x > 19) Then Noche(.¿)_ _ __
6. El método Manan a() simplemente lanzará a la consola el mensaje «Buenos

días».
7. El método Tarde() simplemente lanzará a la consola el mensaje «Buenas
Tardes».
8. El método Noche() simplemente lanzará a la consola el mensaje «Buenas
Noches».
9. Esto es muy importante: deberá especificarse la accesibilidad, de tal manera
que sólo el método Saludar() estará disponible para el programa que
consuma la librería.
98 Alfa omega
SYNAPS PREMIUM
b) Creando aplicación que consume Namespace
10. Se pide que agregue a su solución Ejercicios un proyecto de tipo Console

Application, llamado Principal.
11. Desde el programa, se deberá consumir la librería SaludosDia.
12. Se deberá establecer la referencia hacia la librería.
13. Se deberá importar el espacio de nombres.
14. Se deberá crear desde el programa una instancia de la clase.
15. Se deberá lanzar a ejecución el método SaludosDia.
16. Se deberá agregar el código necesario para que la aplicación, al final, espere
que el usuario presione INTRO para continuar.
e) Usando herramientas de depuración de Visual Studio.
17. Agregue Breakpoints en la línea que manda a ejecución el método

SaludosDia, y también en el procedimiento donde se muestre el mensaje de
la hora en la que está depurando.
18. Depure su programa:
a. Depure el programa, y al llegar al primer breakpoint, ejecute línea por
línea en modo Step Over.
b. Utilice Intellítrace para regresar en la ejecución sin tener que ejecutar
nuevamente la depuración.
c. Continúe la depuración, ahora línea por línea en modo Step Into.
d. Mientras depure, revise el salto de procedimientos en Call Stack
Window.
19. Analice su experiencia.
FIN DEL EJERCICIOI*
Alfaomega 99
SYNAPS PREMIUM
Manejo de Operadores
Competencias:
Objetivo: 1. Conocer cuáles son los operadores
de asignación, aritméticos, lógicos
Aprender el manejo de y de comparación, soportados por
operadores la plataforma .NET.
aritméticos, lógicos, de 2. Conocer cuál es la prioridad de
ejecución de los operadores, y
asignación, y de cómo manejar la prioridad
.,
comparac1on. utilizando paréntesis.
Evidencia de
Evaluaci6n: aprendizaje:
1. Proporcionar 1. Capacidad de traducir
diferentes casos de fórmulas a su representación
análisis, a efecto de codificada.
que sean 2. Capacidad de construir
representados de condiciones para la toma de
forma codificada. decisiones basadas en datos.
3. Capacidad para estructurar
árboles de decisión, e
implementarlos.
SYNAPS PREMIUM
5: Manejo de operadores
5.1 Operadores aritméticos ........................................................................................................................... 103
5.2 Operadores de asignación ...................................................................................................................... 104
5.2.1 Expresión ..............................................................................................................................................104
5.2.2 Operadores de asignación incluyente ........................................................................................ 105
5.3 Operadores comparativos ...................................................................................................................... 106
5.3.1 Consideraciones relativas al código ASCII ............................................................................... 107
5.3.2 Option Compare ................................................................................................................................. 108
5.3.3 Operadores ls, lsN ot y TypeOf...................................................................................................... 109
5.3.4 Operador Like ..................................................................................................................................... 110
5.4 Operadores lógicos .................................................................................................................................... 111
5.4.1 Operadores lógicos de circuito corto ......................................................................................... 114
5.5 Prioridad entre operadores ................................................................................................................... 115
5.5.1 Uso de paréntesis para otorgar preferencia de ejecución ................................................. 117
~ Lab.05.01: Utilización general de operadores de Visual Basic ................................................... l17
a) Comentando bloques de código ...................................................................................................... 119
b) Uso de Clipboard Riny ........................................................................................................................ 119
e) Selección basada en bloques de código (Block Se/ection) ...................................................... 120
~ Lab.05.02: Representando con operadores casos de la vida real. ............................................ 121
102 Alfa omega

SYNAPS PREMIUM
Unidad 5: Manejo de Operadores
Los operadores son los elementos de que se vale un lenguaje de programación para la trans-
formación de expresiones, ya sea mediante cálculos o comparaciones.
Los operadores principales tienen la siguiente clasificación:
1. Aritméticos
2. De asignación
3. Comparativos
4. Lógicos
5.1 Operadores aritméticos

Los operadores aritméticos como los símbolos que producen, a partir de dos expresiones
numéricas conocidas, una nueva expresión numérica, como resultado de la aplicación de un
cálculo aritmético entre aquellas.
El lenguaje dispone de los siguientes operadores aritméticos básicos.
+ Suma Suma expresiones numéricas. Concatena expre-

[concatenación) siones de tipo String.
- Resta Representa la diferencia entre dos números o
especifica la condición negativa de uno.
* Multiplicación Multiplica dos números.
1 División Divide un número entre otro.
\ División entera Divide un número entre otro, dando un resultado
necesariamente entero.
Mod Módulo Divide un número entre otro, dando como resul-
tado el residuo.
1\
Exponenciación Sirve para elevar un número a una determinada
potencia; un número puede ser negativo si el ex-
ponente es un entero.
La forma en que se resuelven este tipo de operadores es la siguiente.
Resultado = Expresiónl Operador Expresión2
Expresión1 y Expresión2 serán siempre datos numéricos. Resultado será siempre numérico.
Operador es el operador aritmético utilizado.
Alfaomega 103
SYNAPS PREMIUM
Se debe tomar en cuenta que Resultado puede no ser del mismo tipo que las expresiones,
por ejemplo, la suma de dos Integer, 2,000,000,000 y 2,000,000,000, no será Integer, y la
división de un Integer 3, entre 2, no dará un número Integer.
5.2 Operadores de asignación

Los operadores de asignación son los que permiten asignar un valor a una variable o pro-
piedad. El ejemplo clásico de este tipo de operadores es el signo de igual (=).
Ejemplo.
Variable = Valor
Donde Variable es una variable o propiedad que puede recibir valores, y Valor, una expre-
sión válida para el tipo de dato de Variable.
5.2.1 Expresión
Una expresión es un valor, existente o derivado; es valor existente si corresponde a una lite-
ral válida para un determinado tipo de dato, o una variable que la contenga; es valor deriva-
do, cuando es el resultado de someter varios valores existentes, sean éstos variables o lite-
rales, a la acción de operadores.
Vea los ejemplos siguientes de expresiones.
4 Existente. Valor numérico 4

((A" Existente. Valor String A
4 + 5 Derivado. Valor numérico 9
3 - 2 Derivado. Valor lógico False, pues 3 y 2 no son iguales
((A" & ((B" Derivado. Valor de concatenación String AB
Vea estos otros ejemplos, sí definimos la siguiente variable.

Dim Edad As Integer = 2e
104 Alfa omega

SYNAPS PREMIUM
Expresiones que podemos utilizar.

Edad La variable misma
str (Edad) La transformación de la variable
((Edad:" & Str (Edad) La transformación de la variable y otras literales
5.2.2 Operadores de asignación incluyente

Son operadores de asignación incluyente, aquellos que consideran el valor que posee la va-
riable o propiedad a la que se le asigna el valor como primera expresión de una operación,
asignando el resultado de la operación a la variable misma.
Los operadores de asignación incluyente existen para los siguientes operadores: /\' *, /, \,
+, -, &, y la forma de representarlos es el operador, seguido inmediatamente por un signo
de igual. Veamos las siguientes asignaciones equivalentes.
X - X + 1 Es lo mismo que X += 1
X - X - 1 Es lo mismo que X -- 1
X - X * 4 Es lo mismo que X *= 4
X - X 1\ 2 Es lo mismo que X 1\_
2
Vea los siguientes ejemplos.
Si Var1 vale Y Varzvale La operación Hace que Var1

valga
10 3 var1 "= var2 1000

10 3 var1 *= var2 30
12 3 var1 /= var2 4
10 3 varl \= var2 3
10 3 varl += var2 13
uABC" uDEF" var1 &= var2 uABCDEF"
10 3 var1 -= var2 7
Alfaomega 105
SYNAPS PREMIUM
5.3 Operadores comparativos

Los operadores comparativos son los que permiten comparar expresiones, una en relación a
la otra, proporcionando un valor de falso (False), verdadero (True), o nulo (Null), depen-
diendo si la comparación es una verdad o no.
Hasta el momento no hemos tratado los valores nulos; los valores nulos son la ausencia de
valor alguno, y su utilidad es para aplicaciones específicas en donde la afectación de un va-
lor es importante.
La tabla que sigue describe los operadores comparativos que Visual Basic maneja.
Operador Verdadero si Falso si Nulo si
<
(Menor que) Exp1 < Exp2 Exp1 >= Exp2 Exp1 o Exp2 = Null
<=
~nor o igual que) Exp1 <= Exp2 Exp1 > Exp2 _j Exp1 o Exp2 = Null
>
{Mayor que) Exp1 > Exp2 Exp1 <= Exp2 Exp1 o Exp2 = Null
>= Exp1 >= Exp2 Exp1 < Exp2 Exp1 o Exp2 = Null
~ayor o igual que)
- Exp1 = Exp2 Exp1 <> Exp2 Exp1 o Exp2 = Null
(Igual a)
<> Exp1 <> Exp2 Exp1 = Exp2 Exp1 o Exp2 = Null
(Distinto de)

Resultado = Expresiónl Operador Expresión2
Expresión1 y Expresión2 pueden ser cualquier tipo de expresiones comparables entre sí.
Resultado será siempre lógico (True, False), o nulo (Null). Operador es el operador utili-
zado para la comparación.
Algunos ejemplos del uso de estos operadores son.
«A" = «s" Retorna False
1 > 0.5 Retorna True
2 >= 2 Retorna True
Retorna True
106 Alfa omega

SYNAPS PREMIUM
Tome en cuenta que las letras mayúsculas, para efectos de comparación, tienen un valor en
código ASCII menor a las minúsculas, y por tanto, son menores. Adicionalmente, la "A" es
menor que la "Z".
5.3.1 Consideraciones relativas al código ASCII

El juego de caracteres de 7 bits denominado ASCII (American Standard Code Information
Interchange 1 Código Americano Estándar para Intercambio de Información), es ampliamen-
te utilizado para representar letras y símbolos de un teclado estándar de EE.UU. El juego de
caracteres ASCII es igual que los primeros 128 caracteres (0-127) del juego de caracteres
ANSI, utilizado por las máquinas antiguas.
Es importante que conozca algunas referencias del código ASCII que pueden serie de utili-
dad.
Código ASCII Representa

8 BackSpace (RETROCESO)
13 Enter (INTRO)
32 SpaceBar (BARRA ESPACIADORA)
64
92
Código ASCII Representa

48 al 57 ((0JJ al ((9JJ
65 al 90 <<A" a la uzn
97 al 122 <<a" a la uz"
225 , 233, 237, ((áJJ ((é" , ((í" ,
'
243, 250, 241 ((ó", ((ú", (( ñJJ
Algunas personas, sobre todo aquellas que no tienen su teclado configurado adecuadamen-
te, saben que presionando la tecla ALT, y sin soltar dicha tecla, se escribe con el teclado
numérico un código ASCII, éste aparecerá. Para ello es necesario que el teclado numérico
esté activado (teniendo el BLOQ NUM 1 NUM LOCK Activado).
Alfaomega 107
SYNAPS PREMIUM
De tal forma que:

Al t + 64 Equivale a teclear re@''
Visual Basic, por otro lado, tiene funciones que permiten obtener la representación simbóli-
ca de un código ASCII, así como de obtener el código ASCII a partir de una representación
simbólica. Las funciones que lo permiten son Chr( ) y Ase( ), respectivamente.
Sintaxis.
Chr(CódigoASCII )
Ase(rccaraeter")
Ejemplos.
Chr( 64 ) ~ re@''
Ase ( re@'' ) ~ 64
5.3.2 Option Compare

Uno de los conceptos importantes respecto a la comparación de datos, específicamente de
los datos de tipo cadena (String), es su sensibilidad al reconocimiento de mayúsculas y
minúsculas.
Se dice que un esquema de comparación es case-sensitive, cuando una comparación es sen-
sible a la diferencia entre mayúsculas y minúsculas ("A" 1: "a"); se dice que un esquema de
comparación es non case-sensitive, cuando una comparación no es sensible a la diferencia
entre mayúsculas y minúsculas ("A" == "a").
En el caso de Visual Basic, podemos especificar de qué manera queremos que nuestros pro-
gramas se comporten respecto a las comparaciones. Para ello, utilizamos el estatuto Opti-
on Compare.
Su sintaxis es la siguiente.
Option Compare [Text 1 Binary]
Si se especifica Option Compare Text, las comparaciones se realizarán bajo el esquema

non case-sensitive; si se especifica Option Compare Binary, las comparaciones se reali-
zarán bajo el esquema case-sensitive.
108 Alfa omega

SYNAPS PREMIUM
Option Compare debe especificarse al inicio de los programas, antes de cualquier línea de
código. Si se omite la especificación, el esquema de comparación será case-sensitive (Bi-
nary).
5.3.3 Operadores ls, lsNot y TypeOf

Además de los operadores comparativos comunes, Visual Basic posee dos operadores com-
parativos especiales: Is y Like.
El operador Is es un operador que determina si una variable hace referencia a la misma
posición de memoria que otra.
La forma en que se resuelve este operador es la siguiente.
Resultado = Expresiónl Is Expresión2
Expresiónl y Expresión2 deben ser variables de tipo reference type. Resultado será siempre
lógico (True, False).
Is retornará verdadero (True) si las variables comparadas refieren a la misma posición de
memoria, y retornará falso (False) si refieren a posiciones distintas de memoria.
En ocasiones lo que se desea saber es si un objeto no referencia la misma posición que otro.
Anteriormente, la tarea se debía realizar combinando los operadores Not e ls, de la siguien-
te forma.
I f Not Objetol Is Objeto2 Then Writeline("Diferentes '')
Dado que esta expresión es poco natural en su lectura, Visual Basic incluye el operador
IsNot, que retorna True en caso de que dos objetos no refieran a la misma posición de
•
memona.
La línea de código quedaría como sigue.
If Objetol IsNot Objeto2 Then Wr ite l ine("Diferentes'')
En ocasiones la comparación no se realiza entre un objeto y otro, sino entre un objeto y un

type. Visual Basic incluye un operador denominado TypeOf. . . Is, que retorna verdadero
en caso de que un objeto sea de un determinado type. Por ejemplo, si deseamos saber si la
variable X es de tipo Integer, tendríamos que especificar lo siguiente.
If (TypeOf X Is Integer) Then Writeline("X es Integer")
Alfaomega 109
SYNAPS PREMIUM
5.3.4 Operador Like

El operador Like compara dos expresiones String, no en términos de igualdad, sino en
términos de cumplimiento de un patrón determinado.
Este operador es especialmente útil si tiene que verificar si una cadena de caracteres com-
puesta obedece a un formato predefinido. Imagine un código de producto que siempre sea
tres letras, un guión, y cuatro números; en ese caso, tiene dos opciones: utilizar Like o
desarrollar una rutina que analice caracter por caracter la expresión y sus posiciones. Sobra
decir que utilizar Like es mucho más efectivo.
La forma en que se resuelve este operador es la siguiente.
Resultado = Expresi6n1 Like Expresión2
Expresiónl debe ser expresiones String. Expresión2 es un patrón String que se pretende
reconocer como existente en Expresiónl. Resultado será siempre lógico (True, False).
Like retornará verdadero (True) si el patrón a buscar es reconocido dentro del dato
String base de la comparación, y falso (False) en caso de que no se reconozca.
El patrón a buscar, llamado patrón nominado, es una literal conformada por caracteres es-
peciales que representan el contenido de caracteres a buscar; a continuación una tabla que
muestra dichos caracteres y su significado.
Caracter de Significado
patrón
)
• Cualquier caracter
* Varios caracteres o ninguno

# Cualquier dígito (0-9)
[lista] Cualquier caracter en la lista
[!lista] Cualquier caracter que no esté en
la lista
110 Alfa omega

SYNAPS PREMIUM
Vea Jos siguientes ejemplos.

"F" Like "F" Retorna True
rr24/18/2882" Like rr##/##/###W' Retorna True
rrABC" Like rrAB*" Retorna True
rrMP3" Like rr[A-Z] [A-Z]#" Retorna True
rrMPG" Like rr[A-Z] [A-Z]#" Retorna False
"MP3" Like "[A-Z][A-Z]?'' Retorna True
rrMPG" Like rr[A-Z] [A-Z] ?" Retorna True
rrAMERICA" Like rrA*A" Retorna True
"HP2992" Like rr[!H]*'' Retorna False
"DP2992'' Like cr[!H]*" Retorna True
"micorreo@mail . com" Like "*@*'' Retorna True
Recomendamos que utilice Jos patrones para determinar la validez de formatos mixtos de
datos, por ejemplo claves de cuatro letras y tres números.
Si lo que va a evaluar son formatos más estándar, como números o fechas, recomendamos
otras funciones más sofisticadas, como IsNumeric () o IsDate( ).
5.4 Operadores lógicos

Los operadores lógicos son aquellos que sirven para unir o negar condiciones, produciendo
un valor lógico. Los operadores lógicos básicos son.
l. Not . niega el resultado de una condición. Revierte el valor; si la condición que afecta es
True producirá False, y viceversa.
2. And . cuando de entre dos condiciones, las dos deben ser True para que en su conjunto la
expresión sea True. (Todas las condiciones True , retronará True).
3. Or . cuando de entre dos condiciones, al menos una debe ser True para que en su conjunto
la expresión sea True. (Al menos una condición True , retronará True).
4. Xor . cuando entre dos condiciones, al menos una cumple por True, pero no las dos.

Resultado = [Expresiónl] Operador Expresión2
Expresiónl y Expresión2 son expresiones de tipo lógico. En el caso de Not, Expresiónl no se

debe poner, ya que el operador actúa sobre una sola expresión. Resultado será siempre lógi-
co (True, False).
Alfaomega 111
SYNAPS PREMIUM
Cuando una expresión lógica se compone por una sola comparación, se dice que es una ex-
presión lógica simple, debido a que sólo se resolverá en un tiempo; si involucra dos o más
comparaciones, o la utilización de un operador lógico, se dice que es una expresión lógica
compuesta, debido a que la expresión lógica deberá resolverse en dos o más tiempos (se
resuelve la comparación, y luego se resuelve dentro del contexto en que se encuentra). Una
expresión lógica compuesta siempre se compone de expresiones lógicas simples, afectadas
por operadores lógicos que las obligan a resolverse como una sola expresión lógi-
ca.Ejemplos.
Not True Es False, porque es lo contrario a True.

Not False Es True, porque es lo contrario a False. _j
Not uA" = uB" Es True, porque ((A" = uB" es False, pero negado
es True.
ccAJJ - uB" And 1 > e.s Es False, porque no todas las condiciones son True. j
ccAJJ - uB" or 1 > e.s Es True, porque al menos una condición es True. 1
En caso de que tenga más de dos condiciones conjuntas, entra en operación lo que se cono-
ce como preferencia, que consiste en determinar el orden en que las condiciones u opera-
ciones se han de resolver.
Ejemplo.
uAJJ = ccB" OR 1 > e.S ANO 2 >= 2 ANO ccsn > uS11
Es False. Las condiciones se resuelven de izquierda a derecha. Vea la explicación basada en

la figura 05.01.
112 Alfa omega

SYNAPS PREMIUM
-··-- -··-
Figura "A" - i ~
"B" oRI 1 > O. S.' ANO ' 2 >= 2 IANO "s" > " s "
05.01
Resolución de
.,
?
False
•
OR True i ANO
•
True ANO False
una expreswn
con múltiples Tr ue ANO TrUe ¡ANO False
'
condiciones
1
'~..-- __ --~~~
T~ue
......,
. ·Fa1se .1
Li~J.:~
Primero se resuelven las condiciones de comparación.

1. Ya que se resolvieron las condiciones de comparación, se sigue el orden de iz-
quierda a derecha; la primera condición de tipo lógico se resuelve; el resultado de
ésta forma parte de la siguiente condición, y así hasta terminar.
2. La expresión inicia siendo una expresión lógica compuesta, formada por cuatro
expresiones lógicas simples, que con la ayuda de tres operadores lógicos, se ven
obligadas a resolverse como una sola expresión lógica que termina con un valor
False.
Las condiciones se resuelven como si tuvieran paréntesis imaginarios.

( ( ("An = "B,, Or 1 > e.5) And 2 >= 2) And "Sn > ''s,,)
En donde las condiciones encerradas en los paréntesis de mayor profundidad se resuelven

.
pnmero.
Si usted agrega de manera explícita paréntesis en las condiciones, les asignará preferencia.
Por ejemplo, cambiemos un poco el orden del ejemplo anterior y veamos qué sucede.
"Sn > "s» Or 2 >= 2 And 1 > e.s And "An = "Bn
De acuerdo a lo que vimos, se resolvería la primera condición con la segunda (False Or

True, se resuelve a True), el resultado se resolvería con la tercera (True And True, re-
torna True), y el resultado se resolvería con la cuarta (True And False, retorna False).
El resultado de lo último que se resolvió fue False.
Alfaomega 113
SYNAPS PREMIUM
¿Cómo cambiaríamos la condición, mediante el uso de paréntesis, para que el resultado fue-
ra verdadero? A continuación una solución.
(uS" < us" OR ( 2 >= 2 ANO 1 > e.S And uA" = uB"))
De esta forma forzamos que en primera instancia se resuelva el paréntesis de mayor pro-
fundidad, que contiene la segunda, tercera y cuarta expresión (True And True And Fal-
se, retrona False), el resultado se resuelve con la primera condición, por ser el paréntesis
de mayor profundidad que sigue (True Or False, resuelve True).
Considere como regla que siempre que abra paréntesis los tiene que cerrar.
Una inadecuada colocación de condiciones puede arrojar resultados erróneos; le recomen-
damos que aunque de forma predefinida existe una preferencia, usted determine claramen-
te qué preferencia desea, utilizando paréntesis cuando tenga más de una condición por re-
solver.
5.4.1 Operadores lógicos de circuito corto

En programación es común que para que algo suceda, debe cumplirse más de una condi-
ción. Uno de los problemas que tenía la anterior versión de Visual Basic, es que no era lo
suficientemente inteligente para saber que ya no tenía caso resolver ciertas condiciones, en
el caso de And y Or.
Sabemos que en el caso de And, si una expresión lógica es False todo es False; si en una
comparación nos encontramos que la primera expresión lógica es False, ¿qué caso tiene
resolver la segunda expresión?
Se denominan operadores lógicos de circuito corto (short- circuiting), aquellos que son lo
suficientemente inteligentes como para determinar la necesidad de continuar evaluando
condiciones posteriores a las primeras.
Básicamente son dos.
1. AndAlso. procesa comparaciones lógicas de circuito corto, de tipo And; produce
False a la primera expresión False que se encuentra, y concluye con la resolu-
ción de expresiones.
2. OrElse. procesa comparaciones lógicas de circuito corto, de tipo Or; produce
True a la primera expresión True que se encuentra, y concluye con la resolución
de expresiones.
114 Alfa omega

SYNAPS PREMIUM
Tabla de comportamiento de operadores lógicos

La siguiente tabla muestra el comportamiento de los operadores lógicos.
Operador Si Expresión1 es y Expresión2 es Resultado

And True True True
1
r
And ----- True False -- -
False
And False True- -·- - - - - -·--·---·--·-·-----·-·-· False
L-·-·-·--·--·-·--·--·-- t-.-----
And False False
--·---
False
- ---------
Or
·--·-·-..-·-·-..-·-·-·· .-·
True
,,_,, '
True
··-·-·-·-·-·-·--·--·-·-·-·-·--· ·--·--·--·-·--·--·-·--·-·--·--·---·-..-·-·-..-·-·-····..... -··-·· ·-···
True ... .......
' ' - ,_,_,_,_,__ __,_,..,_.__,_,_,_,_
,
~
·
·
Or
................- ....... .. ..
,_ , ,, ,_,_,_,_,
True
-·-·- False
....·-·-·-·...-............-........-...·-·-·-·-................ ··-·- ·-··-·- ·-·- ·-·- ·-··-··-·····-··-·-··-·- ·-·- ·-··-·····-·····-··-·- ·-··-·-..-· .....-..............._,_,_,_,... ..,_.......
~
True _.,., ,_,_,_,_,_,_,_,_,_,,_,,_,_,,_,_
Or
~··-··-··-··-··-··-··-··-·-··-·-··-··-·-·
False True True
r.............·-·-·-·-..................................- .......................... ··-··-·-··-·-··-·- ·-··-·····-··-·-··-··-·-··-·-··-··-·-··-·····-··-·-··-·- ·-............ ..................................,_........-..........................-...·-·-··-·····-··-·-··-··-
Or False False False
Xor
......................................................
True
...............................................................................-......... ..-True False
...............................................................................................- ............... -·-··-·-··-········-·-·-·-·..................................................................-.......
Xor True False
-·-··-·-·-··-·-·-·-·-·-·-·-·-·-· -·-·-·-·-·--·--·-·-··-·-·-·-·-·-·-·-·-·-·-·-·-··-· ·-·- ·-··-·- ·-·- ·-··-·- ·-··-·-··-··-·- ·-·- ·-··-·- ·-·····-··-·- ·-·-·--·-·-· -·-·-·-·-·-·-·-·-·-·-·--·-·-··-·-·-··-·-·-·-·-·-·-·-·-·-··-·-·-··-
True
Xor False True
·-·-··-··-·-··-·-·--·-·--·--·-· ¡¡_.-·---·--·------·-·-·-·-·-·-··-··-·-·-·--· ·-··-·-··-·-·-·-·-·-··-·-·-·-·-·-·-·-·-·-·-·-·-·-·--·-·--·--·-·-· r--·--------·--·---·-·-··-·-·-·-·-·-·-··-·-·-·-·-·- -
True
Xor False False False
'-·---·---·-----·---· L~.rue
AndA! so True True
·---·-----·------ ··-- ··- ---
AndA! so - True False False
AndA! so False Ni siquiera se evalúa False
AndA! so False Ni siquiera se evalúa False
OrE! se True Ni siquiera se evalúa True
OrE! se True Ni siquiera se evalúa True
OrE! se False True True
OrE! se False False False
5.5 Prioridad entre operadores

Cuando hay varias expresiones dentro de una expresión que las engloba, cada parte de la
misma se evalúa y se resuelve en un orden predeterminado, donde ciertos operadores han
de resolverse antes que otros, a lo que se llama prioridad de los operadores. Esto es impor-
tante, ya que algunos operadores requieren resolver expresiones derivadas antes de poder
ser resueltas.
Por ejemplo.
(2+5) > (3+1)
115
SYNAPS PREMIUM
No podemos resolver la expresión que implica el operador comparativo (>),sí antes no re-
solvemos las expresiones que involucran el operador de suma (+). El procesador no resuel-
ve operaciones a nivel abstracto.
Cuando hay expresiones que contienen operadores de más de una categoría (aritméticos, de
comparación y lógicos), se resuelven en este orden.
l. Las expresiones que tienen operadores aritméticos.
2. Las expresiones que tienen operadores de comparación.
3. Las expresiones que involucran operadores lógicos.
Esto tiene sentido si tomamos en cuenta que la materia prima para los operadores aritméti-
cos son generalmente expresiones numéricas o expresiones String, y con ellos se genera
una nueva expresión numérica o expresión String.
Los operadores de comparación, por su parte, tienen como materia prima dos expresiones
numéricas o expresiones String, y con ellos se determina un valor lógico.
Por último, los operadores lógicos permiten generar una expresión lógica de dos expresio-
nes lógicas.
Los operadores de comparación tienen la misma prioridad, es decir, se evalúan de izquierda
a derecha, en el orden en que aparecen. Los operadores se evalúan en el siguiente orden de
prioridad.
Comparación Lógicos
Aritméticos
Igualdad ( =) Not
Exponenciación (")
Desigualdad ( <>) And
Negatividad de expresión (-)
Menor que ( <) Or
Multiplicación y división ( *, !)
Mayor que ( >) Xor
División de enteros ( \)
Menor o igual que ( <=)
Módulo aritmético ( Mod)
Adición y substracción ( +, -) Mayor o igual que ( >=)
Cuando hay multiplicación y división en la misma expresión, cada operación se evalúa a

medida que aparece, de izquierda a derecha. Del mismo modo, cuando se presentan adicio-
nes y substracciones en una misma expresión, cada operación se evalúa tal como aparecen
de izquierda a derecha.
116 Alfa omega

SYNAPS PREMIUM
5.5.1 Uso de paréntesis para otorgar preferencia de ejecución

Es posible usar paréntesis para saltar el orden de preferencia y forzar que algunas partes de
una expresión se evalúen antes que otras. Las operaciones entre paréntesis se realizarán
antes que aquellas que se encuentren fuera. Sin embargo, dentro de los paréntesis, la prio-
ridad de los operadores se mantiene según las reglas.
Cuando utilizamos los paréntesis para determinar un orden determinado en que se han de
resolver las expresiones, hablamos que se está especificando la preferencia de ejecución ex-
plícita. Cuando dejamos que el lenguaje proporcione el orden de izquierda a derecha, aten-
diendo a la prioridad de los operadores, hablamos de la preferencia de ejecución automática.
Los programadores profesionales acostumbran el uso de la preferencia de ejecución explíci-
ta, ya que es más fácil de analizar al momento de depurar los programas, y deja una idea
clara de la forma en que queremos que las cosas se resuelvan.
El operador de concatenación de cadenas ( &) no es realmente un operador aritmético, pero
en orden de prioridad se encuentra a continuación de todos los operadores aritméticos y
antes que todos los operadores de comparación.
No olvide que por más larga que parezca una expresión, todos los operadores actúan sobre
dos expresiones, y de dos en dos, hasta dejar una sola expresión final, que podrá ser asigna-
da a una variable o propiedad, o utilizada por algún estatuto o función.
~ Lab.05.01: Utilización general de operadores de Visual

Basic
En este ejercicio se utilizará una aplicación de consola para comprobar la declaración y uso
de variables en un proceso.
3. Asigne como nombre Operadores .
4. El código debe quedar como sigue:
1 Module Modulel
2 Sub Main()
3 Dim Numerol As Integer = 5
4 Dim Numero2 As Single = 2
Alfaomega 117
SYNAPS PREMIUM
5 Dim Textol As String = "Visual "

6 Dim Texto2 As String = "Basic.NET"
7 Console .Writeline(Numerol)
8 Console .Writeline(Numero2)
9 Console .Writeline(Numero1 + Numero2)
le Console .Wri teline(Numero1 - Numero2 )
11 Console .Writeline(Numero1 * Numero2)
12 Console .Writeline(Numerol 1 Numero2)
13 Console .Writeline(Numerol \ Numero2)
14 Console .Writeline(Numerol Mod Numero2)
15 Console .Writeline(Textol Is Texto2)
16 Console .Writeline(Texto1 IsNot Texto2)
17 Console .Writeline(Texto1 + Texto2)
18 Console .Writeline(Textol.Trim() + Texto2.Trim())
19 Console .Writeline(Texto1.Trim() + '' '' + Texto2.Trim())
2e Console .Writeline( ''Pulse INTRO para continuar'' )
22 End Sub
23 End Module
S. Establezca el proyecto Operadores como proyecto de inicio, e inicie la

depuración.
6. Los resultados deben ser los siguientes:
• fii~J1/C:/Users/felope/documents/visual studio 2012/Projects/{jercicios/Operadores/bin/Oeb ug/0-
118 Alfa omega

SYNAPS PREMIUM
a) Comentando bloques de código
7. En ocasiones requerimos comentar una buena cantidad de líneas de código. La

alternativa más laboriosa y demandante de tiempo es colocar apóstrofe al inicio
de cada línea. La otra alternativa es utilizar las herramientas de Visual Studio.
8. Seleccione de la línea 7 a la 21.
9. el botón Comment out the selected fines, en la barra de herramientas,

1+.;:> 1 Presione
o seleccione Edit - Advanced - Comment Se/ection, o presione la secuencia de
teclas CTRL+K, CTRL+C.
a. Esta secuencia de teclas se especifica presionando CTRL+K, soltando, e
inmediatamente presionando CTRL+C.
10. Se debieron haber comentado todas las líneas que estaban seleccionadas.
11. Marque nuevamente las líneas de la 7 a la 21, que actualmente se encuentran
comentadas.
~
12. 1 1 Presione el botón Uncomment out the selected fines, en la barra de
herramientas, o seleccione Edit - Advanced - Uncomment Selection, o presione la
secuencia de teclas CTRL+K. CTRL+U. Se debieron haber removido los apóstrofes
de las líneas comentadas.
DI WBVBVS2012.05.01- Comments.wmv
b) Uso de Clipboard Ring
13. Una de las funciones más usuales con un editor de textos es copiar y pegar código,
a lo que conocemos como Copy-Paste.
a. Generalmente realizamos operaciones de Clipboard usando CTRL+C o CTRL+X
para copiar o mover el contenido seleccionado al Clipboard del equipo, que es la
memoria temporal de trabajo en el ambiente Windows.
b. Una vez que tenemos algo en Clipboard, podemos pegar su contenido en un lugar
determinado, presionando CTRL+V.
c. Existe la creencia generalizada que sólo se mantiene en Clipboard lo último que
copiamos.
14. El Clipboard en Visual Studio realmente almacena hasta las últimas 20 cosas, que
haya copiado o movido en él, y pueden ser extraídos utilizando CTRL+MAYUS-V.
Al reunirse 20 contenidos en Clipboard y tratar de agregar uno más, el contenido
Alfaomega 119
SYNAPS PREMIUM
más antiguo se pierde, y el nuevo contenido toma la primer posición de

recuperación. Clipboard tiene una organización de recuperación LIFO (Last In,
First Out/ Ultimas entradas, primeras salidas), que da lugar a lo que se conoce
como Clipboard Ring.
15. Seleccione la línea 6 de código, y presione CTRL+X.
16. Seleccione la línea S de código, y presione CTRL+X.
19. En este momento, Clipboard tiene 4 valores almacenados:
...
4: Di m Numerol As Integer = 5
3: Dim Numero2 As Single = 2
2: Dim Textol As String - "Visual "
1: Di m Texto2 As String = "Basic.NET" ...
20. Vaya a la línea después de Sub Main( ), y presione CTRL+SHIFT+V, cuatro veces.
a. Vea cómo a medida que va presionando la combinación de teclas, van apareciendo
los diversos valores que fueron almacenados.
21. Presione CTRL+SHIFT+V, tres veces.
22. Presione CTRL+SHIFT+V, dos veces.
23. Presione CTRL+SHIFT+V, una vez.
24. Su código ha quedado como al principio.
25. Imagine las posibilidades de almacenar en Clipboard los nombres de las variables
de uso más común en un proceso, y estarlas invocando de manera rápida en
nuestra edición.
e) Selección basada en bloques de código (Block Selection)
26. Viendo nuestro código nos podemos dar cuenta que Console se repite en
múltiples ocasiones. Se puede simplificar el código agregando un Import al inicio
del programa, eliminando el nombre de la clase Console en todo nuestro código.
El problema es quitar Console de las líneas, dado que tendríamos que quitarlo
líne por línea.
120 Alfa omega

SYNAPS PREMIUM
27. Utilizando la selección line-based no podemos seleccionar únicamente el nombre

del objeto Con sol e de todas las líneas, sin marcar el resto de la línea.
28. Visual Studio permite Jo que se conoce como selección basada en bloques (Block
Selection ), que implica seleccionar un área rectangular del área de edición.
29. Trace un rectángulo que encierre los nombres de objeto Console en el área de
edición. Para hacerlo, presione la tecla ALT y déjela presionada, Juego arrastre el
puntero del ratón desde la esquina superior izquierda de lo que quiere marcar,
hasta la esquina inferior derecha. No olvide incluir el punto de Console.
_, WBVBVS2012.05.02- Block Selection.wmv
30. Habiendo hecho la selección, presione CTRL+X, para enviar el contenido a

Clipboard, con lo cual quitamos las referencias del código.
31. Vaya al inicio del programa, y antes de cualquier otra línea agregue la siguiente.
Imports System.Console
32. Establezca el nuevo proyecto como proyecto de inicio (StartUp Project) e inicie la
depuración de su programa (FS).
FIN DEL EJERCICIO *
~ lab.OS.02: Representando con operadores casos de la vida
real.
En este ejercicio deberá representar con operadores Jos siguientes casos. Analícelos, y
utilice los operadores que crea convenientes.
1. El Teorema de Pitágoras establece que en todo triángulo rectángulo, el
cuadrado de la hipotenusa (el lado de mayor longitud del triángulo
rectángulo) es igual a la suma de Jos cuadrados de los catetos (los dos lados
menores del triángulo, es decir, los que conforman el ángulo recto).
Alfaomega 121
SYNAPS PREMIUM
2. Gráficamente, sería como sigue:
3. En ese sentido:
4. Suponiendo que a, b y e, son variables ya definidas, represente las formulas

del punto anterior, en su representación en código.
122 Alfa omega

SYNAPS PREMIUM
S. Un banco desea automatizar de forma rápida la pre-aprobación de una tarjeta

de crédito, misma que sólo dará sí:
a. La persona no tiene mal historial crediticio.
b. La persona tiene un ingreso mensual superior a $12,000.
c. La persona no tiene más de 65 años.
6. Aplican las siguientes excepciones.
a. Si es empleado del banco, se le otorga.
b. Si es mayor de 65 años, pero sus ingresos mensuales exceden $50,000,
se le otorga.
c. Si la persona está casada y el cónyuge es empleado del banco, se le
otorga.
d. Ninguna de las excepciones aplicará en caso de que la persona tenga
mal historial crediticio.
7. La variable Ap es una variable booleana, en donde True implica que sí se le
otorga, y False, que no.
8. La aplicación recopila los siguientes datos (Variable, (Valores]):
a. Hi: [1] Bueno, [2] Malo. -> Historial crediticio.
b. In: [Integer]. ->Ingresos.
c. Ed: [Integer]. ->Edad.
d. EB: [S] Si, [N] No. ->Empleado del banco.
e. Ca: [S] Sí, [N] No. -> Casado.
f. CEB:: [S] Sí, [N] No. - >Cónyuge empleado del banco.
9. Elabore la expresión lógica que resuelve Ap.
Ap= (
)
FIN DEL EJERCICIO*
Alfaomega 123
SYNAPS PREMIUM
Estructuras de Decisión y Control
Competencias:
l. Conocer el manejo de los
procesos condicionales con
ejecución en el sentido
afirmativo y en el sentido
negativo.
2. Utilizar Select Case para
ejecutar procesos mutuamente
excluyentes, dependiendo de
un valor.
3. Conocer el manejo de las
estructuras de control para
manejar procesos iterativos.
Evaluación:
l . Proporcionar un caso
en donde se deban Evidencia de
aplicar estructuras de aprendizaje:
decisión y de control Capacidad de identificar la
1.
para obtener un necesidad de aplicar
resultado. estructuras de decisión y
control, a partir de un caso.
2. Capacidad de implementar
estructuras de decisión y
control en programas.
3. Capacidad de analizar código
que incluye est ructuras de
decisión y control, y
determinar problemas típicos.
SYNAPS PREMIUM
6: Estructuras de Decisión y Control

6.1 Estructuras de decisión ...................................................................................................................................... 12 7
6.1.1 Estatuto IfThen Else (condicional) ........................................................................................................ 127
6.1.2 Select Case ....................................................................................................................................................... 129
6.2 Estructuras de control 130
•••••• o o ••• o • o . . . . . . . . . o •••••• o • o ••••• o o •••••••••••••• o •••••••••••••••••••••••• o •••••• o o •••••••• o ••••• o •• o •••••••••••• o o ••• o • o •••••• o •••
6.2.1 For Next ............................................................................................................................................................ 131

6.2.2 While .................................................................................................................................................................. 132
6.2.3 Do Loop ............................................................................................................................................................. 133
6.3 Estructuras envolventes y anidadas.............................................................................................................. 135
6.3.1 Reglas para el anidado de estructuras .................................................................................................. 135
~ Lab.06.01: Uso de estructuras de decisión ................................................................................................... 136
~ Lab.06.02: Uso de For Next ................................................................................................................................. 139
a) Agregando tareas a Task Líst..................................................................................................................... 143
b) Agregando comentarios de tarea a un programa ............................................................................... 144
~ Lab.06.03: Identificando errores en estructuras anidadas .................................................................... 145
~ Lab.06.04: Decidiendo el uso de estructuras de decisión y de control. ............................................. 146
126 Alfa omega

SYNAPS PREMIUM
Unidad 6: Estructuras de Decisión y Control
6.1 Estructuras de decisión

Los programas de computadora son secuencias de instrucciones que se ejecutan de manera se-
cuencial. Una parte importante de los programas es que permiten definir escenarios en los cua-
les, dadas ciertas condiciones, las tareas a realizar tienen variaciones.
Son estructuras de decisión aquellas estructuras del lenguaje que permiten decidir qué líneas de
código se han de ejecutar, dependiendo de una condición determinada.
6.1.1 Estatuto lf Then Else (condicional)

El estatuto condicional (If) ejecutará instrucciones dependiendo del valor de una condición que
deriva en una expresión lógica (dato de tipo Bool ean).
Como If tiene muchas variantes, examinaremos varias sintaxis que le aplican.
He aquí la más sencilla:
If ExpresiónLógica Then Instrucción
Donde If es el inicio de la estructura de decisión, ExpresiónLógica es la expresión de tipo Boo-

lean que determina la ejecución de Instrucción, que en este caso sólo puede constar de una sola
instrucción.
Ejemplo.
If Precio < CreditoDisponible Then Cargo = "Aprobado»
Sólo en caso de que ExpresiónLógica derive en un valor de True, Instrucción será ejecutada; esta
sintaxis de If controla sólo la ejecución en el sentido afirmativo de la condición.
Esta forma de If es muy útil para asignar valores a las variables, en caso de que una condición
se cumpla.
Un bloque de código es un conjunto de líneas de código que tienen su propio alcance de ejecución,
y que están siempre delimitadas. Si la ejecución de un bloque de código depende del cumplimien-
to de una condición, es necesario que se delimite la estructura de decisión; el bloque de código
será entonces todo lo que se encuentre entre el estatuto If y el estatuto End If.
If ExpresiónLógica Then
1nstrucciones
End If
Alfaomega 127
SYNAPS PREMIUM
Donde If es el inicio de la estructura de decisión, End If es el fin de la estructura de decisión, y

todas las Instrucciones que se encuentran en el inicio y el fin, constituyen el bloque de código que
es controlado por la condicional. ExpresíónLógíca es la expresión de tipo Boolean que determina
la ejecución de Instrucciones, que en este caso puede constar de una sola instrucción o de muchas.
Sólo en caso de que ExpresiónLógica derive en un valor de True, Instrucciones será ejecutada;
esta sintaxis de If controla sólo la ejecución en el sentido afirmativo de la condición.
Ejemplo.
If Precio < CreditoDis poni ble Then

Ca rgo = rrAprobado"
Cr edi t oDis ponible -= Precio
End If
If es un estatuto de bloque, por lo que si inicia un bloque tendrá que concluirlo. Un error muy
común es que se abren estructuras de decisión, pero no se cierran; es de mucha utilidad darle
organización al código, proporcionando diferente alineación tabulada a las líneas inicio y fin de la
estructura de decisión, y al bloque de código controlado por dicha estructura. Vea nuestros ejem-
plos: If y End If nunca se encuentran con el mismo margen izquierdo que el bloque de código
que controlan; no trate de ser original al respecto, pues con ello sólo logrará que la gente se dé
cuenta que es un programador novato y poco organizado.
Es posible que If controle al mismo tiempo la ejecución en el sentido afirmativo y en el sentido
negativo, a través de la especificación El se. Vea la sintaxis.
If ExpresiónLógica Then
lnstruccionesAfirmatívo
El se
lnstruccionesNegativo
End If
Donde If es el inicio de la estructura de decisión, End If es el fin de la estructura de decisión, y

todas las Instrucciones que se encuentran entre el inicio y el fin, constituyen el bloque de código
controlado por la condicional, pero está dividido en dos bloques de código diferentes, uno que se
ejecutará sólo si Expresión Lógica es True (lnstruccionesAfirmatívo), y otro que sólo se ejecutará si
Expresión Lógica es False (lnstruccíonesNegatívo).
128 Alfa omega

SYNAPS PREMIUM
Ejemplo.
If Precio < CreditoDisponible Then

Cargo = ((Aprobado"
CreditoDisponible -= Precio
El se
Cargo = uoenegado"
End If
ExpresiónLógica es la expresión de tipo Boolean que determina ejecución de lnstruccionesAfir-

mativo o lnstruccionesNegativo.
Esta sintaxis de If controla la ejecución en el sentido afirmativo de la condición, o en el sentido
negativo; como podrá intuir, siempre se ejecutará algo.
6.1.2 Select Case
Select Case es una estructura de decisión que permite ejecutar procesos mutuamente exclu-
yentes, en función a comparaciones realizadas sobre un mismo valor de referencia.
Su sintaxis se encuentra a continuación:
Select Case ExpresiónAEvaluar
Case {Condición 1 Else}
Instrucciones
End Select
Donde ExpresiónAEvaluar es una expresión de cualquier tipo, que será tomada como referencia.
Condición sirve para especificar una condición relacionada con ExpresiónAEvaluar, que en caso de
presentarse, motiva la ejecución de Instrucciones.
Se va construyendo un árbol de decisión basado en una ExpresiónAEvaluar. Se pueden agregar
tantas sentencias Case como se deseen, e incluso las estructuras Select Case se pueden anidar.
Si al momento de evaluar Condición, un determinado valor de ExpresiónAEvaluar cumple en dos
casos, se ejecutará para la primera que se encuentre. Case Else aplica cuando el valor de Ex-
presiónAEvaluar no cumpla para ninguno de los casos anteriores, dentro de la estructura.
Para ver cómo funciona este estatuto, imagínese la siguiente situación hipotética: Una compañía
tiene 35 categorías de empleados; cada categoría tiene un ingreso determinado, en donde las ca-
Alfaomega 129
SYNAPS PREMIUM
tegorías de número más alto son las de mayor ingreso por salario, existiendo una relación direc-
tamente proporcional entre categoría y sueldo.
Se acaba de autorizar un aumento de sueldo general en la compañía, bajo las siguientes políticas:
el personal de alto nivel (categoría superior a 19) no tendrá aumento; las categorías 18, 17 y 14
recibirán el15% de aumento; de la categoría 8 a la 13, recibirán ellO% de aumento, a excepción
de la categoría 10, que es la categoría más rezagada con respecto al salario, pues recibirá el 25%.
Al resto del personal, se le dará un 5% de aumento.
¿Cómo se codificaría una estructura Select Case que atendiera esta necesidad? Veamos.
Select Case Categoria
Case Is > 19
Aumento = e
Case 18, 17, 14
Aumento - e.15
Case 1e
Aumento - e.25
Case 8 To 13
Aumento = e . 1
Case Else
Aumento = e . S
End Select
Vea cómo se especificaron las condiciones y aplique la sintaxis en aquellos casos que lo requiera.
Es importante que se dé cuenta que todas las condiciones giran con relación a la ExpresiónAEva-
luar (en nuestro ejemplo, Categoria ), ya que si no hace uso de dicha expresión, no son conside-
radas. Usted puede agregar como instrucción la línea con una condición Case que se resuelva
True, pero que no involucre a Categoria; en ese caso, el código dependiente de dicho Case nun-
. ,
ca se e¡ecutara.
6.2 Estructuras de control

Son estructuras de control, llamadas también bucles, aquellos elementos del lenguaje que permi-
ten la ejecución de una o más líneas de código de manera repetida.
Mediante las estructuras de control se puede repetir la ejecución de líneas de código.
o Un determinado número de veces
o Hasta que una condición sea verdadera (True)
o Mientras que una condición es falsa (False)
o Una vez por cada elemento de una colección
130 Alfa omega

SYNAPS PREMIUM
Se analizarán los elementos del lenguaje que nos permiten codificar cada una de estas variantes.
6.2.1 For Next

For Next repite la ejecución de un bloque de código un número determinado y conocido de ve-
ces. For Next se apoya en una variable que recibe el nombre de contador, que se incrementa o
reduce de valor, en intervalos también regulares y conocidos.
For Variable= Valorlnicial To ValorMáxímo [Step Incremento]
Instrucciones
Next [Variable]
Donde Variable es una variable de memoria de tipo entero, que permitirá controlar las repeticio-
nes del proceso. Valorlnicial es el valor inicial a partir del cual el incremento o decremento se
llevará a cabo. ValorMáximo es el valor al cual el contador podrá llegar. Incremento es la constan-
te entera que marcará la cantidad de incremento o decremento que sufrirá Variable en cada repe-
tición del proceso.
Ejemplos.
1
Cuenta del 1 al lB
For i = 1 To 1e
Console . Writeline(i)
Next i
1
Serie del S
For i = e To se Step S
Console.Writeline(i)
Next i
1
Decremento del 10 al 1
For i = 10 To 1 Step -1
Console.Writeline(i)
Next i
Si se omite la especificación Step, se asume Incremento con valor de 1 positivo. Si Incremento es

negativo, hablamos de un decremento, en términos reales. Una instrucción que puede ser útil en
el caso de utilizar For Next es Exi t For, que interrumpe la ejecución del For como si ya hubie-
se cumplido todas las repeticiones exigidas.
Alfaomega 131
SYNAPS PREMIUM
6.2.2 While
While ejecuta un bloque de código un tiempo infinito de veces, mientras una condición al inicio
del bloque se cumpla por verdadero (True).
La sintaxis es la siguiente.
While Expresiónlógica
Instrucciones
End While
Ejemplo.
Dim Prueba As Byte - e

While Prueba < 255
Console . Writeline(Prueba)
Prueba += 1
End While
Donde ExpresiónLógica es un valor de tipo Boolean (Truej False), casi siempre una compara-
ción, que de ser verdadera al inicio del ciclo de ejecución, provoca la ejecución de Instrucciones.
Como recordará, los tipos de datos Byte sólo pueden almacenar valores desde Oa 255; en nues-
tro ejemplo, While ejecutará un incremento de 1 para la variable Prueba, mientras sea menor a
255. Si dejáramos que el ciclo fuera más allá de 255, el programa generaría error, pues es impo-
sible que una variable de tipo Byte asuma un valor fuera de su rango.
Al igual que For Next, While tiene una sentencia para interrumpir en cualquier momento el pro-
ceso: Exi t While.
Una de las formas más útiles de While es el ciclo infinito, en donde ninguna operación o variable
dentro del proceso influye en la condición que gobierna la estructura. Simple y llanamente, se
proporciona el valor de True como ExpresiónLógica, y no hay forma que deje de ejecutarse el ci-
clo.
While True
Instrucciones
End While
132 Alfa omega

SYNAPS PREMIUM
Ejemplo.
While True
Console.WriteLine("Qué número estoy pensando")
If Console.ReadLine() = 8 Then
Console.WriteLine(''Efectivamente: 8'' )
Exit While
End If
End While
En este caso, es indispensable que provea a su programa de algún momento en el proceso para
ejecutar Exi t While, ya que de otra manera, nunca concluirá la ejecución del programa, a lo que
se le conoce como ciclo infinito. En caso de que, por error, el programa produzca un ciclo infinito,
éste se puede romper presionando CTRL+ENTER, o ESC.
En el ejemplo que pusimos, mientras no teclee un 8, el programa seguirá pidiendo números.
6.2.3 Do loop
Do Loop ejecuta un bloque de código un tiempo infinito de veces, hasta que una condición se
cumpla por verdadero (True). Esta instrucción brinda más flexibilidad que While, en el sentido
que se puede controlar la evaluación de las condiciones al inicio o al final de la estructura. Usan-
do Do Loop se pueden hacer estructuras que se ejecutan al menos una vez, de una forma más
sencilla que utilizando While.
e Evaluación al inicio
Do {While/Until} ExpresiónLógica
Instrucciones
Loop
e Evaluación al final
Do
Instrucciones
Loop {While/Until} ExpresiónLógica
Alfaomega 133
SYNAPS PREMIUM
Donde ExpresiónLógica es un valor de tipo Boolean (Truej False), casi siempre una compara-
ción. Instrucciones son las instrucciones que se están gobernando en el bucle.
Si se utiliza Do con While (mientras), el ciclo se repite hasta que ExpresiónLógica sea falsa.
Si se utiliza Do con Until (hasta), el ciclo se repite hasta que la condición sea verdadera. Sólo se
puede implementar While o Until, pero no ambas. También tiene que decidir si la evaluación de
las condiciones es al inicio o al final de la estructura, pero no ambas.
Ejemplos.
i = e
Do While i <= LimiteMaximo
WriteLine(i)
i += 1
Loop
i = e
Do Until i > LimiteMaximo
WriteLine(i)
i += 1
Loop
i = e
Do
WriteLine(i)
i += 1
Loop While i <= LimiteMaximo
i = e
Do
WriteLine(i)
i += 1
Loop Until i > LimiteMaximo
Do tiene una sentencia para interrumpir en cualquier momento el proceso: Exi t Do.
134 Alfa omega

SYNAPS PREMIUM
6.3 Estructuras envolventes y anidadas

Las estructuras, sean de decisión o de control, pueden contener a otras estructuras. A una estruc-
tura que contiene a otras estructuras se le llama estructura envolvente; la estructura que está
dentro de otra se llama estructura anidada. Todas las estructuras que se han visto en el capítulo,
sin importar su tipo, pueden anidarse o ser envolventes, es decir, resolverse una dentro de otra.
6.3.1 Reglas para el anidado de estructuras

Las únicas reglas que debe tomar en cuenta son:
o Las estructuras tienen un inicio y un fin; asegúrese de cerrar todas las estructuras que abra.
o Se recomienda programar de tal manera que las estructuras que se abran se cierren lo más
pronto posible.
o La última estructura en abrirse debe ser la primera en cerrarse.
o En el caso de estructuras, las variables de tipo entero se resuelven de manera más rápida que
cualquier otro tipo de dato.
Los problemas más comunes relacionados con las estructuras anidadas (y su solución) son:
o No terminar lo que se inicia.
Problema Solución
If Condición Then If Condición Then
Instrucciones Instrucciones
End If
o No iniciar lo que se termina.

Problema Solución
For Variable = e to 1e
Next Variable Next Variable
o Utilizar las mismas variables que controlan el proceso.

Problema Solución
For Variable = a to 1e For Variable = e to 1e
For Variable = a to S For Variable 1 - e to
Instrucciones S
Next Variable Instrucciones
Next Variable Next Variable 1
Next Variable
Alfaomega 135
SYNAPS PREMIUM
o No terminar primero la última estructura que se inició.

Problema Solución
For Variable = e to te For Variable = e to le
If Condición Then If Condición Then
Next Variable End If
End If Next Variable
~ lab.06.01: Uso de estructuras de decisión

En este ejercicio se utilizará una aplicación de consola para comprobar las estructuras de
decisión. Se parte del supuesto que usted le indique al programa cuánto cuesta un producto que
desea comprar, así como el tipo de membresía que tiene en la tienda donde lo desea comprar. A
cada tipo de membresía le aplica un determinado descuento, que será informado por el
programa.
2. Agregue a su solución un nuevo proyecto: Jnstalled - Visual Basic - Windows -
3. Asigne como nombre Descuento.
4. Establezca este nuevo proyecto como proyecto de arranque.
S. Edite el programa Modulel. vb del proyecto, de tal manera que quede como sigue.
2 Option Strict On
3
S
6 Module Module!
7 Sub Main()
8 Dim Precio As Double
9 Dim FactorDesc As Decimal
te Wri te( "Precio del producto:" )
11 Precio = CDbl (ReadLine())
12 If Precio = e Then
13 Writeline( ''Nada que calcular'' )
14 Else
15 Writeline( "Membresía:" )
16 Writeline( "l.- Diamante" )
17 Writeline( ''2.- Premium'' )
18 Writeline( ''3.- Clásica'' )
136 Alfaomega
SYNAPS PREMIUM
19 Write( ''¿Qué membresia tiene?:'' )

20 Factoroesc = coec (Readline())
21 Select Case FactorOesc
22 Case Is = 1
23 FactorOesc = 0.20
24 Case Is = 2
25 Factoroesc = 0.160
26 Case Is = 3
27 FactorOesc = 0.10
28 Case Else
29 FactorOesc = 0
30 End Select
31 Write( "Precio para usted:" )
32 WriteLine(Precio - (Precio * FactorOesc))
33 End If
34 Write( ''Presione INTRO para continuar'' )
35 Readline()
36 End Sub
37 End Module
6. Inicie la depuración de su programa (F5).

7. Las líneas 1 y 2 hacen de este programa un programa type saJe.
a. La especificación Option Explicit obliga a que todas las variables deban ser
declaradas antes de utilizarse.
b. La especificación Option Strict obliga a evitar las conversiones de tipo cast
(automáticas), es decir, las conversiones deben codificarse.
8. En las líneas 7 y 8 se declaran las variables de trabajo.
9. Cuando el programa solicite el precio (líneas 9 y 10), proporcione el valor e.
a. Vea en el código cómo se utiliza CDbl () , para hacer de lo capturado un dato Double, y
evitar errores, dado que el programa es type safe y no permite conversiones tipo cast
(lfnea 11).
10. En la línea 12 vemos la primera estructura de decisión del programa, que controla la
ejecución del programa en el sentido afirmativo y en el sentido negativo.
En el sentido afirmativo, se ejecutará el bloque de código que va de la línea posterior al
inicio de la estructura (línea 12), hasta la línea anterior al Else o End If (línea 13),
que dan por concluido el bloque. En este caso, sólo es una línea.
En el sentido negativo, se ejecutará el bloque de código que va de la línea posterior al
Else (línea 14), hasta la línea anterior al End If (línea 32), que da por concluido el
bloque.
Alfaomega 137
SYNAPS PREMIUM
Como se proporcionó el valor de cero, la condición que gobierna la ejecución del If se

cumple en el sentido afirmativo (Precio = e es True), y al encontrar el Else, pasa a
ejecutar la línea 34; vea que el bloque en el sentido negativo es ignorado
completamente.
Si todo ocurrió como se esperaba, la salida será la siguiente.
11. Ejecute la aplicación nuevamente. Cuando le solicite el precio, proporcione el valor

2eee. Cuando le solicite el tipo de membresía, proporcione el valor 2.
Como se proporcionó el valor 2eee, la condición que gobierna la ejecución del If se
cumple en el sentido negativo (Precio = e es False), y se procede a ejecutar el
bloque en el sentido negativo.
En la línea 20 se recibe el valor 2, que es asignado a FactorDesc; en la línea 21 se
especifica FactorDesc como valor de referencia para las comparaciones de Select
Case, que se encuentran en las líneas 22, 24 y 26, y en caso de que no se cumpla
ninguna de las anteriores, se ejecuta la línea 28.
Como el valor de FactorDesc es 2 (Is = 2), se procede a ejecutar el bloque de código
correspondiente al cumplimiento de esa condición; en otras palabras, ejecuta la línea
25; vea cómo se agrega la literal O al valor, para indicarle al programa que el valor es
Decimal, ya que de lo contrario podría asumirse otro tipo de dato, y ante la
imposibilidad de conversiones cast se generaría un error. Podríamos haber resuelto
también el problema utilizando la función CDec( ). Concluida la ejecución del bloque de
código correspondiente a la condición que se cumplió, se envía el control del programa
a la línea posterior a la terminación de la estructura (End Select), es decir, ejecuta la
138 Alfa omega

SYNAPS PREMIUM
línea 31 y hacia adelante, que despliegan el precio después de aplicar el factor de

descuento que corresponde al tipo de membresía que seleccionamos.
Si hubiéramos especificado un tipo de membresía que no fuera 1, 2, o 3, el programa

hubiera ejecutado la línea 32, que corresponde a la condición Case Else, es decir, cuando
ninguna de las otras condiciones se cumplió.
12. Guarde todos los cambios en su solución.
FIN DEL EJERCICIO *
~ Lab.06.02: Uso de For Next
En este ejercicio se utilizará una aplicación de consola para comprobar el funcionamiento de For
Next.

3. Asigne como nombre Re pite.
Alfaomega 139
SYNAPS PREMIUM

S. Edite el programa Modulel. vb del proyecto, de tal manera que quede como sigue.
2 Option Strict On
3
S
6 Module Module1
7
8 Sub Main()
9 Dim LimiteMaximo As Integer =4
1e Dim LimiteMinimo As Integer = e
11 Dim i As Integer
12
13 WriteLine( ''Mostrando con For Next incremental'' )
14 For i = LimiteMinimo To LimiteMaximo
15 WriteLine(i)
16 Next i
17
18 WriteLine( ''Muestra usando For Next invertido'' )
19 For i = LimiteMaximo To LimiteMinimo Step -1
2e WriteLine(i)
21 Next i
22
23 WriteLine( ''Mostrando con While'' )
24 i =e
25 While i <= LimiteMaximo
26 Writeline(i)
27 i += 1
28 End While
29
3e WriteLine( ''Muestra usando Do Loop inicial While'' )
31 i =e
32 Do While i <= LimiteMaximo
33 Writeline(i)
34 i += 1
35 Loop
36
37 WriteLine( ''Muestra usando Do Loop inicial Until'' )
38 1 =e
39 Do Until i > LimiteMaximo
4e Writeline(i)
41 i += 1
42 Loop
43
140 Alfa omega

SYNAPS PREMIUM
44 WriteLine( "Muestra usando Do Loop final While" )

45 i =e
46 Do
47 WriteLine(i)
48 i += 1
49 Loop While i <= LimiteMaximo
se WriteLine( "Muestra usando Do Loop final Until" )
51 i =e
52 Do
53 WriteLine(i)
54 i += 1
55 Loop Until i > LimiteMaximo
56
57 Write( ''Presione INTRO para continuar'' )
58 ReadLine()
59 End Sub
6e
61 End Module
6. Inicie la depuración de su programa (FS).

7. En las líneas 9 a la 11 se declaran variables de trabajo que nos ayudarán a visualizar de
una mejor forma el funcionamiento de los bucles. Todas las estructuras hacen lo mismo,
con las siguientes particularidades:
a. For Next se encarga de incrementar un contador de forma automática.
b. Todas las demás estructuras deben apoyarse en un contador implementado
manualmente (i +=1), que en caso de olvidarse puede provocar un ciclo infinito.
c. Las estructuras Until se ejecutan hasta que se cumple por primera vez la condición.
d. Las estructuras While se ejecutan mientras la condición sigue siendo verdadera.
Si todo transcurrió bien, la pantalla mostrará lo siguiente:
Mostrando con For Next incremental
e
1
2
3
4
Muestra usando For Next invertido
4
3
2
1
e
Mostrando con While
Alfaomega 141
SYNAPS PREMIUM
e
1
2
3
4
Muestra usando Do Loop inicial While
e
1
2
3
4
Muestra usando Do Loop inicial Until
e
1
2
3
4
Muestra usando Do Loop final While
e
1
2
3
4
Muestra usando Do Loop final Until
e
1
2
3
4
Presione INTRO para continuar
8. Modifique las asignaciones de las líneas 24, 31, 38, 45 y 52. En lugar de asignar e, asigne
1e. Se proporciona ese valor porque no es válido para las condicionales While y Until
del programa. Compruebe cómo las estructuras con evaluación al final se ejecutan al
menos una vez.
Si todo transcurrió bien, la pantalla mostrará lo siguiente:
Mostrando con For Next incremental
e
1
2
3
4
Muestra usando For Next invertido
4
3
2
1
142 Alfa omega

SYNAPS PREMIUM
e
Mostrando con While
Muestra usando Do Loop inicial While
Muestra usando Do Loop inicial Until
Muestra usando Do Loop final While
1e
Muestra usando Do Loop final Until
1e
Presione INTRO para continuar
a) Agregando tareas a Task List
9. Hay una herramienta en Visual Studio que permite crear y administrar tareas, con el fin
de no olvidar pendientes que puedan tenerse respecto al desarrollo en el que
participamos. Esta herramienta tiene el nombre de Task List.
10. En Task List se pueden manejar dos categorías de registros: Tareas de usuario y
comentarios de tarea.
a. Las tareas de usuario son tareas que el usuario registra, estableciéndoles prioridad
(alta, media, baja) y un indicador de estado, que indica si la tarea ya ha sido concluida
(completed).
b. Los comentarios de tarea son comentarios en el código que tienen significado para
Visual Studio, y que provocan un registro en Task List. Estos comentarios de tarea son:
TODO, para señalar cosas por hacer; HACK, para anotar recordatorios de cosas
relacionadas con el desarrollo; y UNDONE, para deshacer cosas que temporalmente se
colocaron, pero que hay que eliminar antes de liberar el programa en producción.
11. Para ver Task Listes necesario ir a la opción View- Other Windows- Task List (CTRL+
o, T). Con ello aparecerá la ventana Task List.
Figura 06.01 Prionty

Crrale User lasks
Task List Completed
Alfaomega 143
SYNAPS PREMIUM
12. En Task List seleccione en el combo Categories la categoría User Tasks.

13. Haga die en el icono Create Task User. Se agregará una tarea de forma automática.
14. Especifique la tarea:
a. En Description escriba Enviar propuesta de interfaz para su aprobación.
b. En la misma línea de la tarea, haga die en la columna Priority, con lo que aparecerán las
diferentes prioridades que se pueden asignar a una tarea. Seleccione la opción High.
c. Así como está, la tarea se asume incompleta. Cuando ya haya terminado la tarea, haga
die en Completed, y la tarea se marcará como realizada.
d. Haga die en Completed.
e. Si ya no necesita la tarea, puede borrarla seleccionándola, y haciendo Delete en el menú
de contexto. Deberá confirmar la eliminación.
b) Agregando comentarios de tarea a un programa
15. En la línea anterior en donde se inicia la comprobación de While (línea 22) agregue el
siguiente comentario.
' TODO Cambiar los l e por ceros, para que funcione normalmente.
16. Existen comentarios que Visual Studio reconoce y gestiona. Dichos comentarios son
llamados comentarios administrados, y son aquellos que inician con cualquiera de Jos
siguientes prefijos: TODO 1 HACK 1 UNDONE . Cuando uno los coloca, se agrega un registro a
Task List, en donde se especifica el archivo y la línea en la que se realizó la anotación.
a. En Catgories de Task List, seleccione Comments.
b. Aparecerá el comentario que agregamos, el programa, y el número de lfnea.
17. Mueva el cursor de lugar. Vaya al principio del programa (línea 1).
18. En Task List haga doble die sobre el comentario que acaba de agregar, y vea cómo el
control del programa se traslada a donde se encuentra el comentario. Esto puede
agregarle mucha navegabilidad a sus trabajos.
19. Guarde todos los cambios en su solución.
¡gl WBVBVS2012.06.01 - Task List.wmv
FIN DEL EJERCICIO *
144 Alfa omega

SYNAPS PREMIUM
~ Lab.06.03: Identificando errores en estructuras anidadas

En este ejercicio analizará el código que se proporciona, y explicará cuáles son Jos
errores que se presentan (si Jos hay). Si no hay problemas, indíquelo en su respuesta.
1)
If Edad > 18 Then

If Registro = True Then
Autorizacion = True
End If
2)
If Edad > 18 Then

If Registro = True Then Autorizacion = True
End If
3)
For i =1 to 1e
X *= i
If x > 3e Then
Console.WriteLine(''Limite de treinta o
más")
Exit For
Next i
End If
FIN DEL EJERCICIO *
Alfaomega 145
SYNAPS PREMIUM
~ Lab.06.04: Decidiendo el uso de estructuras de decisión y de

control.
Un banco acaba de crear un programa llamado Flexi-lnversión, en donde el cliente puede
invertir una cantidad determinada (Inversión), se le proporciona una tasa de interés
anual (Tasa), y además, el cliente puede indicar un monto máximo en el que deberá
parar el plazo de su inversión (Máximo).
La inversión se termina a) cuando se alcanza el máximo, en cuyo caso se le llama por
teléfono al cliente un día antes, para que acuda por su dinero, o b) cuando se cumplan 90
días de inversión, lo que ocurra primero.
1. Elabore un proyecto Console Application, en donde se pregunte el monto a
invertir, la tasa de interés aplicable, y el monto máximo a obtener.
2. El programa deberá generar una tabla en donde se indique a) el número de día en
curso, b) el monto al día, e) el interés que se pagará en ese día, y d) el monto
acumulado al día.
3. Tome en cuenta que los intereses generados cada día se acumulan al capital
original.
4. En dado caso que en el transcurso de la inversión se alcance el máximo, la tabla
sólo deberá incluir hasta el día en el que se sobrepasó ese máximo.
Tips:
• La tasa que se captura es anualizada, por lo que se debe determinar la tasa diaria,
que es ( (Tasa/365 )/lee). Si se captura le, por ejemplo, la tasa diaria será
e.ee2739
• El incremento diario será el acumulado por la tasa diaria.
• El nuevo acumulado será el acumulado más el incremento.
• Al usar String . Format, esta variante puede ser útil: colocar {e, le: C}, quiere
decir que el primer argumento (e), será expresado en ancho constante de diez
(le) posiciones, con un formato Currency (C).
146 Alfa omega

SYNAPS PREMIUM
Ejemplo de lo que se debe ver como resultado:
Supuesto en el que no se alcanza el Supuesto en el que se alcanza el máximo

, •
maxtmo
Monto a invertir ($):19009 Monto a invertir ($):1eeee
Tasa de interés (%):12 Tasa de interés (%):12
Máximo esperado ($):13900 Máximo esperado ($):10059
1) $l0,eee.00 $3.29 $19,003.29 1) $19,999.99 $3.29 $19,993.29
2) $19,993.29 $3.29 $19,996.58 2) $19,993.29 $3.29 $19,996.58
3) $19,096.58 $3.29 $19,999.87 3) $19,996.58 $3.29 $19,999.87
4) $19,099.87 $3.29 $19,013.16 4) $19,009.87 $3.29 $19,913.16
5) $10,013.16 $3.29 $10,016.45 5) $10,013.16 $3.29 $19,916.45
6) $10,016.45 $3.29 $10,019.74 6) $10,016 . 45 $3.29 $19,919.74
7) $10,019.74 $3.29 $10,023.04 7) $10,019 . 74 $3.29 $19,923.04
8) $10,023 .04 $3.30 $10,026 . 33 8) $10,023 . 04 $3.30 $10,026.33
9) $10,026.33 $3.30 $10,029 .63 9) $10,026 . 33 $3.30 $10,029.63
10) $19,029.63 $3.30 $10,032. 93 10) $10,029 . 63 $3.30 $10,032. 93
11) $19,032.93 $3.30 $10,036. 22 11) $10,032 . 93 $3.30 $10,036. 22
12) $19,036.22 $3.30 $10,039. 52 12) $10,036 . 22 $3.30 $19,039 . 52
13) $10,039.52 $3.30 $10,042.82 13) $19,039 . 52 $3.30 $19,042 . 82
14) $10,042.82 $3.30 $10,046.13 14) $10,042.82 $3.30 $10,046.13
15) $10,046.13 $3.30 $10,049.43 15) $19,046.13 $3.39 $10,049.43
16) $19,049.43 $3.30 $10,052. 73 16) $10,049.43 $3.39 $10,052.73
17) $10,952.73 $3.31 $10,056. 94 Pulse INTRO
18) $10,056.04 $3.31 $10,959.34
19) $10,059.34 $3.31 $10,062.65
20) U9,062.65 $3.31 $10,965.96
21) $19,065.96 $3.31 $10,969.27
22) $19,969.27 $3.31 $10,972.58
23) $10,972.58 $3.31 $19,975.89
24) $19,975.89 $3.31 $19,979.29
25) $19,979.29 $3.31 $19,982.52
26) $19,982.52 $3.31 $10,985.83
27) $19,985.83 $3.32 $10,089.15
28) $19,989.15 $3.32 $10,092.46
29) $10,092.46 $3.32 $10,095.78
30) $10,095.78 $3.32 $10,099.10
31) $10,099.19 $3.32 $10,102.42
32) $10,102.42 $3.32 $10,105.74
33) $10,105.74 $3.32 $10,199.07
34) $10,199.07 $3.32 $10,112.39
35) $10,112.39 $3.32 $10,115.71
36) $10,115.71 $3.33 $10,119.04
37) $10,119.04 $3.33 $10,122.37
38) $10,122. 37 $3.33 $19,125.69
39) $19,125 . 69 $3.33 $10,129.02
40 ) $19,129. 02 $3.33 $10,132. 35
41) $19,132. 35 $3.33 $19,135. 68
42) $19,135.68 $3.33 $19,139. 02
43) $19,139.02 $3.33 $10,142. 35
44) $19,142.35 $3.33 $19,145.68
45) $19,145.68 $3.34 $10,149. 02
46) $10,149.02 $3.34 $10,152. 36
47) U0,152.36 $3.34 $10,155.69
48) U0,155.69 $3.34 $10,159.03
49) U0,159.93 $3.34 $10,162.37
50) $10,162.37 $3.34 $10,165.71
51) $19,165.71 $3.34 $10,169.96
52) U9,169.96 $3.34 $19,172.49
Alfaomega 147
SYNAPS PREMIUM
53) $10,172.40 $3.34 $10,175.74

54) $10,175.74 $3.35 $10,179.09
55) $10,179.09 $3.35 $10,182.44
56) $10,182.44 $3.35 $10,185.78
57) $10,185.78 $3.35 $10,189.13
58) $10,189.13 $3.35 $10,192.48
59) $10,192.48 $3.35 $10,195.83
60) $10,195.83 $3.35 $10,199.19
61) $10,199.19 $3.35 $10,202.54
62) $10,202.54 $3.35 $10,205.89
63) $10,205.89 $3.36 $10,209.25
64) $10,209.25 $3.36 $10,212.60
65) $10,212.60 $3.36 $10,215.96
66) $10,215.96 $3.36 $10,219.32
67) $10,219.32 $3.36 $10,222.68
68) $10,222.68 $3.36 $10,226.04
69) $10,226.04 $3.36 $10,229.40
70) $10,229.40 $3.36 $10 J 232. 77
71) $10,232.77 $3.36 $10,236. 13
72) $10,236.13 $3.37 $10,239 . 50
73) $10,239.50 $3.37 $10,242 . 86
74) $10,242.86 $3.37 $10,246.23
75) $10,246.23 $3.37 $10,249.60
76) $10,249.60 $3.37 $10,252.97
77) $10,252.97 $3.37 $10,256.34
78) $10,256.34 $3.37 $10,259.71
79) $10,259.71 $3.37 $10,263.08
se) $10,263.08 $3.37 $10,266.46
81) $10,266.46 $3.38 $10,269.83
82) $10,269.83 $3.38 $10,273.21
83) $10,273.21 $3.38 $10,276.59
84) $10,276.59 $3.38 $10,279.97
85) $10,279.97 $3.38 $10,283.35
86) $10,283.35 $3.38 $10,286.73
87) $10,286.73 $3.38 $10,290.11
88) $10,290.11 $3.38 $10,293.49
89) $10,293.49 $3.38 $10,296.88
90) $10,296.88 $3.39 $10,300.26
Pulse INTRO
FIN DEL EJERCICIO *
148 Alfa omega

SYNAPS PREMIUM
Manejo Estructurado de Exepciones
Competencias:
1. Conocer el manejo de
excepciones, utilizando el bloque
Try Catch Fina lly .
2. Conocer como f iltra r de manera
específi ca las excepciones, a fi n
de controlar las respuestas de las
aplicaciones f rent e a
im previstos.
3. Conocer a disparar excepciones
generadas por el usuario.
Evaluacl6n:
1. Proporcionar a los
programas ya
desarrollados hasta el Evidencia de
momento, de un aprendizaje:
esquema de manejo 1. Capacidad de proteger código,
estructurado de utilizando Try Catch Finally.
excepciones. 2. Capacidad de implementar
2. Verificar que al esquemas de manejo
estableces manejo preventivo de excepciones
estructurado de usando Error List.
•
excepciones, se 3. Capacidad de filtrar
practica el filtrado de excepciones.
excepciones, y el 4. Capacidad de lanzar
lanzado de excepciones definidas por el
excepciones definidas usuario.
por el usuario.
SYNAPS PREMIUM
7: Manejo Estructurado de Excepciones

7.1 Errores versus Excepciones................................................................................................................... lS 1
7.2 Manejo estructurado de excepciones ................................................................................................ 151
7.3 Try... Catch ... Finally .................................................................................................................................... 152
7.3.1 BloqueTry ............................................................................................................................................152
7.3.2 Bloque Catch ........................................................................................................................................ 152
7.3.3 Bloque Finally...................................................................................................................................... 153
7.3.4 Clase System.Exception ................................................................................................................... 153
7.4 Filtrado de excepciones ........................................................................................................................... lSS
7.4.1 Calificadores de excepción .............................................................................................................155
7.4.2 Objeto Err.............................................................................................................................................. 155
7.4.3 Tipos de filtrado de excepciones ................................................................................................. 156
7.5 Lanzando nuestras propias excepciones .......................................................................................... 156
~ Lab.07.01: Manejo estructurado de excepciones ............................................................................ 156
a) Manejo preventivo de excepciones usando Error List ............................................................. 159
b) Actualizaciones preventivas en cascada ...................................................................................... 161
~ Lab.07.02: Filtrado de excepciones ...................................................................................................... 161
~ Lab.07.03: Lanzamiento de excepciones definidas por el usuario ........................................... 165
~ Lab.07.04: Proporcionando manejo estructurado de excepciones a los programas......... 167
150 Alfa omega

SYNAPS PREMIUM
Unidad 7: Manejo Estructurado de Exepciones
7.1 Errores versus Excepciones

Los errores son acciones u omisiones que tienen que ver con el proceso de desarrollo, y que
conducen a que un programa tenga un comportamiento que no se espera de él.
Por otro lado, existe un concepto denominado excepción, que es una violación a las reglas
sintácticas o de alcance de un lenguaje de programación.
Las excepciones pueden ser excepciones de software, si están relacionadas con una mala
aplicación del lenguaje, o con la asignación de valores fuera de dominio a propiedades o
argumentos; también pueden ser excepciones de hardware, cuando su origen tiene que ver
con la falla o saturación de un dispositivo físico: el programa puede estar correcto, pero
¿cómo escribir información en un disco que está lleno, por ejemplo?
Una excepción siempre es un error, debido a que el resultado obtenido no es el deseado,
pero un error no siempre es una excepción; las excepciones por lo general interrumpen la
ejecución de un programa, mientras que los errores pueden pasar desapercibidos para el
compilador del lenguaje.
Si un desarrollador entendió mal las especificaciones de un programa, por decir algo, una
fórmula aritmética, es probable que codifique correctamente la fórmula que no es correcta;
el programa no reportará errores en tiempo de compilación o ejecución, pero sin duda al-
guna, generará resultados equivocados. El programa se compilará sin problemas, no tendrá
excepciones, pero sí tendrá errores.
Concluimos que los errores tienen un universo más amplio de posibilidades para manifes-
tarse; las excepciones, en cambio, tienen un campo más reducido: el del uso inadecuado del
lenguaje, manejo inadecuado de dominios o problemas de hardware.
En términos llanos, hay que temerle más a los errores que a las excepciones, ya que las ex-
cepciones son un aspecto totalmente manejable en Visual Basic.
7.2 Manejo estructurado de excepciones

El manejo estructurado de excepciones (SEH 1 Structured Exception Handling) es la capaci-
dad que tiene un lenguaje para permitir manejar excepciones a través de una estructura de
control que "protege" porciones localizadas de código, de manera lógica y consistente, sin
perder nunca la secuencia de los procesos.
Algunas de las ventajas del manejo estructurado de excepciones son las siguientes:
l. El manejo estructurado de excepciones permite delimitar claramente los bloques
de código a proteger, y determinar acciones específicas para excepciones específi-
cas.
Alfaomega 151
SYNAPS PREMIUM
2. El flujo de ejecución es más sencillo de seguir, ya que no existen saltos en la ejecu-

ción del código.
3. Las estructuras para el manejo de excepciones se pueden anidar, ofreciendo ma-
yor control al manejo de excepciones.
7.3 Try ...Catch ...Finally

Se puede implementar el manejo estructurado de excepciones a través del estatuto
Try ••• Catch ••• Finally.
Try
Código a ser protegido
Catch
Define el tipo de excepción a capturar y la acción
que deberá tomarse
[ Finally
Define acciones que podrán ser ejecutadas de
manera opcional]
End Try
7.3.1 Bloque Try

Estas son las particularidades del bloque Try . . . End Try:
l. Delimita el área de código en donde puede suceder una excepción.
2. El código escrito dentro del bloque Try se considera código protegido.
3. Si una excepción ocurre, el proceso se transfiere al bloque Catch, que contendrá el
código que queremos ejecutar dado el caso.
4. Se puede utilizar Exi t Try para salir en cualquier instante del bloque de código
protegido, continuando el flujo del programa después del End Try.
7.3.2 Bloque Catch

Si una excepción sucede en el bloque Try, la ejecución de dicho programa se suspende y
continuará al principio del bloque Cate h.
152 Alfa omega

SYNAPS PREMIUM
Estos bloques son una serie de estatutos que comienzan con la palabra reservada Catch,
seguida de un tipo determinado y reconocido de excepción, así como la acción que deberá
realizarse en caso de que la excepción sea detectada.
Estas son las particularidades del bloque Catch:
l. Se puede utilizar uno o varios bloques Catch para manejar las excepciones.
2. Se recomienda manejar de manera separada las excepciones que provoquen acciones
distintas, a fin de mantener la secuencia lógica del programa.
3. Es posible capturar excepciones predefinidas en .NET Framework, o bien crear nues-
tras propias excepciones.
4. Se puede utilizar el estatuto When para comparar una excepción que ocurre, con aque-
llas reconocidas por .NET Framework, utilizando para ello el número único de excep-
ción.
7.3.3 Bloque Finally

El bloque Finally se ejecuta después del bloque Try, en caso de que no ocurrieran excep-
ciones, o después del bloque Catch correspondiente, en caso de que sí haya sucedido una
.'
excepcwn.
Este bloque es opcional en su definición, pero no en su ejecución; si se define un bloque Fi-
nally, éste se ejecutará siempre.
El uso más común de Finally es liberar objetos o cerrar archivos, después de que una ex-
cepción ha sucedido. En cierta forma, es lo mismo declarar Finally que escribir código
fuera de Try.
Finally es opcional, como decíamos, pero recomendamos que lo use ya que su código será
más claro, logrando un manejo verdaderamente estructurado: primero (a) defino qué quie-
ro hacer, luego, (b) defino qué hacer si hay excepciones, y luego, (e) defino qué ocurre des-
pués, hayan ocurrido o no excepciones.
Si en el código protegido por Try no ocurren excepciones, el control del programa hace caso
omiso al bloque Catch, pasando directamente a la ejecución de Finally.
DJ WBVBVS2012.07.01- Bloque para el manejo estructurado de excepciones.wmv
7.3.4 Clase System.Exception

Visual Basic maneja las excepciones a través de la clase System. Exception. Recuerde que
en Visual Basic todo es objeto, incluyendo una excepción que es capturada.
Alfaomega 153
SYNAPS PREMIUM
Una sintaxis común de Catch es la siguiente.

Catch VariableExcepción As System. Exception
En caso de que ocurra una excepción en el bloque de código protegido, el control del pro-
grama se trasladará a la línea Catch, capturará la excepción y la almacenará en una instan-
cia de la clase System . Exception que se declara en la misma línea Cate h.
En nuestro ejemplo, VariableExcepción sería la variable objeto en donde estaría almacenada
la información del problema ocurrido.
En su calidad de objeto, VariableExcepción tendría las propiedades y los métodos de la clase
que le dio origen, es decir, System . Exception .
Algunas de las propiedades más relevantes de System. Exception son las siguientes.
Propiedad Descripción
Message Contiene la información de aquello que causó la excepción. 1
StackTrace Antecedente de ejecución; muestra primeramente la línea que
causó el error (en su formato interno de ejecución), sigue con el
procedimiento, capítulo, etcétera. Esto permite ubicar, en el con-
texto modular del programa, a la excepción.
1
Source Contiene el nombre de la aplicación u objeto que originó la excep-

ción. Puede tratarse incluso de la librería de .NET Framework que
es llamada a ejecución, y que causa la excepción.
InnerException El hecho de que una excepción se presente, puede dar lugar a otras
excepciones (por ejemplo, declarar mal una variable puede pravo-
car excepciones al utilizar dicha variable). En caso de que se pre-
senten excepciones anidadas, mostrará las excepciones que se
_Qresentaron, en orden de aparición.
ToString
HResult
Muestra el nombre calificado de la excepción, el mensaje,
anidamiento de exceQ_ciones,~ y el antecedente de ejecución.
Código numérico específico a la excepción_gue ha ocurrido.
4 1
Todo esto quedará claro al momento que haga el primer ejercicio.
154 Alfa omega

SYNAPS PREMIUM
7.4 Filtrado de excepciones

Visual Basic nos proporciona mucha flexibilidad en el manejo de excepciones, ya que pode-
mos tener rutinas genéricas, o bien, atender las excepciones de manera particular.
7.4.1 Calificadores de excepción
Los calificadores de excepción son los nombres reconocidos internamente por .NET, para
cada una de las excepciones que pueden ocurrir. Generalmente el calificador de excepción
nos proporciona una muy clara idea de lo que está sucediendo. Si vemos un calificador que
dice:
System .D ivideByZeroException.
¿A alguien le queda duda que se trata de una excepción determinada por la clase System,
que tiene que ver con una división entre cero?
Las excepciones que existen pueden ser muchas; hay dos formas de conocerlas: que suce-
dan (lo que no es muy recomendable), o bien, revisando la ayuda de Visual Basic, en donde
cada clase refiere las excepciones que pueden ocurrir en el uso de los objetos basados en
ellas. Por ejemplo, la clase System tiene las siguientes excepciones importantes, entre
otras:
l. DivideByZeroException
2. DLLNotFoundException
3. IndexOutOfRangeExcept ion
4. InvalidCastException
5. OutOfMemoryException
6. OverFlowException
7. PlataformNotSupported Exception
8. UnauthorizedException
Cada clase tendrá las suyas, y habrá que investigarlas de manera particular.
7.4.2 Objeto Err

Visual Basic soporta el objeto Err -objeto reminiscente a versiones pasadas de Visual Ba-
sic-, con la limitación de que no se puede implementar el manejo estructurado de excep-
ciones (Structured Exception Handling) usando Try ... Catch ... Finally ... , y el manejo
de errores (Error Handling) usando On Error, de manera simultánea.
Alfaomega 155
SYNAPS PREMIUM
El objeto Err sí puede utilizarse en el manejo estructurado de excepciones. Esto es muy útil
cuando se desea trabajar con números de error, en lugar de calificadores de excepción, uti-
lizando la propiedad Number.
7.4.3 Tipos de filtrado de excepciones

Cuando al definir un bloque Catch utilizamos un calificador de excepción para capturar el
problema, estamos creando un manejador de excepciones basado en tipos (Type-Filtered Ex-
ception Handler).
Cuando al definir un bloque Catch no utilizamos un calificador de excepción, sino una con-
dición diversa, estamos creando un manejador de excepciones del usuario (User-Filtered Ex-
ception Handler), utilizando el estatuto When.
En un bloque Try se pueden especificar tantos bloques Catch como se deseen. Entre más
bloques Catch se tengan, más particular el manejo de excepciones.
7.5 lanzando nuestras propias excepciones

En ocasiones podemos considerar que un proceso, no violando ninguna de las reglas del
lenguaje, tiene un comportamiento equivocado, digno de ser considerado un error.
En ese caso, es recomendable que tengamos elementos suficientes para provocar
excepciones al momento de detectar algo que no queremos que suceda, advirtiendo como si
se tratara de una excepción reconocida por el lenguaje.
En términos generales, sabemos que cuando se produce una excepción, el CLR genera una
instancia de la clase System. Exception automáticamente. La instanciación, en ese caso, es
realizada en tiempo de ejecución por el mismo sistema.
Nada nos impide instanciar nosotros. La forma en que podemos hacerlo es a través del uso
de Throw New Exception, con la siguiente sintaxis.
Throw New Exception("Mensaje de error'')
~ lab.07.01: Manejo estructurado de excepciones

En este ejercicio se protegerá un código determinado, utilizando Try. . . Catch ...
Finally ... . El programa solicita dos números (un dividendo y un divisor), y a partir de
ahí se intentará una división. Como sabemos, no se puede dividir un número entre cero.
Deliberadamente se causará una excepción, al tratar de dividir entre cero.
156 Alfa omega

SYNAPS PREMIUM

3. Asigne como nombre Excepciones!.
S. Edite el programa Modulel. vb del proyecto, de tal manera que quede como
sigue.
2 Option Strict on
3
5
6 Module Modulel
7
8 Sub Main()
9
19 Try
11 Writeline( ''Prueba de manejo de Excepciones'' )
12 Dim N1, N2, Resultado As Decimal
13 Write( ''Dame el dividendo:'' )
14 N1 = coec (Readline())
15 Write( ''Dame el divisor:'' )
16 N2 = CDec (Readline())
17 Resultado = N1 1 N2
18 Writeline( "Resultado:" & Resultado. ToString)
19 Catch eProblema As Exception
29 Writeline( ''> Origen:'' )
21 Writeline(eProblema.Source )
22 Writeline( ''> Mensaje:'' )
23 Writeline(eProblema.Message)
24 Writeline( ''> Antecedente de ejecución:'' )
25 Writeline(eProblema.StackT race)
26 Writeline( ''> Text o completo:'' )
27 Writeline(eProblema.ToStri ng)
28 Finally
29 Write( ''Pulse INTRO para continuar'' )
39 Readline()
31 End Try
32
33 End Sub
34
35 End Module
Alfaomega 157
SYNAPS PREMIUM

7. Cuando se protege un bloque de código y éste no causa excepciones, se ejecutarán
los bloques Try y Finally, y no Catch; este último sólo se ejecuta en el caso de
.
excepciones.
La línea 12 declara todas las variables que vamos a utilizar en nuestro programa.
La línea 14 preguntará el número que actuará como dividendo (Nl), y la línea 16
el que actuará como divisor (N2). La línea 17 es la que intenta la división (Nl/N2),
asignando el resultado a la variable Resultado.
8. Proporcione el valor 10 como dividendo, y el 5 como divisor.
En nuestro ejemplo, dividir 10 entre S no ofrece ningún problema, y por tanto, el
programa trasladará el control de la ejecución de la línea 18 (bloque Try) a la 28
(bloque Finally); las líneas intermedias, que corresponden al bloque Catch, son
ignoradas.
9. Ejecute la aplicación nuevamente, y proporcione el valor 10 como dividendo, y el
e como divisor.
Si colocamos el cero como divisor, al querer resolver la línea 14, el programa
determina que eso no es posible, generando una excepción. Al detectar que una
excepción ha ocurrido, el control del programa se trasladará al bloque Catch, en
la línea 19.
La excepción que es capturada se almacenará como un objeto basado en
System . Exception, que es declarada en la misma línea Catch. En nuestro caso,
el objeto se llama eProblema.
Las líneas 21, 23, 25 y 27 muestran algunas propiedades importantes del objeto
eProblema, que nos ayudarán a entender qué excepción está ocurriendo, y
dónde.
Después de ejecutar el código del bloque Catch, el programa ejecutará el bloque
de código Finally.
158 Alfa omega

SYNAPS PREMIUM
a) Manejo preventivo de excepciones usando Error List
10. Ya vimos la forma en que se pueden detectar excepciones en tiempo de

depuración, sin embargo, lo ideal es percatarnos de las excepciones incluso antes
de ejecutar los programas. En el caso de nuestro ejemplo el programa es correcto,
pero los datos que el usuario introduce son los que pueden causar las
excepciones. Hay otros tipos de excepciones, denominadas errores de sintaxis, que
son violaciones a las reglas de escritura en un lenguaje de programación
determinado. Los errores de sintaxis, junto con las referencias erróneas, que son el
uso de elementos (variables, estructuras, clases, etcétera) que no han sido
declarados o que no están disponibles dentro del alcance en el cual queremos
utilizarlas, son el pan de cada día en las labores de desarrollo.
11. Hay una herramienta en Visual Studio que permite ver los errores de sintaxis y las
referencias erróneas en tiempo de diseño, que son detectadas en nuestro
programa al momento en que lo estamos editando; dicha herramienta tiene el
nombre de Error List.
12. En Error List se muestra los errores (errors), alertas (warnings), y mensajes
(messages) que se presentan en el código que estamos editando. Los errores son
aquellas cosas que generarán la interrupción del programa en tiempo de
depuración, las alertas son aquellos detalles que si bien no interrumpen la
depuración, si son malas prácticas de programación. Los mensajes son aquellos
mensajes informativos proporcionados por Visual Studio, aplicables a lo que
estamos editando.
Alfaomega 159
SYNAPS PREMIUM
13. Modifique la línea 12 de su código, cambiando el nombre de la variable N2 por N3.

Al hacer esto se generarán múltiples problemas, dado que la variable N2 es
utilizada en varias partes del programa, y ha quedado sin declararse.
14. Seleccione View - Error List (CTRL+ 0 , E) para ver la herramienta Error List.
!nO< l"' • q X 1
T • O 2úrcn 1 OM"''· " <> S...1rch Error .Kt p.

Des<rol'bc n Fae Column Proj«t
O1 Nl' tS not dedett:d.l MI)' be inaccessible d ueto its protedion Modulel:vb 16 U Elo:tp<ocn61
lewl.
O2 N2' is nct dedared. ll may be inaccessibfe dueto its protection Modultl.vb 17
lewl.
Etror l•~t 8reak.po1nts lmmediate Window 0\ltput Find Results 1
15. En Error List se muestran Jos errores que contiene el programa, el archivo físico
en donde se encuentra el problema, la línea de código en la que se encuentra, la
línea, la columna y el proyecto al que pertenece. En la parte superior aparecen
pestañas en las que se puede seleccionar lo que queremos ver, sean errores
(errors), alertas (warnings) o mensajes (messages). En nuestro caso sólo tenemos
2 errores, mismos que son reportados en Error List.
16. Error List mostrará Jos errores de toda la solución, por lo que es especialmente
útil cuando modificamos librerías, en donde nos podemos dar cuenta de los
efectos que tendrán nuestras modificaciones en otros programas que las
consumen.
17. Si se hace doble clic en un error, Visual Studio trasladará el control a la posición
en donde se encontró el error, lo que facilita enormemente la navegación en el
código.
18. Haga doble die en el error 2. Compruebe que se ha trasladado a la línea y la
posición en donde se encontró el error.
19. Otra funcionalidad importante es que, si selecciona un error de la lista, puede
invocar el menú de contexto y seleccionar Show Error Help, con lo cual será
direccionado hacia la ayuda en Internet que le ayude a entender y corregir el
problema.
20. Modifique la línea 12 de su código, y corrija el nombre de la variable que está
ocasionando el problema. Cambie N3 por N2.
160 Alfa omega

SYNAPS PREMIUM
b) Actualizaciones preventivas en cascada
21. Visual Basic proporciona más herramientas para evitar los problemas de
codificación. Una de ellas es la actualización preventiva en cascada.
a. Vuelva a la línea 12.
b. Colóquese en la variable N2, y selecciónela.
c. Intente cambiar el nombre N2 por N3, y vea cómo Visual Studio detecta los
problemas, y pone una marca roja en la parte baja.
d. Al hacer clic en esa marca, sugiere el cambio de N2 por N3, pero en todo el
programa.
e. Haga clic en la marca y sugiera Rename N2 to N3.
f. Vea cómo todas las veces que se utiliza N2, es remplazado por N3.
22. Este recurso puede utilizarlo cuando, por alguna causa, desea modificar el nombre
de una variable ya definida y utilizada, de manera rápida y sencilla.
DI WBVBVS2012.07.02 - Actualización en cascada.wmv
23. Guarde los cambios realizados en su solución.

FIN DEL EJERCICIO *
~ Lab.07.02: Filtrado de excepciones
En este ejercicio se protegerá un código determinado, utilizando Try. . . Catch ...
Finally ... . El programa solicita dos números (un dividendo y un divisor), y a partir de
Difiere del ejercicio anterior en que en este ejercicio no se manejarán las excepciones de
manera genérica, sino particular, a través del filtrado de excepciones.
Deliberadamente se causará una excepción, al tratar de dividir entre cero, o
proporcionando un valor que no es numérico.
Alfaomega 161
SYNAPS PREMIUM
3. Asigne como nombre Excepciones2.

S. Edite el programa Modulel . vb del proyecto, de tal manera que quede como
.
Sigue.
2 Option Strict Off
3
S
6 Module Module1
7
8 Sub Main()
9 Dim Satisfactorio As Boolean = True
10 Try
11 Writeline( "Prueba de manejo de Excepciones" )
12 Dim N1, N2, Resultado As Byte
14 N1 = Readline()
16 N2 = Readline()
17 Resultado = N1 1 N2
18 Writeline( ''Resultado:'' & Resultado.ToString)
19 Catch eProblema As System. Di videByZeroException
20 Writeline( ''>>>>>>> Se trató de dividir entre cero'' )
21 Writeline( ''Error:'' & Err.Number.ToString)
22 Satisfactorio = False
23 Catch eProblema As 5ystem. InvalidCastException
24 Writeline( '' >>>>>>> La conversión cast no es posible'' )
25 Writeline( ''Error:'' & Err.Number.ToString)
27 Catch When Err.Number = 6
28 Writeline( ''>>>>>>> Manejo fuera de limite (Overflow)'' )
30 Finally
31 If Satisfactorio Then
32 Writeline( ''Programa sin problemas'' )
33 Else
34 Writeline( "Programa con problemas." )
35 End If
36 End Try
38 Readline()
39 End Sub
40
41 End Module
162 Alfaomega
SYNAPS PREMIUM

7. Es importante que tome en cuenta que este programa no es type saJe, dado que
tiene la indicación Option Strict Off (línea 2). Esto se realiza porque
intentaremos conversiones tipo cast. También es importante ver que las variables
de trabajo son de tipo Byte (línea 12), y por tanto, sólo soportan un dominio O a
255 sin signo.
8. Proporcione el valor 10 como dividendo, y el e como divisor.
9. Si colocamos el cero como divisor, al querer resolver la línea 17, el programa
determina que eso no es posible, generando una excepción. La excepción es de
tipo Di videByZeroException, por lo que el control del programa se trasladará
al bloque Catch que de manera particular hace referencia a dicho tipo de
excepción.
El control del programa irá al bloque Catch que refiere el tipo de excepción
DivideByZeroException, en la línea 19. Se ejecutarán las líneas 20, 21, y 22, y
luego se procederá a ejecutar el bloque Finally. Se ejecuta el bloque Catch que
corresponde, y no otros.
La línea 21 muestra el número de error del que se trata, utilizando para ello la
propiedad Number del objeto Err, que también funciona en Visual Basic (en forma
mejorada).
La línea 20 muestra un mensaje particular para la excepción de la que se trata;
este es el mayor beneficio de filtrar los errores, ya que si tenemos excepciones
diferentes, es lógico que necesitemos acciones diferentes para manejarlos. El
manejo genérico de excepciones trata a todas por igual, lo que resta precisión a la
función de depuración de programas. El control del programa, agotado el bloque
Catch particular para la excepción que se provocó, seguirá en el bloque Finally.
Es importante ver cómo la línea 9 declara una variable de tipo Boolean
(Satisfactorio), que nos servirá para saber si el proceso fue satisfactorio
(True) o si presentó excepciones (False). De inicio, se considera que el proceso
es satisfactorio (True).
En caso de que suceda alguna excepción, se cambiará el valor de Satisfactorio
a False; con dicho valor le daremos flexibilidad al código del bloque Finally;
anteriormente veíamos que Finally no diferenciaba si el programa había
causado excepción o no. Nosotros le damos esa funcionalidad con nuestra variable
de apoyo, colocando un condicional que ejecute cierto código si presentó
excepciones, y otro bloque de código distinto si no causó excepciones.
Alfaomega 163
SYNAPS PREMIUM
10. Depure la aplicación nuevamente (FS), y proporcione el valor 1e como dividendo,

y el A como divisor.
Vea cómo el programa diferencia entre los tipos de excepciones que pueden ser
causadas en un proceso. Al detectar que no es posible hacer la conversión tipo
cast del valor «A" a su equivalente Byte, se causa el error.
164 Alfa omega

SYNAPS PREMIUM
11. Depure la aplicación nuevamente (FS), y proporcione el valor 1000 como

dividendo.
Vea cómo el programa diferencia entre los tipos de excepciones que pueden ser
causadas en un proceso. Al detectar que 1000 excede el límite de tipo Byte, se
genera la excepción. Si todo ocurrió como se esperaba, la salida será la siguiente.
FIN DEL EJERCICIO *

~ lab.07.03: lanzamiento de excepciones definidas por el
•
usuano
En este ejercicio se protegerá un código determinado, utilizando Try. . . Catch ..•
Finally •.. . El programa solicita dos números (un dividendo y un divisor), y a partir de
Este ejemplo es similar a Jos anteriores, con la diferencia de que nos anticiparemos para
lanzar una excepción antes de que el programa mismo lo haga.
Deliberadamente se causará una excepción, al tratar de dividir entre cero, y se capturará la
excepción antes de que se realice la división, lugar donde anteriormente se manifestaba la
.'
excepcwn.
l. Trabaje sobre la solución Ej ercicios.
Alfaomega 165
SYNAPS PREMIUM

3. Asigne como nombre Excepciones3.
S. Edite el programa Module l. vb del proyecto, de tal manera que quede como
.
sigue.
2 Option Strict On
3
S
6
7 Module Modulel
8
9 Sub Main()
1e Try
11 Writeline( ''Prueba de manejo de Excepciones'' )
12 Dim Nl, N2, Resultado As Decimal
14 Nl = CDec (Readline())
16 N2 = CDec (Readline())
17 If N2 = e Then
18 Throw New Exception ( "Divisor no puede ser cero" )
19 End If
2e Resultado = Nl 1 N2
21 Writeline( ''Resultado:'' & Resultado.To5tring)
22 Catch eProblema As Excepti on
23 Writeline( ''> Problema: '' & eProblema.Message)
24 Finally
26 Readline()
27 End Try
28
29 End Sub
3e
31 End Module

7. Proporcione el valor 1e como dividendo, y el e como divisor.
Si colocamos el cero como divisor, al querer resolver la línea 20, el programa
determinaría que eso no es posible, generando una excepción.
166 Alfa omega

SYNAPS PREMIUM
No nos esperamos a que el programa nos señale la excepción: sabemos que si el

divisor es cero la operación no puede ser correcta. Con eso en mente, decidimos
anticiparnos, y en la línea 17 evaluamos si N2 (el divisor) es cero, en cuyo caso,
lanzaremos una excepción nueva, creada por nosotros (instanciamos
System. Exception), tal como lo muestra la línea 18.
El control del programa se traslada al bloque Catch, y es manejada como
cualquier otra excepción. Si todo ocurrió como se esperaba, la salida será la
siguiente.
FIN DEL EJERCICIO *

~ lab.07.04: Proporcionando manejo estructurado de
excepciones a los programas.
En este ejercicio se implementará el manejo estructurado de excepciones en un programa
ya desarrollado anteriormente.
Partamos de lo siguiente: En todos los sistemas, muchos de los problemas que se presentan
tienen su origen en un manejo erróneo de las aplicaciones por parte de los usuarios. Es
cierto que el buen programador siempre se anticipa a las causas de los problemas y provee
a las interfaces de los mecanismos necesarios para que sólo exista una manera de
introducir datos: de la forma correcta.
Alfaomega 167
SYNAPS PREMIUM
Sin embargo siempre puede haber descuidos, o en ocasiones el uso malintencionado de las
aplicaciones son las que causantes de funcionamientos anormales.
Esto pasa en la realidad: es típico que un usuario escucha que cierta aplicación causa
problemas, y no se toma la molestia de utilizarla, pero sí de propagar la noticia de que la
aplicación falla. Esa mala publicidad nunca ayuda a la estabilidad de las aplicaciones y su
uso en las organizaciones.
Una forma de garantizar que cualquier usuario que asegure que la aplicación falla
realmente haya experimentado una falla, es creando un código de error que deba
proporcionar en caso de levantar un reporte.
l. En la Unidad 3 desarrolló un programa denominado AreaRectangulo.
2. Modifíquelo, de tal manera que quede con manejo estructurado de excepciones.
3. Las acciones a realizar en caso de excepción, es agregar lo siguiente:
Dim Cuando As String
Cuando= String .Format( "{e}.{1}{2}" , Day(Now), Hour(Now), Month(Now))
Console .Writeline( ''El sistema ha experimentado un error." )
Console .Writeline( "Favor de comunicarse con soporte técnico en la" )
Console .Writeline( ''extensión 2e1, mencionando el siguiente código'' )
Console .Writeline( ''que ayudará a la solución del problema:'' )
Consol .WriteLine(String. Format( ''{e}-{1}'' , ex.HResult, Cuando))
4. Haga pruebas.
S. Ahora cambie de estrategia, y trate de filtrar las excepciones si se tratan de tipos de
dato erróneo.
6. Haga las modificaciones para que, si se proporciona cero (e) en algunos de Jos
valores solicitados, se lance una excepción definida por el usuario, ya que no
provocará excepción de tipo inválido, pero el valor Ono es correcto.
7. FIN DEL EJERCICIOI*
168 Alfa omega

SYNAPS PREMIUM
Procedimientos y Funciones
Competencias:
1. Conocer qué son los
procedimientos Y las
f unciones, y la forma en que se
def inen y ejecutan.
2. Conocer los métodos de
desarrollo de procedimientos Y
f unciones, con manejo de
argumentos o sin ellos, Y con
manejo de valores de retorno
o si n ellos.
Evaluacl6n: Evidencia de
1. Proporcionar un caso
práctico en donde se
aprendizaje:
1. Capacidad de aislar procesos
tenga que determinar
específicos en abstracto,
el aislamiento de
pensando en la reutilización Y
tareas, que
la atomicidad de procesos.
posteriormente sean
2. Capacidad de desarrollar
automatizadas a
procedimientos y funciones
través de
en sus diferentes escenarios
procedimientos v
de manejo de argumentos Y
funciones.
valores de retorno.
SYNAPS PREMIUM
8 Procedimientos y Funciones
8.1 Procedimientos........................................................................................................................................... 171
8.1.1 ¿Cuándo definir procedimientos y funciones? ....................................................................... 171
8.1.2 Forma de agregar procedimientos a un programa ............................................................... 172
8.1.3 Forma de mandar llamar a ejecución un procedimiento ................................................... 173
8.1.4 Argumentos .......................................................................................................................................... 173
8.1.4.1 Especificación ByVa/ .................................................................................................................. 173
8.1.4.2 Especificación ByRef .............................................................................................................. ....l7 4
8.1.5 Valores de retorno ............................................................................................................................. 174
8.2 Codificación de procedimientos y funciones ..................................................................................174
8.2.1 Procedimientos ................................................................................................................................... 174
8.2.2 Funciones .............................................................................................................................................. 175
~ Lab.08.01: Procedimiento que no utiliza argumentos .................................................................. 177
~ Lab.08.02: Procedimiento que declara argumentos pero no retorna valores ..................... 179
~ Lab.08.03: Procedimiento que declara argumentos y retorna valores................................... 182
~ Lab.08.04: Uso de ByVal y ByRef ...........................................................................................................185
~ Lab.08.05: Procedimientos multihilos y procesamiento asíncrono......................................... 187
~ Lab.08.06: Decidiendo el uso de procedimientos y funciones ................................................... 191
170 Alfa omega

SYNAPS PREMIUM
Unidad 8: Procedimientos y Funciones
8.1 Procedimientos
La reutilización de código es la práctica de programación que consiste en escribir una sola
vez un bloque de código, con la flexibilidad e independencia suficiente como para que pueda
ser utilizado en múltiples programas y procesos, sin ser modificado.
Las principales formas para hacerlo es a través de los procedimientos y funciones.
Los procedimientos son bloques de código nominados que pueden ser mandados llamar a
ejecución. Las funciones son un tipo de procedimiento que típicamente retorna valores.
Cuando se tiene una tarea grande de programación se puede decidir utilizar procedimien-
tos para dividirla en otras tareas más pequeñas; la realización de todas las pequeñas tareas
particulares implican la ejecución de la tarea general que conforman.
Los procedimientos tienen como objetivo principal crear bloques de código que realizan
una labor independiente, a fin de que puedan ser reutilizados. Por sí mismos, los procedi-
mientos no constituyen un programa formal, sino que operan a manera de soporte con res-
pecto a un programa que los manda ejecutar (programa, interfaz, clase, etcétera).
8.1.1 ¿Cuándo definir procedimientos y funciones?

Un programa, sin duda alguna, puede existir sin recurrir a procedimientos y funciones, pero
el resultado puede ser largo y confuso. A continuación se tienen algunos principios relacio-
nados con los procedimientos y funciones:
1. Atomicidad. Los procedimientos y funciones deben ser atómicos en cuanto a la acti-
vidad que realizan. Generalmente deben tener un objetivo particular, y sólo deben
incluir tareas que tengan que ver con ese objetivo.
a. En esencia, un procedimiento que hace tres cosas, debería transformarse en
tres procedimientos.
2. Jteratividad. Los procedimientos y funciones automatizan procesos iterativos, es de-
cir, que se ejecutan sin variaciones en diferentes partes del programa completo.
a. Si hace un cálculo A y presenta resultados, y luego hace un cálculo B y pre-
senta resultados, presentar resultados es iterativo, y da lugar a un procedi-
miento.
3. Concurrencia. Los procedimientos y funciones pueden ejecutarse de manera concu-
rrente y secuencial; cuando son concurrentes, implica que dos procedimientos pue-
den ejecutarse de forma simultánea sin afectar su funcionamiento. Tome en cuenta
que difícilmente un procedimiento puede agotar los recursos de un equipo, por lo
que sí lanzamos la ejecución concurrente de varios procedimientos -mediante el
uso de hilos, o threads-, puede obtenerse una ventaja de performance; son secuen-
Alfaomega 171
SYNAPS PREMIUM
ciales cuando para la ejecución de un procedimiento se requiere la ejecución previa

de otro.
a. Si una parte del código puede ejecutarse de manera concurrente con otra, se
generan procedimientos para cada una de las partes independientes, y se lan-
zan de manera conjunta a ejecución.
8.1.2 Forma de agregar procedimientos a un programa

La forma de agregar un procedimiento a un programa, es incluir un bloque de código deli-
mitado por la orden Sub y End Sub; la sintaxis es la siguiente:
Sub NombreProcedimiento( )
Instrucciones
End Sub
Donde NombreProcedimiento es el nombre que identifica al procedimiento; Instrucciones es

el bloque de código que será llamado a ejecución a través de NombreProcedimiento. Es po-
sible que se anteponga al Sub la accesibilidad, como Public, Friend, etcétera (para mayor
información, vea el módulo 8), que determinarán la capacidad que tendrá el procedimiento
para ser reutilizado.
Sub y End Sub son las líneas que delimitan el bloque de código del procedimiento. La línea
Sub es la llamada línea de encabezado del procedimiento, porque en ella se declara el nom-
bre del procedimiento, los valores que utilizará para trabajar, así como los valores que re-
,
tornara, en su caso.
Es importante mencionar que Jos procedimientos y las funciones no pueden anidarse, es
decir, que no se puede definir un procedimiento dentro de otro procedimiento; si se desea
esa funcionalidad, puede mandarse llamar a ejecución un procedimiento o función desde
otro procedimiento o función, sin problemas.
Es muy importante que mencionemos que los procedimientos tienen que definirse dentro
de una estructura que el compilador reconozca como contenedora de otros elementos de
programación, como lo son los módulos o las clases. Esto quiere decir que nunca nos topa-
remos un código que directamente codifique procedimientos: generalmente estarán en una
estructura Module o Class.
172 Alfa omega

SYNAPS PREMIUM
8.1.3 Forma de mandar llamar a ejecución un procedimiento

La forma de mandar llamar a ejecutar un procedimiento es muy sencilla, pues sólo se coloca
el nombre del procedimiento, seguido de paréntesis. Vea la sintaxis:
NombreProcedimiento()
Donde NombreProcedimiento es el nombre del procedimiento que será llamado a ejecutar.
8.1.4 Argumentos
Los argumentos, también llamados parámetros, son aquellas expresiones o referencias a
objetos que se le proporcionan a un procedimiento para que realice su tarea con base en
ellos. Los argumentos siempre se declaran dentro de los paréntesis en la línea de encabeza-
do del procedimiento.
Se conocen como argumentos implícitos aquellos que son obligatorios para un determinada
estructura del lenguaje -por ejemplo los eventos de algunas clases-; la particularidad que
tienen es que además de ser requeridos para una funcionalidad dada, los valores de dichos
parámetros son asignados por CLR en tiempo de ejecución, por lo que el programador no
tiene mucho control sobre ellos.
8.1.4.1 Especificación ByVa/
Cuando se especifica un argumento, es importante saber que tienen dos modalidades: By Val
yByRef
Para entender bien este concepto, es necesario que recordemos el concepto de variables.
Como sabemos, las variables son una referencia lógica a una posición física de memoria.
Esto es, cada variable nos permite disponer y modificar el contenido de la memoria que re-
fiere.
En el caso de los argumentos declarados como ByVal, si al argumento se le proporciona
como valor una variable, el argumento define su propia variable de trabajo y refiere su pro-
pia posición en memoria, y copia ahí el valor de la variable original. A partir de ese momen-
to, variable y argumento son independientes, de tal manera que si se modifica el valor del
argumento, el valor de la variable permanece sin cambios.
Utilice ByVal cuando el objetivo de la función no sea modificar o transformar el valor con-
tenido en una variable u objeto.
Alfaomega 173
SYNAPS PREMIUM
8.1.4.2 Especificación ByRef
Contrario a lo que pasa con ByVal, los argumentos definidos como ByRef no reservan su
espacio de memoria, sino que utilizan el mismo de la variable de origen. De esta manera,
tenemos que la variable y el argumento apuntan a la misma posición de memoria. Esto tiene
como consecuencia que, si modificamos el valor del argumento, el cambio también afectará
a la variable.
Utilice ByRef cuando el objetivo de la función sea modificar o transformar el valor conteni-
do en una variable u objeto.
DJ WBVBVS2012.08.01 -Datos de referencia y datos de valor.wmv

8.1.5 Valores de retorno
Los valores de retorno son aquellos valores que un procedimiento puede proporcionar co-
mo resultado de su ejecución.
Aquellos procedimientos que retornan valores son conocidos como funciones.
En el momento en que un procedimiento se codifica, se le especifican tanto los argumentos
que aceptará, como los valores de retorno que tendrá.
8.2 Codificación de procedimientos y funciones
8.2.1 Procedimientos
Si el procedimiento no declara argumentos ni retorna valores, la cosa es muy sencilla:
Sub NombreProcedimiento()
Instrucciones
End Sub
Ejemplo:
Sub Despliega()
Console.Writeline("Pru eba de procedimientos»)
End Sub
174 Alfaomega
SYNAPS PREMIUM
Ejemplo de ejecución:
Despliega()
Si el procedimiento utiliza argumentos, estos deberán declararse entre los paréntesis que
aparecen después del nombre del procedimiento; pueden declararse tantos argumentos
como se deseen, separándose por comas. Cada uno de ellos deberá especificar si se trata de
una expresión (ByVal) o una referencia (ByRef) a un objeto, seguido por el nombre del
argumento, y la correspondiente declaración de tipo:
Sub NombreProcedimiento (Argumental [, Argumento2, . .. ] )

Instrucciones que pueden utilizar los Argumentos
End Sub
Donde cada Argumento es una declaración con la siguiente sintaxis:

[ByVal 1 ByRef] NombreArgumento As [Tipo]
Ejemplo:
Sub Despliega(ByVal Mensaje As String)
Console . Writeli ne(Mensaje)
End Sub
Despliega(''Programa de prueba de procedimientos")
8.2.2 Funciones
Si el procedimiento retorna valores, se trata de una función; a diferencia de los procedi-
mientos, en lugar de Sub, debe utilizarse la palabra reservada Function. Para retornar el
valor de una función, se utiliza la orden Return, seguida del valor que se desea retornar.
Function NombreFuncion() As Tipo
Instrucciones que producen el valor a retornar
Return ValorTipo
End Function
Alfaomega 175
SYNAPS PREMIUM
Ejemplo:
Function DiaDeHoy() As String
Return "Hoy es " & Now.ToString()
End Function
Console.Writeline(DiaDeHoy())
El máximo grado de complejidad para un procedimiento es la función que acepta argumen-

tos y retorna valores.
Function NombreFuncion (Argumental [, Argumento2, ... ] ) As Tipo

Instrucciones que producen el valor a retornar, y utilizan los argumentos
Return ValorTipo
End Function
Ejemplo:
Function Dia(ByVal FechaDada As Date) As String
Return "La fecha proporcionada es " &
FechaDada.ToString()
End Function
Console.Writeline(Dia(Now))
Los argumentos de una función determinada no necesariamente deben proporcionarse en

el orden en que son declarados al momento de su codificación; si se desea pasar los argu-
mentos en un orden distinto al que tienen por definición, es necesario utilizar los nombres
específicos dados a los argumentos.
Vea el siguiente ejemplo, que muestra cómo nominar los argumentos al momento de utili-
zar la función:
Console.Writeline(Dia(FechaDada:=Now))
176 Alfa omega

SYNAPS PREMIUM
~ lab.08.01: Procedimiento que no utiliza argumentos

En este ejercicio demostrará la forma en que se declaran los procedimientos que no
requieren argumentos, y la forma en que se mandan llamar a ejecución.
Para éste y otros ejemplos del módulo, proponemos el siguiente ejemplo hipotético:
Una tienda con venta a crédito tiene una promoción, en donde usted compra hoy y la tienda
no le comienza a cobrar sino transcurridos 90 días. Su programa debe calcular la fecha en
que el cliente debe pagar, contando 90 días a partir de la fecha actual.
Como la tienda cierra los domingos, si la fecha de pago (hoy + 90 días) es domingo, deberá
ampliarse el plazo en un día, con el fin del que el pago pueda ser realizado el día lunes.
Tome en cuenta que: con Visual Basic siempre podremos saber qué día es hoy, utilizando
Now; podremos incrementar los días utilizando la función oateAdd, y validar el día de que se
trata con la función DatePart.
2. Agregue a su solución un nuevo proyecto: lnstalled - Visual Basic -
Windows - Console Application.
3. Asigne como nombre SinArgumentos .
sigue.
1 Module Module1
2 Dim dtmFechaPago As Date
3
4 Sub Main()
S Console .Writeline( ''Hoy:'' & Now.ToShortDateString)
6 FechaPago()
7 Console .Writeline( ''Fecha de pago:'' & dtmFechaPago.ToShortDateString)
8 Esperalntro()
9 End Sub
Hl
11 Sub FechaPago()
12 dtmFechaPago = DateAdd(Datelnterval .Day, 90, Now)
13 If DatePart( Datelnterval .Weekday, dtmFechaPago) - 1 Then
14 dtmFechaPago = DateAdd( Datelnterval .Day, 1, dtmFechaPago)
15 End If
16 End Sub
17
18 Sub Esperalntro()
19 Console .Writeline( ''Pulse INTRO para continuar'' )
2e Console .ReadLine()
Alfaomega 177
SYNAPS PREMIUM
21 End Sub
22
23 End Module

La línea 5 se encarga de desplegar la fecha del sistema.
Para que el programa trabaje como debe ser, es necesario que almacene en
algún lado la fecha calculada; para ello, se declara una variable llamada
dtmFechaPago en la línea 2. El alcance con el que está declarada la variable
(disponible en todo el módulo) será suficiente para que su valor pueda ser
utilizado dentro y fuera de nuestro procedimiento.
La línea 6 manda llamar a ejecución el procedimiento FechaPago(), que
calculará la fecha en que el cliente comenzará a pagar. La ejecución del
programa se traslada automáticamente hasta encontrar una línea de
encabezado de procedimiento que declare a un bloque de código bajo el
nombre de "FechaPago" (línea 11), y por tanto se procede a ejecutar el
bloque de código compuesto por las líneas 12 a la 15, es decir, una después del
Sub, y una antes del End Sub.
La línea 12 asigna a la variable dtmFechaPago el resultado de sumarle a la
fecha del sistema la cantidad de 90 días; las líneas 13 a 15 se encargan de
validar que si el día calculado es domingo (internamente, el día de la semana
número 1), se agregará un día más, a fin de que el día de pago sea un día hábil
(lunes).
El programa se encuentra el fin del procedimiento, y por tal motivo regresa el
control de la ejecución del programa a la línea siguiente a aquella que mando
llamar a ejecución el procedimiento (línea 7). La línea 7 se encarga de
desplegar, en formato de fecha corta, el valor que haya sido calculado, y que
se encuentra en dtmFechaPago.
La línea 8 se encarga de llamar a ejecución un procedimiento llamado
Esperaintro(), que se encarga de mostrar el mensaje que ya hemos
utilizado en otros ejercicios «Pulse INTRO para continuar», y esperar a
que el usuario haga precisamente eso.
Los procedimientos sin argumentos, como el de este ejemplo, tienen un rasgo
característico: toda la comunicación de valores con el resto del programa,
sean datos de entrada o de salida, son manejados a través de variables de
memoria con alcance suficiente como para estar disponibles dentro de los
procedimientos en cuestión.
178 Alfa omega

SYNAPS PREMIUM
Como no declaran argumentos ni valores de retorno son simples. Su aparente

simplicidad es una limitación, ya que todos los programas que deseen hacer
uso del procedimiento deberán declarar las variables que el procedimiento
utiliza, con el mismo tipo y el mismo nombre que con el que fueron
declaradas originalmente.
Para poder reutilizar este procedimiento, el programa que lo pretenda
mandar llamar a ejecución deberá declarar necesariamente una variable que
se llame dtmFechaPago, de tipo Date.
FIN DEL EJERCICIO *

~ Lab.08.02: Procedimiento que declara argumentos pero no
retorna valores
En este ejercicio se demostrará la forma en que se declaran los procedimientos que
requieren argumentos, y la forma en que se mandan llamar a ejecución.
Utilizaremos el mismo caso hipotético del ejercicio anterior, con una pequeña
variante: el cómputo de los 90 días no es a partir de la fecha de hoy, sino de una fecha
cualquiera, que nosotros le proporcionaremos al programa.
Alfaomega 179
SYNAPS PREMIUM

Windows- Console Application.
3. Asigne como nombre ConArgumentos.
sigue.
1 Module Module1
2 Dim dtmFechaPago As Date
3
4 Sub Main()
S Console .Writeline( ''Hoy:'' & Now.ToShortDateString)
6 FechaPago(Now)
7 Console .Writeline( ''Fecha de pago:'' & dtmFechaPago.ToShortDateString)
8 Esperaintro()
9 End Sub
10
11 Sub FechaPago( ByVal FechaBase As Date)
12 dtmFechaPago = DateAdd( Dateinterval .Day, 90, FechaBase)
13 If DatePart( Dateinterval .Weekday, dtmFechaPago) = 1 Then
14 dtmFechaPago = DateAdd(Dateinterval .Day, 1, FechaBase)
15 End If
16 End Sub
17
18 Sub Esperaintro()
19 Con sole . Wri teline( "Pulse INTRO para continuar" )
21 End Sub
22
23 End Module

Para que el programa trabaje como debe ser, es necesario que almacene en
algún lado la fecha calculada; para ello, se declara una variable llamada
dtmFechaPago en la línea 2. El alcance con el que está declarada la variable
(disponible en todo el módulo) será suficiente para que su valor pueda ser
utilizado dentro y fuera de nuestro procedimiento.
La línea 6 manda llamar a ejecución el procedimiento FechaPago(),
proporcionando como argumento el valor de la fecha del sistema (Now); pudo
haber sido cualquier fecha, y el programa calcularía la fecha de pago a partir
180 Alfa omega

SYNAPS PREMIUM
de la misma. La ejecución del programa se traslada automáticamente hasta

encontrar una línea de encabezado de procedimiento que declare a un bloque
de código bajo el nombre de «FechaPago» (línea 11 ). En la declaración del
procedimiento, se especifica que dicho procedimiento espera que el
programa que lo manda llamar a ejecución le proporcione un valor (ByVal)
de tipo fecha (Date).
Se procede a ejecutar el bloque de código compuesto por las líneas 12 a la 15,
es decir, una después del Sub, y una antes del End Sub.
La operación del programa es idéntica al funcionamiento del programa del
proyecto SinArgumentos. Sigue teniendo muchas de las deficiencias propias
del procedimiento que no utiliza argumentos y no retorna valores. Sólo le
encontramos una ventaja: el procedimiento puede trabajar con cualquier
fecha que se le proporcione, y no necesariamente con una que previamente se
haya asignado a la variable dtmFechaPago; eso le da un poco de
independencia al procedimiento. La limitante se sigue dando en los datos de
salida, pero ya no en los de entrada.
Si todo ocurrió como se esperaba, la salida será la siguiente (la fecha del
sistema es ell de enero del2003, por decir alguna):
FIN DEL EJERCICIO*
Alfaomega 181
SYNAPS PREMIUM
~ lab.08.03: Procedimiento que declara argumentos y

retorna valores
En este ejercicio se demostrará la forma en que se declaran los procedimientos que

requieren argumentos y retornan valores, y la forma en que se mandan llamar a
e¡ecuc10n.
o o '
En este escenario, lo correcto es denominar a estos bloques de código como

"funciones", y de hecho notará un par de diferencias en cuanto a los anteriores
procedimientos estudiados hasta ahora en el presente capítulo.
Tome en cuenta la siguiente lista de diferencias:
l . Utilizaremos el bloque Function - End Function en lugar de Sub - End
Sub
2. Se debe especificar de antemano el tipo de dato que retornará nuestra fun-
ción al código que la invoque.
3. Todas las líneas de ejecución que contenga la función deben llegar a un punto
en el que estas retornen un valor del mismo tipo que el especificado en la fir-
ma de la misma.
4. El código que solicite la ejecución de la función deberá estar preparado con
un elemento del mismo tipo que el tipo de dato de retorno de esta para con-
servar en dicho elemento el valor que se le retorne como resultado de dicha
mvocac10n
o o '
Utilizaremos el mismo caso hipotético del ejercicio anterior, con una pequeña
variante: se prohíbe utilizar la variable dtmFechaPago, que veníamos utilizando
como apoyo para la salida del procedimiento.
l. Trabaje sobre la solución Ejercicios.

3. Asigne como nombre ConArgumentosFun .
182 Alfa omega

SYNAPS PREMIUM
S. Edite el programa Modulel . vb del proyecto, de tal manera que quede como
•
s1gue.
1 Module Module1
2
3 Sub Main()
4 Console .Writeline( ''Hoy:'' & Now.ToShortDateString)
5 Console .Writeline( ''Fecha de pago:'' & FechaPago(Now))
6 Esperaintro()
7 End Sub
8
9 Function FechaPago( ByVal FechaBase As Date ) As String
10 FechaBase = DateAdd( Dateinterval .Day, 90, FechaBase)
11 If DatePart( Dateinterval .Weekday, FechaBase) = 1 Then
12 FechaBase = DateAdd( Dateinterval .Day, 1, FechaBase)
13 End If
14 Return FechaBase.ToShortDateString
15 End Function
16
17 Sub Esperaintro()
18 Con sole . Wri teline ( "Pulse INTRO para continuar" )
20 End Sub
21
22 End Module

La línea 5 manda llamar a ejecución la función FechaPago(),
proporcionando como argumento el valor de la fecha del sistema; pudo haber
sido cualquier fecha, y el programa calcularía la fecha de pago a partir de la
.
m1sma.
La función es utilizada como si fuera una expresión String debido a que para
el sistema no representa una función, sino lo que retorna: una expresión
String.
La ejecución del programa se traslada automáticamente hasta encontrar una
línea de encabezado de procedimiento que declare a un bloque de código bajo
el nombre de «FechaPago» (línea 9). En la declaración del procedimiento, se
especifica que dicho procedimiento espera que el programa que lo manda
llamar a ejecución le proporcione un valor (ByVal) de tipo fecha (Date), y
que con base en ello retornará un valor String.
Se procede a ejecutar el bloque de código compuesto por las líneas 10 a la 14,
es decir, una después del Function, y una antes del End Function.
Alfaomega 183
SYNAPS PREMIUM
El cálculo es idéntico al ejercicio anterior, con la variante que sólo se trabaja

con el argumento, dado que no hay variable de trabajo.
El programa se encuentra el fin del procedimiento, representado por la
acción de que la función retornó el valor. La misma línea 14 considera el valor
retronado por la función para desplegar la fecha calculada.
El control de la ejecución del programa continúa a la línea siguiente a aquella
que mando llamar a ejecución el procedimiento (línea 9).
La línea 9 se encarga de llamar a ejecución un procedimiento llamado
Esperaintro( ), que se encarga de mostrar el mensaje que ya hemos
utilizado en otros ejercicios «Pulse INTRO para continuar», y esperar a
que el usuario haga precisamente eso.
Esta función es totalmente flexible, ya que no depende de ninguna variable
externa para funcionar, y para el compilador, la función es una expresión
String. Esta función podría ser reutilizada prácticamente por cualquier
programa, sólo hay que respetar los argumentos que requiere, y el tipo de
valor que retorna.
Si todo ocurrió como se esperaba, la salida es como sigue:
FIN DEL EJERCICIO *
184 Alfa omega

SYNAPS PREMIUM
~ Lab.08.04: Uso de ByVal y ByRef

En este ejercicio se comprobará la forma en que funcionan los alcances de variables
en Visual Basic, y la forma en que podemos aprovechar su manejo para preservar
valores en memoria con eficiencia.
2. Agregue a su solución un nuevo proyecto: Installed - Visual Basic -
3. Asigne como nombre ValRef.
sigue.
1 Module Module1
2
3 Sub Main()
4 Dim Texto As String = "Texto Original"
5 Console .Writeline(Texto)
6 Valor(Texto)
8 Referencia(Texto)
10 Console . Write( "Pulse INTRO para continuar" )
12 End Sub
13
14 Sub Valor( ByVal Texto As String )
15 Texto = ''Texto Valor''
16 Console .Writeline( ''<'' & Texto & ''>'' )
17 End Sub
18
19 Sub Referencia( ByRef Texto As String )
20 Texto = ''Texto Referencia''
21 Console .Writeline( '' <'' & Texto & ''>'' )
22 End Sub
23
24 End Module

7. El programa declara una variable de memoria, llamada Texto, que se verá
sometida a modificaciones en su contenido Qínea 4); de inicio, se le asigna un
valor de «Texto original», mismo que es mostrado en la consola (línea 5).
Alfaomega 185
SYNAPS PREMIUM
La variable será proporcionada como argumento a dos procedimientos, uno

de Jos cuales tratará el dato como valor (líneas 14 a la 17), y otro como
referencia (líneas 19 a la 22).
8. Usando el dato como tipo valor. En la línea 6 se proporciona la variable como
argumento de un procedimiento llamado Valor; dicho procedimiento recibe
el valor y le da tratamiento como tipo valor. En la línea 15 se modifica el valor
de Texto, por «Texto Valor», y se muestran los efectos del cambio en la
línea 16.
Después de ejecutar Valor(), se muestra el contenido de la variable Texto
(línea 7); nos podemos dar cuenta que, aunque se modificó el valor de la
variable en el procedimiento, el valor original no se modificó en lo absoluto.
Esto se debe a que el dato fue manejado como tipo valor, lo que provoca que
el argumento genere su propia copia del dato, dejando al dato original intacto.
9. Usando el dato como tipo referencia. En la línea 8 se proporciona la variable
como argumento de un procedimiento llamado Referencia; dicho
procedimiento recibe el valor y le da tratamiento como tipo referencia. En la
línea 20 se modifica el valor de Texto, por «Texto Referencia», y se
muestran los efectos del cambio en la línea 21.
Después de ejecutar Referencia, se muestra el contenido de la variable
Texto (línea 9); nos podemos dar cuenta que el valor original se modificó.
Esto se debe a que el dato fue manejado como tipo referencia, lo que provoca
que el argumento no genere su propia copia del dato, sino que utilice para el
manejo de información la misma posición de memoria que el valor original.
Si todo ocurrió como se esperaba, la salida es como sigue:
FIN DEL EJERCICIO *
186 Alfa omega

SYNAPS PREMIUM
~ Lab.08.05: Procedimientos multihilos y procesamiento

,
as1ncrono.
En este ejercicio se conocerá una manera de aprovechar las capacidades de
ejecución en múltiples hilos de procesamiento y conocer los fundamentos de su
aprovechamiento.
El paradigma "tradicional" de la programación y codificación de algoritmos en forma
de procedimientos, es un modelo secuencial paso a paso donde cada uno de estos no
puede iniciar hasta que no se concluya el anterior. Con Visual Basic es posible sin
embargo iniciar tareas y dejarlas ejecutando en segundo plano mientras la tarea
principal continúa con su trabajo. Esto permite la ejecución de múltiples tareas de
forma paralela.
En su forma más elemental, esto se logra indicándole al CLR que cree un nuevo hilo
de ejecución en el cual se ejecutará un procedimiento a señalar y continuar con el
procedimiento original mientras el nuevo hilo de ejecución continúa en segundo
plano. Conviene tomar la precaución de preparar la forma de cooperación entre los
hilos de ejecución, ya que cómo estos se ejecutarán de forma asíncrona pueden
interferir en las acciones entre sí.
3. Asigne como nombre Asincronia.
S. Edite el programa Modul el. vb del proyecto, de tal manera que quede como
sigue (En esta primera versión utilizaremos procesos síncronos).
1 Imports System.Diagnostics
2 Imports System.Threading
3 Imports System.Threading. Tasks
4
S Module Module!
6 Sub Main()
7 Dim TiempoTranscurrido As Stopwatch = Stopwatch .StartNew()
8
9 Dim PrimerTarea = Tareal()
10 Dim SegundaTarea = Tarea2()
11 Dim TercerTarea = Tarea3()
Alfaomega 187
SYNAPS PREMIUM
12
13 Console .WriteLine( ''Operación concluida en {a} segundos'' , -
14 TiempoTranscurrido.ElapsedMilliseconds 1 1aaa.a)
15 Console .Writeline( ''Presione <ENTER> para terminar'' )
17 End Sub
18
19 Prívate Function Tarea1() As Integer
28 Console .WriteLine( ''Ejecutando Tarea1 . . . ")
21 Thread .Sleep( 3aaa)
22 Console .WriteLine( ''Tarea1 Concluida." )
23 Return 1
24 End Function
25
26 Private Function Tarea2() As Integer
27 Console .WriteLine( "Ejecutando Tarea2 .. . " )
28 Thread .Sleep(8aaa)
29 Console .WriteLine( ''Tarea2 Concluida." )
38 Return 1
31 End Function
32
33 Private Function Tarea3() As Integer
34 Console .Writeline( ''Ejecutando Tarea3 ... " )
35 Thread .Sleep(3aaa)
36 Console .Writeline( "Tarea3 Concluida." )
37 Return 1
38 End Function
39 End Module
6. Ejecute el código recién capturado y tome nota del tiempo total utilizado.
Note que los procedimientos de cada tarea simulada se invocan de manera
secuencial.
7. Modifique ahora el código para que quede como el ejemplo a continuación

(Ahora sí, con procesos asíncronos).
1 Imports System.Diagnostics
2 Imports System.Threading
3 Imports System.Threading.Tasks
4
188 Alfa omega

SYNAPS PREMIUM
S Module Module1
6 Sub Main()
7 Dim TiempoTranscurrido As Stopwatch - Stopwatch .StartNew()
8
9 Dim PrimerTarea = -
10 Task (Of Integer ).Factory.StartNew( Function () Tarea1())
11 Dim SegundaTarea = _
13 Dim TercerTarea =
15
16 Task .WaitAll(PrimerTarea, SegundaTarea, TercerTarea)
17
18 Console .Writeline( ''Operación concluida en {0} segundos'' , -
19 TiempoTranscurrido.ElapsedMilliseconds 1 1eee.e)
20 Console .Writeline( ''Presione <ENTER> para terminar'' )
22 End Sub
23
25 Console .Writeline( ''Ejecutando Tarea1 ... ")
26 Thread .Sleep(3eee)
27 Console .Writeline( ''Tarea1 Concluida." )
28 Return 1
29 End Function
30
34 Console .Writeline( ''Tarea2 Concluida." )
35 Return 1
36 End Function
37
41 Console .Writeline( "Tarea3 Concluida." )
42 Return 1
43 End Function
44 End Module
Alfaomega 189
SYNAPS PREMIUM
8. Ejecute este nuevo código y tome nota del nuevo valor para el tiempo total
utilizado, a continuación explicaremos el código contenido en el ejemplo
actual.
9. En las líneas de la 1 a la 4 realizamos las importaciones convenientes de

espacios de nombres.
10. La línea 8 inicia un contador de tiempo que nos permite comparar los
tiempos de ejecución entre las dos versiones de este programa
11. En la línea 1 O creamos un nuevo hilo de ejecución y se lo asignamos a la
variable que recibirá el valor que la función a ejecutar en ese hilo retorne.
Aprovechamos para comentar una nueva característica de Visual Basic: Si
,como en este caso, al momento de declarar una variable omitimos su tipo
pero le asignamos un valor retornado por un método, el CLR puede inferir
que la variable tendrá el tipo correspondiente al tipo de retorno del método
en cuestión; en este caso es lnteger. En versiones anteriores, dicha variable
podría haberse declarado como Object; sin embargo, esta nueva característica
nos permite tener código strong typed. Replicamos este proceso para cada
una de las variables a asociar con cada método.
12. La línea 17 le indica al CLR que detenga la ejecución del hilo de ejecución
principal hasta que se tenga la respuesta por cada uno de los métodos
ejecutando en los hilos derivados. Si esta línea no estuviera presente, las
respuestas de cada método se intercalarían en la ejecución del hilo principal
conforme fueran estando completadas las ejecuciones de cada uno.
13. Note en la ejecución que el orden de conclusión de los métodos no representa
el orden en que fueron invocados, sino el orden en que cada uno fue
terminando de acuerdo a la duración de su procesamiento.
14. El código que abarca las líneas 19 y 20 reporta el tiempo total consumido en
el proceso de los métodos invocados
15. Las líneas 21 y 22 simplemente muestran un mensaje de conclusión y evitan
el cierre de la ventana de consola.
16. En la línea 25 se define el primer método que asociaremos a la
correspondiente primer tarea. El formato es el mismo para los métodos
definidos en las líneas 32 y 39: Iniciamos desplegando un mensaje
informativo para que el usuario sepa que hemos iniciado la ejecución del
método, instruimos al CLR para que suspenda la ejecución de este hilo por un
190 Alfa omega

SYNAPS PREMIUM
período determinado que varía en cada uno de los métodos de ejemplo,

desplegamos un mensaje que informa la conclusión del método actual y por
último retornamos un valor entero.
Cómo puede ver, la capacidad de ejecutar simultáneamente múltiples tareas puede
apoyarnos para disminuir los tiempos de respuesta de nuestras aplicaciones.
FIN DEL EJERCICIO *
~ lab.08.06: Decidiendo el uso de procedimientos y

funciones.
En este ejercicio se decidirá el uso de procedimientos y funciones, y se implementará
en un programa.
El caso es el siguiente: Una organización con oficinas a nivel mundial expide
credenciales a sus empleados, y dicha credencial le permite el ingreso a las oficinas
en cualquier parte del mundo.
Dado que hay personas que podrían estar interesadas en ingresar de forma no
autorizada, para evitar falsificaciones, cada credencial incluye un código encriptado
(hash) generado a partir del primer nombre y el primer apellido del titular.
En caso de que el personal de seguridad en cualquiera de las oficinas tenga dudas
respecto a la autenticidad de algún documento, dispondrá de un programa que le
dice, dado el nombre de la persona, cuál es el código encriptado que le corresponde.
Si el código generado no corresponde al nombre, la credencial se retiene y la persona
es denunciada.
Es importante que el programa no sólo muestre el código, sino que muestre el
detalle, carácter por carácter, para evitar que alguna confusión de letras por número.
Veamos un ejemplo.
Si la clave es
ajE91B8
El programa debe mostrar la siguiente información:
Clave: ajE91B8
Detalle : a-j-E-cero-uno-B-ocho
Alfaomega 191
SYNAPS PREMIUM
Por política de desarrollo de la organización, cuando se tiene un programa, se debe

separar la captura de datos, el procesamiento, y el reporte de datos.
1. Agregue a su solución Ejercicios, un proyecto de tipo Console Application,

de nombre Seguridad.
2. Al inicio del programa, agr egue las líneas necesarias para tener disponibles
los espacios de nombre System. Text y System. Security. Cryptography.
3. A nivel módulo, declare una variable llamada Nombre, y una llamada Clave, y
una llamada Detalle, todas de tipo String. Al ser declaradas a este nivel,
estarán disponibles para todo el programa.
4. Agregue un procedimiento llamado Captura(), en donde capture el nombre
del empleado, asignando la captura a la variable Nombre.
S. Agregue la siguiente función al programa.
1 Function CreaHash( ByVal TextoBase As String ) As String
2
3 Dim UE As New UnicodeEncoding
4 Dim Hash As Byte ()
S
6 'Almacena la cadena ingresada en una matriz de bytes
7 Dim bCadena() As Byte = UE.GetBytes(TextoBase)
8 Dim ServicioSHAl As New SHAlCryptoServiceProvider
9
1e 'Crea el hash
11 Hash = ServicioSHAl.ComputeHash(bCadena)
12
13 'Retorna como una cadena codificada en base64
14 Dim CodigoHash As String
15 CodigoHash = Convert .ToBase64String(Hash)
16
17 Return CodigoHash
18
19 End Function
6. Esta funció n, al proporcionarle como argumento un texto cualquiera, retorna

el código encriptado a 64 bits, correspondiente al texto. La funcionalidad
obtenida es esta:
CreaHash("Felipe Ramírez") = zpdaENS8j3giDVMVuW7mmdvhT8I=
7. Agregue una función llamada DetalleHash(), que retorne un valor String

correspondiente al detalle de la clave proporcionada, es decir, la
192 Alfa omega

SYNAPS PREMIUM
representación letra por letra, separados por guiones, donde los dígitos sean
llamados por su nombre (l=uno, 2=dos, y así).
a. Para leer letra por letra la composición de Clave, sugerimos que
agregue un For Next, de i=l, al ancho de Clave (Len (Clave)), lo
que le permitirá recorrer todas las posiciones de la Clave.
Len "Hola" = 4
b. Para recuperar el contenido de cada una de las posiciones de la clave,

puede utilizar la función del sistema Mid(String, x, y), donde
String es la cadena que está recorriendo, x la posición dentro de la
cadena, y y el número de caracteres que quiere extraer. Sugerimos que
asigne el valor de la posición a una variable (Letra), para que pueda
trabajar mejor con el dato.
Mid{"Hola", 3,1 = "1"
c. Una vez que sabe el contenido de la posición, evalúe si se trata de un

dígito, y de ser así, sustituya por el nombre. Un Select Case está
perfecto para la tarea.
Select Case Letra
Case Letra="l"
Letra="uno"
Case Letra="2"
Letra="dos"
Y así...
d. El resultado es acumulativo dentro del ciclo de control. Sugerimos que
defina una variable para ello (Resultado).
Resultado += Letra
e. Para agregar los guiones intermedios, tome en cuenta que mientras la

posición no sea la última, se agregará un guion.
If i < Len(Texto) Then
Resultado += "-"
End If
f. Finalmente, la funcionalidad obtenida es esta:
Alfaomega 193
SYNAPS PREMIUM
DetalleHash("ajEelBS" ) - "a-j-E-cero-uno-B-ocho "
8. Agregue un procedimiento llamado Procesa(), en donde realice el

procesamiento, que equivale a almacenar en la variable Clave el código hash
correspondiente al Nombre (para ello utiliza la funció n CreaHash () ), y
asignar en Detalle la representación letra por letra, de la clave (para ello
utiliza DetalleHash () ).
9. Agregue un procedimiento llamado Reporta() , en donde se muestren los
resultados de la ejecución.
10. Agregue un procedimiento llamado Espera(), que contenga las líneas para
que el programa espere que presione INTRO, para continuar.
11. Si todo se hace bien, su programa debe ofrecer la siguiente salida.
12. En el procedimiento principal de su programa (Main () ) sólo deben aparecer

llamadas a procedimientos.
Sub Main()
Captura()
Procesa()
Reporta()
Espera()
End Sub
FIN DEL EJERCICIO *
194 Alfa omega

SYNAPS PREMIUM
Programación Orientada a Objetos
Competencias:
l. Conocer los término s
fundamentales de la
programación orientada a
objetos : cla ses, objetos, campos,
propiedades, métodos y eventos .
2. Conocer en qué consist e el
encapsulamiento, la herencia y el
poli morfismo.
3. Conocer las t écnicas de
implementación de objetos
mediante programación y
herramientas de Visual Studio.
Evaluacl6n:
en el cual se decida el
desarrollo de una Evidencia de
clase y los miembros aprendizaje:
que debe tener. 1. Capacidad de analizar cuándo una
2. Proporcionar un caso clase puede ser implementada,
en el cual se determinando sus métodos y
desarrolle una clase propiedades.
• • 2. Capacidad de implementar clases
que provea serv1c1os a
que incluyan métodos y
otros programas.
propiedades.
3. Capacidad de consumir clases
desde otros programas.
SYNAPS PREMIUM
9 Programación Orientada a Objetos

9.1 Términos básicos de P00 ....................................................................................................................... 197
9.1.1 Clases y objetos ................................................................................................................................... l97
9.1.2 Campos, propiedades, métodos y eventos ............................................................................... 197
9.1.3 Encapsulamiento, herencia y polimorfismo ............................................................................ 198
9.1.3.1 Encapsulamiento .........................................................................................................................199
9.1.3.2 Herencia .........................................................................................................................................199
9.1.3.3 Polimorftsmo .................................................................................................................................200
9.2 Elementos esenciales de los objetos .................................................................................................. 200
9.2.1Identidad ....................................................... ........................................................................................ 200
9.2.2 Estado .....................................................................................................................................................201
9.2.3 Comportamiento ................................................................................................................................ 201
9.3 Clases~ Métodos y Propiedades ............................................................................................................ 202
9.3.1 Definición de una clase .................................................................................................................... 202
9.3.2 Definición de propiedades .............................................................................................................203
9.3.3 Modificadores de Acceso.................................................................................................................205
~ Lab.09.01: Creando una clase con propiedades y métodos .........................................................206
a) Uso de Code Snippets ..........................................................................................................................206
b) Class Diagram .......................................................................................................................................209
e) Class View................................................................................................................................................ 212
d) Selector de documentos activos (Active Documents) .............................................................. 212
e) Agregando resumen a los miembros ............................................................................................. 213
f) Consumiendo la c/ase........................................................................................................................... 215
~ Lab.09.02: Haciendo un programa class-based ............................................................................... 216
196 Alfa omega

SYNAPS PREMIUM
Unidad 9: Programación Orientada a Objetos
9.1 Términos básicos de POO
9.1.1 Clases y objetos
Una clase es una definición formal de un tipo de objeto. La clase define qué datos formarán
parte de un objeto, qué tareas desarrollará el objeto, y de qué manera interactuará el objeto
con el usuario y con otros objetos.
Los objetos son instancias de una clase. Por instancia podemos entender una copia funcional
de la clase. A la acción de generar un objeto a partir de una clase, se le denomina instancia-
ción.
Al procedimiento o código que realiza la instanciación se le denomina constructor. Al pro-
cedimiento o código que destruye a un objeto, liberando los recursos que éste consumía, se
le llama destructor. En los lenguajes .NET no es necesario codificar destructores, debido a la
existencia del garbage collector, que es el elemento de CLR que se encarga de eliminar obje-
tos no utilizados, a fin de liberar los recursos que utilizan.
DI WBVBV$2012.09.01 - Clases y Objet.os.wmv
9.1.2 Campos, propiedades, métodos y eventos

Las clases, y por tanto los objetos que se derivan de ellas, son un conjunto de datos y com-
portamientos; tanto las clases como Jos objetos están formadas por campos, propiedades y
métodos.
Los campos y las propiedades representan la información que un objeto contiene. Los cam-
pos (fields) son elementos de una estructura, que actúan como valores equivalentes, nomi-
nados.
Las propiedades (properties) son muy parecidas a Jos campos, en el sentido que almacenan
valores; su implementación, sin embargo, es más formal, ya que para leer y asignar valores
a las propiedades es necesario el uso de las instrucciones Property Get y Property
Set, las cuales proporcionan un mayor control con respecto a la forma en la que Jos valores
pueden ser asignados o leídos.
Cuando se utilizan propiedades, la lectura y la asignación de valores son directas, lo que
implica que entre el programa que usa las propiedades y el valor almacenado existe una
capa intermedia de control, que ayuda a aislar (iso/ate) a la aplicación de los valores que
utilizará, permitiendo que dichos valores puedan ser validados antes de que se lean o asig-
nen.
Alfaomega 197
SYNAPS PREMIUM
Los métodos son los comportamientos predefinidos que puede presentar un objeto. En cier-
ta forma, los métodos representan las acciones que el objeto podrá realizar. La manera en
que se pueden definir los métodos es agregando procedimientos y funciones a una clase; al
momento de generar una instancia de dicha clase, los procedimientos y funciones que le
codificamos a la clase formarán los métodos disponibles para el objeto.
Un evento es el resultado de la interacción que un usuario o programa tiene con un objeto,
en una circunstancia dada, que desencadena la ejecución de un procedimiento o método.
La interacción que tiene el usuario o programa con un objeto, provoca internamente una
interacción de dicho objeto con otros, misma que puede ser bidireccional, ya sea que el ob-
jeto reciba una petición de un objeto o aplicación, o bien, que realice una petición a otro
objeto o aplicación.
A las propiedades, métodos y eventos también suele llamárseles miembros (members), que
son el conjunto de elementos declarados por una clase.
Figura
09.01
Estructura de un objerc
Miembros
Objeto
r~
r Eventoe
9.1.3 Encapsulamiento, herencia y polimorfismo

Para que una aplicación realmente esté orientada a objetos, es necesario que soporte las
cualidades de encapsulamiento, herencia y polimorfismo. Estas tres cualidades son repre-
sentativas de POO.
198 Alfa omega

SYNAPS PREMIUM
9.1.3.1 Encapsulamiento
El encapsulamiento es la capacidad que tiene un objeto para almacenar datos y procedi-

mientos, como una unidad funcional, y permitir el acceso a ellos sin que los demás objetos
tengan la necesidad de conocer cómo se integran dichos datos y dicho comportamiento
dentro del objeto. Todo lo que debemos saber de un objeto es qué datos recibe y qué datos
retorna, así como las acciones que realiza.
Las ventajas que proporciona el encapsulamiento a los programadores de software son las
siguientes:
1. Facilita la modularidad. Un módulo es un bloque de código que desarrolla un proceso
específico. La modularidad es la capacidad que se tiene de dividir los procesos en múl-
tiples procesos más pequeños.
2. Mantiene la información oculta. El objeto puede por sí solo encargarse de modificar
los valores de sus propiedades; además, para hacer uso del objeto no es necesario co-
nocer cómo es que realiza las operaciones internas (comportamiento). Sólo el objeto se
encarga de manejar su estado y su comportamiento.
9.1.3.2 Herencia
La herencia describe la habilidad de crear una nueva clase basada en una clase existente.
La clase existente a partir de la cual se generará la nueva clase recibe el nombre de clase
base (base class); la nueva clase, llamada clase derivada (derived class), hereda todas las
propiedades, métodos y eventos de la clase base, y a partir de ahí, puede agregársele las
propiedades y métodos particulares que la hacen especial.
Las ventajas que proporciona la herencia a los programadores de software son las siguien-
tes:
1. Reuso de código. La mayor ventaja de la herencia es que el código se reutiliza de una
forma más eficiente, pues las clases parten de otras clases más generales; esto garantiza
que de inicio las clases ya tienen la funcionalidad de otras anteriormente creadas. Sólo
se estará desarrollando nueva funcionalidad, evitándose el código redundante.
2. Jerarquía de clases. Es posible realizar una jerarquía que distinga procesos generales y
específicos.
Alfaomega 199
SYNAPS PREMIUM
9.1.3.3 Polimorfismo
El polimorfismo es la capacidad de manejar múltiples clases que pueden ser utilizadas de

manera intercambiable, a través de una misma implementación (nombre de clase).
El polimorfismo es esencial para la programación orientada a objetos, ya que permite, a
través de un mismo nombre de clase, poder agrupar diferente funcionalidad, dependiendo
de las propiedades y métodos que se utilicen al momento de invocarlas. Una clase puede
tener un método llamado Calculo, pero puede realizar dos diferentes operaciones, depen-
diendo el número de parámetros que se le proporcionan al método, la secuencia en la que
se le proporcionan, y sus respectivos datatypes.
A la combinación de nombre de método más sus parámetros, se le llama signature; en ese
sentido, podemos decir que una clase polimórfica tiene métodos con diferente signature:
Métodos que se llaman igual pero reciben diferentes parámetros, ya sea en su cantidad, se-
cuencia, o datatype.
9.2 Elementos esenciales de los objetos

Al generar instancias de una clase, estamos generando un objeto. Una vez que los objetos
existen, es posible que los utilicemos para obtener funcionalidad de la aplicación. Es impor-
tante que nos hagamos a la idea de que un objeto, una vez que es creado, ya posee vida pro-
pia y es independiente de todos los demás objetos.
Los objetos, una vez creados, tendrán tres características principales:
1. Identidad.
2. Estado.
3. Comportamiento.
9.2.1 Identidad
La identidad del objeto es su capacidad de tener un nombre que lo identifica y lo diferencia
de los demás objetos. No podemos crear ningún objeto sin asignarle un nombre para su
identificación, pues de ser así generaríamos un elemento al cual no podríamos invocar de
ninguna manera, o lo que es lo mismo, no sería referenciable.
En Visual Basic los objetos poseen una propiedad llamada Name, a través de la cual se mani-
fiesta la identidad de los objetos. A la propiedad Name también se le conoce como propiedad
de identidad.
200 Alfa omega

SYNAPS PREMIUM
9.2.2 Estado
El estado de un objeto es la situación de forma y capacidad de comportamiento que tiene el
objeto en un momento determinado, en tiempo de ejecución.
El estado está determinado por el juego de valores que tienen las propiedades del objeto;
como sabemos, las propiedades son las características particulares del objeto, y especifican
su nombre, su posición, su apariencia, y hasta sus capacidades de interacción con el usuario
y con otros objetos.
Si cambiamos el valor de cualquiera de las propiedades, como podría ser incrementar el
ancho del objeto de 10 a 20 pixels, ello representa una modificación de estado.
Tome en cuenta que la identidad del objeto también forma parte del estado del mismo, pues
Name es una propiedad, al igual que las de posición, apariencia, y otras.
9.2.3 Comportamiento
El comportamiento es la capacidad del objeto para funcionar de una determinada manera.
Como respuesta a la interacción del usuario, de otros objetos, o incluso del mismo sistema,
el objeto podrá comportarse de diferente forma.
El comportamiento de un objeto se presenta por la posibilidad de mandar llamar a ejecu-
• 1
CIOn:
l. Los métodos.
2. Los procedimientos de evento.
3. Los procedimientos y funciones definidas por el usuario.
Los métodos, como sabe, son los comportamientos predefinidos que un objeto puede pre-
sentar, y que se encuentran definidos por la clase de la cual el objeto deriva.
Los procedimientos de evento son aquellos procedimientos que le suceden a un objeto, como
respuesta a la interacción que tienen con el usuario o con otros objetos. El objeto tiene un
conjunto de eventos que reconoce, y usted como desarrollador lo único que hace es decirle
a su programa (a) que quiere que un objeto determinado sea sensible a los eventos que le
sucedan (especificación Wi thEvents al momento de la declaración), (b) elaborar un pro-
cedimiento, y (e) especificarle a dicho procedimiento que será ejecutado en caso de que le
suceda el evento a alguno de los objetos que maneje (Handles). En este tipo de procedi-
mientos generalmente se tienen argumentos implícitos.
Los argumentos implícitos son aquellos que son declarados por Visual Basic de manera au-
tomática, y forman parte de la estructura misma de la clase; la diferencia entre los argu-
mentos y los argumentos implícitos es quién le provee los datos: en el caso de estos últimos,
Alfaomega 201
SYNAPS PREMIUM
CLR es el que se encarga de proveerles los datos de forma dinámica y automática cuando se
ejecuta el programa (tiempo de ejecución). Un ejemplo de ello es el procedimiento de evento
que percibe el movimiento del puntero de ratón sobre los objetos (MouseMove); en tiempo
de ejecución, el procedimiento tendrá dos argumentos (X, Y) que mantienen las coordena-
das del puntero del ratón; si se mueve el puntero, CLR actualiza Jos datos en tiempo real, sin
que el desarrollador se deba preocupar por determinar la posición y asignarlo a los argu-
mentos.
Cada evento podrá exigir la presencia de los argumentos implícitos que necesita para traba-
jar; cuando nosotros declaramos un objeto especificando que queremos que sea sensible a
eventos (Wi thEvents), también le estamos diciendo al programa que queremos que Vi-
sual Basic se encargue de actualizar, en tiempo de ejecución, los datos de los argumentos
implícitos de cada uno de los eventos aplicables al objeto. Nosotros no determinamos el
valor que tendrán los argumentos implícitos; es el CLR, en tiempo de ejecución, quien de-
termina qué valores tendrán.
Los procedimientos definidos por el usuario y las funciones definidas por el usuario, son los
procedimientos y funciones que usted codifica, respectivamente; no dependen de los even-
tos que pueden sucederle al objeto, ni requieren estar predefinidos en ninguna clase: son la
forma más pura de codificación.
Los procedimientos y funciones definidas por el usuario son la parte más especializada de
las aplicaciones, ya que contienen los bloques de código que han de realizar aquello que el
lenguaje por sí mismo no puede. En ocasiones se dice que los procedimientos y funciones
definidas por el usuario, son las reglas de negocio, para la aplicación.
9.3 Clases, Métodos y Propiedades
9.3.1 Definición de una clase

Antes de que proceda a desarrollar una clase determinada, asegúrese de que no hay una
clase en la biblioteca de clases de .NET Framework que haga precisamente lo que desea co-
dificar.
Para crear una clase debe utilizar la siguiente sintaxis.
el ass NombreC/ase
CódigoClase
End class
202 Alfa omega

SYNAPS PREMIUM
Donde NombreC/ase es el nombre a través del cual la clase puede ser invocada. La instancia-
ción de la clase se deberá llevar a cabo por medio de este nombre. CódigoC/ase es el conte-
nido de la clase; como sabemos, el contenido de la clase se compone de datos (propiedades)
y comportamiento (métodos y funciones).
Por esa razón debemos definir dentro de la clase los siguientes elementos. principalmente:
l. Procedimientos (sub - End sub)
2. Funciones (Function - End Function)
3. Propiedades(Property - End Property)
Una clase, como ya sabe, es la definición formal de un objeto. Las clases por sí mismas no
pueden ser utilizadas. Es necesario crear unidades funcionales de las clases, es decir, obje-
tos. Para ello debemos recurrir a un constructor, que es el código que genera la instancia de
una clase:
oim Objeto As New NombreC/ase()
Donde Objeto será el nombre de la instancia de la clase; NombreCiase es el nombre de la

clase que se está instanciando. New es la instrucción constructora por excelencia.
Una vez generada la instancia de la clase, podemos utilizar todos sus elementos, como po-
drían ser los métodos, las funciones y las propiedades.
9.3.2 Definición de propiedades

Una clase puede, además de definir su comportamiento a través de métodos y funciones,
especificar qué propiedades han de conformar su estado.
Las propiedades son las características particulares de un objeto; la clase debe definir qué
propiedades tendrán los objetos que deriven de ella. Para su definición, es necesario definir
las propiedades dentro del bloque de código que compone la clase.
Las propiedades almacenan valores de un determinado tipo de dato, y las operaciones que
se pueden hacer con dicho valor es leerlo (GET) o asignarlo (sET).
Las propiedades, aunque son valores almacenados, tienen un manejo más formal que las
variables de memoria, y de hecho requieren de una variable de memoria que permite la
verificación de los valores, antes de que sean leídos o asignados.
Alfaomega 203
SYNAPS PREMIUM
Sintaxis de la definición de propiedades.

el ass NombreCJase
oim Variable As TipoDatoPropiedad
Property NombrePropiedad As TipoDatoPropiedad
Get
CódigoLectu ra Valor
End Get
set (VariableArgumento As TipoDatoPropiedad)
CódigoAsignación Valor
End set
End Property
• • •
• • •
End class
Donde NombreClase es el nombre de la clase a la que pertenece la propiedad; antes de de-

clarar la propiedad se debe declarar una variable de trabajo (Variable) del mismo tipo de
dato que el que pretende almacenar la propiedad (TipoDatoPropiedad).
Para recuperar el valor que tiene la propiedad se usa CódigoLecturaValor, que es el bloque
de código que se encarga de recuperar el valor de la variable de paso, para considerarlo
como valor de la propiedad.
Para asignarle un valor a una propiedad se utiliza una variable de trabajo (VariableArgu-
mento) que recibe, a manera de argumento, el valor que se pretende asignar a la propiedad.
CódigoAsignación Valor es el bloque de código que se encarga de validar el valor que se pre-
tende asignar a la propiedad; en caso de que sea válido, realiza la asignación.
En una clase se pueden definir tantas propiedades como se requieran en el programa, y por
supuesto, además se pueden definir métodos y funciones que formen parte de la misma.
Estos métodos y funciones pueden hacer uso de las propiedades, con solo referirlas por su
nombre.
Una regla clásica para saber qué propiedades deben definirse es la siguiente: la clase debe
ser autosuficiente, es decir, no debe depender de elementos externos a ella para funcionar.
Si una clase requiere que se defina, fuera de ella, una variable con el alcance y la accesibili-
dad suficiente para ser utilizada por algún procedimiento al interior de la clase, dicha va-
riable debería incluirse dentro de la clase como propiedad.
En desarrollos grandes, lo que se acostumbra es desarrollar clases que agrupen la mayor
cantidad de funcionalidad de una misma naturaleza -clase de soporte a interfaces, clases
para gestión de base de datos, clases de cálculos, etcétera-, que al compilarse darán lugar a
librerías (archivos de extensión DLL), que junto con las librerías de .NET Framework nos
permitirán disponer de la funcionalidad que nuestras aplicaciones requieren.
204 Alfa omega

SYNAPS PREMIUM
9.3.3 Modificadores de Acceso

Si la idea es generar una librería de clases independiente de Jos programas ejecutables, es
lógico pensar que dicha biblioteca estará disponible para su utilización por uno, dos o más
ejecutables (de ahí la razón de independizarlo). Ello no significa, sin embargo, que cualquier
ejecutable podrá hacer uso de la biblioteca de clases; es posible que nosotros no queramos
limitar el acceso a la biblioteca de clases, y para ello podemos utilizar los denominados mo-
dificadores de acceso.
Los modificadores de acceso son calificadores de declaración que determinan el grado de
encapsulamiento de una clase.
El acceso aplica sobre las entidades (clases, propiedades, métodos).
A continuación se muestran a grandes rasgos los modificadores de acceso.
Palabra Clave Definición
Public Las entidades pueden ser llamadas de cualquier parte; también se le
·--·-·-·· ··-·· ··-· ... ··- ~_9E_9~_<:_Q!!,l_Q._~.f.~SO [!~ b{~C:f!..:._. _,_,_,_,_,__,_, ·-· .............. . ·-·------·----·-------·
Private Las entidades sólo se pueden llamar desde el contexto mismo de su
declaración. También se le conoce como acceso privado.
Friend El acceso amigable permite el acceso a las entidades desde el mismo
programa en donde se hace su declaración.
Protected El acceso protegido permite el acceso a las entidades sólo desde la
. misma clase, así como sus clases derivadas .
Protected Es la mezcla del acceso amigable y el acceso protegido.
Friend
La forma de especificar los modificadores de acceso es colocándolos al principio de la defi-

nición de las clases, propiedades y métodos.
Usted debe determinar el alcance que tendrá su jerarquía de clases, a efecto de restringir el
acceso a las clases de tal manera que sólo puedan heredarlas aquellas porciones de código
que deban hacerlo.
Tome en cuenta que en una jerarquía de clases el acceso sólo puede heredarse hacia un ac-
ceso igual o mayor, nunca menor; una clase con acceso Public no puede heredar una clase
Friend o Private, y una clase Friend no puede heredar una Private.
Alfaomega 205
SYNAPS PREMIUM
~ lab.09.01: Creando una clase con propiedades y métodos

En este ejercicio se generará una clase que contiene propiedades y métodos, para
su consumo desde otros programas. Para demostrar todo esto con código,
generemos una clase muy simple, que permitirá calcular el área de diversas
figuras geométricas. Los valores requeridos para calcular las áreas
correspondientes deberán ser manejados como propiedades.
Windows - Class Library.
3. Asigne como nombre Area.
S. Edite el programa Class l . vb del proyecto, y cambie el nombre de la clase,
sustituyendo el assl por Areas.
a) Uso de Code Snippets
l. Una de las costumbres más arraigadas de los programadores es utilizar

código que ya han escrito antes, en programas nuevos. Con un simple Copy-
Paste se gana mucho tiempo, dado que hay código genérico que con pocas
modificaciones funciona para todos Jos programas. Visual Studio incorpora
muchas pequeñas rutinas de uso común con el fin de que sean integradas y
modificadas para su utilización en programas; a estos patrones de código
prestablecidos se les da el nombre de Code Snippets.
2. Una de las operaciones más comunes al momento de codificar clases es la
incorporación de propiedades, por Jo cual debe existir un Code snippet
correspondiente.
a. Colóquese dentro de la clase.
b. Inicie un Code snippet. Tiene dos formas de hacerlo: a) Invoque el
menú de contexto y seleccione lnsert snippet..., o b) Presione CTRL+K,
CTRL+X
c. Aparecerá una herramienta parecida a lntellisense, que permite
seleccionar los patrones de código prestablecidos de Visual Studio.
d. Seleccione Common Code Patterns.
e. Seleccione Properties, Procedures, Events.
f. Seleccione Define Properties.
206 Alfa omega

SYNAPS PREMIUM
g. Con ello se codificará la estructura básica de una propiedad.
C&Hil W'b' • X
• ii~D«tontiom~
Public Class Ar•as +

Privat~ newPrope~yValue As String •
A Public Property NewProperty{) As String
¡; ~t
Return newPropertyValue
End Get
Set(ByVal val ue As String)
newPropertyValue = value
End Set •
End Property
End Class
3. Tome en cuenta una cosa: Cada propiedad requiere una variable de trabajo
que servirá para manejar Jos datos al interior de la clase; al exterior de la
clase, la propiedad podrá ser utilizada, pero la variable de trabajo será
inaccesible.
4. La variable de trabajo es conocida como campo (field). El campo y la
propiedad deben llamarse diferente, pero deberán tener el mismo datatype.
S. Suponga que queremos crear las propiedades para el cálculo del área de un
rectángulo. Lo más lógico es que existiera una propiedad llamada Base, y otra
que se llame Altura, que son de tipo Decimal. Tomamos la decisión de que
las variables de trabajo tengan el mismo nombre que las propiedades, con la
diferencia que les antepondremos una letra «p». En resumen, las propiedades
Base y Altura se apoyarán en las variables pBase y pAl tura.
6. En el código agregado por el Code snippet, seleccione newPropertyValue
haciendo doble die en la palabra.
a. Esta variable es la variable de trabajo que utilizará la propiedad.
b. Vea cómo se selecciona el elemento en todos los lugares en donde es
utilizado.
c. Sustituya newPropertyValue con pBase, y presione TAB.
d. Al presionar TAB ocurrirán dos cosas: a) Se sustituirá el nombre de la
variable en todo el código, y b) Se trasladará el control al siguiente
elemento de código, que es el datatype que la variable de trabajo y la
propiedad compartirán.
e. Sustituya Sting por Decimal, y presione TAB.
Alfaomega 207
SYNAPS PREMIUM
f. Ahora estará en el nombre de la propiedad. Sustituya NewProperty

por Base, y habrá terminado la codificación de su propiedad.
g. La codificación representa lo siguiente: a) Se utilizará la variable
pBase como variable de trabajo de la propiedad Base, y ambas son
Decimal; b) Cuando se solicite o utilice la propiedad (GET), se
retornará el valor que en ese momento la variable de trabajo; y e)
Cuando se le establezca un valor a la propiedad (SET), el valor que se
le asigne a la propiedad le será asignado a la variable de trabajo.
7. Use Code snippet y agregue la propiedad Altura, siguiendo el mismo
procedimiento que se utilizó para crear la propiedad Base.
¡gl WBVBVS2012.09.02 · Métodos con Code Snippets.wmv
8. Después de la segunda propiedad, agregue un método a la clase, usando Code

snippet.
a. Inicie un Code snippet.
b. Seleccione Common Code Patterns.
c. Seleccione Properties, Procedures, Events.
d. Seleccione Define function.
e. Con ello se codificará la estructura básica de una función.
9. Remplace MyFunc por Rectangulo, y muévase al siguiente elemento
presionando TAB.
10. Remplace Integer por Decimal, y muévase al siguiente elemento
presionando TAB.
11. Remplace el valor de retorno e por (Base * Altura)
12. Genere una nueva función usando Code snippets, y genere una nueva función
de nombre Triangulo, cuyo valor de retorno sea Decimal, y que retorne
((Base * Altura)/2).
13. El código debe haber quedado como sigue.
1 Public Class Areas

2 Private pBase As Decimal
3 Public Property Base() As Decimal
4 Get
5 Return pBase
208 Alfaomega
SYNAPS PREMIUM
6 End Get
7 Set (ByVal value As Decimal )
8 pBase = value
9 End Set
1e End Property
11
12 Private pAltura As Decimal
13 Public Property Altura() As Decimal
14 Get
15 Return pAltura
16 End Get
18 pAltura = value
19 End Set
28 End Property
21 Function Rectangulo() As Decimal
22
23 Return (Base * Altura)
24 End Function
25
26 Function Triangulo() As Decimal
27
28 Return ((Base * Altura) 1 2)
29 End Function
38
31 End Class
b) Class Diagram
14. Sin duda alguna, Code snippet es una facilidad sorprendente para agilizar el
código, pero no es la única opción. Para aquellos que deseen una alternativa
más gráfica, se puede utilizar los diagramas de clases (Ciass Diagra m).
15. Agregaremos la funcionalidad para calcular el área de un círculo, utilizando
Class Diagra m.
16. En Solution Explorer seleccione el nodo principal del proyecto Areas, y en
el menú de contexto seleccione Vi ew Class Diagr am.
a. Aparecerá el diagrama de la clase contenida en el proyecto. Tome en
cuenta que pueden aparecer más elementos definidos por Visual
Studio.
b. Dentro del espacio de trabajo, seleccione la clase Areas, y arrástrela a
un espacio menos congestionado del área de trabajo, de tal manera
que se pueda extender y contraer sin obstrucciones.
Alfaomega 209
SYNAPS PREMIUM
Expander 1 Contraer
( Areas
ll Class
)1
17. Haga die en el botón Expander 1 Contraer, para que vea cómo aparecen y se
ocultan los miembros de la clase.
18. En la parte superior de la clase, invoque el menú de contexto y seleccione
Class Details, que permitirá ver de manera detallada los miembros de la
clase.
..
\1
N..,.
•
"V
;1
• 0
G
lNf19Uio
~-.:Id'~•
•
..• "' .......
" . .rtin
"'"""' ......
...... •
,.
·-. ..
~ a...
.&t """'"''~
""""'
" · po:.ll.....
.... ,t.uc
Oo<~ul ......
,.,,...,
tdd fot'Ctlo """"" ""''"
19. En la extrema izquierda puede apreciarse una jerarquía compuesta por

métodos (Methods) , propiedades (Properties), campos (Fields) y eventos
(Events).
a. Como puede verse, en cada una de las jerarquías vienen los elementos
que actualmente tiene definidas la clase, junto con el datatype y el
modificador de acceso.
20. Crearemos un campo usando Class Diagram.
a. En Class Details, vaya a la sección de campos (Fields).
b. Colóquese donde dice <add field> y escriba pRadio.
c. Presione TAB para avanzar a la columna Type.
d. En la columna Type, especifique Decimal.
e. Este campo será utilizado como variable de trabajo por una propiedad
que estamos por crear.
210 Alfa omega

SYNAPS PREMIUM
21. Crearemos una propiedad usando Class Diagram.

a. En Class Details, vaya a la sección de propiedades (Properties).
b. Colóquese donde dice <add property> y escriba Radio.
c. Presione TAB para avanzar a la columna Typ e.
22. Crearemos un método usando Class Diagr am.
a. En Class Details, vaya a la sección de métodos (Fiel ds).
b. Colóquese donde dice <add method> y escriba Circulo.
c. Presione TAB para avanzar a la columna Type.
e. Extienda la jerarquía de Triangulo hasta que vea <add parameter>
.... Ci) Triangulo

() <add parameter>
f. Colóquese en <add parameter>.

g. No agregará un parámetro, pero si no lo hace, Visual Studio asume que
quiere agregar un procedimiento (Sub) y no una función (Function).
23. Cierre la ventana Class Detail y guarde su trabajo.
24. Edite el código de su clase (Class l. vb).
a. Podrá darse cuenta que la propiedad que agregó no utiliza el campo
que ha agregado.
b. En la sección GET, agregue Return pRadio
c. En la sección SET, agregue pRadio=value
d. En la función nueva, agregue lo siguiente Return
(3 . 14*{Radio"2))
25. Ha dejado la clase lista para funcionar.
Alfaomega 211
SYNAPS PREMIUM
e) Class View
26. En ocasiones no quiere modificar las clases, sino ver qué miembros tiene.
27. Para hacer esto, puede invocar la herramienta Class View, seleccionando la
opción de menú View - Other Windows - Class View, o bien, presionando
CTRL+SHIFT+C.
28. Invoque Class View, y vea cómo en la parte superior aparecen los objetos
definidos en los proyectos de la solución, y en la parte baja, los miembros que
dichas clases poseen.
29. Si hacemos doble clic en cualquiera de los elementos, Visual Studio nos
llevará a la línea de código de definición del elemento. Esto es muy útil, ya que
en muchas ocasiones, sobre todo cuando trabajamos en equipo, desearemos
ver cómo se codificó una clase a fin de entenderla de una mejor manera.
30. Cierre Class View.
DJ WBVBVS2012.09.03 - Class Diagram.wmv
d) Selector de documentos activos (Active Documents)
31. Si se presiona CTRL+TAB, aparecerá elselector de documentos activos. En

dicha herramienta se podrán seleccionar las herramientas actualmente
activas, así como los documentos.
32. Para seleccionar alguno de los elementos, puede hacer clic sobre la
herramienta o documento, utilizando las flechas de dirección, o manteniendo
la tecla CTRL presionada, y presionando repetidamente la tecla TAB hasta
que se seleccione el documento que desea.
33. Presione CTRL y mantenga presionada la tecla.
34. Ahora presione TAB en repetidas ocasiones, y compruebe cómo puede
navegar entre los diferentes recursos y herramientas disponibles.
a. Presione CTRL+TAB hasta que se posicione en el diagrama de clase
(ClassDiagraml . cd).
b. Seleccione la clase Areas, e invoque C/ass Details.
212 Alfa omega

SYNAPS PREMIUM
e) Agregando resumen a los miembros
35. Modifique la información de Summary para todos los elementos de la clase.

Miembro Summary
Rectang ulo Muestra el área de un rectángulo
Tr1angulo Muestra el área de un triángulo rectángulo
circulo Muestra el área de un círculo.
Altura Valor de medida de la altura
Base Valor de medida de la base
Rad10 Valor de medida del radio
pAltura Variable de pasopara altura
pBase Variable de paso para base
pRadlO Variable de paso para radio
36. Revise el código resultante, que deberá haber quedado como sigue.
1 Public Class Areas
o o o
2 <summary>
3 o o o Variable de paso para base
4 o o o </summary>
S Private pBase As Decimal

6
o o o
7 <summary>
8 ooo Valor de medida de la base
9 ooo </summary>
19 Public Property Base() As Decimal

11 Get
12 Return pBase
13 End Get
15 pBase = value
16 End Set
17 End Property
18
o o o
19 <summary>
29 o o o Variable de paso para altura
21 o o o </summary>
22 Private pAltura As Decimal

23
24 o o o <summary>
25 o o o Valor de mediida de la altura
26 o o o </summary>
27 Public Property Altura() As Decimal

28 Get
29 Return pAltura
39 End Get
Alfaomega 213
SYNAPS PREMIUM

32 pAltura = value
33 End Set
34 End Property
35
36 ••• <summary>
37 ' ' ' Muestra el área de un rectángulo
38 ' ' ' </summary>
39 Function Rectangulo() As Decimal
40 Return (Base * Altura)
41 End Function
42
43 ••• <summary>
44 '''Muestra el área de un tri{angulo
45 ''' </summary>
46 Function Triangulo() As Decimal
47 Return ({Base * Altura) 1 2)
48 End Function
49
se '' . <summary>
51 ' ' ' Variable de paso para radio
52 ' ' ' </summary>
53 Private pRadio As Decimal
54
55 ' .. <summary>
56 ' ' ' Valor de mediida del radio
57 ''' </summary>
58 Public Property Radio As Decimal
59 Get
60 Return pRadio
61 End Get
62 Set (value As Decimal )
63 pRadio = value
64 End Set
65 End Property
66
67 ''' <summary>
68 '''Muestra el área de un círculo
69 ''' </summary>
70 Public Function Circulo() As Decimal
71 Return {3 .14 * (Radio A 2))
72 End Function
73 End Class
37. Guarde los cambios en su solución.
214 Alfa omega

SYNAPS PREMIUM
f) Consumiendo la clase

Windows- Console Application.
40. Asigne como nombre DemoAreas.
42. Seleccione el nodo principal del proyecto.
43. Invoque el menú de contexto, y seleccione Add Reference.
44. Seleccione Projects - Areas, y presione Ok.
45. Edite el código, que debe quedar de la siguiente manera:
1 Imports Areas
2
3 Module Modulel
4
5 Sub Main()
6 Dim x As New Areas. Areas
7 Console .Write( ''Radio:'' )
8 x.Radio = Console .Readline()
9 Console .Writeline(x.Circulo())
19 Console . Wri teline( "Presione Intro" )
12
13 End Sub
14
15 End Module
46. En la línea 1 se importa la librería Areas.
47. En la línea 6 se instancia la clase Areas que se encuentra en la librería Areas.
48. En la línea 8 asignamos el valor capturado a la propiedad Radio del objeto

instanciado.
49. En la línea 9 ejecutamos el método Circulo() del objeto instanciado, que nos
muestra el área del círculo.
so. Depure el programa, proporcionando un valor de 20 como radio. Si todo
sucede correctamente, este será el resultado:
Alfaomega 215
SYNAPS PREMIUM
FIN DEL EJERCICIO *

~ lab.09.02: Haciendo un programa class-based
En este ejercicio se generará una clase para ser consumida por diferentes
programas. Tendrá además que decidir qué pasa a ser método y qué pasa a ser
propiedad.
Retome el ejercicio 08.06, del capítulo anterior, se generó un programa llamado
Seguridad, que permitía generar, a partir de un dato textual, su correspondiente
hash code a 64 bits, y además, un procedimiento que se encargaba de
proporcionar un detalle de dicho código, con la finalidad de que los dígitos no se
pudieran confundir con las letras.
Los procedimientos utilizados, en esencia, son algo más o menos así (aunque
pudo haber implementado algo diferente).
Para crear el hash code codificamos algo así:

1 Function CreaHash( ByVal TextoBase As String) As String
2
3 Dim UE As New UnicodeEncoding
4 Dim Hash As Byte ()
5
6 'Almacena la cadena ingresada en una matriz de bytes
7 Dim bCadena() As Byte = UE.GetBytes(TextoBase)
8 Dim ServicioSHAl As New SHAlCryptoServiceProvider
9
216 Alfa omega

SYNAPS PREMIUM
10 'Crea el hash
11 Hash = ServicioSHA1.ComputeHash(bCadena)
12
13 ' Retorna como una cadena codificada en base64
14 Dim CodigoHash As String
15 CodigoHash = Convert .ToBase64String(Hash)
16
17 Return CodigoHash
18
19 End Function
Para crear el detalle sin ambigüedades, codificamos algo así:

1 Function DetalleHash( ByVal TextoBase As String) As String
2 Dim Resultado As String
3 Dim Letra As String
4 Dim i As Integer
S
6 Resultado - ""
7
8 For i = 1 To Len(TextoBase)
9 letra = Mid(TextoBase, i, 1)
10 Select Case Letra
11 Case "2"
12 Letra - "nueve"
13 Case "111
14 letra - "uno"
15 Case "2"
16 Letra - "dos"
17 Case "3"
18 Letra - "tres"
19 Case "4"
20 Letra - "cuatro"
21 Case "Sil
22 Letra - "cinco"
23 Case 11611
24 Letra - "seis"
25 Case "7"
26 Letra - "siete"
27 Case "8"
28 letra - "ocho"
29 Case "9"
30 letra - "nueve"
31 End Select
32 Resultado += Letra
33
.
If 1 < Len(TextoBase) Then
34 Resultado += . - ..
35 End If
Alfaomega 217
SYNAPS PREMIUM
36 Next
37
38 Return Resultado
39 End Function
1. Agregue a la solución Ejercicios un proyecto de tipo Class Library llamado

Has hing, en donde incluya como métodos las dos funciones anteriores.
a. Modifique las funciones, pues no deben recibir argumentos.
2. Determine qué propiedades necesita, e impleméntelas.
a. Recuerde: no puede utilizar variables externas a la clase.
3. Genere una nueva versión del programa Seguri dad, llamado Seguridad2,
que deberá hacer exactamente lo mismo, pero utilizando la clase Hashing,
que acaba de crear.
FIN DEL EJERCICIO *
218 Alfa omega

SYNAPS PREMIUM
Unidad de aprendizaje 1 O
Herencia y Polimorfismo de Clases
Competencias:
1. Aprenderá los términos
fundamentales necesarios para
entender la herencia y el
polimorfismo entre clases.
2. Aprenderá las formas de herencia
entre clases, y la manera de
establecer relaciones jerárquicas
entre clases.
3. Aprenderá el uso de modificadores
que permiten que los miembros
de una clase base puedan ser
modificados dentro de una clase
derivada.
Evaluacl6n:
l. Proporcionar un caso
en el cual se utilice
herencia y Evidencia de
polimorfismo de aprendizaje:
clases. 1. Capacidad de analizar una
2. Proporcionar un caso situación en la cual la herencia y el
en el cual se polimorfismo pueden aportar a la
desarrolle una clase eficiencia del programa.
que provea servicios a 2. Capacidad de implementar clases
con herencia y polimorfismo.
otros programas, en
3. Capacidad de consumir clases con
donde se haga uso de herencia y polimorfismo desde
herencia. otros programas.
SYNAPS PREMIUM
10 Herencia y Polimorfismo de clases

10.1 Herencia y Polimorfismo ...................................................................................................................... 221
10.1.1 Herencia ............................................................................................................................................... 221
10.1.2 ¿Cuándo se debe utilizar la herencia? ..................................................................................... 221
10.1.3 Overloading, Overriding, y Shadowing ................................................................................... 222
10.1.3.1 Overloaded .................................................................................................................................. 222
10.1.3.2 Overriden ..................................................................................................................................... 222
10.1.3.3 Shadowed .................................................................................................................................... 223
10.1.4 For·m as de herencia ........................................................................................................................ 223
10.1.4.1 Inherits {Heredar) .................................................................................................................... 223
10.1.4.2 Notlnheritable (No Heredable) ............................................................................................ 223
10.1.4.3 Mustlnherit (Debe Heredar) ................................................................................................. 224
10.2 Polimorfismo ............................................................................................................................................ 224
10.2.1 Estatutos auxiliares de polimorfismo ..................................................................................... 225
10.2.1.1 NotOverridable (No Remplazable} ..................................................................................... 226
10.2.1.2 Overridable (Remplazable) ................................................................................................... 226
10.2.1.3 MustOverride (Debe Remplazarse) .................................................................................... 226
10.2.1.4 o·verrides (Remplaza) ............................................................................................................. 227
10.2.1.5 Overloads (Sobrecarga/Sustituye) ..................................................................................... 227
10.2.2 My Base y MyClass ...........................................................................................................................227
~ Lab.lO.Ol: Herencia ent·re clases ........................................................................................................... 228
~ Lab.10.02: Polimorfismo basado en herencia................................................................................... 230
a) Clase base ............................................................................................................................................... 232
b) Clase derivada con remplazamiento ............................................................................................. 233
e) Clase derivada con sustitución ......................................................................................................... 236
~ Lab.10.03: lteradores ................................................................................................................................. 239
~ Lab.10.04: Implementación de herencia y polimorfismo ............................................................ 243
220 Alfa omega

SYNAPS PREMIUM
Unidad 10: Herencia y Polimorfismo de Clases
10.1 Herencia y Polimorfismo
10.1.1 Herencia
La herencia (inheritance) es un concepto fundamental de la programación orientada a obje-

tos, y consiste en la habilidad de definir clases que sirven como base de otras clases, evitan-
do la redundancia en la definición de elementos tales como métodos, eventos, y propieda-
des.
Tenemos una clase base y una o varias clases derivadas; las clases derivadas aprovechan
todo lo declarado en la clase base, asumiéndolo como suyo y utilizando capacidades que no
están codificadas en ellas.
Las clases derivadas pueden heredar, e incluso extender, las propiedades, métodos y even-
tos de la clase base. Es posible también que las clases derivadas sustituyan o modifiquen
(OverridingjShadowing) la funcionalidad de los métodos de la clase base.
En Visual Basic, por omisión todas las clases pueden heredarse.
Las ventajas de la herencia son muchas, pero la principal es que el desarrollador sólo tendrá
que escribir y depurar el código una vez, para una clase; no obstante a ello, podrá disponer
en muchas clases la misma funcionalidad, estableciendo las referencias adecuadas.
10.1.2 ¿Cuándo se debe utilizar la herencia?
La herencia entre clases no debe utilizarse por el simple hecho de que el lenguaje lo permi-
te. La herencia debe planearse; el desarrollador debe pensar cómo han de ser las clases,
organizándolas en lo que se conoce como jerarquía de clases.
Se recomienda una jerarquía de clases cuando entre las clases se presenta una relación de
tipo Es-un (is-a); debe evitarse el uso de herencia cuando se trata de relaciones Tiene-un
(has-a).
Una clase que contiene las características de todos los automóviles en general (Automóvi-
les), tiene mucho que compartirle a una clase que almacena las particularidades de aque-
llos automóviles considerados como automóviles deportivos (AutomóvilesDeportivos ).
Un automóvil deportivo, antes de ser deportivo, es un automóvil (is-a), por lo tanto, al pro-
gramar sería pertinente desarrollar una jerarquía de clases.
Ahora pregúntese, ¿qué comparte un dueño de un automóvil y un automóvil? Automóviles
y DueñosAutomóviles no comparten rasgos, ni siquiera similares. Las personas que po-
seen automóviles no se derivan de los automóviles, ni viceversa. Que una persona tenga un
(has-a) automóvil, no quiere decir que comparta con otros dueños de automóviles la mayo-
Alfaomega 221
SYNAPS PREMIUM
ría de sus características. En programación, establecer una jerarquía de clases entre estos
dos conceptos no tendría ningún sentido.
Se recomienda una jerarquía de clases, obviamente, sólo si el código de una clase brinda
alguna funcionalidad que se pueda reutilizar en otra más específica; tratar de heredar as-
pectos muy particulares que sólo aplican para una clase y no para otras no tiene sentido.
10.1.3 Overloading, Overriding, y Shadowing
Para implementar el polimorfismo, hay que conocer tres conceptos básicos: Overloading,
Overrídíng, y Shadowing. Al explicar el polimorfismo, concluimos que un mismo nombre de
método puede tener funcionalidad distinta dependiendo de los argumentos que le son pro-
porcionados.
Como sabe, los argumentos de cualquier función van entre paréntesis y separados por co-
mas, después del nombre del método o función; por tratarse de una lista de valores, esta-
mos ante la presencia de una serie de valores.
10.1.3.1 Overloaded
Los miembros con característica Overloaded son utilizados para proporcionar diferentes
versiones de una propiedad o método que tiene el mismo nombre, pero que acepta diferen-
te número de argumentos, o argumentos de diferente tipo de dato.
10.1.3.2 Overriden
Las clases derivadas heredan la funcionalidad de las clases base. En ese sentido, se espera
que una propiedad o método heredados de la clase base, tengan la misma funcionalidad,
tanto en la clase base como en la clase derivada.
Por la razón que sea, a veces una clase derivada no desea tener el mismo comportamiento
que la clase base. En otras palabras, desea sustituir la propiedad o el método con su propia
versión.
Las propiedades y métodos con característica Overriden permiten sustituir elementos here-
dados de la clase base, con aquellos que la clase derivada realmente necesita.
La única restricción que se tiene es que los miembros Overriden deben aceptar el mismo
número de argumentos y retornar los mismos valores, respetando los tipos de datos de la
clase base, a efecto de que el encapsulamiento de los objetos sea posible.
222 Alfa omega

SYNAPS PREMIUM
10.1.3.3 Shadowed
Los miembros con característica Shadowed son aquellos que remplazan localmente a otros
miembros existentes, dentro de un alcance diferente al original.
En esencia, es una forma de remplazar funcionalidad, pero más drástica que Overriden, pues
mientras que en Overriden se debe respetar el signature, en Shadowed no.
10.1.4 Formas de herencia
10.1.4.1 lnherits (Heredar)
El estatuto Inherits se utiliza para especificar que una clase de nueva creación tiene como
base una clase ya existente. La clase nueva es la clase derivada (derived class); la clase ya
existente es la clase base (base c/ass).
Class NombreC/aseDerivada
Inheri ts NombreC/aseBase
• • •
End Class
En este caso, la clase derivada dispone de todos los elementos declarados en la clase base.
10.1.4.2 Notlnheritable (No Heredable)
Por omisión todas las clases en Visual Basic pueden heredarse. Existirán ocasiones en que
no queramos que una clase pueda heredarse. En ese caso, hay que especificar, al declarar
una clase, que ésta no es heredable.
Notinheri table Class NombreC/ase
• • •
End Class
En este caso, intentar heredar NombreC/ase generaría error (Inherits NombreClase).
Alfaomega 223
SYNAPS PREMIUM
10.1.4.3 Mustlnherit (Debe Heredar)
Ya explicábamos que no se puede tener acceso a la funcionalidad de una clase, sino a través
de una instancia de la misma, es decir, de un objeto basado en la clase. Eso es verdadero
sólo relativamente.
¿Habrá alguna forma de que podamos disponer de la funcionalidad de una clase, sin generar
una instancia de la misma?
La respuesta es que sí. Podemos declarar una clase que no pueda instanciarse, y que pueda
ser utilizada sólo si se hereda por otra clase. Para hacer eso es necesario especificar el esta-
tuto Musti nheri t .
Mu sti nheri t Class NombreClase
•••
End Cl ass
En este caso, instanciar NombreClase generaría error (Dim Objeto As New NombreCla -
se() )
10.2 Polimorfismo
El polimorfismo es la habilidad que tiene el lenguaje para definir múltiples clases que con-
tengan métodos y propiedades del mismo nombre, pero que brindan diferente funcionali-
dad.
Cuando se presenta el polimorfismo es posible elegir, en tiempo de ejecución, aquellos mé-
todos o propiedades que necesitamos. No importa que varias clases posean los mismos mé-
todos y las mismas propiedades: la aplicación debe ser capaz de utilizar precisamente aque-
llas cuya funcionalidad estamos invocando.
Cuando se declara una clase y a partir de ésta se derivan otras clases, estamos ante la pre-
sencia de la herencia; si además de esto, los métodos y propiedades de la clase base que
fueron heredados son modificados (Overriden) o sustituidos (Overloaded) en la clase deri-
vada, de tal manera que comparten el mismo nombre pero no la misma funcionalidad, es-
tamos ante el polimorfismo. Para que haya polimorfismo, antes debe haber herencia.
Cuando en una clase derivada se modifican métodos o propiedades de la clase base, se dice
que hay polimorfismo basado en herencia.
224 Alfa omega

SYNAPS PREMIUM
10.2.1 Estatutos auxiliares de polimorfismo
En ocasiones heredamos una clase, pero nos damos cuenta que algunas entidades (méto-
dos, propiedades, eventos) no se ajustan del todo a lo que verdaderamente necesitamos; en
resumen, no nos sirven tal y como fueron heredadas. Es posible que pensemos que los ele-
mentos heredados son útiles, pero lo son más si podemos hacer unas pequeñas modifica-
ciones.
Dichas modificaciones se realizan en la clase derivada, respecto a las definiciones originales
existentes en la clase base.
La programación orientada a objetos hace posible que eso suceda, pues permite implemen-
tar diferentes comportamientos para un método (override), o de plano remplazado por
completo (overload). La funcionalidad heredada puede modificarse por otra que sea más
indicada para el problema de programación que deseamos resolver; con ello se promueve
que la reutilización del código sea flexible y adaptable.
Por omisión, una clase derivada hereda los métodos y propiedades de su clase base. Si ne-
cesitamos que una propiedad o método heredado se comporte de manera distinta a como
se definió en la clase base, puede ser implementada de forma distinta (overridden) o rem-
plazada (overloaded); esto quiere decir que la herencia sirve hasta donde nosotros desea-
mos comenzar a hacer modificaciones.
Los estatutos auxiliares de polimorfismo sirven para especificar el grado de modificación que
ha de darse entre la clase derivada y la clase base; estos son:
1. Overridable
2. NotOverridable
3. Overrides
4. MustOverride
5. Overloads
Clase Base
NotOverridable Clase Derivada
1
Overridable
1 Overrides ]
Must Override
1 1 Overload
Alfaomega 225
SYNAPS PREMIUM
La interpretación es la siguiente:
l. Los estatutos auxiliares aplican para los miembros que pueden ser modificados en su
implementación, como por ejemplo, los métodos.
2. Los estatutos NotOverridable, Overridable y MustOverride sólo se especifican en
la clase base, e indican si el miembro acepta o no modificaciones.
3. Los estatutos Overrides y Over load sólo se especifican en la clase derivada, e indican
su la modificación es un remplazo o una sustitución.
4. En el caso de que en la clase base y en la clase derivada haya un miembro con el mismo
nombre, el miembro en la clase base deberá ser especificado como Overridable o
MustOverride, y en la clase derivada deberá ser especificado como Overrides u
Over load. Las especificaciones van por pares.
¡gl WBVBVS2012.10.01- Estatutos auxiliares de herencia y polimorfismo.wmv

10.2.1.1 NotOverridab/e (No Remplazable)
El primer escenario es que la clase base no acepte que su funcionalidad sea modificada o
sustituida. En ese caso, el estatuto NotOverridable previene que una propiedad o méto-
do de una clase base pueda ser sustituido en una clase derivada.
Por omisión, los métodos públicos en una clase base son NotOverridable.
10.2.1.2 Overridab/e (Remplazable)
El segundo escenario es que la clase base admita modificaciones o sustituciones a su fun-

cionalidad. El estatuto Overridable establece que una propiedad o método (elemento) de
una clase base puede ser modificado en su implementación o sustituido en una clase deri-
vada.
10.2.1.3 MustOverride (Debe Remplazarse)
El tercer escenario es que la modificación a la funcionalidad de la clase base no sólo sea

posible, sino que sea obligatoria. El estatuto MustOverride hace que sea obligatorio hacer
variaciones en la clase derivada, de las propiedades o método de la clase base, que han sido
heredados.
Del lado de la clase derivada hay dos escenarios, que sólo son posibles si los elementos de
la clase base permiten modificaciones en la funcionalidad.
226 Alfa omega

SYNAPS PREMIUM
10.2.1.4 Overrides (Remplaza)
El primer escenario de modificación es cuando la clase base permite que su funcionalidad

sea modificada, respetando la estructura original del elemento modificado (signature). El
estatuto Overrides permite la variación en la clase derivada, de sus propiedades o sus
métodos. Esto será siempre y cuando se mantengan los mismos argumentos en el método
de la clase base y de la clase derivada. Ove rr ides sólo permite desarrollar en la clase de-
rivada una implementación distinta de un elemento de la clase base, y no su sustitución
por otro que no guarde semejanza.
10.2.1.5 Overloads (Sobrecarga/Sustituy e)
El segundo escenario es que se desee sustituir la funcionalidad, sin necesidad de respetar

estructuras o condiciones precedentes.
En ocasiones además de modificar el comportamiento de los métodos que participan en
una relación de herencia, es necesario hacer uso de diferentes argumentos, ya sea porque
los que se tienen deben considerar otros tipos de datos, o bien, que el método que modifica
al heredado de la clase base requiere una cantidad distinta de argumentos. En este caso, ya
no hablamos de una implementación distinta de lo mismo, sino de dos métodos bastante
distintos entre sí, que comparten un nombre.
En este último caso, Overrides no sirve, pues exige igualdad de argumentos. Para poder
lograr nuestro cometido, debemos utilizar Over loads, que indica la sustitución del méto-
do de la clase base por otro de la clase derivada, tengan o no relación entre sí. A través de
Overloads es la única forma de implementar, bajo un mismo nombre, dos métodos que no
coinciden más que en el nombre.
10.2.2 MyBase y MyCiass

Al implementar polimorfismo enfrentamos un fenómeno muy básico: terminamos con dos
versiones de un mismo miembro: uno en la clase base, y uno en la clase derivada.
Con My Base podemos obligar a la aplicación a que utilice la versión del miembro que se
encuentra en la clase base y no de la clase derivada; utilizamos la palabra reservada
MyClass, cuando queremos llamar a ejecución un método que se encuentra en la clase de-
rivada.
Es importante saber que tanto MyBas e como MyCl ass, aunque en su manejo parecen un
objeto, realmente no lo son. No se instancian; existen porque el lenguaje los proporciona
para referir miembros que pueden tener ambigüedad.
El uso de MyBase y MyClass, por simple lógica, sólo puede presentarse en las clases deri-
vadas.
Alfaomega 227
SYNAPS PREMIUM
~ lab.lO.Ol: Herencia entre clases

En este ejercicio se generará una clase base y una clase derivada; se comprobará
la herencia entre ellas.
Se definirán dos clases y una se establecerá como clase base de la otra; la clase
base tendrá un método y la clase derivada otro. Se elaborará un programa desde
el cual se generará un objeto que será una instancia de la clase derivada.
Utilizando ese objeto, se ejecutará un método de la clase base, comprobándose
que, aún y cuando el método no está codificado en la clase que se instanció, de
todas maneras está disponible gracias a la herencia existente entre las clases.
3. Asigne como nombre Herencia.
4. Vea cómo en Solution Explorer sólo aparece un programa (Modulel . vb).
6. Seleccione el nodo principal del proyecto, invoque el menú de contexto y
seleccione View Class Diagram, con lo que aparecerá Class Diagram.
a. Dentro del espacio de trabajo aparecen algunos elementos que utiliza
Visual Studio.
b. Como nosotros no haremos nada con ellos, los seleccionamos,
invocamos el menú de contexto y seleccionamos Remove from
diagram.
c. Esto no implica que Jos archivos se eliminen físicamente. Sólo significa
que no queremos verlos.
d. Class Diagram se queda vacío.
7. En Class Diagram, coloque el puntero del ratón en cualquier parte del área
de trabajo, invoque el menú de contexto y seleccione Add - Class.
a. Aparecerá la ventana New Class.
b. En Class Name asigne el nombre MiClaseBase.
c. El acceso será Public, y debe estar seleccionado Create n ew file.
d. Presione Ok.
e. En Solution Explorer se deberá haber agregado al proyecto el código
MiClaseBase. vb.
228 Alfa omega

SYNAPS PREMIUM
8. Aparecerá la nueva clase en Class Diagram .
de trabajo que no esté ocupada, invoque el menú de contexto y seleccione
Add- Class.
b. En Class Na me asigne el nombre MiClaseDeri vada.
c. El acceso será Public, y debe estar seleccionado Create new file.
d. Presione Ok.
MiClaseDer i va da. vb, y en Class Diagram debe tener las dos clases
que ha creado.
10. Seleccione MiClaseDeri vada en Class Diagram, invoque el menú de contexto y seleccione
View Code.
a. Con ello aparecerá Code Editor, permitiendo la edición de la clase.
b. Dentro de la clase, agregue la siguiente línea:
Inherits MiCl aseBase
c. Regrese a Class Diagram.

11. Como puede ver, ya es visible en Class Diagram la relación entre las clases. A partir de este
momento, los elementos compartidos de MiClaseBase estarán disponibles cuando se genere
una instancia de MiClaseDeri vada.
12. Seleccione MiClaseBase, invoque el menú de contexto y seleccione Add - Method.
a. Especifique por nombre Mensajel
13. Seleccione MiClaseDerivada, invoque el menú de contexto y seleccione Add- Method.
a. Especifique por nombre Mens aje2
14. Haga doble die sobre el método Mensajel de MiClaseBase, para editar su código. Agregue
el siguiente código:
Consol e.Wri t e l ine ("Des de base"
15. Vuelva a Class Diagram, haga doble die sobre el método Mensaje2 de MiClaseDer i va da,
para editar su código. Agregue el siguiente código:
Console. Writeline " Desde derivada"
16. Ahora procesa a editar el programa Modulel. vb del proyecto. Dentro de la clase, codifique lo
siguiente:
Alfaomega 229
SYNAPS PREMIUM
Dim x As New MiClaseDerivada

x.Mensajel ()
Console.Writeline("Presion e Intro")
e~
Console. Readlin"" 0'---------
17. Lo que hace este código es generar una instancia de la clase derivada, para posteriormente
ejecutar el método Mensaje!(}.
a. Como puede darse cuenta, en MiClaseDerivada no hay ningún método codificado
con ese nombre.
b. Al haber establecido la relación entre clases, MiClaseDerivada puede utilizar los
métodos compartidos de MiClaseBase, por lo cual no detecta errores.
18. Depure el programa (FS), y si todo está correcto, aparecerá lo siguiente:
FIN DEL EJERCICIOI*
~ lab.10.02: Polimorfismo basado en herencia

En este ejercicio se comprobará el polimorfismo basado en herencia; para ello se
definirán varias clases, se heredarán unas con otras, y se verá el uso de la palabra
reservada MyBa se dentro de una clase derivada.
El programa pretende calcular una cantidad que hay que pagarle a unos
trabajadores. Generalmente, el pago se les otorga multiplicando las horas que
trabajaron por la tarifa que se paga por hora; considérese que los empleados
230 Alfa omega

SYNAPS PREMIUM
pueden trabajar diferente número de horas -de 15 a 40 por semana- , y puede

pagárseles la hora a diferentes tarifas - de $150.00 a $235.00-.
Independientemente de las horas trabajadas y la tarifa, hay variantes para el
pago: a los empleados que todos los días llegan a tiempo se les proporciona un
25% de pago adicional, como bono de puntualidad; otra variante es que, si la
persona fue seleccionada como el empleado del mes, se le pagan las horas a una
tarifa fija, muy superior a la tarifa normal -$400.00-.
El reto es que todos los cálculos se hagan a través de métodos de clase, que todos
los métodos deben llamarse igual, y que se defina una jerarquía de clases.
3. Asigne como nombre Nomina.
4. Vea cómo en Solution Explorer sólo aparece un programa (Module l. vb).
S. Establezca este nuevo proyecto como proyecto de arranque.
6. Edite el código hasta que quede de la siguiente manera.
1 Module Modulel
2 Public HT As Decimal
3 Public TH As Decimal
4
S Sub Main()
6 Console .Write( ''Horas trabajadas (#):'' )
7 HT = CDec (Console .ReadLine())
8 Console .Write( ''Tarifa por hora ($):'' )
9 TH = CDec (Console .Readline())
10
11 ' Calculo y resultado aquí
12
13 ' Esperando una tecla
14 Console .Write( "Presione Intro" )
15 Console .Read()
16 End Sub
17
18 End Module
7. El código hace lo siguiente:
a. En las líneas 2 y 3 se definen variables de trabajo. Al tener el
modificador Public, estarán disponibles para todos los programas del
proyecto.
Alfaomega 231
SYNAPS PREMIUM
b. De la línea 6 a la 9, recopilamos los datos para realizar pruebas de

cálculo.
c. Dado que las clases que programaremos esperan datos de tipo
Decimal, hacemos la transformación al momento de la captura de los
datos, usando la función CDec () (líneas 7 y 9).
8. Seleccione el nodo principal del proyecto, invoque el menú de contexto y
seleccione View Class Diagram, con lo que aparecerá Class Diagram.
a. Dentro del espacio de trabajo aparecen algunos elementos que utiliza
Visual Studio.
b. Como nosotros no haremos nada con ellos, los seleccionamos,
invocamos el menú de contexto y seleccionamos Remove from
diagram.
c. Esto no implica que los archivos se eliminen físicamente. Sólo significa
que no queremos verlos.
d. Class Diagram se queda vacío.
a) Clase base
de trabajo, invoque el menú de contexto y seleccione Add- Class.
b. En Class Name asigne el nombre Pago.
c. El acceso será Public, y debe estar seleccionado Crea te new file.
d. Presione Ok.
Pago. vb.
10. Aparecerá la nueva clase en Class Diagram.
11. Seleccione la clase Pago en Class Diagram, invoque el menú de contexto y
seleccione Class Details.
12. Agregue un método:
a. En Name asigne el valor CalculaPago.
b. En Type asigne Decimal.
c. Asegúrese que Modifier tenga asignado el valor Public.
13. Estableciendo el modificador de herencia.
232 Alfa omega

SYNAPS PREMIUM
a. Estando en el método, presione F4, para ver la ventana de

propiedades del método.
b. En Propertíes, seleccione la propiedad Inheritance Modifier, y
establezca el valor Overridable. Esto permitirá que, en caso de que
se establezca esta clase como base de otra, la clase derivada tenga la
posibilidad de modificar el método.
14. En Class Díagram seleccione el método CalculaPago de la clase Pago,
invoque el menú de contexto y seleccione Class Details.
15. Agregando parámetros a un método.
a. Expanda la jerarquía del método Calc ulaPago, hasta que aparezca
<add parameter>.
b. Agregue un parámetro cuyo Name sea Horas Tra bajadas, Type sea
Decimal, y Modifier sea ByVal, y Summary sea «Hor as t r a bajada s
en el pe riodo».
c. Agregue un parámetro cuyo Name sea Tarifa Base, Type sea
Decimal, y Modifier sea ByVal, y Summary sea «Ta r ifa base para
el cálculo~ po r hora».
16. En Class Díagram haga doble die en el método CalculaPago de la clase
Pago, a fin de que aparezca el código de la clase.
a. Como puede ver, Visual Studio reporta errores, dado que al tratarse de
una función, no se ha especificado valor de retorno.
b. Codifique en el método lo siguiente:
Return (HorasTraba j adas * TarifaBase)
_, WBVBVS2012.10.02 - Clase Base.wmv
b) Clase derivada con remplazamiento
17. En Class Díagram, coloque el puntero del ratón en cualquier parte no

ocupada del área de trabajo, invoque el menú de contexto y seleccione Add-
Class.
b. En Class Name asigne el nombre PagoBoni fica do.
c. El acceso será Public, y debe estar seleccionado Crea t e new file.
Alfaomega 233
SYNAPS PREMIUM
d. Presione Ok.
PagoBonificado. vb.
19. Seleccione la clase PagoBonificado en Class Diagram, invoque el menú de
contexto y seleccione Class Details.
a. En Name asigne el valor CalculaPago.
b. En Type asigne Decimal.
c. Asegúrese que Modifier tenga asignado el valor Public.
21. En Class Diagram haga doble die en la clase PagoBoni ficado, para editar
su código.
22. Dentro de la clase y antes de que se defina cualquier cosa, agregue la
siguiente línea, para establecer la relación de jerarquía entre las clases.
Inherits Pago~--------------~------------------------~
23. Como podrá darse cuenta, Visual Studio reporta un error, ya que se presenta
un fenómeno llamado contaminación de nombres, que se presenta cuando se
definen dentro de un mismo alcance dos elementos con el mismo nombre.
24. El método CalculaPago de la clase Pago es Overridable, es decir, acepta
modificaciones que se realicen en una clase derivada; el problema es que el
método CalculaPago de la clase PagoBoni ficado no tiene la especificación
requerida para indicar que modifica el método de la clase base.
a. En Class Diagram seleccione el método CalculaPago y presione F4
para modificar sus propiedades.
b. Busque la propiedad I nheri tance Madi fier, y especifique el valor
de Overrides.
c. Como puede comprobar, Visual Studio no permite realizar la
modificación. Esto sucede porque el método en la clase base es
Overridable, y el método en la clase derivada es Overrides; estas
especificaciones indican un remplazo (Overrides) y no una
sustitución (Overloads). Este hecho obliga a que el método en ambas
clases tenga el mismo signature, es decir, los mismos parámetros o
argumentos.
234 Alfa omega

SYNAPS PREMIUM
25. En Class Diagram seleccione el método CalculaPago de la clase

PagoBoni ficado, invoque el menú de contexto y seleccione Class Details.
26. Agregando los parámetros al método.
a. Expanda la jerarquía del método CalculaPago, hasta que aparezca
<add parameter>.
b. Agregue un parámetro cuyo Name sea HorasTrabajadas, Type sea
Decimal, y Modifier sea ByVal.
c. Agregue un parámetro cuyo Name sea TarifaBa se, Type sea
27. En Class Diagram seleccione el método CalculaPago de la clase
PagoBoni ficado.
a. Estando en el método, presione F4, para ver la ventana de
propiedades del método.
b. En Properties, seleccione la propiedad Inheritance Modifier, y
establezca el valor Overrides, que ahora sí podrá establecerse dado
que ambos métodos tienen el mismo signatu re.
c. Esto permitirá que, en caso de que se establezca esta clase como base
de otra, la clase derivada tenga la posibilidad de modificar el método.
28. En Class Diagram haga doble die en el método CalculaPago de la clase
PagoBonificado, a fin de que aparezca el código de la clase.
29. Codifique en el método lo siguiente:
Dim PagoNeto As Decimal
PagoNeto = MyBase .CalculaPago(HorasTrabajadas, TarifaBase)
PagoNeto = PagoNeto * (1 + 9.250)
Return PagoNeto._ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ .....,~
30. Vea cómo en la segunda línea se utiliza MyBase.

a. Si no se colocara, se generaría un error, dado que el método se
mandaría llamar a ejecución a sí mismo.
b. Que se incluya MyBase indica que se consumirá el método codificado
en la clase base, y no el método de la clase derivada.
c. Si estuviéramos en un método distinto a CalculaPago, podríamos
mandar llamar sin problemas cualquier versión del método, ya sea el
de la clase base (MyBase. CalculaPago) o el de la clase derivada
(MyClass . CalculaPago).
Alfaomega 235
SYNAPS PREMIUM
¡gl WBVBVS2012.10.03 - Clase Derivada Overrides.wmv
e) Clase derivada con sustitución
31. En Class Diagram, coloque el puntero del ratón en cualquier parte no

ocupada del área de trabajo, invoque el menú de contexto y seleccione Add-
Class.
b. En Class Name asigne el nombre PagoFijo.
c. El acceso será Public, y debe estar seleccionado Create new file.
d. Presione Ok.
PagoFijo.vb.
33. Seleccione la clase PagoFijo en Class Diagram, invoque el menú de contexto
y seleccione Class Details.
f. En Name asigne el valor CalculaPago.
g. En Type asigne Decimal.
h. Asegúrese que Modifier tenga asignado el valor Public.
a. Expanda la jerarquía del método CalculaPago, hasta que aparezca
<add parameter>.
b. Agregue un parámetro cuyo Name sea Hora sTrabajada s, Type sea
35. En Class Diagram haga doble die en la clase PagoFijo, para editar su
código.
36. Dentro de la clase y antes de que se defina cualquier cosa, agregue la
siguiente línea, para establecer la relación de jerarquía entre las clases.
Inherits Pago~--------------------------------------~
236 Alfa omega

SYNAPS PREMIUM
37. En Class Diagram seleccione el método CalculaPago de la clase PagoFijo y

presione F4 para modificar sus propiedades.
i. Busque la propiedad Inheri tan ce Modi fier, y trate de especificar
el valor Over loads.
J. Como puede comprobar, Visual Studio no permite realizar la
modificación. La forma de resolver este tema es codificando
directamente.
38. En Class Diagram haga doble die en el método CalculaPago de la clase
PagoFijo, para editar el código.
k. La línea que inicia la definición del método deberá ser modificada, a fin
de que sea una función (Function) que sustituye (Overloads).
l. De una vez codifique todo el método, para que quede como sigue:
Public Overloads Function CalculaPago(HorasTrabajadas As Decimal )
Return HorasTrabajadas * 400
End Function
m. Vea cómo en el caso de este procedimiento, el signature ha cambiado.
DI WBVBVS2012.10.04- Clase Derivada Overloads.wmv
39. Edite el programa Modulel. vb del proyecto, de tal manera que quede como
.
stgue:
1 Module Modulel
2 Public HT As Decimal
3 Public TH As Decimal
4
5 Sub Main()
6 Console .Write( ''Horas trabajadas (#):'' )
7 HT = CDec (Console .ReadLine())
8 Console .Write( ''Tarifa por hora ($):'' )
9 TH = CDec (Console .ReadLine())
10
11 ' Calculo y resultado aquí
12 Dim x As New Pago ()
13 Dim y As New PagoBonificado ()
14 Dim z As New PagoFijo ()
15 Console .WriteLine( ''Pago normal:'' )
16 Console . WriteLine( String. Format( "{e: C}" , x. CalculaPago(HT, TH)))
Alfaomega 237
SYNAPS PREMIUM
17 Console .WriteLine( ''Pago con bono:'' )

18 Console .Writeline(String .Format( ''{e:C}'' , y. CalculaPago(HT, TH)))
19 Console .Writeline( ''Pago tari fa fija:'' )
2e Console .Writeline(String .Format( ''{e:C}'', z.CalculaPago(HT)))
21
22 ' Esperando una tecla
23 Console .Write( ''Presione Intro'' )
24 Console .Read{)
25 End Sub
26
27 End Module
40. En términos generales:
a. De la línea 12 a la 14 se generaron instancias de las clases disponibles.
Tome en cuenta que cada una de ellas tiene su propia implementación
de CalculaPago.
b. De la línea 15 a la 20 se muestran los resultados.
c. Vea cómo cada uno de los resultados utiliza una de las
implementaciones de CalculaPago. De hecho, al momento de
codificar, Visual Studio sugiere el signa tu re adecuado para cada uno de
los métodos.
41. Guarde toda la solución, e inicie la depuración.
a. En Horas trabajadas proporcione 20.
b. En Tarifa por hora proporcione 15.
42. Si todo salió bien, el resultado será el siguiente:
238 Alfa omega

SYNAPS PREMIUM
FIN DEL EJERCICIO *
~ lab.10.03: lteradores
Aunque el propósito principal de este ejercicio es demostrar el uso y creación de
iteradores; para poder hablar de ellos primero mencionaremos un requisito: las
interfaces.
No se entienda por interfaces elementos visuales de nuestra aplicación, sino a un
especial concepto de la programación orientada a objetos. En esencia, y de forma
muy simplificada, una interfaz sería algo parecido a un prototipo de clase. Esto es
que la interfaz puede definir los métodos yjo propiedades que una clase que se
base en ella debe implementar. De principio pudiera parecer como una clase
Mustlnherit con todos sus miembros como MustOverride. Sin embargo, por
mencionar un par de ellas, una interface presentará las siguientes diferencias
contra una clase:
1. Una interfaz no implementará ninguna línea de código para los miembros es-
pecificados en ella, solamente las "firmas" de los mismos.
2. Una clase puede implementar una o más interfaces. Esto es una técnica que
bajo ciertas circunstancias, nos permite acercarnos a emular la herencia múl-
tiple (Recuerde que dicha característica no está permitida en .net).
Alfaomega 239
SYNAPS PREMIUM
Nuestro ejemplo implementará una interfaz ya definida del .net Framework

denominada /Enumerable, la cual tiene el propósito de ofrecer un mecanismo
para la iteración sobre los elementos de una secuencia.
2. Agregue a su solución un nuevo proyecto: Installed - Visual Basic -
3. Asigne como nombre Iterador.
4. Vea cómo en Solution Explorer sólo aparece un programa (Modulel. vb).
6. Edite el código hasta que quede de la siguiente manera.
1 Module Module1
2
3 Sub Main()
4 Dim Nombres As New Amigos ()
S For Each Elemento As String In Nombres
6 Console .Writeline(Elemento)
7 Next
8 Console .ReadLine()
9 End Sub
10
11 Private Class Amigos
12 Implements !Enumerable
13
14 Public Nombres = New String () { "Beshful" ' "Duc" J "Dupey" J -
15 "Grampy" , "Heppy" , "Sliipy" , "Sniizy" }
16
17 Public Iterator Function SiguienteNombre() As IEnumerator
18 Implements IEnumerable .GetEnumerator
19
20 For i As Integer = e To Nombres.Length - 1
21 Yield Nombres(i)
22 Next
23 End Function
24 End Class
25
26 End Module
7. En el explorador de soluciones, mediante el menú contextua! sobre el

proyecto, accese al elemento View Class Diagram.
240 Alfaomega
SYNAPS PREMIUM
~ View Class Diagram
8. Observe que al expandir el elemento correspondiente a Modulel, encontrará

una sección denominada Nested Types (Esto se debe a que dentro de nuestro
módulo estamos definiendo una clase que explicaremos en unos instantes). Si
expandimos ahora el elemento Amigos, obtendremos una vista cómo esta:
Modulel
Module
'-1 Methods
Gl Main
:- , Nested Types
? IEnum!fable
Amigos ~
Class
13 Fields
,_. Nombres
:J Methods
(i) Sigui!flte ...
9. Observe que la clase Amigos presenta una figura superior indicando que
dicha clase implementa la interfaz anotada a su lado, en este caso
/Enumerable. Puede cerrar ya la vista de diagrama de clases.
10. Ejecute el código, obtendrá el siguiente resultado:
Alfaomega 241
SYNAPS PREMIUM
11. Analizando el código encontramos que en la línea 4 instanciamos la clase

Amigos que será la que nos provea de los datos a trabajar en nuestro
Procedimiento MainQ.
12. En la línea S iniciamos un bloque for-each; este tipo de bloques itera sobre
un conjunto de datos desde el primero hasta el último de ellos. Basta con
indicarle cómo deseamos llamarle al elemento en turno en cada iteración del
mismo para la colección a barrer y dentro del bloque, cada vez que
accedamos a ese identificador, estaremos refiriéndonos automáticamente al
elemento actualmente "seleccionado". En este caso, le hemos indicado que
denomine "Elemento" a cada dato tipo St ring que encuentre en Nombres y le
estamos indicando en la línea 6 que despliegue en la consola el valor
correspondiente y que avance a la siguiente línea.
13. Por parte del procedimiento principal; una vez que hemos terminado de
desplegar los valores encontrados, simplemente esperamos la pulsación de la
tecla lntro para finalizar.
14. Lo más importante de este ejemplo viene a continuación, ya que en la línea 11
declaramos una clase y en la línea 12 le instruimos para que implemente la
interfaz IEnumerable que habíamos explicado al principio de este apartado.
15. Las líneas 14 y 15 definen un campo que expondrá un arreglo de tipo String
el cual contiene los valores que se estarán trabajando.
16. El título de este ejercicio, se origina de lo expresado en la línea 17. En ésta
declaramos una función con el calificador Iterator y, debido a que le hemos
indicado un identificador personalizado (SiguienteNombre ), le debemos
indicar que corresponde a la implementación del método GetEnumerator
definido en la Interfaz IEnumerator.
17. En la línea 20 puede observar un bloque For - Next, que recorre el arreglo
en el campo Nombres.
18. Especial atención merece la línea 21 con su instrucción Yield, ya que esta es
la que entrega el valor al código iterando por la colección. No pase por alto el
percibir que la estructura iteradora mantiene automáticamente el estado en
cuanto al seguimiento de cual elemento de la colección ha sido ya entregado y
cuál es el siguiente a entregar.
FIN DEL EJERCICIO *
242 Alfa omega

SYNAPS PREMIUM
~ lab.10.04: Implementación de herencia y polimorfismo

En este ejercicio implementará herencia y polimorfismo.
1. Agregue un proyecto de tipo Console Application en la solución
Ejercicios, que se llame Captura.
2. Captu ra debe solicitar tres datos: Nombre, Fecha de nacimiento, y
Sueldo.
3. El programa deberá mostrar la información capturada en el siguiente
formato, pero no podrá realizar dentro de él modificación a manipulación
alguna para lograr el formato deseado:
a. El Nombre, de tipo String, en mayúsculas.
b. La Fecha, de tipo Date, en formato short date (d, en
String. Format).
c. El Sueldo, de tipo Decimal, en formato Currency (C, en
String . Format).
4. Si todo se programa bien, el resultado será el siguiente:
S. Agregue un proyecto de tipo Class Library en la solución Ejercicios,

que se llame Soporte.
a. Incluirá sólo un método, llamado EsperaQ, que se encargará de
mostrar la leyenda «Presione INTRO», y esperar a que el usuario
haga die para continuar.
b. Además, heredará los métodos de otra clase llamada Formato.
Alfaomega 243
SYNAPS PREMIUM
6. Agregue un proyecto de tipo Class Library en la solución Ejercicios,

que se llame Formato, que no puede instanciarse -solo puede
heredarse-, y que deberá tener polimorfismo.
a. Formato tiene tres métodos, y los tres se llaman Modifica ().
b. La primer versión de Modifica(), recibe un dato String, y
retorna el String en mayúsculas.
c. La segunda versión de Modifica(), recibe un dato Date, y retorna
el String de una fecha en formato en short date.
d. La tercera versión de Modifica(), recibe un dato Decimal, y
retorna el String de un dato Decimal en formato Currency.
7. Haga que Soporte herede la funcionalidad de Formato, y que Captura
genere utilice los servicios de Soporte.
FIN DEL EJERCICIOI*
244 Alfa omega

SYNAPS PREMIUM
Interfaces de Usuario con Windows

Applications
Competencias:
1. Conocer los elementos básicos del
desarrollo de interfaces de
usuario.
2. Conocer los objetos principales
que pueden ser utilizados en las
interfaces de usuario.
3. Conocer la manera en que se
pueden aprovechar las
propiedades, métodos y eventos
de los controles, a fin de validad y
controlar el comportamiento de la
interfaz.
Evaluacl6n:
en el cual se
desarrolle una Evidencia de
Interfaz de usuario aprendizaje:
gráfica, en donde se 1. Capacidad de analizar una
acepten los datos situación real, y diseñar una
completos y interfaz que permita la interacción
correctos. efectiva entre el usuario y la
aplicación.
2. Capacidad de implementar
interfaces basadas en Windows,
con manejo de eventos y
validaciones.
SYNAPS PREMIUM
11 Interfaces de Usuario con Windows Applications

ll.llnterfaz de usuario .................................................................................................................................. 247
11.2 Controles .................................................................................................................................................... 248
11.2.1 Toolbox................................................................................................................................................ 248
11.2.2 Formas de agregar controles a una interfaz ......................................................................... 249
11.2.3 ¿Cómo aprender a usar los Controles? .................................................................................... 249
11.2.3.1 Piense en términos de clases ................................................................................................. 249
11.2.3.2 Piense en su necesidad ............................................................................................................ 249
11.2.3.3 Propósito de la clase ................................................................................................................ 250
11.2.3.4 Conozca los miembros de una clase ................................................................................... 250
11.2.4 Relación de controles ..................................................................................................................... 252
11.2.4.1 De estructura .............................................................................................................................. 252
11.2.4.2 Para introducción y especificación de datos ................................................................... 253
11.2.4.3 Para definir layout ................................................................................................................... 255
11.2.4.4 Para desencadenar acciones ................................................................................................. 257
11.2.4.5 Para manipulación de datos ................................................................................................. 258
11.3 Desarrollo de interfaces basadas en objetos ................................................................................ 258
11.3.1 Entendiendo el propósito de la interfaz ................................................................................. 258
11.3.2 Determinación de datos involucrados .................................................................................... 259
11.3.4 Determinación de objetos recomendados ............................................................................. 259
11.3.5 Validaciones ...................................................................................................................................... 261
~ Lab.11.01: Uso de ayuda msdn y .NET Framework ........................................................................ 262
a) ln9resando a MSDN ............................................................................................................................ 262
b) Buscando información de clases ..................................................................................................... 263
~ Lab.11.02: Investigando clases básicas ............................................................................................... 266
a) Labe/ .........................................................................................................................................................266
b) TextBox.................................................................................................................................................... 266
e) MaskedTextBox ..................................................................................................................................... 267
d) Button ...................................................................................................................................................... 26 7
~ Lab.11.03: Creando una interfaz con Windows Applications .....................................................267
a) Seleccionando los controles adecuados ........................................................................................ 269
b) Agregando objetos a la interfaz...................................................................................................... 269
e) Estableciendo el orden de tabulación (Tab0rder) .................................................................... 270
d} Estableciendo propiedades a los objetos...................................................................................... 270
e) Programando comportamientos .................................................................................................... 273
~ Lab.11.04: Creando su propia interfaz ................................................................................................ 276
246 Alfa omega

SYNAPS PREMIUM
Unidad 11: Interfaces de Usuario con Windows Applications
ll.llnterfaz de usuario
Una interfaz de usuario es el elemento de software a través del cual un programa determi-
nado recibe datos por parte del usuario. Cuando se compone de elementos gráficos es lla-
mada interfaz gráfica de usuario (GUI j Graphic User Interface). Microsoft .NET es increí-
blemente flexible para la creación de interfaces gráficas, en sus dos alternativas: Windows
(Windows Applications) y Web (ASP.NET Applications).
El objetivo principal de una interfaz, sea
cual sea su tipo, es recibir los datos vá-
lidos, mínimos, suficientes y necesarios, • Agrt!Ji Titnclos ---~ _ _ I!Q!j!
con fines de almacenamiento, procesa- 10 de la T10nda.
1
miento, o ejecución de acciones. Nombre de la Tienda:
Una interfaz se constituye en un único Dirección de la Tienda:
punto de contacto con el usuario: per- Q.odad:
mite la entrada y salida de datos, encar- Cotegoria
gándose de los enlaces subyacentes que Código Postal:
el usuario no tiene por qué conocer. El

usuario captura información y espera
un resultado, sin importarle la arquitec-
TooiStripSUtusubtn
tura de hardware y software que per-
miten a la aplicación producir la res-
puesta que espera.
Una buena interfaz:

1. Permite la recopilación de la cantidad precisa de datos que el programa requiere. Más
datos de los requeridos es excesivo; menos, es insuficiente.
2. Permite la recopilación de los datos, en el tipo de dato que se necesita. Si se desea captu-
rar una fecha de nacimiento, lo que se espera es un dato de tipo Date, y no un String,
un Integer, u otro.
3. Valida que los datos respeten las reglas de negocio. Si las reglas de negocio dicen que
una fecha a capturar no debe ser menor que la fecha del día del sistema, o si un número
debe estar entre un determinado rango, la interfaz debe garantizar que sólo se admitan
datos que respeten dichas reglas.
4. Proporciona la manera de corregir los errores que en la captura se cometan, y orientar
al usuario sobre la forma correcta de captura.
s. Debe ser amigable, estética y proporcionada. De preferencia, se deben respetar los con-
vencionalismos que el usuario utilice con más frecuencia; el programador no debe ante-
poner sus preferencias personales, si estas no facilitan la aceptación de la aplicación por
parte del usuario.
Alfaomega 247
SYNAPS PREMIUM
6. La interfaz de usuario debe proporcionar la información de manera organizada y estéti-

ca, de manera que el usuario que la utiliza encuentre la información en la cantidad y la
forma requerida.
11.2 Controles
11.2.1 Toolbox
Los controles son las representaciones gráficas de las clases,
disponibles en Visual Studio a través de Toolbox.
Toolbox • ~ X
Soarch Toolbox P· En esencia, los controles son la forma para llegar a las clases
~ All Windows Forms de BCL, a fin de generar instancias que se convierten en obje-
~ Common Controls
~ Containers tos de interfaz. Si desea que su interfaz sea efectiva, debe co-
~ Monus & Toolbars nocer la clase de la cual derivan los objetos que incluye en sus
~ Data
~ Compononts
aplicaciones. Conocer la clase permite tener control respecto a
~ Pnntlng la capacidad de los objetos, además de que permite seleccio-
nar los objetos adecuados para la realización de tareas especí-
~ Reporting
~ WPF lntoroporab1hly
ficas.
~ Visual Basic Pov.orPocks
~ Goneral
Los controles están disponibles en la herramienta Toolbox. El
nombre de esta ventana no podía ser más pertinente: se trata
There are no usablo controls 1n
lhiS group. Orag an rtom onto
de una caja de herramientas, y como tal, debemos: a) Conocer
thiS toxt to add tt to tho toolbo.. qué herramientas tenemos en la caja (controles); b) Saber
usar las herramientas que hay en la caja (clases), y e) Usar sólo
las herramientas que uno necesita, pues usar más de las nece-
sarias sólo nos conduce a ser más ineficientes.
Toolbox organiza los controles en grupos de controles, o Tabs,
Toolbox SorvorExploror en donde agrupa lO COntrOleS de acuerdO a la Similitud de SU
funcionalidad. Los grupos de controles pueden expandirse o
contraerse con el fin de tener presentes sólo los controles que
estamos utilizando, e incluso es posible la generación de gru-
pos de controles del usuario, colocando ahí los controles más usuales para nosotros; con
ello se mejora la operación de buscar y encontrar controles. Un excelente punto de partida
será siempre el grupo Common Controls, que contiene los controles más usados por las
aplicaciones profesionales en ambiente Windows.
Otra ventaja que tiene Toolbox es que, si desconocemos para qué sirve algún control, basta
con que coloquemos el puntero del ratón sobre el control y presionemos Fl, con lo cual
abrirá la ayuda de la clase a la cual está asociado el control. De esa manera es muy fácil ex-
plorar las capacidades de un elementos disponible para su uso en la plataforma .NET Fra-
mework.
248 Alfa omega

SYNAPS PREMIUM
11.2.2 Formas de agregar controles a una interfaz
Existen tres formas para agregar un control a una interfaz gráfica:

1. Modo inserción. Se logra haciendo doble die sobre un control en Toolbox. El objeto se
agregará dentro del espacio de trabajo, donde podrá moverse o ajustarse. En este modo
no tenemos control de la posición en la que el objeto se colocará, ni de sus dimensiones.
2. Modo arrastre. Se logra arrastrando un control desde Toolbox hasta el espacio de tra-
bajo. En este modo tenemos el control de la posición que ocupará el objeto, pero no de
sus dimensiones.
3. Modo trazo. Consiste en hacer un die sobre un control en Toolbox, y dibujar en el es-
pacio de trabajo el contorno que ha de ocupar el control. En este modo tenemos control
de la posición y las dimensiones que el objeto ha de ocupar.
11.2.3 ¿Cómo aprender a usar los Controles?
Podemos iniciar con la tarea de explicar cómo se utiliza cada uno de los controles, y dar
ejemplos de su codificación. El problema es que son muchos y tienen un uso muy diverso;
en esencia, resulta poco práctico intentar hacerlo: el documento quedaría muy a mplio, y lo
peor de todo, seguramente incompleto.
Lo mejor es explicar una técnica que permita que aprendamos cualquier control que necesi-
temos considerando nuestras propias necesidades.
11.2.3.1 Piense en términos de clases
Primero, tomemos en cuenta que en la plataforma .NET todo es un objeto, y los controles no
son la excepción. Todo control que agregamos a nuestra interfaz, realmente se traduce en
un objeto derivado de una clase, que agregamos a nuestro programa. Si usted agrega un
Textbox a su interfaz, lo que realmente está haciendo es crear un objeto basado en la clase
System.Windows . Forms. Textbox, defin ida en la librería System.Windows. Forms .dll,
dentro de la instalación física que hizo de su Microsoft .NET Framework.
Pero mantengamos las cosas simples: al agregar un control Textbox, usted agrega un obje-
to.
11.2.3.2 Piense en su necesidad
Lo primero que tiene que hacer es pensar en su necesidad, responder a la pregunta:
¿Qué funcionalidad quiero tener en mi aplicación?
Alfaomega 249
SYNAPS PREMIUM
Y una respuesta:
"Deseo capturar la opinión que los usuarios tienen de mi aplicación, para lo cual quiero que
escriban su opinión de manera obligatoria y además cómoda, cuidando que la opinión no sea
mayor a 300 caracteres, y al final, se desea que todo esté escrito en mayúsculas".
Sea específico en los datos que quiere, y en las restricciones que tendrán.
11.2.3.3 Propósito de la clase
Como sabe, los objetos son implementaciones de una clase. ¿Qué puede hacerse con el obje-
to? Sólo se puede saber conociendo qué se puede hacer con la clase.
Cada clase tiene un propósito específico, y lo mejor de todo, es que está documentado de
forma plena en la documentación de .NET Framework. Usted puede buscar en MSDN la do-
cumentación de cualquier clase contenida en .NET Framework, y puede encontrar artículos,
tanto en inglés como español, con lo que podrá despejar prácticamente cualquier duda.
Usted deberá plantearse la pregunta: ¿Hay una clase que pueda resolver mi necesidad?
Cuando lo que desea es muy específico y no es de uso general, es muy probable que deba
desarrollar sus propias clases para satisfacer su necesidad. Sin embargo, la biblioteca de
clases de .NET es tan extensa, que resulta casi imposible que no exista una clase que pueda
serie útil para aquellas necesidades de propósito general, como podría ser agregar un cua-
dro de texto, un botón o una imagen.
La pregunta que sigue es:
¿Qué clase de .NET Framework me sirve para satisfacer mi necesidad?
Y una respuesta:
"Sí hay una clase que satisface mi necesidad. Se llama System.Windows.Forms.Textbox, que
permite crear un cuadro de texto para la entrada de datos del usuario, y que está disponible
en Toolbox a través del control Textbox"
11.2.3.4 Conozca los miembros de una clase
Una vez que determina qué clase es la que satisface su necesidad, lo que debe conocer son
los miembros de la clase, que le ayudarán a especificar su apariencia y a determinar sus
capacidades de comportamiento. Los miembros de una clase son:
1. Propie da des. Características nominadas que nos permiten especificar atributos que
tienen que ver con la apariencia y las capacidades de funcionalidad de los objetos.
250 Alfa omega

SYNAPS PREMIUM
2. Eventos. Procedimientos que se ejecutarán cuando se presente una condición de in-

teracción con el objeto, ya sea por la intervención del usuario, o por la intervención
de un proceso.
3. Métodos. Acciones que es posible realizar con, o sobre el, objeto.
Las preguntas que siguen son:

¿Qué apariencia y qué comportamientos deseo para el objeto?
¿Qué propiedades, eventos y métodos me permiten la funcionalidad que deseo?
Y una respuesta:
"El cuadro de texto deberá brindar un espacio cómodo de edición, y por tanto se desea
que sea un cuadro amplio, lo que se logra con las propiedades Mul tiline, Size.
Además, el cuadro de texto tiene un máximo de caracteres de 300, lo que se puede limi-
tar a través de la propiedad Maxlenght. El contenido estará en mayúsculas si se esta-
blece la propiedad CharacterCasing a Upper. Como se debe escribir información de
manera obligatoria, puedo revisar que el contenido de la captura, que se almacena en
la propiedad Text, no sea igual a •m, al dispararse el evento Leave, que sucede cuan-
do se abandona el objeto."
Debe ser particularmente cuidadoso con las propiedades, ya que algunas serán opcionales y
otras obligatorias; también habrá algunas que no se puedan modificar en tiempo de ejecu-
ción (Read Only), mientras que otras sí; habrá algunas que tendrán valor absoluto, mientras
que otras serán colecciones, y así.
Para reducir esfuerzo en el estudio de las clases, piense que la programación basada en ob-
jetos tiene muchas ventajas, entre ellas, la herencia de funcionalidad: Generalmente los ob-
jetos derivan de una clase base y heredan rasgos y características, pasando de lo más gene-
ral a lo más particular.
Vea las siguientes clases:
System.Windows.Forms. Label
System.Windows.Forms. Textbox
System.Windows . Forms.Button
Como puede ver, comparten el mismo sufijo. ¿En términos prácticos, qué quiere decir esto?
Pues que tanto Label, como Textbox, como Button, derivan de System.Windows. Forms,
lo cual quiere decir que comparten muchas propiedades iguales, tales como BackColor,
Alfaomega 251
SYNAPS PREMIUM
Enabled, Font, Visible, etcétera. Recomendamos, por estrategia, estudiar primero Jos
miembros de una clase base (en este caso System. Windows. Forms. Control), con lo cual
habremos aprendido más del 90% de los miembros de todas las clases derivadas ( Label,
Textbox, Button, entre otras).
11.2.4 Relación de controles
A continuación se relacionan de manera general y agrupada por funcion es, los controles
más comunes para el desarrollo de aplicaciones Windows.
11.2.4.1 De estructura
Son aquellos controles que permiten definir la estructura general de los formula rios. Antes
de que cualquier control sea agregado, estos controles trazan el mapa del área de trabajo en
donde serán colocados los demás controles. Generalmente se trata en este caso de objetos
contenedores.
Función Controi/Compoente Descripción
Para contener a
Agrupa un conjunto de controles en un
otros controles,
agrupandolos .._...CJ) Panel marco sin etiqueta que permite el
desplazamiento.
Agrupa un conjunto de controles (tales

1 f:J GroupBox l como botones de radio) en un marco
con etiqueta, que no permite el
desplazamiento.
Proporciona una página con fichas para

Cl TabControl organizar y tener acceso a controles
agrupados de forma eficiente.
Proporciona dos paneles separados por

Sil SplitContainer una barra movible.
Representa un panel que dispone

.~¡ TablelayoutPanel dinámicamente su contenido en una
cuadrícula que se compone de filas y
columnas.
252 Alfa omega

SYNAPS PREMIUM
Representa un panel que dispone

FlowlayoutPanel
11
l dinámicamente su contenido en
posición horizontal o vertical.
11.2.4.2 Para introducción y especificación de datos
Son aquellos controles que permiten proporcionar datos de alguna manera. Son general-
mente aquellos a través de los cuales el usuario interactúa con la aplicación, brindándole
información que la aplicación no puede generar por sí misma.
Para editar
Permite la edición y presentación de
información E!!) TextBox información textual sin formato.
textual

~;1 RichTextBox información textual, tanto sin formato, como
en formato enriquecido (RTF1 Rich Text
Format).

(.). MaskedT extBox información textual, y permite especificar
una máscara o patrón que el texto
proporcionado debe cumplir (dígitos, letras,
signos, etcétera).
Para seleccionar
Permite mostrar una lista desplazable de
valores de una
g=
a- CheckedlistBox elementos, en donde cada uno de ellos posee
lista de valores
una casilla de verificación.
Es muy utilizado para indicar la presencia o
ausencia de características, en donde se
pueden seleccionar ninguna, una, alguna o
todas.
Permite mostrar una lista desplegable de

~ ComboBox elementos, que se expande cuando es
utilizado y se contrae cuando no es utilizado,
ideal para economizar espacio de trabajo en
la interfaz.
Permite mostrar una lista de elementos de

[]
a
DomainUpDown
l texto a través de la cual los usuarios se
pueden desplazar mediante botones hacia
arriba y hacia abajo, con lo cual se muestran
los elementos inmediatos anteriores y
osteriores del elemento actualmente
Alfaomega 253
SYNAPS PREMIUM
mostrado.
Permite mostrar una lista de texto y

~ ListBox elementos gráficos (en forma de iconos).
...•• ListView
Permite mostrar los elementos por medio de
una de cuatro vistas diferentes.
Las vistas son a) Sólo texto, b) Texto con
iconos pequeños, e) Texto con iconos
grandes y una vista d) Detalles.
Permite mostrar una lista de números a

[8 NumericUpDown través de la cual los usuarios se pueden
desplazar mediante botones hacia arriba y
hacia abajo.
Muy similar a DomainUpDown, con la
diferencia que en este control los valores
son un rango numérico.
Permite mostrar una colección jerárquica de

[ ·-·- TreeView l objetos de nodo que pueden constar de
texto con casillas o iconos opcionales.
Es el típico árbol de elementos.
Para
Permite mostrar una casilla de verificación
especificación de
valores 0 CheckBox con una etiqueta.
Se utiliza generalmente para establecer
opciones de tipo SI/NO,
AUSENTE/PRESENTE.
Permite mostrar un botón de radio, en el

0 RadioButton 1 cual se pueden seleccionar opciones
mutuamente excluyentes.
Permite que los usuarios establezcan

o- TrackBar valores mediante el desplazamiento de un
control de posición a lo largo de una escala.
Para manejo de
Permite mostrar un calendario gráfico que
fechas
~ DateTimePicker permite que los usuarios seleccionen una
1
fecha o una hora.
254 Alfa omega

SYNAPS PREMIUM
Permite mostrar un calendario gráfico que

~ MonthCalendar permite que los usuarios seleccionen un
intervalo de fechas.
11.2.4.3 Para definir layout
Son aquellos controles que no proveen datos, pero que aportan elementos gráficos para
darle estética e información de soporte al usuario. Permiten escribir mensajes, agregar
imágenes, y en general, proporcionar a la interfaz el loo k &feel qua haga sentir que nuestra
aplicación se trata de una aplicación en ambiente Windows.
Para presentar
Permite mostrar texto que los usuarios
información de
solo lectura 1
A Label
- J no pueden modificar directamente.
Permite mostrar información acerca del

1 6: StatusStri p 1 estado actual de la aplicación mediante
un área con marco, habitualmente en la
parte inferior de un formulario maestro
(que contiene a otros formularios).
Permite mostrar una barra que ilustra el

eJ ProgressBar porcentaje de avance en tiempo real de
una tarea.
Permite mostrar un icono, en el área de

1 6: Notifylcon 1 notificación de estado de la barra de
tareas, que representa una aplicación que
se ejecuta en segundo plano.
Crea barras de herramientas que pueden

lo• TooiStrip tener un aspecto y un diseño de Microsoft
Windows XP, y que admiten el
desbordamiento y la reordenación de
elementos en tiempo de ejecución.
Para manipula r
Permite mostrar archivos gráficos, tales
imágenes
1 E!l PictureBox
EL E
1 como mapas de bits e iconos, en un
' marco.
Alfaomega 255
SYNAPS PREMIUM
Actúa como un repositorio para las

.tmagenes.
'
Los controles Imagelist y las imágenes

que contienen se pueden reutilizar de una
o varias aplicaciones, pues forman un
recurso reutilizable.
Para generar Permite crear una barra de menú estilo

~
menús lE) MenuStrip 1 Windows.
Permite crear menús de contexto.

f'rl ContextMenuStrip
Para habilitar
Proporciona Ayuda emergente o en
ayuda al usua rio HelpProvider pantalla relativa a los controles.
Proporciona una ventana emergente que

Toomp muestra una breve descripción de para
qué sirve un control cuando el usuario
coloca el puntero sobre el control.
Para generar
Permite mostrar el cuadro de diálogo de
cuadros de diálogo rrj ColorDialog selección de colores, que permite que los
estándar del
usuarios seleccionen el color de un
ambiente Windows
elemento de la interfaz.
Permite mostrar un cuadro de diálogo

que permite que los usuarios establezcan
una fuente y sus atributos.

OpenFíleDialog que permite que los usuarios naveguen
hasta un archivo y lo seleccionen.

~ PrintDialog que permite que los usuarios seleccionen
una impresora y sus atributos.
256 Alfa omega

SYNAPS PREMIUM

fSJ PrintP reviewDialog
11
l que muestra cómo aparecerá un
componente PrintDocument de control
al imprimirse.

~ FolderBrowserOialog que permite que los usuarios examinen,
creen y finalmente seleccionen una
carpeta

t;:l SaveFileDialog que permite que los usuarios guarden un
archivo.
Para visualizar
Permite al usuario navegar por páginas
contenidos WebBrowser Web dentro del formulario.
especiales
Reproduce los archivos de sonido en el

formato . wav. Se pueden cargar o
SoundPiayer
l reproducirse los sonidos de forma
. ' .
asmcromca.
11.2.4.4 Para desencadenar acciones
Son aquellos controles que permiten lanzar a ejecución procedimientos de almacenamiento

o procesamiento que el aplicativo realizará tomando en cuenta los datos proporcionados en
la interfaz.
· Función Controi/Compoente Descripción
Para ejecutar
Muestra un botón que ejecuta una acción.
comandos o Wl Button
acciones
Permite mostrar texto en forma de vínculo

A l inkl abel de estilo Web y desencadena un evento
cuando el usuario hace die en el texto.
Generalmente, el texto es un vínculo a otra
ventana o a un sitio Web.
Alfaomega 257
SYNAPS PREMIUM
11.2.4.5 Para manipulación de datos
Son aquellos controles que permiten manipular datos desde fuentes de información.
- Función Controi/Compoente Descripción
Para manejo
de datos
desde fuentes
•••
i_:;
____
..................OataGridView
El control DataGridView proporciona interfaz
para mostrar y editar datos en forma de matriz
de dos dimensiones, con amplias facilidades de
personalización a nivel celdas, filas, columnas y
bordes.
Sirve como interfaz para simplificar el enlace de

los controles en un formulario con un origen de
~~ BindingSource
l datos, proporcionando administración de
monedas y divisas, notificación de cambios y
otros servicios.
Proporciona una interfaz tipo barra de

.___~a BindingNavigator herramientas para navegar y manipular los
datos en un formulario.
Los controles en este apartado no son los únicos, pero sí son los más básicos de cada cate-
,
gona.
11.3 Desarrollo de interfaces basadas en objetos
11.3.1 Entendiendo el propósito de la interfaz

Comenzamos explicando que una interfaz de usuario se manifiesta a través de un espacio
de trabajo que tiene un propósito de recopilación de datos e interacción con el usuario, que
desencadenará un procesamiento, un almacenamiento, o la ejecución de una acción. Si no
entendemos el propósito de la interfaz no podremos desarrollar una buena interfaz.
Imagine que tiene que generar una interfaz para registrar información de tiendas de un
negocio. Lo que hay que registrar es un identificador de tienda, su nombre comercial, su
dirección, la ciudad en la que se encuentra, el estado donde se encuentra, y su código postal.
La idea es que la interfaz permita introducir los datos completos y correctos, y almacenarlos
en una base de datos. También se desea que sea posible modificar los datos, o eliminarlos,
en un momento dado.
258 Alfa omega

SYNAPS PREMIUM
11.3.2 Determinación de datos involucrados
Una vez que tenemos claro el propósito de la interfaz, debemos centrarnos en hacer una
especificación de los datos involucrados; no sólo debemos conocer los datos, sino que de-
bemos hacernos una idea del tipo de dato que manejaremos, así como las validaciones que
es necesario realizar antes de determinar que la información requerida es completa y co-
rrecta.
En nuestro caso, tendríamos lo siguiente:
Dato Datatype Descripción Validaciones --
IDTienda String (4). Identificador de la • No debe omitirse.

tienda. • Sólo permite dígitos.
• Deben ser necesariamente 4 digitos.
NombreTienda String [40). Nombre comercial de • No debe omitirse.
la tienda. • Sólo permite mayúsculas.
• Sólo__¡¡_ermite letras_y_ e~acios en blanco.
DireccionTienda String (40). Dirección/Domicilio • No debe omitirse.
. de la tienda. • Sólo permite mªy_úsculas.
CiudadTienda String [20]. Ciudad en donde se • No debe omitirse.
localiza la tienda. • Sólo permite mayúsculas.
• Sólo_¡:¡_ermite letras_y_ e~cios en blanco.
EstadoTienda String [2). Estado en donde se • No debe omitirse.
localiza la tienda. • Sólo permite mayúsculas.
• Sólo permite letras.
• Deben ser necesariamente dos letras.
CodigoPostal String [5). Código postal del • No debe omitirse.
domicilio. • Sólo permite dígitos.
• Deben ser necesariamente S dígitos.
11.3.4 Determinación de objetos recomendados
Una vez que conocemos los datos involucrados, debe visualizar en su mente la interfaz idó-
nea para realizar el trabajo, y a partir de ese bosquejo mental, debe analizar qué controles
son los más adecuados para la recopilación de los datos. Tome en cuenta que algunos con-
troles, a la vista, parecen muy similares, aunque sus capacidades son diferentes (v.g. Text-
box y MaskedTextbox).
En nuestro caso, tendríamos los siguientes objetos:
Alfaomega 259
SYNAPS PREMIUM
· Form
10 de la Tll!nda
Nonbe de la llenda
Figura 11.1 Label Orecco6o •de la Toenda
Interfaz basada
en objetos.
TooiStñpStltusl.abtll
lmagelist
Tome en cuenta que su interfaz tiene como base un objeto que sirve como espacio de traba-
jo para todos los demás. Un objeto contenedor es aquél que puede contener otros objetos
dentro de sí. Los objetos contenedores son conocidos también como objetos padre (Parent),
mientras que los objetos contenidos son conocidos como objetos hijo (Child). Es posible que
un objeto contenedor esté contenido en otro objeto contenedor, por lo que podemos decir
que éstos pueden anidarse.
Tome en cuenta también que una interfaz: a) Debe tener el número mínimo, suficiente y
necesario de objetos, que le permitan cumplir con su propósito; b) Debe ser intuitiva y es-
tandarizada respecto al conocimiento entendido por los usuarios, pues una interfaz que
tiene que explicarse poco, es una buena interfaz: e) Debe tener una secuencia conveniente
respecto a la captura de datos, de tal manera que los primeros datos requeridos sirvan para
inferir otros datos.
Esta última regla tiene una excepción: en ocasiones los usuarios están muy acostumbrados
a una distribución de datos que resulta desordenada; hay que evaluar el grado de confusión
que generaría ordenar la secuencia de datos de entrada. Si la confusión generada hace que
el cambio sea contraproducente en términos de aceptación y uso de la aplicación, deberá
evitarse el orden comúnmente entendido. Esto suele suceder cuando las interfaces replican
formatos en papel, que sin tener una distribución óptima, son conocidos por todo el mundo.
260 Alfa omega

SYNAPS PREMIUM
En nuestro ejemplo, el objeto padre es un objeto de tipo Form (formulario). Siguiendo con el
análisis de nuestro ejemplo, podemos decir que tenemos lo siguiente:
Objeto Tipo Cantidad
Form Parent 1
Label Child 6
MaskedTextBox Child 6
Button Child 4
ImageList Child 1
StatusStri p Parent 1
ToolSt r ipStatu sLabel Child 1
11.3.5 Validaciones
Cuando ya se tienen lo objetos que han de utilizarse, lo único que resta es implementar las
validaciones que permitan que la interfaz reciba no sólo los datos completos, sino correctos.
Las estrategias de validación pueden ser las siguientes:
1. Validación por restricción de dominio. La forma más confiable de validar infor-
mación es utilizar controles que restringen los valores que el usuario puede propor-
cionar a la interfaz, de tal manera que en todo momento el usuario no puede hacer
otra cosa que proporcionar un dato válido. Esto es muy común con listas de opciones
y otros controles que además de tener valores de entrada restringidos, poseen un
valor por omisión (Default), que además es correcto.
2. Validación al finalizar un formulario. Generalmente, los formularios concluyen su
tarea cuando el usuario utiliza un botón que le indica a la interfaz que los datos pro-
porcionados son los que se deberán tomar en cuenta para el almacenamiento / pro-
cesamiento. En ese momento, el procedimiento que se ejecutará al haber utilizado el
botón, puede encargarse de realizar las validaciones vía programación.
3. Validación por control. Se presenta cuando las características del control trans-
forman o limitan la información que está siendo ingresada, a fin de que cumpla con
una validación. Esto se logra con la participación de propiedades y de eventos que en
tiempo real se ejecutan al momento de la introducción de datos.
Es común que las tres estrategias convivan en una interfaz para lograr el objetivo de valida-
ción de una manera correcta.
Alfaomega 261
SYNAPS PREMIUM
~ lab.ll.Ol: Uso de ayuda msdn y .NET Framework

Este laboratorio pretende que usted sea autosuficiente en relación a la búsqueda de
información de las clases que necesita para desarrollar sus propias aplicaciones.
a) Ingresando a MSDN
1. El recurso msdn de Microsoft es un referente documental en el cual puede encontrar

mucha información relacionada con los productos de desarrollo de la compañía. Para
ingresar, acuda en Internet a la siguiente liga:
http://msdn.microsoft.com/es-es/default.aspx
2. Con lo cual ingresará a la página principal de msdn.
2.1. En la parte superior, aparece un menú, y la posibilidad de seleccionar el
idioma deseado.
Figura 11.2
Elementos de msdn
msdn.
2.2. En caso de que así lo desee, cambie el idioma de los contenidos. Tome en
cuenta que en español estará más cómodo, pero que en inglés suelen
encontrarse los recursos y artículos más completos y recientes. Dado que
estamos en aprendizaje básico, la profundidad de los contenidos no hace
diferencia.
2.3. Seleccione en el menú la opción Library (Biblioteca). Los elementos de dicha
, .
pagma son:
,
2.3.1. Arbol de contenidos. Es una jerarquía de temas de
documentación, en donde se pueden ubicar los temas de nuestro
interés.
2.3.2. Búsqueda de contenidos. Es un cuadro de texto que permite
especificar una búsqueda dentro de los contenidos de msdn.
2.3.3. Expander /Contraer Árbol de Contenidos. Es un ícono que
permite contraer o extender el ancho del Árbol de Contenidos.
262 Alfaomega
SYNAPS PREMIUM
Muy práctico cuando el monitor no es muy grande y deseamos ver

con más amplitud los contenidos.
,
2.3.4. Area de contenidos. Es el área en donde se mostrarán los
contenidos de la documentación que nos interesa explorar.
Extender 1Contraer Árbol de

Contenidos
Búsqueda
de
Figura 11.3
MSDN Llbrary (en español)
Distribución de • ~ . ... 10 !'\¡.. ~Otm'~o.~l 1}6.1f>1tll· 'w'Jitl"'' f(l~ !Milo
msdn.
l•z rJll s.'\•1
on.,.rcck ~'fi'IIÓQ • MSON l.lbriJY ffl tij)il\ol llll. Wtf. r'I'OINCIOII trtl'l<lil !*) dtWI'OlfCIO~tt q¡¡• ..
"«•<'MI!IIIU. I)I'od\1~ tfO"d~M: 'J Wf'\\<IOs<lt M<!f:W'tt ,.iSON l torlty IN~'t ll~lfo'ltOI y
,.l., Área de
Het~...~ '1 'l!lf9U""' deo dewtlllk;
Otl.ar-ol~ Nll docum•Ma:ión M~~~ t.:<igo éf "..'fflFio ¡ft~ Mm~ wcrt flh'OI IMII'IOI 11111 M\tCI'I!'lll' lf CIOI'.......,t: contenidos
O.wl'cllo Ot 0'!.;• <¡utre~-.. dtsp16ceH pcr 1114tl5 de contemdct o ute l1 bil¡q~.
Wl'4r'IY\Aflll"
5Ql ~..w•
lh(IO!oOit 5b Hndn,~J'II Contenido destacado
~~~~On!U(r.cn
PI.;. h-l('f '/ lt<Mk)Oifi " 9'\i!tf'Qifll
Árbol de Onf¡ diO'II('b
~O lliH!'Ill clll' 101 MT!Ini~r.lOtll 11111 orlo di! fldll O.IM apl<MIOIIIII M Wull ~II.Ot MIO
contenidos '-'"7 ..-lk.~l¡;, liQ<otco. ~tl"4i ~ti dt li$ (.jlt~4;as n11t•~ y K!l.lal•:tóu C•tPOfiiOIH (OI'IIM 1\ffJ_,.tflllll 0t UMi'UiifiKIÓotl cltl tiClO
dr YlCU ee tn :plice:aw: (lol.t.(•en \'lsutl S111áio 2'01.0,
~0ÓM b f:III!I'"UI:JKO'I ele! CdHie Y.d.J de llllpiKio:"OOI"'tt fOfl \' .fl !·do
Apr~ acfl'~.& ele' ~ (iOflll;l,oiM 111'1 PfO'Jf(IO ~ ~flO y Q.lt l)tMII dfflt .-gult tildii!'IHI'\tlro ~ tJQ!JpC pt!~
Comt.-.::1' 1 uliiU bs htrn~m.trb$ de fQ!IIfm1!JCIOfl cW odo de wil dt 1M IPiadOIItl ~ .rd.idal tfl '111111'
$t~02010.
~CMCII!f'll!lm:>dlo~ I'VIlllll '>'!..r 11 :M Cll

~ eón» p.¡ede ~~ el .upedo y el cM'pofUrnl!f"to cltl W'IIM'O dt OeW101~ ~·
$-.Ao~o.
.,.t "\'lf.lll
.. ......,. fl'l ., ~ St-..do lP10

c~:a tr.. r~ auc:)ere·J::as y ~~s ele \ b l SZ.do 1C!1'-
b) Buscando información de clases
2.4. Seleccione Desarrollo .NET, que es el tema en el que estamos interesados.

2.5. Seleccionemos .NET Framework 4.5, dado que es la versión de .NET
Framework que estamos utilizando por trabajar con el producto en edición
2012.
2.6. Dado que queremos información de las clases, seleccionamos Biblioteca de
clases de .NET Framework.
2.6.1. Aparecerán todos los espacios de nombres del producto. Recuerde
que los espacios de nombre son una alternativa para agrupar
clases de una misma naturaleza, por lo cual resultan muy útiles
para ubicar clases que no sabemos cómo se llaman. Vamos
llegando a las clases por simple intuición.
2.7. Si conocemos el nombre de la clase que buscamos, basta con colocarla en
Búsqueda de Contenidos, y hacer clic en la lupa.
2.7.1. Escriba en Búsqueda de Contenidos, Textbox. Presione INTRO al
terminar.
Alfaomega 263
SYNAPS PREMIUM
2.7.2. Aparecerán los resultados más comunes para la búsqueda. En

primera instancia aparece la clase que nos interesa, que fácilmente
identificamos, tanto por el nombre como por la jerarquía de clases
que se muestra.
2.7.3. Hacemos clic en el tema que nos interesa, y nos aparecerá la
descripción de la clase, junto con sus miembros.
2.7.4. Preste atención a la versión de .NET Framework que se recupera.
Si no es la requiere, haga clic en Otras versiones, y seleccione la
que desea.
2.7.5. ¿Cuál es la funcionalidad de la clase Textbox?
2.7.6. Ahora busque la propiedad Maxlenght.

2.7.7. ¿Para qué sirve Maxlenght?
2.7.8. ¿Qué tipo de dato (datatype) utiliza Maxlenght?
2.7.9. ¿Qué significa el valor de Opor omisión que contiene?
la! WBVBVS2012.11.01 - Uso de ayuda msdn.wmv
264 Alfa omega

SYNAPS PREMIUM
Es fundamental que aprenda a recopilar información de las clases, ya que deberá aprender
en dos pasos:
1. Entendiendo la función de la clase. Hay que saber para qué sirve la clase, ya que
no todos los objetos sirven para lo mismo. Es cierto, puede capturar una fecha en un
TextBox, pero la cantidad de validaciones y conversiones que tendrá que realizar
después es increíble. Mejor utilice DateTimePicker, que tiene ese propósito
específico. El aprendizaje es ese: prefiera lo específico a lo genérico.
2. Entienda los miembros de la clase. Debe entender los miembros de la clase, y los
tipos de dato que soportan. Esto es básico para reducir el tiempo de depuración de
su programa. En ocasiones, las propiedades no aceptan valores básicos, sino que
requieren enumeradores (valores nominados), colecciones, e incluso clases, que
también deberá investigar.
3. Entienda los eventos de la clase. Revise cuándo suceden los eventos de la clase,
qué argumentos implícitos tienen y cómo programar en función al momento. Es muy
probable que en los eventos sea cuando aplique los métodos del objeto.
Con la información de las preguntas anteriores, podría complementar la siguiente tabla de

análisis de clase, que le sería de mucha ayuda en caso de consultas.
Nombre de la clase: Textbox
Funcionalidad: Muestra un control de cuadro de texto para la entrada de

datos de un usuario. Sirve para la introducción textual de
información en una interfaz.
Miembros relevantes
Tipo de Nombre Datatype Función
miembro
Propiedad Max l enght Int Obtiene o establece el número máximo de
caracteres que se permiten en el cuadro
de texto.
Alfaomega 265
SYNAPS PREMIUM
);;> TABLA DE ANALISIS DE CLASE. Este documento de trabajo

describe una clase y los miembros que consideramos importantes, a fin de
poder contar con una referencia personalizada de la clase. Si desea elaborar
un documento de este tipo, busque el Template WB.TABLA DE ANÁLISIS DE
CLASE.DOCX, en el CD complementario..
FIN DEL EJERCICIO *
~ Lab.11.02: Investigando clases básicas

Este laboratorio pretende que usted investigue información que será útil en general.
a) Label
3. Realice una TABLA DE ANÁLISIS DE CLASE para la clase Label, cuidando cubrir los
siguientes miembros, al menos:
Propiedades Eventos Métodos
Text
Font
Font.Bold
Font.Name
Font.Size
ForeColor
b) TextBox
1. Realice una TABLA DE ANÁLISIS DE CLASE para la clase MaskedTextBox, cuidando

cubrir los siguientes miembros, al menos:
Text TextChanged Focus()
Enabled
Maxlenght
Multiline
ScrollBars
CharacterCasing
ToolTip
Visible
266 Alfa omega

SYNAPS PREMIUM
e) MaskedTextBox
2. Realice una TABLA DE ANÁLISIS DE CLASE para la clase MaskedTextBox, cuidando

cubrir los siguientes miembros, al menos:
Text TextChanged Focus ()
Enabled
HidePromptOnleave
BeepOnError
Mas k
PasswordChar
ToolTip
Visible
d) Button
3. Realice una TABLA DE ANÁLISIS DE CLASE para la clase Button, cuidando cubrir los
siguientes miembros, al menos:
Text Click
Enabled
FIN DEL EJERCICIO*
~ lab.11.03: Creando una interfaz con Windows Applications

Este laboratorio pretende que usted utilice información que ha recopilado de las clases en
el ejercicio anterior.
Nombre del programa: lnputBasico
Caso hipotético:
Un club exclusivo de gastronomía organizó una ceremonia de maridaje de comida

mediterránea. En la salida del evento se colocaron algunas computadoras con a finalidad
de que los comensales pudieran opinar respecto a su experiencia. Las opiniones pueden
ser anónimas o no. En caso de que lo sean, los comensales colocarán su opinión, y nada
más; en caso de que no se desee opinar anónimamente, los comensales podrán
proporcionar su código secreto de membresía en el club. Dicho código está compuesto
por una letra y tres dígitos.
Alfaomega 267
SYNAPS PREMIUM
1. Se espera que haya un cuadro de texto amplio, en donde se pueda escribir una
. .,
opm10n.
2. La opinión no puede exceder de 300 caracteres.
3. La opinión debe estar en mayúsculas. Si el usuario no usa mayúsculas, el programa
deberá convertirlas.
4. A manera de ayuda, al colocar sobre el cuadro de texto el puntero del ratón, deberá
mostrarse un texto que indique la información que se espera recibir.
S. Se puede proporcionar la clave secreta de membresía en el club que consiste en
una letra y tres dígitos, a través de un cuadro de texto, pero deberá estar oculta al
escribirse.
6. Se debe tener un botón para aceptar la información. El botón de Aceptar debe estar
inhabilitado, a menos de que se compruebe que el cuadro de texto de la opinión
tiene contenido.

2. Agregue a su solución un nuevo proyecto: Jnstalled - Visual Basic - Windows -
Windows Form Application.
3. Asigne como nombre InputBasico .
S. Deberá generar una interfaz que luzca como sigue:
• . Optntón
¿Cuál es tu opinión respecto a la experiencia?
Código de miembro (Opcional): _
268 Alfa omega

SYNAPS PREMIUM
a) Seleccionando los controles adecuados

6. Dadas las características de Jos puntos de función, se requiere:
6.1. Para capturar la opinión, se requiere un cuadro de texto que permita
capacidad multi-línea, que además permita restringir el número máximo de
caracteres, y que permita transformar una entrada a mayúsculas. Dadas esas
características, elegimos un objeto basado en TextBox.
6.2. Para capturar el código de miembro, que obedece a una máscara o patrón
específico de captura, elegimos un objeto basado en MaskedTextBox.
6.3. Para lanzar la acción de aceptar los datos, elegimos el típico objeto basado en
Button.
6.4. Para especificar la ayuda que aparecerá de manera fugaz al posicionar el
puntero sobre los campos, requerimos de un objeto basado en ToolTip, que
es un objeto de trabajo, que sólo es visible en tiempo de ejecución.
6.5. Para las leyendas en general, decidimos usar objetos basados en La bel .
b) Agregando objetos a la interfaz
7. Una vez que tiene decididos qué objetos son Jos que utilizará, agréguelos a la interfaz.
8. Por el momento no se preocupe por la apariencia y el contenido, pues eso se realizará
después.
9. Agregue los objetos.
9.1. Agregue el Button.
9.2. Agregue los dos Label.
9.3. Agregue el TextBox.
9.4. Agregue el MaskedTextBox.
9.5. Agregue el ToolTi p.
9.6. Vea cómo en modo de diseño, Visual Studio agrega líneas guía que permiten
alinear adecuadamente los objetos, e incluso, manejar el espacio de un objeto
respecto a otros elementos de la interfaz.
DI WBVBVS2012.11.02- Agregando objetos.wmv
Alfaomega 269
SYNAPS PREMIUM
e) Estableciendo el orden de tabulación (TabOrder)
10. Una de las cosas más importantes de toda interfaz es la secuencia en la cual los datos
son preguntados.
11. En ambiente Windows, para ir de un objeto a otro, típicamente se utiliza la tecla
TAB.
12. El primer objeto con el cual interactuamos -objeto que adquiere el enfoque al inicio
de uso de la interfaz- es el objeto cero (0), al presionar TAB, iremos al objeto uno
(1), y así sucesivamente; al llegar al último objeto de la interfaz y presionar TAB, el
control regresa al objeto cero.
13. A este orden se le denomina Tab Order.
14. Visual Studio asigna el Tab Order en función al orden en que los objetos son
agregados. Lo recomendable es que agregue los objetos de la forma que más se le
facilite, y posteriormente modifique el Tab Order.
15. Para modificar el Tab Order:
15.1. Seleccione la opción de menú View- Tab Order .
15.2. Aparecerán indicadores de orden de tabulación, distinguiendo aquellos
objetos que pueden obtener el enfoque, y los que no.
15.3. Para cambiar el orden de tabulación de un objeto, basta posicionarse sobre el
objeto y hacer die sobre él, hasta que se coloque el orden que queremos que
tenga.
15.4. Modifique el orden de tabulación del TextBox, hasta que tenga el número O.
15.5. Modifique el orden de tabulación del MaskedTextBox, hasta que tenga el
número 1.
15.6. Modifique el orden de tabulación del Button, hasta que tenga el número 2.
DJ WBVBVS2012.11.03- TabOrder.wmv
d) Estableciendo propiedades a los objetos
16. Uno de los trabajos más finos del desarrollo de interfaces es proporcionar a los
objetos los valores a las propiedades, lo cual determinará la apariencia y las
capacidades de comportamiento.
17. Modifique las propiedades los objetos basados en Labe l , utilizando para ello
Properties Window.
270 Alfa omega

SYNAPS PREMIUM
17.1. En caso de que las modificaciones afecten la distribución de los objetos,

mueva la posición y las dimensiones de los mismos.
17.2. ~~ 1' Recomendamos ampliamente que en Properties Window especifique el

orden Alphabetical, con el fi n de que sea más fácil la localización de las
propiedades.
Objeto Propiedad Valor a asignar
Label Text ¿Cuál fue tu experiencia en este evento?:
Font > Bold True
Font > Size 12
Label Text Código secreto (Opcional):
Font > Bold True
Font > Size 12
DI WBVBVS2012.11.04 - Label Properties.wmv

17.3. Un consejo: Como puede ver, las propiedades de Font son las mismas en
ambos objetos. Visual Studio permite la modificación de propiedades en
grupo.
17.3.1. Para seleccionar un grupo de controles, mantenga presionada la
tecla CTRL.
17.3.2. Haga die sobre los objetos que desea seleccionar como grupo (de
preferencia, deben ser del mismo tipo).
17.3.3. Deje de presionar la tecla CTRL.
17.3.4. En ese caso, en Properties Windows aparecerán sólo las
propiedades que aplican para todos los objetos seleccionados.
17.3.5. Cualquier modificación que se haga en ese momento, aplicará para
todos los objetos seleccionados.
18. Modifique las propiedades del objeto TextBox. Tome en cuenta estos consejos:
18.1. Para modificar el valor de una propiedad de valor no restringido (caso de
Name, por ejemplo), hacer doble die en el nombre de la propiedad nos lleva a
seleccionar el valor actual de la propiedad, mismo que podemos modificar
sobrescribiendo.
18.1.1. El nuevo valor no se da por ingresado hasta que presione INTRO.
18.1.2. Si se mueve de propiedad sin presionar INTRO, puede perder lo
que escribió.
Alfaomega 271
SYNAPS PREMIUM
18.2. Cuando las propiedades tienen valor restringido -Visual Studio muestra un
combo con las opciones permitidas-, hacer doble die en el nombre de la
propiedad provoca el cambio de valor.
18.3. Algunas propiedades son especiales, y Visual Studio provee herramientas
intuitivas para ingresar sus valores. Tal es el caso de la propiedad ToolTip:
dado que esa propiedad se apoya del objeto ToolTip que se agregó, muestra
un cuadro de edición.
18.3.1. Escriba en dicho cuadro. Como el cuadro permite que agreguemos
salto de línea (INTRO), para dar por aceptado el dato habrá que
presionar CTRL+INTRO.
18.4. Tome en cuenta que se asigna la propiedad Name, cosa que no se hizo en los
objetos Label. Esto se debe a una regla esencial: se le da nombre a los objetos
que vayan a ser utilizados de forma programática.
1 Objeto Propiedad Valor a asignar
TextBox (Name) txtüpinion
CharacterCasing Upper
Maxlenght 300
Multline True
ScrollBars Vertical
ToolTip Capture aquí la opinión del evento.
Aparecerá todo en mayúsculas.
WBVBVS2012.11.05- TextBox Properties.wmv
19. Modifique las propiedades de MaskedTextBox.

19.1. La propiedad más importante de este control es Mask, que permite definir
una máscara o patrón, posición por posición. Algunos caracteres que pueden
ser útiles son los siguientes:
19.1.1. Caracteres necesarios: e, para dígitos; L, para literales;&, para
caracter.
19.1.2. Caracteres opcionales: 9, para dígito o espacio; #,para dígitos y
signos (+/-); ?, para literales; a y A, para alfanumérico.
19.1.3. Signos, que aparecen tal cual: - • , : 1 $
19.1.4. Casing: <,para convertir a minúsculas; >,para convertir a
mayúsculas.
19.1.5. Escape: \ convierte un caracter de máscara (e, L, A, etcétera) en
literal.
19.1.6. Todos los demás caracteres que no son máscara, aparecen tal cual.
272 Alfa omega

SYNAPS PREMIUM
19.1.7. Ejemplos: Teléfono +00 {99) 9999 - 9999;RFC? LLL-999999-

AAA.

MaskedTextBox (Name) txtCodigo
Mas k LOOO
PasswordChar *
ToolTip Código secreto de miembro. Este dato es
o cional.
WBVBVS2012.11.06- MaskedTextBox Properties.wmv
20. Modifique las propiedades de otros objetos, para complementar su interfaz.

20.1. El«&» que se antepone a la letra «A» en Button. Text, provoca la existencia
de una tecla de atajo equivalente a hacer die en el botón. En este caso, sería
CTRL+A.
20.2. La propiedad ToolTipTitle permite que el ToolTip muestre un
encabezado al texto definido en los controles que lo utilizan.
Form Text Opinión
Button Text &Aceptar
ToolTip ToolTipTitle Ayuda
¡gl WBVBVS2012.11.07- General Properties.wmv
e) Programando comportamientos
21. Una vez que los objetos tienen las propiedades correctas, es momento de
proporcionarle vida a la interfaz, mediante la programación de comportamientos.
22. Haga doble die en cualquier parte libre del formulario.
22.1. Con ello se abrirá Code Editor.
22.2. Por omisión, editará el procedimiento de evento que sea más común para el
objeto en el cual se hizo doble dic.
22.3. En nuestro caso, se procede a codificar el procedimiento de evento Load del
objeto Forml, que es nuestro formu lario. Este evento se ejecuta cuando el
formulario es cargado, y antes de que se muestre en pantalla.
22.4. Aunque el nombre del procedimiento es bastante obvio Form_Load, no es el
nombre lo que hace que dicho procedimiento de mande ejecutar. Realmente
Alfaomega 273
SYNAPS PREMIUM
el procedimiento está asociado al evento del objeto por la especificación

Ha ndles que aparece al final de la línea que declara el procedimiento.
22.4.1. Un mismo procedimiento puede manejar (Handles) los eventos de
varios objetos de la misma naturaleza, si se especifica
Objeto. Evento, separados por comas.
22.5. Codifique lo siguiente, dentro del procedimiento:
Buttonl. Enabl ed = False;....__ _ _ _ _ _ _ _ _ _ _ _~---
22.6. Este código provocará que el botón no esté disponible para su uso. Esto pudo
haberse definido manejando las propiedades del botón; quisimos hacerlo
mediante código, para que entienda que el procedimiento de evento Load es
fundamental, pues en él se pueden realizar definiciones e inicializaciones
importantes.
22.7. Ahora codifiquemos las acciones que se desencadenarán cuando se haga clic
en el botón. En otras palabras, el procedimiento de evento Clic k para el
objeto Buttonl.
22.7.1. En el Selector de elementos de Code Editor, seleccione Buttonl.
22.7.2. En el Selector de sub-elementos de Cod e Editor, seleccione Click.
22.8. En ese procedimiento, codifique lo siguiente. Este procedimiento es una
validación al finalizar un formulario :
1 If txtCodigo. Text <> "" Then
2 If len(txtCodigo.Text) <> 4 Then
3 MsgBox( "El código está incompelto" )
4 txtCodigo.Focus()
5 Exit Sub
6
7 End If
8 End If
9 MsgBox( ''Captura correcta'' )
10 Me .Close()
22.9. Lo que hace este código es lo siguiente:

22.9.1. El código es opcional. Si el código está vacío (línea 1), entonces el
programa reporta que la captura es correcta (línea 9), y cierra el
formulario (línea 10).
22.9.2. Si el código no está vacío (línea 1), entonces el código debe
introducirse correctamente. Si la longitud es diferente de 4 Qínea
2), entonces se manda un mensaje que indica que el dato es
274 Alfaomega
SYNAPS PREMIUM
incompleto (línea 3), regresa el enfoque al objeto donde se captura

el código (línea 4), y se sale del procedimiento (línea 5).
22.10. Ahora codificaremos el procedimiento TextChanged del objeto
txtOpinion.
22.10.1. En el Selector de elementos de Code Editor, seleccione
txtOpinion.
22.10.2. En el Selector de sub-elementos de Code Editor, seleccione
TextChanged.
22.10.3. Codifique lo siguiente:
Buttonl.Enabled = (Len(txtOpinion.Text) >e)
22.10.4. TextChanged se ejecutará cada que el contenido del cuadro de

texto llamado txtOpinion sufra modificaciones.
22.10.5. Cada vez que se modifique el contenido, se puede determinar si la
longitud del contenido es mayor a cero o no; si es mayor a cero,
quiere decir que hay contenido, la condición se resolverá a True, y
ese valor se le asignará a Buttonl. Enabled, y por tanto el botón
se habilitará para su uso. Caso contrario, si el contenido no es
mayor a cero, entonces el campo está vacío, la condición resuelve a
False, que al asignarse a Buttonl. Enabled, inhabilita el botón.
23. Tome en cuenta cómo no se codificó nada para validar si el código tiene el formato
correcto: confiamos en que MaskedTextBox se encargará de ello, lo que constituye
una validación por control.
DJ WBVBVS2012.11.08- Form Behavior.wmv

24. Depure su aplicación (FS):
24.1. Compruebe que de inicio el botón está inhabilitado.
24.2. Coloque el puntero del ratón sobre el cuadro de texto donde se escribe la
opinión, y compruebe si aparece el ToolTi p.
24.3. Escriba una letra en la opinión, y compruebe que el botón se activa al detectar
contenido en el cuadro de texto.
24.4. Compruebe que el contenido se escribe en mayúsculas, independientemente
de cómo lo escribe.
Alfaomega 275
SYNAPS PREMIUM
24.5. Elimine la letra que ha agregado, y compruebe que el botón se inhabilita al

detectar que el cuadro de texto no tiene contenido.
24.6. Escriba una opinión cualquiera, y presione el botón.
24.7. Vea cómo es irrelevante que haya omitido el código.
24.8. Deberá mostrarse el mensaje de que todo está bien, y cerrará la ventana.
25. Depure su aplicación nuevamente (FS).
25.1. Proporcione una opinión.
25.2. Intente escribir un código y vea cómo está oculto.
25.3. Intente escribir un código que no atienda el patrón de una letra y tres dígitos.
25.4. Estando el código incompleto, presione el botón. Vea cómo se reporta que el
código que está incompleto, y regresa el enfoque al control que presenta el
problema.
25.5. Escriba correctamente el código, por ejemplo «A123».
25.6. El programa reporta que la captura es correcta.
FIN DEL EJERCICIO *
~ lab.11.04: Creando su propia interfaz

Este laboratorio pretende que usted utilice el conocimiento adquirido para la creación de
interfaces, y que desarrolle una.
1. Elija una credencial o identificación de su propiedad (Licencia de manejo, ID
personal, Credencial del trabajo, etcétera)
2. Analice los datos que contiene.
3. Desarrolle una interfaz basada en un proyecto Windows Applications, que permita
capturar de forma correcta toda la información contenida en la credencial o
identificación que eligió.
4. Deberá tomar varias decisiones:
a. Qué datos recopilará.
b. En qué orden los recopilará.
c. Qué tipos de control utilizará.
d. Qué validaciones aplican.
FIN DEL EJERCICIO*
276 Alfa omega

SYNAPS PREMIUM
Explotación de Datos usando

ADO.NET
Competencias:
1. Conocer ADO.NET y sus principales
clases.
2. Conocer los esquemas conectados
y desconectados para el manejo
de base de datos en .NET.
3. Conocer la manera de estableces
conexión entre las aplicaciones y
las bases de datos.
4. Conocer la manera de enlazar
objetos a bases de datos.
Evaluacl6n:
Evidencia de
en el cual se
desarrolle una
aprendizaje:
1. Capacidad explicar el uso de las
aplicación que diferentes clases de ADO.NET.
establezca una 2. Capacidad de establecer conexión
conexión a base de ent re las aplicaciones y las bases
datos de forma de datos.
programática. 3. Capacidad de determinar cuándo
2. Proporcionar un caso utilizar bases de datos conectadas,
y cuándo desconectadas.
de datos enlazados,
4. Capacidad de hacer aplicaciones
en donde la selección con consumo de datos (Data
de un objeto incida en Driven Applications).
el contenido de otro
objeto.
SYNAPS PREMIUM
12 Explotación de Datos usando ADO.NET

12.1 Modelo de objetos de ADO.NET .......................................................................................................279
12.1.1 Data Provider Objects.................................................................................................................. 279
12.1.2 DataSet Objects .............................................................................................................................. 281
12.2 Enfoques de enlace a datos ................................................................................................................ 283
12.2.1 Bases de datos conectadas ........................................................................................................ 283
12.2.2 Bases de datos desconectadas ................................................................................................. 285
12.3 Espacios de nombres relacionados con ADO.NET.. .................................................................. 286
12.4 Conexiones a bases de datos específicas ...................................................................................... 287
12.4.1 Conexión basada en Access ....................................................................................................... 287
12.4.2 Conexión basada en SQL Server 7.0 o superior ................................................................. 288
12.4.3 Conexión basada en Oracle .......................................................................................................288
12.5 Enlazado de datos (Data Binding) .................................................................................................. 289
12.5.1 Enlazado simple ...................................................... ....................................................................... 289
12.5.2 Enlazado complejo ........................................................................................................................ 289
~ Demo.12.01: La base de datos Pubs ................................................................................................... 290
~ Lab.12 .01: Conexión a bases de datos con Visual Studio ........................................................... 292
a) Información preliminar de la base de datos ............................................................................. 292
b) Creando una conexión en Visual Studio ..................................................................................... 292
e) Creando un DataSet para consumo de datos ............................................................................ 293
d) Definiendo BindingSource e interfaz de datos con TableAdapter..................................... 295
e) Enlazado complejo con BindingSource y BindingNavígator............................................... 296
fJ Enlazado simple con TextBox ......................................................................................................... 297
~ Lab.12.02: Conexión a bases de datos por programa .................................................................. 298
a) Habilitando el acceso a los archivos de configuración ......................................................... 299
b) Obteniendo información de App.config ...................................................................................... 300
e) Conectando a la base de datos de forma programática ....................................................... 300
d) Código de conexión simplificado ...................................................................................................301
~ Lab.12.03 Listas desplegables dependientes, en modo desconectado ................................. 302
~ Lab.12.04 Visor de registros .................................................................................................................. 306
278 Alfa omega

SYNAPS PREMIUM
Unidad 12: Explotación de Datos usando ADO.NET
12.1 Modelo de objetos de ADO.NET

El modelo de objetos de ADO.NET se divide en dos grandes bloques:
• Data Provider Objects.- Son aquellos objetos que se encargan del manejo efi-
ciente del flujo de datos, del almacén de datos, hasta la copia local de datos (caché).
• DataSet Objects.- Son aquellos objetos que, una vez teniendo una copia local de
datos, permiten agregar información, modificar la información existente, o recupe-
rar información, de la copia local, de manera desconectada. Para el uso de estos
objetos se requiere el soporte XML de .NET Framework.
La primera decisión que debe hacer al momento de desarrollar una aplicación con manejo
de base de datos, es determinar si requiere o no manejar bases de datos desconectadas.
En caso de que determine que sí requiere utilizar bases de datos desconectadas, identifi-
que en qué funciones de la aplicación serán requeridas. Si no requiere operaciones desco-
nectadas, con que aprenda el uso de los Data Provider Objects será suficiente; en caso de
que sí requiera operaciones en modo desconectado, deberá aprender DataSet Objects.
12.1.1 Data Provider Objects

Los objetos relacionados con los controladores de datos .NET, llamados Data Provider Ob-
jects, son aquellos que se encargan de la comunicación de paquetes de datos entre el alma-
cén de datos, y la copia local de datos, a utilizar de manera desconectada.
Data Provider Objects
Figura 12.1 Connection Abre canal de datos

Transaction 1
Estructura
de Data
Provider Command Ejecuta
Objects. comandos
1 Parameters
DataAdapter
lntermediación de
r SelectCommand 1nsertCommand datos
DataSet
1
DeleteCommand UpdateCommand
Alfaomega 279
SYNAPS PREMIUM
Estos objetos se encargan de respetar los convencionalismos de la base de datos, de comu-

nicarse con ella en el formato en que ésta reconozca los paquetes de datos, generando una
copia local de datos en el cliente de la aplicación.
Originalmente, .NET Framework incluyó sólo dos proveedores de datos .NET:
1. SQL Server (SqlClient)
2. OleDb (OleDb)
Posteriormente, fueron agregadas los siguientes proveedores de manera nativa:
1. ODBC (Odbc)
2. Oracle (Oracle)
3. Entity Data Model (EntityClient)
Estos proveedores le permiten acceder a las bases de datos de forma veloz y efectiva.
Básicamente, los Data Provider Objects de ADO.NET son los siguientes:
Obje to Función
Conne ction Permite establecer la conexión con un almacén de datos.
Se debe definir un objeto Connection por cada enlace a almacén de da-
tos requerido por la aplicación. Los objetos DataRea der, DataAdapter
y Command requieren de un objeto Conne ction para funcionar.
Co11111and Ejecuta comandos SQL, y opcionalmente, retorna datos del a lmacén de

datos.
Se requiere un objeto Command para cada instrucción a enviar al almacén
de datos. DataReader requiere de un objeto Command para realizar la
lectura; DataAdapter requiere un objeto Command por cada operación a
realizar (SE LECT, INSERT, UPDATE y DELE TE). En caso de que Da-
taAdapter no realice alguna de las operaciones de actualización, no será
necesario definir Command.
DataReade r Permite generar un fl ujo de datos (data stream) de sólo lectura con el
almacén de datos.
El objeto DataReader se puede utilizar para lecturas sólo hacia delante;
no es requerido por ningún objeto, por lo que su uso es opcional.
DataAdapter Permite generar un flujo de datos (data stream) de lectura - escritura

entre la copia local de datos y el almacén de datos. Se e ncarga de cargar
datos del a lmacén de datos e n el DataSet (SELECT), y de reproducir en
el almacén de datos los cambios realizados en el DataSet (INSERT, UP-
DATE, DELETE) de manera desconectada. Se requiere si se desea la in-
teracción entre un DataSet y un almacén de datos.
280 Alfaomega
SYNAPS PREMIUM
En el momento en que DataReader o DataAdapter poseen datos, quiere decir que ya se

tiene flujo de datos abierta a través de Connection.
Los Data Provider Objects son llamados así porque, dependiendo del proveedor o contro-
lador de datos que se utiliza, se les antepone un prefijo que determina su origen. Por ejem-
plo:
Objeto Para Sql Server Para otras bases Para Oracle
(SqlClient) de datos (Oracle)
(OleDb)
Connection SqlConnection OleDbConnection OracleConnection
DataReader SqlDataReader OleDbDataReader OracleDataReader
DataAdapter SqlDataAdapter OleDbDataAdapter OracleDataAdapter
Command SqlCommand OleDbCommand OracleCommand
En manuales y guías de estudio, suele referirse a los objetos como xxxCommand, xxxData-
Reader, y así, de tal forma que, en caso de que aparezcan nuevos controladores y provee-
dores de datos usted sólo tenga que aprender el prefijo que desea aplicar, aprovechando
así el conocimiento del modelo de objetos que ya tiene.
Dependiendo el controlador de datos .NET que se desee utilizar, el nombre de los objetos
,
vana.
12.1.2 DataSet Objects

El hecho de que se tenga un flujo de datos con el almacén de datos no quiere decir que po-
demos manejar los datos tal y como si dispusiéramos de la base de datos en nuestro equi-
po.
Para poder hacerlo, requerimos de un conjunto de objetos que nos permitan disponer de la
copia local de datos, con todas las particularidades de una base de datos; nos referimos de
DataSet Objects.
DataSet se conforma por un conjunto de datos locales, del lado del cliente, y permite ope-
rar sobre ellos toda la funcionalidad de un manejador de base de datos, permitiendo agre-
gar registros, modificar los datos ya existentes, realizar consultas, etcétera, respetando las
reglas de las bases de datos originales, con la ventaja de que todo eso sucede de manera
desconectada.
Si lo que vamos a desarrollar son puras aplicaciones conectadas, tal y como lo habíamos
hecho siempre, probablemente DataSet no nos resultará tan maravilloso. Sin embargo,
creemos que al igual que todo el mundo, usted tiene interés en las aplicaciones Web, y por
tanto, le interesan las bases de datos desconectadas.
Alfaomega 281
SYNAPS PREMIUM
Si usted conoce las bases de datos relacionales, verá que DataSet y sus objetos asociados
son prácticamente una base de datos relacional.
DataSet
Tables
Figura DataTable
12.2
1 Columns
Estructura
1
deDataSet
Objects. Rows
Constrolnts
Básicamente, los DataSet Objects son los siguientes:
Objeto Función
DataSet Representa la copia local y desconectada de datos, residentes en memo-
•
na.
Se requiere un objeto DataSet por cada modelo de datos a representar
de manera local.
DataTable Representa una tabla dentro del modelo de datos. Se organiza a través
de la colección Tables, que depende de DataSet.
Se requiere un objeto DataTable por cada tabla del modelo de datos a
representar de manera local.
DataColumn Representa una columna o campo, perteneciente a una tabla determi-

nada. Se organiza a través de la colección Columns, que depende de
DataTable.
Se requiere un objeto DataColumn por cada columna o campo del mo-
delo de datos a representar de manera local.
282 Alfaomega
SYNAPS PREMIUM
DataRow Representa una fila o registro, perteneciente a una tabla determinada.

Se organiza a través de la colección Rows, que depende de DataTable.
Se requiere un objeto DataRow por cada registro del modelo de datos a
representar de manera local.
Const raint Representa una restricción de valor único o llave foránea, que aplica a
una tabla determinada. Se organiza a través de la colección Con s trai -
nt s , que depende de DataTable.
Se requiere un objeto Constrai nt por cada por restricción de valor
único (generalmente usadas por las llaves primarias, aunque no nece-
sariamente), y también uno por cada llave foránea definida en el mode-
lo de datos a representar de manera local.
DataRelation Representa una relación ent re tablas. Se organiza a través de la colec-

ción Relations, que depend e de DataSet.
Se requiere un objeto DataRelation por cada relación entre tablas
existente en el modelo de datos a representar de manera local.
Dat a Set se apoya fuertemente en el manejo de colecciones.
Como todas las colecciones, se puede referir el contenido a través de Items, o bien, seña-
lando el identificador de elemento que corresponda, de manera explícita.
12.2 Enfoques de enlace a datos
12.2.1 Bases de datos conectadas

Durante mucho tiempo, las aplicaciones de bases de datos sólo podían ser de una forma:
conectadas.
Una base de datos conectada es la forma de acceso a base de datos en la cual la aplicación
está continuamente conectada al almacén de datos. Este modo de trabajo obedece al mo-
delo petición respuesta, clásico del esquema cliente servidor.
Las ventajas de una base de datos conectada son:
l. La seguridad del acceso a los datos es fácil de mantener.
2. El acceso concurrente a los datos es fácil de controlar.
3. Los datos se encuentran actualizados todo el tiempo.
Alfaomega 283
SYNAPS PREMIUM
Las desventajas de una base de datos conectada son:

1. La conectividad entre la aplicación y la base de datos debe ser permanente.
2. Cada conexión a la base de datos requiere recursos para ser mantenida, Jo que im-
plica que la escalabilidad no es muy buena; cada conexión utiliza recursos, inde-
pendientemente si se están realizando operaciones con la base de datos o no.
Las bases de datos conectadas se recomiendan para aquellas aplicaciones en donde los
datos actualizados en tiempo real son críticos, en donde se tienen usuarios concurrentes, y
donde la información debe estar actualizada para todos todo el tiempo, como puede ser un
sistema bancario, un sistema de control de la producción, o un sistema financiero para el
control de movimientos en la bolsa.
La forma de trabajo es muy similar a la forma en que trabaja actualmente el modelo cliente
-servidor.
1. En el momento en que se requiere interactuar con el almacén de datos se establece

.'
una conex10n.
2. Al abrir una conexión, se envía al manejador de bases de datos una instrucción SQL
o instrucción que se desee ejecutar en el servidor.
3. El servidor ejecuta la instrucción, y en su caso, retorna datos a través de la conexión
que se encuentra todavía abierta.
4. Al haberse concluido el trabajo, la conexión se cierra.
Figura 12.3 (
O Se establece conexión
Flujo de
trabajo en
( 8 Se hace requerimiento
modo
conectado
G) Envía respuesta )
Atiende Cierra
.'
conex1on.
requerimiento
284 Alfa omega

SYNAPS PREMIUM
12.2.2 Bases de datos desconectadas

Con el uso de Internet, la escalabilidad se vio comprometida en los esquemas de bases de
datos conectadas; simplemente, no era posible estar escalando los servidores de base de
datos debido a que el modelo de base de datos no era eficiente en el manejo de conexiones
concurrentes. En una aplicación en Internet no sabemos cuántos usuarios desearán co-
nectarse (y mantenerse conectados).
Derivado de esto surgen las bases de datos desconectadas, que son aplicaciones de base de
datos en la cual la aplicación y el almacén no están permanentemente conectados; en este
esquema, la aplicación sólo toma el conjunto de datos mínimos que requiere para trabajar,
mismos que se almacenan en una memoria temporal (caché) en su equipo. Sobre esos
datos, la aplicación realiza consultas y modificaciones; cuando ya termina de trabajar, sólo
entonces se procede a actualizar el almacén de datos.
Las ventajas del esquema desconectado son:
• Se puede trabajar todo el tiempo, sin la preocupación de estar consumiendo recur-
sos en el servidor, pues el acceso a las bases de datos es a petición.
• Mientras no utilizamos la conexión, otros usuarios pueden hacer uso de ella.
• La escalabilidad se mantiene de manera eficaz, ya que el uso concurrente de la base
de datos se mantiene al mínimo.
Las desventajas de las bases de datos desconectadas son:

• Los datos no están permanentemente actualizados.
• Los conflictos relacionados con la modificación de los mismos datos por diferentes
usuarios deben resolverse, de tal forma que no se pierdan transacciones.
Las base de datos desconectadas se recomiendan para aquellas aplicaciones donde la ac-
tualización de datos que realizan los usuarios no es necesariamente concurrente, donde no
se requiere la información actualizada t odo el tiempo, y donde se tiene pocos recursos de
cómputo y almacenamiento. Por ejemplo, en el caso de una agenda en línea, correo elec-
trónico, control de gastos personales, y en fi n, toda la gama de aplicaciones ideales para
dispositivos móviles, tales como celulares o palm-tops.
La forma en que trabaja el esquema conectado es muy distinta a la forma de trabajar clien-
te - servidor. De inicio, no es necesario que exista un almacén de datos, aunque lo común
.
es que si' exista.
En este esquema:
1. Se realiza una conexión, de igual forma que en esquema conectado.
Alfaomega 285
SYNAPS PREMIUM
2. La aplicación, en lugar de ejecutar instrucciones sobre el almacén de datos, toma el

conjunto de datos mínimos que la aplicación requiere para trabajar.
3. Se cierra la conexión.
4. Los datos extraídos se almacenan en una memoria temporal (caché) en el equipo
que hico la petición (copia local de datos).
5. Sobre la copia local de datos, la aplicación realiza consultas y modificaciones.
6. Cuando así se considere oportuno, se reproducen en el almacén de datos las modifi-
caciones realizadas en la copia local.
Figura 12.4
Flujo de trabajo en modo desconectado
! ( O Se establece conexión
'
~ ( 8 Se hace requerimiento
A .
'V Env1a respuesta
)
Se almacenan
Atiende
dato localmente
requerimiento
Se cierra
conexión
( 0 se establece conexión
Se cierra
conexión
+--------- l Se trabajan
datos localmente
0
Se aplican cambios de
datos locales en la base
de datos
12.3 Espacios de nombres relacionados con ADO.NET

Dijimos que ADO.NET era un conjunto de clases de .NET Framework; como todas las clases
de .NET Framework, se organizan a través de espacios de nombres. Por estar relaciona-
dos con ADO.NET, y por tanto, con el manejo de bases de datos, se les conoce como Data-
Related Namespaces.
Estos espacios de nombre residen físicamente en las librerías System oData odll, y Sys-
temoXml.dll, que deberán establecerse como referencia en las aplicaciones que requie-
286 Alfa omega

SYNAPS PREMIUM
ran manejar bases de datos. En el caso de las aplicaciones Web, las referencias ya están
establecidas a nivel servidor.
Los espacios de nombres relacionados con ADO.NET son Jos siguientes:
Espacio de nombres Descripción

System.Data Núcleo de ADO.NET, que incluye las clases que permiten la ar-
quitectura desconectada.
System.Data.Common Clases de utilería y de interfaz, que son utilizadas por los contro-
Jadores de datos .NET
System.Xml Clases para el soporte a XML.
Dependiendo de la base de datos a la que se quiera enlazar, deberán importarse más espa-
cios de nombres, que serán específicos de cada cliente. En general, no deberá preocuparse
por importar Jos espacios de nombres, si es que realiza las actividades desde Visual Studio.
12.4 Conexiones a bases de datos específicas
12.4.1 Conexión basada en Access

Para conectarnos con una base de datos basada en OLEDB (como lo es Access y SQL Ser-
ver 6.5) desde ASP.NET, es necesario que, en primera instancia, importe los espacios de
nombres requeridos para conexiones OleDb. Al inicio de su programa de código, antes de
la definición de la partial class, agregue lo siguiente:
Imports Namespace="System.Da ta"

Im po rt s Names pa ee="Sy s t,;;;,e,;;,;m .D
;;,;,;,;;;,;a;;;,t;;;,;a;;;,.;,;O;..;l"""e;.;;D,;;b_"_ _ _ _ _ _ _ _ _ _ _ _~-----'
Esto permitirá que no sea necesario especificar cada referencia al modelo de objetos de
conexión OleDb a través de nombres calificados.
Para la conexión, será necesario que codifique, en un bloque de código declarativo, la pro-
gramación ADO.NET típica para una conexión de este tipo.
Generamos la instancia de OleDbConnection, especificamos la cadena de conexión, y
abrimos la conexión:
1 Dim Conecta As New OleDbConnection()
2 Conecta. ConnectionString="Provider=M icrosoft. Jet. OLEDB. 4. 0;" & _
3 ''Data Source=pubs.mdb;''
4 Conecta.Open()
Alfaomega 287
SYNAPS PREMIUM
Las conexiones abiertas por este medio deberán cerrarse a través del método Close.
12.4.2 Conexión basada en SQJ.. Server 7.0 o superior

Para conectarnos con una base de datos en SQL Server 7.0 o posterior desde nuestras apli-
caciones, es necesario que, en primera instancia, importe los espacios de nombres reque-
ridos para conexiones SQLClient. Al inicio de su programa de código, antes de la defini-
ción de la clase, agregue lo siguiente:
Imports Namespace="System.Data"
Import Namespace="System.Data.S LClient"
conexión SQLClient a través de nombres calificados.
Generamos la instancia de SqlConnection, especificamos la cadena de conexión, y abri-
mos la conexión:
1 Dim Conecta As New SqlConnection()
2 Conecta. ConnectionString="Data source=Aprenda; " & _
3 ''Initial catalog=Pubs;" & _
4 ''User Id=sa;'' & _
5 ''Password=secreto;''
6 Conecta.Open()
Las conexiones abiertas por este medio deberán cerrarse a través del método Clase.
12.4.3 Conexión basada en Oracle

Para conectarnos con una base de datos en Oracle desde nuestras aplicaciones, es necesa-
rio que, en primera instancia, importe los espacios de nombres requeridos para conexio-
nes Oracle. Al inicio de su programa de código, antes de la definición de la clase, agregue lo
siguiente:
Imports Namespace="System.Data"
Import Namespace="System.Data.OracleClient"
conexión Oracle a través de nombres calificados.
288 Alfa omega

SYNAPS PREMIUM
Generamos la instancia de OracleConnection, especificamos la cadena de conexión, y
abrimos la conexión:
1 Dim Conecta As New OracleConnection()
2 Conecta.ConnectionString="User Id=SYSTEM;" & _
3 "Password=secreto;" &
4 "Data Source=AVBNET;"
S Conecta.Open()
Las conexiones abiertas por este medio deberán cerrarse a través del método Close.
12.5 Enlazado de datos (Data Binding)

El enlazado de datos (Data Binding) es la capacidad de los obj etos para asumir el mismo
valor de otro objeto, en un momento determinado, sin necesidad de programar la iguala-
ción de valores.
El enlazado de datos puede darse de dos formas diferentes:
1. Enlazado simple. Cuando sólo se enlaza un dato a un tiempo.
2. Enlazado complejo. Cuando a un tiempo se enlazan más de un valor.
12.5.1 Enlazado simple

En el caso del enlazado simple, la referencia de valor es uno a uno, y se realiza asignando a
alguna propiedad de valor del objeto que adquiere el valor, utilizando una referencia a un
obj eto proveedor de datos.
12.5.2 Enlazado complejo

En el caso del enlazado compuesto. la referencia de valor es múltiple; los valores a enlazar
no son únicos, ya que generalmente los datos provienen de un origen de datos como Data-
Set o DataView, que poseen elementos o miembros de datos (members). de entre los cua-
les se tiene que especificar cuál se desea tomar.
Al igual que el enlazado simple, la transferencia de datos se realiza al aplicar el método
DataBind de los objetos que adquieren los datos.
Algunos objetos que aceptan este tipo de enlazado de datos son:
1. Table
2. Repeater
Alfaomega 289
SYNAPS PREMIUM
3. Datalist
4. DropDownlist
S. DataGrid
No todos los objetos permiten enlazado de dato complejo; el enlazado complejo es posible
gracias a un conjunto de propiedades que Jo permiten; sólo aquellos objetos que posean
dichas propiedades podrán disponer de la funcionalidad del enlazado complejo.
Algunas de esas propiedades se muestran a continuación:
DataSource Establece el origen de datos para el objeto.
DataMember Establece el miembro o elemento de datos del origen de

datos, que proporcionará sus valores.
DataTextField Columna que proporcionará la información textual a

mostrar en ciertos controles.
DataValueField Columna que proporcionará la información a almacenar

en la propiedad de valor en ciertos controles.
~ Demo.12.01: la base de datos Pubs

Para poder comprobar los ejemplos que realizaremos en este documento, utilizaremos la
base de datos pubs, que almacena datos de prueba relativos a la venta de libros. En caso
de que no posea esa base de datos en su instalación de SQL Server, puede encontrar en su
CD de compañía el script llamado InstPubs. sql, mismo que deberá ejecutar desde SQL
Server.
Sólo describiremos las tablas y campos más importantes para los ejercicios que hemos de
desarrollar.
a) AUTHORS: Registra los datos de los autores de los libros. Incluye los
siguientes campos: identificador del autor (au_id), apellidos del autor
(au_lname), nombre del autor (au_fname), teléfono (phone), dirección
(address), y siglas del estado al que pertenece (state).
b) PUBLISHERS: Registra las casas editoriales que publican los libros.
Incluye los siguientes campos: identificador de la casa editorial (pub_id), y
nombre de la casa editorial (pub_name).
e) TITLES: Registra los datos de los tftulos o libros que se tienen para venta.
Incluye los siguientes campos: identificador del título (title_id), descripción
del título (title ), precio (price), fecha de publicación (pubdate), y clave de
la editorial que publicó el libro (pub_id).
290 Alfa omega

SYNAPS PREMIUM
d) TITLEAUTHORS: Es una tabla de relación que registra qué libros son de

qué autores. Está compuesta por las llaves primarias de las tablas que
une: identificador de autor (au_id) e identificador de libro (title_id).
e) STORES: Registra los datos de las diferentes tiendas que venden los libros.
Incluye los siguientes campos: identificador de tienda (stor_id), nombre de
la tienda (stor_name), y siglas del estado en el que se encuentra la tienda
(state).
fJ SALES: Registra las ventas que se realizan de un determinado libro en una
determinada tienda, a través de una orden de compra. Incluye los
siguientes campos: Identificador de la tienda donde se realiza la venta
(stor_id), número de orden de compra (ord_num), identificador del libro
que se vendió (title_id), cantidad vendida (qty), fecha de la orden de
compra (ord_date).
pubs tiene la siguiente composición básica:
roysched
stor_id
«d_num
«d_date
Pmploypp
<1:'1
paytenns fl ...,_Id
fl We.Jd rn.me
nH
n.me
jobjd
totles
jobJYI
fl We_id pub.Jd
We f*e_date
type
fl st« _id ~-id
st«_name
i!===- ·-j price
advance
stor_address
clty royalty
ytd_sales
state l"h'
zlp notes
pubdate 11 job_id
job_desc
pub ooofu mln_lvl
max_ivl
11 pubjd
lago
pr_lnfo
t otlr.uothnr
Alfaomega 291
SYNAPS PREMIUM
~ Lab.12.01: Conexión a bases de datos con Visual Studio

En este laboratorio establecerá una conexión con una base de datos en SQL Server usando
Visual Studio.
a) Información preliminar de la base de datos
1. Para este ejercicio, debe contar con una instancia de SQL Server trabajando en su
computadora. De dicha instancia, usted debe saber lo siguiente:
a. Nombre de la instancia: - - - - - - - (KNOWLEDGEMGR)
b. Nombre de la base a utilizar: Pubs
c. Cuenta para acceder a la base de datos: (sa)
d. Contraseña para acceder a la base de datos: (secreto)
i. Se colocó entre paréntesis la información utilizada en los ejercicios.

Usted debe utilizar la información real del ambiente en el que está
trabajando.
2. Ingrese a SQL Server, y asegúrese que tiene disponible la base de datos de prueba,
denominada Pubs, que es la que utilizaremos en los ejercicios.
a. En caso de que no posea esa base de datos, puede encontrar en su CD de
compañía el script llamado InstPubs. sql, mismo que deberá ejecutar
desde SQL Server.
b. Al ejecutar el script, la base de datos se generará, y además se poblará de
datos de prueba.
b) Creando una conexión en Visual Studio
3. Seleccione la herramienta Server Explorer.

a. Generalmente comparte espacio en el ambiente de desarrollo con ToolBox.
b. En caso de que no esté visible, puede invocarlo a través de la opción de
menú View- Server Explorer, o bien, presionando CTRL+ALT -S.
4. En Server Explorer, haga die en el icono Connect To Database ( • ).

...
a. La primera vez que se conecta a una base de datos, probablemente le
pregunte a qué base de datos se estará enlazando regularmente.
b. Aparecerá la ventana Choose Data Source. Si no le apareció esta ventana,
pase al punto S.
c. Seleccione Microsoft SQL Server. Con ello se establecerá el Data Provider a
utilizar; en este caso, es el proveedor de datos nativo de .NET. Asegúrese de
que está marcado Always use this selection, para que asuma siempre que
292 Alfa omega

SYNAPS PREMIUM
nos conectaremos con SQL Server. Desde luego, usted podrá hacer la
selección más conveniente, en su momento.
d. Presione Continue.
S. Aparecerá la ventana Add Connection.
a. Vea cómo en Data source se tiene el valor de Microsoft SQL Server
(SqlClient), lo cual es correcto porque nos enlazaremos a una base de
datos SQL Server. En caso de que se tratara de otra base de datos, sería
necesario modificar el data provider.
b. En Server Name, especifique el nombre de la instancia. KNOWLEDGEMGR, en el
caso del ejercicio.
c. En Log on to the server, seleccione Use SQL Server Authenticcation.
i. En User name, escriba sa.
ii. En Password, escriba se e reto.
d. Marque Save my password.
e. En Connect to a database, seleccione Selector en ter a database name, y
seleccione la base de datos Pubs, que es con la cual vamos a trabajar.
f. Finalmente, haga die en Test Connection. Si todo está bien, aparecerá un
mensaje que dice Test connection succeeded. En ese caso, haga die en
Ok.
g. Observe que en Database Explorer se ha agregado un nodo con la conexión
que acabamos de crear. Si expande la jerarquía, verá que Visual Studio hace
un enlace con SQL Server, dando lugar a un ambiente integrado de
desarrollo.
6. ¿Qué hemos hecho hasta aquí? Hasta aquí, hemos definido una conexión a la base
de datos, lo que abre un canal para que nuestras aplicaciones tengan acceso a una
base de datos física.
DI WBVBVS2012.12.01- Conexion.wmv
e) Creando un DataSet para consumo de datos
7. Ahora crearemos una aplicación que nos permita entender el consumo de datos
desde aplicaciones Windows. Al final, nuestra aplicación deberá lucir como sigue:
Alfaomega 293
SYNAPS PREMIUM
• FO<ml
1 of 14 • •1 9 X
8. Trabaje sobre la solución Ejercicios .

10. Asigne como nombre NavegaDatos.
12. Cambie el tamaño del formulario para que quede menos alto y más extendido.
13. En Solution Explorer, abra el archivo app . config.
a. Este es el archivo de configuración general del sitio, que controla aspectos
generales de funcionamiento y comportamiento.
b. Se trata de un documento XML.
c. Vea cómo no hay referencia alguna a Pubs, todavía.
14. Seleccione el nodo principal del proyecto NavegaDatos, y con el menú de contexto
seleccione Add- New Item. Aparecerá la pantalla Add New ltem.
15. Seleccione Command ltem - Data- Dataset, para agregar un Dataset al proyecto.
a. Establezca el nombre por omisión DataSet1.xsd, y presione Add.
16. Se agregará un Dataset al proyecto, y se abrirá Data Design, para que usted pueda
crear tablas y objetos en su nuevo Dataset.
17. Proporcionando estructura al Dataset.
a. En Server Explorer, identifique la conexión que hemos definido, y expanda la
jerarquía hasta que se muestre el contenido del folder Tables.
b. Aparecerán todas las tablas de la base de datos.
c. Seleccione la tabla jobs, y arrástrela a Data Designer.
d. Visual Studio entenderá que el Dataset recibirá en algún momento datos de
la base de datos física a la que hace referencia la conexión, por lo cual, para
obtener los datos en su momento, debe tener acceso a los datos físicos. Para
ello, requiere de la cadena de conexión.
294 Alfa omega

SYNAPS PREMIUM
e. Como la cadena de conexión tiene información sensible, aparecerá una

advertencia que le indica que información sensible será agregada en el
archivo de configuración App.config. Autorice, presionando Ok.
f. Sólo entonces, las definiciones que se tienen en la base de datos pasan a
estar también en la copia local de la base de datos, es decir, del Dataset
18. Abra App.config del proyecto, y vea cómo ya hay referencias al enlace con la base de
datos, en la sección ConnectionString.
a. Este es un tema sensible de seguridad, pues lo ideal es que esa información
se encuentre encriptada.
b. Hay mecanismos para encriptar secciones de los archivos de configuración,
pero escapan al alcance de este texto.
c. En Google puede buscar "Encrypt Connection String in app.config", y
aparecerán algunos muy buenos artículos referente a ello.
d. Cierre App.config
19. ¿Qué hemos hecho hasta aquí? Creamos una aplicación, y dentro de ella, creamos
un Dataset que es una representación local de la base de datos física. Es muy
importante mencionar que el Dataset es un recipiente de datos, pero aún no tiene
datos. Al crear la tabla de Dataset a partir de la tabla de la base de datos, lo que
hicimos es que Visual Studio hiciera por nosotros el trabajo de crear un recipiente
de datos totalmente compatible con la base de datos física. Nuestro proyecto tiene
un recipiente de datos, que aún no tiene datos.
¡gl WBVBVS2012.12.02- Dataset.wmv
d) Definiendo BindingSource e interfaz de datos con TableAdapter
20. Nuestra tarea ahora es preparar al Dataset para que tome datos del almacén físico,
y que ponga esos datos a disposición de Jos objetos de la interfaz que lo requieran.
21. Habrá objetos que utilicen los datos que posea el Dataset, es decir, se enlazarán con
el Dataset para consumir los datos que contiene. El objeto que gestionará el enlace
de los diferentes objetos con el Dataset se llama BindingSource.
a. En Toolbox, seleccione el Tab Data, y arrastre un control BindingSource a la
interfaz. Se agregara con un nombre por omisión: BindingSourcel.
b. El lugar donde lo coloque es irrelevante, pues no es un control que se vea en
tiempo de ejecución. Sólo se colocará una representación visual del objeto
Alfaomega 295
SYNAPS PREMIUM
en la parte baja del área de trabajo de Visual Studio, a fin de que pueda
trabajar con él.
c. Seleccione el objeto BindingSourcel, y presione F4 para editar sus
propiedades.
d. Busque la propiedad DataSource. Haga clic en el combo para asignar valor.
Extienda la jerarquía Other Data Sources - Project Data Sources, y seleccione
DataSetl.
e. Luego seleccione la propiedad DataMember, que permite seleccionar qué
elemento del Dataset es el que deseamos consumir. A esa propiedad
asígnele el valor de }obs.
22. Lo primero que debemos entender es que el Dataset es una estructura estándar
basada en XM L, y que los almacenes de datos que le proporciona información
pueden ser muy diversos (SQL Server, Oracle, Access, MySQL, etcétera), cada quién
con sus propias maneras de almacenar y manipular los datos.
23. En la parte baja de Visual Stu dio aparecen tres objetos: Dataset y DataBinding
nosotros los colocamos; el tercero de los objetos es un TableAdapter que Visual
Studio agregó automáticamente, porque es necesario.
a. Los objetos de tipo TableAdapter tienen la función de servir de interfaz o
traductor entre el almacén físico de datos y el Dataset.
b. En resumen, se encargan de hacer compatible al almacén físico con el
Dataset.
24. Aunque lo más lógico sería primero definir TableAdapter y luego BindingSource, se
hace en este orden para no tener que hacerlo nosotros, y que Visual Studio defina
por nosotros el objeto al percatarse de su necesidad.
25. ¿Qué hemos hecho hasta aquí? Visual Studio creo un TableAdapter que permitirá
tomar datos de la tabla Jobs del almacén físico, y hacerlos compatibles con la tabla
Jobs que está en Dataset: con esto, Dataset puede llenarse de datos del almacén
físico. Cuando ya tenga datos, los diferentes objetos de la interfaz podrán consumir
los datos del Dataset, utilizando para ello el objeto BindingSource, que hemos
creado.
DI WBVBVS2012.12.03 - BindingSource.wmv
e) Enlazado complejo con BindingSource y BindingNavigator
26. El enlazado complejo es un enlazado donde participan más de un dato a la vez.

27. Para comprobar este tipo de enlazado, agregaremos un objeto BindingNavigator,
que nos permite navegar entre los datos de un recurso enlazado.
296 Alfa omega

SYNAPS PREMIUM
a. En Toolbox identifique a BindingNavigator. Arrastre el control a la parte

superior del área de trabajo del formulario, para agregarlo.
b. Modifique la propiedad BindingSource, y seleccione el objeto
BindingSourcel. Dese cuenta que no aparece disponible como opción el
objeto Datasetl, es decir, los datos del Dataset están disponibles sólo a
través del objeto BindingSource.
28. Guarde su proyecto y depure (FS).
29. Vea cómo el control BindingNavigator indica que está en el registro 1 de varios. El
enlazado es complejo porque el control tiene conciencia no sólo de un dato, sino de
todo el conjunto de datos al mismo tiempo.
30. Puede navegar entre ellos, utilizando las funciones del control.
aJ WBVBVS2012.12.04- BindingNavigator.wmv
1) Enlazado simple con TextBox
31. El enlazado complejo simple es un enlazado donde participa un solo dato a la vez.
32. Agregue un objeto TextBox, abajo del BindingNavigator.
33. Amplíe el ancho del cuadro de texto.
34. En Properties Windows busque (Databindings), expanda la jerarquía hasta que vea
la propiedad Text (campo de mostrado de datos).
35. Modifique el valor de la propiedad. Abra la jerarquía de BindingSourcel, y
seleccione el campo job_desc.
36. Modifique la propiedad Enabled, estableciendo el valor de False, para que sea un
campo de sólo lectura.
37. Guarde su trabajo e inicie depuración (FS).
38. Vea cómo aparece el dato correspondiente en el cuadro de texto.
39. Cuando navega utilizando BindingNavigation, el contenido del cuadro de texto
cambia también.
11' WBVBVS2012.12.04 - Binding Simple con Textbox.wmv

40. Haga die en cualquier parte del formulario y vea el código del procedimiento de
evento Load del formulario. La línea que ahí aparece es la que provoca que se
carguen datos en el Dataset a través de la intermediación de TableAdapter. Una vez
Alfaomega 297
SYNAPS PREMIUM
que se cargan los datos, la actualización de los objetos que están enlazados es
automática. Cierre el código.
41. ¿Qué hemos hecho hasta aquí? En tiempo de ejecución, nuestros objetos
consumen los datos de un Dataset, a través de un objeto BindingSource que nos
permite llegar a un objeto Dataset que se puebla de datos gracias a la
intermediación de un TableAdapter que utiliza una conexión previamente definida.
FIN DEL EJERCICIO*
~ lab.12.02: Conexión a bases de datos por programa

En este laboratorio establecerá una conexión con una base de datos en SQL Server usando
programación. El ejemplo es simple, y utilizará la cadena de conexión que ya está
almacenada en el archivo de configuración desde el pasado ejercicio.
3. Asigne como nombre ConectaPro.
s. Agregue los siguientes objetos al programa:
Button Text Conectar a la base
Label (Name) Resultado
Text Esperando conexión
6. La interfaz quedará de la siguiente forma:
j"'C" ' C '" < >• ' O " H '
•:;} Forml
[ Conectar a ]
Esperando conextón
7. Abra el archivo de configuración del proyecto ConectaPro (App.config).

8. Vea que dentro del archivo no se encuentra la sección <ConnectionStrings>.
9. Abra el archivo de configuración del proyecto NavegaDatos.
298 Alfa omega

SYNAPS PREMIUM
10. Copie toda la sección <ConnectionStrings>.
11. Pegue dentro del archivo de configuración de ConectaPro la sección

<ConnectionString>.
12. Modifique el nombre asignado al elemento en el archivo de configuración.
Actualmente el valor es NavegaDatos.My.MySettings.pubsConnectionString;
cámbielo a ConectaProCS.
13. El archivo de configuración quedará como sigue:
1 <?xml version="1.9" encoding="utf-8" ?>
2 <configuration>
3 <startup>
4 <supportedRuntime version="v4.9" sku=".NETFramework,Version=v4.5" />
5 </startup>
6 <connectionStrings>
7 <add name="ConectaProCS" .J
connectionString="Data Source=KNOWLEDGEMGR;Initial Catalog=pubs;Persist .J
Security Info=True;User ID=sa;Password=secreto" .J
providerName="System.Oata.SqlClient" />
8 </connectionStrings>
9 </configuration>
a) Habilitando el acceso a los archivos de configuración
14. Para tener acceso al archivo de configuración desde nuestras aplicaciones, es

necesario disponer de los servicios proporcionados por el namespace
System.Configuration.
a. Seleccione el nodo principal del proyecto.
b. Invoque el menú de contexto y seleccione Add Reference.
c. Aparecerá la ventana Reference Manager.
d. Seleccione en la jerarquía Assembiles - Framework, para que aparezcan
todas las referencias de .NET Framework disponibles.
e. En las referencias, busque System.Configuration, y selecciónelo,
asegurándose que el cuadro de verificación sea marcado.
f. Haga die en Ok.
15. Compruebe que la referencia quedó establecida.
a. En la barra de herramienta de Solution Explorer, seleccione Show All Files.
b. Aparecerá el Folder References. Expanda la jerarquía, y compruebe que ya
se tiene ahí la referencia a System.Configuration.
DI WBVBVS2012.12.0S- System.Configuration reference.wmv
Alfaomega 299
SYNAPS PREMIUM
b) Obteniendo información de App.config

16. Haga doble clic en cualquier parte no ocupada del formulario, para invocar el
código del formulario. Al inicio del programa, antes de que se declare la clase,
escriba estas dos líneas.
1 Imports System.Configuration
2 Imports System.Data.SqlClient

a. En la línea 1, se importa el namespace System.Configration, que nos
proporcionará los objetos y elementos para poder interactuar con el archivo
de configuración.
b. La línea 2, se importa el namespace System.Data.SqlClient, que nos permitirá
tener acceso a una base de datos SQL Server.
e) Conectando a la base de datos de forma programática
18. En el selector de elementos seleccione Buttonl, y en el selector de sub-elementos

seleccione Click, para modificar el procedimiento que ha de ejecutarse cuando se
haga clic en el botón. Edite dentro del procedimiento lo siguiente:
1 Dim Conneetions As Cco";~Leti.o• St!'l' ,;" • • ,• 1··,c,; • ·"
2 Conneetions = '1ri.g •. rationManage· .ConneetionStrings
3 Dim es As String
4 es = Conneetions.Item{"ConeetaProCS").ConneetionString
5
6 Dim enn As SQlConnec:tc~
7 enn = New •,,¡,C ,.~··e~tio•' O
8 enn.ConneetionString = es
9 enn .Open()
10 If enn.State = 1 Then
11 Resultado.Text = "Conexión exitosa"
12 El se
13 Resultado.Text = ''Conexión no exitosa''
14 End If
15 enn .Close()

a. En la línea 1 se define una variable llamada Connections, que permite
manejar la colección ConnectionStringSettingsCollection, que es la colección
a través de la cual se pueden explorar los elementos de la sección
<ConnecionStrings> del archivo de configuración.
b. En la línea 2 se le asigna a Connections la colección que contiene la
información de las definiciones realizadas en la sección <ConnectionStrings>
del archivo de configuración. A partir de este momento, las definiciones
están disponibles a través de esta variable.
300 Alfa omega

SYNAPS PREMIUM
c. En la línea 3 se define una variable que utilizaremos para manejar la cadena

de conexión que recuperaremos del archivo de configuración.
d. En la línea 4 tomamos el valor de la cadena de conexión identificada como
ConectaProCS en la sección <ConnectionStrings> del archivo de
configuración.
e. La línea 6 declara un objeto SQLConnection llamado cnn, que permitirá el
enlace con nuestra base de datos en SQL Server. Dicho objeto se instancia en
la línea 7.
f. En la línea 8 se asigna al objeto cnn la cadena de conexión que deberá
utilizar para realizar el enlace. Como puede ver, se trata de la cadena de
conexión que recuperamos del archivo de configuración.
g. En la línea 9 se establece la conexión con la base de datos.
h. Sí el estado de la conexión es 1 (línea 10), quiere decir que la conexión fue
exitosa, y por tanto se muestra el mensaje correspondiente (línea 11); de lo
contrario, se mostrará el mensaje contrario (línea 13).
.
J. Se cierra la conexión (línea 15) .
d) Código de conexión simplificado
20.. NET provee diferentes constructores para los objetos, de tal manera que hay
variantes que permiten una programación más compleja o menos compleja.
21. En el código anterior, las líneas 6 y 7 se pueden concentrar en una sola:
Dim Cnn As SqlConnection
Cnn = New SqlConnection()
Se pueden resumir en:

Dim Cnn As New SqlConnection()
Ahora bien:
Cnn = New SqlConnection()
Cnn.ConnectionString = es
Se puede resumir si el valor asignado a la propiedad ConnectionString se coloca

entre los paréntesis. Todo lo anterior puede resumirse en una sola línea:
Cnn = New SqlConnection(cs)
22. Modifique su código, para que quede de la siguiente manera:
Alfaomega 301
SYNAPS PREMIUM
1 Dim cnn As New SqlConnectíon (cs)

2 cnn.Open()
3 If cnn.State = 1 Then
4 Resultado. Text = "Conexión exitosa"
5 Else
6 Resultado.Text = "Conexión no exitosa"
7 End If
8 cnn.Close()
23. Depure su programa (FS).

24. Al hacer clic en el botón, debe establecerse la conexión, y el correspondiente
mensaje aparecerá en la interfaz.
a. Esto es importante, pues todo el manejo de datos depende de que se pueda
hacer una conexión con la base de datos.
FIN DEL EJERCICIO *
~ lab.12.03 listas desplegables dependientes, en modo

desconectado
Desarrollará una aplicación que establezca conexión con una base de datos SQL Server,
que defina un objeto DataSet, y que de manera desconectada pueble de datos a dos
listas desplegables de objetos, subordinando una respecto al valor seleccionado en la
otra, en modo desconectado.
3. Asigne como nombre Combos Enlazados.
S. Agregue Jos siguientes objetos al programa:
j Objeto Propiedad Valor a asignar
Label Text Puestos:
ComboBox (Name) cboPuestos
Label Text Empleados:
ComboBox (Name) cboEmpleados
Label Text Valor seleccionado- Puestos:
Label (Name) lblPuesto
Text Pendiente
Label Text Valor seleccionado- Empleados:
Label (Name) lblEmpleado
Text Pendiente
302 Alfa omega

SYNAPS PREMIUM
6. La interfaz quedará de la siguiente forma:
a:} Forml
~os.
Empleados:
Valorselecaonado Puestos: Pendierte
Valor seleccionado · Empleados: Pendiente
a) Estableciendo la plataforma de datos con Dataset

6. Las tareas que realizaremos ya las hemos visto en ejercicios anteriores, por lo cual
sólo nos detendremos en aspectos no explorados.
7. Seleccione el nodo principal del proyecto.
8. En el menú de contexto seleccione Add- New Item.
9. Seleccione en la jerarquía Data, y agregue un Dataset Mantenga el nombre por
omisión (Datasetl.xsd).
10. La herramienta Dataset Designer estará vacía.
11. Seleccione Server Explorer y expanda la jerarquía de la conexión que ya hemos
definido, de tal manera que vea el Folder Tables.
12. Arrastre a Dataset Designer la tabla employee.
13. Si nos aparece la advertencia de posible exposición de datos sensibles, acepte.
14. Arrastre a Dataset Designer la tabla jobs.
15. Vea cómo Dataset Designer intuye la relación existente entre las tablas.
gl WBVBVS2012.12.06- Dataset multitabla.wmv
a) Definiendo fuentes de datos para objetos combo

16. Seleccione Toolbox y ubique el control BindingSource.
17. Agregue dos controles BindingSource a la interfaz (arrastre el control dos veces,
desde Toolbox hacia el formulario).
18. Seleccione el objeto BindingSource1 y edite sus propiedades.
Alfaomega 303
SYNAPS PREMIUM
a. Seleccione la propiedad DataSource y cambie su valor.

b. Seleccione Other Data Sources - Project Data Sources - DataSetl
c. Seleccione la propiedad DataMember y establezca como valor jobs.
d. Con esta especificación, podremos enlazar cualquier control con los datos de
la tabla Jobs del DataSet, a través de BindingSourcel.
19. Seleccione el objeto BindingSource2 y edite sus propiedades.
a. Seleccione la propiedad DataSource y cambie su valor.
b. Seleccione Other Data Sources - Project Data Sources - DataSetl
c. Seleccione la propiedad DataMember y establezca como valor employee.
d. Con esta especificación, podremos enlazar cualquier control con los datos de
la tabla Jobs del DataSet, a través de BindingSourcel.
20. Utilice el SmartTag de cboPuestos:
a. Seleccione el cuadro de verificación Use Data Bound Items, con lo que se le
indica al objeto que el contenido del combo será tomado de una fuente de
datos, y no por programación.
b. Como queremos que este combo muestre los puestos, asignamos en Data
Source el objeto BindingSourcel, que es el que permite el enlazado con esos
datos.
c. En Display Member, seleccione job_desc; este campo es el campo que se
mostrará en la lista de opciones del combo.
d. En Value Member, seleccione el objeto job_id, que es el valor al que
queremos llegar al elegir una opción en el combo.
21. Utilice el SmartTag de cboEmpleados:
a. Seleccione el cuadro de verificación Use Data Bound Items, con lo que se le
indica al objeto que el contenido del combo será tomado de una fuente de
datos, y no por programación.
b. Como queremos que este combo muestre los empleados, asignamos en Data
Source el objeto BindingSource2, que es el que permite el enlazado con esos
datos.
c. En Display Member, seleccione fname; este campo es el campo que se
mostrará en la lista de opciones del combo.
d. En Value Member, seleccione el objeto emp_id, que es el valor al que
queremos llegar al elegir una opción en el combo.
D WBVBVS2012.12.07 - Alimentando datos a combobox.wmv
304 Alfa omega

SYNAPS PREMIUM
22. Haga doble die en cboPuestos, para editar el procedimiento de evento que ocurrirá
cuando se cambie el valor en el combo. Escriba la siguiente línea, que provocará
que, al seleccionar un elemento en el combo, se nos informe la clave asociada al
elemento seleccionado.
lblPuesto.Text=cboPuestos .Sel ectedValue
23. Haga doble die en cboEmpleados, para editar el procedimiento de evento que
ocurrirá cuando se cambie el valor en el combo. Escriba la siguiente línea, que
provocará que, al seleccionar un elemento en el combo, se nos informe la clave
asociada al elemento seleccionado.
lblEmpleado . Text=cboEm leado.SelectedValue
24. Depure el programa (FS) y compruebe lo siguiente:

a. Cada combo tiene los datos correspondientes a la tabla que se enlazaron.
b. Al modificar un valor en el combo, se actualiza el valor seleccionado que se
muestra en las etiquetas informativas.
c. Al seleccionar una opción en cboPuestos, el contenido de cboEmpleados no
sufre ningún cambio.
d. Cierre la aplicación.
a) Aplicación de filtros de datos en tiempo de ejecución

25. En ocasiones, la interacción con los elementos de la interfaz provocan
modificaciones en la misma interfaz.
26. Uno de los comportamientos más comunes en interfaces con manejo de datos, es
que la selección de un valor en un objeto determinado, implica filtros o selecciones
específicas en otros objetos.
27. En el caso de nuestro ejemplo, deseamos que, al seleccionar un valor en el combo
de puestos, en el combo de empleados sólo aparezcan los empleados que tengan ese
puesto.
28. Para hacer esto, edite haga doble die en cboPuestos, para ir al procedimiento de
evento SelectlndexChanged. Dentro del procedimiento, agregue la siguiente línea.
BindingSource2.Filter = String.Format( "job_id={el}", cboPuestos.SelectedValue)
Esta línea especifica un filtro a BindingSource2, que equivaldría a hacerle un filtro a

la tabla employee. Se especifica un criterio, en donde job_id es igual al valor
seleccionado en el combo de puestos. Como BindingSource2 es el que proporciona
Alfaomega 305
SYNAPS PREMIUM
los datos a cboEmpleados, al seleccionar un determinado puesto, sólo se mostrarán

los empleados de ese puesto en el combo.
29. Depure su aplicación, y compruebe que una selección en el combo de puestos, filtra
el contenido del combo de empleados.
FIN DEL EJERCICIO*
~ Lab.12.04 Visor de registros

En este laboratorio deberá desarrollar una aplicación que recupere de manera filtrada
datos de una base.
1. Agregue a su solución Ejercicios un proyecto llamado VerTiendas, basada en un
proyecto Windows Applications.
2. La aplicación utilizará la base de datos Pubs.
3. Deberá preguntar por las iniciales de un estado (txtiDEstado), y deberá mostrar en
formato de dos dimensiones los registros de la tabla stores, cuya clave de estado
(state) coincida con lo capturado.
4. Utilice para ello DataSet y DataGridView. Su interfaz debe lucir como sigue.
Oave del Estado. 1 Ver Datos ~
stor_ld stor_name stor_address

.....::....---~--'
* .J 1
~--------~--------
1
~~--------~------- -
~ 1
"'
S. La cadena de conexión deberá obtenerse de un archivo de configuración.

FIN DEL EJERCICIO *
306 Alfa omega

SYNAPS PREMIUM
Multicapa con Visual Basic, -Windows

-
Applications y SQ_L Server
Competencias:
1. Conocer el marco teórico del
desarrollo multicapa.
2. Conocer la forma de implementar
cada una de las capas en la
tecnología más apropiada para
ello.
3. Conocer la forma en que Visual
Studio integra todas las
herramientas necesarias para el
desarrollo multicapa.
Evaluacl6n:
1. Proporcionar un caso Evidencia de
en el cual se
aprendizaje:
desarrolle una
l. Capacidad explicar en qué
aplicación multicapa. consiste el modelo multicapa.
2. Capacidad de desarrollar la capa
de datos, en SQL Server, desde
Visual Studio.
de presentación utilizando
lenguajes .NET.
de presentación basada en
Windows, desde Visual Studio.
SYNAPS PREMIUM
13 Multicapa con Visual Basic, Windows Applications y SQ_L

Server
13.1 Modelo de desarrollo Multicapa ......................................................................................................309
13.1.1 Capa de presentación (Presentation Tier) .......................................................................... 309
13.1.2 Capa de procesamiento (Processing Tier) .......................................................................... 310
13.1.3 Capa de datos (Data Tier) .......................................................................................................... 31 1
13.2 Implementación de Multicapa con Windows Applications y SQL Server ...................... .311
13.2.1 Secuencia de implementación .................................................................................................. 311
13.2.2 Conocimientos requeridos ........................................................................................................ 312
13.3 Objeto Command ................................................................................................................................... 313
13.3.1 Tipos de comandos ....................................................................................................................... 314
13.3.2 Tipos de ejecución de los comandos ...................................................................................... 315
~ Lab.13.01: Desarrollando la capa de datos ...................................................................................... 315
a) Conocimiento de la base .................................................................................................................. 315
b) Conocimiento de la tabla a manipular ....................................................................................... 316
e) Creando stored procedures en SQL Server usando Server Explorer ................................. 317
d) Probando stored procedures desde Visual Studio ................................................................... 319
e) Realizando consultas desde Visual Studio ................................................................................. 323
~ Lab.13.02: Desarrollando la capa de procesamiento ...................................................................325
a) Creación de una clase ....................................................... ................................................................325
b) Agregando propiedades usando Code Snippets .......................................................................326
e) Agregando métodos que usan Commandy DataReader....................................................... 329
d) Agregando métodos que usan Command con ExecuteScalar ............................................. 331
~ Lab.13.03 Desarrollando la capa de presentación ........................................................................ 332
a) Agregando proyectos existentes a una solución ...................................................................... 333
b) Agregando imágenes y barras de status .................................................................................... 334
e) Referenciando la clase de capa de procesamíento .................................................................. 336
d) Instanciando la clase de capa de procesamíento .................................................................... 337
e) Recuperando la cadena de conexión de App.config ................................................................ 338
jJ Buscando información en la base de datos ................................................................................ 339
g) Agregando y modificando información en la base de datos .............................................. .340
h) Eliminando información en la base de datos ........................................................................... 341
~ Lab.13.04 Realizando su propia aplicación ..................................................................................... 342
308 Alfa omega

SYNAPS PREMIUM
Unidad 13: Multicapa con Visual Basic, Windows Applications y SQL Server
13.1 Modelo de desarrollo Multicapa

Según Salazarl el modelo de desarrollo de aplicaciones conocido como Modelo Multicapa,
consiste en aislar las operaciones de base de datos, de lógica de negocios, y de front-end, de
tal manera que convivan para producir un resultado esperado, sin mezclarse.
Dado que cada una de las diferentes operaciones demanda la participación de profesiona-
les con diferente especialidad, resulta muy conveniente la separación, de tal manera que
puedan trabajar sobre un mismo aplicativo de manera simultánea.
A grandes rasgos, cada una de las diferentes operaciones se les denomina capas, y las más
clásicas son las siguientes:
Modelo Multicapa
Figura 13.1
Modelo ( ) ( ) ~
Multicapa o
~
Capa de presentación capa de datos
Web Engine (liS) capa de procesamiento SQL Server
ASP.NfT Services .NfT Framework Bas~s d~ datos
Web Site 1Aplicativos CLR/BCL Stored Procedures
Clas~s y programas
En ambiente de producción, el ideal es que cada capa se encuentre en diferente servidor, a

fin de distribuir la carga de operaciones de la aplicación entre las capas. Sin embargo es
importante que precisemos una cosa: no es la distribución de la aplicación en diferentes
servidores lo que la hace multicapa, sino el aislamiento entre operaciones de diferente na-
turaleza, es decir, en un supuesto determinado, puede haber una aplicación multicapa en la
cual todos los componentes se encuentran en un mismo servidor.
13.1.1 Capa de presentación (Presentation Tier)

La capa de presentación es la capa que provee las interfaces a través de las cuales el usua-
rio fina l podrá interactuar con la aplicación. La responsabilidad de esta capa es proveer
servicios al usuario final, al mismo tiempo que recopila datos completos y correctos para
que el resto de las capas puedan operar sin problemas las funciones de procesamiento,
almacenamiento y explotación de datos.
1
Francisco Salazar (2006). Aplicaciones multicapa y Objetos de Negocios usando tecnología
Microsoft.NET. Aprenda Ediciones. México.
Alfaomega 309
SYNAPS PREMIUM
Para el ambiente Web, lo que generalmente nos encontramos en esta capa es:
1. Un Servidor que tiene instalado un motor de ejecución Web que le permite recibir peti-
ciones (HTTP Request), y responderlas. En el caso de Microsoft, ese motor es liS (In-
ternet lnformation Server).
2. .NET Fremwork, que habilita los ASP.NET Web Services, que controlan el parsing y el
rendering de las páginas, hacen el manejo de estados, controlan el caché, y permiten el
diálogo entre páginas.
3. Los Web Sites, o aplicativos Web, propiamente, lo que representa páginas .aspx,
.master, web.config, archivos complementarios, etcétera.
Para el ambiente Windows, lo que generalmente nos encontramos en esta capa es:
1. Instalaciones locales de la plataforma .NET Framework, en versión compatible a la so-
portada por los aplicativos.
2. Una instalación local de los aplicativos.
En esta capa tiene poca importancia el lenguaje que se utiliza para desarrollar, pues el uso
de lenguaje se limita a mandar llamar clases y codificar comportamientos de los eventos.
13.1.2 Capa de procesamiento (Processing Tier)

La capa de procesamiento es la capa que provee los procesos y la lógica de negocio del
aplicativo. Esta capa tiene la responsabilidad de desarrollar todo proceso que es ordenado
por la capa de presentación, considera los datos previstos por dicha capa, y se encarga de
regresar los resultados a la capa de procesamiento, luego de haber realizado las tareas so-
licitadas.
Para tanto para el ambiente Web como para el ambiente Windows, en esta capa podemos
encontrarnos los siguientes elementos:
1. Un servidor que tiene instalado la plataforma de ejecución para un modelo de pro-
gramación. En el caso de Microsoft, ese modelo de programación es .NET Frame-
work, que habilitará los Windows Forms Services, mismos que son utilizados para
interactuar con las API de Windows, y lograr así el control de los recursos del ser-
vidor y su aprovechamiento.
2. .NET Framework también aporta el modelo de ejecución, a través del CLR (Common
Language Runtime), la compilación JIT Qust in Time) del modelo, y además permite
el acceso directo a todas las clases de BCL (Base Class Library), lo que permite
aprovechar toda la funcionalidad de los lenguajes de .NET.
3. Las librerías de enlazado dinámico (DLL J dynamic link library), que contienen la
programación de lógica de negocios, desarrollados por los programadores del pro-
310 Alfa omega

SYNAPS PREMIUM
yecto, que cumplen con funciones de lectura, escritura y transformación de datos,

además del enlace con la base de datos.
13.1.3 Capa de datos (Data Tier)

La capa de datos es la capa que provee los servicios del manejador de bases de datos. Esta
capa tiene la responsabilidad de recibir peticiones de lectura y escritura de datos, y reali-
zarlas de forma rápida, segura e integrada. Realiza la extracción y procesamiento de datos
utilizando modelos optimizados y arquitecturas especializadas para tal efecto.
Tanto para el Web como para Windows, en esta capa podemos encontrarnos los siguientes
elementos:
1. Un servidor que tiene instalado un motor de bases de datos, que en plataforma Mi-
crosoft se trata de SQL Server, que brindará los servicios de Database Engine y
Analysis Services, entre otros.
2. Provee los objetos de base de datos (bases de datos, tablas, relaciones, vistas, etcé-
tera), y los datos contenidos en los objetos, mismos que están disponibles a través
del Data Provider y adaptador de datos correspondiente.
3. Posee soporte a programación, contando con un interprete de estatutos Transact
SQL, en el caso de instrucciones indicadas manualmente, y además contiene y ejecu-
ta programas precompilados (stored procedures), que proveen el mayor desempe-
ño.
13.2 Implementación de Multicapa con Windows Applications y

SQL Server
13.2.1 Secuencia de implementación

Si se desea implementar un desarrollo multicapa usando Windows Applications y SQL Ser-
ver, se debe hacer lo siguiente:
1. Capa de datos.
a. Se requiere conocer los datos del servidor, a fin de poder establecer el enla-
ce.
b. Se requiere conocer los recursos a utilizar (accesos, tablas, campos, relacio-
nes, etcétera)
c. Se recomienda disponer de un Diagrama de Entidad Relación para poder co-
nocer las dependencias y la integridad de datos en el modelo.
d. Se recomienda disponer de un diccionario de dato que permita conocer los
tipos de datos y los dominios de datos.
Alfaomega 311
SYNAPS PREMIUM
e. Se requiere tener, en la medida de lo posible, toda la codificación que tenga

que ver con datos, en forma de stored procedures, que son procedimientos
precompilados que se almacenan en la misma base.
2. Una vez que se tiene lista la capa de datos, se recomienda preparar la capa de pre-
sentación.
a. Se requiere desarrollar las clases que proveen procesamiento a la base de
datos, en aquellos procesos que no puedan desarrollarse internamente con
los recursos y la programación en capa de datos.
b. Se requiere desarrollar las clases que proveen procesamiento a capa de pre-
sentación.
c. Se requiere desarrollar clases que proveen procesamiento que enlaza la capa
de presentación con la capa de datos.
3. Una vez que se tiene lista la capa de procesamiento, entonces se prepara la capa de
.,
presentac10n.
a. Se requiere desarrollar las interfaces, con sus correspondientes validacio-
nes.
b. Las interfaces deberán consumir la funcionalidad de las clases, ya sea para
procesamientos especiales, o bien para la recuperación y manejo de datos.
13.2.2 Conocimientos requeridos

Si usted personalmente quiere desarrollar cada una de las capas, aquí le mencionamos qué
requiere conocer:
1. Capa de datos.
a. Se requiere tener conocimientos de modelación de bases de datos y norma-
lización.
b. Se requiere conocimientos de administración de SQL Server.
c. Se requieren conocimientos de programación en Transact SQL.
d. Se requieren conocimientos de progr amación de funciones.
2. Capa de presentación.
a. Se requiere dominar un lenguaje de programación .NET
b. Se requiere que conozca programación orientada a objetos.
c. Se requiere que sea capaz de desarrollar y consumir clases.
d. Se requiere conocimientos de ADO.NET.
3. Capa de presentación.
312 Alfa omega

SYNAPS PREMIUM
a. Se requiere tener conocimientos de programación HTML.

b. Se requiere tener conocimientos de ASP.NET, para elaboración de interfaces
con validaciones.
c. Se requiere tener conocimientos de diseño de interfaces que utilizan oríge-
nes de datos.
13.3 Objeto Command

Antes de ver desarrollo multicapa, es necesario que sepamos la forma en que se ejecutan
comandos en ADO.NET, a grandes rasgos. Para ello utilizamos el objeto Command.
El objeto Command, aplicable a cada uno de los proveedores de datos (SqlCommand,
OleDbCommand, y OracleCommand), permite ejecutar un estatuto SQL sobre un almacén
de datos.
Generalmente, el proceso de ejecución de un comando es el siguiente:
1. Abrir una conexión a través de Connection.
2. Generar una instancia de Command.
3. Especificarle a Command sobre qué conexión debe ejecutar el comando.
4. Especificar el comando que se desea ejecutar.
S. Ejecutar el comando.
6. Cerrar la conexión.
Las propiedades más importantes de Command son:

Propiedad Utilidad Valor que almacena
CommandText Retorna o establece el String
procedimiento almace-
nado, la instrucción de
SQL, o la tabla de la que
se extraerán datos. Su
contenido depende de lo
que se especifique en la
propiedad CommandTy-
pe.
CommandType Obtiene o establece un CommandType
valor que indica cómo se • StoredProcedure
interpreta la propiedad • TableDirect
CommandText. • Text
Connection Obtiene o establece el Dependiendo del proveedor de datos:
objeto Connection que • SqlConnection
Alfaomega 313
SYNAPS PREMIUM
utiliza esta instancia de • OleDbConnection

objeto Command. • OracleConnection
Parameters Obtiene el objeto Para- Dependiendo del proveedor de datos:
meterCollection. • SqlParameterCollectio n
• OleDbParameterCollect ion
• OracleParameterCollec tion
Transaction Obtiene o establece del Dependiendo del proveedor de datos:
objeto la Transaction en
• SqlTransaction
la que se ejecuta el obje-
• OleDbTransaction
to Command.
• OracleTransaction
UpdateRowsour- Obtiene o establece la UpdateRowSource
ce manera en que se apli-
• Both
can los resultados de
• FirstReturnedRecord
comando a DataRow • None
cuando lo utiliza el mé- • OutputParameters
todo Update del DbDa-
taAdapter.
13.3.1 Tipos de comandos

Los tipos de comando que se tienen son los siguientes:
Tipo de comando Descripción
StoredProcedure Si lo que se va a ejecutar es un procedimiento almacenado
(Stored Procedure) de SQL Server o de Oracle; en la propiedad
CommandText debe especificarse el nombre del procedimiento
almacenado a ejecutar.
El procedimiento almacenado puede retornar o no valores.
TableDirect Si se desea recuperar el contenido de una tabla o tablas; en la
propiedad CommandText debe especificarse el nombre de la
tabla o tablas a recuperar. Si son más de una, debe propor-
donarse la lista de tablas, separadas por comas, lo que produ-
eirá como resultado la unión Uoin) de las mismas.
Text Si se desea ejecutar una instrucción SQL. En CommandText
debe especificarse una instrucción SQL válida. Dependiendo
del manejador de base de datos, es posible que el dialecto SQL
cambie; deberá ajustarse a las instrucciones SQL reconocidas
por el manejador de bases de datos_que esté utilizando.
En caso de que un comando retorne valores, es necesario que éstos se almacenen en un
objeto contenedor de datos. Un objeto contenedor de datos es aquél, que puede almacenar
datos extraídos a través de un flujo de datos, en una conexión abierta.
Son objetos contenedores de datos DataSet y DataReader.
314 Alfa omega

SYNAPS PREMIUM
13.3.2 Tipos de ejecución de los comandos

Los tipos de ejecución que permite Command son:
Tipo de ejecución Descripción
ExecuteReader Método que ejecuta una consulta que retorna un flujo de
datos, en forma de registros. Este tipo de ejecución uti-
liza a DataReader como contenedor de datos.
ExecuteScalar Método que ejecuta una consulta de valor simple, es de-
cir, un solo datos. Este tipo de ejecución retorna sólo
una fila y una columna; al igual que ExecuteReader,
utiliza a DataReader como contenedor de datos.
ExecuteNonQuery Método que ejecuta una instrucción SQL que no retorna
valores, como puede ser un INSERT, DELETE, o UPDATE.
~ Lab.13.01: Desarrollando la capa de datos

En este laboratorio se utilizará mayormente SQL Server.
Dado que el curso no es de SQL Server, se verán Jos puntos al detalle mínimo y suficiente
para entender el desarrollo multicapa con Windows Applications, sin profundizar mucho
en los temas de dicha plataforma.
La idea central de la aplicación será hacer un actualizador para la tabla que almacena las
tiendas (stores) en la base de datos de prueba (pubs). Se desea que la interfaz recupere
información, permita modificar información, e incluso que permita eliminarla.
a) Conocimiento de la base
De inicio, debemos conocer la información primordial de la instancia de base de datos a la

que nos conectaremos. Eso ya lo conocemos, dados los ejercicios de la unidad anterior,
aunque no está de más que recuerde la información.
a. Nombre de la instancia: - -- - - - - (KNOWLEDGEMGR)
b. Nombre de la base a utilizar: Pubs
e. Cuenta para acceder a la base de datos: - - - - - - - (sa)
d. Contraseña para acceder a la base de datos: - - - - - - - (secreto)
i. Se colocó entre paréntesis la información utilizada en los ejercicios.
Usted debe utilizar la información real del ambiente en el que está
trabajando.
Alfaomega 315
SYNAPS PREMIUM
b) Conocimiento de la tabla a manipular

Ya que tenemos la información de la base de datos, nos centramos en la tabla que hemos
de manipular.
Lo que buscamos es hacer un desarrollo multicapa para actualizar datos en la tabla st ores
de pubs.
La tabla tiene la siguiente especificación:
~OWLEOGEMGR.pubs • dbo.stores
. ~N~ Oa~T~
¡- ·-.
! •'11 i stor _1d char("1)
¡_,_¡
stor _name varchar(10)
stor _addr!SS varchar(10)
dty varchar(20)
stll~ char(2)
zlp char(S)
Esta especificación nos dice mucha información que repercutirá en nuestra programación,
por ejemplo:
a) Podemos determinar los tipos de datos a utilizar en nuestros programas, que en
general son String.
b) Podemos determinar el dominio de los datos, que al ser St r ing, tienen que ver con
el número de posiciones a utilizar.
e) Podemos ver que, excepto la llave primaria, todos los campos pueden ser nulos, lo
que influirá en las validaciones que debemos realizar en capa de presentación.
Es importante tomar en cuenta lo siguiente: las capas deben guardar una concordancia
exacta en cuanto a los tipos y dominios de los datos.
Nunca está de más observar los datos que actualmente posea la tabla, para darnos una
idea en realidad de lo que almacena: Actualmente, la tabla tiene los siguientes datos.
Cl Reds [UJ- ~s 1
1 stor_id stor_name sl()(_address ciy siate ~

1 [~] Eric the Read Books 788 Catamaugus Ave. Seattle WA 98056
2 7066 Bamum's 567 Pasadena Ave. Tustln CA 92789
3 7067 News & Brev.~ 577 Rrst Sl. los Gl!los CA 96745
4 7131 Doc·U·Mat· Oualty l..aLndJy and Books 24-AAvogadro W~ RenUade WA 98014
5 7896 Fncallve Boolahop 89 Madson Sl. Fremori CA 90019
6 8042 Bookbelll 679~5!. POI!Iand OR 89076
316 Alfa omega

SYNAPS PREMIUM
Ya que vimos la estructura y contenido de la tabla, nos resta ver un poco más allá: las
relaciones y dependencias de la tabla son las siguientes:
V ttor_ld
stor_nome
ttor_•dchss
d.y
state
Zlll
Esta información nos hace suponer que:

a) La tabla stores es una tabla fuerte en relación a las tablas sales y discounts, por lo
cual, no se pueden eliminar datos de stores si se tienen registros de
correspondencia en las tablas débiles de la relación (sales y discounts), pues se
generaría falta de integridad en el modelo de datos.
b) Las relaciones admiten opcionalidad, es decir, que no es necesario que al agregar un
registro en stores, necesariamente se deba agregar registros en sus tablas
relacionadas.
e) Creando stored procedures en SQL Server usando Server Explorer
1. Los procedimientos almacenados, llamados generalmente stored procedures, son

programas en Transact SQL que pueden ser invocados como funciones. Cuando a
SQL Server se le solicita la ejecución de cualquier instrucción o programa Transact
SQL, realiza un proceso de parsing, luego optimiza el código, lo precompila, y
entonces lo ejecuta; en el caso de los stored procedures, se almacena el programa
precompilado en la base, por lo que SQL Server ya no somete el código a todo el
proceso de ejecución, mejorando el desempeño.
2. Lo primero que se debe determinar es qué procedimientos almacenados debemos
agregar como parte de nuestra aplicación:
Alfaomega 317
SYNAPS PREMIUM
a. Stores Read: Procedimiento almacenado que se encarga de buscar un

registro en la tabla stores. Se le debe proporcionar la llave primaria del
registro a buscar. Si el registro existe, retornará los datos del registro, si no
existe, retornará valores vacíos del registro.
b. Stores Wri te: Procedimiento almacenado encargado de actualizar o dar de
alta un registro en la tabla stores. Se le deberán proporcionar los datos
correspondientes a los campos del registro, y deberá retornar un estado: 1,
si el registro se agregó satisfactoriamente, por no existir; 2, si el registro
existe, y actualizó los atributos no primos.
c. StoresRemove : Procedimiento almacenado encargado de borrar un registro
de la tabla s tores . Se le debe proporcionar la llave primaria del registro a
eliminar, y deberá retornar un estado: 1, si el registro fue eliminado
satisfactoriamente; 2 si el registro no fue eliminado por no existir; 3, si el
registro no fue eliminado por tener dependencias en tablas débiles.
3. Aprovecharemos la plena integración que tienen las herramientas de desarrollo de
Microsoft, para generar nuestros stored procedures desde Visual Studio.
4. El primer procedimiento almacenado que desarrollaremos es StoresRead, que se
encarga de buscar un registro en la tabla stores. Se le debe proporcionar la llave
primaria del registro a buscar. Si el registro existe, retornará los datos del registro,
si no existe, retornará valores vacíos del registro.
S. En Server Explorer:
a. Identifiquemos la conexión que ya tenemos definida hacia la base de datos
pubs, que tiene el nombre knowledgemgr . pubs. dbo.
b. Expandamos la jerarquía hasta ubicar el nodo Stored Procedures.
c. Utilizando el menú de contexto, seleccionemos la opción Add a new Stored
Procedure.
d. Deberá aparecer en el editor de código el código base para que podamos
desarrollar nuestro procedimiento almacenado.
e. Codifique el siguiente código, cuidando que en la primera línea se
especifique como nombre el de dbo . StoresRead (el código está en el CD de
compañía, como StoresRead. sql):
1 CREATE PROCEDURE dbo.StoresRead
2 (
3 @stor_id char( 4)
4 )
5 AS
6 BEGIN
7 SET NOCOUNT ON
8 select • from stores where stor_id = @stor_id
9 END
f. El código hace lo siguiente:
318 Alfaomega
SYNAPS PREMIUM
i . En la línea 1 se especifica que se quiere crear un stored procedure

llamado dbo . StoredRead.
ii . En caso de que el procedimiento almacenado requiera datos de
entrada, se deberán abrir paréntesis (líneas 2 a 4), y entre ellos, hacer
la lista de los parámetros en un formato @va ria ble tipo
[=Valor] [ NULL] (línea 3); recuerde que todos los parámetros
deberán anteponer@, para ser reconocidos como variables de
usuano.
iii. En caso de que sean varios los parámetros, deberán separarse las
especificaciones por coma.
i v. Si los parámetros tienen valor por omisión, puede hacerse la
especificación igualando a l valor default.
v. Si los parámetros pueden omitirse, puede especificarse utilizando la
palabra NULL.
vi. Al concluir la definición de parámetros, se debe indicar el inicio de la
codificación del procedimiento almacenado: AS (línea 5).
vii. Como el procedimiento generalmente se compone de varias líneas, se
establece un bloq ue de código Transact SQL, que se delimita con
BEGIN... END (línea 6 y 9).
viii . La línea 7 le indica a SQL Server que no retorne como resultado el

conteo de registros involucrados en el procedimiento.
ix . La línea 8 realiza una consulta de todos los campos(*) de la tabla de
tiendas (stores), siempre y cuando se cumpla con la condición de que
el campo stor_id sea igual al valor proporcionado al procedimiento
almacenado en tiempo de ejecución (@stor_id).
g. Guarde el procedimiento almacenado (CTRL+S) y vea en Se rve r Explorer
cómo el stored procedure se ha agregado al servidor.
d) Probando stored procedures desde Visual Studio

h. Seleccione el nodo correspondiente al stored procedure que acaba de
agregar, y utilizando en menú de contexto, seleccione la opción Execute
(CTRL+ALT+FS).
i. Aparecerá la ventana Run Stored Procedure, que nos permitirá proveer los
datos requeridos por el procedimiento almacenado para producir los
resultados.
i . Coloque en Value para @stor_id, el valor 7896.
ii. Presione Ok.
Alfaomega 319
SYNAPS PREMIUM
IWn Storod Proc:odure
¡= Tho .torod procodu~ <(dbo).(StoresRead)> requiros th• tou.,..;,g p1romdm:

Figura 9.1
Diredion Name Vlluo
Ejecución de un In @.tor_id
Stored Procedure
desde Visual
Studio.
( OK 1[ C•ncol
-
j. Aparecerá la herramienta Output Window, en la cual aparecerá el resultado

proporcionado por el stored procedure que hemos desarrollado.
Figura 9.2 tiw~NI i"""

········ rduth:
''" '-.l-.~ 89 ~::tb~ s-:. ,,_or.
........
........................................ ···························-············ ···················· u············ ,.1,
Presentoción de - ,_. ..u~eoc:
u .........~~;
resultados en pon, ........ • . •
r!. ..l~ ,.-u¡; ,. . J.t>t...-u.~ ••J·
Output Window.
DI WBVBVS2012.13.01 - Creando y probando Stored Procedure l .wmv

6. Modifique el stored procedure StoresRead, de tal manera que quede como sigue.
Vea, cómo se modificaron Jos nombres de campo. Posteriormente se explicará por
que.
1 ALTER PROCEDURE dbo.StoresRead

2 (
3 @stor_id char(4)
4 )
S AS
320 Alfa omega

SYNAPS PREMIUM
6 BEGIN
7 SET NOCOUNT ON
8 select stor id As IDTienda,
9 stor_name As NombreTienda,
18 stor_address As DireccionTienda,
11 city As CiudadTienda,
12 state As EstadoTienda,
13 zip As CPTienda
14 from stores
1S where stor_id = @stor_id
16 END
7. El siguiente procedimiento almacenado a desarrollar el denominado StoresWrite:

Procedimiento almacenado encargado de actualizar o dar de alta un registro en la
tabla stores. Se le deberán proporcionar los datos correspondientes a los campos
del registro, y deberá retornar un estado: 1, si el registro se agregó
satisfactoriamente, por no existir; 2, si el registro existe, y actualizó los atributos no
primos. Codifique lo siguiente (el código está en el CD de compañía, como
StoresWrite. sql):
1 CREATE PROCEDURE dbo.StoresWrite
2 (
3 @stor_id char(4),
4 @stor_name varchar(48),
5 @stor_address varchar(48),
6 @city varchar(28),
7 @state char (2) ,
8 @zip char(S)
9 )
18 AS
11 BEGIN
12 SET NOCOUNT ON
13 if not exists (Select * from stores where stor_id = @stor_id)
14 begin
15 -- No existe el registro, aplica INSERT
16 insert into stores
17 (stor_id, stor_name, stor_address, city, state, zip)
18 values
19 (@stor_id, @stor_name, @stor_address, @city, @state, @zip)
28 Select 1 As ValorRetorno
21 end
22 el se
23 begin
24 -- Existe el registro, aplica UPDATE
25 update stores set
26 stor_name = @stor_name,
27 stor_address = @stor_address,
28 city = @city,
29 state = @state,
38 zip = @zip
31 where stor_id = @stor_id
32
34 end
35 END
Alfaomega 321
SYNAPS PREMIUM

a. Declara los parámetros a utilizar, que son las variables privadas
equivalentes a cada uno de los campos que se actualizarán en la base de
datos (líneas 2 a la 9).
b. Si no existe un registro cuyo stor_id sea el proporcionado al procedimiento
almacenado (línea 13), entonces inserta un nuevo registro con los datos
proporcionados (líneas 16 a la 19), y retorna el estado de 1 (línea 20).
c. De lo contrario (línea 22), quiere decir que el registro existe y que no puede
agregarse, sino modificarse, lo cual se hace utilizando los valores
proporcionados, sin incluir los atributos primos (líneas 25 a la 31). Es muy
importante que no olvide la condición de discriminación (línea 31), pues de
no colocarla, actualizará todos los registros de la tabla. Hechas las
modificaciones, se retorna en este caso el estado 2 (línea 33).
9. Guarde el stored procedure, y luego ejecútelo para probarlo. Proporcione los

siguientes datos:
Run Stom! Pro<odure
Tho storod prO<oduro <ldbo).IStorosWrito)> roquiros tholollowing paromot...:
Ty¡>o O.rectten Nomo Voluo

chor In @stor_id 9000
vanhlr In Oslor_namo Aprend1lobrory
VMChar In @stor_address Conocido
varch.lr In C<oty Montorroy
chor In @state Nl
chor In Onp m:ll
OK 11 C.ncol J
'- - -
10. Vea en Output Window que aparece el resumen de la operación, entre ello, el valor
de retorno correspondiente a la acción realizada.
11. Ejecute ahora StoresRead, usando como valor de búsqueda el9000 que acaba de
agregar. Vea cómo el dato está en la base.
IDJ WBVBVS2012.13.02- Creando y probando Stored Procedure 2.wmv
322 Alfa omega

SYNAPS PREMJUM
e) Realizando consultas desde Visual Studio
12. En Server Explorer, dentro del nodo de la conexión, localice el nodo Tables.
13. Expanda la jerarquía y ubique la tabla stores.
14. Seleccione el nodo, y utilizando el menú de contexto, seleccione Show Table Data.
15. Compruebe que el registro que acaba de agregar al probar el stored procedure, está
ahí.
16. Ejecute nuevamente el procedimiento almacenado StoresWrite.
17. En stor _address, modifique el valor, yasigne Ave. Leones 1eee.
18. Recuerde que el procedimiento almacenado, en caso de encontrar el registro, lo
único que hace es modificar los atributos no primos, así que debió haberse
actualizado.
19. Revise nuevamente los datos de la tabla, y compruebe la modificación.
a. Los datos estarán desactualizados, por lo que deberá seleccionar todos los
registros y ejecutar la consulta nuevamente (CTRL+R).
b. Vea cómo ahora sí aparecen los datos actualizados.
20. Cierre el tab que muestra los datos de la tabla.
DI WBVBVS2012.13.03- Consultando datos desde Visual Studio.wmv

21. El siguiente procedimiento almacenado a desarrollar el denominado
StoresRemove, qué es el encargado de borrar un registro de la tabla stores. Se le
debe proporcionar la llave primaria del registro a eliminar, y deberá retornar un
estado: 1, si el registro fue eliminado satisfactoriamente; 2 si el registro no fue
eliminado por no existir; 3, si el registro no fue eliminado por tener dependencias
en tablas débiles (el código está en el CD de compañía, como StoresRemove. sql):
1 CREATE PROCEDURE dbo . StoresRemove
2 (
3 @stor_id char(4)
4 )
5 AS
6 BEGIN
7 SET NOCOUNT ON
8 if not exists (Select * from stores where stor_id = @stor_id)
9 begin
19 -- No existe el registro, no se puede borrar.
12 end
13 else
14 begin
15 if (not exists (select * from sales where stor_id = @stor_id)) and
16 (not exists (select * from discounts where stor id = @stor_id))
Alfaomega 323
SYNAPS PREMIUM
17 begin
18 -- No tiene dependencias con otras tablas, se puede borrar.
19 delete stores where stor_id = @stor_id
21 end
22 else
23 begin
24 -- Tiene dependencias y no puede borrarse
26 end
27 end
28 END

a. Declara los parámetros a utilizar, que es la variable privada equivalente al
atributo primo de la tabla (línea 3).
b. Si no existe un registro cuyo stor_id sea el proporcionado al
procedimiento almacenado (línea 8), entonces el registro no puede ser
borrado, y retorna el estado de 2 (línea 11).
c. De lo contrario (línea 13), quiere decir que el registro existe, y puede
intentarse su eliminación. Si el registro no tiene registros de coincidencia en
sales (línea 15) o en discounts (línea 16), entonces es posible eliminar el
registro.
d. Se borra el registro Qínea 19), y retorna el estad de 1 (línea 20), que indica
borrado satisfactorio. Por el contrario, es decir, que sí tuvo registros de
coincidencia en las tablas relacionadas, retorna el estado de 3 (línea 25).
23. Guarde el stored procedure, y pruebe su funcionamiento.
a. Ejecute el stored procedure y proporcione un stor_id de 9eee, que fue el que
le proporcionamos al registro nuevo con el cual probamos el stored
procedure StoresWri te. El registro se eliminará y se retornará el valor de
retorno 1.
b. Ahora revise los datos contenidos en la tabla stores, y compruebe que el
registro ya no está.
e. Ahora revise los datos de la tabla discounts, y compruebe que tienda tiene
asociado un descuento. Comprobamos que el registro de stores cuyo
stor_id es 8042 no podría eliminarse, dado que tiene registros asociados.
f . Ejecute de nuevo el stored procedure StoresRemove, y proporcione el dato
8842. Vea cómo no se elimina, y se envía el valor de retorno 3.
g. Ejecute de nuevo el stored procedure, y proporcione el dato 9999, mismo que
no existe. Vea cómo no se elimina nada, y se retorna el valor de 2.
24. ¡Felicidades! Ha concluido la capa de datos. En general todo será de esta forma:
cambiarán las consultas y el código, pero en esencia es codificación DML
convencional.
324 Alfa omega

SYNAPS PREMIUM
25. Si no está muy familiarizado con la programación Transact SQL, le recomendamos

libros y cursos que Alfaomega tiene relativo al tema.
FIN DEL EJERCICIO *
~ lab.13.02: Desarrollando la capa de procesamiento

Una vez que se desarrolló la capa de datos, debemos programar la lógica de negocios.
El objetivo de este laboratorio es desarrollar una librería en Visual Basic (DLL), que sea
utilizada por la capa de presentación para ponerse en contacto con la capa de datos (stored
procedures).
Se debe generar una clase que:
a) Declare las propiedades para el manejo de datos.
b) Contenga un método llamado Leer, que se encargue de buscar un registro en la
tabla de tiendas, y en su caso, que lo recupere.
e) Contenga un método llamado Escribir, que se encargue de agregar o actualizar
registros en la tabla de tiendas.
d) Contenga un método llamado Eliminar, que se encargue de eliminar registros de
la tabla de tiendas.
Fuimos cuidadosos en no hacer referencias a la base datos, a sus tablas y campos. De eso se
trata: el aislamiento entre capas debe producir ese efecto. Ni la capa de procesamiento ni
la capa de presentación deben saber nada de la capa de datos, más que los objetos puestos
a disposición para aprovechar funcionalidad (stored procedures). Por cuestión de
seguridad, es muy sano que nadie, más que los responsables de la base de datos, conozcan
de su estructura.
a) Creación de una clase

Class Library.
3. Asigne como nombre TareasBD.
a. Es irrelevante establecer este nuevo proyecto como proyecto de arranque,
pues no posee interfaz.
4. Aparecerá una clase, disponible en Code Editor.
5. Importe los espacios de nombre System.Data y System.Data. SqlClient, pues
requeriremos funcionalidad de bases de datos para la clase.
Alfaomega 325
SYNAPS PREMIUM
DI WBVBVS2012.13.04- Clase y Data namespaces.wmv
b) Agregando propiedades usando Code Snippets
6. En el modelo multicapa con .NET todas las acciones se desarrollan en un esquema

orientado a objetos. En ese sentido, todos los valores se manejan como
propiedades, y todos los procedimientos terminan siendo métodos.
7. Las propiedades que manejaremos son las siguientes:
IDTienda Permite m ar ellO de la tienda.

NombreTienda Permite m arel nombre de la tienda.
DireccionTienda Permite arel nombre de la tienda.
CiudadTienda String Permite manejar el nombre de la ciudad en la cual se
encuentra la tienda.
EstadoTienda String Permite manejar la abreviación del Estado en el cual se
encuentra la tienda.
CPTienda String Permite manejar el código postal del domicilio en el que
se encuentra la tienda.
ConnectionString String Permite manejar la información relacionada con la
cadena de conexión que permite llegar a la base de datos
de manera tica.
ValorRetorno Integer Permite manejar la información del estado retornado
por la capa de datos, Jo que permite manejar los estados
utilizarlos efectos de ción.
8. En Visual Studio se dispone de una herramienta denominada Code Snippets, que

permiten agilizar el proceso de codificación en aquellos casos donde anteriormente
se requería realizar copy-paste de funciones comunes.
9. En el código de TareasBD. vb, colóquese dentro de la clase.
10. Invoque el menú de contexto y seleccione la opción lnsert Snippet..., o bien,
presione CTRL+K, CTRL+X.
a. Seleccione Code Patterns -It For Each, Try Catch, Property, etc.
b. Seleccione Properties, Procedures, Events.
c. Seleccione Define a Property.
11. Aparecerá el código para declarar una propiedad.
326 Alfa omega

SYNAPS PREMIUM
a. Tome en cuenta que cada propiedad se apoya en una variable de trabajo que
permite el manejo de valores al interior de la clase, que posteriormente será
entendido por los elementos externos a través de las propiedades.
b. En Code Snippet se encontrará en la primera definición
(newPropertyValue), que es precisamente la variable de trabajo de su
propiedad.
c. Estando sobre newPropertyValue, escriba piDTienda.
d. Vea cómo en todas las partes donde se encontraba newPrope rtyValue, se
colocará piDTienda.
e. Presione TAB hasta que el cursor se coloque en NewProperty.
f. Estando en NewProperty, escriba IDTienda.
g. Desde este momento, al interior de la clase, manejar la variable piDTienda,
le proporcionará valor a la propiedad a la que sirve, es decir IDTienda.
h. Para los programas que utilicen la clase para la creación de objetos,
piDTienda no será visible, ya que sólo tendrán acceso a la propiedad
IDTienda.
DI WBVBVS2012.13.05 - Propiedad con Code Snippet.wmv

12. De la misma forma que agregó la propiedad IDTienda, agregue el resto de las
propiedades que se encuentran en la tabla del punto 6, usando Code Snippets.
Agregue también otras especificaciones Imports. Al final esta tarea, su código se
.
vera' como s1gue:
1 Imports Microsoft.VisualBasic
2 Imports System.Oata
3 Imports System.Data.SqlClient
4
S Public Class TareasBD
6 Private piDTienda As String
7 Public Property IDTienda() As String
8 Get
9 Return piDTienda
10 End Get
11 Set (ByVal value As String)
12 piDTienda = value
13 End Set
14 End Property
15
16 Private pNombreTienda As String
17 Public Property NombreTienda() As String
18 Get
19 Return pNombreTienda
20 End Get
22 pNombreTienda = value
Alfaomega 327
SYNAPS PREMIUM
23 End Set
24 End Property
25
26 Private pDireccionTienda As String
27 Public Property DireccionTienda() As String
28 Get
29 Return pDireccionTienda
3e End Get
31 Set(ByVal value As String)
32 pDireccionTienda = value
33 End Set
34 End Property
35
36 Private pCiudadTienda As String
37 Public Property CiudadTienda() As String
38 Get
39 Return pCiudadTienda
4e End Get
42 pCíudadTienda = value
43 End Set
44 End Property
45
46 Prívate pEstadoTíenda As Stríng
47 Public Property EstadoTíenda() As Stríng
48 Get
49 Return pEstadoTíenda
se End Get
51 Set(ByVal value As 5tring)
52 pEstadoTienda = value
53 End Set
54 End Property
55
56 Prívate pCPTíenda As String
57 Public Property CPTienda() As String
58 Get
59 Return pCPTienda
Ge End Get
61 Set (ByVal value As Stríng)
62 pCPTienda = value
63 End Set
64 End Property
65
66 Prívate pConnectionString As String
67 Public Property ConnectinString() As String
68 Get
69 Return pConnectionString
7e End Get
72 pConnectionString = value
73 End Set
74 End Property
75
76 Private pValorRetorno As Integer
77 Public Property ValorRetorno() As Integer
78 Get
79 Return pValorRetorno
se End Get
81 Set (ByVal value As Integer)
82 pValorRetorno = value
328 Alfaomega
SYNAPS PREMIUM
83 End Set
84 End Property
85
86
87 End Class
13. Colocar las propiedades es laborioso, pero no complejo. Vea la propiedad

ValorRetorno: le decimos que declare una variable de trabajo (línea 76). Luego
define la propiedad (línea 77); cuando se lea la propiedad (línea 78), el sistema
buscará el valor que tenga la variable de trabajo y lo retornará (línea 79); por otro
lado, cuando se asigne un valor a la propiedad (línea 81 ), el valor asignado deberá
asignarse a la variable de trabajo (línea 82).
14. Básico: Lo que para fuera de la clase es la propiedad, dentro de la clase es la
variable de trabajo. Es por eso que no verá a los métodos de la clase utilizar las
propiedades, de la misma forma que no verá a los programas externos a la clase
utilizar las variables de trabajo.
e) Agregando métodos que usan Command y OataReader
15. Ahora codificaremos el método leer(), que nos permitirá leer registros de la base
de datos.
16. Para entender mejor lo que hace este método, le recomendamos que tenga en la
mente con toda claridad qué es lo que hace el stored procedure StoresRead.
17. Después de la última propiedad que agregó, codifique lo siguiente:
1 Sub Leer()
2 Dim cnn As New SqlConnection (pConnectionString)
3 cnn.Open()
4 Dim cmd As New SqlCommand (String .Format( "EXEC StoresRead '{0}'" , piDTienda), cnn)
S Dim dr As SqlDataReader
6 dr = cmd.ExecuteReader()
7 If dr.HasRows Then
8 If dr.Read() Then
9 pNombreTienda = dr( "NombreTienda" )
10 pDireccionTienda = dr( ''DireccionTienda'' )
11 pCiudadTienda = dr( ''CiudadTienda'' )
12 pEstadoTienda = dr( ''EstadoTienda'' )
13 pCPTienda = dr( ''CPTienda'' )
14 End If
15 Else
16 pNombreTienda = ""
17 pDireccionTienda = ""
18 pCiudadTienda = ""
19 pEstadoTienda = ""
20 pCPTíenda = ""
21 End If
22 dr.Close()
cnn. Close ()
End Sub
Alfaomega 329
SYNAPS PREMIUM
18. Lo que hace este código es lo siguiente:

a. Se declara e instancia una conexión, utilizando como cadena de conexión el
valor que se haya asignado a la propiedad ConnectionString (línea 2).
b. La línea 3 abre la conexión.
c. La línea 4 define un comando que ejecuta el procedimiento almacenado
StoresRead, proporcionándole como parámetro lo que se haya asignado a
la propiedad IDTienda . Obviamente, el comando utiliza la conexión que se
ha abierto previamente.
d. Se define un DataReader, que es un objeto de ADO.NET que permite realizar
lecturas secuenciales de forma muy veloz (línea 5).
e. Se ejecuta el comando, y el resultado se envía al DataReader (línea 6).
i. Es muy importante ver que se usa el método ExecteReader() para
la ejecución del comando.
ii. Este método abre un flujo de datos que sólo puede ser consumido por
objetos que sean de tipo DataReader.
iii. De esta forma, el DataReader puede hacer una lectura secuencial de
los registros que arroje el comando.
f. Valida si la consulta retorna datos -el registro existe- (línea 7).
g. Si es así, el método Read () del objeto DataReader (línea 8) tiene varias
funciones:
i. Retorna falso o verdadero, dependiendo si una lectura de datos
.
. ' o no registros.
arro¡o
ii. Si la lectura arrojó datos, almacena en un buffer el contenido del
primer registro retornado.
m. Si se sigue aplicando el método Read (), cargará de uno por uno en el
buffer los registros, de forma secuencial, en caso de que sean varios,
hasta que la lectura ya no encuentre más registros.
iv. La forma de acceder a un dato del buffer, es simplemente nombrando
el campo original que se haya retornado en la consulta.
h. Si el comando arrojó al menos un registro (línea 8), los valores de los
campos retornados por el stored procedure StoresRead se almacenarán a
las variables de trabajo, y por ende, quedarán disponibles al usuario final a
través de las propiedades (línea 8 a 12).
i. Si la consulta no retorna datos -registro no existe, línea 15-, entonces se
le quita el valor a las propiedades (líneas 16 a la 20).
j. Se cierra el DataReader (línea 14).
k. Se cierra la conexión (línea 15).
330 Alfa omega

SYNAPS PREMIUM
d) Agregando métodos que usan Command con ExecuteScalar
19. Ahora codificaremos el método Escribi r (), que nos permitirá escribir en la base
de datos.
mente con toda claridad qué es lo que hace el stored procedure Stores Wri te.
21. Después del último método que agregó en la clase, agregue otra. Codifique lo
siguiente:
1 Sub Escribir()
3 cnn.Open()
4 Dim cmd As New SqlCommand (String.Format( _
5 ''EXEC StoresWrite '{e}','{l}', '{2}', '{3}','{4}', '{5}''' , _
6 piDTienda, pNombreTienda, pDireccionTienda, pCiudadTienda, pEstadoTienda, _
7 pCPTienda), cnn)
8 pValorRetorno = Cint (cmd.ExecuteScalar())
9 cnn.Close()
1e End Sub
22. Lo que hace este código es lo siguiente:

a. Se declara e instancia una conexión, utilizando como cadena de conexión el
valor que se haya asignado a la propiedad ConnectionString (línea 2).
b. La línea 3 abre la conexión.
c. La línea 4 a la 7 define y declara un comando, que manda ejecutar el stored
procedure llamado StoredWri te; vea cómo se proporcionan todos los
parámetros que requiere. Obviamente, el comando utilizará la conexión que
hemos abierto.
i. Estas líneas pueden ser una, si se eliminan los continuadores de línea
de Visual Basic (ESPACIO +_); colocamos continuadores porque no
cabe en el texto, pero su uso es innecesario.
d. En la línea 8 se asigna el valor de retorno del procedimiento almacenado, a
la variable de trabajo que creamos para manejar los valores de retorno.
1. Note que el método utilizado para ejecutar el comando es
ExecuteScalar( ), que tiene la particularidad de retornar, sin el
apoyo de DataReader, el valor contenido en la primera columna de
la primera fila del resultado regresado por el comando.
ii. En este caso, el stored procedure está preparado para retornar un solo
valor, por lo que ExecuteScalar( ) es bastante adecuado.
23. A fin de cuentas, la propiedad ValorRetorno tendrá el estado regresado por el
stored procedure, lo que nos dará indicios de lo que pasó.
Alfaomega 331
SYNAPS PREMIUM
24. Ahora codificaremos el método Eliminar(), que nos permitirá eliminar registros
de la base.
mente con toda claridad qué es lo que hace el stored procedure StoresRemove.
26. Después del último método que agregó en la clase, agregue otra. Codifique lo
siguiente:
1 Sub Eliminar()
3 cnn.Open()
4 Dim cmd As New SqlCommand (String .Format( "EXEC StoresRemove '{0}'" , piDTienda), cnn)
S pValorRetorno = Cint (cmd.ExecuteScalar())
6 cnn.Close()
7 End Sub
27. En esencia, hace lo mismo que el método Escribir(), a diferencia que ejecuta un
diferente stored procedure, y por tanto, utiliza diferentes parámetros.
28. ¡Felicidades! Ha concluido la capa de procesamiento.
a. Dese cuenta que no necesitó saber absolutamente nada de información de la
base de datos, ni de sus tablas ni de sus campos.
b. Sólo bastó que supiera el nombre de los stored procedures, los parámetros
que requieren y los tipos de datos que usan, y qué retornan.
FIN DEL EJERCICIO*
~ lab.13.03 Desarrollando la capa de presentación

En el presente laboratorio desarrollaremos la capa de presentación de nuestro ejemplo,
que cubrirá las principales funciones de toda buena capa de presentación: a) Recibir la
cantidad mínima, suficiente y necesaria de datos; b) Validar que los datos sea correctos y
completos; e) Que tenga comportamientos que minimicen los errores de captura. Se
utilizará una interfaz de usuario pre-construida -cosa que ya sabe hacer-, y nos
enfocaremos en la programación requerida para consumir la capa de procesamiento desde
una interfaz.
Nuestra aplicación se encargará de recibir los datos, y permitirnos consultar, agregar,
modificar y eliminar registros en una base de datos SQL Server, utilizando las clases que ya
desarrollamos en la capa de procesamiento.
Al final, la interfaz luce como sigue:
332 Alfa omega

SYNAPS PREMIUM
a;l Agr~ga Ti~das
ID de la Tienda: [® ~scar ]
Nombre de la Tienda:
Dirección de la Tienda:
Oudad:
Estado:
Código Postal:
[@Guardar ] (@Eknlnar ] ((!) aro ]
ITooiStripStatuslabelll J3 ...
•
••
~~~~~~~~~~-
-
----·-
a) Agregando proyectos existentes a una solución
1. Todo este texto lo ha venido preparando para la elaboración de una buena capa de
presentación, lo que incluye controles, validaciones, uso de fuentes, etcétera. No nos
detendremos diseñando cosas que ya puede desarrollar usted por su cuenta, sino
que explicaremos la forma en que se integra una interfaz al esquema multicapa.
a. En su CD de compañía vienen pre-construido el proyecto AgregaTiendas, y
se encuentra en el directorio de los archivos complementarios que
corresponden a este capítulo.
b. Desde el sistema operativo, utilice Windows Explorer y copie el directorio
AgregaTiendas al directorio de su solución (Ejercicios), que es donde se
encuentran todos los directorios de los diferentes proyectos que ha
desarrollado.
c. El hecho de que copie el directorio no implica que Visual Studio reconozca el
proyecto.
d. Agregue el proyecto a la solución.
i. Seleccione el nodo principal de su solución, invoque el menú de
contexto, y seleccione la opción Add - Existing Project.
Alfaomega 333
SYNAPS PREMIUM
ii. Vaya al directorio que acaba de copiar, y seleccione el archivo

AgregaTiendas.vbproj
m. En ese momento, habrá integrado el proyecto a su solución.
2. Establezca este proyecto como proyecto de inicio.
3. El formulario Forml. vb (con su correspondiente archivo de código) contiene todos
los controles requeridos para registrar los datos de una tienda. Los objetos
TextBox importantes son:
a. txtiDTienda: Recibe el identificador de la tienda.
b. txtNombreTienda: Recibe el nombre de la tienda.
c. txtDireccionTienda: Recibe la dirección de la tienda.
d. txtCiudadTienda: Recibe la ciudad de la tienda.
e. txtEstadoTienda: Recibe la abreviatura del Estado en el que se localiza la
tienda.
f. txtCPTienda : Recibe el código postal de la tienda.
4. Haga doble die sobre Forml.vb del proyecto, para ponerlo en modo de diseño.
DI WBVBVS2012.13.06- Agregando a solucion proyecto existente.wmv
b) Agregando imágenes y barras de status
5. Casi todo lo que contiene este formulario puede hacerlo usted mismo: Agregar
objetos Label, MaskedTextBox, Button, y modificarle sus propiedades.
6. Una de las novedades de esta interfaz, es que incluye imágenes en los controles
Button, y una barra de estado, lo cual se hace de la siguiente manera (no es
necesario que lo haga, pues ya está hecho; sólo se menciona para que sepa cómo es
que llegamos a ese resultado).
a. En su CD se encuentran archivos de imagen que utilizará. Copie los archivos
Add.png, Find.png, Remove.png, y Up.png.
b. Seleccione el nodo principal de su proyecto, invoque el menú de contexto y
seleccione Add - New Folder, y asigne el nombre lmagenes.
c. Seleccione el Folder que acaba de agregar, invoque el menú de contexto, y
pegue las imágenes que copió.
d. En Toolbox, busque el tab Components, y ubique el componente ImageList;
arrastre el componente a la interfaz, para agregarlo. Como es un elemento
que no se ve en tiempo de ejecución, se agregará en la parte baja del área de
trabajo.
334 Alfa omega

SYNAPS PREMIUM
e. Seleccione lmageList1 y edite sus propiedades.

i. Asegúrese de que lmageSize tiene el valor 16,16 (medidas en pixels).
11. En la propiedad Images, haga die en ..., y aparecerá Images Collection
Editor.
m. Haga die en Add, abra el Folder que creo, y se mostrarán los archivos
que ha copiado.
iv. Selecciónelos todos y haga die en Abrir.
v. Se agregarán a la colección. Como ve, lmageListl controlará las
imágenes y las podrá recuperar mediante el índice que les fue
asignado. Presione Ok.
vi. Tiene que modificar Jo mismo para los cuatro botones, así que los
selecciona en grupo: mantenga presionada la tecla CTRL mientras
hace die en cada uno de los botones.
vii. Estando todos los botones seleccionados, modifique la propiedad
TextAlign, seleccionando MiddleRight.
vm. Ahora seleccione únicamente btnBuscar, y modifique sus
propiedades: En ImageList, seleccione ImageListl. Con ello se indica
que ese botón consumirá una de las imágenes contenidas en
lmageListl. Modifique la propiedad lmagelndex, de tal manera que
seleccione la imagen de la Jupa.
ix. Seleccione btnGuardar, y modifique sus propiedades: En lmageList,
seleccione lmageList1. Modifique la propiedad lmagelndex, de tal
manera que seleccione la imagen del símbolo de más.
x. Seleccione btnEliminar, y modifique sus propiedades: En lmageList,
seleccione lmageListl. Modifique la propiedad lmagelndex, de tal
manera que seleccione la imagen del símbolo de menos.
xi. Seleccione btnOtro, y modifique sus propiedades: En ImageList,
seleccione lmageListl. Modifique la propiedad Imagelndex, de tal
manera que seleccione la imagen del símbolo flech a arriba.
XII. Agréguela a su proyecto copiándolos y pegándolos en Server
Explorer.
7. En Toolbox, seleccione StatusStrip, y agréguelo a la parte baja del formula rio.
8. Indique que quiere que se comporte como StatusLabel.
DI WBVBVS2012.13.07- Imágenes y barras de estado.wmv
Alfaomega 335
SYNAPS PREMIUM
9. Se agregaron otros elementos que tienen que ver más con la lógica de
programación que con el lenguaje.
a. Se tiene un atributo primo y cinco atributos no primos.
b. El atributo primo nos sirve para invocar los datos en función a la llave
. .
pnmana.
c. O está disponible el atributo primo, o los atributos no primos, pero no
ambos.
d. La lógica del programa es la siguiente:
i. Se proporciona el atributo primo, y se busca.
n. Si se encuentra un registro coincidente, se recupera la información de
la base de datos, y se actualizan los atributos no primos. En ese caso,
hacer die en Guardar actualiza los atributos no primos, y hacer die en
Eliminar, elimina el registro, porque existe.
m. Si no se encuentra un registro coincidente, los atributos no primos no
tienen valor y son complementados por el usuario. En ese caso, hacer
die en Guardar agrega un nuevo registro. Eliminar ni siquiera está
disponible, porque el registro ni existe.
iv. En todos los casos, cuando se está editando los atributos no primos,
hacer die en Otro hace que los campos se limpien, y que se pase a
trabajar con el atributo primo, para una nueva búsqueda.
e. Vea los procedimientos NoPrimos, NoPrimosOff, Primos, PrimosOff, además
de Load y TextChanged, que proveen ese comportamiento.
e) Referenciando la clase de capa de procesamiento
10. Ya se desarrolló una clase que actuará como librería de todas aquellas tareas que
tengan que ver con la capa de procesamiento de la aplicación, sin embargo, no está
disponible para una página ni para su código sino hasta que se establece una
referencia que permita utilizarla.
11. Para dejar disponible la clase de la capa de presentación desde Visual Studio:
a. Seleccione el nodo principal del proyecto AgregaTiendas.
b. Invoque el menú de contexto y seleccione Add Reference, con lo que
aparecerá Reference Manager.
c. En la jerarquía, seleccione Solution- Projects.
d. Seleccione TareasBD, asegurándose que se marca el cuadro de verificación, y
presione Ok.
336 Alfa omega

SYNAPS PREMIUM
e. Compruebe que ha agregado la referencia. En la barra de Solution Explorer,

haga clic en Show Al! Files, expanda el nodo References, y compruebe que
TareasBD está ahí.
f. Haga doble clic en cualquier parte del formulario, para que se abra Code
Editor.
g. Vaya al inicio del programa, antes de la definición de la clase, y agregue la
siguiente línea.
Imports TareasBD
h. A partir de este momento la clase de capa de procesamiento estará
disponible para la interfaz.
DI WBVBVS2012.13.08- Referenciando capa de procesamiento.wmv
i. Para simplificar más el código, vaya al inicio del programa y agregue mas
namespaces.
Imports System.Data
Imports System.Data.SqlClient
Imports System.Configuration
d) Instanciando la clase de capa de procesamiento
12. Una vez que se ha importado una librería, las clases que contiene están disponibles
para su uso a través de un objeto.
13. Edite el código del formulario. Dentro de la clase, antes de cualquier procedimiento,
codifique la declaración e instanciación de la variable que nos apoyará en el manejo
de la clase TareasBD.
a. Llámele a la variable MiObjeto.
b. Califique la variable como Publ ic, a fin de que esté disponible para
cualquier procedimiento dentro del programa.
c. A partir de este momento, todas las propiedades y métodos que codificamos
en capa de procesamiento estarán disponibles a través del objeto.
d. La línea a agregar sería como sigue.
Public MiObj eto As New TareasBD.TareasBD( )
Alfaomega 337
SYNAPS PREMIUM
e) Recuperando la cadena de conexión de App.config

14. Abra el archivo de configuración (App.config) del proyecto ConectaPro.
15. Copie la sección <ConectionStrings>, que ya contiene una definición de cadena de
conexión, de nombre ConectaProCS.
16. Ahora a archivo de configuración (App.config) del proyecto que estamos trabajando
(AgregaTiendas).
17. Después de la sección <startup>, copie la sección <ConnectionStrings> que tiene en
memoria.
18. Cambie el nombre de la conexión, de ConectaProCS, a AgregaTiendasCS.
19. El archivo de configuración debe quedar como sigue:
1 <?xml version=''1.0'' encoding=''utf-8'' ?>

2 <configuration>
3 <startup>
4 <supportedRuntime version="v4. a" sku=". NETFramework, Version=v4. S" 1 >
S </startup>
6 <connectionStrings>
7 <add name="AgregaTiendasCS" connectionString="Data Source=KNOWLEDGEMGR;
Initial Catalog=pubs;Persist Security Info=True;User ID=sa;
Password=secreto'' providerName=''System.Data.SqlClient'' />
8 </connectionStrings>
9 </ configuration>
20. Como vamos a requerir recuperar la cadena de conexión del archivo de

configuración, es necesario que agreguemos la referencia de espacio de nombres
System.Configuration a nuestro proyecto. Si no recuerda cómo hacerlo, revise el
siguiente video del capítulo anterior. Obviamente, deberá trabajar las mismas
tareas, pero sobre el proyecto en que nos encontramos.
_, WBVBVS2012.12.05- System.Configuration reference.wmv
21. Use el selector de elementos y elija Forml (events), y en el selector de sub-

elementos, elija Load.
22. Antes de cualquier cosa dentro del procedimiento, recupere la cadena de conexión
que se encuentra en el archivo de configuración, y asígnesela a la propiedad
ConnectionString de nuestro objeto.
338 Alfa omega

SYNAPS PREMIUM
23. El procedimiento de evento deberá quedar como sigue.

1 Prívate Sub Forml_Load(sender As Objeet , e As EventArgs) Handles MyBase .Load
2 Dim Conneetions As ConneetionStringSettingsC olleetion
3 Conneetions = ConfigurationManager.Conn eetionStrings
4
Dim es As String
5
6
es = Conneetions.Item( ''AgregaTiendasCS'' ).ConneetionString
7 MiObjeto.ConneetinString = es
8
9 PrimosOn()
1e NoPrimosOff()
11 ToolStripStatusLabell.Tex t - ''''
End Sub
24. La variable es contendrá contiene la cadena de conexión recuperada del archivo de

configuración. Por otro lado, Mi Objeto es una instancia de la clase TareasBD, y ya
posee la cadena de conexión recuperada, por lo cual podemos intentar conectarnos
a la base de datos utilizando los métodos de nuestro objeto.
f) Buscando información en la base de datos
25. Codifique el evento Click del objeto Buttonl.

1 MiObjeto.IDTienda = txtiDTienda.Text
2 MiObjeto.Leer()
3 txtNombreTienda.Text = MiObjeto.NombreTienda
4 txtDireccionTienda.Text = MiObjeto.DireccionTienda
5 txtCiudadTienda.Text = MiObjeto.CiudadTienda
6 txtEstadoTienda.Text = MiObjeto.EstadoTienda
7 txtCPTienda.Text = MiObjeto.CPTienda
8 PrimosOff()
9 NoPrimosOn()

a. En la línea 1, se asigna a la propiedad IDTienda del objeto, el ID de la tienda
que se haya capturado en la interfaz; esta propiedad es sumamente
importante, puesto que es la utilizada por la clase para buscar registros.
b. En la línea 2, se ejecuta el método Leer(); en caso de que exista un registro
con el ID de tienda especificado, se leerá el registro y sus valores
automáticamente se colocarán en las propiedades del objeto
correspondiente. En el caso de que no se encuentre un registro coincidente,
las propiedades no tendrán valor.
c. En las líneas 3 a la 7, se asigna a la propiedad Text de los cuadros de texto
los valores de las propiedades correspondientes.
d. Inhabilita los campos primos (línea 8) y habilita los campos no primos (línea
9).
Alfaomega 339
SYNAPS PREMIUM
27. Guarde su aplicación y ejecútela.

a. Proporcione un ID de tienda existente, por ejemplo, 8e42.
b. Vea cómo se recuperan los datos y se colocan en la interfaz.
c. Haga die en Otro.
d. Ahora proporcione un ID de tienda que no exista, por ejemplo 99913 .
e. Vea cómo los datos se limpian.
_, WBVBVS2012.13.09- Ejecución multicapa l .wmv
g) Agregando y modificando información en la base de datos
1. Codifique el evento Click del objeto btnGuardar.

1 MiObjeto.IDTienda = txtiDTienda . Text
2 MiObjeto.NombreTienda = txtNombreTienda.Text
3 MiObjeto.DireccionTienda = txtDireccionTienda.Text
4 MiObjeto.CiudadTienda = txtCiudadTienda.Text
5 MiObjeto.EstadoTienda = txtEstadoTienda.Text
6 MiObjeto.CPTienda = txtCPTienda .Text
7 MiObjeto.Escribir()
8 Select Case MiObjeto.ValorRetorno
9 Case 1
1e ToolStripStatuslabell.Text = "Registro agregado"
11 Case 2
12 ToolStripStatuslabell. Text = "Registro actualizado"
13 End Select

a. De la línea 1 a la 6, se asignan a las propiedades de MiObjeto los valores
correspondientes a cada campo, que se hayan capturado en la interfaz.
b. En la línea 7 se realiza la escritura de datos.
c. La propiedad ValorRetorno contiene el valor de estado de la transacción
que proporcionan los procedimientos almacenados de la capa de datos. De la
línea 8 a la 13 se maneja el mensaje informativo, dependiendo del escenario
que se presente.
3. Ejecute la aplicación:
a. Proporcione como ID de tienda 9eel, y presione Buscar. Dado que no se
recupera información, queda claro que el registro no existe.
b. Complemente el resto de la información, de la siguiente manera.
i. Nombre de la tienda: Aprenda Library
ii. Dirección de la tienda: Conocido
340 Alfa omega

iii. Ciudad: Monterrey

iv. Estado: NL
v. Código postal: 64000
c. Presione Guardar. Vea cómo el sistema notifica que se ha agregado un
registro, en la barra de status.
d. Ahora modifique el Domicilio de la tienda, y coloque el valor Ave Leones
1000, y presione el botón Guardar. Vea cómo se notifica la actualización.
e. Haga die en Otro.
f. Escriba en ID de la tienda el valor 804 2 y presione Buscar.
g. Haga die en Otro.
h. Ahora escriba en ID de la tienda el valor 9001 y presione Buscar.
i. Vea cómo el registro está actualizado a la última versión.
DI WBVBVS2012.13.10- Ejecución multicapa 2.wmv
h) Eliminando información en la base de datos
1. Codifique el evento Click del objeto btnEiiminar.

1 MiObjeto.IDTienda = txtiDTienda.Text
2 MiObjeto . Eliminar()
3 Select Case MiObjeto.ValorRetorno
4
Case 1
S
6
ToolStripStatusLabell.Tex t = ''Registro eliminado''
7 Case 2
8 ToolStripStatusLabell.Tex t = ''Registro no existe. ''
9 Case 3
10 ToolStripStatus Labell.Text = ''Registro con dependencias."
11 End Select

a. En la línea 1 proporciona asigna a la propiedad IDTie nda el ID de la tienda
capturado en la interfaz.
b. En la línea 2 se lanza el método Eliminar( ), que pretende remover el
registro correspondiente a la llave proporcionada.
c. De la línea 4 a la 10, se reporta el mensaje correspondiente al escenario que
se haya presentado al intentar la eliminación del registro.
3. Guarde el programa y ejecútelo.
Alfaomega 341
a. Proporcione como ID de tienda, el correspondiente a un registro inexistente.

Intente con 99913. Presione Eliminar y vea cómo el sistema reporta dicha
. .'
s1tuac10n.
b. Proporcione como ID de tienda, el correspondiente a un registro con
dependencias. Intente con 8942, que tiene dependencia en la tabla de
descuentos. Presione Eliminar y vea cómo el sistema reporta dicha
situación.
c. Proporcione como ID de tienda, el correspondiente a un registro existente y
sin dependencias. Intente con 9991, que acaba de agregar. Presione
Eliminar y vea cómo el sistema reporta dicha situación.
d. Proporcione como ID de tienda el 9991. Presione Buscar y vea cómo ya no
existe.
DI WBVBVS2012.13.10- Ejecución multicapa 3.wmv

4. ¡Felicidades! Acaba de terminar de preparar la capa de procesamiento, y con ello,
toda la integración multicapa con ASP.NET, Visual Basic y SQL Server.
5. USTED ESTÁ LISTO PARA DESARROLLAR APLICACIONES WINDOWS CON
ACCESO A DATOS.
FIN DEL EJERCICIO *
~ Lab.13.04 Realizando su propia aplicación

Una empresa de venta de zapatos por catálogo enfrenta un problema: la fuerza de ventas
está molesta porque cuando acuden al centro de distribución de la compañía, no hay
existencia de los zapatos que sus clientes les solicitan. Al menos, dicen, debería haber un
medio que informara de qué zapatos sí hay existencia, a fin de acudir al centro de
distribución sólo cuando se tenga en existencia los modelos, números y colores que
.
reqmeren.
La empresa intentó brindar ese servicio a través de un cal/ center, pero el resultado fue
catastrófico, ya que las líneas telefónicas se saturaban; incrementar el número de personas
atendiendo el call-een ter resultaría muy costoso, así que no era una opción viable.
Entonces alguien pensó en una solución: desarrollar una aplicación Web desde la cual las
personas pudieran consultar la existencia de los modelos, colores y los números
disponibles en existencia en el centro de distribución; se desea también que la aplicación
permita actualizar los inventarios.
342 Alfa omega

El modelo de datos para manejar esa necesidad tiene los siguientes elementos:
Se pueden comercializar zapatos de un determinado modelo, color y tamaño, siempre y

cuando se tengan en existencia.
Los modelos de zapatos pertenecen a diferentes colecciones, que se almacenan en la tabla
Colecciones.
Algo así como:
012011 Otoño Invierno 2011
PV2012 Primavera Verano 2012
E52012 Escolares 2012
Los modelos de zapatos se almacenan en una tabla denominada Modelos.

Algo así como:
2782 Carnival 012011
2732 Rose Free PV2012
8929 Sailor PV2012
Los colores de los zapatos se almacenan en una tabla denominada Colores.

Algo así como:
BC Blanco
NG Negro
BO Blanco Ostión
Los tamaños de los zapatos se almacenan en una tabla denominada Tamanos.

Algo así como:
0300 Tres
0312 Tres y medio
a4a0 Cuatro
Las existencias se controlan a través de una tabla denominada Existencias, que indica
cuántos pares de zapatos se tienen de una determinada combinación de modelo, tamaño y
color.
Algo así como:
2782 0312 BC 20
2782 0312 NG 4
2732 a4aa Be e
Alfaomega 343
No se puede manipular la existencia directamente, sino que se actualiza en función a los

movimientos en inventario que se realizan. Los únicos movimientos permitidos se
almacenan en la tabla TiposMov.
Algo así como:
EII Entrada por inventario inicial 1
EAI Entrada por ajuste de inventario 1
EEP Entrada por embarque de producción 1
EDC Entrada por devolución de cliente 1
SAI Salida por ajuste de inventario -1
SPV Salida por venta -1
SPD Salida por devolución a producción -1
SPP Salida por pérdida o robo -1
El último dato del tipo de movimiento es crucial, pues la Cantidad de zapatos involucrada
en el movimiento, se multiplicará por este factor, mismo que se le sumará a la existencia.
Dese cuenta que, si el tipo de movimiento es una salida, el factor es -1, o sea que si la
existencia es 10, y el movimiento es salida por una Cantidad de 2, se multiplicará por -1 (=
-2), que al sumarse a la existencia dará la nueva existencia: 8.
Los movimientos se registran en la tabla Movimientos. El ID de movimiento es

automático, es decir, la base de datos lo provee.
Algo así como:
0001 0110112012 2 2782 0312 BC SPV
0002 0210112012 10 2732 0400 BC EEP
0003 0210112012 2 2732 0400 BC SPV
En su CD de compañía viene el archivo denominado SuperShoes . sql, que permite la

creación de la base de datos sobre una instancia de SQL Server que tenga disponible.
Abra su instancia de SQL Server y ejecute el script.
344 Alfa omega

A grandes rasgos, el Diagrama de Entidad Relación del modelo quedaría como sigue:
T!pOSMOV
~N._ l)aQ Type Alowtt.ll!s
!DriDOMov dlar{4) r.:J
o-~v varcNr{lO) o
lmpaao El
~""
o
Colecciones
CoumnN..,. o~u Type Alow Nulls 1 Movimientos
IOColecaon chal{6} E] Alo w l'lul!s
' OCo1ecrion vatdw(40} []
ColtmnNlllTW
IOMov~ lnt
O.a. Type
El ' FMov d.te

fJ
f]
~ nt El
IOMoc:leb dw(S) El
1
lDT•~Mno dw(4) El
IOColcr chal(2) El
IDTopoMov cNr(4) D
D
Modelos
Clollr-n ~ ...... Data -ype Alow N-.;ls 1
ID"'ooelo dlar{S) o 1
~ vw..r{40) E] 1<· ~
IDColrcm dlar{6) E]
o Exitencias
., Coltmn Name
IDMoc:lelo cNt(S)
Data Type Alow Nuls
fJ
IOTaJNno cNt(4) f]
'' IOColcr cNt(2) el
Existencia IRt o
. EJ
Tamanos
CoUmnName Data Type Alow NIJis
r, IDTamano dw(4) n
OTaJNno vitdll<(30} El
[J
1
Colores
~N._ Data Type Alow Nul!s
IOColcr chal(2) o
OCoior vw..r{30) o
El
1
'
Alfaomega 345
La aplicación tendrá dos interfaces:

a) Orientada a la fuerza de ventas: Tendrá por objetivo proveerle a la fuerza de
ventas las herramientas que les permitan consultar de forma específica la
existencia en el centro de distribución de un modelo, tamaño y color determinado,
así como ver el listado de existencias de zapatos para una colección determinada.
b) Orientado al personal de inventarios: Tendrá por objetivo proveerle a los
encargados del inventario las herramientas para agregar colecciones, modelos,
colores, tamaños, tipos de movimientos, además de permitir capturar existencias de
zapatos y movimientos. De igual manera, las páginas de consulta disponibles para la
fuerza de ventas, estarán disponibles para el personal de inventarios.
Se requiere:
l. Crear una Aplicación con apariencia limpia y vistosa, de acuerdo a los estándares de
Windows.
2. Deberá crear una aplicación que al menos contenga Jo siguiente:
a. InicioFV: Formulario principal de inicio, que expone ofertas y promociones
que se desea que la fuerza de ventas tenga en cuenta.
b. ConsultaExistencia: Formulario que permite introducir un modelo, un
color y un tamaño, y con base en ello, recibir de la base de datos la
información correspondiente a la existencia.
c. ListadoExistencia: Formulario que permite especificar una determinada
colección, y en base a esa selección, muestre un listado de todos los modelos,
colores y tamaños, con su correspondiente existencia.
3. Deben hacerse formularios para actualización básica de datos:
a. Colecciones: Formulario que permite agregar, actualizar o remover
información de las colecciones en la base de datos.
b. Colores: Formulario que permite agregar, actualizar o remover
información de los colores en la base de datos.
c. Tamanos: Formulario que permite agregar, actualizar o remover
información de los tamaños en la base de datos.
d. TipoMov: Formulario que permite agregar, actualizar o remover
información de los tipos de movimiento en la base de datos.
e. Modelos: Formulario que permite agregar, actualizar o remover
información de los Modelos en la base de datos.
f. Existencias: Formulario que permite agregar, actualizar o remover
información de las existencias en la base de datos.
g. Movimientos : Formulario que permite agregar información de los
movimientos, en la base de datos. Esta tabla no admite actualizaciones ni
eliminaciones.
346 Alfa omega

h. Cons ultaExi st encia: Formulario que permite introducir un modelo, un

color y un tamaño, y con base en ello, recibir de la base de datos la
información correspondiente a la existencia.
i. ListadoExistencia: Formulario que permite especificar una determinada
colección, y en base a esa selección, muestre un listado de todos los modelos,
colores y tamaños, con su correspondiente existencia.
4. En el caso de las páginas que permiten actualizar información:
a. Deberán tener todas las validaciones pertinentes.
b. Deberán tener una distribución proporcionada.
c. Deberán, en el caso de los datos que son llave foránea, manejarlos como
objetos de lista con enlace a datos (ComboBox enlazados), y no en forma de
TextBox.
5. Deberá codificarse una clase general, llamada Shoe sData. vb, que operará la capa
de procesamiento de todo el Web Site.
6. El manejo de la cadena de conexión deberá manejarse a través del archivo
App. config.
7. Todas las actividades en la base de datos deberán ser manejadas a través de stored
procedures, que compondrán la capa de datos.
a. El manejo de la modificación de existencia al registrarse un movimiento
deberá manejarse internamente en la capa de datos.
8. Dejamos a su criterio cuestiones de diseño y operación.
La suerte es donde coincide la capacidad y la oportunidad.

¡Mucha Suerte!
FIN DEL EJERCI CIO~·
Alfaomega 347

Aprenda Visual Basic 2012

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Aprenda Visual Basic 2012

Enviado por

Direitos autorais:

Formatos disponíveis

ren

Aprenda Practicando VIsual

Aprenda Practicando Visual Basic usando Visual Studio 2012

© 2013 Alfaomega Grupo Editor, S.A. de C.V.

Miembro de la Cámara Nacional de la Industria Editorial Mexicana

Pág. Web: http://www.alfaomega.com.mx

Derechos reser vados:

Empresas del grupo:

1: La plataforma Microsoft .NET

2: Ambiente de trabajo usando Visual Studio 2012

3: Variables, Arreglos y Tipos de datos

3.4.1 Declaración de variables ................................................................................................................... 47

~ Lab.04.03: Inspección de código y variables ....................................................................................... 93

6: Estructuras de Decisión y Control

6.1.1 Estatuto IfThen Else (condicional) ........................................................................................... 127

7: Manejo Estructurado de Excepciones

9: Programación Orientada a Objetos

9.3.2 Definición de propiedades ............................................................................................................. 203

10: Herencia y Polimorfismo de Clases

e) Clase derivada con sustitución .........................................................................................................236

11: Interfaces de Usuario con Windows Applications

xii Alfa omega

a) Seleccionando los controles adecuados ....................................................................................... 269

12: Explotación de Datos usando ADO.NET

Alfa omega xiii

13: Multicapa con Visual Basic, Windows Applications y SQ_l Server

Acerca del autor

Contexto del curso

APCP: Microsoft .NET Developer

Fundamentos de .NET Framework y Visual Studio

Desarrollo de aplicaciones con acceso a datos usando

Requerimientos del curso

El libro se acompaña con un CD de compañía, mismo que puede descargarse a

El libro no acompaña la media física. Si desea tener un disco físico, puede

Este CD de compañía contiene lo siguiente:

Para docentes, contamos con recursos adicionales, como presentaciones en

Alfa omega xix

Descripción de las unidades

3. Contenido teórico. Es el marco teórico de conocimientos que nos

Indica que hay en el CD de compañía un video clip que muestra la eje-

1 Parte Nivel / habilidades requeridas Unidades correspondientes a la parte

Alfa omega xxi

Programación Intermedio 9. Programación Orientada a Objetos.

Cómo utilizar el libro

a. Sugerimos que los laboratorios con instrucciones detalladas los

La Plataforma Microsoft .NET

1: La Plataforma Microsoft .NET

1.1 Definiendo a la plataforma .NET

1.1.1 ¿Qué es Microsoft .NET?

La plataforma Microsoft .NET es la alternativa que Microsoft propone al mercado para el

1.1.2 Historia de versiones de .NET

13 Febrero 2002 Visual Studio .NET Tablet Media Center Editions

Nótese cómo en algunas ocasiones el cambio de un producto no implicó el cambio de otro:

1.1.3 Instalaciones de .NET

1.1.4 ¿Cómo funciona .NET?

1. Utilizando Microsoft Visual Studio, generamos gráficamente programas de código fuen-

1.1.5 Principales capas de Microsoft . NET Framework

Las principales capas de Microsoft .NET Framework son las siguientes:

ASP.NET Windows ADO.NET

l. Capa de lenguajes. La capa de lenguajes es la capa compuesta por el CLS y todos

2. . NET Framework {Infraestructura y servicios). Se conoce como .NET Frame-

i. Es importante mencionar que la gran cantidad de clases están orga-

1.2 Entendiendo a los lenguajes .NET

1.2.1 ¿Qué es un lenguaje .NET?