Documentos de Académico
Documentos de Profesional
Documentos de Cultura
NET
Luis Miguel Blanco
Responsable de la edicin Coordinacin de la edicin
Paco Marn (fmarin@eidos.es) Antonio Quirs (aquiros@eidos.es)
Autoedicin
Magdalena Marn (mmarin@eidos.es) Luis Miguel Blanco (lmblanco@eidos.es)
Grupo EIDOS
C/ Tllez 30 Oficina 2
28007-Madrid (Espaa)
Tel: 91 5013234 Fax: 91 (34) 5017824
www.grupoeidos.com/www.eidos.es
www.LaLibreriaDigital.com
A Olga y David, por las horas que les he robado para escribir este texto que ahora tienes en tus manos
A mis padres
ndice
NDICE............................................................................................................................ 7
INTRODUCCIN........................................................................................................ 21
UNA VERSIN LARGO TIEMPO ESPERADA......................................................... 21
AQUELLOS DIFCILES TIEMPOS DE LA PROGRAMACIN EN WINDOWS .... 22
SLO PARA LOS ELEGIDOS ..................................................................................... 22
EL PROYECTO THUNDER ....................................................................................................................................23
UN PRODUCTO REVOLUCIONARIO...................................................................................................................23
EL PASO A OLE Y ODBC ........................................................................................................... 23
PASO A 32 BITS Y ORIENTACIN A OBJETO ..................................................................................................23
ACTIVEX Y ADO ....................................................................................................................... 24
PROGRAMACIN EN INTERNET ........................................................................................................................24
LOS PROBLEMAS PARA EL DESARROLLO EN LA RED.................................................................................25
EL PANORAMA ACTUAL......................................................................................................................................25
LAS SOLUCIONES APORTADAS POR VB.NET ............................................................................. 25
EL PRECIO DE LA RENOVACIN........................................................................................................................25
COMENZAMOS.......................................................................................................................................................26
LA EVOLUCIN HACIA .NET ................................................................................ 27
LAS RAZONES DEL CAMBIO...............................................................................................................................27
LA DIFCIL DECISIN DE ABANDONAR ANTERIORES TECNOLOGAS .....................................................28
LA PROBLEMTICA DE WINDOWS DNA .................................................................................... 28
ASP................................................................................................................................. 28
ADO ............................................................................................................................... 28
VISUAL BASIC .......................................................................................................................................................29
UNA
PUNTUALIZACIN
SOBRE
LOS
EVENTOS..................................................................................
110
112
113
114
114
LA
PGINA
INICIO.......................................................................................................................
DE
114
116
117
119
EL
EXPLORADOR
Agregar
nuevos
Propiedades
Propiedades
Agregar
EL
MEN
SOLUCIONES...................................................................................................
DE
elementos
del
de
proyectos
la
..............................................................................
un
proyecto....................................................................................
124
126
proyecto............................................................................................................
127
solucin
.........................................................................................................
128
solucin...............................................................................................
128
CONTEXTUAL
una
...................................................................................................................
130
130
131
EL
CUADRO
DE
Organizacin
en
HERRAMIENTAS......................................................................................................
135
fichas................................................................................................................
136
Manipulacin
de
fichas
Organizacin
de
Manipulacin
de
Agregar
...............................................................................................................
137
controles
..........................................................................................................
137
controles
..........................................................................................................
139
controles........................................................................................................................
140
LAS
BARRAS
Barras
Acople
DE
de
de
HERRAMIENTAS.....................................................................................................
herramientas
barras
de
personalizadas......................................................................................
herramientas
..............................................................................................
142
143
145
145
VENTANA
146
DE
RESULTADOS
.............................................................................................................
147
Ajuste
148
de
fuente
Nmeros
de
Bsqueda
Ajuste
de
Dividir
el
color
...............................................................................................................
lnea.........................................................................................................................
sustitucin
lnea
editor
Marcadores
Mostrar
cdigo................................................................................................
149
.............................................................................................................................
151
de
de
cdigo
..........................................................................................................
.................................................................................................................................
espacios
149
en
blanco
........................................................................................................
152
153
154
Esquematizacin..........................................................................................................................
154
Regiones
155
Comentarios
......................................................................................................................................
de
cdigo
en
bloque
...............................................................................................
156
IntelliSense
Cambiar
..................................................................................................................................
maysculas
minsculas
..........................................................................................
156
158
EDITORES
LISTA
DE
DE
IMGENES..................................................................................................................
TAREAS
............................................................................................................................
Definicin
de
smbolos
Creacin
de
tareas
Ventana
Lista
Eliminacin
MOSTRAR
de
de
LA
para
tareas.............................................................................................
......................................................................................................................
tareas
...............................................................................................................
159
160
161
161
162
tareas..................................................................................................................
163
COMPLETA...............................................................................................
163
PANTALLA
VISTA
LA
CLASES.......................................................................................................................
DE
163
164
MACROS
165
El
..........................................................................................................................................
Explorador
Ejecucin
de
Grabacin
de
Manipulacin
El
de
IDE
de
Escritura
de
Macro
EL
para
SISTEMA
Ayuda
Contenido
de
macros
............................................................................................................
166
macros
...................................................................................................................
167
macros
..................................................................................................................
167
proyectos
macros
macros
comentar
DE
macros........................................................................................
168
........................................................................................................................
169
....................................................................................................................
170
lneas
de
de
cdigo
determinadas................................................................
AYUDA....................................................................................................................
172
173
dinmica...........................................................................................................................
174
....................................................................................................................................
175
ndice
...........................................................................................................................................
176
Buscar..........................................................................................................................................
177
Ayuda
178
externa..............................................................................................................................
Mantener
temas
de
ayuda
disponibles
........................................................................................
179
APLICACIONES
...................................................................................................
181
181
LA
CONSOLA
CONSOLE.........................................................................................................................
CLASE
ESCRITURA
DE
DE
INFORMACIN
.........................................................................................................
LECTURA
DE
INFORMACIN
............................................................................................................
182
183
185
187
EL
LENGUAJE
.................................................................................................................................
189
189
......................................................................................
190
191
VARIABLES
......................................................................................................................................
191
Declaracin
.................................................................................................................................
191
.............................................................................................................................
192
Denominacin
Lugar
de
la
declaracin
..............................................................................................................
192
Tipificacin..................................................................................................................................
193
Declaracin
195
mltiple
en
lnea
.....................................................................................................
Asignacin
de
Valor
inicial.................................................................................................................................
Declaracin
obligatoria
Tipificacin
ARRAYS,
valor.....................................................................................................................
..............................................................................................................
obligatoria...............................................................................................................
CONCEPTOS
Declaracin
Asignacin
obtencin
de
un
CONSTANTES
CONCEPTOS
.......................................................................................................
.................................................................................................................................
Modificacin
Recorrer
BSICOS
de
tamao
valores
..............................................................................................
..............................................................................................................
array........................................................................................................................
...................................................................................................................................
MNIMOS
OPERADORES
DEL
SOBRE
DEPURACIN.....................................................................................
LENGUAJE
.................................................................................................
195
197
198
201
203
203
204
205
206
206
208
211
..................................................................................................................................
ARITMTICOS
Potenciacin:
^............................................................................................................................
Multiplicacin:
Divisin
real:
Divisin
entera:
Resto:
Mod
Suma:
Resta:
/............................................................................................................................
\........................................................................................................................
real:
213
213
^=
Multiplicacin:
212
......................................................................................................................................
&,
ABREVIADOS
Potencia:
212
213
.......................................................................................................................................
OPERADORES
211
.................................................................................................................................
CONCATENACIN:
Divisin
........................................................................................................................
211
..................................................................................................................
DE
ASIGNACIN...................................................................................
...............................................................................................................................
*=
.....................................................................................................................
/=.........................................................................................................................
214
215
215
215
216
216
Divisin
entera:
Suma:
+=
Resta:
\=
.....................................................................................................................
216
...................................................................................................................................
217
-=.....................................................................................................................................
217
Concatenacin:
&=....................................................................................................................
218
COMPARACIN
................................................................................................................................
218
Comparacin
de
cadenas
La
Asc(
La
funcin
funcin
Chr(
............................................................................................................
219
.........................................................................................................................
220
).........................................................................................................................
221
Comparacin
de
objetos.
El
operador
Is
....................................................................................
224
225
And
225
..............................................................................................................................................
Not
...............................................................................................................................................
227
Or
................................................................................................................................................
228
Xor
...............................................................................................................................................
229
.......................................................................................................................................
230
AndAlso
OrElse..........................................................................................................................................
PRIORIDAD
DE
OPERADORES
...........................................................................................................
231
231
233
RUTINAS
CDIGO...................................................................................................................
235
235
236
DE
PROCEDIMIENTOS............................................................................................................................
236
Sintaxis
de
un
procedimiento
Sub................................................................................................
237
Llamada
un
procedimiento
Sub................................................................................................
238
Sintaxis
de
un
procedimiento
Function
.......................................................................................
238
Llamada
un
procedimiento
Function
.......................................................................................
240
procedimientos
........................................................................................
241
firma
procedimiento....................................................................
241
.....................................................................................................
241
Paso
de
parmetros
Protocolo
de
Tipo
dato
de
llamada
de
un
de
parmetro
un
Paso
por
valor
(ByVal)
Paso
por
referencia
............................................................................................................
(ByRef)
....................................................................................................
242
243
Parmetros
Array
opcionales................................................................................................................
de
parmetros
Sobrecarga
de
...................................................................................................................
procedimientos
....................................................................................................
245
246
247
ESTRUCTURAS
DE
CONTROL............................................................................................................
253
Seleccin......................................................................................................................................
253
If
253
...End
Select
If
Case
.................................................................................................................................
...End
Select
..........................................................................................................
257
Repeticin....................................................................................................................................
259
While
259
...End
While
...................................................................................................................
Do
260
...Loop.................................................................................................................................
For
...Next.................................................................................................................................
For
Each
...Next........................................................................................................................
262
264
265
Agregar
266
un
nuevo
mdulo
(y
fichero)
de
cdigo.........................................................................
Excluir
REGLAS
eliminar
DE
ficheros
de
MBITO.........................................................................................................................
270
271
mbito
de
Pblico
procedimientos
.....................................................................................................................................
Privado
....................................................................................................................................
mbito
mbito
mbito
mbito
mbito
...........................................................................................................
de
de
274
procedimiento
de
de
nivel
273
274
nivel
nivel
271
variables.....................................................................................................................
nivel
271
bloque
mdulo
de
proyecto
............................................................................................
........................................................................................................
275
.......................................................................................................
276
.....................................................................................................
277
278
VARIABLES
278
STATIC
FUNCIONES
CONVENCIONES
.........................................................................................................................
COMPLEMENTARIAS
DE
DEL
LENGUAJE...........................................................
NOTACIN........................................................................................................
281
281
283
FUNCIONES
DEL
LENGUAJE
.............................................................................................................
285
Numricas....................................................................................................................................
285
Cadena
de
caracteres
286
Fecha
hora................................................................................................................................
..................................................................................................................
292
292
PROGRAMACIN
295
ORIENTADA
OBJETO
(OOP)................................................................
295
295
295
297
OBJETOS
298
..........................................................................................................................................
CLASES
............................................................................................................................................
298
299
300
Abstraccin..................................................................................................................................
300
Encapsulacin
.............................................................................................................................
300
Polimorfismo
...............................................................................................................................
301
......................................................................................................................................
301
Herencia
JERARQUAS
RELACIONES
Herencia
DE
CLASES
ENTRE
..................................................................................................................
OBJETOS..........................................................................................................
......................................................................................................................................
302
302
302
Pertenencia..................................................................................................................................
303
Utilizacin
303
...................................................................................................................................
REUTILIZACIN
...............................................................................................................................
CREACIN
DE
CLASES......................................................................................................................
303
303
304
305
306
306
...........................................................................................................
306
307
307
308
309
INSTANCIACIN
DE
OBJETOS
310
310
312
PROPIEDADES
VIRTUALES
...............................................................................................................
PROPIEDADES
PREDETERMINADAS..................................................................................................
314
315
316
317
319
323
LA
ESTRUCTURA
WITH...END
..........................................................
WITH................................................................................................
325
325
326
327
329
Enlace
329
Enlace
temprano..........................................................................................................................
tardo
...............................................................................................................................
..........................................................................................
330
333
337
CONSTRUCTORES
341
MTODOS
HERENCIA...............................................................................................
CONSTRUCTORES............................................................................................................
341
HERENCIA........................................................................................................................................
343
344
345
Protected
.....................................................................................................................................
346
..........................................................................................................................................
347
Friend..........................................................................................................................
348
Friend
Protected
348
350
350
353
355
COMPORTAMIENTO
ESCRITURA
HERENCIA
DE
DE
LAS
PALABRAS
CLAVE
ME,
MYCLASS
MYBASE
ANTE
LA
MTODOS.................................................................................................................
MTODOS
CONSTRUCTORES........................................................................................
SOBRE-
359
360
362
362
ELEMENTOS
365
COMPARTIDOS
INTERFACES
......................................................................
365
368
370
371
INTERFACES.....................................................................................................................................
373
ESTRUCTURAS
378
Creacin
Estructuras
La
.................................................................................................................................
manipulacin
estructura
clases,
cul
del
sistema
de
estructuras.....................................................................................
debemos
utilizar?
............................................................................
DateTime............................................................................................
378
380
382
ENUMERACIONES
............................................................................................................................
383
387
388
393
394
LA
ESTRUCTURA
CHAR
...................................................................................................................
395
....................................................................................................................
396
396
FORMATEO
397
DE
VALORES
.................................................................................................................
Fechas
.........................................................................................................................................
398
Modificando
el
400
formato
estndar
para
las
fechas.......................................................................
Nmeros
......................................................................................................................................
402
Formateando
directamente
...................................................................................
403
formatear
.......................................................................................
403
formatos
personalizados..............................................................
403
Usando
la
clase
Usando
una
clase
DELEGACIN
DELEGADOS
DE
para
para
DE
DE
crear
CDIGO
(DELEGATES)
DECLARACIN
CREACIN
String
en
consola
EVENTOS..................................................................................407
..............................................................................................................
407
.......................................................................................................
407
..............................................................................................................
408
DELEGADOS
DELEGADOS
la
411
414
EVENTOS
EN
.NET
...........................................................................................................................
414
PROGRAMACIN
ESTRICTAMENTE
PROCEDURAL............................................................................
414
414
PROGRAMACIN
415
BASADA
EN
EVENTOS...........................................................................................
415
416
417
417
418
420
421
LA CLASE EVENTARGS, O CMO OBTENER INFORMACIN DEL OBJETO EMISOR DEL EVENTO.......
422
ARRAYS
ASPECTOS
LA
CLASE
............................................................................................................................................
BSICOS
ARRAY
427
.........................................................................................................................
427
............................................................................................................................
428
.....................
428
Todos
los
arrays
son
dinmicos
..................................................................................................
429
DECLARACIN.................................................................................................................................
430
431
RECORRER
431
EL
MODIFICACIN
CONTENIDO
DE
..............................................................................................................
TAMAO............................................................................................................
433
.............................................................................................................................................
434
435
CLONACIN
435
.....................................................................................................................................
COPIA...............................................................................................................................................
436
INICIALIZACIN
437
DE
VALORES
..........................................................................................................
ORDENACIN...................................................................................................................................
439
BSQUEDA.......................................................................................................................................
439
ARRAYS
MULTIDIMENSIONALES
COLECCIONES
.....................................................................................................
...............................................................................................................................
440
443
443
444
444
LA
445
ARRAYLIST.....................................................................................................................
CLASE
Instanciacin
de
Agregar
valores
Recorrer
Capacidad
objetos
obtener
un
valores
valores
en
ArrayList..............................................................................................
445
ArrayList...................................................................................................
445
de
una
un
ArrayList................................................................................
coleccin
ArrayList........................................................................
446
447
Bsquedas
en
colecciones
ArrayList
...........................................................................................
451
Ordenar
LA
elementos
CLASE
en
HASHTABLE
un
objeto
ArrayList
.................................................................................
....................................................................................................................
453
453
Manejo
bsico
Operaciones
de
varias
colecciones
con
Hashtable....................................................................................453
colecciones
Hashtable..........................................................................
455
Traspaso de elementos desde una coleccin Hashtable a un array bsico ................................ 457
LA
LA
CLASE
SORTEDLIST....................................................................................................................
458
CLASE
QUEUE.............................................................................................................................
459
de
459
Manipulacin
LA
CLASE
valores
STACK
COLECCIONES
en
una
coleccin
Queue......................................................................
.............................................................................................................................
462
PERSONALIZADAS..........................................................................................
465
465
465
467
MANIPULACIN
473
DE
ERRORES..................................................................................................
ERRORES,
ESE
MAL
COMN.............................................................................................................
473
Errores
de
escritura
....................................................................................................................
473
Errores
de
ejecucin
...................................................................................................................
474
Errores
lgicos
ERRORES
............................................................................................................................
EXCEPCIONES................................................................................................................
MANIPULADORES
DE
EXCEPCIONES
................................................................................................
474
474
475
475
475
La
475
La
estructura
clase
Try...End
Try.........................................................................................................
Exception.......................................................................................................................
478
Creacin
de
excepciones
MANIPULACIN
NO
personalizadas
ESTRUCTURADA
DE
....................................................................................
484
ERRORES..........................................................................
486
El
objeto
Err................................................................................................................................
486
On
Error
......................................................................................................................................
486
On
Error
Goto
On
Error
Resume
Etiqueta
..............................................................................................................
486
Next
................................................................................................................
487
Creacin de errores
On
Error
Goto
..........................................................................................................................
488
491
491
SYSTEM.IO,
OBJETOS
EL
PUNTO
DE
PARTIDA.................................................................................................
STREAM............................................................................................................................
491
492
492
LA
492
LA
CLASE
CLASE
STREAMWRITER
.............................................................................................................
STREAMREADER.............................................................................................................
494
496
496
LA
CLASE
MANEJO
DE
FILESTREAM
DATOS
............................................................................................
...................................................................................................................
496
BINARIOS..........................................................................................................
498
498
500
LA
CLASE
PATH
...............................................................................................................................
502
503
Consideraciones
sobre
la
ruta
de
archivos
.................................................................................
506
507
507
FORMULARIOS
.........................................................................................................
509
509
SYSTEM.WINDOWS.FORMS
510
LA
.............................................................................................................
..............................................................................................................................
510
510
CLASE
FORM
WINDOWS
512
513
514
515
TRABAJO
EL
CONTROLES..............................................................................................................
CON
CUADRO
........................................................................................
DE
HERRAMIENTAS......................................................................................................
517
517
518
519
ORGANIZACIN-FORMATO
520
ANCLAJE
ACOPLE
DE
DE
MLTIPLE
DE
CONTROLES....................................................................
CONTROLES.................................................................................................................
CONTROLES
..................................................................................................................
522
523
CONTROLES
CONTROLES
BUTTON
WINDOWS
MS
..............................................................................................................
HABITUALES........................................................................................................
...........................................................................................................................................
525
525
526
527
528
.........................................................................................................................................................
530
ESCRITURA DEL MANIPULADOR DE EVENTO SIN USAR EL NOMBRE PROPORCIONADO POR EL EDITOR
RESPONDIENDO
LOS
EVENTOS
DE
UN
FORMULARIO
....................................................................
LABEL..............................................................................................................................................
FOCO
DE
ENTRADA
..........................................................................................................................
530
531
532
TEXTBOX.........................................................................................................................................
532
535
535
CHECKBOX......................................................................................................................................
538
RADIOBUTTON
540
LISTBOX
GROUPBOX
.........................................................................................................
..........................................................................................................................................
542
.....................................................................................................................................
547
COMBOBOX
COMPARTIENDO
CDIGO
ENTRE
CONTROLES..................................................................................
549
553
Cdigo
553
para
el
interfaz
de
usuario..............................................................................................
Cdigo para eventos del formulario, conectando con Handles .................................................. 555
Cdigo
para
eventos de
controles,
conectando
con
Handles......................................................
555
...........................................................................................................................
...........................................................................................................................
TEMPORIZADORES
557
559
560
563
HERENCIA
...........................................................................................................................
565
base.......................................................................................................................
566
El
VISUAL
formulario
Crear
un formulario heredado
desde
un
proyecto
independiente............................................... 570
MENS
..............................................................................................................................................
575
CONTROLES
DE
.............................................................................................................
575
Men
Men
Creacin
TIPO
Principal.
Contextual.
de
mens
MEN
MainMenu
........................................................................................................
ContextMenu..................................................................................................
desde
cdigo
................................................................................................
575
580
582
PROGRAMACIN
CON
HEBRAS
...............................................................................................
LA
CLASE
THREAD
..........................................................................................................................
585
585
586
586
CONTROL
INDEFINIDOS.............................................................................................
588
................................................................................................................
590
EJECUCIN
DE
PROCESOS
MULTIHEBRA
591
593
594
SINCRONIZACIN
596
DE
HEBRAS..........................................................................................................
597
599
........................................................................................................
601
.......................................................................................................
601
604
.............................................................
606
...........................................................................
607
608
COMPORTAMIENTO
MODAL
DE
FORMULARIOS...............................................................................
608
611
ColorDialog
................................................................................................................................
611
FontDialog
..................................................................................................................................
612
SaveFileDialog............................................................................................................................
614
OpenFileDialog...........................................................................................................................
615
VALIDACIN
CONTROLES
DE
617
CONTROLES...........................................................................................................
626
................................................................................................................
627
AVANZADOS
IMAGELIST.......................................................................................................................................
628
TOOLBAR.........................................................................................................................................
629
STATUSBAR.....................................................................................................................................
631
DATETIMEPICKER
...........................................................................................................................
633
NUMERICUPDOWN..........................................................................................................................
634
DOMAINUPDOWN............................................................................................................................
635
MONTHCALENDAR
635
..........................................................................................................................
LINKLABEL......................................................................................................................................
636
637
NOTIFYICON
638
....................................................................................................................................
SYSTEM.DRAWING
..........................................................................................................................
642
642
LA
646
CLASE
BRUSH.............................................................................................................................
649
650
Empleo
del
control
PictureBox
...................................................................................................
651
652
655
656
.............................................................................................
664
.............................................................................................................
666
Interoperabilidad.........................................................................................................................
666
Mantenimiento.............................................................................................................................
666
Programacin..............................................................................................................................
666
Rendimiento.................................................................................................................................
667
Escalabilidad...............................................................................................................................
667
667
DataSet
669
ADO
........................................................................................................................................
.NET
XML........................................................................................................................
669
.............................................................................................
670
671
LAS
CLASES
CONNECTION...............................................................................................................
673
LAS
CLASES
COMMAND...................................................................................................................
676
LAS
CLASES
DATAREADER
.............................................................................................................
680
LA
LAS
CLASE
CLASES
DATASET
........................................................................................................................
DATAADAPTER
...........................................................................................................
683
686
689
694
Tipos
694
de
Elementos
Data
Binding.................................................................................................................
integrantes en
un
proceso
de
Data
Binding...............................................................
694
694
DATAGRID.......................................................................................................................................
701
703
708
708
710
711
Obtener
tablas
relacionadas
mediante
cdigo............................................................................
711
Mostrar
una
relacin
maestro-detalle
en
dos
DataGrid.............................................................
714
715
716
717
718
BSQUEDAS
CON
DATAVIEW..........................................................................................................
720
721
723
Introduccin
Una versin largo tiempo esperada
Con la aparicin de .NET Framework, y de Visual Basic .NET, como una de las herramientas estrella para el
desarrollo sobre esta nueva plataforma de trabajo, estamos asistiendo a una evolucin/revolucin sin precedentes en el
mundo de la informtica, que sita a este clsico de la programacin en una posicin difcil de igualar y menos an de
superar.
Visual Basic .NET (VB.NET a partir de ahora), como cada nueva versin de las que han aparecido en el
mercado de este producto, incorpora, como es natural, un buen conjunto de novedades. Sin embargo, la inclusin de
Visual Basic en el entorno de .NET, aade tambin un compendio de drsticos cambios para los programadores de
versiones anteriores, derivados en su conjunto, de la necesidad de afrontar con garantas de xito el desarrollo de la
nueva generacin de aplicaciones para Internet, objetivo perseguido por todas las herramientas de desarrollo actuales.
Tales cambios, como decimos, son necesarios para la plena integracin de Visual Basic con el resto de lenguajes
del entorno de .NET; un alto porcentaje, suponen la mejora sobre ciertas caractersticas del lenguaje y la eliminacin
de aspectos obsoletos, arrastrados por una compatibilidad, que en ocasiones como la actual, es necesario dejar atrs; en
otros casos, se trata de adaptar nuestras costumbres a nuevos modos y hbitos de programar.
Para comprender un poco mejor, la razn que ha llevado a los diseadores de Microsoft al punto actual,
hagamos un breve repaso histrico a la programacin con Windows y Visual Basic.
desarrollo de la parte del interfaz de la aplicacin, controlando hasta el ms mnimo detalle de lo que el usuario
pudiera hacer con una ventana: captura y envo de mensajes desde y hacia las ventanas de la aplicacin, gestin de
manipuladores de ventanas y contextos de dispositivos para el dibujo de todos los elementos de la aplicacin, escritura
de los procedimientos de ventana, etc.; el ms simple programa que mostrara un mensaje tena un gran nmero de
lneas de cdigo.
En un escenario como este, en la mayor parte de casos, se desviaba la atencin de lo verdaderamente importante
en la aplicacin: la funcionalidad que necesitbamos dar al usuario. Programar una simple entrada de datos para
almacenar en un fichero era toda una odisea.
Por aadidura, tampoco existan herramientas de desarrollo que facilitaran la labor del programador, todo
consista en un puado de aplicaciones independientes que funcionaban en modo comando: compilador, enlazador,
editor de cdigo, etc., lo que haca que un programador no pudiera alcanzar el mismo nivel de productividad que tena
desarrollando las aplicaciones MS-DOS de aquel entonces.
Esto supona un grave inconveniente para Microsoft, puesto que el paso previo para popularizar su nuevo
entorno de usuario para ordenadores personales, pasaba por la existencia de una comunidad de programadores lo ms
amplia posible, todos escribiendo aplicaciones para Windows; sin embargo, dada su dificultad, pocos eran los que se
lanzaban a tal osado intento.
El proyecto Thunder
Conscientes del problema que entraaba el que los desarrolladores no migraran de forma masiva a la creacin
de programas para Windows, Microsoft puso en marcha un proyecto con el nombre clave Thunder (Trueno),
encaminado a crear una herramienta de desarrollo que facilitara la escritura de programas para Windows. En 1991,
este proyecto dio como fruto la primera versin de Visual Basic (VB a partir de ahora).
Un producto revolucionario
VB 1.0 supona una forma de encarar el desarrollo de aplicaciones Windows totalmente diferente a lo conocido
hasta aquel entonces. Mediante un entorno de desarrollo integrado (IDE) ejecutado desde el propio Windows,
cualquier programador, sin necesidad de conocer los aspectos intrincados de Windows y con una mnima curva de
aprendizaje, poda crear aplicaciones que hasta esa fecha era potestad reservada slo a unos pocos.
En esa poca, resultaba asombroso cmo de forma prcticamente intuitiva, crebamos un formulario, aadamos
controles, y en definitiva, disebamos el interfaz de usuario sin escribir una sola lnea de cdigo. La parte
correspondiente al cdigo, quedaba reservada para los eventos de los controles que necesitbamos que respondieran a
las acciones del usuario.
El gran inconveniente en esta versin y en VB 2.0, era que adoleca de un soporte nativo para manipular bases
de datos, puesto que uno de los pilares de las aplicaciones de gestin lo constituye su capacidad de comunicarse con
bases de datos para almacenar y recuperar informacin.
aplicaciones de gestin. Ahora ya no haba excusa para desarrollar un mantenimiento de datos bajo Windows de una
forma relativamente rpida y sencilla.
ActiveX y ADO
La versin 5.0 permita la compilacin de las aplicaciones a cdigo nativo, superando la ms lenta de versiones
anteriores, basada en pseudo-cdigo; como resultado, nuestros programas podan ejecutarse casi tan velozmente como
los de C++.
Otro rea del desarrollo hasta ese momento reservado a C++ era la creacin de controles ActiveX. La versin
5.0 introdujo la posibilidad de crear controles Actives, con lo que ya no era necesario recurrir a C++ para crear
nuestros propios controles, superando una nueva limitacin.
Respecto al manejo de bases de datos, se inclua una nueva jerarqua de objetos para datos: DAO (Data Access
Objects), que facilitaba la manipulacin de bases de datos Jet, el formato utilizado por Access.
VB 6 inclua un nuevo modelo de acceso a datos mejorado: ADO (ActiveX Data Objects), cuya finalidad era la
de reemplazar a los medios existentes hasta ese momento: RDO y DAO, por una nica jerarqua de objetos de acceso a
datos de cualquier tipo y en cualquier situacin: bases de datos locales, cliente/servidor, acceso a datos a travs de
Internet, etc. Este modelo de objetos para datos, si bien se conserva en .NET, ha sido profundamente renovado para
atender a las exigencias de las aplicaciones actuales.
Programacin en Internet
En los ltimos tiempos, y ms concretamente durante el periodo en el que aparecieron las versiones
5.0 y 6.0 de VB, el desarrollo de aplicaciones para Internet ha tomado un auge espectacular. VB no ha sido
ajeno a este factor, y en la versin 6.0, se incluan elementos que intentaban proporcionar al programador, capacidades
de acceso a Internet para evitar su cambio a otras herramientas o lenguajes ms especficos para la Red.
Los Documentos ActiveX y las Web Classes fueron un buen intento de llevar la programacin de Internet a VB,
pero su rendimiento en ejecucin y complejidad en algunos casos, distaban mucho de ser la solucin idnea a este
problema, y el programador que necesitaba crear aplicaciones web, hubo de cambiar a soluciones ms especficas,
como la programacin de pginas ASP.
Por otro lado, un punto fuerte de la programacin web, en el que VB s ha tenido xito, ha sido el desarrollo de
componentes, que encapsulan reglas de negocio, y pueden ser llamados desde pginas ASP. Estos componentes,
compilados en formato de DLL, se ejecutan en la capa intermedia del esquema de funcionamiento en tres capas de una
aplicacin en Internet.
El panorama actual
La entrada en una nueva generacin de aplicaciones para Internet, basada cada vez ms en dispositivos y
servicios trabajando en conjunto para ofrecer un mayor y mejor nmero de soluciones, haca cada vez ms patente el
hecho de que VB necesitaba un cambio (una nueva versin), que le permitiera afrontar todos estos nuevos retos:
VB.NET es la respuesta a todas estas necesidades.
El precio de la renovacin
Pero todas las mejoras efectuadas en VB.NET, han hecho que esta herramienta sufra una renovacin tan
profunda, que marcan un punto de inflexin importante, haciendo que muchos programadores opinen que estamos ante
un nuevo lenguaje, ms que una nueva versin.
A pesar de ciertas opiniones negativas, procedentes de los sectores ms conservadores de la comunidad VB,
debemos recordar que el paso de VB3 a VB4 tambin supuso importantes y profundos cambios en el modo en el que
se desarrollaban las aplicaciones por aquel entonces; sin embargo, todas aquellas innovaciones han sido asumidas por
el colectivo de desarrolladores y en la actualidad sera impensable abordar la realizacin de un programa sin ellas.
Otro punto a favor de VB.NET consiste en el hecho de que proporciona una utilidad de migracin de
aplicaciones creadas con versiones anteriores de VB que segn las pruebas realizadas es capaz de migrar hasta el 95%
del cdigo de una aplicacin creada en VB6.
Y lo que es ms importante, no es obligatoria la migracin de una aplicacin escrita por ejemplo en VB6;
podemos seguir ejecutando tales programas dentro de .NET Framework, con el inconveniente de que al no ser cdigo
gestionado por el entorno de .NET no podr aprovecharse de sus ventajas.
Muchos programadores argumentarn: -Y por qu no incorporar programacin web, dejando la facilidad de
uso que siempre ha tenido VB?-. La respuesta hemos de buscarla en el apartado anterior.
Si queramos programacin en Internet y todo el nuevo espectro de servicios que se avecinan, era necesario
integrar VB como lenguaje del entorno .NET, pero los lenguajes que formen parte de esta plataforma estn obligados a
cumplir una serie de requisitos, no porque lo pueda necesitar el lenguaje, sino porque es la plataforma la que obliga a
ello para poder sacar partido de todas las ventajas de .NET.
Si reflexionamos adems, mirando hacia anteriores cambios de versiones, podemos comprobar que desde VB4,
todos los cambios han sido en buena medida profundos, para poder adaptarse a las necesidades de los programas en
cada momento. Bien es cierto, que esta versin incorpora un cambio ms traumtico que las otras, pero si sopesamos
las nuevas funcionalidades y potencia que obtendrn nuestras aplicaciones, suponemos que la inversin efectuada en
adaptarnos merecer la pena.
Comenzamos
Nos encontramos en un momento muy importante en la historia de la informtica en general, y la programacin
en particular; estamos en el punto de partida de una nueva generacin de aplicaciones, que demandan una nueva
tecnologa, y que gracias al entorno .NET y a VB.NET, como una de sus herramientas integrantes, vamos a poder
afrontar con plenas garantas de xito.
Desde esta obra, intentaremos hacer que la curva de aprendizaje de VB.NET, sea una experiencia grata y amena,
tanto para los programadores que se acercan por primera vez a este lenguaje, como para los veteranos, ya curtidos en
las lides del mundo de Visual Basic. Bienvenidos a todos.
La
evolucin
hacia
.NET
ASP
Las pginas ASP (Active Server Pages) son el medio con el que en Windows DNA, podemos programar
aplicaciones para Internet utilizando la tecnologa de Microsoft.
Aun cuando el resultado conseguido es satisfactorio, el hecho de ser cdigo interpretado, carecer de una
herramienta de depuracin y poca estructuracin suponen un grave paso atrs, mxime cuando todas las herramientas
de desarrollo tienden progresivamente hacia un modelo orientado a objetos.
ADO
Este modelo de objetos para el acceso a datos fue diseado inicialmente para ASP, pero dado su xito, se
traslado tambin a Visual Basic, para superar los inconvenientes que presentaban los obsoletos DAO y RDO.
El hecho de que se creara en un principio para ASP, puede hacernos pensar que es el medio perfecto para el
acceso a datos en Internet; sin embargo, su diseo no se basa totalmente en un modo de acceso desconectado a los
datos, ya que para que funcionara con mejor rendimiento dentro del mundo cliente/servidor de las aplicaciones VB,
tambin se puede utilizar estableciendo una conexin permanente con el origen de datos del servidor, lo que supone un
claro lastre a la hora de trasladarlo al mundo de Internet, en el que la conexin se establece slo durante el tiempo que
dura la operacin a realizar con los datos (obtencin, modificacin)
Visual Basic
El papel de VB dentro de Windows DNA ha sido fundamentalmente, el de la escritura de componentes para su
uso por parte de las pginas ASP de una aplicacin web; de hecho, es el lenguaje preferido para el desarrollo de
componentes debido a su ya larga tradicin como lenguaje sencillo y de fcil manejo.
Microsoft hizo un intento de dotar de un mayor nmero de caractersticas a Visual Basic para que pudiera
convertirse en una herramienta de desarrollo integral para Internet; para ello, incorpor las Web Classes, los
documentos ActiveX y controles ActiveX, aunque ninguno de ellos obtuvo plena aceptacin.
Por un lado, las Web Classes tenan el complejo modelo de programacin, mientras que los documentos
ActiveX arrojaban unos pobres rendimientos de ejecucin. Con respecto a los controles ActiveX, necesitaban de cierto
proceso de instalacin por parte del servidor, lo que los haca en muchas situaciones poco operativos. Estas
circunstancias han impedido que VB pudiera convertirse en la herramienta de desarrollo para Internet de Microsoft.
Otros factores decisivos que han limitado la plena entrada de VB en la programacin web han sido la falta de
capacidades multihebra, inexistencia de un interfaz de usuario especfico para aplicaciones web, falta de herencia y
otras caractersticas orientadas a objeto, escasa integracin con otros lenguajes, deficiente gestin de errores, etc.,
aspectos todos, solucionados en VB.NET.
problemas existentes en la actualidad. La actualizacin de una DLL, cuando se produce un cambio en la misma y los
conflictos de versin entre componentes, llevan a una inversin muy importante y grave de tiempo en corregir estos
problemas.
Qu es .NET?
.NET es toda una nueva arquitectura tecnolgica, desarrollada por Microsoft para la creacin y distribucin del
software como un servicio. Esto quiere decir, que mediante las herramientas de desarrollo proporcionadas por esta
nueva tecnologa, los programadores podrn crear aplicaciones basadas en servicios para la web.
Las caractersticas principales que conforman .NET son las siguientes:
.
La plataforma .NET Framework, que proporciona la infraestructura para crear aplicaciones y el
entorno de ejecucin para las mismas.
.
Los productos de Microsoft enfocados hacia .NET, entre los que se encuentran Windows .NET
Server, como sistema operativo que incluir de forma nativa la plataforma .NET Framework; Visual Studio .NET,
como herramienta integrada para el desarrollo de aplicaciones; Office .NET; b.Central para .NET, etc.
.
Servicios para .NET desarrollados por terceros fabricantes, que podrn ser utilizados por otras
aplicaciones que se ejecuten en Internet.
Existen adicionalmente un conjunto de productos, que bajo la etiqueta de Servidores Empresariales para .NET
(.NET Enterprise Servers) se incluyen dentro de la estrategia .NET. Entre estos productos podemos encontrar a SQL
Server 2000, BizTalk Server, Commerce Server 2000, etc. Sin embargo, hemos de hacer una puntualizacin
importante: estos productos no estn basados en .NET Framework, pueden funcionar dentro del entorno de ejecucin
de .NET Framework, pero el nico producto actualmente desarrollado bajo el nuevo entorno es Visual Studio .NET.
Gracias a .NET y a su modelo de desarrollo basado en servicios, se flexibiliza y enriquece el modo en el que
hasta ahora se construan aplicaciones para Internet. La idea que subyace bajo esta tecnologa, es la de poblar Internet
con un extenso nmero de aplicaciones, que basadas en servicios para la web (Web Services), formen un marco de
intercambio global, gracias a que dichos servicios estn fundamentados en los estndares SOAP y XML, para el
intercambio de informacin.
En este sentido, un programador puede crear Web Services para que sean utilizados por sus propias aplicaciones
a modo de componentes (pero de una forma mucho ms avanzada que empleando el modelo COM clsico), siguiendo
una estructura de programacin ya conocida. Ver Figura 1.
Figura 1. Esquema de funcionamiento de aplicacin web incluyendo Web Services.
Sin embargo, los Web Services traen de la mano un nuevo modelo de distribucin del software; el basado en el
desarrollo y publicacin de Web Services y en la suscripcin a los mismos por parte de otras aplicaciones, potenciales
usuarios de tales servicios. Ver Figura 2.
Los fabricantes de software, pueden de esta manera, dedicarse a la creacin de servicios web y a su alquiler.
Nace de esta manera, la figura del proveedor de servicios web.
Dado el esquema anterior, el programador puede construir sus aplicaciones a base de Web Services, reduciendo
significativamente el tiempo y esfuerzo en el desarrollo.
.NET Framework
.NET Framework constituye la plataforma y elemento principal sobre el que se asienta Microsoft .NET. De cara
al programador, es la pieza fundamental de todo este nuevo modelo de trabajo, ya que proporciona las herramientas y
servicios que necesitar en su labor habitual de desarrollo.
.NET Framework permite el desarrollo de aplicaciones a travs del uso de un conjunto de herramientas y
servicios que proporciona, y que pueden agruparse en tres bloques principales: el Entorno de Ejecucin Comn o
Common Language Runtime (CLR a partir de ahora); la jerarqua de clases bsicas de la plataforma o .NET
Framework Base Classes; y el motor de generacin de interfaz de usuario, que permite crear interfaces para la web o
para el tradicional entorno Windows, as como servicios para ambos entornos operativos. La Figura 3 muestra un
diagrama con la distribucin de elementos dentro del entorno de .NET Framework.
En la base del entorno de ejecucin, se encuentra el CLR, que constituye el ncleo de .NET Framework,
encargndose de la gestin del cdigo en cuanto a su carga, ejecucin, manipulacin de memoria, seguridad, etc.
En el nivel intermedio, se sita la jerarqua de clases bsicas del entorno de ejecucin, que constituyen un slido
API de servicios a disposicin del programador, para multitud de tareas como, gestin del sistema de ficheros,
manipulacin multihebra, acceso a datos, etc.
Finalmente, en el nivel superior, encontramos las clases que permiten el diseo del interfaz de usuario de
nuestras aplicaciones. Si necesitamos desarrollar aplicaciones para Internet, utilizaremos ASP.NET, que nos provee de
todo lo necesario para crear aplicaciones para la Red: web forms, web services, etc.
Y no piense el programador tradicional de Windows, que todo en .NET Framework es programacin para
Internet. La plataforma no se ha olvidado de este colectivo de programadores, que necesitan desarrollar programas
para este sistema operativo, y pone a su disposicin los denominados Windows Forms, la nueva generacin de
formularios, con caractersticas avanzadas y muy superiores a las del motor de generacin de formularios de VB6.
Adicionalmente, existe la posibilidad de que necesitemos servicios del sistema que no requieran interfaz de
usuario en absoluto. Este aspecto tambin est contemplado por la plataforma, permitindonos, por ejemplo, la
creacin de servicios para Windows 2000 y NT.
En los siguientes apartados, haremos una descripcin de los elementos y caractersticas ms destacables del
CLR, que permitan al lector obtener una visin global del mismo, y de las ventajas de escribir programas para este
entorno de ejecucin.
Dim
sNombre
sNombre
=
MessageBox.Show(sNombre.Length)
MessageBox.Show(sNombre.ToUpper())
As
'
'
devuelve
devuelve
String
"coche"
5
COCHE
En el Cdigo fuente 1, escrito en VB.NET, declaramos una variable de tipo String (cadena de caracteres), y a
continuacin le asignamos un valor; hasta aqu, todo igual que en versiones anteriores. Pero ahora viene lo novedoso,
ya que manipulamos la variable igual que un objeto, obteniendo la longitud de su valor mediante la propiedad Length
y convertimos su valor a maysculas ejecutando el mtodo ToUpper(); en ambos casos mostramos el resultado usando
un objeto MessageBox.
En este fuente y otros escritos en VB.NET que utilicemos a lo largo de este tema, el lector percibir cambios en
la sintaxis del lenguaje, motivados por la nueva versin de VB. Todas estas novedades se comentarn en los temas
dedicados al lenguaje y su implementacin orientada a objeto.
La Tabla 1 muestra una relacin de los principales tipos de datos de .NET Framework y su correspondencia
especfica con VB.NET.
Tabla 1. Tipos de datos de .NET Framework con sus correspondencias en VB.NET.
Debemos aclarar, no obstante, que el tipo String no se englobara dentro de los tipos primitivos del lenguaje, ya
que realmente, una variable de tipo String, lo que contiene es un array de tipos Char; sin embargo, nosotros podemos
seguir manipulando cadenas de caracteres del mismo modo en el que lo hacamos en versiones anteriores de VB, ya
que el entorno se encarga de gestionar el array de valores Char que una cadena contiene.
Categoras de tipos
Los tipos creados por el CTS pueden clasificarse en dos grupos principales, segn el modo en el que se
almacenan y manipulan en memoria:
.
Tipos por valor. Un tipo creado por valor, almacena un dato que puede ser accedido de forma directa.
Los tipos por valor se organizan a su vez en varios subgrupos, como son los tipos de datos nativos de la plataforma
.NET, tipos de datos creados por el programador y tipos enumerados.
.
Tipos por referencia. Un tipo creado por referencia, contiene la direccin de memoria en donde
reside un dato. Para acceder a dicho dato, lo hacemos de forma indirecta utilizando esa direccin de memoria o
referencia. Los tipos por referencia se organizan a su vez en varios subgrupos, como son las clases propias de la
plataforma, las clases creadas por el programador, interfaces, delegates, etc.
La Figura 6 muestra un esquema con la organizacin de tipos de .NET Framework.
Figura 6. Organizacin de tipos de .NET Framework.
Cuando creamos un tipo por referencia, la instancia de una clase (un objeto) que asignamos a una variable, por
ejemplo; dicho tipo se sita en el montn. Una variable de este tipo contiene la referencia a un valor, no el propio
valor, por lo que si asignamos una variable que contiene un tipo por referencia a otra variable, se dice que ambas
apuntan o se refieren al mismo valor. Un tipo por referencia s puede contener un valor nulo.
El Cdigo fuente 2 muestra un ejemplo de creacin y asignacin de valores a cada uno de estos tipos.
Public
Class
Public
Cliente
Calculo
As
Long
End
Class
Module
'
Dim
Dim
Gestion
Public
declarar
Sub
variables
dos
ImportePrim
ImporteSeg
ImportePrim
ImporteSeg
'
'
las
dos
variables
ImportePrim
ImporteSeg
asignamos
un
ahora
-->
-->
nuevo
el
mismo
valor
las
=
las
dos
variables
ImportePrim
ImporteSeg
tienen
'
declarar
dos
oClienteUno
oClienteDos
oClienteUno.Calculo
'
al
asignar
'
ambas
variables
'
o
oClienteDos
'
100
ImportePrim
tienen
de
'
'
'
Dim
Dim
Main()
valor)
Long
Long
por
'
'
'
'
ImporteSeg
(tipos
As
As
los
dos
'
'
'
asignamos
'
en
oClienteDos.Calculo
objetos
As
el
una
variables
728
valor
100
728
------------------------------------------(tipos
por
referencia)
New
Cliente()
As
Cliente
objeto
apuntan
direccin
=
nuevo
uno
distinto
=
un
objetos
tienen
oClienteUno.Calculo
oClienteDos.Calculo
un
ahora
-->
-->
valor
100
100
a
al
85000
variable
objeto
memoria
oClienteUno
otra
mismo
de
mismo
valor
-->
-->
valor
de
=
en
la
la
los
propiedad
85000
85000
propiedad
objetos
120000
'
'
'
'
'
'
los
dos
en
ya
objetos
tienen
la
que
la
misma
oClienteUno.Calculo
oClienteDos.Calculo
el
mismo
ambos
referencia
en
-->
-->
valor
propiedad,
apuntan
memoria
120000
120000
End
Sub
End
Module
Como acabamos de observar, las variables Long, son tipos por valor que contienen valores independientes; por
el contrario, las variables con los objetos de la clase Cliente, por el hecho de haber asignado una de ellas a la otra,
apuntan al mismo lugar o referencia.
Otro detalle importante a destacar de este fuente es el manejo de valores nulos. Como hemos comentado, los
tipos por valor no pueden tener valores nulos, por lo que aunque no se aprecie en el fuente, las variables Long, al ser
creadas, tienen como valor inicial el cero, mientras que las variables con los objetos Cliente, al ser instanciadas, s
contienen un valor nulo o Nothing, como se denomina en VB.NET.
Representado de una forma grfica, la disposicin en memoria del anterior cdigo fuente quedara como se
muestra en el esquema de la Figura 7.
Como podemos comprobar, la relacin que la memoria tiene con respecto a los tipos de .NET es muy
importante, ya que dependiendo de donde sean ubicados, se conseguir un rendimiento mas o menos ptimo en la
ejecucin del programa.
Traducido a cdigo VB.NET, el anterior esquema quedara como muestra el Cdigo fuente 3.
Public
Class
Public
'
Dim
Embalar
Shared
tipo
iImporte
As
Sub
por
Integer
Main()
valor
825
'
'
'
Dim
asignamos
el
tipo
por
variable
Object
una
oOtroVal
'
'
'
'
'
iImporte
'
As
si
tipo
mantiene
los
por
cambiamos
valor,
el
valor
valores
el
la
de
copias
son
valor
=
contenido
variable
original
ya
ambas
los
valores
seran
'
'
actuales
de
del
Object
que
variables
independientes
999
la
variables
siguientes:
los
iImporte
oOtroVal
'
End
embalaje:
a
Object
iImporte
-->
-->
999
825
Sub
End
Class
El proceso opuesto al anterior, denominado desembalaje o unboxing, consiste en tomar un tipo Object y
convertirlo a un tipo por valor.
Tomando el ejemplo anterior, si queremos volver a convertir la variable Object a un tipo por valor, creamos un
nuevo tipo por valor y le asignamos la variable Object, crendose una copia del valor en el nuevo tipo por valor. La
Figura 9 muestra como quedara este proceso.
Public
Class
Public
'
Dim
Embalar
Shared
Sub
tipo
iImporte
por
Integer
As
Main()
valor
825
'
'
'
Dim
asignamos
tipo
una
oOtroVal
'
'
'
'
'
el
si
tipo
mantiene
los
As
por
son
cambiamos
valor,
el
valor
valores
por
variable
Object
el
la
de
copias
valor
=
contenido
variable
original
ya
ambas
embalaje:
a
Object
iImporte
del
Object
que
variables
independientes
iImporte
'
los
'
'
'
valores
seran
iImporte
oOtroVal
999
actuales
de
la
los
-->
-->
variables
siguientes
999
825
'----------------------'
desembalaje:
'
'
Dim
crear
y
iNuevoImp
un
asignarle
As
nuevo
tipo
el
Integer
por
tipo
=
valor
Object
oOtroVal
End
Sub
End
Class
Metadata (metadatos)
Durante el diseo de .NET Framework, se hizo evidente que una aplicacin necesitaba, adems de su propio
cdigo ejecutable, informacin adicional sobre la propia aplicacin, que pudiera ser utilizada por el entorno de
ejecucin para funcionalidades diversas.
Para resolver este problema, se opt por incluir toda esta informacin complementaria dentro de la propia
aplicacin. A la informacin que va incluida en la aplicacin pero que no forma parte del cdigo ejecutable se le
denomina metadatos, y con esta tcnica obtenemos aplicaciones o componentes auto-descritos.
Los metadatos son creados por el compilador del lenguaje utilizado en cada caso y grabados dentro del fichero
resultante (EXE o DLL) en formato binario, siendo el CLR el encargado de recuperarlos en el momento que los
necesite.
Algunos de los datos proporcionados por los metadatos de una aplicacin son la descripcin del ensamblado
(trataremos los ensamblados posteriormente) junto a su versin, clave y tipos que lo componen (clases, interfaces,
etc.).
Soporte multi-lenguaje
Uno de los puntos clave del CLR es que est diseado para soportar mltiples lenguajes, permitiendo as unos
elevados niveles de integracin entre los mismos. Con tal motivo, .NET Framework proporciona los siguientes
lenguajes con sus correspondientes compiladores para la escritura de aplicaciones:
. VB.NET.
. C#.
Ejecucin administrada
La ejecucin administrada se trata de un conjunto de elementos existentes en .NET Framework, que supervisan
el cdigo del programa durante su ejecucin dentro del CLR, asegurndose de que el cdigo cumple todos los
requisitos para poder hacer uso de los servicios proporcionados por el entorno de ejecucin, y beneficiarse de sus
ventajas.
Cdigo administrado
El cdigo que escribamos orientado a utilizar todas las cualidades del CLR se denomina cdigo administrado.
Por defecto el cdigo escrito en VB.NET, C# y JScript.NET es administrado, con lo que el programador no debe
preocuparse en configurar de manera especial su proyecto.
Por el contrario, el cdigo escrito en C++ no es administrado por defecto, lo que significa que el entorno no lo
supervisa y no garantiza su fiabilidad al ser ejecutado por el CLR. Si el programador de C++ quiere que su cdigo sea
administrado debe utilizar las extensiones administradas que la plataforma proporciona para este lenguaje y activarlas
a travs de una opcin del compilador.
El hecho de que el entorno realice labores de comprobacin sobre el cdigo, supone evidentemente, una labor
extra que repercute sobre el rendimiento final a la hora de ejecutar el programa. Sin embargo, las pruebas realizadas
ofrecen como resultado una prdida de un 10% en el rendimiento del cdigo administrado con respecto al cdigo no
administrado.
Teniendo en cuenta los niveles de seguridad que nos ofrece el cdigo administrado y dado que la velocidad de
los procesadores evoluciona, esta prdida de rendimiento que supone la ejecucin administrada posiblemente no sea
significativa en un corto plazo de tiempo.
Datos administrados
De forma similar al cdigo, los datos administrados son datos los datos de la aplicacin gestionados en memoria
por el CLR a travs de un mecanismo denominado recolector de basura.
Al igual que en el punto anterior, los datos son administrados por defecto en las aplicaciones escritas en
VB.NET, C# y JScript.NET. Si utilizamos en cambio C++, los datos de la aplicacin no son administrados por
defecto, debindolo indicar en el cdigo del programa.
fuente.
Adems del cdigo en IL, el compilador genera tambin metadatos, que como se ha explicado en un apartado
anterior, contienen informacin adicional, incluida en la propia aplicacin, y que sern utilizados por el CLR al
ejecutar el programa.
Tanto el cdigo en IL, como los metadatos generados, se guardan en un fichero de tipo EXE o DLL, basado en
la especificacin tradicional de Microsoft para ficheros con formato de ejecutable transportable (Portable Executable o
PE) y objeto comn (Common Object File Format o COFF). Con el desarrollo de la tecnologa .NET, esta
especificacin ha sido ampliada para dar cabida, adems de cdigo binario, cdigo IL y metadatos.
Ya que el cdigo obtenido en IL es independiente del procesador, en su estado actual no es posible todava
ejecutarlo, debido a que el IL no ha sido diseado para conocer las instrucciones especficas del procesador en el que
se va a ejecutar. La ejecucin se lleva a cabo, realizando el paso final de compilacin que se detalla seguidamente.
Independencia de plataforma
Ya que el cdigo mquina ejecutable, es obtenido a travs de un compilador JIT, con las instrucciones
adecuadas para un procesador determinado, .NET Framework proporciona varios compiladores JIT para cada una de
las plataformas que soporta, consiguiendo as que la aplicacin, una vez escrita, pueda funcionar en distintos sistemas
operativos, y haciendo realidad el objetivo de que nuestro cdigo sea independiente de la plataforma en la que se vaya
a ejecutar, actuando .NET Framework como una capa intermedia, que asla el cdigo del sistema operativo. Ver Figura
13.
Dominios de aplicacin
En .NET Framework se han reforzado las caractersticas de seguridad y aislamiento hasta un nivel que permite
la ejecucin de mltiples aplicaciones en un mismo proceso. A este contexto de ejecucin de un programa se le
denomina dominio de aplicacin (Application Domain).
La tcnica utilizada tradicionalmente para conseguir aislar las aplicaciones, de modo que no se produzcan
colisiones entre las mismas, ha sido a travs de procesos. Cada aplicacin se carga en un proceso separado, que
proporciona el adecuado nivel de aislamiento; de este modo, se evitan posibles conflictos entre las direcciones de
memoria utilizadas por cada programa. Sin embargo, esto supone un gran consumo de recursos, cuando las
aplicaciones deben hacer llamadas a otras aplicaciones que residan en procesos distintos, debido a que se debe de
realizar un traspaso de procesos entre la aplicacin que realiza la llamada y la aplicacin destino. Esta tcnica ha sido
mejorada en .NET, de modo que se consigue tener en un mismo proceso, varias aplicaciones en ejecucin.
El cdigo administrado en .NET Framework, para poder ser considerado como seguro, debe pasar en primer
lugar una fase de comprobacin, efectuada por el CLR, que asegure el hecho de que no realice ningn acceso no
permitido a direcciones de memoria u otras operaciones que puedan provocar un fallo del sistema. Una vez superada
dicha comprobacin, el cdigo es marcado como seguro a nivel de tipos (type-safe), y la aplicacin ejecutada.
Superada esta fase de verificacin, el programa se ejecutar en un dominio de aplicacin, que como hemos
comentado antes, consiste en una tcnica que permite ejecutar varias aplicaciones en un nico proceso, con el mismo
nivel de aislamiento que si se estuvieran ejecutando en procesos separados, y la ventaja de eliminar la sobrecarga
producida cuando distintas aplicaciones estn situadas en diferentes procesos y deben hacerse llamadas entre s. Cada
aplicacin se ejecuta en su propio dominio de aplicacin
Los dominios de aplicacin incrementan notablemente la capacidad de crecimiento de los servidores al ejecutar
mltiples aplicaciones en un mismo proceso. La Figura 14 muestra un esquema del proceso de carga y ejecucin de
aplicaciones en sus correspondientes dominios de aplicacin.
Servidores de entorno
Un servidor de entorno o Runtime Host es el encargado de ejecutar un dominio de aplicacin dentro del CLR,
aprovechando las ventajas proporcionadas por este ltimo.
Cuando el CLR se dispone a ejecutar una aplicacin, un servidor de entorno crea el entorno de ejecucin o shell
para dicha aplicacin, y lo carga en un proceso; a continuacin, crea un dominio de aplicacin en ese proceso y por
ltimo carga la aplicacin en el dominio.
.NET Framework dispone entre otros, de los servidores de entorno relacionados a continuacin:
.
ASP.NET. Carga el entorno en un proceso preparado para gestionarse en la web; creando tambin, un
dominio de aplicacin para cada aplicacin de Internet ejecutada en un servidor web.
.
Internet Explorer. Crea un dominio de aplicacin por cada sitio web visitado, en el que se ejecutan
controles administrados basados en el navegador.
.
Windows Shell. Crea un dominio de aplicacin con interfaz Windows, para cada programa que es
ejecutado.
Namespaces
Otro de los pilares que forman los cimientos de .NET Framework es el concepto de espacio de nombres o
namespaces.
Un namespace o espacio de nombres, tambin denominado nombre calificado, es el medio proporcionado por la
plataforma para organizar las clases dentro del entorno, agrupndolas de un modo ms lgico y jerrquico. Para
comprender mejor este concepto veamos un ejemplo:
Estamos desarrollando un conjunto de clases para las operaciones de gestin contable y facturas de una
empresa. Podemos ir escribiendo todas las clases y situarlas dentro de una misma aplicacin o DLL. Actualmente
tenemos dos clases para operaciones contables, denominadas Balance y LibroIVA, y otras dos clases para operaciones
con facturas, denominadas Albaran y Factura.
Pero necesitamos aadir una clase ms para las facturas que registre el libro de IVA de las facturas emitidas. El
nombre ms idneo sera LibroIVA, pero ya est siendo utilizado, as que para evitar problemas de duplicidad de
nombres, debemos elegir otro que puede no se ajuste a definir la funcionalidad de la clase.
Mediante el uso de espacios de nombre este problema sera solucionado, con el aadido de poder organizar
mejor cada clase, asignndole un nombre jerrquico para la funcionalidad que desempea. Para ello, deberamos crear
un namespace con el nombre Gestion, que contuviera otros dos namespaces llamados Contabilidad y Facturacin, para
finalmente incluir en cada uno de ellos las clases correspondientes. La Figura 16 muestra un diagrama organizativo de
las clases de este ejemplo utilizando espacios de nombre.
Cuando creamos un proyecto dentro de Visual Studio .NET, esta herramienta ya se encarga de crear de forma
automtica un namespace con el mismo nombre del proyecto. En el caso de que sea el programador quien quiera crear
un namespace de forma explcita, puede hacerlo mediante la palabra clave Namespace dentro del cdigo del proyecto.
Para acceder desde el cdigo de una aplicacin, a una clase contenida dentro de un espacio de nombre, debemos
indicarlo en la aplicacin realizando una operacin que en VB.NET se denomina Importar. Existen dos medios para
importar un espacio de nombre: usar la palabra clave Imports en la cabecera del mdulo de cdigo junto al nombre del
namespace y clase a la que queremos acceder; o bien usar la descripcin calificada completa en cada momento que
necesitemos hacer referencia a la clase. El Cdigo fuente 5 muestra algunos ejemplos:
Imports
Imports
Gestion.Contabilidad
System.Windows.Forms
Public
Class
Public
Dim
Dim
Dim
Shared
oBal
oFactu
oPulsado
Cliente
Sub
As
As
New
As
Main()
New
Balance()
Gestion.Facturacion.Factura()
New
Button()
'............
'............
'............
End
Sub
End
Class
La convencin sintctica para hacer referencia a una clase contenida en un espacio de nombre, es como
acabamos de ver, el espacio de nombre y la clase separados por un punto. En el caso de acceder a una clase que se
encuentra con varios espacios de nombre de profundidad, especificaremos dichos espacios de nombre separados por
un punto, e igualmente al final, la clase. La inclusin al final del nombre de la clase, depende de si instanciamos
directamente el objeto usando la lista de espacios de nombre o importamos dicha lista.
En el caso de instanciar un objeto directamente en el cdigo, escribiremos los espacios de nombre y al final, el
nombre de la clase. Si importamos los espacios de nombre, no debemos poner el nombre de la clase, sino que debemos
terminar con el espacio de nombres que contiene la clase que necesitamos.
De esta forma, la lnea mostrada en el Cdigo fuente 6, nos permitir instanciar en el cdigo del mdulo donde
est declarada, objetos de la clase File, que est en el namespace IO, este ltimo a su vez contenido en el namespace
System.
Imports
System.IO
En el ejemplo del Cdigo fuente 5, al importar una clase contenida en un namespace, en este caso Balance o
Button, cuando instanciamos un objeto de ella, no es necesario poner el namespace completo. No ocurre lo mismo con
Factura, ya que al no haber importado el namespace que la contiene, debemos indicarlo en el momento de instanciar el
objeto.
Todas las clases de la plataforma .NET estn contenidas dentro de espacios de nombre, por lo que siempre que
necesitemos instanciar un objeto, deberemos hacerlo usando la convencin de espacios de nombre y puntos explicada
anteriormente.
Las clases principales de .NET Framework estn, por consiguiente, incluidas tambin en sus correspondientes
namespaces. Como muestra el ejemplo anterior, si queremos instanciar un objeto para un formulario (Button,
TextBox, etc.) debemos usar el espacio System.Windows.Forms, y dentro de este la clase que necesitemos. Como
habr podido adivinar el lector, el namespace System constituye el espacio raz, a partir del cual, descienden el resto
de espacios de nombre y clases de la plataforma, como IO, Threading, Collections, etc.
conjunto de clases, que permiten dotar a las aplicaciones de todas las caractersticas necesarias.
El desarrollador experimentado puede estar preguntndose la necesidad de implementar una nueva jerarqua de
clases si las actuales ya cumplen con su cometido. Entre las posibles razones, queremos destacar las siguientes:
.
El nuevo sistema de clases est mucho mejor organizado, y provee al programador de una potencia y
versatilidad para sus aplicaciones nunca antes lograda en versiones anteriores de Visual Studio.
.
Podemos crear una nueva clase, heredando de una clase propia de la plataforma, para extender su
funcionalidad.
.
Desplazando la funcionalidad de las clases fuera de los lenguajes, y hacindolas por lo tanto,
independientes de los mismos, simplifica el proceso de desarrollo.
.
Al ser las clases de .NET Framework, comunes a todos los lenguajes, se eliminan las barreras
tradicionales que impedan a los programadores abordar ciertos proyectos por el hecho de usar un lenguaje que no
dispona de cierta funcionalidad que s tena otro lenguaje. Ahora cualquier programador, con independencia del
lenguaje que elija, tiene pleno acceso a todas las funcionalidades que le brinda la plataforma .NET.
El ejemplo del Cdigo fuente 7 muestra la declaracin y asignacin de valor a una variable desde VB.NET y
C#. Con las salvedades particulares de cada lenguaje, en ambos casos se instancia una variable de la misma clase o
tipo: Integer.
'
Dim
MiDato
//
int
cdigo
As
Integer
VB.NET
=
20
cdigo
C#
MiDato=20;
Cdigo fuente 7. Instanciacin de objetos de la misma clase de .NET Framework desde distintos lenguajes.
Dentro de .NET Framework, System designa al espacio de nombre principal o raz, a partir del cual, descienden
todos los espacios de nombre y clases de la plataforma.
Adems de las clases que proporcionan acceso a los tipos de datos intrnsecos de .NET Framework, System nos
permite el acceso a otros servicios entre los que se encuentran los mostrados en la Tabla 2.
Ensamblados
Un ensamblado o assembly, consiste en un conjunto de tipos y recursos, reunidos para formar la unidad ms
elemental de cdigo que puede ejecutar el entorno de .NET Framework.
De igual forma que los edificios se crean a base de la unin de un conjunto de materiales, dentro de la
tecnologa .NET, los ensamblados se presentan como los bloques de construccin software, que se unen o ensamblan
para crear aplicaciones. Una aplicacin desarrollada para .NET Framework debe estar compuesta por uno o varios
ensamblados, ver Figura 17.
Podemos establecer una analoga entre un ensamblado y una DLL, ya que ambos contienen clases, que se
exponen a otras aplicaciones. Por dicho motivo, a un ensamblado tambin se le da el nombre de DLL lgica; el
trmino DLL se emplea porque tiene un comportamiento similar al de las DLLs tradicionales, y el trmino lgica
porque un ensamblado es un concepto abstracto, ya que se trata de una lista de ficheros que se referencian en tiempo
de ejecucin, pero que no se compilan para producir un fichero fsico, a diferencia de lo que ocurre con las DLLs
tradicionales.
Sin embargo, un ensamblado extiende sus funcionalidades a un horizonte mucho ms amplio, ya que puede
contener otros elementos aparte de clases, como son recursos, imgenes, etc.
Por otro lado, simplifican los tradicionales problemas de instalacin y control de versiones sobre los programas,
uno de los objetivos de la tecnologa .NET, en la que en teora, para instalar una aplicacin, slo sera necesario copiar
los ficheros que la componen en un directorio de la mquina que la vaya a ejecutar.
Cuando creamos un nuevo proyecto en VB.NET desde Visual Studio .NET, dicho proyecto es ya un
ensamblado, creado de forma implcita.
El contenido de un ensamblado
Un ensamblado est compuesto por los siguientes elementos:
.
ensamblado.
.
.
.
Manifiesto del ensamblado, que contiene informacin acerca de los elementos que forman el
Metadatos sobre los tipos que contiene el ensamblado.
Mdulos de cdigo con los tipos compilados en IL.
Recursos adicionales.
Un aspecto muy importante a tener en cuenta con referencia a este tipo de ensamblados, consiste en que los
ficheros que lo componen, no estn conectados fsicamente (no se compilan a un fichero destino); es el manifiesto del
ensamblado el que se encarga de mantener las referencias, de manera que el CLR al ejecutar el ensamblado, lee el
manifiesto para averiguar que elementos lo forman, y as poder manipular el ensamblado como una entidad ejecutable
nica.
Este aspecto de la arquitectura de los ensamblados es de suma importancia, ya que un mismo fichero,
conteniendo uno o varios mdulos compilados en IL, puede formar parte al mismo tiempo de varios ensamblados, al
no estar conectado fsicamente con ninguno de ellos, slo a travs del manifiesto. Ver Figura 21.
Los ensamblados compartidos se sitan en la Cach Global de Ensamblados o Global Assembly Cache, que es
una cach especial del CLR que administra este tipo de ensamblados.
Para instalar un ensamblado compartido en la cach global, utilizaremos alguna de las herramientas que
permiten realizar tal operacin, como Windows Installer, la utilidad GACUTIL.EXE proporcionada en el SDK de
.NET Framework o el Explorador de Windows.
Durante la ejecucin de un programa, cuando sea necesario el uso de un ensamblado compartido, el CLR
realizar la bsqueda de dicho ensamblado empleando su clave de identificacin y el nmero de versin, para localizar
el correcto ensamblado en la cach global.
Versiones de ensamblados
Todos los ensamblados deben disponer de su correspondiente versin, que es almacenada en el manifiesto. Los
datos de la versin de un ensamblado se indican de dos maneras:
Nmero de versin. Consiste en un valor numrico representado bajo el siguiente formato:
<Nmero superior>.<Nmero inferior>.<Nmero de construccin>.<Revisin>
Ficheros de configuracin
Cuando el CLR necesita hacer uso de un ensamblado, toma su nmero de versin del manifiesto, realiza una
bsqueda del ensamblado y lo ejecuta en caso de encontrarlo. Este es el comportamiento por defecto de entorno de
ejecucin.
Sin embargo, puede haber ocasiones en las que se haga necesario el uso de una versin diferente del
ensamblado, para lo cual, debemos redirigir al CLR hacia dicha versin especfica que deseamos ejecutar, en lugar de
la versin por defecto.
Esto lo conseguimos a travs de los ficheros de configuracin, que son unos ficheros con extensin .CFG,
basados en etiquetas XML, en los que a travs de un conjunto de etiquetas clave ordenamos al entorno la ejecucin de
una determinada versin del ensamblado. En el ejemplo del Cdigo fuente 8 indicamos mediante un fichero de
configuracin el uso de una versin especfica de un ensamblado.
<configuration>
<runtime>
<assemblyBinding
<dependentAssembly>
xmlns="urn:schemas-microsoft-com:asm.v1">
<assemblyIdentity
publickeytoken="32ab4ba45e0a69a1"
culture="sp"
<bindingRedirect
newVersion="2.0.0.0"/>
<codeBase
href="http://www.AcmeFac.com/GestVentas.dll"/>
</dependentAssembly>
</assemblyBinding>
</runtime>
</configuration>
name="GestVentas"
/>
oldVersion="1.0.0.0"
version="2.0.0.0"
.
.
.
Instalacin
de
Visual
Studio
.NET
Se trata del kit de desarrollo de software para .NET Framework (Software Development Kit o SDK), que
contiene la propia plataforma .NET y un conjunto de herramientas independientes, algunas funcionan en modo
comando (en una ventana MS-DOS) y otras en modo grfico. Los elementos imprescindibles para poder desarrollar
aplicaciones para .NET estn contenidos en este conjunto de herramientas.
Requisitos hardware
La Tabla 3 muestra una lista con las caractersticas mnimas y recomendadas que debe tener el equipo en el que
instalemos VS.NET.
Tabla 3. Requerimientos hardware para instalar Visual Studio .NET.
Sistema operativo
VS.NET puede ser instalado en un equipo con uno los siguientes sistemas operativos:
.
.
.
.
Para aprovechar todo el potencial de desarrollo de la plataforma, es recomendable usar como sistema operativo
Windows 2000, ya que ciertos aspectos del entorno (las caractersticas avanzadas de gestin grfica por ejemplo) no
estn disponibles si instalamos .NET en otro sistema con menos prestaciones.
Recomendaciones previas
Es recomendable realizar la instalacin sobre un equipo limpio, es decir, un equipo con el software mnimo para
poder realizar pruebas con .NET Framework, o con otro tipo de aplicaciones sobre las que estemos seguros de que no
se van a producir conflictos con el entorno.
En este sentido, una buena prctica consiste en crear en nuestro disco duro una particin que utilizaremos para
el trabajo cotidiano con el ordenador, y otra particin en la que instalaremos VS.NET.
Para ayudar al lector a formarse una idea ms aproximada en cuanto a configuraciones hardware y software, el
equipo utilizado para realizar las pruebas mostradas en este texto ha sido un Pentium III a 933 MHz, con 256 MB de
memoria y disco duro de 18 GB.
En cuanto a sistemas operativos, se han realizado dos particiones sobre el disco duro; en la particin primaria se
ha asignado un tamao de 2 GB y se instalado Windows 98. En el resto de espacio en disco se ha creado una unidad
lgica sobre la que se ha instalado Windows 2000 Server y el Service Pack 2 para este sistema operativo.
Respecto a las aplicaciones utilizadas, aparte naturalmente de VS.NET, hemos instalado Visual Studio 6.0 que
puede perfectamente convivir en el mismo equipo en el que est instalado .NET Framework y por ende VB.NET, de
esta forma podemos hacer pruebas con la herramienta de migracin de aplicaciones de VB.NET que convierte
aplicaciones escritas en VB6 a la nueva versin de VB. Como base de datos se ha utilizado SQL Server 2000 y como
conjunto de herramientas adicionales Office 2000.
El orden ms conveniente de instalacin en el equipo del software antes mencionado, de forma que evitemos
posibles conflictos ha sido el siguiente:
.
.
.
.
.
.
Ya que es posible que el programa de instalacin reinicie el equipo una o ms veces, a continuacin
estableceremos, en el caso de que existan en nuestro equipo, las claves de acceso al sistema, para que los reinicios sean
automticos. Ver Figura 27.
Pulsaremos a continuacin sobre Instalar ahora, con lo que se proceder a la actualizacin de los componentes
de la lista. Una vez terminada esta actualizacin, aceptaremos la ventana final de Windows Component Update y
seguiremos con la instalacin normal de VS.NET, lo que nos requerir de nuevo la introduccin del CD1.
Puesto que ya hemos actualizado los componentes del sistema, el siguiente paso ser ya la instalacin de
VS.NET, que pondremos en marcha al hacer clic sobre el paso 2 de la instalacin, que tiene el nombre de Visual
Studio .NET. Ver Figura 28.
Se mostrar pues, la pantalla con los datos de licencia, producto y usuario. En el caso de estar de acuerdo con
todos estos trminos y aceptar el contrato, haremos clic sobre Continuar. Ver Figura 29.
A continuacin debemos seleccionar aquellos elementos del producto que deseamos instalar, el entorno de
ejecucin, lenguajes, utilidades, ayuda, etc., y su ubicacin en el disco duro, como muestra la Figura 30. Terminada la
seleccin, pulsaremos sobre Instalar ahora para que comience el proceso.
Durante la instalacin, el programa nos solicitar progresivamente los discos rotulados como CD2 y CD3.
Este proceso de instalacin nos indica el archivo que se est instalando en cada momento, as como la
informacin de su estado a travs de una barra de progreso y el tiempo estimado restante, aunque por las pruebas
realizadas, este ltimo valor no es totalmente fiable. Para que el lector se forme una idea, en el equipo en el que se
realiz la instalacin, esta llevo un tiempo aproximado de dos horas. Ver Figura 31.
Concluida la instalacin, el programa nos informar de si se produjo alguna incidencia. En caso de que no se
hayan producido errores, finalizaremos haciendo clic sobre Listo, con lo que ya tendremos instalado Visual Studio
.NET en nuestro ordenador. Ver Figura 32.
La
primera
aplicacin
Como podemos observar, en este cuadro de dilogo hay varios puntos a tener en cuenta que describimos
seguidamente.
En la lista Tipos de proyecto podemos seleccionar el lenguaje en el que vamos a codificar el programa: Visual
Basic, C#, C++; as como otra serie de asistentes de instalacin, todo ello agrupado en diferentes carpetas. En este caso
elegiremos Proyectos de Visual Basic.
Una vez que sabemos el lenguaje a usar, debemos elegir el tipo de aplicacin en la lista Plantillas.
Seleccionaremos Aplicacin para Windows ya que vamos a crear un programa con interfaz tpica de Windows.
La gran ventaja de las plantillas radica en que al crear la aplicacin, nos proporciona la funcionalidad bsica de
la misma, que de otro modo tendramos que codificar manualmente.
Por ltimo, en el campo Nombre escribiremos HolaMundo como nombre para nuestra aplicacin y en el campo
Ubicacin estableceremos la carpeta del disco duro que contendr los ficheros del proyecto. Pulsando Aceptar se
crear el nuevo proyecto.
Formularios
Una vez creado el proyecto, se aade un formulario al mismo, apareciendo una nueva pestaa en el rea
principal del IDE, que corresponde al diseador del formulario. Ver Figura 40.
Dentro de una aplicacin VB.NET, el trmino formulario designa a una ventana estndar de las que utilizamos
habitualmente en Windows para comunicarnos con el usuario, mientras que el diseador del formulario representa a la
plantilla de una ventana, sobre la cul aadiremos controles y modificaremos si es necesario su aspecto inicial.
Un formulario es, al igual que la gran mayora de elementos en el entorno de .NET, un objeto, y como tal, la
forma de manipularlo pasa por asignar y obtener valores de sus propiedades, y por la ejecucin de sus mtodos.
Debido a que un formulario dispone de un elevado nmero de propiedades y mtodos, durante el texto nos
centraremos slo sobre los que vayamos a trabajar, pudiendo el lector, consultar el resto a travs de la ayuda de
VS.NET; esto es aplicable a todos los objetos con los que tratemos.
Situar el ratn en la pestaa Propiedades, que se halla generalmente en el margen derecho del IDE, que al
expandirse, nos mostrar la ventana Propiedades para el objeto que tengamos en ese momento activo en el proyecto.
Ver Figura 42.
En esta ventana, los nombres de las propiedades aparecen en la columna izquierda y su valor en la derecha. Por
defecto, las propiedades aparecen ordenadas por categoras, pero para acceder ms rpidamente a ellas a travs del
nombre, vamos a ordenarlas alfabticamente, pulsando el segundo botn de esta ventana comenzando por la izquierda.
Ver Figura 43.
La primera propiedad a mencionar, y la ms importante para cualquier objeto es Name, que contiene el nombre
del objeto que luego nos va a permitir manipularlo en el cdigo del programa. VB.NET asigna nombres por defecto a
los formularios y controles que agreguemos a la aplicacin. En este caso, el nombre que ha asignado al formulario es
Form1. Podemos modificar estos nombres por otros que sean ms significativos para el programador, sin embargo,
para simplificar este ejemplo, mantendremos los nombres que sean asignados por defecto.
El formulario en su estado actual, muestra como ttulo el mismo que tiene para el nombre. La propiedad que
contiene el ttulo del formulario es Text, y vamos a cambiarla por un valor que describa mejor la funcionalidad que
queremos dar al programa.
Para ello, haremos clic sobre el valor de la propiedad Text y cambiaremos el literal que aparece por el siguiente:
Programa de prueba. Al pulsar [INTRO], el diseador del formulario mostrar el nuevo ttulo.
Otro aspecto es referente a la posicin del formulario en pantalla cuando ejecutemos el programa. Actualmente
es Windows quien calcula dicha posicin, apareciendo en la zona superior izquierda de la pantalla. Podemos modificar
tambin esta posicin, para ello haremos clic en la propiedad StartPosition, que mostrar un botn que al ser pulsado
abrir una lista con los posibles valores disponibles. Seleccionaremos CenterScreen, y cada vez que ejecutemos el
programa, el formulario aparecer siempre en el centro de la pantalla.
Controles
Los controles constituyen aquellos elementos que insertamos dentro de un formulario, y que permiten al mismo
interactuar con el usuario, tales como botones de pulsacin, cajas de texto, casillas de verificacin, cajas con listas de
valores, etc.; al igual que un formulario, son objetos con sus propiedades y mtodos, y se manejan de la misma forma.
Para aadir un control a un formulario, en primer lugar situaremos el ratn sobre la pestaa Cuadro de
herramientas, que al expandirse mostrar los controles disponibles, que podemos incluir en un formulario. Ver Figura
44.
La operacin de aadir un control a un formulario se denomina dibujo de control, y podemos realizarla de varias
maneras:
.
Haciendo doble clic sobre el icono del control, lo que situar una copia del control en el formulario
con una posicin y tamao predefinidos por VB.NET.
.
Haciendo clic sobre el icono del control, y a continuacin clic sobre la superficie del formulario. El
nuevo control se insertar desde el punto en que hemos pulsado, extendindose hacia la derecha y abajo con un tamao
predeterminado por el diseador.
.
Haciendo clic sobre el icono del control, y seguidamente clic sobre la posicin del formulario en la
que queramos comenzar a dibujar el control, arrastraremos y soltaremos dando nosotros el tamao requerido al
control.
Label
Un control Label o Etiqueta es un control esttico. Eso quiere decir que no realiza ninguna interaccin con el
usuario, puesto que slo muestra un texto informativo.
Dibujaremos sobre el formulario un control de este tipo del modo descrito anteriormente, al que el diseador le
asignar el nombre Label1. A continuacin, con el control seleccionado, pasaremos a la ventana de propiedades. En la
propiedad Text escribiremos Hola Mundo, lo cual se reflejar tambin en el control dentro del diseador de
formularios. Ver Figura 45.
Ya que el tamao de Label1 con respecto al formulario es insignificante, aumentaremos dicho tamao haciendo
clic sobre el control; esto mostrar alrededor del mismo una serie de recuadros o guas de redimensin. Haciendo clic
sobre cualquiera de ellas y arrastrando el ratn, variaremos el tamao del Label hasta conseguir uno ms adecuado.
Tambin podemos hacer clic sobre el control y arrastrarlo, cambiando la posicin en la que lo habamos
dibujado originalmente.
Ahora debemos cambiar el tamao del tipo de letra, y para ello emplearemos la propiedad Font o Fuente del
control. Pasaremos pues a la ventana de propiedades, observando como esta propiedad muestra en su valor el nombre
del fuente actual. Ver Figura 46.
Haciendo clic sobre Font, aparecer un botn con puntos suspensivos, que al ser pulsado, abrir el cuadro de
dilogo estndar del sistema para seleccin de tipos de letra. Ver Figura 47
Cambiando el tamao del tipo de letra a 20 y pulsando Aceptar, aumentar la letra del Label que tenemos en el
formulario.
Ejecutando la aplicacin
En este punto del desarrollo, daremos por concluida la aplicacin. Ahora debemos ejecutarla para comprobar
que todo funciona correctamente. Podemos hacerlo empleando una de las siguientes formas:
. Seleccionar la opcin Depurar + Iniciar en el men de VS.NET.
. Pulsar [F5].
. Pulsar el botn Iniciar de la barra de herramientas. Ver Figura 48.
Figura 48. Botn Iniciar de la barra de herramientas de VS.NET.
Esta accin compilar el proyecto y generar la aplicacin, ejecutndola desde el propio IDE. El resultado ser
la visualizacin del formulario de la Figura 49.
Este formulario podemos manipularlo de igual forma que cualquier otro de los que existan en el sistema:
redimensionarlo, maximizarlo, minimizarlo, etc.
Como ventaja aadida, observe el lector que para crear este programa no ha necesitado escribir ni una sola lnea
de cdigo, todo lo ha realizado a travs de los diseadores y dems elementos del IDE.
El cdigo de la aplicacin
Quiere lo anterior decir que un formulario no tiene cdigo?. La respuesta es no, toda aplicacin VB.NET tiene
su correspondiente cdigo, lo que ocurre en el caso del formulario que acabamos de crear, es que al haberlo hecho
desde el diseador de formulario, su cdigo lo genera el IDE por nosotros, lo que supone una gran ayuda.
Para acceder al cdigo fuente del formulario, hemos de hacerlo de alguna de las siguientes maneras:
.
.
.
Cualquiera de las anteriores acciones abre una nueva pestaa en la zona principal del IDE, mostrando el editor
de cdigo del formulario. Ver Figura 50.
Sin embargo falta un pequeo detalle, ya que evidentemente, no es posible que un formulario tenga tan pocas
lneas de cdigo. Lo que ocurre es que el cdigo generado por el diseador, est oculto por una tcnica denominada
Esquematizacin (Outlining), que permite definir zonas y regiones de cdigo que pueden ser expandidas o contradas
desde el editor de cdigo, haciendo clic en los indicadores de la regin correspondiente.
En este caso, el diseador ha creado una regin con el nombre Windows Form Designer generated code, y la ha
contrado. Podemos reconocer una regin de cdigo contrada porque su nombre se encuentra dentro de un rectngulo.
Para expandir una regin de cdigo, haremos clic en el signo + que se encuentra a la izquierda de su nombre, lo
que mostrar su contenido al completo. En nuestro caso accederemos al cdigo del formulario Form1, que
reproducimos en el Cdigo fuente 9.
Public
Inherits
Class
Form1
System.Windows.Forms.Form
#Region
"
Windows
Form
Designer
Public
MyBase.New()
code
"
Sub
'This
call
InitializeComponent()
'Add
generated
any
is
required
initialization
New()
by
the
after
the
Windows
Form
Designer.
InitializeComponent()
call
End
Sub
'Form
overrides
dispose
to
clean
up
Protected Overloads Overrides Sub Dispose(ByVal
If
disposing
If
Not
(components
Is
components.Dispose()
the
component
list.
disposing As Boolean)
Then
Nothing)
Then
End
End
MyBase.Dispose(disposing)
If
If
End
Friend
'Required
Private
Sub
WithEvents
Label1
by
components
the
New
Windows
required
the
using
Private
by
System.Windows.Forms.Label()
System.Drawing.Font("Microsoft
Form
Designer
System.ComponentModel.Container
the
Windows
Form
Designer
Windows
Form
Designer.
the
code
editor.
Sub
InitializeComponent()
New
System.Drawing.FontStyle.Regular,
Byte))
Me.Label1.Location
Me.Label1.Name
Me.Label1.Size
Me.Label1.TabIndex
Me.Label1.Text
'
'Form1
'
System.Windows.Forms.Label
As
'NOTE:
The
following
procedure
is
'It
can
be
modified
using
'Do
not
modify
it
<System.Diagnostics.DebuggerStepThrough()>
Me.Label1
Me.SuspendLayout()
'
'Label1
'
Me.Label1.Font
=
As
Sans
Serif",
System.Drawing.GraphicsUnit.Point,
New
System.Drawing.Point(56,
=
New
=
System.Drawing.Size(184,
=
"Hola
20.25!,
CType(0,
56)
"Label1"
40)
0
Mundo"
Me.AutoScaleBaseSize
Me.ClientSize
=
Me.Controls.AddRange(New
Me.Name
Me.StartPosition
Me.Text
=
Me.ResumeLayout(False)
New
System.Drawing.Size(5,
13)
New
System.Drawing.Size(292,
273)
System.Windows.Forms.Control()
{Me.Label1})
=
"Form1"
System.Windows.Forms.FormStartPosition.CenterScreen
"Programa
de
prueba"
End
Sub
#End
Region
End
Class
Cdigo fuente 9.
El lector puede estar sorprendido ante tal cantidad de cdigo para un simple formulario, por lo que vamos a
analizar brevemente cada una de las partes que componen este fuente para comprobar que todas son necesarias.
Public
Class
Inherits
.
Form1
System.Windows.Forms.Form
.
Class
End
Cdigo fuente 10
Por el mero hecho de establecer una relacin de herencia entre Form y Form1, toda la funcionalidad de la clase
Form (que representa la clase padre o base) pasa a la nueva clase Form1 (que representa a la clase hija o derivada), a la
que podremos aadir nuevas caractersticas propias, de forma similar a como se establece una relacin real padre-hijo.
Para ms informacin sobre los espacios de nombres, consulte el lector el tema dedicado a .NET Framework.
Public
MyBase.New()
Sub
'This
call
InitializeComponent()
'Add
any
is
required
initialization
New()
by
the
after
the
Windows
Form
InitializeComponent()
End
Designer.
call
Sub
Cdigo fuente 11
Puesto que nuestra clase Form1 hereda de la clase Form, en el mtodo constructor de Form1 llamamos al
mtodo constructor de la clase base con MyBase.New( ). La palabra clave MyBase representa al objeto de la clase
padre. Por ltimo llamamos al mtodo InitializeComponent( ), que como su nombre indica, se encarga de inicializar
los componentes del formulario: configura las propiedades del formulario, crea y aade los controles.
cualquier elemento del formulario (propiedades, mtodos, etc), desde dentro del propio formulario. Aunque no es
necesario el uso de Me, se recomienda por hacer ms fcil la lectura del cdigo; el propio IDE al generar el cdigo
utiliza esta palabra, lo cual es indicativo de su importancia.
Se instancia el control Label1, y se asigna valor a sus propiedades, para ms adelante, agregarlo a la lista de
controles del formulario con el mtodo AddRange( ) de la coleccin Controls del formulario.
Tambin se establecen valores para las propiedades del formulario, y durante todo este tiempo, para evitar
efectos extraos de visualizacin, esta es suspendida para el formulario, y se vuelve a reanudar al final. Esto se
consigue con los mtodos SuspendLayout( ) y ResumeLayout( ) del formulario. Ver el Cdigo fuente 12.
Friend
WithEvents
'Required
Private
Label1
by
components
the
Windows
required
the
using
Private
by
New
System.Drawing.Font("Microsoft
New
New
=
New
New
Me.Controls.AddRange(New
Me.Name
Me.StartPosition
=
Me.Text
=
Me.ResumeLayout(False)
Form
Designer
System.ComponentModel.Container
the
Windows
Form
Designer
Windows
Form
Designer.
the
code
editor.
Sub
InitializeComponent()
New
System.Drawing.FontStyle.Regular,
Byte))
Me.Label1.Location
Me.Label1.Name
Me.Label1.Size
=
Me.Label1.TabIndex
Me.Label1.Text
'
'Form1
'
Me.AutoScaleBaseSize
Me.ClientSize
=
System.Windows.Forms.Label
As
'NOTE:
The
following
procedure
is
'It
can
be
modified
using
'Do
not
modify
it
<System.Diagnostics.DebuggerStepThrough()>
Me.Label1
Me.SuspendLayout()
'
'Label1
'
Me.Label1.Font
=
As
System.Windows.Forms.Label()
Sans
Serif",
System.Drawing.GraphicsUnit.Point,
20.25!,
CType(0,
System.Drawing.Point(56,
56)
=
"Label1"
System.Drawing.Size(184,
40)
=
0
"Hola
Mundo"
System.Drawing.Size(5,
System.Drawing.Size(292,
13)
273)
System.Windows.Forms.Control()
{Me.Label1})
=
"Form1"
System.Windows.Forms.FormStartPosition.CenterScreen
"Programa
de
prueba"
End
Sub
Cdigo fuente 12
entorno para que el recolector de basura de la plataforma, los recupere cuando considere necesario. Esta accin se
emplea tanto para los componentes, representados por la variable components, como para el propio formulario, en la
llamada que hace a este mismo mtodo en su clase base. Ver Cdigo fuente 13.
'Form
overrides
dispose
to
clean
up
Protected Overloads Overrides Sub Dispose(ByVal
If
disposing
If
Not
(components
Is
components.Dispose()
the
component
list.
disposing As Boolean)
Then
Nothing)
Then
End
End
MyBase.Dispose(disposing)
End
If
If
Sub
Cdigo fuente 13
Si modificamos los elementos del proyecto (formularios, clases, mdulos, etc), debemos grabar los cambios en
alguna de las siguientes maneras:
. Opcin Generar + Generar del men de VS.NET.
.
Opcin Depurar + Iniciar del men de VS.NET.
.
Pulsando [F5] al ejecutar el proyecto en modo de prueba. Los elementos del proyecto que se hayan
modificado y no se hayan grabado, se grabarn automticamente.
Un proyecto VB.NET est compuesto por un conjunto de ficheros, cuyos tipos han variado notablemente desde
VB6. Clasificados por su extensin, a continuacin se relacionan algunos de estos ficheros:
.
VB. Cdigo fuente escrito en lenguaje Visual Basic. A diferencia de VB6, en el que haba diferentes
tipos de ficheros en funcin de si se trataba de un formulario, clase, mdulo de cdigo, etc., un fichero con extensin
VB puede contener cualquier tipo de cdigo en VB: clases, mdulos de cdigo, etc.
.
VBPROJ. Proyecto de VB. Contiene informacin sobre todos los elementos que forman parte de un
proyecto: ficheros de cdigo, referencias, etc.
.
SLN (Solucin). Una solucin es el medio que utiliza VS.NET para agrupar varios proyectos escritos
en el mismo o en diferentes lenguajes de los que integran la plataforma .NET.
.
VBPROJ.USER. Informacin sobre las opciones de usuario del proyecto.
.
RESX. Plantilla de recursos en formato XML.
.
EXE. Aplicacin ejecutable.
.
PDB. Informacin sobre depuracin de la aplicacin
En el directorio bin del proyecto se genera el fichero ejecutable, que contiene nuestra aplicacin y que en
principio es lo nico que necesitamos para ejecutar el programa en cualquier otro equipo, que naturalmente, tambin
tenga instalado la plataforma .NET Framework. Ello nos evita problemas y ahorra tiempo de instalacin.
Una vez grabado el proyecto a disco, podemos dar por concluido el desarrollo de nuestro primer programa Hola
Mundo.
Escritura
de
cdigo
Crear el proyecto
En primer lugar, iniciaremos el IDE de VS.NET y crearemos un nuevo proyecto en VB.NET de la misma forma
que la explicada en el tema anterior. El nombre que daremos al proyecto ser EscribirCodigo.
Al igual que en el ejemplo HolaMundo, este tipo de proyecto crea un formulario vaco, pero no vamos a hacer
uso del mismo. A continuacin, agregaremos un nuevo mdulo al proyecto para el cdigo que vamos a escribir.
Mediante la opcin de men de VS.NET Proyecto + Agregar mdulo, se abrir la caja de dilogo Agregar
nuevo elemento, con la que podremos aadir a nuestro proyecto un mdulo (como este caso), formulario, clase, etc.,
seleccionando dicho elemento del panel derecho. Ver Figura 52.
Daremos el nombre MiCodigo.VB al mdulo, con lo que se crear el nuevo mdulo en un fichero y se mostrar
una nueva pestaa en la ventana principal del IDE con el editor de cdigo para el mdulo. Ver Figura 53. Un mdulo
se define mediante las palabras clave Module...End Module, que indican respectivamente el comienzo y fin del
mdulo, y entre ellas escribiremos el cdigo que va a contener: procedimientos, declaraciones, etc.
CodigoProg.VB
=============
Class
Cliente
'
cdigo
de
la
'
'
End
............
............
Class
Module
General
'
cdigo
del
mdulo
'
'
End
............
............
Module
Class
'
Facturas
cdigo
'
'
End
clase
de
la
clase
............
............
Class
Cdigo fuente 14
Aunque tambin podemos aadir todos los ficheros .VB que necesitemos al proyecto, para tener nuestro cdigo
organizado por procedimientos generales, procedimientos especficos de la aplicacin, clases de formularios, clases no
visuales, etc., este el modo recomendado de organizacin cuando el programa es muy grande. Ver Cdigo fuente 15.
En cualquier caso, disponemos de una gran flexibilidad a este respecto.
CodigoClases.VB
=============
Class
Cliente
'
cdigo
de
la
clase
............
............
'
'
End
'
'
'
Class
Class
cdigo
Facturas
la
clase
............
............
de
End
**************************************************
Class
RutinasVarias.VB
================
Module
General
'
cdigo
del
mdulo
............
............
'
'
End
'
'
'
Module
Module
cdigo
del
Listados
mdulo
............
............
End
Module
Cdigo fuente 15
Comentarios de cdigo
Para introducir un comentario aclaratorio en el cdigo de un programa utilizaremos la comilla simple ( ),
seguida del texto correspondiente al comentario. Podemos insertar comentarios desde el comienzo de lnea o a
continuacin de cdigo ejecutable. Ver Cdigo fuente 16.
Sub
'
este
Dim
Valor
es
un
End
Cdigo fuente 16
comentario
Valor
158
'
este
desde
es
el
As
un
principio
comentario
Prueba()
de
lnea
Integer
junto
una
lnea
de
cdigo
Sub
Procedimientos
Dentro de cualquier lenguaje de programacin, un procedimiento o rutina de cdigo es aquella entidad que
guarda un conjunto de lneas de cdigo que sern ejecutadas al llamar al procedimiento desde cualquier otro punto del
programa.
Para crear un procedimiento en el programa usaremos las palabras clave Sub...End Sub, y entre las mismas
escribiremos las instrucciones del procedimiento. El Cdigo fuente 17 muestra un ejemplo.
Sub
Prueba()
'
instruccin1
'
instruccin2
'
instruccin3
'
............
'
............
'
............
'
End
instruccinN
Sub
Los procedimientos podemos incluirlos en cualquier lugar dentro del programa. En el ejemplo actual,
escribiremos un procedimiento en el mdulo MiCodigo, al que daremos el nombre de Main( ) y que representa el
procedimiento por el cual se comienza a ejecutar la aplicacin.
Module
MiCodigo
Sub
Main()
End
Sub
End
Module
Cdigo fuente 18
La clase MessageBox
Queremos mostrar un aviso cuando empecemos a ejecutar la aplicacin, por lo que podemos usar la clase
MessageBox. Esta es una clase del sistema, que permite mostrar un mensaje en pantalla al usuario mediante su mtodo
Show( ), y una cadena de caracteres que pasaremos como parmetro a dicho mtodo.
Se trata de una clase no instanciable, es decir, no permite que creemos objetos a partir de ella. Al utilizarla, es el
entorno el encargado de crear un objeto compartido, que usaremos para llamar a sus miembros compartidos o shared.
Para usar esta clase en nuestro procedimiento Main( ), podemos hacerlo como se muestra en el Cdigo fuente
19.
Sub
Main()
MessageBox.Show("Empieza
el
End
programa")
Sub
Cdigo fuente 19
Seguidamente haremos clic sobre el nombre del proyecto, y para acceder a sus propiedades emplearemos alguna
de las siguientes formas:
Haremos clic sobre el tercer botn de esta ventana, que corresponde a las propiedades del elemento
seleccionado. Ver Figura 56.
.
Seleccionaremos la opcin de men de VS.NET Proyecto + Propiedades.
.
Haremos clic sobre el nombre del proyecto en el Explorador de soluciones, y seleccionaremos la
opcin Propiedades del men contextual.
Cualquiera de estas acciones nos mostrar la ventana de propiedades del proyecto en ella, debemos abrir la lista
desplegable del elemento Objeto inicial, que actualmente mostrar el nombre del formulario como objeto inicial, y
seleccionar Sub Main. Pulsaremos Aceptar y a partir de ese momento, el entorno de ejecucin buscar un
procedimiento con el nombre Main( ), para ejecutar en primer lugar. Ver Figura 57.
El resultado ahora, al ejecutar el programa, ser el mensaje que mostramos a travs de MessageBox. Ver Figura
58.
Variables
Creemos que mostrar un simple mensaje es insuficiente en este ejemplo, por lo que vamos adems, a pedir al
usuario que introduzca un valor, que mostraremos en otro mensaje posterior. Dicho valor lo almacenaremos en una
variable del programa.
Para declarar variables en VB.NET utilizaremos la instruccin Dim, seguida del nombre de la variable y el tipo
de dato que queremos asignarle. En Main( ) declararemos una variable como muestra el Cdigo fuente 20.
Sub
Main()
MessageBox.Show("Empieza
Dim
Nombre
End
As
el
programa")
String
Sub
Cdigo fuente 20
InputBox( )
InputBox( ) es una funcin que muestra una caja de dilogo en la que el usuario puede introducir un valor, que
ser devuelto al aceptar dicha caja. El Cdigo fuente 21 muestra el formato de InputBox( ).
InputBox(Mensaje,Ttulo,RespuestaDefecto,XPosicion,YPosicion)
Cdigo fuente 21
.
.
Mensaje. Obligatorio. Cadena de caracteres con el texto que va a mostrar la caja de dilogo.
Ttulo. Opcional. Ttulo que aparecer en la caja de dilogo.
.
RespuestaDefecto. Opcional. Cadena de caracteres con el valor que devolver esta funcin, en el caso
de que el usuario no escriba nada.
.
XPosicion, YPosicion. Opcionales. Valores numricos que indican las coordenadas en donde ser
mostrada la caja. Si se omiten, se mostrar en el centro de la pantalla.
Completando el procedimiento
Llegados a este punto del ejemplo, tenemos todos los ingredientes para completarlo. Necesitamos que el usuario
introduzca su nombre utilizando InputBox( ), volcar dicho nombre en la variable que hemos declarado y mostrarlo
usando otro MessageBox. Todo ello lo vemos en el Cdigo fuente 22.
Sub
Main()
MessageBox.Show("Empieza
Dim
Nombre
MessageBox.Show("El
el
Nombre
As
=
nombre
programa")
InputBox("Escribe
del
usuario
End
es:
"
&
String
tu
Nombre,
"Programa
nombre")
de
prueba")
Sub
Cdigo fuente 22
Despus de escribir su nombre en el campo de la caja, si el usuario pulsa OK, InputBox( ) devolver el valor de
dicho campo a la variable Nombre. Por ltimo, mostraremos el valor de la variable usando el mtodo Show( ) de
MessageBox, pero con algunas variaciones respecto a la primera vez que utilizamos esta clase en Main( ). En este caso
concatenamos una cadena de caracteres al nombre, para ello debemos utilizar el operador &, y empleamos un segundo
parmetro, que muestra un ttulo en la ventana del mensaje. Ver Figura 60.
Finalizamos el programa
Tras la ejecucin del programa para comprobar que todo funciona correctamente, grabamos si es necesario, los
ltimos cambios del proyecto y podemos dar por concluida la aplicacin.
Un programa ms operativo
En este tema vamos a escribir una aplicacin algo ms completa, que consistir en un formulario en el que
introduciremos el nombre de un fichero y un pequeo texto, que seguidamente grabaremos en nuestro equipo. As que,
una vez esbozado el objetivo a conseguir... manos a la obra.
La forma de dibujar un control en un formulario ya ha sido explicada anteriormente, por lo que directamente
mostramos en la Figura 62, el formulario resultante con los controles ya insertados, en donde indicamos el tipo de
control y el nombre que hemos asignado a cada control en su propiedad Name.
A continuacin detallamos brevemente la funcionalidad de cada uno de los controles de este formulario:
.
Label1, Label2. Muestran un simple literal que indica al usuario lo que debe introducir en los
controles de texto.
.
txtNombreFichero. Contiene el nombre que daremos al fichero en el que grabaremos el texto.
.
txtTexto. Contiene el texto que se va a guardar en un fichero. La diferencia de este control, con el otro
control de tipo TextBox del formulario, reside en que permite escribir varias lneas de texto, gracias a que hemos
asignado a su propiedad Multiline el valor True. La propiedad Multiline por defecto contiene False, lo que indica que
un TextBox slo permite introducir el texto en una nica lnea.
.
btnGrabar. Al pulsar este botn, se tomar el texto del control txtTexto y se grabar en un fichero
con el nombre que contenga el control txtNombreFichero. Veremos como escribir el cdigo para un control ms
adelante.
.
btnSalir. Al pulsar este botn, se finalizar la ejecucin del programa, de igual forma que si
pulsramos el botn de cierre del formulario o [ALT+F4].
Observe el lector que al asignar el nombre de algunos controles, hemos utilizado un prefijo. As, para un
TextBox utilizamos el prefijo txt (txtNombreControl); para un Button, btn (btnNombreControl), etc.
Esta tcnica, denominada convenciones de notacin, consiste en una serie de normas no obligatorias, utilizadas
a la hora de escribir el cdigo, y que son pactadas generalmente en equipos de trabajo, de manera que cuando un
programador debe tomar parte de un proyecto que ha estado desarrollando otro programador, la interpretacin del
cdigo se facilita, y el desarrollo del proyecto en este sentido, se dinamiza.
El programador independiente puede igualmente utilizar este tipo de convenciones, ya que gran parte del cdigo
fuente que circula en artculos, demos, aplicaciones shareware, etc., emplean una serie de convenciones genricas de
notacin, por lo que si necesita en algn momento compartir su cdigo, la legibilidad del mismo se facilita.
La Tabla 4 muestra una serie de convenciones para la codificacin de los nombres de controles, que
proponemos como ejemplo, para que el lector utilice estas o alguna similar.
Controles y eventos
Windows es un sistema basado en eventos. Esto quiere decir que cualquier cosa que ocurra dentro de un
formulario, bien sobre el propio formulario, o a cualquiera de los controles que lo componen, se detecta a travs de un
suceso o evento: pasar el ratn sobre un control, hacer clic, escribir en un control de texto, cerrar el formulario,
redimensionarlo, etc. Cualquier accin de este tipo provoca el evento correspondiente.
En nuestro ejemplo actual, si ejecutamos el programa y hacemos clic sobre alguno de los botones del
formulario, no ocurrir nada en absoluto. Quiere esto decir que los botones no tienen eventos?, la respuesta es no, los
botones s tienen eventos, as como los dems controles, y aunque no lo percibamos, se estn produciendo
constantemente, lo que sucede, es que una vez que dibujamos un control en un formulario, dicho control inicialmente
no est programado para responder a los eventos, por lo que debemos escribir el cdigo para el evento
correspondiente, en respuesta a la accin del usuario.
Siguiendo con los botones del formulario, vamos a elegir el ms sencillo de codificar, btnSalir. Para escribir el
cdigo del evento correspondiente a la pulsacin de este control, la forma mas rpida es haciendo doble clic sobre l
en el diseador del formulario, lo que abrir el editor de cdigo y nos situar en un procedimiento vaco que
mostramos en el Cdigo fuente 23.
Private Sub
System.EventArgs)
btnSalir_Click(ByVal sender
Handles
As
End
System.Object, ByVal e As
btnSalir.Click
Sub
Se trata de un procedimiento cuyo nombre, btnSalir_Click, compuesto del nombre del control y del evento, lo
proporciona automticamente el IDE. Recibe dos parmetros: sender y e, con informacin adicional proporcionada por
el entorno. Pero lo verdaderamente importante est al final de la declaracin: Handles btnSalir.Click. La palabra
clave Handles, seguida del nombre de un control, un punto y el nombre de un evento de ese control, le indica al
entorno de .NET Framework que debe ejecutar este procedimiento cuando se produzca el evento para ese control. No
realizaremos en este momento una explicacin ms detallada puesto que trataremos este aspecto con ms profundidad
en temas posteriores del texto.
Este procedimiento ser ejecutado cada vez que pulsemos el control btnSalir, por lo que si en tal situacin,
queremos cerrar el formulario, slo ser necesario incluir la lnea de cdigo mostrada en el Cdigo fuente 24.
Private Sub
System.EventArgs)
'
Me.Close()
btnSalir_Click(ByVal sender
Handles
As
cerrar
System.Object, ByVal e As
btnSalir.Click
el
End
formulario
Sub
Cdigo fuente 24. Cdigo del evento Click para cerrar un formulario.
El mtodo Close( ) del formulario, produce su cierre, y por ende, la finalizacin del programa. El efecto es el
mismo que si pulsamos el botn de cierre del formulario o la combinacin [ALT+F4]. La palabra clave Me indica que
estamos haciendo usando una propiedad o mtodo del formulario desde el interior de la clase del propio formulario;
esta palabra clave ser explicada con ms detalle en el tema dedicado a la programacin orientada a objeto.
Ahora nos formularemos una interesante cuestin: -Y por qu saba VS.NET cul evento quera codificar y me
lo ha mostrado directamente?-. Pues sencillamente, VS.NET no lo saba, lo que sucede es que cuando hacemos doble
clic sobre un control en el diseador del formulario, se abre el editor de cdigo y nos sita en el evento por defecto del
control. Y sucede que el evento por defecto de un control Button es Click( ).
Esta lista muestra todos los eventos que podemos codificar para el control que hemos seleccionado en el
formulario. Al seleccionar el evento Click( ), se mostrar la declaracin de dicho procedimiento de evento vaca para
escribir las acciones descritas anteriormente.
'
btnGrabar_Click(ByVal sender
Handles
declarar
'
una
de
As
variable
texto
Dim
System.Object, ByVal e As
btnGrabar.Click
para
en
crear
'
'
fichero
obtener
StreamWriter
de
un
texto
objeto
escribir
'
cerrar
'
el
fichero,
el
control
objeto,
fichero
lo
que
eliminar
vaco
StreamWriter
en
el
oEscritor
=
File.CreateText(Environment.CurrentDirectory
Me.txtNombreFichero.Text
&
'
escribir
en
'
oEscritor.Write(Me.txtTexto.Text)
fichero
As
un
para
escritura
un
oEscritor
'
la
&
fichero
"\"
&
".TXT")
el
contenido
cierra
tambin
el
del
TextBox
el
objeto
oEscritor.Close()
oEscritor
End
Nothing
Sub
En primer lugar declaramos la variable oEscritor de tipo StreamWriter. Este tipo de objetos nos permitirn
realizar la escritura de un flujo (stream) de caracteres sobre un fichero del disco.
A continuacin, vamos a crear un fichero de texto en nuestro disco duro, en la misma ruta en la que se est
ejecutando la aplicacin. Esto lo conseguimos llamando al mtodo compartido CreateText( ), del objeto File (observe
el lector que al ser un mtodo compartido no necesitamos instanciar un objeto de la clase File y pasarlo a una
variable).
El mtodo CreateText( ) recibe como parmetro una cadena de caracteres con la ruta y el nombre del fichero a
crear. Para componer esta ruta utilizamos por un lado el objeto Environment y su propiedad compartida
CurrentDirectory que devuelve la ruta del directorio actual en donde se est ejecutando la aplicacin, y por otro lado la
propiedad Text del control txtNombreFichero, que contiene el valor que el usuario haya escrito en dicho TextBox.
Estos dos elementos los unimos, formando una sola cadena, mediante el operador de concatenacin de VB: &.
La llamada a CreateText( ) devuelve un objeto de tipo StreamWriter, que depositamos en la variable oEscritor,
con lo que ya tenemos en la variable un objeto para escribir texto.
El siguiente paso consiste en llamar al mtodo Write( ) de oEscritor y pasarle como parmetro la propiedad Text
del control txtTexto, que contiene el texto escrito por el usuario. Este texto es grabado en el fichero.
Para finalizar, cerramos el objeto oEscritor llamando a su mtodo Close( ) y le asignamos la palabra clave
Nothing para liberar los recursos del sistema que pudiera estar utilizando.
Observe el lector, como el formato de manipulacin de objetos se basa en la variable que contiene el objeto o el
propio nombre del objeto (si es compartido), un punto y el nombre del mtodo a llamar o propiedad de la que
recuperamos o a la que asignamos un valor, tal y como muestra de forma esquemtica el Cdigo fuente 26.
' objetos instanciados '---------------------oVar.Propiedad = valor ' asignar valor a
propiedad variable = oVar.Propiedad ' recuperar valor de propiedad oVar.Metodo([ListaParametros])
' llamar a mtodo variable = oVar.Metodo([ListaParametros]) ' llamar a mtodo y recuperar valor
' objetos compartidos '---------------------Objeto.Propiedad = valor ' asignar valor a
propiedad
variable
=
Objeto.Propiedad
'
recuperar
valor
de
propiedad
Objeto.Metodo([ListaParametros]) ' llamar a mtodo Variable = Objeto.Metodo([ListaParametros]) '
llamar a mtodo y recuperar valor
Cdigo fuente 26. Modos de manipulacin propiedades y mtodos de objetos.
Ya slo queda ejecutar el programa, escribir valores en los controles, y generar el fichero de texto para
comprobar que todo funciona correctamente, con ello habremos conseguido crear un programa que tenga una
aplicacin algo ms prctica que el tpico hola mundo.
La descripcin del IDE se abordar en esta obra de dos formas: una de ellas ser en el tema actual, dentro del
que se explicarn los aspectos generales. La otra forma ser a lo largo de los distintos temas del texto que as lo
requieran, ya que ciertos aspectos especficos del IDE es recomendable describirlos en el tema con el que guardan una
mayor relacin.
La pgina de inicio
Nada ms iniciar VS.NET, se muestra la pgina de inicio del IDE. Ver Figura 65.
Desde esta pgina podemos realizar una primera configuracin del entorno, ya que si hacemos clic en el vnculo
Mi perfil, situado en la columna izquierda, accederemos a una pantalla en la que podemos establecer una configuracin
adaptada al lenguaje con el que vamos a programar. Ver Figura 66.
Como puede comprobar el lector, podemos configurar el perfil general para adaptar a nuestra comodidad la
totalidad del IDE, o bien hacerlo slo sobre ciertos elementos como el teclado, diseo de ventana, etc.
Establezca el lector el perfil que prefiera, por el momento recomendamos elegir slo la combinacin de teclado
adaptada a un perfil de programador de Visual Basic 6. El resto de elementos los dejaremos como estaban por defecto,
ya que si adaptamos la totalidad del IDE al perfil de VB, se expandirn muchas de las ventanas ocultas adicionales,
dejando poco espacio en la ventana principal de trabajo.
Configurado el perfil del programador, haremos clic en el vnculo Introduccin, de la columna izquierda, para
volver al punto inicial, en el que crearemos un nuevo proyecto de VB.NET, de la forma explicada en el tema La
primera aplicacin, que nos servir para hacer las pruebas sobre los diferentes aspectos del IDE.
Si por cualquier motivo, cerramos la pgina de inicio, podemos volver a visualizarla utilizando alguna de las
siguientes formas:
Opcin de men Ayuda + Mostrar pgina de inicio o bien con Ver + Explorador Web + Inicio.
.
.
En los siguientes apartados realizaremos una descripcin ms detallada de algunos de estos componentes del
IDE y el modo de trabajar con ellos.
dejaremos a estos elementos los nombres que asigna por defecto el IDE. Si adems, en los dos diseadores de
formulario que deberemos tener actualmente, seleccionamos la opcin Ver + Cdigo, se aadirn los correspondientes
editores de cdigo a la ventana, que mostrar un aspecto similar al de la Figura 68.
Podemos cambiar de diseador con un simple clic sobre su ficha correspondiente o la combinacin de teclas
[CTRL.+TAB]. Cuando la ventana se llene totalmente de fichas, podemos desplazarnos entre las mismas mediante los
dos iconos de la parte superior derecha que muestra unas flechas de direccin. Si queremos cerrar alguna de las fichas,
podemos hacerlo igualmente pulsando el icono de cierre de esta ventana o la combinacin [CTRL.+F4].
Para cambiar la posicin de las fichas, debemos hacer clic sobre la ficha que queramos cambiar y arrastrar hacia
una nueva posicin.
La organizacin en fichas, supone un importante cambio en el modo de trabajo respecto a VB6, que aporta una
mayor comodidad a la hora de tener abiertos simultneamente diversos editores y diseadores. Sin embargo, si el
programador se siente ms confortable con la antigua organizacin basada en ventanas, puede cambiar a dicha
configuracin seleccionando la opcin de men Herramientas + Opciones, que mostrar la ventana de opciones de
configuracin del IDE. Ver Figura
69.
En el caso de que no estemos posicionados inicialmente, debemos seleccionar en la parte izquierda de esta
ventana, la carpeta Entorno y su apartado General. A continuacin pulsaremos sobre la opcin Entorno MDI y pulsar
Aceptar, ver Figura 70. Debemos tener en cuenta, que los cambios no se reflejarn hasta la prxima vez que iniciemos
VS.NET. Si queremos volver al modo inicial, tendremos que pulsar sobre Organizacin por fichas.
Es posible crear una nueva ventana para albergar fichas, usando la opcin de men Ventana + Nuevo grupo de
fichas horizontal, o la opcin Ventana + Nuevo grupo de fichas vertical, a la que podremos mover fichas desde la
ventana original con slo arrastrar y soltar. Ver Figura 71.
Habr ocasiones en que necesitaremos tener permanentemente visible una ventana adicional. Para ello, y una
vez que tengamos visible la ventana, debemos cambiar su estado a Acoplable, haciendo clic sobre el icono en forma de
chincheta que aparece en la barra de ttulo. Esto har que cambie dicho icono de forma indicando el nuevo estado. Ver
Figura 74 y Figura 75.
Una ventana acoplable o fija no se oculta cuando pasamos a cualquier otra ventana del IDE.
Tambin puede ser til en algunas situaciones, permitir que una ventana pueda moverse libremente por todo el
rea del IDE, para lo que en tal caso, haremos clic derecho sobre su ttulo y elegiremos la opcin Flotante, lo que
dejar a dicha ventana libre para ser situada en cualquier lugar del IDE, sin la obligacin de estar ajustada a ningn
borde del entorno de desarrollo. Ver Figura 76.
Para ocultar una de estas ventanas, haremos clic en su icono de cierre o en su men contextual de estado, opcin
Ocultar.
El acople de una ventana no es obligatorio realizarlo siempre en los laterales, tambin podemos ajustar una de
estas ventanas a la parte inferior o superior del IDE. Para ello hemos de arrastrar la ventana hacia uno de los bordes del
IDE hasta el momento en que se muestre un rectngulo que representa la gua o modo en cmo se va a acoplar dicha
ventana. Ver Figura 77.
Al soltar en el momento en que aparece la gua de acople, la ventana quedar fijada en concordancia. Ver Figura
78.
Podemos conseguir un acople entre mltiples ventanas, arrastrando una de ellas hacia la zona de trabajo de otra
y soltando en el momento en que aparezca la gua de acople. La Figura 79 muestra tres ventanas con diferentes acoples
realizados entre ellas.
Finalmente, es posible tambin acoplar mltiples ventanas pero organizarlas mediante fichas, de modo que slo
se visualice una ventana a la vez haciendo clic en la ficha con el ttulo de la ventana. Al acoplar una ventana para que
se muestre de esta forma, debemos situarla sobre el ttulo de otra, apareciendo la gua de acople como muestra la
Figura 80.
En la Figura 81 tenemos mltiples ventanas acopladas organizadas de esta manera. Podemos cambiar entre ellas
haciendo clic en la ficha mostrada en la parte inferior.
Para separar cualquiera de estas ventanas, basta con hacer clic sobre su ficha y arrastrar hacia el exterior de la
ventana contenedora.
El Explorador de soluciones
Al desarrollar una aplicacin en VB.NET, los elementos que contiene: formularios, mdulos, clases, recursos,
referencias, etc., se organizan dentro de un proyecto.
Tambin es posible tener varios proyectos abiertos simultneamente en la misma sesin de trabajo del IDE.
Dichos proyectos se organizan dentro de lo que en VS.NET se denomina una solucin.
Una solucin puede contener proyectos desarrollados en los diferentes lenguajes de la plataforma .NET, y el
medio ms cmodo para manejarlos es a travs de la ventana Explorador de soluciones. La Figura 82 muestra el
aspecto tpico de esta ventana con una solucin que contiene un proyecto, en el que a su vez hay contenido un
formulario.
Los modos de abrir a esta ventana son los siguientes:
.
.
.
.
Figura 83. Botn del Explorador de soluciones en la barra de herramientas del IDE.
La carpeta References contiene las referencias que estn establecidas dentro del proyecto, hacia los diferentes
espacios de nombre que pueden ser necesarios a la hora de escribir el cdigo. Al expandir esta carpeta tendremos
referenciados entre otros: System, System.Windows.Forms, etc.
Al crear un nuevo proyecto desde VS.NET, dichas referencias son establecidas automticamente por el IDE,
facilitando el trabajo del programador que no necesita preocuparse por los espacios de nombres esenciales necesita
para su aplicacin.
Las referencias establecidas por el IDE varan en funcin del estilo de proyecto elegido: aplicacin de Windows,
de consola, etc. El programador puede, naturalmente, establecer referencias adicionales en funcin de las necesidades
del programa.
Respecto al fichero ASSEMBLYINFO.VB, contiene informacin adicional del ensamblado, fundamentalmente
en forma de atributos, para el entorno de ejecucin. Podemos editar este fichero para cambiar ciertos parmetros del
ensamblado. Ver Cdigo fuente 27.
Imports
Imports
'
'
'
set
'
System.Reflection
System.Runtime.InteropServices
Review
<Assembly:
<Assembly:
<Assembly:
<Assembly:
<Assembly:
<Assembly:
<Assembly:
the
values
of
the
assembly
attributes
AssemblyTitle("")>
AssemblyDescription("")>
AssemblyCompany("")>
AssemblyProduct("")>
AssemblyCopyright("")>
AssemblyTrademark("")>
CLSCompliant(True)>
'The following GUID is for the ID of the typelib if this project is exposed to COM
<Assembly:
Guid("C0158A80-9226-4712-A38C-17233E5767CE")>
'
'
Version
information
for
an
assembly
consists
of
the
following
four
values:
'
' You can specify all the values or you can default the Build and Revision Numbers
by
using
the
'*'
as
shown
below:
<Assembly:
AssemblyVersion("1.0.*")>
Cdigo fuente 27. Contenido del fichero ASSEMBLYINFO.VB creado por el IDE.
El modo de apertura de un proyecto explicado hasta el momento consiste en iniciar VS.NET y abrir despus el
proyecto. Sin embargo, podemos hacer directamente doble clic sobre el fichero del proyecto (fichero con extensin
.VBPROJ), y esta accin abrir el IDE y cargar el proyecto en un solo paso.
Estas opciones hacen uso comn de la caja de dilogo Agregar nuevo elemento. Lo que sucede, es que si
elegimos aadir por ejemplo un formulario, la caja de dilogo se abre posicionndonos ya en la plantilla
correspondiente al elemento que queremos aadir, ello supone un atajo y nos ahorra el paso de seleccin del elemento.
Pero podemos cambiar libremente dicho elemento, seleccionando uno diferente en el panel derecho de este dilogo. La
Figura 85 muestra un proyecto en el que adems del formulario por defecto, Form1, se ha agregado el formulario,
frmDatos, la clase Factura, el mdulo, General, y el fichero de texto TextFile1.
Haciendo clic en el segundo botn de la barra de herramientas de esta ventana, Mostrar todos los archivos,
observar el lector como se visualizan las carpetas del proyecto que contienen los ficheros inicialmente ocultos, como
el ejecutable.
Propiedades de la solucin
Al igual que el proyecto, si hacemos clic sobre el nombre de la solucin y pulsamos el botn Propiedades de la
barra de herramientas, se abrir la ventana de propiedades de la solucin, en la que podremos configurar aspectos tales
como el proyecto de inicio, en el caso de una solucin con varios proyectos; establecer las dependencias de un
proyecto, etc. Ver Figura 87.
El men contextual
Tanto si nos encontramos en la ventana del explorador de soluciones como en cualquier otra, podemos acceder
de un modo rpido a mltiples opciones de los elementos situados en la ventana, haciendo clic derecho sobre un
elemento, de modo que se abrir el men contextual correspondiente, en el que podremos elegir operaciones
relacionadas con el elemento seleccionado. La Figura 90 muestra el men contextual de un proyecto.
La ventana de propiedades
Cuando estamos diseando un formulario, esta ventana muestra las propiedades del objeto que tengamos
seleccionado en el diseador: bien un control o el propio formulario. La Figura 93 muestra esta ventana indicando sus
elementos principales.
Como vemos en la figura anterior, las propiedades se organizan en dos columnas: una contiene los nombres de
las propiedades y otra sus valores. Las propiedades compuestas de varios miembros, incluyen en el lateral izquierdo un
signo + para expandirlos.
Ciertas propiedades contienen una lista de valores, que podemos abrir con el botn que figura en el valor de la
propiedad. Ver Figura 94.
Existe otras propiedades cuyo valor es seleccionado mediante una caja de dilogo. En esta propiedades, se
muestra en su valor, un botn con puntos suspensivos indicando que debemos pulsarlo para modificar su valor. Ver
Figura 95.
Podemos hacer clic sobre un control del formulario para pasar a continuacin a ver sus propiedades, o bien
podemos elegir el control de la lista desplegable de controles. La Figura 96 muestra esta lista con el propio formulario
y varios controles adicionales.
Los dos primeros botones de la barra de herramientas de esta ventana, nos permiten respectivamente, ordenar las
propiedades por categora o alfabticamente. Mientras que en la parte inferior, se visualiza una descripcin resumida
de la propiedad que tengamos seleccionada. Si no deseamos ver dicha descripcin, haremos clic derecho sobre la
ventana, seleccionando la opcin de men Descripcin.
El IDE de Visual
Herramientas y editores
Studio
.NET.
El Cuadro de herramientas
Situado habitualmente como una ficha expandible en el lateral izquierdo del IDE, la ventana Cuadro de
herramientas contiene todos los controles que podemos insertar en un formulario para construir el interfaz de usuario
de la aplicacin. Ver Figura 97.
Organizacin en fichas
Esta ventana est organizada en base a una serie de fichas en forma de barras, en las que al hacer clic se
despliegan sus elementos. Por defecto, cuando abrimos el cuadro de herramientas, se muestra abierta la ficha Windows
Forms, conteniendo los controles que habitualmente utilizaremos en los formularios, aunque tambin disponemos de
las fichas Data, Components, etc.
Ya que habitualmente no haremos uso de todos los controles en un programa, algunas fichas se encuentran
ocultas, por lo que si queremos tener todas disponibles, haremos clic derecho sobre el cuadro de herramientas y
elegiremos la opcin de men Mostrar todas las fichas, con lo que fichas como HTML, XML Schema, Dialog Editor,
etc., que hasta ese momento no estaban disponibles, podrn ser usadas por el programador.
Para seleccionar un control, slo hemos de desplazarnos por la lista de controles de la ficha que tengamos
abierta con las teclas de desplazamiento o los botones de la ventana que realizan tambin dicha funcin y que se
encuentran en el ttulo de la ficha actual y la siguiente. Ver Figura 98.
Manipulacin de fichas
Las fichas del cuadro de herramientas se muestran en un orden predeterminado por el IDE, pero podemos
cambiar la posicin de cualquier ficha haciendo clic sobre la misma y arrastrando arriba o abajo hasta soltarla en una
nueva posicin.
Esta flexibilidad tambin se extiende al hecho de que podemos crear nuestras propias fichas para situar en ella
controles ya existentes en el cuadro de herramientas o nuevos controles.
Para crear una nueva ficha, que llamaremos MisControles, haremos clic derecho en el cuadro de herramientas y
seleccionaremos la opcin de men Agregar ficha, ello crear una nueva ficha vaca en la que escribiremos su nombre
y pulsaremos [INTRO] para terminar, vase la Figura 105. El modo de aadir controles a una ficha ser explicado en
un prximo apartado.
Es posible tambin, cambiar de nombre y eliminar las fichas existentes, haciendo clic derecho sobre su ttulo y
eligiendo del men contextual, la opcin Eliminar ficha o Cambiar nombre de ficha. Debemos tener en cuenta que
slo podremos eliminar las fichas que hayamos creado nosotros, puesto que las que originalmente se muestran en el
IDE, pertenecen al entorno de desarrollo y no pueden eliminarse.
Organizacin de controles
Los controles dentro de una ficha se visualizan por defecto con el icono del control y su nombre, en el llamado
modo Vista de lista. No obstante, podemos hacer que los controles se muestren en vista de iconos, al estilo de VB6,
haciendo clic derecho sobre el cuadro de herramientas y seleccionando la opcin de men Vista de lista, que se
encontrar marcada, desmarcndola de esa forma, y quedando esta ventana con un aspecto parecido al de la Figura
100.
Aunque esta vista pueda ser inicialmente de mayor agrado para los programadores de VB6, creemos que la vista
de lista, al incluir el nombre del control es ms prctica de manejar, por lo que vamos a dejar de nuevo esta ventana
con dicha vista.
Podemos ordenar los controles de una ficha por su nombre, haciendo clic derecho sobre esta ventana y eligiendo
la opcin de men Ordenar elementos alfabticamente.
Figura 100. Cuadro de herramientas mostrando controles con vista de iconos.
El orden alfabtico puede tener el inconveniente de situar algunos controles de uso frecuente (por ejemplo
TextBox), al final de la lista. Para remediar este problema, podemos cambiar la posicin de los controles dentro de la
lista de dos maneras: haciendo clic sobre el control y arrastrndolo hasta la posicin que deseemos; o bien, haciendo
clic derecho sobre la lista de controles y eligiendo las opciones Subir o Bajar. En este ltimo modo podemos lograr
una ordenacin mixta, en parte alfabtica, pero con nuestro controles de mayor uso en posiciones preferentes. La
Figura 101 muestra un ejemplo de este orden combinado.
Figura 101. Controles con orden mixto: parte alfabtica y parte preferente.
Manipulacin de controles
Todos los controles aparecen con su nombre original en el cuadro de herramientas. No obstante, es posible
cambiar dicho nombre por otro que sea ms fcilmente identificable por nosotros, o con el que nos sintamos ms
cmodos.
Por ejemplo, supongamos que queremos cambiar el nombre del control StatusBar. Para ello, haremos clic
derecho sobre dicho control y seleccionaremos la opcin Cambiar nombre de elemento, lo que nos permitir editar
directamente el nombre en la lista de controles. Introduciremos como nuevo nombre Barra de estado y pulsaremos
[INTRO], el resultado se refleja en la Figura 102.
Es importante remarcar, que este tipo de cambio slo es a nivel del literal mostrado por el control en el cuadro
de herramientas, ya que cuando aadamos una copia del control al formulario, el nombre que le asignar el IDE
seguir siendo su nombre original: StatusBar.
Mediante las operaciones estndar de Windows: Cortar, Copiar y Pegar, podemos cambiar de ficha los
controles, mientras que si hacemos clic y arrastramos un control hacia otra ficha, moveremos dicho control de su ficha
original, depositndolo en una nueva. La Figura 103 muestra la ficha General, con los controles Panel y ListView,
originarios de la ficha Windows Forms: el primero se ha copiado y el segundo se ha movido a esta ficha.
Agregar controles
Adems de poder organizar los controles existentes, es posible aadir nuevos controles a cualquiera de las fichas
del cuadro de herramientas. Para ello, y una vez situados sobre una ficha, debemos hacer clic derecho y seleccionar la
opcin de men Personalizar cuadro de herramientas, que nos mostrar la caja de dilogo del mismo ttulo de la
Figura 104.
En esta ventana, y dependiendo de la ficha seleccionada, podemos aadir al cuadro de herramientas tanto
controles basados en componentes COM, como componentes de .NET Framework.
Como ejemplo, nos situaremos en la ficha General del cuadro de herramientas, abriendo a continuacin la
ventana para personalizar el cuadro de herramientas. Haremos clic sobre la ficha de componentes de .NET, y
marcaremos la casilla del control DirListBox, pulsando seguidamente el botn Aceptar, con lo que dicho control se
aadir a la ficha. Ver Figura 105.
La operacin inversa, es decir, eliminar un control del cuadro de herramientas, podemos realizarla de dos
formas:
.
Seleccionar el control y pulsar [SUPR], confirmando su eliminacin del cuadro de herramientas.
.
Abrir la ventana para personalizar el cuadro de herramientas, localizar el control y quitar la marca de
su casilla. Con ello desaparecer del cuadro de herramientas.
Public
Dim
Dim
For
Total
Next
End
Sub
Conteo(ByVal
Indicador
Total
Importe
As
As
Indicador
+=
As
Long)
Integer
Long
=
Importe
To
+
100
4
Sub
Posteriormente, aadimos un botn al formulario del proyecto y en el cdigo de su evento escribimos la lnea
del Cdigo fuente 29.
MessageBox.Show("Has
pulsado
un
botn")
Ambos cdigos fuente los seleccionamos y copiamos al Portapapeles en el modo habitual. Hasta aqu nada de
particular, pero si abrimos el cuadro de herramientas y hacemos clic en la ficha Anillo del Portapapeles, veremos algo
parecido a la Figura 106.
Figura 106. Acceso al cdigo fuente copiado al Portapapeles desde el cuadro de herramientas de VS.NET.
Si a continuacin, abrimos el editor de cdigo correspondiente a cualquier elemento del proyecto: formulario,
clase, mdulo, etc., podemos hacer clic en cualquiera de los elementos del Anillo del Portapapeles y arrastrarlo,
copindolo en dicho editor de cdigo. Tambin conseguiremos el mismo resultado haciendo doble clic en cualquiera
de los elementos de esta ficha. Esta caracterstica aporta una gran comodidad en la manipulacin del cdigo fuente de
la aplicacin.
Para mostrar alguna de las barras de herramientas definidas en el IDE, podemos hacerlo de las siguientes
formas:
Clic derecho sobre una de las barras actualmente visible, lo que mostrar un men contextual con todas las
barras existentes, en el que podremos elegir una. Ver Figura 107.
Figura 107. Men contextual con las barras de herramientas del IDE.
Opcin de men Herramientas + Personalizar, que mostrar la ventana Personalizar, en la que dentro de la
ficha Barras de herramientas, podremos visualizar y ocultar barras, marcando y desmarcando respectivamente la
casilla asociada a dicha barra. Ver Figura 108.
Figura 108. Ventana Personalizar para manejar las barras de herramientas del IDE.
Marcando por ejemplo, la barra Editor de texto, se visualizar esta barra, situndose debajo de la estndar. Ver
Figura 109.
La Figura 112 muestra la barra estndar y la barra personalizada que acabamos de crear en su posicin habitual;
la barra de edicin de cdigo fuente en un lateral del entorno; mientras que la barra para depurar est flotando en el
IDE. El indicador con forma de pequeas lneas situado en la parte izquierda de cada barra, antes del primer botn,
sirve para hacer clic sobre l y mover la barra de lugar.
Ventana de resultados
Esta ventana se encuentra habitualmente en la parte inferior del IDE, y muestra el producto de acciones
diversas, como la compilacin previa a la ejecucin, generacin de ejecutable, etc. La Figura 114 muestra esta ventana
en la que aparece el resultado de la ejecucin de una aplicacin en depuracin, es decir, una aplicacin ejecutada desde
el propio IDE.
Si necesitamos visualizar otros resultados, como por ejemplo el de la generacin del ejecutable, tenemos que
abrir la lista desplegable situada en la parte superior de esta ventana.
Existen otras variantes de esta ventana, que muestran los resultados de bsquedas efectuadas en la ayuda del
IDE, bsquedas de smbolos en el examinador de objetos, etc. Todas ellas se sitan como fichas en la parte inferior del
entorno de trabajo. Ver Figura 115.
Figura 115. Fichas de resultados de bsquedas en el IDE.
Esta ventana dispone de multitud de opciones y caractersticas dada su importancia, por lo que en este apartado
trataremos las ms importantes.
Al haber seleccionado en la pgina de inicio de VS.NET la configuracin de teclado de VB6, la mayora de las
opciones en cuanto a tipo de letra y color de los elementos del editor de cdigo estarn ajustadas correctamente. No
obstante, es posible modificar cualquiera de estos valores si queremos realizar una configuracin ms personalizada
todava.
Por ejemplo, si el tipo de letra no es de nuestro agrado, seleccionaremos la opcin Herramientas + Opciones,
que abrir la ventana Opciones. Dentro de ella, en la carpeta Entorno, haremos clic en el elemento Fuentes y colores,
que nos mostrar en la parte derecha la configuracin de tipo de letra y colores para el editor de cdigo fuente. Ver
Figura 117.
Aqu podemos cambiar por ejemplo, el tipo de fuente a una de ancho fijo como Fixedsys, ms cmoda para
trabajar, y el color de algunos elementos de cdigo, como los literales de error, comentarios, etc.
Aparte de estas opciones, la carpeta Editor de texto de esta misma ventana, nos permite configurar tanto
aspectos generales del editor de cdigo, como particulares para cada lenguaje. Ver Figura 118.
Entre las caractersticas del editor para VB.NET que podemos configurar, se encuentra el mostrar la lista de
miembros automticamente para los objetos, visualizar los nmeros de lnea, indentacin de cdigo, ancho de los
tabuladores, finalizacin automtica de estructuras de cdigo, etc.
Figura 118. Opciones especficas para el editor de cdigo del lenguaje VB.NET.
Nmeros de lnea
En la parte inferior derecha del IDE nos encontramos la barra de estado, que muestra el nmero de lnea,
columna y carcter sobre el que estamos situados actualmente. Si en algn momento necesitamos desplazarnos a un
nmero de lnea determinado dentro del documento actual, seleccionaremos la opcin de men Edicin + Ir a, que
mostrar la caja de dilogo de la Figura 119 para posicionarnos en una lnea en concreto.
En esta ventana por un lado, introduciremos el texto en el campo Buscar, despus podemos indicar al alcance o
mbito de nuestra bsqueda: el documento actual, todos los documentos, o el procedimiento de cdigo en el que
estbamos situados cuando hemos invocado la bsqueda.
Podemos realizar una bsqueda con un alto nivel de precisin, marcando alguna de las opciones que permiten
buscar slo por palabras completas, distinguiendo entre maysculas y minsculas, por expresiones regulares, etc.
Al pulsar el botn Buscar siguiente, se comenzar a realizar la bsqueda segn los valores establecidos,
marcndose el texto hallado cada vez que la bsqueda tenga xito.
Si pulsamos el botn Reemplazar, cambiar ligeramente el aspecto de la ventana, permitiendo al usuario
introducir un texto, con el que reemplazaremos el que vamos a buscar. En la Figura 121 vamos a sustituir las
ocurrencias de la palabra Total por la palabra Resultado; podemos ir buscando y reemplazando cada vez que
localicemos el texto, o bien realizar una sustitucin global en un solo paso.
La bsqueda por expresiones regulares es especialmente interesante. Podemos definir una expresin regular
como un carcter comodn que nos permitir realizar una bsqueda extendida. Si marcamos la casilla Usar para
expresiones regulares, se habilitar el botn en forma de flecha que hay junto al campo Buscar. Al pulsar dicho botn
se mostrar un men con la lista de expresiones regulares disponibles. Ver Figura 122.
Figura 122. Men de expresiones regulares para bsqueda de texto.
Un ejemplo del uso de expresiones regulares podra ser el siguiente: supongamos que queremos localizar todas
las cadenas de texto que tengan las palabras Calcular porcentaje, y en medio de ambas que pueda haber una letra
comprendida entre un intervalo. La expresin de bsqueda quedara as: Calcular [m-t] porcentaje.
Otro tipo de bsqueda disponible lo encontramos en la opcin de men Edicin + Avanzadas + Bsqueda
incremental, o combinacin de teclado [CTRL. + ALT + I] que una vez seleccionada, realiza una bsqueda dinmica
del texto que vayamos introduciendo.
Ajuste de lnea
Esta opcin, que se encuentra en el men Edicin + Avanzadas + Ajuste de lnea, si est activada, parte una
lnea de cdigo muy larga en varias, de forma que no quede oculta en la ventana del editor. Si no est activada, se
mantiene una nica lnea por muy larga que sea, de forma que parte puede quedar oculta. Ver Figura 123.
Activar esta caracterstica puede resultar muy cmodo, ya que evita al programador tener que desplazarse hacia
la derecha para ver el contenido de lneas de cdigo muy largas.
Para dejar esta ventana con un solo panel de edicin seleccionaremos la opcin de men Ventana + Quitar
divisin.
Otro modo de establecer la divisin del editor de cdigo en dos paneles, consiste en hacer clic y arrastrar el
indicador de divisin que se encuentra en la parte superior derecha de esta ventana, soltando en el punto que deseemos.
Con esto quedar tambin dividida la ventana. Ver Figura 125.
Figura 125. Indicador de divisin del editor de cdigo.
Marcadores
Un marcador consiste en una seal que situamos en una lnea de cdigo, de manera que podamos volver
rpidamente a ella, sin necesidad de estar buscndola. Esta caracterstica resulta especialmente til cuando trabajamos
con documentos de cdigo muy grandes.
Para establecer un marcador, nos situaremos en la lnea a marcar, y seleccionaremos la opcin de men Edicin
+ Marcadores + Alternar marcador, o la combinacin de teclado [CTRL + K, CTRL + K] Esta accin establecer la
marca correspondiente en el margen del editor de cdigo, consistente en un semicrculo azul. Ver Figura 126.
Una vez que hayamos establecido todos los marcadores que consideremos oportunos, podemos desplazarnos de
uno a otro con las opciones del men Edicin + Marcadores: Marcador siguiente o Marcador anterior, que
corresponden respectivamente a las pulsaciones de teclado [CTRL + K, CTRL
+ N] y [CTRL + K, CTRL + P].
El desplazamiento entre marcadores se realizar en la ventana del editor actual, es decir, si tenemos varias
ventanas de edicin de cdigo abiertas, con marcadores tambin establecidos en ellas, no podremos pasar desde el
ltimo marcador de una ventana al primer marcador de otra.
Para eliminar todos los marcadores establecidos en el editor actual, seleccionaremos la opcin de men Edicin
+ Marcadores + Borrar marcadores, o la combinacin de teclas [CTRL + K, CTRL + L].
Esquematizacin
La Esquematizacin u Outlining consiste en una caracterstica del editor por la cual podemos expandir
o contraer bloques de cdigo, facilitando su lectura.
Cuando la esquematizacin se encuentra activada (estado por defecto), se muestra una lnea o gua en el lateral
izquierdo del editor, que discurre paralela al cdigo. Ver Figura 128.
La gua dispone a lo largo del cdigo de una serie de smbolos ms (+), y menos (-), que permiten al hacer clic,
expandir o contraer respectivamente el cdigo. Cuando hay una parte del cdigo oculto de esta manera, se muestran
adems unos puntos suspensivos. Ver Figura 129.
Regiones
Mediante las directivas del compilador #Region...#End Region, podemos definir bloques de cdigo, que
comprendan varios procedimientos, y que a travs de esquematizacin, ocultemos o expandamos colectivamente. Cada
regin de cdigo debe tener un nombre, que estableceremos en una cadena de caracteres a continuacin de la palabra
clave Region. Ver Figura 130.
Figura 130. Regin de cdigo definida en el editor.
Al crear un formulario con el diseador de VS.NET, su editor de cdigo correspondiente aade una regin con
el nombre "Windows Form Designer generated code", que contiene el cdigo que genera automticamente el
diseador.
Seleccin sin comentarios ([CTRL + K, CTRL + U]), comentar y quitar comentarios respectivamente al bloque
seleccionado.
Estas opciones tambin estn disponibles en la barra de herramientas del editor de texto, cuyos botones se
muestran en la Figura 131.
Figura 131. Botones para comentar y quitar comentarios del cdigo fuente.
Ir a la definicin de un procedimiento
Al hacer clic derecho sobre la llamada a un procedimiento, se muestra un men contextual, en el que al
seleccionar la opcin Ir a definicin, nos sita en el cdigo del procedimiento seleccionado.
IntelliSense
Las opciones del men Edicin + IntelliSense, suponen una gran ayuda para el programador a la hora de escribir
cdigo, facilitando la labor de buscar miembros de clases, informando sobre los parmetros de procedimientos, etc.
A continuacin realizaremos un rpido repaso de cada una de estas opciones:
Lista de miembros. [CTRL + J]. Abre una lista que muestra los miembros del identificador seleccionado en
el editor: clase, enumeracin, etc.
Nos encontramos en la siguiente situacin: hemos creado una aplicacin Windows con el tpico formulario que
se encuentra en una clase con el nombre Form1. En un procedimiento declaramos una variable con el nombre
oVentana, de tipo Form1. Cuando escribamos esta variable y pongamos un punto, o bien ejecutemos esta opcin de
men, aparecer la lista de miembros de la clase Form1. Ver Figura 132.
Informacin de parmetros. [CTRL + MAYS + I]. Al hacer una llamada a un procedimiento, esta opcin
muestra una vieta informativa con un resumen de la lista de parmetros necesarios para un procedimiento del
programa.
En el siguiente ejemplo realizamos una llamada a un procedimiento llamado Comprobar( ), que recibe como
parmetro un valor numrico Integer. Al aplicar esta opcin se muestra la Figura 133.
Private
Dim
Sub
Comprobar(ByVal
Resultado
Dato
As
As
Integer)
Boolean
If
Resultado
Else
Resultado
End
Dato
=
=
=
End
2000
Then
True
False
If
Sub
Informacin rpida. [CTRL + I]. En funcin del elemento de cdigo sobre el que sea aplicada, esta opcin
muestra una vieta informativa.
Si por ejemplo, ejecutamos esta opcin sobre la llamada al mtodo Show( ) de un objeto MessageBox, se
muestra la informacin de la Figura 134. Esto indica que el mtodo requiere un parmetro de tipo String.
Palabra completa. [CTRL + ESPACIO]. Ayuda a completar la escritura de una instruccin. Si por ejemplo,
comenzamos a escribir en el editor la palabra mess y seleccionamos esta opcin, se abrir una lista de valores en el que
se mostrar el valor ms parecido. En esta lista podremos ya elegir la instruccin que necesitemos. Ver Figura 135.
Si en lugar de agregar un nuevo elemento, seleccionamos un fichero de imagen o icono existente, dicho ficheros
se aadir al proyecto, mostrndose en el editor de imagen permitiendo su modificacin. La Figura 137 muestra esta
situacin con un icono.
Al abrir este editor, se muestra tambin automticamente la barra de herramientas para la edicin de imgenes,
que dispone de los elementos necesarios para este trabajo. Ver Figura 138.
Figura 136. Editor de imgenes de VS.NET.
Lista de tareas
Cuando desarrollamos una aplicacin, van apareciendo algunas labores que no podemos completar en el
momento y debemos posponer para otra ocasin. Cada programador lleva un control ms o menos efectivo de esta
lista de labores incompletas: apuntarlas en un fichero con el Bloc de notas, una libreta de apuntes, etc., que cumplen
correctamente su misin, si bien, ninguna de ellas est integrada con la herramienta de programacin.
VS.NET incorpora un novedoso elemento denominado tarea, que permite definir labores pendientes de realizar
en el cdigo de la aplicacin, asignarles una prioridad y realizar bsquedas entre todas las definidas en el programa.
En el contexto del IDE, una tarea es un identificador simblico, que al ser incluido en una lnea de comentario
es detectado de forma especial, engrosando la lista de tareas pendientes de realizar en el proyecto.
En esta pantalla de configuracin, podemos alterar los valores de los smbolos asociados a tareas, crear nuestros
propios smbolos y eliminar todos excepto el smbolo TODO. En este caso, en el campo Nombre escribiremos un
nuevo smbolo con el nombre PENDIENTE, y pulsaremos el botn Agregar, para aadirlo a la lista existente.
Creacin de tareas
Podemos crear tareas de dos formas: asociando una tarea a un smbolo o directamente a una lnea ejecutable.
En el primer caso, una vez creados o configurados los smbolos de tareas, vamos a aadir una tarea en el cdigo
fuente, de tipo PENDIENTE, el que acabamos de crear. Situados en un procedimiento, aadiremos el comentario
mostrado en el Cdigo fuente 31.
Private
Sub
Dim
Total
Dim
As
Valor
Long
As
Total
'
Calcular()
String
PENDIENTE:
agregar
Valor
parmetros
=
End
500
este
procedimiento
"nuevo"
Sub
De igual forma que hemos agregado esta tarea, podemos utilizar los otros tipos definidos en el IDE, como son
TODO, HACK, etc.
En el segundo caso, haremos clic derecho sobre una lnea de cdigo y seleccionaremos la opcin de men
Agregar acceso directo a la lista de tareas, que situar una marca en forma de flecha en el margen del editor de
cdigo. Esta opcin tambin est disponible en el men Edicin + Marcadores, o con la combinacin de teclas [CTRL
+ K, CTRL + H]. Ver Figura 140.
Eliminacin de tareas
Cuando consideremos una tarea completada podemos eliminarla de la lista. El modo de quitar una tarea depende
de su tipo:
.
Si se trata de una tarea asociada a una lnea de cdigo ejecutable, haremos clic sobre ella en la ventana
de tareas y pulsaremos [SUPR]. O bien, haremos clic derecho y elegiremos la opcin de men Eliminar.
.
Si la tarea est asociada a un smbolo situado en un comentario de cdigo, bastar con borrar la lnea
del comentario.
La Vista de clases
Esta ventana, a la que accedemos con la opcin de men Ver + Vista de clases, o la combinacin de teclas
[CTRL + MAYS + C] proporciona una panormica de todos los mdulos que componen el proyecto: clases, cdigo
estndar, etc. Ver Figura 142.
Organizada en forma de rbol jerrquico, podemos expandir los elementos que parten desde el proyecto, hasta
llegar a los miembros de cada clase. Una vez expandida una clase, al hacer clic derecho sobre uno de sus mtodos o
propiedades, se muestra un men contextual que nos permite ver el cdigo del elemento seleccionado, su organizacin
en el examinador de objetos, etc.
Por defecto, la ordenacin de los miembros de las clases se realiza por tipo, aunque el primer botn de la barra
de herramientas de esta ventana nos permite alterar dicho orden.
Figura 142. Ventana Vista de clases del IDE.
El Explorador de objetos
Muy relacionada con la vista de clases tenemos esta ventana, que abrimos con la opcin de men Ver
+ Otras ventanas + Examinador de objetos, o pulsando la tecla [F2]. Una vez abierta, se sita como una ficha
ms de la ventana principal del IDE, organizada en tres paneles principales.
El panel izquierdo muestra la organizacin de espacios de nombres, clases, etc. El panel derecho visualiza los
miembros de la clase actualmente seleccionada. Finalmente, el panel inferior muestra la declaracin del miembro
seleccionado en el panel derecho. Ver Figura 143.
Figura 143. Examinador de objetos de VS.NET.
La diferencia respecto a la vista de clases, reside en que con el examinador de objetos podemos buscar
informacin sobre cualquiera de las clases que componen la plataforma .NET Framework, pulsando sobre el ltimo
botn de la barra de herramientas: Buscar smbolo, ver Figura 144.
Para buscar un smbolo dentro de las clases, se muestra una caja de dilogo en la que introducimos el nombre
del smbolo. Al pulsar el botn Buscar, se abre la ventana Resultados, situada habitualmente en la parte inferior del
IDE, con la lista de smbolos coincidentes encontrados. Al hacer doble clic sobre alguno de los smbolos encontrados,
se actualiza la informacin del examinador de objetos, mostrando la clase y smbolo seleccionado.
Como ejemplo, en la Figura 145, hemos buscado por el smbolo Button, seleccionando de los valores resultantes
el correspondiente a la clase Button, del espacio de nombres System.Windows.Forms.
Macros
Dentro del contexto de las herramientas informticas, una macro consiste en un conjunto de acciones, de las que
habitualmente realizamos con dicha herramienta, que han sido grabadas para ser ejecutadas en un solo paso. Esto
supone una gran ayuda al usuario tanto en tiempo como en esfuerzo, ya que unificamos en una sola operacin, una
lista de tareas que posiblemente tenga que realizar de forma repetitiva un gran nmero de veces durante una sesin de
trabajo.
Otra de las ventajas de las macros radica en que por su peculiar naturaleza, deben poder ser creadas por el
propio usuario, de manera que este defina las macros que mejor se adapten a su quehacer cotidiano.
Los lectores que sean usuarios de alguna de las herramientas de la familia Microsoft Office estarn a buen
seguro familiarizados con las macros. En Microsoft Word por ejemplo, podemos crear una macro que seleccione el
texto del documento que estamos escribiendo, cambie su tipo de letra y estilo. Todas estas operaciones las
realizaramos en un solo paso al ejecutar la macro.
VS.NET incorpora un conjunto de macros predefinidas, con algunas de las operaciones ms habituales, as
como un entorno adicional para la creacin de nuestras propias macros.
Las macros realizan operaciones fundamentalmente sobre el cdigo fuente, por ello recomendamos al lector que
una vez creado un nuevo proyecto de VB.NET de tipo aplicacin Windows, se posicione sobre una ventana de editor
de cdigo para poder comprobar mejor los resultados de las pruebas realizadas.
El Explorador de macros
El primer elemento del IDE que tenemos que utilizar para trabajar con macros es el Explorador de macros, al
cual accedemos de alguna de las siguientes formas:
. Opcin de men Ver + Otras ventanas + Explorador de macros.
. Opcin de men Herramientas + Macros + Explorador de macros.
. [ALT + F8].
Esta ventana muestra inicialmente las macros definidas por defecto en el IDE. La organizacin se realiza en
base a proyectos de macros, de una forma similar a los proyectos habituales de VB.NET. En el interior de cada
proyecto encontramos un conjunto de mdulos, dentro de los cuales se encuentran las macros. Ver Figura 146.
Como podemos observar, partiendo del elemento Macros, y en forma de rbol, tenemos los proyectos
predefinidos: Samples y MyMacros. Samples contiene un conjunto de macros ya creadas por defecto para el IDE,
mientras que MyMacros es un proyecto que como su nombre indica, est pensado para aadir nuestras propias macros.
Podemos asimismo, crear proyectos de macros adicionales.
Ejecucin de macros
Una vez familiarizados con el explorador de macros, abriremos el proyecto Samples y su mdulo VSEditor.
Podemos ejecutar alguna de las macros de este mdulo de las siguientes maneras:
. Haciendo clic sobre la macro y pulsando [INTRO].
. Haciendo doble clic sobre la macro.
. Haciendo clic derecho y eligiendo la opcin Ejecutar de su men contextual
Si por ejemplo, ejecutamos la macro InsertDate, se incluir la fecha actual en la lnea del editor en la que
estemos posicionados, como muestra el ejemplo del Cdigo fuente 32.
Public
Dim
Valores
'
resultado
jueves,
Function
Valores
DevuelveImporte()
As
As
Long
Long
=
de
12
la
ejecucin
de
de
la
julio
macro
de
55477
InsertDate
2001
Return
End
Valores
Function
Grabacin de macros
La operativa a seguir para grabar una macro es la misma que la utilizada en las herramientas de Microsoft
Office, por lo que a los lectores usuarios de este grupo de aplicaciones, les resultar muy fcil la creacin de macros en
VS.NET. No obstante, aquellos usuarios no familiarizados con estas aplicaciones comprobarn tambin que se trata de
un proceso muy sencillo.
Tomemos una situacin simple: supongamos que con relativa frecuencia en nuestro cdigo, debemos
seleccionar un conjunto de lneas de comentario y convertirlas a maysculas. Esta operacin implica un conjunto de
elementales pasos, pero que si nos vemos a repetirlos muy frecuentemente, llegarn a convertirse en una molestia.
Para remediar este problema, grabaremos dichas acciones en una macro, de modo que cada vez que necesitemos
realizarlas, ejecutando la macro conseguiremos el mismo resultado en un solo paso.
En primer lugar, situados en el explorador de macros, haremos clic en el proyecto MyMacros, y
seleccionaremos la opcin de men Establecer como proyecto de grabacin. Esto har que las macros creadas a partir
de ese momento se graben en dicho proyecto, dentro de su mdulo RecordingModule.
A continuacin, seleccionaremos la opcin de men Herramientas + Macros + Grabar Temporary Macro, o la
combinacin de teclas [CTRL + MAYS + R]. Esto iniciar la grabacin de la macro, con lo que cualquier accin que
hagamos a partir de ese momento quedar grabada.
Los pasos que grabaremos en la macro sern los siguientes: seleccionaremos una o varias lneas de comentarios
en un editor de cdigo, y despus elegiremos la opcin de men Edicin + Avanzadas + Poner en maysculas, que
La macro quedar grabada con el nombre predeterminado TemporaryMacro dentro del explorador de macros.
Podemos cambiarle el nombre por otro ms descriptivo, haciendo clic derecho sobre la macro y seleccionando la
opcin de men Cambiar nombre. Le asignaremos por ejemplo el nombre PasarMay. El modo de ejecucin es igual
que el explicado en el apartado anterior.
Es muy recomendable cambiar el nombre a una macro recin grabada, ya que al grabar la siguiente, el IDE
tambin le asignar el nombre TemporaryMacro, sobrescribiendo la macro que hubiera previamente.
Como resultado, obtendremos un nuevo proyecto con su mdulo correspondiente en el explorador de macros. Si
queremos grabar macros en dicho proyecto, deberemos establecerlo como proyecto de grabacin, operacin
anteriormente explicada.
El IDE de macros
Hasta el punto actual, imaginamos que todo habr funcionado correctamente, pero probablemente el lector se
pregunte, en el caso de la macro que ha grabado en un apartado anterior, qu clase de magia contiene la macro, que
permite la repeticin de las acciones antes grabadas en ella.
Para desvelar este misterio, debemos acceder al interior de la macro, lo que conseguimos a travs de una versin
reducida del IDE de VS.NET, especialmente diseada para la creacin y manipulacin de macros denominada IDE de
macros. Podemos abrir este entorno mediante alguna de las siguientes operaciones:
.
directo.
.
.
.
Haciendo clic derecho sobre la macro y seleccionando la opcin de men Editar. Este es el medio ms
Opcin de men Herramientas + Macros + IDE de macros.
Pulsando las teclas [ALT + F11].
Clic derecho sobre el elemento Macros del explorador de macros.
Si hemos elegido editar directamente la macro PasarMay( ), en el editor de cdigo de macros, podemos
comprobar como una macro no es otra cosa que un procedimiento especial, que es ejecutado por VS.NET cada vez que
invocamos la macro. Ver Cdigo fuente 33.
Sub
PasarMay()
DTE.ActiveDocument.Selection.LineDown(True,
2)
DTE.ActiveDocument.Selection.ChangeCase(vsCaseOptions.vsCaseOptionsUppercase)
End
Sub
Escritura de macros
Cuando el lector vaya creando sus propias macros de prueba, observar como todas estn basadas en el objeto
DTE, que constituye el objeto principal para la manipulacin del cdigo fuente a travs de macros.
Conociendo los mtodos y propiedades de este objeto, podemos escribir nuestras propias macros en el editor de
cdigo del IDE de macros, para efectuar operaciones sobre el cdigo fuente de nuestras aplicaciones como seleccionar,
comentar, buscar, etc.
Sin embargo, el conocimiento del objeto DTE puede resultar algo oscuro para el programador si no dispone de
la documentacin de referencia adecuada, por lo que existe un truco para poder crear nuestras propias macros sin un
entendimiento a fondo de dicho objeto.
Establezcamos la siguiente situacin: necesitamos escribir una macro que comente un nmero de lneas de
cdigo variable cada vez que sea ejecutada, es decir, que cada vez que invoquemos esta macro, deberemos pedir al
usuario, a partir de la lnea de cdigo en la que est situado, cuantas lneas quiere comentar.
Lo primero que necesitamos saber es cmo debemos utilizar el objeto DTE para posicionarnos al principio de la
lnea de cdigo y comentarla. Para averiguarlo, nada ms fcil que crear una macro que haga dicha tarea. Ver Cdigo
fuente 34.
Sub
TemporaryMacro()
'
posicionar
al
principio
de
la
lnea
(en
la
primera
DTE.ActiveDocument.Selection.StartOfLine(vsStartOfLineOptions.vsStartOfLineOptionsF
irstColumn)
columna)
'
seleccionar
la
lnea
de
cdigo
DTE.ActiveDocument.Selection.LineDown(True)
'
comentar
la
lnea
seleccionada
DTE.ExecuteCommand("Edit.CommentSelection")
End
Sub
Ahora que sabemos como aplicar el proceso a una lnea, escribiremos nuestra propia macro en el IDE de
macros, a la que daremos el nombre ComentarBloqueCodigo, y que contendr el cdigo anterior con las variaciones
necesarias para pedir al usuario el nmero de lneas a comentar, seleccionar dichas lneas, y finalmente comentarlas.
Ver Cdigo fuente 35.
Sub
ComentarBloqueCodigo()
'
selecciona
'
por
el
el
nmero
de
usuario
lneas
luego
introducidas
las
comenta
Dim
NumLineas
As
Integer
Dim
Contador
As
Integer
'
NumLineas
cdigo")
pedir
=
al
InputBox("Nmero
usuario
de
el
lineas
comentar",
'
posicionar
al
principio
de
DTE.ActiveDocument.Selection.StartOfLine(
vsStartOfLineOptions.vsStartOfLineOptionsFirstColumn)
'
For
comenzar
Contador
nmero
la
a
=
de
"Comentar
bloque
lnea
actual
_
seleccionar
To
lneas
de
lneas
NumLineas
DTE.ActiveDocument.Selection.LineDown(True)
Next
'
comentar
DTE.ExecuteCommand("Edit.CommentSelection")
las
End
lneas
seleccionadas
Sub
Cdigo fuente 35. Macro para comentar un nmero variable de lneas de cdigo.
A partir de aqu, podemos ejecutar nuestra macro del modo explicado anteriormente, para comprobar que su
funcionamiento es correcto. Ver Figura 150.
Sub
ComentarIdentificador()
'
pedir
nombre
Dim
identificador
Identif
Identif
If
Exit
End
del
comentar
As
InputBox("Introducir
nombre
buscar",
String
"Comentar
identificador")
'
posicionar
Dim
ts
al
As
comienzo
TextSelection
del
=
procedimiento
DTE.ActiveWindow.Selection
ts.MoveToPoint(ts.ActivePoint.CodeElement(vsCMElement.vsCMElementFunction).GetStart
Point(vsCMPart.vsCMPartHeader))
Dim
LineaCodigo
As
String
Do
'
bajar
la
siguiente
lnea
de
cdigo
DTE.ActiveDocument.Selection.LineDown()
'
posicionar
cursor
al
comienzo
de
la
DTE.ActiveDocument.Selection.StartOfLine(vsStartOfLineOptions.vsStartOfLineOptionsF
irstColumn)
'
seleccionar
la
lnea,
pasar
su
contenido
a
una
'
variable,
y
volver
a
posicionar
cursor
al
principio
'
de
lnea
DTE.ActiveDocument.Selection.EndOfLine(True)
LineaCodigo
=
DTE.ActiveDocument.Selection.Text
LineaCodigo
=
LineaCodigo.Trim()
'
eliminar
espacios
en
blanco
DTE.ActiveDocument.Selection.StartOfLine(vsStartOfLineOptions.vsStartOfLineOptionsF
irstText)
lnea
'
si
If
Exit
Else
'
'
si
Dim
Posicion
'
If
'
llegamos
(LineaCodigo
si
al
final
=
no
existe
del
procedimiento,
finalizar
"End
Sub")
estamos
identificador
el
Posicion
al
final,
la
en
As
si
existe
Posicion
comentar
el
identificador
>
la
en
-1
macro
Then
Do
comprobar
actual
Integer
LineaCodigo.IndexOf(Identif)
la
lnea
lnea
Then
lnea
DTE.ActiveDocument.Selection.StartOfLine(vsStartOfLineOptions.vsStartOfLineOptionsF
irstText)
DTE.ActiveDocument.Selection.EndOfLine(True)
DTE.ExecuteCommand("Edit.CommentSelection")
End
End
Loop
End
If
If
Sub
El sistema de ayuda
Al igual que ha sucedido con multitud de elementos del IDE, la ayuda o MSDN Library (Microsoft
Development Network Library) en esta versin de Visual Studio ha sido ampliamente mejorada. La aplicacin
utilizada para navegar por la documentacin de la ayuda es Microsoft Document Explorer, que permite al programador
una enorme flexibilidad a la hora de realizar consultas sobre la ayuda disponible de los diferentes productos de
desarrollo que componen la plataforma .NET.
La integracin ahora del sistema de ayuda con el IDE es total, siguiendo como es natural, con la tnica
establecida en versiones anteriores de proporcionar ayuda contextual siempre que sea posible. Si por ejemplo, nos
encontramos diseando un formulario y hacemos clic sobre un control TextBox, al pulsar [F1] se abrir una nueva
pestaa en la ventana principal del IDE que iniciar la ayuda, y nos posicionar en un documento relativo a dicho
control. Ver Figura 151.
La documentacin de ayuda est creada en formato HTML, lo cual nos permite, gracias a su elevado grado de
integracin, guardar los documentos que visitemos dentro del apartado Favoritos de Internet Explorer, y consultarlos
igualmente utilizando este navegador de Internet.
Figura 151. Pgina de ayuda de VS.NET.
Ayuda dinmica
Esta ventana muestra enlaces a los temas de ayuda del entorno .NET. Podemos acceder a ella mediante la
opcin de men Ayuda + Ayuda dinmica, pulsando [CTRL + F1], o haciendo clic en su ficha desplegable situada en
un lateral del IDE, que tendr alguna de las formas mostradas en la Figura 152.
Tal y como su propio nombre indica, los enlaces que muestra esta ventana son activos y van actualizndose
dependiendo del elemento de cdigo u objeto del diseador en el que estemos posicionados. La Figura 153 muestra un
ejemplo de esta ventana cuando estamos posicionados en la palabra clave del lenguaje Property.
Al hacer clic sobre alguno de los enlaces de esta ventana, la ficha del IDE que muestra la ayuda se actualizar
igualmente con el tema seleccionado.
Figura 153. Ventana Ayuda dinmica.
Contenido
Esta ventana muestra la documentacin al completo de la plataforma .NET Framework organizada en reas
temticas. Podemos abrirla de las siguientes formas:
.
Haciendo clic en el primer botn de la barra de herramientas de la ventana Ayuda dinmica (icono con
forma de libro).
.
Situando el cursor encima de su ficha desplegable situada en el lateral del IDE.
.
Men Ayuda + Contenido.
Teclas [CTRL + ALT + F1]. La ventana mostrada tendr el aspecto de la Figura 154.
Figura 154. Ventana Contenido, de la ayuda.
El manejo de la ayuda con esta ventana se basa en expandir o cerrar los libros que muestra. Al hacer clic en uno
de los iconos en forma de documento, se mostrar su contenido en la ventana de ayuda que tengamos abierta en el
IDE.
ndice
Esta ventana nos permite realizar una bsqueda dinmica de un elemento dentro de la ayuda. Podemos acceder a
ella de las siguientes formas:
.
Haciendo clic en el segundo botn de la barra de herramientas de la ventana Ayuda dinmica (icono
con forma de interrogacin).
.
Situando el cursor encima de su ficha desplegable situada en el lateral del IDE.
.
Men Ayuda + ndice.
.
Teclas [CTRL + ALT + F2].
Segn tecleamos un valor en el campo Buscar de esta ventana, se realizar una bsqueda dentro del MSDN, del
valor ms parecido a lo que hasta ese momento hemos tecleado. Podemos adicionalmente, seleccionar en la lista
desplegable Filtrado por, un rea para acotar la bsqueda Ver la Figura 155.
Una vez que localicemos en la lista de elementos, el tema deseado, haremos clic sobre l y se mostrar su
contenido en la ventana principal del IDE.
Buscar
En el caso de que la ayuda contextual o a travs del ndice no aporten la informacin necesaria, podemos utilizar
la ventana Buscar, perteneciente a la ayuda, que explorar en toda la documentacin del MSDN y devolver una lista
con los documentos que cumplan la condicin de bsqueda. Esta ventana, ver Figura 156, est disponible de las
siguientes formas:
.
Haciendo clic en el tercer botn de la barra de herramientas de la ventana Ayuda dinmica (icono con
forma de libros y lupa).
.
Situando el cursor encima de su ficha desplegable situada en el lateral del IDE.
.
Men Ayuda + Buscar.
.
Teclas [CTRL + ALT + F3].
Figura 156. Ventana Buscar en la ayuda.
Al igual que en la ventana de ndice, teclearemos un valor en el campo Buscar y estableceremos un filtro sobre
un tema si lo necesitamos (no es obligatorio). Podemos restringir adems la bsqueda, marcando las casillas
correspondientes que limitan aspectos de la bsqueda.
Una vez pulsado el botn Buscar, la ventana Resultados de la bsqueda, mostrar una lista de todos los temas
relacionados, ver Figura 157. Al hacer doble clic sobre uno de los elementos, se mostrar el tema en la ventana de
ayuda correspondiente.
Figura 157. Resultados de una bsqueda en la ayuda.
Ayuda externa
En el caso de que el lector est ms acostumbrado a trabajar con la ayuda como un elemento aparte del entorno
de desarrollo, puede configurarla para que sea mostrada de forma externa al IDE de VS.NET.
Para ello debemos situarnos en la pgina de inicio del IDE y hacer clic en el vnculo Mi perfil. A continuacin,
en el apartado Mostrar ayuda, haremos clic en la opcin Ayuda externa. Los cambios quedarn grabados, pero no se
harn efectivos hasta la siguiente ocasin en que iniciemos el IDE.
A partir de ese momento, cuando invoquemos la ayuda en cualquiera de las maneras anteriormente descritas, se
abrir una nueva ventana perteneciente a la coleccin combinada de Visual Studio .NET, conteniendo el tema de
ayuda seleccionado. Ver Figura 158.
La ventaja de usar la ayuda de forma externa reside en que al ejecutarse en su propia ventana, disponemos de
ms espacio para visualizar cada uno de los temas seleccionados.
Los mecanismos de bsqueda dentro de la ayuda estn igualmente disponibles a travs de las fichas
desplegables situadas en el lateral, o el men de esta ventana.
consultados, haya uno en concreto al que necesitemos recurrir con especial frecuencia.
Para facilitar el trabajo con la ayuda en una situacin como esta, una vez que hayamos localizado el tema de
ayuda que consultaremos en repetidas ocasiones, abriremos una nueva ventana con el men Ventana + Nueva ventana,
y a partir de ese momento, toda la navegacin por la ayuda que realicemos se reflejar en esa ltima ventana,
permaneciendo el contenido de la otra ventana de ayuda con el tema original.
La Figura 159 muestra un ejemplo en el que dentro de la ventana de ayuda se han abierto dos ventanas
o fichas: la primera comenzando por la izquierda contiene un tema que consultaremos en repetidas ocasiones;
mientras que la segunda contiene la navegacin por la ayuda que vamos realizando durante nuestro trabajo de
desarrollo.
Podemos abrir tantas ventanas adicionales como precisemos, y organizarlas arrastrando y soltando sobre la ficha
que contiene su nombre. Debemos tener en cuenta que la ventana hija o ficha activa ser la que se actualice cuando
nos desplazamos a un tema de ayuda nuevo.
Esta caracterstica est disponible tanto si hemos configurado el IDE para utilizar la ayuda externa como interna.
Aplicaciones
de
consola
Una aplicacin de consola es aquella que se ejecuta dentro de una ventana de lnea de comandos. Este tipo de
ventana recibe diferentes denominaciones: Smbolo del sistema, Sesin MS-DOS, Ventana de lnea de comandos, etc.,
por lo que a lo largo de esta obra nos referiremos a ella de forma genrica como consola.
Las aplicaciones de consola son muy tiles cuando necesitamos realizar pruebas que no impliquen el uso del
modo grfico del sistema operativo: formularios, controles, imgenes, etc., ya que consumen menos recursos y su
ejecucin es ms veloz.
En nuestro caso particular, debido a que los prximos temas versarn sobre aspectos del lenguaje, y en ellos no
necesitaremos obligatoriamente el uso de formularios, utilizaremos aplicaciones de consola para los ejemplos.
Despus de pulsar Aceptar se crear el proyecto que contendr un fichero de cdigo con el nombre
MODULE1.VB, en cuyo interior encontraremos un mdulo de cdigo conteniendo un procedimiento Main( ) vaco,
por el que comenzar la ejecucin del programa. Ver Cdigo fuente 37.
Module
Module1
Sub
Main()
End
Sub
End
Module
Cdigo fuente 37
La clase Console
Esta clase se encuentra dentro del espacio de nombres System, y nos proporciona a travs de sus mtodos,
acceso a la consola para mostrar u obtener informacin del usuario.
Debido a que los miembros de esta clase se encuentran compartidos (shared), no es necesario crear una instancia
previa de la misma en una variable, pudiendo ejecutar directamente sus mtodos sobre el objeto Console. Todo ello se
explicar en los siguientes apartados.
Escritura de informacin
Para mostrar texto utilizaremos el mtodo WriteLine( ) del objeto Console. Este mtodo escribe en la lnea
actual de la consola el valor que le pasemos como parmetro, aadiendo automticamente las marcas de retorno de
carro y nueva lnea, por lo que la siguiente escritura se realizar en una nueva lnea. Ver Cdigo fuente 38.
Sub
Main()
Console.WriteLine("Hola
Console.WriteLine("Esta
End
Cdigo fuente 38
mundo
es
otra
desde
lnea
nueva")
Sub
la
consola")
El cdigo fuente anterior tiene no obstante un inconveniente: cuando el lector lo ejecute observar que se
muestra la consola con las lneas de texto, pero inmediatamente vuelve a cerrarse, no dejando apenas tiempo para ver
su contenido. Esto es debido a que no utilizamos ninguna instruccin que establezca una parada en la ejecucin, que
nos permita observar el resultado de lo que hemos escrito en la consola.
Para remediar este problema, utilizaremos el mtodo ReadLine( ), que realiza una lectura de los caracteres que
vayamos introduciendo en la lnea actual de la consola, e impedir continuar la ejecucin hasta que no pulsemos
[INTRO]. Ver Cdigo fuente 39 y el resultado en la Figura 161.
Sub
Main()
Console.WriteLine("Hola
mundo
Console.WriteLine("Esta
es
desde
la
otra
consola")
lnea
nueva")
Console.ReadLine()
End
Sub
Cdigo fuente 39
Los valores a mostrar con WriteLine( ) pueden ser de distintos tipos de datos, pudiendo insertar tambin lneas
en blanco, como vemos en el Cdigo fuente 40.
'
Sub
ejemplos
Main()
WriteLine()
con
'
escritura
Console.WriteLine("Esta
Console.WriteLine("Ahora
de
es
ponemos
Console.WriteLine()
cadenas
la
una
'
'
Console.WriteLine("A
Console.WriteLine(5891)
escritura
continuacin
Console.WriteLine()
nmeros
nmero")
un
con
nmeros")
150)
otra
de
de
vaca
'
'
escritura
Console.WriteLine("Resultado
Console.WriteLine(5
caracteres
lnea")
vaca")
lnea
de
escribimos
Console.WriteLine("Operaciones
Console.WriteLine(500
'
parada
Console.ReadLine()
de
primera
lnea
la
espera
expresin
>
respuesta
lnea
valores
lgica:
del
vacia
>
lgicos
2")
2)
usuario
End
Sub
Cdigo fuente 40
La Figura 162 muestra la consola con el resultado de la ejecucin del anterior fuente.
Write( ) es otro mtodo que nos permite tambin escribir valores en la consola. Su uso es igual que WriteLine( ),
aunque debemos tener en cuenta que Write( ) no separa los valores a mostrar. Veamos un ejemplo en el Cdigo fuente
41.
Sub
Console.Write("Hola")
Console.Write("A")
Console.Write("Todos")
Console.Write(3456)
Main()
End
Sub
Cdigo fuente 41
La ejecucin del anterior cdigo mostrara en la consola los valores as: HolaATodos3456.
Para evitar que el texto en la consola salga junto, podemos incluir espacios al comienzo y/o al final en las
cadenas de caracteres que pasemos como parmetro a Write( ), o bien utilizar este mtodo pasando una cadena vaca.
Ver Cdigo fuente 42.
'
Sub
ejemplos
con
Main()
Write()
Console.Write("Hola
")
Console.Write("A")
Console.Write("
Todos")
Console.Write("
")
Console.Write(3456)
Console.ReadLine()
End
Sub
Cdigo fuente 42
se encuentran en variables o expresiones, por lo que tendremos que realizar una combinacin de la cadena de texto
principal con los dems elementos para obtener la cadena final que mostraremos al usuario. Esto lo podemos hacer
empleando dos tcnicas:
Concatenacin.
Concatenando a la cadena principal las variables que contienen los valores a mostrar. Ver Cdigo fuente 43.
'
'
Dim
Dim
'
Nombre
Numero
concatenar
declarar
Nombre
As
Numero
As
asignar
mltiples
valores
variables
String
Integer
valor
=
las
variables
"Luis"
15
Console.WriteLine("He visto a " & Nombre & " transportando " & Numero & " cajas")
Console.ReadLine()
Cdigo fuente 43
Parmetros sustituibles.
Pasando como primer parmetro la cadena a mostrar, y aadiendo tantos parmetros adicionales como valores
debamos mostrar en la cadena principal. En la cadena principal indicaremos el lugar en donde visualizaremos los
parmetros poniendo su nmero entre los smbolos de llave { }. El Cdigo fuente 44 muestra la misma situacin del
ejemplo anterior pero utilizando esta tcnica. El resultado final en la consola es el mismo que el del ejemplo anterior.
'
'
Dim
Dim
'
Nombre
Numero
'
'
'
'
'
combinacin
declarar
Nombre
As
Numero
As
asignar
de
mliples
variables
String
Integer
valor
=
a
=
las
variables
"Luis"
15
'
el
primer
parmetro
contiene
la
cadena
a
mostrar,
el
resto
de
parmetros
son
las
variables
que
se
visualizarn
en
alguna
posicin
de
la
cadena
del
primer
parmetro,
el
contenido
de
la
variable
Nombre
se
situar
en
el
lugar
indicado
por
{0},
la
variable
Numero
en
la
posicin
de
{1}
y
as
sucesivamente
valores
Console.WriteLine("He
Console.ReadLine()
visto
{0}
transportando
{1}
cajas",
Nombre,
Numero)
Cdigo fuente 44
Como habr comprobado el lector, los parmetros sustituibles comienzan a numerarse por cero, no estando
obligados a mostrarlos en el mismo orden en el que los hemos situado en la llamada al mtodo. El Cdigo fuente 45
muestra dos ejemplos de sustitucin de parmetros, uno de ellos con el mismo orden en el que se han situado en
WriteLine( ), y otro con un orden distinto.
'
Dim
Dim
Dim
declaracin
Lugar
Numero
Vehiculo
de
As
As
As
variables
String
Integer
String
'
asignacin
de
valor
Vehiculo
=
Lugar
=
Numero
=
variables
"tren"
"Alicante"
300
'
visualizacin
Console.WriteLine("El {0} con
Vehiculo,
de
resultados
destino {1} viaja a mas
Lugar,
de
{2}
en
kms.
por
consola
hora",
Numero)
Console.WriteLine()
Console.WriteLine("El
Vehiculo,
Console.ReadLine()
{2}
con
destino
{0} viaja
Lugar,
mas
de
{1}
kms.
por
hora",
Numero)
Cdigo fuente 45
Lectura de informacin
Para obtener el texto escrito por el usuario en la lnea actual de la consola y hasta la pulsacin de [INTRO]
podemos utilizar el mtodo ReadLine( ) del objeto Console.
El Cdigo fuente 46 muestra como volcamos a una variable el contenido de la lnea escrita por el usuario y
posteriormente exponemos su contenido, tambin a travs de la consola.
'
'
declaramos una
de
una
variable
lnea
para volcar el
de
la
contenido
consola
Dim
LineaTexto
As
Console.WriteLine("Introducir
LineaTexto = Console.ReadLine()
'
el
'
ahora
mostramos
Console.WriteLine()
Console.WriteLine("El
usuario
ha
Console.WriteLine(LineaTexto)
'
aqu
evitamos
'
as
podemos
ver
Console.ReadLine()
cerrar
mejor
String
lo
que
escrito
la
el
un
se
texto
pasa
la
hemos
la
texto")
variable
escrito
siguiente
lnea:")
consola,
resultado
Cdigo fuente 46
Read( ) es otro mtodo del objeto Console que permite tambin la lectura del dispositivo de entrada de la
consola, pero en este caso devuelve el cdigo de una sola tecla pulsada por el usuario. Para ilustrar el uso de este
mtodo tenemos el ejemplo del Cdigo fuente 47, en el que despus de pulsar varias teclas, nos introducimos en un
bucle que va extrayendo cada uno de sus cdigos, que volvemos a transformar en el carcter correspondiente a la tecla
pulsada.
'
ejemplo
CodTecla
NombreTecla
Dim
Dim
con
As
As
Read()
Integer
Char
Console.WriteLine("Pulsar
Console.WriteLine()
While
'
tomar
CodTecla
'
If
Exit
End
los
si
se
CodTecla
cdigos
ha
convertir
de
=
pulsado
=
Console.WriteLine("Cdigo
'
NombreTecla
varias
el
Console.WriteLine("Tecla
las
teclas")
teclas
intro,
13
de
uno
salir
Then
While
If
tecla
pulsada:
al
caracter
cdigo
=
pulsada:
Cdigo fuente 47
terminado,
{0}",
de
CodTecla)
la
tecla
Chr(CodTecla)
{0}",
NombreTecla)
While
pulse
intro")
End
Console.ReadLine()
Console.WriteLine("Ejemplo
Console.ReadLine()
True
a
uno
Console.Read()
El
lenguaje
Como muestra el diagrama, una aplicacin est formada por uno o ms ficheros de cdigo, que a su vez
contienen mdulos de cdigo o clases, dentro de los que se escriben procedimientos que son los elementos que
contienen el cdigo base.
Cuando creamos una aplicacin usando VS.NET, es el propio IDE quin se encarga de crear por nosotros la
estructura bsica del programa: crea un fichero de cdigo conteniendo un mdulo que tiene el procedimiento de
entrada, slo falta el cdigo del programador.
Todos los elementos que componen una aplicacin VB.NET, son organizados por VS.NET bajo el concepto de
proyecto. Un proyecto aglutina los ficheros de cdigo de la aplicacin, recursos, referencias a clases globales de la
plataforma .NET, etc. Consulte el lector el tema dedicado a la primera aplicacin en VB.NET para una descripcin
general de estos tipos de fichero.
De manera implcita, cada vez que creamos un nuevo proyecto utilizando el IDE, dicho proyecto es al mismo
tiempo un ensamblado de mbito privado, por lo que tambin podemos referirnos a una aplicacin utilizando ambos
trminos: proyecto o ensamblado.
Module
Module1
Sub
Main()
End
Sub
End
Module
Cdigo fuente 48
En el caso de una aplicacin de consola creada desde VS.NET, se crea un mdulo de forma automtica que
contiene un procedimiento Main( ) vaco. Dentro de este procedimiento escribiremos el cdigo de los prximos
ejemplos.
Variables
Una variable es un identificador del programa que guarda un valor que puede ser modificando durante el
transcurso de dicha aplicacin.
Declaracin
La declaracin de una variable es el proceso por el cual comunicamos al compilador que vamos a crear una
nueva variable en el programa.
Para declarar una variable utilizaremos la palabra clave Dim, seguida del identificador o nombre que daremos a
dicha variable. Ver Cdigo fuente 49
Sub
Main()
Dim
MiValor
Sub
End
Cdigo fuente 49
Denominacin
Respecto al nombre de la variable, debe empezar por letra, y no puede ser ninguna de las palabras reservadas del
lenguaje, ni contener caracteres como operadores u otros smbolos especiales. VerCdigo fuente 50
Sub
Dim
Dim
Dim
Dim
Dim
Dim
MiValor
'
Total2
'
Mis_Datos
'
7Datos
'
Nombre+Grande
'
End
'
nombre
nombre
nombre
nombre
nombre
nombre
Main()
correcto
correcto
correcto
incorrecto
incorrecto
incorrecto
End
Sub
Cdigo fuente 50
Como podemos comprobar en este fuente, y ya explicamos en un tema anterior, incluimos comentarios en el
cdigo usando la comilla simple ( ' ) seguida del comentario correspondiente.
Estos avisos constituyen una gran ayuda, ya que permiten al programador observar problemas en la escritura del
cdigo, antes incluso de ejecutar el programa.
Existen multitud de avisos de muy diversa naturaleza, teniendo en cuenta que la tnica general consiste en que
el cdigo problemtico quedar subrayado por el IDE hasta que no modifiquemos la lnea en cuestin y la escribamos
correctamente.
Lugar de la declaracin
Podemos declarar variables en muy diversos lugares del cdigo. El punto en el que declaremos una variable ser
determinante a la hora del mbito o accesibilidad a esa variable desde otros puntos del programa. Por ahora, y
cindonos a la declaracin de variables dentro de procedimientos, recomendamos declarar todas las variables en la
cabecera o comienzo del procedimiento, para dar una mayor claridad al mismo. Despus de la declaracin,
escribiramos el resto de instrucciones del procedimiento.
Tipificacin
La tipificacin de una variable es la operacin por la cual, al declarar una variable, especificamos qu clase de
valores o tipo de datos vamos a poder almacenar en dicha variable.
En VB.NET utilizamos la palabra clave As seguida del nombre del tipo de datos, para establecer el tipo de una
variable. Ver Cdigo fuente 51
Dim
Dim
Dim
Sub
Valor
As
String
'
Cuenta
As
Integer
FhActual
As
Main()
cadena
de
caracteres
'
numrico
entero
Date
'
fecha
End
Sub
Cdigo fuente 51
Si al declarar una variable no indicamos el tipo, por defecto tomar Object, que corresponde al tipo de datos
genrico en el entorno del CLR, y admite cualquier valor.
Segn la informacin que acabamos de ver, si declaramos una variable de tipo Byte e intentamos asignarle el
valor 5899 se va a producir un error, ya que no se encuentra en el intervalo de valores permitidos para esa variable.
Esto puede llevar al lector a preguntar: por qu no utilizar siempre Object y poder usar cualquier valor?, o mejor
para qu necesitamos asignar tipo a las variables?.
El motivo de tipificar las variables reside en que cuando realizamos una declaracin, el CLR debe reservar
espacio en la memoria para los valores que pueda tomar la variable, como puede ver el lector en la tabla anterior, no
requiere el mismo espacio en memoria una variable Byte que una Date. Si adems, declaramos todas las variables
como Object, los gastos de recursos del sistema sern mayores que si establecemos el tipo adecuado para cada una, ya
que como el CLR no sabe el valor que puede tomar en cada ocasin la variable, debe realizar un trabajo extra de
adecuacin, consumiendo una mayor cantidad de recursos.
Una correcta tipificacin de las variables redundar en un mejor aprovechamiento de las capacidades del
sistema y en un cdigo ms veloz en ejecucin. Cuantos ms programas se diseen optimizando en este sentido, el
sistema operativo ganar en rendimiento beneficindose el conjunto de aplicaciones que estn en ejecucin.
VS.NET dispone de una ayuda al asignar el tipo a una variable, que nos muestra la lista de tipos disponibles
para poder seleccionar uno sin tener que escribir nosotros el nombre. Al terminar de escribir la palabra As, aparecer
dicha lista, en la que pulsando las primeras letras del tipo a buscar, se ir situando en los ms parecidos. Una vez
encontrado, pulsaremos la tecla Enter o Tab para tomarlo. Ver Figura 167.
Figura 167. Lista de tipos de datos al declarar una variable.
En el caso de que tengamos que declarar ms de una variable del mismo tipo, podemos declararlas todas en la
misma lnea, separando cada una con una coma e indicando al final de la lista el tipo de dato que van a tener, como
vemos en el Cdigo fuente 52
Dim
Nombre,
Apellidos,
Ciudad
As
String
Cdigo fuente 52
Con esta tcnica de declaracin, todas las variables de la lnea tienen el mismo tipo de dato, ya que no es posible
declarar mltiples variables en la misma lnea que tengan distintos tipos de dato.
Asignacin de valor
Para asignar un valor a una variable utilizaremos el operador de asignacin: el signo igual ( = ), situando a su
izquierda la variable a asignar, y a su derecha el valor. Ver Cdigo fuente 53
Dim
Cuenta
Cuenta
As
=
Integer
875
Cdigo fuente 53
Segn el tipo de dato de la variable, puede ser necesario el uso de delimitadores para encerrar el valor que
vamos a asignar.
.
Tipos numricos. Las variables de tipos de datos numricos no necesitan delimitadores, se asigna
directamente el nmero correspondiente. Si necesitamos especificar decimales, utilizaremos el punto ( . ) como
carcter separador para los decimales
.
Cadenas de caracteres. En este caso es preciso encerrar la cadena entre comillas dobles ( " ).
.
Fechas. Al asignar una fecha a una variable de este tipo, podemos encerrar dicho valor entre el signo
de almohadilla ( # ) o comillas dobles ( " ). El formato de fecha a utilizar depende del delimitador. Cuando usemos
almohadilla la fecha tendr el formato Mes/Da/Ao; mientras que cuando usemos comillas dobles el formato ser
Da/Mes/Ao.
Las fechas pueden contener adems informacin horario que especificaremos en el formato
Hora:Minutos:Segundos FranjaHoraria. En el caso de que no indiquemos la franja horaria
(AM/PM) y si estamos utilizando el signo almohadilla como separador, el entorno insertar
automticamente los caracteres de franja horaria correspondientes.
Tipos lgicos. Las variables de este tipo slo pueden tener el valor True (Verdadero) o False (Falso).
Adems de asignar valores como acabamos de explicar, podemos asignar el contenido de una variable a otra o el
resultado de una expresin, como veremos ms adelante en el apartado dedicado a operadores. El Cdigo fuente 54
Sub
Dim
Dim
Dim
Dim
Dim
Dim
Dim
Dim
Dim
ImporteFac
Precio
Valor
FhActual
FhNueva
FhCompletaUno
FhCompletaDos
FhHora
Correcto
Main()
Integer
Double
String
Date
Date
Date
Date
Date
Boolean
As
As
As
As
As
As
As
As
As
ImporteFac
Precio
Valor
FhActual
FhNueva
FhCompletaUno
FhCompletaDos
FhHora
Dim
NuevaCadena
875
50.75
"mesa"
#5/20/2001#
"25/10/2001"
#10/18/2001
=
=
=
Valor
NuevaCadena
'
Correcto
9:30:00
As
asignar
una
variable
'
mostrar
Console.WriteLine("Variable
Console.WriteLine("Variable
Console.WriteLine("Variable
Console.WriteLine("Variable
Console.WriteLine("Variable
Console.WriteLine("Variable
Console.WriteLine("Variable
Console.WriteLine("Variable
Console.WriteLine("Variable
Console.WriteLine("Variable
mes/da/ao
dia/mes/ao
AM#
14:22:00"
PM#
"7/11/2001
#5:40:00
'
'
variables
ImporteFac:
Precio:
Valor:
FhActual:
FhNueva:
FhCompletaUno:
FhCompletaDos:
FhHora:
NuevaCadena:
Correcto:
String
otra
True
en
la
{0}",
{0}",
{0}",
{0}",
{0}",
{0}",
{0}",
{0}",
{0}",
{0}",
consola
ImporteFac)
Precio)
Valor)
FhActual)
FhNueva)
FhCompletaUno)
FhCompletaDos)
FhHora)
NuevaCadena)
Correcto)
Console.ReadLine()
End
Sub
Cdigo fuente 54
Otra cualidad destacable en este apartado de asignacin de valores, reside en que podemos declarar una variable
y asignarle valor en la misma lnea de cdigo, como vemos en el Cdigo fuente 55
Dim
Dim
Valor
ImporteFac
Cdigo fuente 55
As
As
String
=
"mesa"
Integer
=
875
Valor inicial
Toda variable declarada toma un valor inicial por defecto, a no ser que realicemos una asignacin de valor en el
mismo momento de la declaracin. A continuacin se muestran algunos valores de inicio en funcin del tipo de dato
que tenga la variable:
.
.
.
.
.
Numrico. Cero ( 0 ).
Cadena de caracteres. Cadena vaca ( "" ).
Fecha. 01/01/0001 0:00:00.
Lgico. Falso (False).
Objeto. Valor nulo (Nothing).
Sub
Main()
Dim
ImporteFac
Dim
Valor
Dim
FhActual
As
Date
Dim
FhNueva
As
Date
Dim
ValorLogico
As
Boolean
Dim
UnObjeto
As
Object
'
mostrar
As
Integer
As
variables
Console.WriteLine("Variable
String
en
la
ImporteFac:
Console.WriteLine("Variable
{0}",
Valor:
{0}",
consola
ImporteFac)
Valor)
Console.WriteLine("Variable
FhActual:
{0}",
FhActual)
Console.WriteLine("Variable
FhNueva:
{0}",
FhNueva)
Console.WriteLine("Variable
ValorLogico:
Console.WriteLine("Variable
{0}",
UnObjeto:
{0}",
ValorLogico)
UnObjeto)
Console.ReadLine()
End
Sub
Cdigo fuente 56
Debemos tener en cuenta al ejecutar estas lneas, que en los casos de las variables de tipo cadena y objeto, no se
mostrar nada, ya que se considera que estn inicializadas pero vacas.
Por otro lado podemos, inversamente, inicializar una variable que ya tiene valor, asignndole la palabra clave
Nothing; con ello, la variable pasa a tener el valor por defecto o inicial. Ver el Cdigo fuente 57.
Sub
Main()
Dim
Valor
Dim
FhActual
As
String
As
Date
Dim
ValorLogico
'
Valor
FhActual
ValorLogico
asignar
valores
=
=
=
'
Valor
FhActual
ValorLogico
'
As
Boolean
variables
"mesa"
"10/8/2001"
True
inicializar
=
=
=
mostrar
variables
Console.WriteLine("Variable
variables
Nothing
Nothing
Nothing
en
Valor:
Console.WriteLine("Variable
FhActual:
Console.WriteLine("Variable
ValorLogico:
la
{0}",
{0}",
{0}",
consola
Valor)
FhActual)
ValorLogico)
Console.ReadLine()
End
Sub
Cdigo fuente 57
Declaracin obligatoria
Es obligatorio, por defecto, la declaracin de todas las variables que vayamos a utilizar en el cdigo. En el caso
de que intentemos utilizar una variable no declarada, se producir un error.
La declaracin de variables proporciona una mayor claridad al cdigo, ya que de esta forma, sabremos en todo
momento si un determinado identificador corresponde a una variable de nuestro procedimiento, de un parmetro, etc.
Mediante la instruccin Option Explicit, y sus modificadores On/Off, podemos requerir o no la declaracin de
variables dentro del programa.
. Option Explicit On. Hace obligatoria la declaracin de variables. Opcin por defecto.
. Option Explicit Off. Hace que no sea obligatoria la declaracin de variables.
Podemos aplicar esta instruccin para que tenga efecto a nivel de proyecto y a nivel de
fichero de cdigo.
Option Explicit a nivel de proyecto.
Para establecer Option Explicit a nivel de proyecto, debemos abrir la ventana Explorador de soluciones, hacer
clic en el nombre del proyecto, y a continuacin pulsar el botn de propiedades en esa misma ventana. Esto mostrar
la ventana de propiedades del proyecto, en cuyo panel izquierdo haremos clic sobre el elemento Generar. Finalmente
abriremos la lista desplegable del elemento Option Explicit, seleccionaremos un valor (On, Off) y pulsaremos Aplicar
y Aceptar. Ver Figura 168.
Figura 168. Propiedades del proyecto para modificar la declaracin obligatoria de variables.
Con la declaracin obligatoria desactivada podramos escribir cdigo como el mostrado en el Cdigo fuente 58.
Sub
Main()
Valor
MiDato
"coche"
=
984
Console.WriteLine("Variable
Valor:
{0}",
Valor)
Console.WriteLine("Variable
MiDato:
{0}",
MiDato)
Console.ReadLine()
End
Sub
Cdigo fuente 58
En el ejemplo anterior, no hemos declarado las variables en Main( ). Al estar Option Explicit Off esto no
produce error, y el CLR al detectar un identificador sin declarar, crea una nueva variable internamente.
Mucho ms fcil que tener que declarar las variables verdad?. Pues precisamente esta facilidad es uno de los
graves problemas de no declarar variables. En un procedimiento de prueba con poco cdigo, esto no supone una
importante contrariedad. Sin embargo pensemos un momento, que en lugar de un pequeo procedimiento, se trata de
una gran aplicacin con muchas lneas de cdigo, procedimientos, y cientos de variables. Al encontrarnos con una
variable de esta forma, no sabremos si esa variable ya la hemos utilizado con anterioridad en el procedimiento, si ha
sido pasada como parmetro al mismo, etc. Estas circunstancias provocan que nuestro cdigo se vuelva complejo de
interpretar, retrasando la escritura general de la aplicacin. Si volvemos a activar Option Explicit On, inmediatamente
sabremos que algo va mal, ya que toda variable no declarada, quedar subrayada por el IDE como un error de
escritura. Las ventajas son evidentes.
Option Explicit a nivel de fichero.
Para establecer la declaracin obligatoria a nivel de fichero, debemos situarnos al comienzo del fichero de
cdigo y escribir la instruccin Option Explicit con el modificador correspondiente. El Cdigo fuente 59 muestra un
ejemplo de cmo desactivar esta caracterstica en el fichero de cdigo actual.
'
'
'
desactivar
declaracin
obligatoria
de
variables
ahora
podemos,
dentro
de
este
fichero
de
cdigo,
escribir
todas
las
variables
sin
declarar
Option
Explicit
Off
Module
Sub
Valor
MiDato
Module1
Main()
"coche"
984
=
=
Console.WriteLine("Variable
Valor:
{0}",
Valor)
Console.WriteLine("Variable
MiDato:
{0}",
MiDato)
Console.ReadLine()
End
Sub
End
Module
Cdigo fuente 59
Option Explicit a nivel de fichero, nos permite establecer el modo de declaracin de variables slo para ese
fichero en el que lo utilizamos, independientemente del tipo de obligatoriedad en declaracin de variables establecido
de forma general para el proyecto. Podemos por ejemplo, tener establecido Option Explicit On para todo el proyecto,
mientras que para un fichero determinado podemos no obligar a declarar variables escribiendo al comienzo del mismo
Option Explicit Off.
El hecho de tener Option Explicit Off no quiere decir que no podamos declarar variables, podemos, por
supuesto declararlas, lo que sucede es que el compilador no generar un error al encontrar una variable sin declarar.
El otro grave problema al no declarar variables proviene por la incidencia en el rendimiento de la aplicacin.
Cuando tenemos Option Explicit Off, el CLR por cada identificador que encuentre sin declarar, crea una nueva
variable, y ya que desconoce qu tipo de dato querra utilizar el programador, opta por asignarle el ms genrico:
Object.
Una excesiva e innecesaria proliferacin de variables Object afectan al rendimiento del programa, ya que el
CLR debe trabajar doblemente en la gestin de recursos utilizada por dichas variables. En el prximo apartado
trataremos sobre la obligatoriedad a la hora de tipificar variables.
Por todo lo anteriormente comentado, a pesar de la engaosa facilidad y flexibilidad de Option Explicit Off,
nuestra recomendacin es tener configurado siempre Option Explicit On a nivel de aplicacin, nos ahorrar una gran
cantidad de problemas.
Tipificacin obligatoria
Cuando declaramos una variable, no es obligatorio por defecto, establecer un tipo de dato para la misma.
Igualmente, al asignar por ejemplo, una variable numrica a una de cadena, se realizan automticamente las oportunas
conversiones de tipos, para transformar el nmero en una cadena de caracteres. Veamos un ejemplo en el Cdigo
fuente 60.
Sub
'
'
Main()
no
es
la
necesario
variable
tipificar
Valor
la
se
variable,
crea
tipificacin
con
el
tipo
Dim
Object
Valor
'
tipificacin
Dim
Dim
Importe
UnaCadena
'
'
implcita,
al
sigue
asignar
siendo
una
de
explcita
Integer
String
As
As
fecha
tipo
a
Object,
la
pero
variable
detecta
Valor,
que
'
'
Valor
se
trata
esta
de
informacin
una
fecha
como
y
un
guarda
subtipo
Importe
'
no
'
para
'
ya
'
la
UnaCadena
internamente
Date
#8/20/2001#
590
es
necesario
hacer
una
conversin
de
tipos
previa
asignar
un
nmero
a
una
variable
de
cadena,
que
se
realiza
una
conversin
implcita,
variable
UnaCadena
contiene
la
cadena
"590"
=
Importe
Console.WriteLine("Variable
Valor:
Console.WriteLine("Variable
Importe:
Console.WriteLine("Variable
UnaCadena:
{0}",
{0}",
{0}",
Valor)
Importe)
UnaCadena)
Console.ReadLine()
End
Sub
Cdigo fuente 60
Como ya comentbamos en el apartado anterior, si no asignamos el tipo de dato adecuado al declarar una
variable, el CLR le asigna el tipo Object, lo que afecta negativamente al rendimiento de la aplicacin.
La instruccin Option Strict, junto a sus modificadores On/Off, nos permite establecer si en el momento de
declarar variables, ser obligatoria su tipificacin. Tambin supervisa la obligatoriedad de realizar una conversin de
tipos al efectuar asignaciones entre variables, o de expresiones a variables.
.
Option Strict On. Hace obligatoria la tipificacin de variables y la conversin de tipos explcita.
.
Option Strict Off. Hace que no sea obligatoria la tipificacin de variables. La conversin de entre
tipos distinta en asignaciones y expresiones es realizada automticamente por el entorno. Opcin por defecto.
Podemos configurar Option Strict a nivel de proyecto y de fichero de cdigo, de igual forma que con Option
Explicit. En el caso de configurar a nivel de proyecto, deberemos abrir la ventana de propiedades del proyecto, y en su
apartado Generar, establecer el valor correspondiente en la lista desplegable Option Strict. Ver Figura 169.
Figura 169. Configuracin de Option Strict a nivel de proyecto.
Si configuramos a nivel de fichero de cdigo, escribiremos esta instruccin en la cabecera del fichero con el
modificador oportuno. Consulte el lector el anterior apartado para un mayor detalle sobre el acceso a esta ventana de
propiedades del proyecto.
En el ejemplo del Cdigo fuente 61, establecemos Option Strict On a nivel de fichero de cdigo, y a partir de
ese momento, no podremos asignar un tipo de dato Double a un Integer, o un valor numrico a una variable String,
por exponer un par de casos de los ms comunes. El cdigo errneo ser marcado por el IDE como un error de
sintaxis, e igualmente se producir un error si intentamos ejecutar el programa.
Option
Module
Strict
On
Module1
Sub
'
ahora
es
obligatorio
Main()
establecer
'
el
tipo
Dim
Dim
Dim
TotalGeneral
Valor
=
TotalGeneral
Dato
=
TotalGeneral
End
de
Valor
TotalGeneral
Dato
'
'
dato
todas
las
As
As
As
error,
error,
no
no
=
se
se
permite
permite
la
la
conversin
conversin
variables
Integer
Double
String
500
implcita
implcita
Sub
Module
End
Cdigo fuente 61
Si queremos que no se produzcan errores de conversin en el anterior cdigo fuente, tendremos que emplear las
funciones de conversin de tipo que proporciona el lenguaje. En este caso utilizaremos
CInt( ), a la que pasamos un valor numrico como parmetro, y devuelve un tipo numrico Integer; y CStr( ),
que convierte a String el valor que pasemos como parmetro. Veamos el resultado en el Cdigo fuente 62.
Sub
Main()
'
ahora
'
el
es
tipo
Dim
de
obligatorio
dato
Valor
Dim
todas
Integer
Double
As
TotalGeneral
String
=
=
variables
As
Dato
Valor
las
As
TotalGeneral
Dim
Dato
establecer
CInt(TotalGeneral)
CStr(TotalGeneral)
'
conversin
End
'
de
500
conversin
de
tipos
tipos
Sub
Cdigo fuente 62
Establecer Option Strict On requiere un mayor trabajo por parte del programador, ya que ha de ser ms
cuidadoso y escribir un cdigo ms correcto y preciso, lo cual es muy conveniente. Sin embargo, ya que la opcin por
defecto en este sentido es Option Strict Off, los ejemplos realizados a lo largo de este texto se ajustarn en este
particular a dicha configuracin, con ello ganamos en comodidad, ya que evitaremos la obligacin de realizar
conversiones de tipos en muy diversas situaciones.
arrays reside en su uso a travs de las caractersticas de orientacin a objetos de que disponen, cubriremos los arrays en
profundidad posteriormente, dentro de un tema especfico en el que trataremos todos sus aspectos principales.
Declaracin
Para declarar un array actuaremos prcticamente igual que para declarar una variable normal, con la diferencia
de que utilizaremos los parntesis junto al nombre de la variable, para indicar que se trata de un array, y
opcionalmente, dentro de los parntesis, indicaremos el nmero de elementos de que inicialmente va a constar el array.
Tambin es posible, asignar valores a los elementos en el mismo momento de su declaracin.
Debemos tener en cuenta a la hora de establecer el nmero de elementos, que el primer ndice de un array es el
cero, por lo que al ser creado, el nmero real de elementos en un array ser el especificado en la declaracin ms uno.
La Figura 170 muestra la representacin de un array en un modo grfico.
Figura 170. Representacin grfica de un array.
Sub
'
Dim
array
Colores()
'
array
Dim
'
'
Dim
array
en
el
Frutas()
sin
As
Main()
elementos
String
con
4
Nombres(3)
elementos:
de
As
con
3
momento
As
String
elementos,
cuyos
valores
de
la
declaracin
del
=
{"Manzana",
"Naranja",
End
3
String
asignamos
array
"Pera"}
Sub
Cdigo fuente 63
Al declarar un array, todos sus valores son del mismo tipo de dato. Si necesitamos que dichos valores sean de
tipos diferentes, debemos declarar el array como tipo Object, ya que al ser este, el tipo de dato genrico en el entorno
de .NET, nos permitir asignar valores de distintos tipos al array.
Sub
'
array
Dim
con
4
elementos:
de
Nombres(3)
As
Main()
a
3
String
'
asignar
valores
Nombres(0)
al
array
Nombres(1)
"Ana"
Nombres(2)
"Pedro"
Nombres(3)
"Antonio"
=
'
obtener
"Laura"
valores
de
un
array
Dim
ValorA
As
String
Dim
ValorB
As
String
ValorA
Nombres(1)
'
Pedro
ValorB
Nombres(3)
'
Laura
'
mostrar
los
Console.WriteLine("Variables:
valores
ValorA
-->
{0},
obtenidos
ValorB
-->
del
{1}",
ValorA,
array
ValorB)
Console.ReadLine()
End
Sub
Cdigo fuente 64
Modificacin de tamao
Para modificar el tamao o nmero de elementos de un array, emplearemos la instruccin ReDim, seguido del
array a modificar y el nuevo tamao. En el Cdigo fuente 65, modificamos el tamao de un array, aadindole dos
elementos.
'
Dim
array con 4
Nombres(3)
'
asignar
Nombres(0)
Nombres(1)
Nombres(2)
Nombres(3)
'
ampliamos
ReDim
elementos:
As
valores
=
=
=
=
al
el
con
array
de
0 a 3
String
array
"Ana"
"Pedro"
"Antonio"
"Laura"
elementos:
de 0 a 5
Nombres(5)
Cdigo fuente 65
ReDim no toma el array existente y modifica su nmero de elementos, sino que internamente crea un nuevo
array con el nmero de elementos indicado, por lo que se pierden los valores del array previo.
Para solucionar este inconveniente, debemos utilizar junto a ReDim, la palabra clave Preserve. Con ello, los
valores existentes en el array a modificar son conservados. Ver Cdigo fuente 66.
'
ampliamos
' y los valores
ReDim
el
de
array
con
los elementos
Preserve
6
elementos:
que hubiera,
de
son
0
a
5
conservados
Nombres(5)
Cdigo fuente 66
Recorrer un array
Para recorrer todos los elementos de un array emplearemos la estructura de control For...Next, que ejecuta un
bloque de cdigo un nmero determinado de veces, y la funcin del lenguaje Ubound( ), que devuelve el nmero de
elementos del array pasado como parmetro. Ver Cdigo fuente 67.
Sub
'
crear
Dim
un
array
y
Nombres(3)
rellenarlo
As
Nombres(0)
Nombres(1)
Nombres(2)
Nombres(3)
'
'
Dim
For
Main()
valores
String
con
"Ana"
"Pedro"
"Antonio"
"Laura"
=
=
=
recorrer
de
el
cada
Contador
Contador
array
uno
mostrar
de
del
0
array:
To
{0},
el
sus
As
=
Console.WriteLine("Posicin
Contador,
Next
contenido
elementos
Integer
UBound(Nombres)
valor:
{1}",
_
Nombres(Contador))
Console.ReadLine()
End
Sub
Cdigo fuente 67
La estructura For...Next ser explicada con ms detalle en el apartado dedicado a las estructuras de control del
lenguaje.
Constantes
Al igual que las variables, una constante es un elemento del lenguaje que guarda un valor, pero que en este caso
y como su propio nombre indica, dicho valor ser permanente a lo largo de la ejecucin del programa, no pudiendo ser
modificado.
Para declarar una constante, debemos utilizar la palabra clave Const, debiendo al mismo tiempo establecer el
tipo de dato y asignarle valor. Ver Cdigo fuente 68.
Sub
Const
Const
Color
As
ValorMoneda
As
String
Double
Main()
"Azul"
120.48
=
=
End
Sub
Cdigo fuente 68
La tipificacin de una constante se rige, al igual que las variables, por la configuracin que tengamos
establecida para la instruccin Option Strict.
Si intentamos asignar un valor a una constante despus de su asignacin inicial, el IDE nos subrayar la lnea
con un aviso de error de escritura, y se producir igualmente un error si intentamos ejecutar el programa. Ver Figura
171
La ventaja del uso de constantes reside en que podemos tener un valor asociado a una constante, a lo largo de
nuestro cdigo para efectuar diversas operaciones. Si por cualquier circunstancia, dicho valor debe cambiarse, slo
tendremos que hacerlo en el lugar donde declaramos la constante.
Supongamos como ejemplo, que hemos escrito un programa en el que se realiza una venta de productos y se
confeccionan facturas. En ambas situaciones debemos aplicar un descuento sobre el total resultante. Ver Cdigo fuente
69.
Sub
'
venta
Dim
Importe
Dim
TotalVenta
Console.WriteLine("Introducir
Importe
=
'
aplicar
TotalVenta
=
Console.WriteLine("El
importe
Console.WriteLine()
'
'
'
de
importe
descuento
de
sobre
Importe
la
venta
es:
la
{0}",
venta
100
TotalVenta)
.............
.............
.............
'
factura
Dim
PrecioArt
Dim
TotalFactura
Console.WriteLine("Introducir
PrecioArt
'
aplicar
TotalFactura
=
Console.WriteLine("El
total
Console.WriteLine()
'
'
'
Console.ReadLine()
Main()
productos
As
Double
As
Double
de
la
venta")
Console.ReadLine()
de
precio
del
descuento
de
mercancas
Double
Double
artculo")
Console.ReadLine()
As
As
la
a
PrecioArt
factura
es:
la
{0}",
factura
100
TotalFactura)
.............
.............
.............
End
Sub
Cdigo fuente 69
Sub
'
crear
constante
Const
DESCUENTO
para
As
calcular
Integer
'
venta
Dim
Importe
Dim
TotalVenta
Console.WriteLine("Introducir
Importe
'
aplicar
descuento
sobre
TotalVenta
=
Console.WriteLine("El
importe
Console.WriteLine()
'
'
'
de
As
As
de
importe
=
la
venta,
Importe
la
de
atencin
productos
Double
Double
la
venta")
Console.ReadLine()
al
uso
de
la
venta
es:
{0}",
constante
DESCUENTO
TotalVenta)
.............
.............
.............
'
factura
Dim
PrecioArt
Dim
TotalFactura
Console.WriteLine("Introducir
PrecioArt
'
aplicar
descuento
a
TotalFactura
=
Console.WriteLine("El
total
Console.WriteLine()
'
'
'
Console.ReadLine()
Main()
descuento
=
100
la
de
de
As
As
precio
del
factura,
atencin
PrecioArt
la
factura
End
al
es:
mercancas
Double
Double
artculo")
Console.ReadLine()
uso
de
{0}",
la
constante
DESCUENTO
TotalFactura)
.............
.............
.............
Sub
Cdigo fuente 70
Podemos tambin ver con detalle el valor que van adquiriendo las variables a lo largo de la ejecucin, abriendo
la ventana Locales del depurador, mediante el men Depurar + Ventanas + Locales, o la pulsacin [CTRL + ALT +
V, L]. Ver Figura 173.
En el caso de arrays, debemos hacer clic en el signo ms ( + ) que aparece junto al nombre de la variable, para
abrir y mostrar los elementos del array. Ver Figura 174.
Si en cualquier momento queremos continuar la ejecucin normal del programa sin seguir usando el depurador,
pulsaremos [F5].
Operadores
del
lenguaje
Los operadores son aquellos elementos del lenguaje que nos permiten combinar variables, constantes, valores
literales, instrucciones, etc., para obtener un valor numrico, lgico, de cadena, etc., como resultado.
La combinacin de operadores con variables, instrucciones, etc., se denomina expresin, mientras que a los
elementos integrantes de una expresin y que no son operadores, se les denomina operandos.
En funcin de la complejidad de la operacin a realizar, o del tipo de operador utilizado, una expresin puede
ser manipulada a su vez como un operando dentro de otra expresin de mayor nivel.
Los operadores se clasifican en las categoras detalladas a continuacin, segn el tipo de expresin a construir.
Aritmticos
Efectan el conjunto habitual de operaciones matemticas.
Potenciacin: ^
Eleva un nmero a determinada potencia. Debemos situar el nmero base a la izquierda de este operador,
mientras que el exponente lo situaremos a la derecha.
Podemos realizar varias potenciaciones al mismo tiempo y utilizar nmeros negativos. El valor devuelto ser de
tipo Double. Ver Cdigo fuente 71.
Dim
Resultado
Resultado
=
12
Resultado
=
2
^
3
Resultado
=
(-4)
^
^
^
5
7
2
'
'
As
Double
devuelve:
248832
devuelve:
2097152
'
devuelve:
16
Cdigo fuente 71
Multiplicacin: *
Multiplica dos nmeros. En el caso de que alguno de los operandos sea un valor nulo, se usar como cero. Ver
Cdigo fuente 72.
Dim
Dim
Dim
Resultado
DatoSinValor
Indefinido
Resultado
As
As
As
'
la
variable
'
asignada,
por
Resultado
=
50
*
'
la
'
asignada,
Resultado
=
Double
Integer
Object
25
DatoSinValor
no
ha
sido
lo
que
contiene
cero
DatoSinValor
'
devuelve:
0
variable
Indefinido
no
ha
sido
por
lo
que
contiene
Nothing
25
*
Indefinido
'
devuelve:
0
'
devuelve:
125
Resultado
24.8
5.98
'
devuelve:
148.304
Cdigo fuente 72
Divisin real: /
Divide dos nmeros, devolviendo un resultado con precisin decimal. Ver Cdigo fuente 73.
Dim
Resultado
Resultado
=
Resultado
50
250
3
/
'
4
As
Double
devuelve: 16.6666666666667
'
devuelve:
62.5
Cdigo fuente 73
Por norma general, el valor devuelto ser de tipo Double,. No obstante, si uno de los operandos es de tipo
Single, el resultado ser de tipo Single. De igual manera, si los dos operandos son del tipo de dato Decimal, el
resultado tambin ser un valor Decimal.
Divisin entera: \
Divide dos nmeros, devolviendo como resultado un valor numrico entero. Ver Cdigo fuente 74.
Dim
Resultado
Resultado
=
Resultado
=
50
\
3
'
250
\
4
'
devuelve:
devuelve:
As
Integer
16
62
Cdigo fuente 74
Resto: Mod
Divide dos nmeros y devuelve el mdulo o resto de la divisin. Ver Cdigo fuente 75.
Dim
Resultado
As
Double
Cdigo fuente 75
Suma: +
En funcin del tipo de dato de los operandos, este operador realiza una suma de nmeros o una concatenacin
de cadenas de caracteres. Puede producirse un error dependiendo del tipo de dato del operando y la configuracin de
Option Strict. El Cdigo fuente 76 muestra algunos ejemplos de suma y concatenacin, con la instruccin Option
Strict Off.
Sub
Dim
Dim
Dim
Dim
Dim
Resultado
Cadena
Valor
Nombre
CadenaResulta
'
Resultado
Resultado
'
Cadena
Main()
Double
String
Integer
String
String
As
As
As
As
As
=
=
suma
12
450
"hola
concatenacin
"
+
"amigos"
'
Cadena
Valor
CadenaResulta
de
+
+
7
130
'
'
de
devuelve:
'
suma
devuelve:
devuelve:
"hola
de
=
=
Cadena
'
Valor
Nombre
Valor
'
devuelve:
operaciones
=
=
CadenaResulta
Resultado
End
Valor
Valor
cadenas
amigos"
variables
"15"
20
"35"
incorrectas
25
"Alfredo"
+
nmeros
19
580
Nombre
Nombre
'
'
error
error
Sub
Cdigo fuente 76
Si cambiamos a continuacin la configuracin a Option Strict On, la siguiente operacin que antes se ejecutaba,
ahora provocar un error. Ver Cdigo fuente 77.
'
Cadena
Valor
CadenaResulta
suma
de
=
=
Cadena
Valor
variables
"15"
20
'
error
Cdigo fuente 77
Para solucionar el problema debemos convertir explcitamente todos los operandos al mismo tipo de datos.
Observe el lector que en esta situacin, no se realiza una suma, sino una concatenacin. Ver Cdigo fuente 78.
'
Cadena
Valor
suma
de
=
=
variables
"15"
20
CadenaResulta
Cadena
CStr(Valor)
'
devuelve:
"1520"
Cdigo fuente 78
A pesar de que el operador + permite concatenar tipos String, se recomienda el uso del operador especfico de
concatenacin &, que veremos ms adelante.
Resta: Efecta una resta entre dos nmeros, o cambia el signo de un nmero (de positivo a negativo, y viceversa). Ver
Cdigo fuente 79.
Sub
Dim
Resultado
As
Dim
Valor
As
Dim
OtroValor
As
'
resta
de
Resultado
=
100
'
cambiar
a
signo
negativo
Valor
=
'
volver
a
cambiar
el
signo
de
'
estaba
en
negativo,
con
lo
'
a
OtroValor
=
un
un
que
Main()
Integer
Integer
Integer
nmeros
75
nmero
-50
nmero,
vuelve
positivo
-Valor
End
Sub
Cdigo fuente 79
Concatenacin: &, +
Estos operadores permiten unir dos o ms cadenas de caracteres para formar una nica cadena. Se recomienda el
uso de & para facilitar la legibilidad del cdigo y evitar ambigedades. El uso de + puede dar lugar a equvoco, ya que
en muchas situaciones no sabremos a primera vista si se est realizando una suma o concatenacin. Ver Cdigo fuente
80.
Sub
Dim
Dim
CadResulta
Nombre
As
As
CadResulta
=
Console.WriteLine("Variable
Nombre
CadResulta
=
Console.WriteLine("Variable
Console.ReadLine()
End
Cdigo fuente 80
Main()
String
String
"esto
es
CadResulta:
"
=
Nombre
CadResulta:
&
&
{0}",
"una
"
{0}",
prueba"
CadResulta)
"Juan"
Almendro"
CadResulta)
Sub
Potencia: ^=
Para elevar un nmero a una potencia podemos utilizar la sintaxis normal o abreviada. Ver Cdigo fuente 81.
Dim
Dim
Valor
Resultado
Valor
Resultado
'
Resultado
'
Resultado
As
As
=
=
Integer
Double
3
2
sintaxis
Resultado
^
Valor
sintaxis
Valor
^=
'
'
normal
devuelve:
8
abreviada
devuelve:
8
Cdigo fuente 81
Multiplicacin: *=
Para multiplicar dos nmeros podemos utilizar la sintaxis normal o abreviada. Ver Cdigo fuente 82.
Dim
Dim
Valor
Resultado
Valor
Resultado
'
Resultado
'
Resultado
As
As
=
=
Integer
Double
7
12
Resultado
*=
sintaxis
*
Valor
sintaxis
Valor
'
'
normal
devuelve:
84
abreviada
devuelve:
84
Cdigo fuente 82
Divisin real: /=
Para dividir dos nmeros, y obtener un resultado con precisin decimal, podemos utilizar la sintaxis normal o
abreviada. Ver Cdigo fuente 83.
Dim
Dim
Valor
Resultado
Valor
Resultado
'
Resultado
'
Resultado
As
As
5
182
Integer
Double
Resultado
sintaxis
/
Valor
sintaxis
Valor
'
/=
'
devuelve:
normal
36.4
abreviada
devuelve:
36.4
Cdigo fuente 83
Divisin entera: \=
Para dividir dos nmeros, con un resultado entero, podemos utilizar la sintaxis normal o abreviada. Ver Cdigo
fuente 84.
Dim
Dim
Valor
Resultado
Valor
Resultado
'
Resultado
'
Resultado
As
As
5
182
Integer
Double
Resultado
sintaxis
\
Valor
sintaxis
Valor
'
\=
'
normal
devuelve:
36
abreviada
devuelve:
36
Cdigo fuente 84
Suma: +=
Podemos sumar nmeros, o concatenar cadenas utilizando la sintaxis normal o abreviada. Ver Cdigo fuente 85.
Dim
Dim
Dim
Dim
Valor
Resultado
CadenaA
CadenaB
As
As
As
As
'
con
Valor
Resultado
valores
=
=
'
Resultado
Resultado
Integer
Double
String
String
numricos
69
200
sintaxis
+
Valor
'
devuelve:
normal
269
'
Resultado
'
CadenaA
CadenaB
CadenaB
sintaxis
Valor
'
+=
con
=
+=
abreviada
devuelve:
269
cadenas
"
=
'
devuelve:
CadenaA
de
varios
"589
caracteres
numeros"
"589"
varios
numeros"
Cdigo fuente 85
Resta: -=
Podemos restar nmeros utilizando la sintaxis normal o abreviada. Ver Cdigo fuente 86.
Dim
Dim
Valor
Resultado
Valor
Resultado
'
Resultado
'
Resultado
As
As
69
200
Integer
Double
Resultado
sintaxis
Valor
sintaxis
Valor
'
-=
'
devuelve:
normal
131
abreviada
devuelve:
131
Cdigo fuente 86
Concatenacin: &=
Para concatenar dos cadenas, podemos emplear la sintaxis normal o abreviada. Ver Cdigo fuente 87.
Dim
Dim
PrimeraCad
SegundaCad
PrimeraCad
SegundaCad
=
'
PrimeraCad
'
PrimeraCad
&=
As
As
"Aqu
"una
PrimeraCad
Cdigo fuente 87
String
String
SegundaCad
va
"
prueba"
&
sintaxis
SegundaCad
'
sintaxis
'
devuelve:
devuelve:
"Aqu
va
"Aqu
una
va
una
abreviada
prueba"
normal
prueba"
Comparacin
Estos operadores permiten comprobar el nivel de igualdad o diferencia existente entre los operandos de una
expresin. El resultado obtenido ser un valor lgico, True (Verdadero) o False (Falso). La Tabla 6 muestra la lista de
los operadores disponibles de este tipo.
nmeros.
Dim
Resultado
As
Boolean
Cdigo fuente 88
Comparacin de cadenas
Podemos utilizar los operadores de comparacin antes descritos para comparar tambin cadenas de caracteres.
La instruccin Option Compare, junto a sus modificadores Binary/Text, nos permite definir el modo en que se
realizarn las comparaciones entre expresiones que contengan cadenas.
.
Option Compare Binary. Las comparaciones se realizan en base a los valores binarios internos de
los caracteres. Esta es la opcin por defecto.
.
Option Compare Text. Las comparaciones se realizan en base a los valores textuales de los
caracteres.
Podemos configurar Option Compare a nivel de proyecto y de fichero de cdigo. En el caso de configurar a
nivel de proyecto, deberemos abrir la ventana de propiedades del proyecto, y en su apartado Generar, establecer el
valor correspondiente en la lista desplegable. Ver Figura 175.
Si configuramos a nivel de fichero de cdigo, escribiremos esta instruccin en la cabecera del fichero con el
modificador oportuno. Consulte el lector el apartado sobre declaracin obligatoria de variables, para un mayor detalle
sobre el acceso a esta ventana de propiedades del proyecto.
En el Cdigo fuente 89 tenemos un ejemplo de comparacin de cadenas utilizando Option Compare Binary.
Option
Compare
Binary
Module
Module1
Sub
Dim
Resultado
As
Main()
Boolean
El motivo de que la comparacin A con a devuelva falso, o de que M no sea mayor que m se debe a
que lo que se comparan son los valores binarios, o cdigos que sirven para representar a cada carcter. Por ejemplo, el
cdigo de M es 77, mientras que el de m es 109, por lo que al ser este ltimo mayor, la comparacin realizada en
Option
Compare
Text
Module
Module1
Sub
Dim
Resultado
Resultado
"A"
"a"
'
devuelve:
True
Resultado
"M"
<
"Z"
'
devuelve:
True
Resultado
"M"
>
"m"
'
devuelve:
False
Resultado
Main()
Boolean
As
"F"
<>
"f"
'
End
End
devuelve:
False
Sub
Module
Cdigo fuente 90
En esta ocasin A y a si son iguales, debido a que se comparan sus valores como texto y no como los
cdigos internos utilizados para representar los caracteres. De igual forma, se devuelve falso en la expresin que
comprueba si F y f son distintos, ya que bajo esta configuracin, ambos caracteres se consideran iguales.
La funcin Asc( )
Cuando realizamos comparaciones entre cadenas, basadas en los valores binarios de los caracteres, es til en
ocasiones conocer el cdigo de dichos caracteres. Para averiguar cul es el cdigo correspondiente a un determinado
carcter, el lenguaje nos proporciona la funcin Asc( ).
Esta funcin recibe como parmetro una cadena, y devuelve un valor numrico de tipo Integer, con el cdigo
correspondiente al primer carcter de la cadena. El Cdigo fuente 91 nos muestra algunos ejemplos.
Dim
CodigoCar
CodigoCar
=
CodigoCar
=
CodigoCar
=
CodigoCar
=
CodigoCar
=
Cdigo fuente 91
CodigoCar
Asc("A")
Asc("a")
Asc("M")
Asc("F")
Asc("f")
Asc("hola")
'
'
'
'
'
'
devuelve:
devuelve:
devuelve:
devuelve:
devuelve:
devuelve:
As
65
97
77
70
102
104
Integer
La funcin Chr( )
Si nos encontramos en la situacin inversa a la descrita en el apartado anterior, es decir, tenemos el cdigo de un
carcter y queremos saber a cul corresponde, la funcin Chr( ) recibe un nmero como parmetro y devuelve el
carcter al que pertenece como un dato de tipo Char, aunque tambin podemos asignar el resultado a una variable
String. Veamos unos ejemplos en el Cdigo fuente 92.
Dim
Dim
MiCaracter
MiCadena
As
MiCaracter
MiCaracter
=
MiCadena
=
MiCadena
=
As
Char
String
Chr(65)
'
Chr(70)
'
Chr(77)
'
Chr(102)
'
devuelve:
devuelve:
devuelve:
devuelve:
"A"
"F"
"M"
"f"
Cdigo fuente 92
Resultado
Cadena
Like
Patrn
Cdigo fuente 93
.
Resultado. Valor lgico con el resultado de la comparacin. Verdadero indica que hay una
coincidencia de Cadena con Patrn. Falso indica que no se ha producido coincidencia de Cadena con Patrn.
.
Cadena. Cadena de caracteres que se compara con el patrn de coincidencia.
.
Patrn. Cadena de caracteres en donde se especifican los caracteres especiales que sirven de patrn
de coincidencia respecto al valor de Cadena. La Tabla 7 muestra los caracteres y convenciones de uso establecidas por
el lenguaje para el uso de patrones de comparacin.
Tabla 7. Caracteres patrn del operador Like.
Debemos tener en cuenta que los resultados obtenidos en expresiones que utilicen este operador estarn
condicionadas por la configuracin establecida mediante Option Compare. Revise el lector el apartado sobre
comparacin de cadenas en donde se describe esta instruccin.
Cuando utilicemos los corchetes para establecer una lista de caracteres a comparar, debemos emplear el guin (
- ) como separador de rangos. Si necesitamos que alguno de los caracteres patrn estn entre los que vamos a buscar,
debemos encerrarlo entre corchetes. El Cdigo fuente 94 muestra algunos ejemplos de uso de este operador.
'
Dim
'
'
ejemplos
con
el
operador
Like
Resultado
As
Boolean
-------------------------------patrn
?
El patrn
sustitucin
"MONITOR"
coincide con
de
dos
Like
la cadena
carcter
"HO?A"
la cadena
caracteres
"MO?ITO?"
El
'
'
'
"La
gran
llanura"
Like
"La
llanu*"
-------------------------------patrn
#
'
'
'
devuelve
True
'
al
hacer
Resultado
=
"Ha
ganado
'
devuelve
False
'
ya
que
en
el
'
existentes
Resultado
=
"Ha
ganado
'
devuelve
'
ya
que
en
'
Resultado
=
"Ha
'
'
la
128
El
patrn
128
El
patrn
coincide
con
la
cadena
sustitucin
de
dos
nmeros
millones"
Like
"Ha
ganado
##8
millones"
patrn
no
coincide
con
la
se
especifican
ms
dgitos
en
la
millones"
Like
"Ha
ganado
###8
False
El
patrn
no
el
patrn
se
utilizan
de
dgitos
ganado
128
millones"
Like
coincide
con
la
cadena,
caracteres
de
sustitucin
incorrectamente
"Ha
ganado
128
##llones"
-------------------------------patrn
[Lista]
'
devuelve
True
'
dentro
del
Resultado
=
El
rango
carcter
en
"H"
de
la
cadena,
los
cadena
millones"
de
la
cadena
lista
Like
se
del
encuentra
patrn
"[A-M]"
' devuelve
'
dentro
Resultado
False
del
=
El
rango
'
devuelve
True
'
dentro
del
Resultado
=
El
rango
' devuelve
'
dentro
Resultado
True
del
=
'
devuelve
False
'
dentro
del
Resultado
=
'
'
combinacin
El
rango
"Fal##
comparacin
dentro
'
'
se
Resultado
'
'
de
la
cadena
lista
Like
la
cadena
lista
Like
de la
la
carcter
de
en
la
"R"
False
"Faltan
*
de la
la
cadena
lista
Like
no
se
del
se
del
no
encuentra
patrn
"[a-m]"
se
del
la
cadena
se
lista
del
Like
encuentra
patrn
"[A-M]"
encuentra
patrn
"[!P-W]"
encuentra
patrn
"[!P-W]"
-------------------------------varios
caracteres
patrn
'
devuelve
True
Resultado
=
"Faltan
"Fal*
##
'
'
'
carcter
en
"h"
El carcter
rango
en
"D"
de
'
devuelve
Resultado
=
carcter
en
"h"
Todas
las
48
horas
*
para
Las
48
sustituciones
del
para
llegar
a
ll[a-g]gar
sustituciones
de
horas
para
caracteres
llegar
patrn
son
destino"
?
nmericos
son
a
destino"
correctas
Like
_
des*"
incorrectas
Like
_
para
ll[a-g]gar
?
des*"
-------------------------------utilizando
caracteres
patrn
de
la
expresin
devuelve
True
El
carcter
de
cierre
de
interrogacin
sustituye
correctamente
al
encerrarse
entre
corchetes
=
"Ha
llegado
Ana?,
bienvenida"
Like
"Ha*Ana[?],
bienvenida"
-------------------------------comparacin
de
dos
cadenas
vacas
'
Resultado
devuelve
""
Like
True
""
Cdigo fuente 94
Resultado
ObjetoA
Is
ObjetoB
Cdigo fuente 95
Para probar este operador podemos crear una aplicacin de tipo Windows y aadir un mdulo en el que
escribiramos un procedimiento Main( ). Despus de configurar el proyecto para que se inicie por este procedimiento,
escribiremos las lneas que se muestran en el Cdigo fuente 96.
'
'
Dim
Dim
Public
Sub
declarar
dos
contendran
objetos
de
VentanaUno
VentanaDos
Dim
'
'
'
VentanaUno
VentanaDos
Main()
que
Form
Form
Form
variables
la
clase
As
As
Resultado
crear
asignando
dos
cada
As
instancias
uno
de
Boolean
la
de
clase
los
las
=
=
'
la
expresin
'
False
ya
que
'
a
objetos
diferentes,
Resultado
=
New
New
de
Form
objetos
variables
Form()
Form()
comparacin
con
Is
devuelve
las
variables
tienen
referencias
aunque
sean
de
la
misma
clase
VentanaUno
Is
VentanaDos
End
Sub
Cdigo fuente 96
Como hemos podido comprobar, al comparar las variables del anterior fuente con Is, el resultado es False, ya
que ambos objetos son instancias diferentes, aunque pertenezcan a la misma clase: Form.
Si por el contrario, creamos una nica instancia de un objeto y la asignamos a las dos variables, el resultado ser
muy diferente. En este caso el operador Is devolver True ya que ambas variables contienen el mismo objeto. Ver
Cdigo fuente 97.
'
'
Dim
Dim
Public
Sub
declarar
dos
contendran
objetos
de
VentanaUno
VentanaDos
Dim
'
'
el
VentanaUno
'
'
en
VentanaDos
Main()
que
Form
Form
Form
variables
la
clase
As
As
Resultado
crear
una
objeto
despus
una
nica
resultante
=
el
variable
As
instancia
de
se
asigna
New
mismo
se
objeto
asigna
=
Boolean
la
a
que
la
clase
una
ya
otra
Form,
variable
Form()
est
variable
VentanaUno
'
'
ambas
al
'
Resultado
variables
mismo
objeto,
de
=
contienen
por
comparacin
VentanaUno
Is
una
lo
que
Is
referencia
la
devuelve
expresin
True
VentanaDos
Sub
End
Cdigo fuente 97
Resultado
ExpresinA
OperadorLogico
ExpresinB
Cdigo fuente 98
Cuando los operandos que forman parte de la expresin son numricos, la evaluacin de la expresin se realiza
a nivel de bit, es decir, comparando los bits de las posiciones equivalentes de ambos nmeros y obteniendo
igualmente, un valor numrico como resultado.
And
A nivel lgico, este operador realiza una conjuncin entre dos expresiones. La Tabla 8 muestra los diferentes
resultados obtenidos con el uso de este operador en funcin de los valores que tengan sus expresiones.
Tabla 8. Tabla de valores lgicos del operador And.
El Cdigo fuente 99 muestra algunos ejemplos a nivel lgico con este operador.
Dim
Resultado
Resultado
=
Resultado
=
Resultado
=
Cdigo fuente 99
Resultado
=
"H"
8
"W"
58
=
<>
>
>
20
"H"
8
"b"
As
And
"H"
=
"H"
'
And
720
<
150
'
And
62
<
115
'
And
"Q"
=
"R"
'
Boolean
devuelve:
devuelve:
devuelve:
devuelve:
True
False
False
False
El Cdigo fuente 100 muestra algunos ejemplos a nivel de bit con este operador.
Dim
Resultado
Resultado
=
Resultado
=
6
15
And
8
'
And
45
'
As
devuelve:
devuelve:
Integer
8
4
Dim
Resultado
As
Boolean
Resultado = (58 > 20) And ("H" = "H") ' devuelve: True
Resultado = ("H" = "H") And (720 < 150) ' devuelve: False
Resultado = (8
Resultado = ("W" >
115)
"R")
'
'
devuelve:
devuelve:
False
False
Como puede comprobar el lector al ejecutar, el resultado es el mismo que si no utilizamos parntesis, pero la
claridad al leer estas lneas de cdigo es mucho mayor.
Not
A nivel lgico, este operador realiza una negacin entre dos expresiones. Su formato es ligeramente distinto del
resto de operadores lgicos, como vemos en el Cdigo fuente 102.
Resultado
Not
Expresin
La Tabla 10 muestra los resultados obtenidos con el uso de este operador en funcin de su expresin.
Tabla
El
Cdigo
10.
fuente
Tabla
103
de
muestra
algunos
valores
ejemplos
lgicos
del
nivel
lgico
con
operador
Not.
este
operador.
El Cdigo fuente 104 muestra algunos ejemplos a nivel de bit con este operador.
Dim
Resultado
Resultado
=
Resultado
= Not 16 '
Not
4
'
devuelve:
devuelve:
As
Integer
-17
-5
Or
A nivel lgico, este operador realiza una disyuncin entre dos expresiones. La Tabla 12 muestra los diferentes
resultados obtenidos con el uso de este operador en funcin de los valores que tengan sus expresiones.
El Cdigo fuente 105 muestra algunos ejemplos a nivel lgico con este operador.
Dim
Resultado
Resultado
=
Resultado
=
Resultado
=
Resultado
=
(58
("H"
=
(8
<>
("W"
>
>
20)
Or
("H"
=
"H")
Or
(720
<
8)
Or
(62
<
"b")
Or
("Q"
=
As
"H")
150)
115)
"R")
'
'
'
'
Boolean
devuelve:
devuelve:
devuelve:
devuelve:
True
True
True
False
El Cdigo fuente 106 muestra algunos ejemplos a nivel de bit con este operador.
Dim
Resultado
Resultado
=
Resultado
=
6
15
Or
Or
8
'
45
'
As
devuelve:
devuelve:
Integer
15
47
Xor
A nivel lgico, este operador realiza una exclusin entre dos expresiones. La Tabla 14 muestra los diferentes
resultados obtenidos con el uso de este operador en funcin de los valores que tengan sus expresiones.
El Cdigo fuente 107 muestra algunos ejemplos a nivel lgico con este operador.
Dim
Resultado
Resultado
Resultado
=
Resultado
=
=
(58
("H"
=
(8
<>
Resultado
>
("W"
20)
Xor
"H")
Xor
8)
Xor
>
"b")
As
("H"
=
(720
<
(62
<
Xor
("Q"
"H")
150)
115)
=
'
'
'
Boolean
devuelve:
devuelve:
devuelve:
"R")
'
False
True
True
devuelve:
False
El Cdigo fuente 108 muestra algunos ejemplos a nivel de bit con este operador.
Dim
Resultado
Resultado
=
Resultado
=
6
15
Xor
Xor
45
'
'
devuelve:
devuelve:
As
7
43
Integer
AndAlso
Este operador realiza una conjuncin lgica de tipo cortocircuito entre dos expresiones. En este tipo de
operacin, en cuanto la primera expresin devuelva falso como resultado, el resto no ser evaluado devolviendo falso
como resultado final.
La Tabla 16 muestra los diferentes resultados obtenidos con el uso de este operador en funcin de los valores
que tengan sus expresiones.
Dim
Resultado
As
Boolean
Resultado = (58 > 20) AndAlso ("H" = "H") ' devuelve: True
Resultado = ("H" = "H") AndAlso (720 < 150) ' devuelve: False
Resultado
=
(8
<>
8)
AndAlso
(62
<
115)
'
devuelve:
False
OrElse
Este operador realiza una disyuncin lgica de tipo cortocircuito entre dos expresiones. En este tipo de
operacin, en cuanto la primera expresin devuelva verdadero como resultado, el resto no ser evaluado devolviendo
verdadero como resultado final.
La muestra los diferentes resultados obtenidos con el uso de este operador en funcin de los valores que tengan
sus expresiones.
Dim
Resultado
As
Resultado = ("H" = "H") OrElse (720 < 150) ' devuelve: True
Resultado
=
(8
<>
8)
OrElse
(62
<
115)
'
devuelve:
True
Resultado = ("W" > "b") OrElse ("Q" = "R") ' devuelve: False
Prioridad de operadores
Boolean
Dentro de una lnea de cdigo que contenga varias operaciones, estas se resolvern en un orden predeterminado
conocido como prioridad de operadores. Dicha prioridad se aplica tanto entre los operadores de un mismo grupo como
entre los distintos grupos de operadores.
Prioridad entre operadores del mismo grupo.
Los operadores aritmticos se ajustan a la prioridad indicada en la Tabla 18.
El operador de mayor prioridad es el de potenciacin, los de menor son la suma y resta. En el caso de
operadores con idntica prioridad como multiplicacin y divisin, se resolvern en el orden de aparicin, es decir, de
izquierda a derecha. Veamos un ejemplo en el Cdigo fuente 111
Dim
Resultado
Resultado
As
^
Long
'
devuelve:
261
Los operadores de comparacin tienen todos la misma prioridad, resolvindose en el orden de aparicin dentro
de la expresin.
Los operadores lgicos se ajustan a la prioridad indicada en la Tabla 19.
En el ejemplo del Cdigo fuente 112, el resultado final de la operacin es True debido a que el operador Not
cambia la segunda expresin a True, resultando las dos expresiones de la operacin True.
Dim
Resultado
Resultado
=
10
<
70
As
And
Not
30
Boolean
20
'
devuelve:
True
El Cdigo fuente 113 muestra un ejemplo de expresin en el que intervienen operadores de diferentes tipos.
Dim
Resultado
Resultado
30
As
>
100
And
52
Boolean
>
10
'
devuelve:
False
Dim
Resultado
Resultado
=
((30
5)
>
100)
As
And
(52
>
200
Boolean
(2
5))
'
devuelve:
True
Rutinas
de
cdigo
Dim
'
Resultado
Resultado
una
((30
sola
5) *
lnea
> 100)
As
And
lgica
(52 >
200
y
/
(2
Boolean
fsica
+ 5))
'
varias
lneas
fsicas,
aunque
internamente
'
el
compilador
reconoce
una
sola
lnea
lgica
Resultado
=
((30
+
5)
*
5
>
100)
And
_
(52
>
200
(2
5))
Dim
Sub
Valor
'
As
en
Integer,
la
As
String,
siguiente
'
habitualmente
Valor
50
Nombre
lnea
se
Nombre
Resultado
hay
escriben
=
"Julio"
As
Main()
Boolean
tres
en
Resultado
sentencias
lneas
=
que
separadas
50
<>
275
Si bien en algunas situaciones puede ser til, esta caracterstica hace que nuestro cdigo se vuelva ms
complicado de leer, restndole claridad a nuestra aplicacin, por lo que recomendamos no utilizarla salvo en casos
muy necesarios.
Procedimientos
Todo el cdigo ejecutable de una aplicacin se ubica en rutinas de cdigo o procedimientos. Un procedimiento
es un elemento del lenguaje compuesto por un conjunto de lneas de cdigo, a las que se denomina cuerpo del
procedimiento. Su comienzo y fin lo establecemos mediante ciertas palabras reservadas del lenguaje, asocindole un
identificador, que nos servir para reconocerlo entre el resto de procedimientos creados en el programa. Podemos
enviarle tambin informacin adicional en forma de parmetros, con lo que el resultado de la ejecucin de un
procedimiento variar segn los valores que pasemos en cada llamada.
En VB.NET disponemos de los siguientes tipos de procedimientos:
.
Sub. Procedimiento que realiza un conjunto de operaciones pero no devuelve valor al punto de
llamada. A lo largo del texto tambin nos referiremos a las rutinas de tipo Sub con el nombre genrico de
procedimiento.
.
Function. Procedimiento que realiza un conjunto de operaciones, y devuelve un valor denominado
valor de retorno al punto de cdigo que realiz la llamada. A lo largo del texto tambin nos referiremos a las rutinas de
tipo Function con el nombre genrico de funcin.
.
Property. Procedimiento que se utiliza para labores de acceso y asignacin de valores a las
propiedades de un objeto. Sern tratados con ms profundidad en el tema dedicado a la programacin orientada a
objetos.
[mbito]
Sub
NombreProcedimiento[(ListaParmetros)]
[CdigoEjecutable]
[Exit
Sub
Return]
[CdigoEjecutable]
End
Sub
Cdigo fuente 117
Los elementos que forman parte de este tipo de rutina son los siguientes:
.
mbito. Define el modo en que vamos a poder acceder o llamar al procedimiento desde otro punto de
la aplicacin. El mbito de los elementos del lenguaje ser tratado en un apartado posterior.
.
Sub...End Sub. Palabras clave que indican el comienzo y final del procedimiento respectivamente.
Cuando hagamos una llamada al procedimiento, el compilador ejecutar el cdigo comprendido entre estas dos
palabras clave.
.
NombreProcedimiento. Identificador que utilizamos para reconocer y llamar al procedimiento.
.
ListaParmetros. Lista de variables separadas por comas, y encerradas entre parntesis, que
representan la informacin que recibe el procedimiento desde el cdigo llamador.
.
Return. Esta palabra clave permite salir de la ejecucin del procedimiento sin haber llegado a su fin.
Podemos utilizarla en tantos lugares dentro de un procedimiento como sea necesario. Se recomienda su uso en lugar de
Exit Sub, ya que podemos emplear Return para salir de cualquier tipo de procedimiento, con lo cual se unifica la
escritura del cdigo.
.
Exit Sub. Al igual que en el punto anterior, esta palabra clave permite salir de la ejecucin del
procedimiento sin haber llegado a su fin, pudiendo igualmente, situarla en tantos lugares dentro del procedimiento
como sea necesario.
El Cdigo fuente 118 muestra el modo ms simple de crear un procedimiento. Escriba el lector este
procedimiento en la aplicacin de consola sobre la que est realizando las pruebas, a continuacin de Main( ).
Sub
Prueba()
Console.WriteLine("Estamos
en
el
procedimiento
End
Prueba")
Sub
Module
Module1
Sub
Console.WriteLine("Estamos
'
en
llamada
el
procedimiento
un
Main()
Main")
procedimiento
Prueba()
Console.ReadLine()
End
Sub
Sub
Console.WriteLine("Estamos
End
en
el
procedimiento
End
Prueba()
Prueba")
Sub
Module
Figura 176. No es posible hacer una llamada a un procedimiento Sub en una expresin.
NombreFuncin[(ListaParmetros)]
As
TipoDato
Valor]
Valor]
Function]
End
Function
Los elementos que forman parte de este tipo de rutina son los siguientes:
.
mbito. Define el modo en que vamos a poder acceder o llamar al procedimiento desde otro punto de
la aplicacin. El mbito de los elementos del lenguaje ser tratado en un apartado posterior.
.
Function...End Function. Palabras clave que indican el comienzo y final de la funcin
respectivamente. Cuando hagamos una llamada a la funcin, el compilador ejecutar el cdigo comprendido entre
estas dos palabras clave.
.
NombreFuncin. Identificador que utilizamos para reconocer y llamar a la funcin. En este tipo de
procedimiento, tambin utilizamos su nombre para asignar el valor que ser devuelto al cdigo llamador en el modo
NombreFuncin = Valor, en esta ltima situacin, podemos situar esta expresin de devolucin en tantos lugares
como necesitemos dentro de la funcin.
.
TipoDato. Tipo de dato del valor devuelto como resultado de la ejecucin de la funcin.
.
ListaParmetros. Lista de variables separadas por comas, y encerradas entre parntesis, que
representan la informacin que recibe la funcin desde el cdigo llamador.
.
Return. Esta palabra clave permite salir de la ejecucin de la funcin devolviendo al mismo tiempo
un valor al cdigo que hizo la llamada. Podemos utilizarla dentro de una funcin, en tantos lugares como necesitemos.
.
Exit Function. Esta palabra clave permite salir de la ejecucin de la funcin sin haber llegado a su
fin. Podemos utilizarla dentro de una funcin, en tantos lugares como necesitemos.
El Cdigo fuente 121 muestra un sencillo ejemplo de procedimiento Function, en el cual se pide al usuario que
introduzca un nmero que es devuelto como resultado de la funcin.
Function
Calcular()
As
Integer
Dim
MiValor
As
Integer
Console.WriteLine("Introducir
un
nmero
de
1
a
100")
MiValor
=
Console.ReadLine()
Return
MiValor
'
tambin
podemos
utilizar
esta
'
sintaxis
para
devolver
el
valor
'
de
retorno
de
la
funcin:
'Calcular
=
MiValor
End
Function
En el caso de devolver el valor de retorno de una funcin utilizando el propio nombre de la funcin, nos
encontramos con el problema de que si en un momento determinado tenemos que cambiar el nombre de la funcin,
tambin deberemos cambiar todos aquellos puntos de la rutina en donde devolvemos el valor. Por este motivo es
recomendable el uso de Return para el devolver el valor de la funcin, ya que si tenemos que cambiar el nombre de la
funcin, no ser necesario modificar los puntos en los que se devuelve el valor de este tipo de procedimiento.
Module
Module1
Sub
Dim
Dim
Resultado
NuevoValor
'
llamada
'
por
Calcular()
a
este
'
llamada
'
de
retorno
Resultado
Console.WriteLine("La
una
a
y
funcin
motivo,
'
llamada
a
NuevoValor
=
Console.WriteLine("La
sin
recoger
dicho
una
asignando
variable
una
1500
variable
Main()
Integer
Integer
As
As
funcin
el
=
Resultado
el
valor
obteniendo
valor
a
contiene:
funcin
como
+
NuevoValor
valor
de
se
el
una
{0}",
retorno,
pierde
valor
variable
Calcular()
Resultado)
parte
de
una
expresin
Calcular()
*
2
contiene:
{0}",
NuevoValor)
Console.ReadLine()
End
Sub
Function
Calcular()
MiValor
Dim
Console.WriteLine("Introducir
MiValor
un
=
As
Integer
Integer
As
nmero
de
a
100")
Console.ReadLine()
Return
'
'
MiValor
tambin
sintaxis
podemos
para
utilizar
devolver
esta
el
valor
'
de
retorno
de
'Calcular
la
funcin:
MiValor
Function
End
End
Module
[Optional]
[ByVal
ByRef]
[ParamArray]
NombreParametro
As
TipoDato
Las reglas y cuestiones sobre paso de parmetros descritas en los siguientes apartados son vlidas tanto para
procedimientos como para funciones, excepto en aquellos lugares donde se indique lo contrario.
Sub
Dim
Nombre
Nombre
As
Main()
String
"Juan"
Prueba(Nombre)
Prueba("Esto
Console.ReadLine()
es
una
prueba")
End
Sub
Sub
Prueba(ByVal
Console.WriteLine("El
valor
ValorMostrar
del
parmetro
As
pasado
es
{0}",
End
String)
ValorMostrar)
Sub
Sub
Dim
Nombre
Main()
String
As
Nombre
'
llamamos
'
"Juan"
le
pasamos
un
una
procedimiento
variable
por
valor
Prueba(Nombre)
'
'
'
la
al
variable
volver
ha
que
aqu
sido
'
Console.WriteLine("Valor
pasada
ha
de
Sub
pasado
sido
por
la
Console.ReadLine()
End
no
hemos
al
cambiada,
valor,
procedimiento,
debido
sigue
conteniendo
cadena
la
variable
dentro
de
que
"Juan"
Main():
{0}",
Nombre)
Sub
Prueba(ByVal
'
'
ValorMostrar
modificamos
este
el
cambio
no
As
valor
afecta
ValorMostrar
String)
del
la
parmetro,
variable
Console.WriteLine("Valor
del
parmetro
dentro
Nombre
"Elena"
de
Prueba():
{0}",
End
ValorMostrar)
Sub
Lo que ocurre en el fuente anterior a nivel de gestin interna en memoria de los parmetros es lo siguiente:
cuando se realiza la llamada al procedimiento y se pasa el parmetro, el entorno detecta que se trata de un parmetro
pasado por valor, por lo que crea una nueva variable en memoria que ser la que manipulemos dentro del
procedimiento. La Figura 177 muestra una representacin grfica de este proceso.
Figura 177. Esquema de gestin interna de variables en el paso por valor.
En el entorno de .NET Framework, por defecto, todos los parmetros son pasados por valor. Esto lo puede
comprobar el lector de un modo muy simple: si al declarar un parmetro no especifica el tipo de paso, el IDE
automticamente situar junto a ese parmetro la palabra clave ByVal.
Se recomienda siempre que sea posible el paso de parmetros por valor, ya que ayuda a generar un cdigo ms
optimizado y contribuye a mejorar la encapsulacin.
Sub
Dim
Nombre
As
Main()
String
Nombre
=
"Juan"
Console.WriteLine("Valor de la variable antes de llamar a Prueba():
{0}",
Nombre)
'
'
y
Prueba(Nombre)
le
llamamos
pasamos
a
una
un
variable
'
el
cambio
realizado
al
parmetro
'
ha
afectado
a
la
variable
Nombre,
'
el
mismo
valor
que
se
asign
Console.WriteLine("Valor
de
la
variable
al
volver
Console.ReadLine()
por
procedimiento
referencia
en
el
procedimiento
que
aqu
contiene
en
el
procedimiento
a
Main():
{0}",
Nombre)
End
Sub
'
Sub
Prueba(ByRef
ValorMostrar
modificamos
el
valor
ValorMostrar
As
String)
del
parmetro
Console.WriteLine("Valor
del
parmetro
dentro
"Elena"
de
Prueba():
{0}",
End
ValorMostrar)
Sub
Lo que ocurre en el fuente anterior a nivel de gestin interna en memoria de los parmetros es lo siguiente:
cuando se realiza la llamada al procedimiento y se pasa el parmetro, el entorno detecta que se trata de un parmetro
pasado por referencia, y tanto la variable del cdigo llamador como la del procedimiento llamado utilizan la misma
direccin de memoria o referencia hacia los datos, por lo que los cambios realizados en un procedimiento afectarn
tambin al otro. La Figura 178 muestra una representacin grfica de este proceso.
Main()
Dim
Localidad
Dim
Importe
Dim
DiaHoy
'
Localidad
Importe
DiaHoy
'
As
As
=
=
de
parmetros
Importe,
=
=
=
Date
--------------------"Sevilla"
15044
#2/10/2002#
Prueba(Localidad,
'
Localidad
Importe
DiaHoy
Integer
As
paso
String
por
posicin
DiaHoy)
--------------------"Madrid"
250
#5/8/2002#
'
paso
de
parmetros
Prueba(Cantidad:=Importe,
por
Fecha:=DiaHoy,
nombre
Ciudad:=Localidad)
Console.ReadLine()
End
Sub
Sub
Prueba(ByVal
Ciudad
As
String,
Console.WriteLine("Valores
Console.WriteLine("Ciudad:
Fecha)
End
ByVal
Cantidad
de
{0}
Cantidad:
As
Integer,
ByVal
Fecha
los
{1}
Fecha:
As
Date)
parmetros")
{2}",
Ciudad,
Cantidad,
Sub
Podemos mezclar ambos tipos de paso en la llamada a un procedimiento, teniendo en cuenta que los parmetros
en los que no utilicemos paso por nombre, deberemos situarlos en su posicin correcta. El Cdigo fuente 128 muestra
un ejemplo con una variacin sobre el ejemplo anterior.
Prueba(Localidad,
Fecha:=DiaHoy,
Cantidad:=Importe)
Parmetros opcionales
Un parmetro opcional es aquel que no es necesario especificar al hacer la llamada a un procedimiento.
Para indicar en la declaracin de un procedimiento que un parmetro es opcional, debemos utilizar la palabra
clave Optional seguida de la especificacin del parmetro, y finalizar con la asignacin de un valor por defecto para el
parmetro. Teniendo en cuenta adems, que a partir del primer parmetro opcional en la lista de un procedimiento,
todos los parmetros sucesivos tambin deben ser opcionales.
En el Cdigo fuente 129 creamos una funcin en la que declaramos un parmetro opcional. Despus hacemos
dos llamadas a dicho procedimiento, pasando y omitiendo el parmetro opcional respectivamente en cada llamada.
Sub
Dim
Dim
Dim
Localidad
Importe
Resultado
Main()
String
Integer
Integer
As
As
As
'
Localidad
Importe
'
paso
de
Resultado
Console.WriteLine("Primera
=
=
todos
=
llamada,
los
parmetros
Calcular(Localidad,
valor
devuelto:
--------------------"Sevilla"
15044
al
{0}",
procedimiento
Importe)
Resultado)
'
Localidad
--------------------"Madrid"
'
paso
slo
del
'
esto
har
que
se
'
del
Resultado
Console.WriteLine("Segunda
llamada,
primer
utilice
parmetro
el
parmetro
al
valor
=
valor
devuelto:
procedimiento,
por
defecto
opcional
Calcular(Localidad)
{0}",
Resultado)
Console.ReadLine()
End
Sub
Function
Calcular(ByVal
5500)
Console.WriteLine("Valores
Console.WriteLine("Ciudad:
Ciudad
As
String,
Optional
As
de
{0}
Return
los
{1}",
Cantidad:
ByVal
Cantidad
As
Integer
Integer
parmetros")
Ciudad,
Cantidad)
Cantidad
100
End
Function
Array de parmetros
Cuando en la lista de parmetros de un procedimiento utilizamos la palabra clave ParamArray junto al nombre
del ltimo parmetro de la lista, dicho parmetro ser considerado un array, por lo que al hacer la llamada al
procedimiento podremos pasarle un nmero variable de valores, que manejaremos a travs del array. El Cdigo fuente
130 muestra un ejemplo.
Sub
Dim
Dim
Dim
Valor
Ciudad
Nombre
Main()
Integer
String
String
As
As
As
Valor
Ciudad
Nombre
7954
"Valencia"
"Jorge"
=
=
'
en
'
todos
'
del
'
en
Prueba(Valor,
la
los
llamada
al
valores
que
primer
parmetro,
el
array
Ciudad,
procedimiento
pasemos
a
sern
de
"mesa",
Prueba()
continuacin
depositados
parmetros
Nombre)
Console.ReadLine()
End
Sub
'
el
parmetro
MasDatos
del
procedimiento
es
un
array
'
Sub
Prueba(ByVal
de
Importe
As
Dim
Integer,
parmetros
ByVal ParamArray
Contador
Console.WriteLine("Elemento:
Contador,
Next
End
As
variables
String)
As
'
mostrar
Console.WriteLine("Parmetro
Console.WriteLine()
el
Importe:
'
el
resto
'
estn
en
el
'
con(una)
Console.WriteLine("Contenido
del
For
Contador
=
MasDatos()
Integer
primer
{0}",
de
array,
parmetros
del
los
obtenemos
estructura
array
de
parmetros
0
To
{0}
parmetro
Importe)
procedimiento
recorriendolo
For...Next
MasDatos():")
UBound(MasDatos)
Valor:
{1}",
_
MasDatos(Contador))
Sub
Con ParamArray tenemos la ventana de que podemos pasar una cantidad variable de parmetros al
procedimiento en cada llamada. La nica restriccin es que debemos utilizarlo como ltimo parmetro de la lista del
procedimiento.
Sobrecarga de procedimientos
Si bien el uso de parmetros opcionales es un medio para ahorrar al programador el paso de los mismos en
situaciones en las que no son necesarios, resulta una solucin un tanto artificiosa, ya que lo que realmente hace es
complicar ms que facilitar la escritura de cdigo.
VB.NET aporta al lenguaje una nueva tcnica que permite obviar el uso de parmetros opcionales por una
solucin ms elegante y flexible: los procedimientos sobrecargados.
Antes de explicar en qu consiste un procedimiento sobrecargado, situmonos en el siguiente escenario:
Necesitamos mostrar los datos de un empleado de dos formas, en funcin del modo de consulta. Por un lado
visualizaramos su nombre, domicilio y localidad; y por otra parte su edad, DNI y fecha de alta en la empresa.
Con lo que sabemos hasta el momento, podramos resolver este problema escribiendo un procedimiento con
parmetros opcionales, y segn pasramos un valor u otro, mostrar la informacin correspondiente.
El Cdigo fuente 131 muestra este modo de resolver el problema. El uso de la estructura If...End If ser
explicado posteriormente en el apartado dedicado a estructuras de control, por lo que aclararemos brevemente al lector
que el uso de esta estructura nos permite ejecutar bloques de cdigo en funcin de que la expresin utilizada a
continuacin de If se evale o no a Verdadero.
Sub
'
mostrar
datos
'
en
funcin
VerDatosEmpleado("Pedro")
del
del
Main()
empleado
nombre
'
'
en
VerDatosEmpleado(,
mostrar
datos
funcin
del
de
empleado
edad
28)
la
Console.ReadLine()
End
Sub
Sub
Integer
VerDatosEmpleado(Optional
ByVal
If
Nombre
Console.WriteLine("Nombre
Console.WriteLine("Domicilio:
Console.WriteLine("Localidad:
Nombre As
=
String
"X",
<>
empleado:
Colina
del
Optional
ByVal
"X"
{0}",
Edad As
999)
Then
Nombre)
Alta,12")
Salamanca")
End
If
If
Edad
Console.WriteLine("Edad
Console.WriteLine("DNI:21555666")
Console.WriteLine("Fecha
de
<>
del
999
empleado:
alta
en
la
{0}",
Then
Edad)
empresa:
10/4/1997")
End
If
Console.WriteLine()
End
Sub
Cdigo fuente 131
El uso de parmetros opcionales, como acabamos de constatar, resulta engorroso, ya que nos obliga a
comprobar qu valor ha sido pasado y mostrar los datos correspondientes en consecuencia. Tenemos adems, un
inconveniente aadido, y es que podemos pasar los dos parmetros a la vez, con lo que se mostraran todos los datos,
cuando lo que queremos es visualizar un grupo u otro en cada llamada.
Una aproximacin diferente al problema sera escribir dos procedimientos distintos, y llamar a uno u otro segn
los datos que necesitemos. Ver Cdigo fuente 132.
Sub
'
mostrar
datos
del
VerEmpleNombre("Pedro")
'
mostrar
VerEmpleNum(28)
empleado
datos
segn
Main()
nombre
del
empleado
Console.ReadLine()
End
Sub
Public
Sub
VerEmpleNombre(ByVal
Nombre
As
Console.WriteLine("Datos
empleado
por
Console.WriteLine("Nombre
del
empleado:
{0}",
String)
nombre")
Nombre)
segn
edad
Console.WriteLine("Domicilio:
Console.WriteLine("Localidad:
Console.WriteLine()
Colina
Alta,12")
Salamanca")
End
Sub
Public
Sub
VerEmpleNum(ByVal
Edad
As
Console.WriteLine("Datos
empleado
por
Console.WriteLine("Edad
del
empleado:
{0}",
Integer)
edad")
Edad)
Console.WriteLine("DNI:21555666")
Console.WriteLine("Fecha
de
alta
en
la
empresa:
10/4/1997")
Console.WriteLine()
End
Sub
Cdigo fuente 132.
Sin embargo, esta solucin nos obliga a tener que saber varios nombres de procedimiento, con lo que tampoco
ayuda mucho a simplificar el cdigo.
No sera ideal, disponer de un nico nombre de procedimiento y que este fuera lo suficientemente inteligente
para mostrar los datos adecuados en cada caso?, pues esta caracterstica est implementada en VB.NET a travs de la
sobrecarga de procedimientos.
La sobrecarga de procedimientos es una tcnica que consiste en crear varias versiones de un mismo
procedimiento, distinguindose entre s por la lista de parmetros o protocolo de llamada del procedimiento.
Para definir un procedimiento como sobrecargado, debemos comenzar su declaracin con la palabra clave
Overloads. Podemos utilizar procedimientos tanto Sub como Function cuando realizamos sobrecarga., siendo posible
que una de las implementaciones no tenga lista de parmetros. El Cdigo fuente 133 muestra un ejemplo de
sobrecarga.
Overloads
'
Sub
cdigo
Datos()
del
procedimiento
'
'
End
............
............
Sub
Overloads
'
Sub
cdigo
Datos(ListaParametrosA)
del
procedimiento
'
'
End
Overloads
'
............
............
Sub
Function
cdigo
'
Datos(ListaParametrosB)
del
As
TipoDatoRetorno
procedimiento
............
'
End
............
Function
En el ejemplo anterior, cuando llamemos al procedimiento Datos( ), el entorno de .NET Framework, en funcin
de si pasamos o no parmetros al procedimiento, y de cmo sean estos parmetros, ejecutar la versin adecuada del
procedimiento.
Ya que el protocolo o firma del procedimiento es el elemento que emplea el CLR para diferenciar cada una de
sus versiones o implementaciones, las listas de parmetros de cada versin deben ser diferentes al menos en uno de los
siguientes aspectos:
. Nmero de parmetros.
. Orden de los parmetros.
. Tipo de dato de los parmetros.
Por consiguiente, no es posible crear dos procedimientos sobrecargados que slo se diferencien en los nombres
de los parmetros, por los modificadores de mbito (Public, Private, etc.), o por el tipo de dato de retorno en el caso de
un procedimiento Function.
Una vez vistas las normas y restricciones aplicables a los procedimientos sobrecargados, veamos en el Cdigo
fuente 134 como solucionaramos el problema planteado al comienzo de este apartado empleando esta tcnica.
Sub
Dim
Dias
'
mostrar
datos
VerEmpleado("Pedro")
'
mostrar
Dias
Console.WriteLine("Das
Console.WriteLine()
'
mostrar
VerEmpleado(25,
del
As
empleado
segn
datos
Main()
Integer
nombre
del
empleado
del
empleado:
segn
edad
VerEmpleado(28)
{0}",
Dias)
=
libres
salario
pasando
las
horas
trabajadas
80)
Console.ReadLine()
End
Sub
Overloads
Sub
VerEmpleado(ByVal
Nombre
As
String)
Console.WriteLine("Datos
empleado
por
nombre")
Console.WriteLine("Nombre
del
empleado:
{0}",
Nombre)
Console.WriteLine("Domicilio:
Colina
Alta,12")
Console.WriteLine("Localidad:
Salamanca")
Console.WriteLine()
End
Sub
Integer)
por
{0}",
As
Integer
Integer
edad")
Edad)
Console.WriteLine("DNI:21555666")
Console.WriteLine("Fecha
de
alta
Console.WriteLine()
en
la
DiasLibres
Return
End
ByVal
Long)
Dim
empresa:
10/4/1997")
5
DiasLibres
Function
Salario
=
Console.WriteLine("Salario
Console.WriteLine()
As
PrecioHora
segn
Long
*
horas:
{0}",
HorasTrabajadas
Salario)
End
Sub
En este cdigo hemos creado tres versiones sobrecargadas del procedimiento VerEmpleado( ). En una
mostramos los datos del empleado segn el nombre; en otra tambin mostramos otro conjunto de datos segn la edad y
adems, al ser una funcin, devolvemos el nmero de das libres del empleado; finalmente en una tercera
implementacin, calculamos el salario segn el precio por hora y las horas trabajadas, que pasamos al protocolo de
llamada. Desde Main( ) por lo tanto, siempre llamamos al procedimiento VerEmpleado( ).
El motivo de usar el trmino mtodo en lugar de procedimiento para esta lista, se debe a que como veremos en
el tema sobre objetos, todo lo que haremos habitualmente en nuestra labor de programacin, ser crear clases, objetos,
mtodos, propiedades, etc. Por ello la terminologa empleada en general se aproxima ms a las tcnicas de
programacin con objetos que a la programacin estructurada.
Bifurcacin
mbito
del
cdigo
Estructuras de control
Las estructuras de control contienen bloques de cdigo que sern ejecutados en funcin del resultado obtenido al
evaluar una expresin asociada a la estructura. A este proceso de redireccin del flujo del programa hacia un
determinado bloque de cdigo se le denomina bifurcacin
Segn el modo de ejecucin del cdigo que contienen, las estructuras de control se dividen en los siguientes
tipos: seleccin y repeticin.
Seleccin
Las estructuras de seleccin o decisin permiten ejecutar un bloque de cdigo entre varios disponibles, segn el
resultado de la evaluacin de una expresin situada en la cabecera de la estructura.
If...End If
La sintaxis de esta estructura puede aplicarse de diferentes formas en funcin del tipo de decisin a resolver.
Decisin simple.
La sintaxis de decisin simple se muestra en el Cdigo fuente 135.
If
Expresin
Then
cdigo
......
......
'
'
'
End
If
Si al evaluar Expresin se devuelve como resultado Verdadero, se ejecutarn las lneas o bloque de cdigo
comprendido entre If y End If. Si Expresin es Falso, se desviar la ejecucin a la primera lnea de cdigo que haya
despus de End If. Veamos un ejemplo en el Cdigo fuente 136.
Sub
Dim
Valor
As
Main()
Integer
Console.WriteLine("Introducir
Valor
un
=
nmero")
Console.ReadLine()
If
Valor
=
Console.WriteLine("Estamos
dentro
de
la
"
ya
que
su
expresin
End
5
estructura
devuelve
Then
If,"
&
_
Verdadero")
If
Console.ReadLine()
End
Sub
Cdigo fuente 136
If
Expresin
Then
Instruccin
Sub
Dim
Dim
Valor
Resultado
As
As
Main()
Integer
Integer
Console.WriteLine("Introducir
Valor
un
nmero")
Console.ReadLine()
If
Valor
Console.WriteLine("La
Console.ReadLine()
End
variable
Then
Resultado
resultado
contiene
Valor
10
{0}",
Resultado)
Sub
Como habr comprobado el lector, la sentencia que hay a continuacin de Then slo se ejecutar cuando la
variable Valor contenga 5.
Decisin doble.
Adems de ejecutar un bloque de cdigo cuando la expresin valga Verdadero, podemos tambin ejecutar
cdigo cuando la expresin devuelva Falso. En este caso aadiremos a la estructura la palabra clave Else, como
muestra la sintaxis del Cdigo fuente 139.
'
If
cdigo
cuando
Expresin
Expresin
es
Else
cdigo
cuando
Expresin
es
Then
Verdadero
......
......
'
'
'
Falso
......
......
'
'
End
If
Sub
Dim
Dim
Valor
Resultado
As
As
Main()
Integer
Integer
Console.WriteLine("Introducir
Valor
un
nmero")
Console.ReadLine()
If
Resultado
Else
Resultado
End
Valor
=
=
Valor
Then
10
777
If
En este ejemplo, cuando Valor contenga 5 se ejecutar el bloque de cdigo que hay a continuacin de If, pero
cuando Valor contenga un nmero distinto, se ejecutar el cdigo que hay a continuacin de Else. La ejecucin en
cualquier caso, continuar despus a partir de la siguiente lnea que haya a partir de la palabra clave End If.
Decisin doble en una lnea.
Al igual que ocurre con la decisin simple, si para cada resultado de la expresin, slo necesitamos ejecutar una
instruccin, podemos escribir todo el cdigo en una sola lnea. Veamos la sintaxis en el Cdigo fuente 141.
If
Expresin
Then
InstruccinVerdadero
Else
InstruccinFalso
Sub
Dim
Dim
Valor
Resultado
Main()
Integer
Integer
As
As
Console.WriteLine("Introducir
un
Valor
nmero")
Console.ReadLine()
If
Valor
Then
Resultado
Valor
10
Else
Resultado
777
Si bien la ejecucin de la estructura If en una lnea puede ser til en ocasiones, tiene como contrapartida el que
nuestro cdigo se vuelva ms difcil de leer. Por ello es ms recomendable el uso de esta estructura de control en su
formato If...End If.
Decisin mltiple.
En el caso de que la expresin principal a evaluar devuelva Faso, podemos agregar expresiones adicionales
utilizando la palabra clave ElseIf, con su bloque de cdigo respectivo. En el caso de que ninguna de ellas se cumplan,
podemos incluir un Else, para ejecutar un bloque de cdigo por defecto. Veamos la sintaxis en el Cdigo fuente 143.
'
If
cdigo
cuando
ExpresinA
ExpresinA
es
Then
Verdadero
.......
ElseIf
cdigo
cuando
ExpresinB
ExpresinB
es
Then
Verdadero
.......
[ElseIf
cdigo
cuando
ExpresinN
ExpresinN
es
Then]
Verdadero
.......
'
'
'
'
'
[Else]
cdigo
'
'
End
cuando
ninguna
epxresin
devuelve
Verdadero
.......
If
Sub
Dim
Dim
Valor
Resultado
Main()
Integer
Integer
As
As
Console.WriteLine("Introducir
Valor
un
nmero")
Console.ReadLine()
If
Resultado
Valor
=
ElseIf
Resultado
Valor
=
ElseIf
Resultado
Valor
Else
Resultado
=
Valor
5
+
Then
10
>
Valor
100
+
Then
200
Then
-8
<
=
End
777
If
En esta situacin, si la primera expresin es Verdadero, se ejecutar el cdigo situado a partir de If. Sin
embargo, si If devuelve Falso, se comprobarn sucesivamente las expresiones de cada uno de los ElseIf existentes. En
el caso de algn ElseIf devuelva Verdadero, se ejecutar el cdigo que haya a partir del mismo. Si ninguna de las
anteriores situaciones se cumple, se ejecutar el cdigo que haya a partir de Else en el caso de que este se haya
definido.
Select
Case
Expresin
Case
'
'
cdigo
si
se
cumple
ListaExpresionesA
ListaExpresionesA
.....
cdigo
si
se
cumple
ListaExpresionesB]
ListaExpresionesB
.....
[Case
'
'
[Case
'
Else]
cdigo
si
no
se
cumple
ninguna
'
End
ListaExpresiones
.....
Select
La lista de expresiones asociada a cada Case en esta estructura estar separada por comas y podr tener alguno
de los siguientes formatos:
. Expresin.
. ExpresinMenor To ExpresinMayor
. Is OperadorComparacin Expresin
Tras evaluar la expresin de la estructura, si se encuentra una coincidencia con alguno de los Case, se ejecuta el
bloque de cdigo situado entre dicho Case y el siguiente. En caso de que no haya ninguna coincidencia, podemos
opcionalmente, ejecutar un bloque por defecto, utilizando la palabra clave Case Else. Finalizada esta estructura, la
ejecucin continuar a partir de la lnea situada despus de End Select.
Veamos a continuacin, en el Cdigo fuente 146 un ejemplo de uso de esta estructura.
Sub
Dim
Valor
Main()
Integer
As
Console.WriteLine("Introducir
un
Valor
Select
Case
Console.WriteLine("El
Case
valor
Case
Console.WriteLine("El
Case
Console.WriteLine("El
Case
Console.WriteLine("El
nmero")
Console.ReadLine()
es
120,
es
valor
valor
3000
est
Is
valor
Valor
5
5")
en
To
rango
el
es
120
de
250
250")
3000
<
menor
4000
4000")
de
10
10")
Case
Console.WriteLine("El
valor
es
{0},
no
se
cumple
ningn
caso",
End
Else
Valor)
Select
Console.ReadLine()
End
Sub
Cdigo fuente 146
En el caso de que tras evaluar la expresin, haya ms de un Case cuya lista de expresiones se cumpla, se
ejecutar el que est situado en primer lugar. En el ejemplo anterior, cuando la variable Valor contiene 5, se cumplen
dos casos. Ver Cdigo fuente 147.
Case
Console.WriteLine("El
valor
es
5")
.....
.....
'
'
Case
Console.WriteLine("El
Is
valor
<
menor
es
10
10")
de
Case
12
To
15,
4,
7,
Is
>
20
Repeticin
Estas estructuras, tambin denominadas bucles, ejecutan un bloque de cdigo de forma repetitiva mientras se
cumpla una condicin asociada a la estructura. A cada una de las veces en que se ejecuta el cdigo contenido en estas
estructuras se le denomina iteracin.
While...End While
Se trata del tipo ms sencillo, ejecuta las lneas de cdigo que contiene, mientras que la expresin situada junto
a While devuelva Verdadero. Veamos su sintaxis en el Cdigo fuente 149.
While
'
'
Expresin
cdigo
.....
End
While
Sub
Dim
Dim
Valor
Contador
Main()
Integer
Integer
As
As
Console.WriteLine("Introducir
un
Valor
nmero")
Console.ReadLine()
Console.WriteLine("Mostrar
introducido")
While
Console.Write("-"
Contador
en
consola
todos
Contador
los
nmeros
<
&
+=
End
desde
hasta
el
Valor
Contador)
1
While
Console.ReadLine()
End
Sub
Cdigo fuente 150
Do...Loop
Esta estructura ejecuta un conjunto de lneas de cdigo, en funcin del valor devuelto por una expresin, que a
modo de condicin, podemos situar al comienzo o final de la estructura.
Es posible adems, no utilizar la expresin de evaluacin al principio o final, debiendo en ese caso, introducir
alguna condicin en el interior del cdigo de la estructura, para forzar la salida del bucle y evitar caer en un bucle
infinito. La instruccin Exit Do nos permite forzar la salida del bucle, pudiendo emplearla tantas veces como sea
necesario.
Veamos a continuacin, las diferentes variantes disponibles.
Condicin al principio.
La sintaxis se muestra en el Cdigo fuente 151.
Do
'
'
[Exit
'
'
While
Until
Expresin
cdigo
......
Do]
cdigo
......
Loop
La diferencia entre usar While o Until reside en que empleando While, el cdigo del bucle se ejecutar mientras
la expresin devuelva Verdadero. En el caso de Until, el cdigo se ejecutar mientras que la expresin devuelva Falso.
Veamos los ejemplos del Cdigo fuente 152.
Sub
Dim
Dim
Dim
Dim
Valor
Palabra
Contador
Pruebas
As
As
As
As
'
Main()
Integer
String
Integer
Integer
bucle
con
Do
While
Console.WriteLine("Introducir
Valor
While
Valor
<>
un
200
nmero")
Console.ReadLine()
Loop
'
bucle
Do
Until
Console.WriteLine("Introducir
con
Palabra
Until
"coche"
palabra")
=
una
Palabra
Console.ReadLine()
Loop
'
'
'
'
'
'
Contador
Do
en
al
pero
no
este
usuario
si
consigue
de
While
Console.WriteLine("Introducir
Pruebas
If
Exit
Else
Contador
End
Loop
End
caso
un
=
inicializar
vamos
a
que
introduzca
despus
de
acertar,
forzamos
la
=
Pruebas
nmero
Contador
=
+=
Intento
contador,
tambin
nmero,
intentos,
salida
estructura
1
200
pedir
un
cinco
la
<>
nro.{0}",
Contador)
Console.ReadLine()
Then
Do
1
If
Sub
En el ltimo caso de este ejemplo, podemos observar como empleamos adems, la anidacin de diferentes
estructuras, combinndolas para realizar las comprobaciones oportunas.
Condicin al final.
La diferencia en este caso, consiste en que el contenido de la estructura se ejecuta al menos una vez. El Cdigo
fuente 153 muestra su sintaxis.
Do
'
'
[Exit
'
'
cdigo
......
Do]
cdigo
......
Loop
While
Until
Expresin
Sub
Dim
Dim
Valor
Palabra
Main()
Integer
String
As
As
'
bucle
con
Do
Console.WriteLine("Introducir
Valor
Loop
un
nmero")
Console.ReadLine()
While
'
bucle
Do
Console.WriteLine("Introducir
Palabra
Loop
While
Valor
con
Until
una
palabra")
=
Palabra
Until
End
<>
200
Console.ReadLine()
"coche"
Sub
Sin condicin.
Este es el modo ms sencillo de la estructura: sin incluir condicin al principio o final. Tambin es el modo ms
peligroso, ya que si no incluimos un control dentro del cdigo, corremos el riesgo de caer en un bucle infinito. En el
ejemplo del Cdigo fuente 155, establecemos una condicin de salida mediante una estructura If dentro del bucle, que
comprueba el contenido de la variable, y fuerza la salida cuando tenga un valor superior a cierto nmero.
Sub
Dim
Valor
As
Main()
Integer
Do
Console.WriteLine("Introducir
Valor
'
comprobar
y
Valor
If
Exit
End
Loop
un
nmero")
Console.ReadLine()
salir
del
>
bucle
si
400
es
necesario
Then
Do
If
End
Sub
For...Next
Esta estructura ejecuta un bloque de cdigo un nmero determinado de veces, establecido por un rango de
valores y controlado por un contador. El Cdigo fuente 156 muestra su sintaxis
For
Contador
Inicio
To
Fin
'
'
[Step
Incremento]
cdigo
......
[Exit
For]
cdigo
......
'
'
Next
El elemento Contador se inicializa con un valor y el cdigo existente entre For y Next es ejecutado una serie de
veces, hasta que el valor de Contador se iguala a Fin.
Por defecto, los incrementos de Contador son en uno, pero podemos cambiar este aspecto utilizando el
modificador Step, mediante el que podemos establecer el nmero en el que se van a realizar los incrementos. Step
tambin nos permite realizar decremento utilizando un nmero negativo.
Si queremos realizar una salida de la ejecucin de esta estructura antes de haber completado el nmero de
iteraciones establecidas, podemos utilizar la instruccin Exit For, que provocar dicha salida de igual modo que el
explicado anteriormente en la estructura Do...Loop.
El Cdigo fuente 157 muestra diferentes ejemplos de uso de este tipo de bucle.
Sub
Dim
Dim
Contador
Final
As
As
'
recorrido
Console.WriteLine("Bucle
Main()
Integer
Integer
simple
For
del
bucle
normal")
For
Contador
Console.WriteLine("Variable
To
Contador:
10
{0}",
Contador)
Next
Console.WriteLine()
'
recorrer
Console.WriteLine("Bucle
Console.WriteLine("Introducir
Final
For
Contador
el
el
=
bucle
For
nmero
=
1
Console.WriteLine("Variable
especificando
con
de
ejecuciones
To
un
incremento
incremento")
para
el
bucle")
Console.ReadLine()
Step
4
Final
Contador:
{0}",
Contador)
Next
Console.WriteLine()
'
recorrer
Console.WriteLine("Bucle
For
Contador
el
bucle
For
18
Console.WriteLine("Variable
especificando
con
To
4
Contador:
un
decremento
decremento")
Step
-1
{0}",
Contador)
Next
Console.WriteLine()
'
'
'
'
For
al
que
este
bucle
ser
mayor
el
valor
establecido
Contador
=
Console.WriteLine("Variable
no
el
final,
se
valor
de
y
un
18
no
To
Contador:
{0}",
ejecutar,
contador
haber
decremento
4
Contador)
Next
'
recorrer
el
'
todas
Console.WriteLine("Bucle
For
For
Contador
Console.WriteLine("Variable
If
Contador
Exit
End
Next
bucle
salir
las
salida
1
con
=
antes
antes
Contador:
{0}",
de
de
To
completar
iteraciones
completar")
10
Contador)
Then
For
If
Console.ReadLine()
End
Sub
Cdigo fuente 157
Un truco para optimizar y acelerar la ejecucin en un bucle de este tipo, consiste en utilizar como contador una
variable de tipo Integer, en vez de una de tipo Short, Long, Decimal, etc. Esto es debido a que los tipos Integer se
actualizan ms rpidamente que los otros tipos numricos, aunque la diferencia slo ser apreciable en bucles que
ejecuten muchos miles de iteraciones y que contengan muchas instrucciones. Ver Cdigo fuente 158.
Dim
ContRapido
As
ContLento
As
'
este
Dim
For
'
Next
bucle
se
ContRapido
For
Integer
Decimal
ejecutar
=
ContLento
ms
rpido
1
que
To
el
siguiente
10000
cdigo
To
10000
cdigo
'
Next
Cdigo fuente 158
For Each...Next
Se trata de una variante de la estructura For...Next, y su misin consiste en ejecutar un bloque de cdigo por
cada uno de los elementos existentes en un array o coleccin. El Cdigo fuente 159 muestra su sintaxis.
For
Each
Elemento
In
'
'
ColecArray
cdigo
......
[Exit
For]
cdigo
......
'
'
Next
El Cdigo fuente 160 muestra un ejemplo del uso de esta estructura de control.
Sub
'
Dim
Dim
'
For
crear
lsColores()
'
del
en
array
un
As
array
String
=
lsColor
cada
lsColores,
Each
y
{"Azul",
iteracin
y
se
lsColor
rellenarlo
"Verde",
As
se
guarda
con
"Marino",
Main()
valores
"Violeta"}
String
obtiene
en
la
In
un
variable
elemento
lsColor
lsColores
Console.WriteLine(lsColor)
Next
End
Sub
permite una gran flexibilidad para ordenar el cdigo de nuestro proyecto, que debemos organizar en contenedores
fsicos y lgicos de cdigo.
Un contenedor fsico no es otra cosa que un fichero con extensin .VB; estos ficheros son los que la plataforma
reconoce como ficheros con cdigo VB.NET. Podemos tener uno o varios dentro de un proyecto.
Un contenedor lgico, dicho del modo ms simple, es aquel elemento en el entorno de .NET que nos permite
escribir en su interior declaraciones y procedimientos, que sern accesibles desde otros elementos dentro del proyecto
o ensamblado actual, o bien desde otros ensamblados, en funcin de su mbito o accesibilidad.
El CLR dispone de varios tipos de contenedores lgicos, entre los que se encuentran los mdulos, clases,
interfaces, estructuras, etc. Los espacios de nombres (namespaces) son un tipo de contenedor lgico especial, cuya
misin consiste en albergar al resto de contenedores lgicos; una especie de metacontenedor. La estructura bsica de
un contenedor lgico se muestra en la Figura 180.
La configuracin por defecto en este sentido para VS.NET, establece que cada vez que aadimos un nuevo
mdulo o clase a un proyecto, se crea un nuevo fichero con extensin .VB, que contiene el mencionado mdulo o
clase. El nombre utilizado es el mismo para el fichero y el mdulo o clase. Sin embargo, podemos incluir varios
contenedores lgicos, de igual o distinto tipo, dentro del mismo fichero de cdigo. Ver Figura 181.
Figura 181. Esquema de organizacin del cdigo en un proyecto VB.NET.
En este apartado describiremos las operaciones bsicas a realizar, para aadir nuevos mdulos de cdigo a un
proyecto, quitarlos, y agregar otros ya existentes. Lo comentado aqu ser igualmente vlido a la hora de manejar
clases en el tema dedicado a OOP.
Al pulsar Abrir, se crear un nuevo fichero con el nombre indicado en la caja de dilogo y la extensin .VB, que
contendr un mdulo tambin del mismo nombre, dentro del cual podemos empezar a escribir cdigo. Ver Figura 183.
Module
NombreModulo
'
cdigo
'
......
Module
End
Cdigo fuente 161
Debemos tener en cuenta que no es posible anidar mdulos, es decir, no podemos declarar un mdulo dentro de
la declaracin de un mdulo ya existente. Ver Cdigo fuente 162.
'
Module
esto
no
es
vlido
producir
NombreModulo
un
error
Module
End
End
NombreNuevo
Module
Module
Veamos a continuacin un ejemplo. En el apartado anterior, hemos creado un nuevo mdulo con el nombre
Module2, crendose al mismo tiempo, un nuevo fichero de cdigo con el nombre Module2.VB. Pues bien, para aadir
otro mdulo ms dentro de este fichero de cdigo, al que daremos el nombre Cuentas, tan slo hemos de poner la
declaracin del nuevo mdulo antes o despus del existente. Ver Cdigo fuente 163.
Cdigo fuente 163
Con este ejemplo intentamos demostrar que los mdulos de cdigo son totalmente independientes del fichero
fsico que los alberga; por tal razn, varios mdulos pueden escribirse dentro del mismo fichero.
Por ejemplo, he utilizado el Bloc de notas para escribir un mdulo que contiene un procedimiento, y lo he
guardado en un fichero con el nombre MiCodigo.VB. Al utilizar la opcin antes mencionada, se abrir una caja de
dilogo, con la que navegar por las carpetas del equipo para localizar el fichero; al pulsar el botn Abrir, se aadir
dicho fichero al proyecto. Ver Figura 185.
El motivo de usar el trmino clase en lugar de mdulo para esta lista, se debe, como ya explicamos
anteriormente en el apartado sobre la lista Nombre de mtodo, a que como veremos en el tema sobre objetos, todo lo
que haremos habitualmente en nuestra labor de programacin, ser crear clases, objetos, mtodos, propiedades, etc.
Por ello la terminologa empleada en general se aproxima ms a las tcnicas de programacin con objetos que a la
programacin estructurada.
Para eliminar fsicamente el fichero de cdigo, debemos realizar la misma operacin descrita antes, pero
seleccionando en este caso en el men contextual, la opcin Eliminar.
Reglas de mbito
El mbito o accesibilidad de un elemento declarado en el cdigo, consiste en la capacidad que tenemos para
utilizar dicho elemento desde otro punto cualquiera del cdigo, ya sea desde el interior del propio ensamblado o desde
un ensamblado externo.
Las reglas de mbito se aplican por un lado a procedimientos y variables, visto el lenguaje desde el prisma de la
programacin estructurada; y por otro lado, estas normas tambin se aplican a mtodos y propiedades, visto el
lenguaje desde el punto de vista de la programacin orientada a objetos.
En este tema realizaremos una revisin de las cuestiones de mbito aplicadas a procedimientos y variables,
dejando el mbito de mtodos y propiedades para el tema sobre OOP.
mbito de procedimientos
El mbito de procedimientos consiste en la capacidad de poder llamar a un procedimiento desde un punto dado
del cdigo, en funcin del nivel de acceso definido para dicho procedimiento en el momento de su declaracin.
Para especificar el mbito de un procedimiento, lo haremos mediante una palabra clave o modificador de
mbito, anteponindolo al tipo de procedimiento (Sub o Function) dentro de la declaracin. El Cdigo fuente 164
muestra la sintaxis a utilizar.
Modificadormbito
Sub
Function
NombreProcedimiento([ListaParmetros])
Pblico
Un procedimiento con mbito pblico puede ser llamado desde cualquier punto del mdulo en el que se ha
declarado, o desde cualquier otro mdulo del proyecto. La palabra clave utilizada como modificador de mbito en este
caso es Public.
En el Cdigo fuente 165 tenemos dos mdulos: General y Calculos, que contienen respectivamente los
procedimientos Main( ) y Totales( ). Desde Main( ) podemos perfectamente llamar al procedimiento Totales( ), ya que
al haber sido declarado como Public, es accesible desde otro mdulo.
Module
General
Public
Console.WriteLine("Estamos
'
llamar
Totales(400)
Console.ReadLine()
End
al
en
el
procedimiento
Sub
mdulo
General,
Totales()
que
procedimiento
est
en
Main()
Main")
otro
mdulo
Sub
End
Module
Module
Calculos
Public
Sub
Totales(ByVal
Importe
Dim
Resultado
As
Console.WriteLine("Estamos
en
el
mdulo
Calculos,
Resultado
=
Importe
Console.WriteLine("El
total
obtenido
es:
As
procedimiento
+
{0}",
Integer)
Integer
Totales")
1000
Resultado)
End
Sub
End
Module
Public es el modificador de mbito por defecto para procedimientos, lo que quiere decir que si no lo utilizamos,
al crear un procedimiento, su mbito ser pblico por defecto.
Es posible escribir varios procedimientos con el mismo nombre y mbito pblico en distintos mdulos. Cuando
esto ocurra, al llamar al procedimiento se ejecutar por defecto el que ms prximo est desde el mdulo que ha sido
llamado. En el caso de que necesitemos ejecutar el procedimiento que se encuentre en otro mdulo deberemos hacer la
llamada escribiendo el nombre del mdulo, un punto, y el nombre del procedimiento. Veamos un ejemplo en el
Cdigo fuente 166.
Module
Public
'
en
esta
'
que
Totales(400)
'
en
esta
'
en
primer
'
que
Calculos.Totales(280)
General
llamada,
est
llamada,
lugar,
est
Sub
ejecutar
se
en
como
se
en
el
este
especificamos
ejecuta
el
el
el
procedimiento
mismo
Main()
Totales()
mdulo
nombre
del
procedimiento
mdulo
mdulo
Totales()
Calculos
Console.ReadLine()
End
Sub
Public
Sub
Totales(ByVal
Importe
As
Integer)
'
en
esta
versin
del
procedimiento,
'
multiplicamos
el
parmetro
por
un
valor
Dim
Resultado
As
Integer
Console.WriteLine("Estamos
en
el
mdulo
General,
procedimiento
Totales")
Resultado
=
Importe
*
4
Console.WriteLine("El
total
obtenido
es:
{0}",
Resultado)
End
Sub
End
Module
Module
Calculos
Public
Sub
Totales(ByVal
Importe
As
Integer)
'
en
esta
versin
del
procedimiento,
'
sumamos
un
valor
al
parmetro
Dim
Resultado
As
Integer
Console.WriteLine("Estamos
en
el
mdulo
Calculos,
procedimiento
Totales")
Resultado
Console.WriteLine("El
End
=
total
Importe
obtenido
+
{0}",
es:
1000
Resultado)
Sub
End
Module
Privado
Un procedimiento con mbito privado slo puede ser llamado desde el propio mdulo en el que se ha declarado.
La palabra clave utilizada como modificador de mbito en este caso es Private. Veamos un ejemplo en el Cdigo
fuente 167.
Module
General
Public
'
podemos
'
ya
Totales(400)
Sub
el
tiene
ejecutar
que
Dim
MiNumero
'
'
'
por
MiNumero
error,
la
dentro
lo
que
funcin
no
Main()
Totales()
pblico
procedimiento
mbito
As
ObtenerNumero
del
es
accesible
=
Integer
tiene
mdulo
desde
mbito
privado,
Calculos,
este
mdulo
ObtenerNumero()
Console.ReadLine()
End
Sub
End
Module
Module
Calculos
Public
Sub
Totales(ByVal
Dim
Resultado
Console.WriteLine("Estamos
en
el
mdulo
'
'
podemos
ya
llamar
que
desde
estamos
Importe
As
Calculos,
aqu
a
en
la
el
As
procedimiento
funcin
mismo
Integer)
Integer
Totales")
ObtenerNumero
mdulo
Resultado
Console.WriteLine("El
=
total
Importe
obtenido
+
es:
{0}",
End
ObtenerNumero()
Resultado)
Sub
Private
Function
ObtenerNumero()
Console.WriteLine("Estamos
en
el
mdulo
"
procedimiento
Return
End
As
Integer
Calculos,"
&
_
ObtenerNumero")
18
Function
End
Module
En el anterior fuente, desde Main( ) no podemos llamar a la funcin ObtenerNumero( ), ya que dicha funcin
tiene mbito Private y reside en un mdulo distinto.
Sin embargo, s podemos llamarla desde el procedimiento Totales( ), ya que en ese caso, la llamada se realiza
dentro del mismo mdulo de cdigo.
mbito de variables
El mbito de variables consiste en la capacidad de acceso que tenemos hacia una variable, de forma que
podamos obtener su valor, as como asignarlo. Para determinar su nivel de accesibilidad, aqu intervienen, adems de
los modificadores de mbito, el lugar o nivel de emplazamiento de la variable dentro del cdigo.
Respecto a los modificadores de mbito, disponemos de las mismas palabras clave que para los procedimientos:
Public y Private, y su sintaxis de uso la vemos en el Cdigo fuente 168.
Modificadormbito
[Dim]
NombreVariable
As
TipoDato
En funcin del punto de cdigo en el que sea declarada una variable, podremos omitir el uso de la palabra clave
Dim para realizar dicha declaracin.
A continuacin se describen los diferentes tipos de mbito para variables, en funcin de su lugar de declaracin.
Public
Sub
Main()
'
'
Dim
declaramos
una
a
nivel
Nombre
variable
de
que
este
As
tiene
mbito
procedimiento
String
Nombre
Console.WriteLine("Introducir
Nombre
&=
"
End
"Hola"
un
"
valor")
Console.ReadLine()
Sub
&
Public
Sub
Manipular()
'
si
intentamos
desde
este
procedimiento
'
acceder
a
la
variable
Nombre
del
'
procedimiento
Main(),
se
produce
un
error
Nombre
=
"nuevo
valor"
End
Sub
En el ejemplo anterior, la variable Nombre puede ser manipulada dentro del procedimiento Main( ), y cualquier
intento de acceder a ella desde otro procedimiento provocar un error.
Public
'
variables
Dim
Dim
con
mbito
MiNumero
Total
Sub
a
nivel
As
As
Console.WriteLine("Introducir
MiNumero
If
MiNumero
'
variable
con
un
'
slo
es
accesible
Dim
Calculo
Console.WriteLine("Introducir
Calculo
de
Main()
procedimiento
Integer
Integer
un
nmero")
Console.ReadLine()
>
mbito
dentro
As
nmero
otro
=
MiNumero
0
nivel
esta
a
de
Then
bloque
If
Integer
para
sumar")
Console.ReadLine()
de
estructura
+=
Calculo
If
End
Console.WriteLine("El
'
error,
la
Total
variable
=
Console.ReadLine()
resultado
Calculo
150
total
no
es:
es
{0}",
accesible
+
MiNumero)
desde
aqu
Calculo
End
Sub
Cdigo fuente 170
En este punto debemos aclarar que el mbito dentro de un bloque se entiende como la parte de la estructura en la
que ha sido declarada la variable. Por ejemplo, en una estructura If...End If con Else, si declaramos una variable a
continuacin de If, dicha variable no ser accesible desde el bloque de cdigo que hay a partir de Else. Ver Cdigo
fuente 171.
If
'
variable
'
slo
es
Dim
'
'
'
MiNumero
con
un
accesible
Calculo
Else
la
variable
Calculo
>
mbito
dentro
no
a
de
es
0
Then
nivel
de
bloque
esta
estructura
If
As
Integer
......
accesible
desde
aqu
......
End
If
Module
'Dim
Private
General
Nombre
Nombre
As
String
As
<---
String
'
esta
declaracin
...pero
Public
se
es
recomienda
perfectamente
declarar
Sub
Nombre
Private
Main()
Console.WriteLine("Procedimiento
Console.WriteLine("Asignar
con
vlida...
Main()")
valor
=
la
variable")
Console.ReadLine()
Console.WriteLine("El
valor
de
la
variable
en
Main()
es:
{0}",
Nombre)
Manipular()
MostrarValor()
Console.ReadLine()
End
Sub
Public
Console.WriteLine("Procedimiento
Console.WriteLine("Asignar
Nombre
Console.WriteLine("El
Sub
valor
=
valor
de
la
variable
en
Manipular()
Manipular()")
variable")
Console.ReadLine()
la
Manipular()
es:
{0}",
End
End
Module
Module
Calculos
Public
'
'
Nombre)
Sub
Sub
error,
a
no
la
'
se
variable
en
MostrarValor()
puede
acceder
Nombre,
que
el
desde
est
de
Private
General
Console.WriteLine("Valor
mdulo
MostrarValor()")
Nombre
End
declarada
mdulo
Console.WriteLine("Procedimiento
End
este
la
"Antonio"
variable
Nombre:
{0}",
Nombre)
Sub
Module
Para comprobar el valor de estas variables a travs del depurador, tenemos que utilizar la ventana Automtico,
que podemos abrir con el men Depurar + Ventanas + Automtico, o las teclas [CTRL + ALT + V, A]. Ver Figura
188.
Module
'
'
Public
General
esta
desde
variable
cualquier
Nombre
Public
Console.WriteLine("Procedimiento
Console.WriteLine("Asignar
Nombre
Console.WriteLine("El
Manipular()
MostrarValor()
valor
ser
lugar
accesible
proyecto
String
del
As
Sub
valor
=
de
la
variable
en
Main()
Main()")
variable")
Console.ReadLine()
la
Main()
es:
{0}",
Nombre)
Console.ReadLine()
End
Sub
Public
Console.WriteLine("Procedimiento
Console.WriteLine("Asignar
Nombre
Console.WriteLine("El
valor
Sub
valor
=
de
la
variable
en
la
Manipular()
End
End
es:
{0}",
Nombre)
Sub
Module
Module
Public
'
al
haber
'
como
Public
en
el
'
desde
un
mdulo
Console.WriteLine("Procedimiento
Nombre
Console.WriteLine("Valor
de
Manipular()
Manipular()")
variable")
Console.ReadLine()
Calculos
Sub
MostrarValor()
declarado
la
variable
Nombre
mdulo
General,
podemos
acceder
a
ella
distinto
al
que
se
ha
declarado
MostrarValor()")
=
"Antonio"
la
variable
Nombre:
{0}",
Nombre)
End
Sub
End
Module
.
mbito de procedimiento. Para estas variables, su periodo de vida est comprendido entre el
momento en que son declaradas y hasta que la ejecucin del procedimiento termina.
.
mbito a nivel de mdulo y proyecto. En este caso, el periodo de vida de la variable va desde el
comienzo de la ejecucin de la aplicacin y hasta que esta termina.
Variables Static
Este tipo de variables se caracterizan por el hecho de que retienen su valor al finalizar el procedimiento en el
que han sido declaradas. Se deben declarar utilizando la palabra clave Static, pudiendo opcionalmente omitir la palabra
clave Dim. El Cdigo fuente 174 muestra su sintaxis.
Static
[Dim]
Importe
As
Integer
Cuando declaramos una variable normal dentro de un procedimiento, cada vez que llamamos al procedimiento,
dicha variable es inicializada. El ejemplo del Cdigo fuente 175, en cada llamada al procedimiento, se inicializa la
variable y le sumamos un nmero, por lo que la variable siempre muestra el mismo valor por la consola.
Public
Verificar("Primera")
Verificar("Segunda")
Verificar("Tercera")
Console.ReadLine()
'
'
'
en
en
en
Sub
esta
esta
esta
llamada
llamada
llamada
se
se
se
Main()
muestra
7
muestra
7
muestra
7
End
'
'
Dim
Sub
Public
Sub
Verificar(ByVal
OrdenLlamada
As
String)
cada
vez
que
se
ejecuta
este
procedimiento
la
variable
Importe
se
inicializa
a
5
Importe
As
Integer
=
5
Importe
Console.WriteLine("{0}
contiene
OrdenLlamada,
llamada
+=
al procedimiento,
{1}",
la
2
variable
_
Importe)
End
Sub
Pero cambiemos el modo de declaracin de la variable Importe, aadindole Static. En este caso, la primera vez
que se ejecuta el procedimiento, se inicializa la variable con el valor 5, pero al terminar la ejecucin, la variable no se
destruye, sino que en la siguiente ejecucin conserva el valor, que podemos ir incrementando en cada llamada. Ver
Cdigo fuente 176.
Public
Sub
Main()
Verificar("Primera")
Verificar("Segunda")
Verificar("Tercera")
Console.ReadLine()
'
'
'
en
en
en
esta
esta
esta
llamada
llamada
llamada
se
se
se
muestra
muestra
muestra
7
9
11
End
Sub
Public
Sub
Verificar(ByVal
OrdenLlamada
As
String)
'
declarar
variable
con
el
modificador
Static,
'
en
la
primera
llamada
toma
el
valor
inicial
de
5,
'
las
sucesivas
llamadas
no
ejecutarn
esta
lnea
Static
Dim
Importe
As
Integer
=
5
Importe
Console.WriteLine("{0}
llamada
variable
contiene
OrdenLlamada,
End
+=
al
2
procedimiento,
la
{1}",
_
Importe)
Sub
Las variables Static por lo tanto, tienen un periodo de vida que abarca todo el tiempo de ejecucin del programa,
mientras que su mbito es a nivel de procedimiento o bloque, ya que tambin pueden crearse dentro de una estructura
de control.
Convenciones de notacin
Las convenciones de notacin consisten en una serie de normas no oficiales a la hora de declarar elementos en
el cdigo, que facilitan su interpretacin y mantenimiento.
Si bien esto no es inicialmente necesario, ni la herramienta de programacin obliga a ello, en la prctica se ha
demostrado que una serie de normas a la hora de escribir el cdigo redundan en una mayor velocidad de desarrollo y
facilidad de mantenimiento de la aplicacin. Siendo til no slo en grupos de trabajo, sino tambin para
programadores independientes.
Seguidamente describiremos una serie de normas de codificacin para variables y constantes, que no son en
absoluto obligatorias a la hora de escribir el cdigo del programa, pero si pretenden concienciar al lector de la
necesidad de seguir unas pautas comunes a la hora de escribir dicho cdigo, de manera que al compartirlo entre
programadores, o cuando tengamos que revisar una aplicacin desarrollada tiempo atrs, empleemos el menor tiempo
posible en descifrar lo que tal o cual variable significa en el contexto de una rutina o mdulo.
Variables. El formato utilizado para la notacin de variables se basa en utilizar un carcter para indicar el
mbito de la variable, seguido de uno o dos caracteres para especificar el tipo de dato y el resto del nombre que
daremos a la variable o cuerpo. Ver el Cdigo fuente 177.
<mbito><TipoDato><Cuerpo>
Tabla 22. Caracteres para indicar el tipo de dato en los nombres de las variables.
Para el cuerpo de la variable se utilizar WordMixing, que consiste en una tcnica en la cul empleamos, si es
necesario, varias palabras juntas para describir mejor el contenido de la variable. Veamos unos ejemplos en el Cdigo
fuente 178.
'
variable
liCodAcceso
local
de
tipo
integer
' variable
msNombreUsuario
nivel
de
mdulo
de
' variable
pdtDiaAlta
nivel
de
proyecto
tipo
de
string
tipo
fecha
En el caso de objetos creados por el programador, utilizaremos como prefijo para el tipo de dato, el carcter o,
o bien tres caracteres indicativos de la clase. Ver el Cdigo fuente 179.
'
variable
Dim
Dim
es
un
objeto
creado
As
As
por
el
programador
Empleado
Empleado
Constantes. En este caso seguiremos el mismo formato de notacin que para las variables en lo que respecta
al mbito y tipo de dato. El cuerpo de la constante sin embargo, deberemos escribirlo en maysculas, y separar las
distintas palabras utilizando el carcter de guin bajo ( _ ) en vez de WordMixing. Cdigo fuente 180.
'
piTIPO_IVA
constante
'
constante
msCOLOR_INICIAL
nivel
nivel
de
de
proyecto
de
mdulo
de
tipo
tipo
integer
string
Sub
Dim
Valor
Dim
Total
Main()
As
As
Console.WriteLine("Introducir
Integer
un
Valor
nmero")
If
Total
=
Console.WriteLine("Resultado:
Else
Console.WriteLine("El
End
Object
valor
Console.ReadLine()
IsNumeric(Valor)
Valor
{0}",
introducido
no
es
Then
100
Total)
numrico")
If
Console.ReadLine()
End
Sub
Cdigo fuente 181
IsDate( ). Esta funcin devuelve un valor lgico indicando si la expresin que pasamos como parmetro
contiene una fecha o una cadena que pueda ser convertida a fecha. Ver el Cdigo fuente 182.
Public
Sub
Dim
Dim
Valor
UnaFecha
Main()
Object
Date
As
As
Console.WriteLine("Introducir
una
Valor
fecha")
Console.ReadLine()
If
UnaFecha
Console.WriteLine("La
Else
Console.WriteLine("El
End
Console.ReadLine()
fecha
valor
introducido
IsDate(Valor)
=
es:
no
es
una
{0}",
fecha")
If
Then
Valor
UnaFecha)
End
Sub
Cdigo fuente 182
IsArray( ). Esta funcin devuelve un valor lgico indicando si la expresin que pasamos como parmetro
contiene un array. Ver el Cdigo fuente 183.
Dim
Public
Colores()
As
String
Sub
=
{"Verde",
"Azul",
Main()
"Rojo"}
Verificar(Colores)
Verificar("prueba")
Console.ReadLine()
End
'
If
Public
comprobar
Sub
Sub
si
Verificar(ByVal
ValorPasado
el
parmetro
contiene
IsArray(ValorPasado)
Console.WriteLine("El
parmetro
pasado
Else
Console.WriteLine("El
parmetro
pasado
no
End
End
es
un
array")
es
un
array")
If
Sub
As
un
Object)
array
Then
Numricas
Int(Nmero), Fix(Nmero). Estas funciones devuelven la parte entera del parmetro Nmero. La diferencia
entre ambas reside en que cuando el parmetro pasado es negativo, Int( ) devuelve el entero negativo menor o igual
que Nmero, mientras que Fix( ) devuelve el entero negativo mayor o igual que Nmero. Ver el Cdigo fuente 184.
Dim
Resultado
As
Integer
Resultado
Resultado
Resultado
Resultado
Int(66.87)
Fix(66.87)
'
66
66
'
-67
66
'
Int(-66.87)
Fix(-66.87)
'
.
Randomize([Nmero]). Inicializa el generador de nmeros aleatorios, que utilizaremos
posteriormente en la funcin Rnd( ). Opcionalmente recibe un nmero como parmetro que sirve al generador como
valor inicial o semilla para la creacin de estos nmeros.
.
Rnd([Nmero]). Devuelve un nmero aleatorio de tipo Single, que ser menor que 1, pero mayor o
igual a cero.
Podemos, opcionalmente, variar el modo de generacin del nmero pasando un valor al parmetro de esta
funcin. En funcin de si el parmetro es mayor, menor de cero, o cero, el comportamiento de Rnd( ) a la hora de
generar el nmero ser diferente. Ver el Cdigo fuente 185.
Dim
Dim
Contador
Aleatorio
As
As
Integer
Single
Randomize()
For
Contador
Aleatorio
To
Console.WriteLine("Nmero
generado:
10
Rnd()
{0}",
Aleatorio)
Next
Console.ReadLine()
Cdigo fuente 185 El
Si necesitamos que el nmero aleatorio est comprendido en un intervalo de nmeros enteros, utilizaremos la
frmula del Cdigo fuente 186 para generarlo.
Int((LmiteSuperior
LmiteInferior
1)
Rnd()
LmiteInferior)
El ejemplo del Cdigo fuente 187 crea nmeros aleatorios comprendidos entre el intervalo de los nmeros 7 y
12.
Dim
Contador
As
Integer
Dim
Aleatorio
As
Single
Randomize()
For
Aleatorio
Contador
=
Int((12
Console.WriteLine("Nmero
Next
Console.ReadLine()
1
7
generado:
+
{0}",
To
1)
10
Rnd()
7)
Aleatorio)
Cadena de caracteres
Len(Cadena). Devuelve un nmero con la longitud de la cadena pasada como parmetro. Ver el Cdigo
fuente 188.
Dim
Longitud
=
Console.WriteLine("La
Longitud
Len("comprobar
cadena
tiene
As
cuantos
caracteres",
{0}
caracteres
Longitud)
Integer
hay")
'
32
Space(Nmero). Devuelve una cadena de espacios en blanco, de una longitud igual al nmero pasado como
parmetro. Ver el Cdigo fuente 189.
Dim
ConEspacios
=
Console.WriteLine("La
ConEspacios
As
"Hola"
&
Space(7)
cadena
con
espacios
tiene
ControlChars.CrLf
&
ConEspacios)
'
&
el
"a
valor:"
Hola
String
todos"
&
_
todos
Dim
CadBuscar
CadBuscada
PosComienzo
Dim
Dim
CadBuscar
PosComienzo
Console.WriteLine("La
_
PosComienzo)
=
=
posicin
"El
de
comienzo
As
As
As
castillo
InStr(CadBuscar,
de
la
cadena
'
String
String
Integer
del
encontrada
bosque"
"tillo")
es:
{0}",
7
.
Left(Cadena, Longitud). Esta funcin extrae, comenzando por la parte izquierda de Cadena, una
subcadena de Longitud de caracteres.
.
Right(Cadena, Longitud). Esta funcin extrae, comenzando por la parte derecha de Cadena, una
subcadena de Longitud de caracteres. El Cdigo fuente 191 muestra ejemplos de Left( ) y Right( ).
Dim
CadIzquierda
CadDerecha
Dim
CadIzquierda
Console.WriteLine("Resultado
de
CadDerecha
Console.WriteLine("Resultado
de
As
String
String
As
=
la
funcin
Left("Especial",
Left():
{0}",
CadIzquierda)
'
3)
Esp
la
funcin
Right("Especial",
Right():
{0}",
CadDerecha)
'
3)
ial
Mid(Cadena, Inicio [, Longitud]). Extrae de Cadena, comenzando en la posicin Inicio, una subcadena.
Opcionalmente podemos utilizar el parmetro Longitud, para indicar el largo de la subcadena. En caso de no utilizar
este ltimo parmetro, la subcadena se obtendr hasta el final. Ver Cdigo fuente 192.
Dim
MiCadena
SubCadena
Dim
MiCadena
=
SubCadena
Console.WriteLine("Subcadena
encantado
SubCadena
Console.WriteLine("Subcadena
As
As
"El
=
hasta
el
=
de
String
String
bosque
Mid(MiCadena,
final:
{0}",
SubCadena)
Mid(MiCadena,
caracteres:
{0}",
6,
SubCadena)
encantado"
6)
'
sque
'
3)
squ
Dim
MiCadena
CadSustituida
Dim
MiCadena
"Este
As
As
coche
String
String
es
especial"
CadSustituida
'
resultado:
Console.WriteLine("Resultado
Replace(MiCadena,
Este
coche
reemplazo
en
la
del
cadena:
"es",
xx
{0}",
"xx")
xxpecial
CadSustituida)
'
en
el
anterior
ejemplo
los
dos
primeros
caracteres
'
no
se
sustituyen
porque
no
se
ha
especificado
el
tipo
'
de
comparacin,
que
a
continuacin
s
indicaremos
CadSustituida
=
Replace(MiCadena,
"es",
"xx",
,
,
CompareMethod.Text)
'
resultado:
xxte
coche
xx
xxpecial
'
ahora
s
se
han
sustituido
todas
las
ocurrencias
de
"es"
Console.WriteLine("Resultado
del
reemplazo
en
la
cadena:
{0}",
CadSustituida)
LTrim(Cadena), RTrim(Cadena), Trim(Cadena). Estas funciones eliminan de una cadena, los espacios en
blanco a la izquierda en el caso de LTrim( ); los espacios en blanco a la derecha en el caso de RTrim(); o los espacios
en blanco a ambos lados Trim( ). Ver el Cdigo fuente 194.
Dim
Dim
CadEspacios
CadResultante
CadResultante
=
=
CadEspacios
CadResultante
=
"
LTrim(CadEspacios)
RTrim(CadEspacios)
CadResultante
As
As
Barco
'
'
Trim(CadEspacios)
"Barco
"
'
String
String
"
"
Barco"
"Barco"
Dim
Cadena
CadMay
CadMin
Dim
Dim
Cadena
CadMay
CadMin
"Vamos
As
As
As
Convertir
=
=
En
String
String
String
Maysculas
MinscuLAS"
UCase(Cadena)
LCase(Cadena)
'
"VAMOS
A
Console.WriteLine("Conversin
CONVERTIR
a
EN
MAYSCULAS
maysculas:
Y
{0}",
MINSCULAS"
CadMay)
'
"vamos
a
Console.WriteLine("Conversin
convertir
a
en
maysculas
minsculas:
y
{0}",
minsculas"
CadMin)
Format(Expresin
[,CadenaFormato]
[,PrimerDaSemana]
[,PrimeraSemanaAo]).
Formatea
la
expresin pasada en el primer parmetro, empleando de forma opcional una cadena para especificar el tipo de
formateo a realizar. Si el valor a formatear es una fecha, podemos utilizar los dos ltimos parmetros para especificar
el primer da de la semana y la primera semana del ao; estos dos ltimos parmetros son enumeraciones, cuyos
valores aparecen automticamente al asignar su valor. Consulte el lector, la documentacin de ayuda para ms
informacin.
Como cadena de formato, podemos utilizar los nombres predefinidos de formato, o una serie de caracteres
especiales, tanto para formateo de nmeros como de fechas. En lo que respecta a los nombres predefinidos, la Tabla 23
muestra algunos de los utilizados.
Tabla
El
Cdigo
23.
Nombres
fuente
196
de
muestra
formato
para
algunos
ejemplos
la
de
funcin
formateo
Format(
con
).
nombre
El Cdigo fuente 197 muestra algunos ejemplos de formato con caracteres especiales.
Dim
MiFecha
MiNumero
ValorFormato
Dim
Dim
MiFecha
MiNumero
ValorFormato
ValorFormato
ValorFormato
=
=
=
As
As
As
#7/19/2002
=
Format(MiFecha,
"dddd
Format(MiFecha,
Format(MiNumero,
Date
Double
String
6:25:00
d/MMM/yyyy")
'
"HH:mm")
"#,#.00")
"viernes
'
'
PM#
16587.097
19/jul/2002"
"18:25"
"16.587,10"
Dim
Dim
MiCadena
'
Conversion
'
Conversion
MiCadena
Conversion
"el
convertir
=
convertir
=
As
As
String
String
lleg
puntual"
mayscula
VbStrConv.UpperCase)
minscula
StrConv(MiCadena,
VbStrConv.LowerCase)
tren
a
StrConv(MiCadena,
'
convertir
'
Conversion
mayscula
la
cada
StrConv(MiCadena,
de
=
primera
letra
palabra
VbStrConv.ProperCase)
Fecha y hora
.
Now( ). Devuelve un valor de tipo Date con la fecha y hora del sistema.
.
DateAdd(TipoIntervalo, ValorIntervalo, Fecha). Suma o resta a una fecha, un intervalo
determinado por el parmetro TipoIntervalo. El intervalo a utilizar pueden ser das, semanas, meses, etc. Para
determinar si se realiza una suma o resta, ValorIntervalo deber ser positivo o negativo respectivamente.
.
DateDiff(TipoIntervalo, FechaPrimera, FechaSegunda). Calcula la diferencia existente entre dos
fechas. En funcin de TipoIntervalo, la diferencia calculada sern das, horas, meses, aos, etc.
.
DatePart(TipoIntervalo, Fecha). Extrae la parte de una fecha indicada en TipoIntervalo. Podemos
obtener, el da, mes, ao, da de la semana, etc.
El Cdigo fuente 199 muestra un conjunto de ejemplos que utilizan las funciones para manipular fechas.
Dim
Dim
Dim
Dim
MiFecha
FechaPosterior
DiasDiferencia
ParteFecha
MiFecha
FechaPosterior
DiasDiferencia
ParteFecha
As
As
As
As
Date
Date
Long
Integer
=
Now()
'
#1/19/2002
12:27:08
PM#
DateAdd(DateInterval.Month,
2,
MiFecha)
'
#3/19/2002
12:27:08
PM#
=
DateDiff(DateInterval.Day,
MiFecha,
FechaPosterior)
'
59
=
DatePart(DateInterval.Year,
MiFecha)
'
2002
Module
Module1
Public
Console.WriteLine("Iniciamos
Sub
el
programa
Main()
en
el
modulo
General")
Console.ReadLine()
End
Sub
End
Module
Module
Calculos
Public
Console.WriteLine("Iniciamos
Sub
el
programa
Main()
en
el
modulo
Calculos")
Console.ReadLine()
End
Sub
End
Module
Por defecto, y ya que as se establece al crear el proyecto, la ejecucin comenzar por el Main( ) del mdulo
Module1. Pero podemos hacer que el procedimiento de inicio sea el Main( ) que est en el mdulo Calculos, abriendo
la ventana de propiedades del proyecto y seleccionando como objeto inicial dicho mdulo. Ver Figura 190.
Con esta tcnica, podremos disponer de tantos procedimientos de inicio como mdulos contenga nuestro
proyecto.
No obstante, si slo deseamos que exista un nico procedimiento Main( ) a lo largo de todo el cdigo de nuestra
aplicacin, en la lista desplegable Objeto inicial, de la ventana de propiedades del proyecto, tendremos que seleccionar
la opcin Sub Main; esto nos obligar a tener slo un procedimiento Main() dentro de cualquiera de los mdulos,
producindose un error si al comienzo de la ejecucin se detecta ms de una versin de Main( ).
Module
Public
General
psNombre
Public
'
'
'
'
'
'
'
'
procedimiento
de
aqu
mostramos
para
seleccionar
del
programa:
clculo
de
nmina,
As
String
Sub
inicio
por
alguno
del
ejemplo
de
altas
periodos
un
los
de
vacacionales,
Main()
programa,
men
procesos
empleados,
etc.
......
......
......
End
Sub
Public
Sub
CalcularVacaciones(ByVal
liIDEmpleado
As
Integer,
_
ByVal
ldtFechaInicio
As
Date,
ByVal
liNumDias
As
Integer)
'
en
este
procedimiento
calculamos
'
el
periodo
de
vacaciones
del
empleado
'
pasado
como
parmetro
Dim
ldtFechaFinal
As
Date
'
......
'
obtener
el
nombre
del
empleado
en
funcin
de
su
identificador
psNombre
=
"Juan"
psApellidos
=
"Plaza"
'
......
'
......
'
calcular
la
fecha
final
y
mostrar
'
el
periodo
vacacional
ldtFechaFinal
=
DateAdd(DateInterval.Day,
liNumDias,
ldtFechaInicio)
Console.WriteLine("Empleado:
{0}
{1}",
psNombre,
psApellidos)
Console.WriteLine("Vacaciones
desde
{0}
hasta
{1}",
_
Format(ldtFechaInicio,
Format(ldtFechaFinal,
Console.ReadLine()
"dd/MMM/yy"),
_
"d/MMMM/yyyy"))
End
Sub
'
otros
procedimientos
del
mdulo
......
......
'
'
End
Module
Module
Varios
Public
psApellidos
As
String
Public
Sub
CrearEmpleado(ByVal
liIDEmpleado
As
Integer,
_
ByVal
lsNombre
As
String,
ByVal
lsApellidos
As
String,
_
ByVal
lsDNI
As
String,
ByVal
ldtFechaAlta
As
Date)
'
grabamos
los
datos
de
un
nuevo
empleado
en
la
'
base
de
datos
que
utiliza
el
programa
'
......
Console.WriteLine("Se
ha
grabado
el
empleado:
{0}
{1}
{2}",
_
liIDEmpleado,
Console.ReadLine()
End
'
lsNombre,
lsApellidos)
Sub
otros
procedimientos
del
mdulo
......
'
'
......
Module
End
Module
Public
Pagos
Sub
TransfNomina(ByVal
Double)
'
realizamos
la
'
a
un
empleado,
'
'
obtenemos
los
psNombre
psApellidos
'
'
visualizamos
Console.WriteLine("Pago
Console.WriteLine("Empleado:
{0}
Console.WriteLine("Ingresado:
Console.ReadLine()
liIDEmpleado
As
transferencia
utilizando
Integer,
de
su
datos
del
=
=
el
de
{1}",
psNombre,
{0}",
ByVal
ldbImporte
nmina
identificador
......
empleado
"Ana"
"Roca"
......
resultado
nmina")
psApellidos)
ldbImporte)
End
Public
'
buscar
Dim
'
psNombre
psApellidos
lsDatosEmpleado
As
Sub
Sub
la
MostrarEmpleado(ByVal
informacin
del
lsDatosEmpleado
liIDEmpleado
empleado
por
As
As
su
=
=
=
StrConv(psNombre
VbStrConv.ProperCase)
Console.WriteLine("El
empleado
Console.ReadLine()
seleccionado
&
"
es:
"
{0}",
&
Integer)
identificador
String
......
"isabel"
"casillas"
psApellidos,
lsDatosEmpleado)
End
'
Sub
otros
procedimientos
del
'
'
End
mdulo
......
......
Module
En el ejemplo anterior se declaran variables pblicas en diferentes mdulos del proyecto, y se crean
procedimientos para las tareas relacionadas con el alta, visualizacin de datos, pagos, etc., del empleado. Todo este
cdigo se encuentra disperso a lo largo del programa, por lo que su mantenimiento, segn crezca la aplicacin, se har
progresivamente ms difcil.
Dejemos por el momento, a nuestro atribulado programador, pensando en cmo resolver este problema;
posteriormente volveremos a l para aportarle una solucin, que vendr naturalmente, de mano de la OOP.
Objetos
Un objeto es una agrupacin de cdigo, compuesta de propiedades y mtodos, que pueden ser manipulados
como una entidad independiente. Las propiedades definen los datos o informacin del objeto, permitiendo consultar o
modificar su estado; mientras que los mtodos son las rutinas que definen su comportamiento.
Un objeto es una pieza que se ocupa de desempear un trabajo concreto dentro de una estructura organizativa de
nivel superior, formada por mltiples objetos, cada uno de los cuales ejerce la tarea particular para la que ha sido
diseado.
Clases
Una clase no es otra cosa que el conjunto de especificaciones o normas que definen cmo va a ser creado un
objeto de un tipo determinado; algo parecido a un manual de instrucciones conteniendo las indicaciones para crear el
objeto.
Los trminos objeto y clase son utilizados en OOP con gran profusin y en contextos muy similares, por lo que
para intentar aclarar en lo posible ambos conceptos, diremos que una clase constituye la representacin abstracta de
algo, mientras que un objeto constituye la representacin concreta de lo que una clase define.
La clase determina el conjunto de puntos clave que ha de cumplir un objeto para ser considerado perteneciente a
dicha clase o categora, ya que no es obligatorio que dos objetos creados a partir de la misma clase sean exactamente
iguales, basta con que cumplan las especificaciones clave de la clase.
Expongamos ahora las anteriores definiciones mediante un ejemplo preciso: un molde para crear figuras de
cermica y las figuras obtenidas a partir del molde. En este caso, el molde representara la clase Figura, y cada una de
las figuras creadas a partir del molde, sera un objeto Figura. Cada objeto Figura tendr una serie de propiedades
comunes: tamao y peso iguales; y otras propiedades particulares: un color distinto para cada figura.
Aunque objetos distintos de una misma clase pueden tener ciertas propiedades diferentes, deben tener el mismo
comportamiento o mtodos. Para explicar mejor esta circunstancia, tomemos el ejemplo de la clase Coche; podemos
crear dos coches con diferentes caractersticas (color, tamao, potencia, etc.), pero cuando aplicamos sobre ellos los
mtodos Arrancar, Acelerar o Frenar, ambos se comportan o responden de la misma manera.
Abstraccin
La abstraccin es aquella caracterstica que nos permite identificar un objeto a travs de sus aspectos
conceptuales.
Las propiedades de los objetos de una misma clase, pueden hacerlos tan distintos que sea difcil reconocer que
pertenecen a una clase idntica. No obstante, nosotros reconocemos a qu clase pertenecen, identificando adems, si se
trata de la misma clase para ambos. Ello es posible gracias a la abstraccin.
Tomemos como ejemplo dos objetos coche, uno deportivo y otro familiar; su aspecto exterior es muy diferente,
sin embargo, cuando pensamos en cualquiera de ellos, sabemos que ambos pertenecen a la clase Coche, porque
realizamos una abstraccin o identificacin mental de los elementos comunes que ambos tienen (ruedas, volante,
motor, puertas, etc.).
Del mismo modo que hacemos al identificar objetos reales, la abstraccin nos ayuda a la hora de desarrollar una
aplicacin, permitindonos identificar los objetos que van a formar parte de nuestro programa, sin necesidad de
disponer an de su implementacin; nos basta con reconocer los aspectos conceptuales que cada objeto debe resolver.
Por ejemplo, cuando abordamos el desarrollo de un programa de gestin orientado a objetos, realizamos una
abstraccin de los objetos que necesitaramos para resolver los procesos del programa: un objeto Empleado, para
gestionar al personal de la empresa; un objeto Factura, para gestionar las ventas realizadas de productos; un objeto
Usuario, para verificar las personas que utilizan la aplicacin, etc.
Encapsulacin
La encapsulacin establece la separacin entre el interfaz del objeto y su implementacin, aportndonos dos
ventajas fundamentales.
Por una parte proporciona seguridad al cdigo de la clase, evitando accesos y modificaciones no deseadas; una
clase bien encapsulada no debe permitir la modificacin directa de una variable, ni ejecutar mtodos que sean de uso
interno para la clase.
Por otro lado la encapsulacin simplifica la utilizacin de los objetos, ya que un programador que use un objeto,
si este est bien diseado y su cdigo correctamente escrito, no necesitar conocer los detalles de su implementacin,
se limitar a utilizarlo.
Tomando un ejemplo real, cuando nosotros utilizamos un objeto Coche, al presionar el acelerador, no
necesitamos conocer la mecnica interna que hace moverse al coche, sabemos que el mtodo Acelerar del coche es lo
que tenemos que utilizar para desplazarnos, y simplemente lo usamos.
Pasando a un ejemplo en programacin, si estamos creando un programa de gestin y nos proporcionan un
objeto Cliente que tiene el mtodo Alta, y sirve para aadir nuevos clientes a la base de datos, no precisamos conocer
el cdigo que contiene dicho mtodo, simplemente lo ejecutamos y damos de alta a los clientes en nuestra aplicacin.
Polimorfismo
El polimorfismo determina que el mismo nombre de mtodo, realizar diferentes acciones segn el objeto sobre
el que sea aplicado. Al igual que suceda en la encapsulacin, el programador que haga uso del objeto, no necesita
conocer los detalles de implementacin de los mtodos, se limita a utilizarlos.
Pasando a un ejemplo real, tomamos dos objetos: Pelota y VasoCristal; si ejecutamos sobre ambos el mtodo
Tirar, el resultado en ambos casos ser muy diferente; mientras que el objeto Pelota rebotar al llegar al suelo, el
objeto VasoCristal se romper.
En un ejemplo aplicado a la programacin, supongamos que disponemos de los objetos Ventana y Fichero; si
ejecutamos sobre ambos el mtodo Abrir, el resultado en Ventana ser la visualizacin de una ventana en el monitor
del usuario; mientras que en el objeto Fichero, se tomar un fichero en el equipo del usuario y se dejar listo para
realizar sobre l operaciones de lectura o escritura.
Herencia
Se trata de la caracterstica ms importante de la OOP, y establece que partiendo de una clase a la que
denominamos clase base, padre o superclase, creamos una nueva clase denominada clase derivada, hija, o subclase. En
esta clase derivada dispondremos de todo el cdigo de la clase base, ms el nuevo cdigo propio de la clase hija, que
escribamos para extender sus funcionalidades.
A su vez podemos tomar una clase derivada, creando una nueva subclase a partir de ella, y as sucesivamente,
componiendo lo que se denomina una jerarqua de clases, que explicaremos seguidamente.
Existen dos tipos de herencia: simple y mltiple. La herencia simple es aquella en la que creamos una clase
derivada a partir de una sola clase base, mientras que la herencia mltiple nos permite crear una clase derivada a partir
de varias clases base. El entorno de .NET Framework slo permite utilizar herencia simple.
Como ejemplo real de herencia, podemos usar la clase Coche como clase base; en ella reconocemos una serie de
propiedades como Motor, Ruedas, Volante, etc., y unos mtodos como Arrancar, Acelerar, Frenar, etc. Como clase
derivada creamos CocheDeportivo, en la cul, adems de todas las caractersticas mencionadas para la clase Coche,
encontramos propiedades y comportamiento especficos como ABS, Turbo, etc.
Un ejemplo basado en programacin consistira en disponer de la ya conocida clase Empleado. Esta clase se
ocupa, como ya sabemos, de las operaciones de alta de empleados, pago de nminas, etc.; pero en un momento dado,
surge la necesidad de realizar pagos a empleados que no trabajan en la central de la empresa, ya que se trata de
comerciales que pasan la mayor parte del tiempo desplazndose. Para realizar dichos pagos usaremos Internet,
necesitando el nmero de tarjeta de crdito y la direccin email del empleado. Resolveremos esta situacin creando la
clase derivada CiberEmpleado, que hereda de la clase Empleado, en la que slo tendramos que aadir las nuevas
propiedades y mtodos para las transacciones electrnicas, puesto que las operaciones tradicionales ya las tendramos
disponibles por el mero hecho de haber heredado de Empleado.
Jerarquas de clases
Como decamos en un apartado anterior, uno de los fines de la OOP consiste en la clasificacin del cdigo; para
ello se emplean jerarquas o rboles de clases, en los que a base de niveles, se muestra un conjunto de clases
conectadas por una relacin de herencia. Observemos el esquema de la Figura 192, en el que se muestra un ejemplo de
la jerarqua de clases de medios de transporte.
En esta representacin de ejemplo, como nivel superior de la jerarqua o clase base estara Medios de transporte,
de la que se derivaran las clases Barco, Tren, Automvil, y a su vez, de estas ltimas, partiran nuevas clases hijas.
Herencia
Como acabamos de describir en el apartado sobre caractersticas de la OOP, cuando a partir de una clase
existente, creamos una nueva clase derivada, esta nueva clase dispone de todas las propiedades y mtodos de la clase
base, mas el cdigo propio que implemente.
Para reconocer si existe esta relacin entre dos objetos, debemos realizar un anlisis sintctico sobre la misma
usando la partcula es un.
Tomando como ejemplo los objetos Empleado, CiberEmpleado y Factura, podemos decir que s hay una
relacin de herencia entre Empleado y CiberEmpleado, ya que al analizar la frase Un objeto CiberEmpleado es un
Empleado, el resultado es verdadero.
No ocurre lo mismo entre los objetos CiberEmpleado y Factura, ya que el anlisis de la frase Un objeto
CiberEmpleado es una Factura, devuelve falso.
Pertenencia
Los objetos pueden estar formados a su vez por otros objetos. Un objeto Factura puede estar compuesto por
objetos CabeceraFactura, LineaFactura, etc. Se dice en este caso que hay una relacin de pertenencia, puesto que
existe un conjunto de objetos que pertenecen a otro objeto o se unen para formar otro objeto. A este tipo de relacin se
le denomina tambin Contenedora.
Para reconocer si existe esta relacin entre dos objetos, debemos realizar un anlisis sintctico sobre la misma
usando la partcula tiene un. As, por ejemplo, la frase Un objeto Factura tiene un objeto LineaFactura devolvera
verdadero.
Utilizacin
Hay situaciones en que un objeto utiliza a otro para realizar una determinada tarea, sin que ello suponga la
existencia de una relacin de pertenencia entre dichos objetos.
Por ejemplo, un objeto Ventana puede utilizar un objeto Empleado para mostrar al usuario las propiedades del
empleado, sin necesidad de que el objeto Empleado sea propiedad del objeto Ventana.
Ntese la importante diferencia entre esta relacin y la anterior, ya que aqu, el objeto Ventana a travs de
cdigo, crear, o le ser pasado como parmetro, un objeto Empleado, para poder mostrarlo en el rea de la ventana.
Para reconocer si existe esta relacin entre dos objetos, debemos realizar un anlisis sintctico sobre la misma
empleando la partcula usa un. As, por ejemplo, la frase Un objeto Ventana usa un objeto Empleado devolvera
verdadero.
Reutilizacin
Un objeto bien diseado, puede ser reutilizado en otra aplicacin de modo directo o creando una clase derivada
a partir de l. Este es uno de los objetivos perseguidos por la OOP, aprovechar en lo posible el cdigo ya escrito,
ahorrando un considerable tiempo en el desarrollo de programas.
Creacin de clases
Volvamos al ejemplo expuesto al comienzo de este tema, en el cul, habamos dejado a nuestro programador
desarrollando los procesos de un empleado dentro de una aplicacin de gestin empresarial. Recordemos que se
planteaba el problema de que ante el crecimiento del programa, el mantenimiento del cdigo, al enfocarse de modo
procedural, poda volverse una tarea realmente difcil.
Vamos a replantear este diseo, encauzndolo bajo una perspectiva orientada a objeto, que nos permita un uso
ms sencillo del cdigo y un mantenimiento tambin ms fcil. Para lo cual desarrollaremos una clase que contenga
todas las operaciones a realizar por el empleado; en definitiva, crearemos la clase Empleado, cuyo proceso
describiremos a continuacin.
Podemos escribir una clase en VB.NET utilizando diferentes tipos de aplicacin, en este caso emplearemos una
aplicacin de consola. Iniciaremos en primer lugar VS.NET, creando un proyecto de tipo consola. A continuacin
seleccionaremos el men Proyecto + Agregar clase, que nos mostrar la ventana para agregar nuevos elementos al
proyecto. El nombre por defecto asignado por el IDE para la clase ser Class1; cambiaremos dicho nombre por
Empleado, y pulsaremos Abrir. Ver Figura 193.
Figura 193. Aadir una clase a un proyecto.
Se crear de esta forma un nuevo fichero de cdigo (EMPLEADO.VB), mostrndose el editor de cdigo con su
contenido. Observemos en este sentido, que la definicin de una clase se realiza utilizando las palabras clave
Class...End Class; entre estas palabras escribiremos el cdigo de la clase. Ver Cdigo fuente 202.
Public
Class
Empleado
End
Class
Fichero
MisClases.VB
====================
Class
Empleado
'
cdigo
de
'
'
End
Public
la
clase
......
......
Class
Class
Factura
'
cdigo
de
'
'
End
la
clase
......
......
Class
Instanciacin de objetos
En este momento, nuestra clase Empleado cuenta con el cdigo mnimo para poder ser utilizada, para lo que
debemos instanciar objetos a partir de la misma.
Como ya se explic en un apartado anterior, el proceso de instanciacin consiste en crear un objeto a partir de
las especificaciones de la clase. El modo ms comn de trabajar con una instancia de una clase, o lo que es lo mismo,
con un objeto, pasa por asignar dicho objeto a una variable.
Instanciaremos un objeto en el cdigo utilizando la sintaxis de declaracin de variables junto a la palabra clave
New, empleando como tipo de dato el nombre de la clase. Todo este cdigo lo podemos situar en un mdulo dentro
del proyecto, bien en un fichero de cdigo aparte o en el mismo fichero en donde estamos escribiendo la clase. El
Cdigo fuente 204 muestra las formas disponibles de instanciar un objeto y asignarlo a una variable.
Module
General
Sub
'
'
Dim
loEmpleado1
declarar
y
despus
loEmpleado1
=
'
declaracin
loEmpleado2
Dim
'
Dim
e
As
declaracin
'
la
loEmpleado3
As
New
Main()
variable
objeto
Empleado
Empleado()
instanciacin
New
simultnea
Empleado()
primero
instanciar
el
posterior
misma
As
la
instanciacin
lnea
Empleado
End
End
de
=
New
en
cdigo
Empleado()
Sub
Module
Si bien es cierto que ya es posible crear objetos a partir de nuestra clase, no lo es menos el hecho de que no
podemos hacer grandes cosas con ellos, puesto que la clase se encuentra vaca de cdigo. Debemos aadir propiedades
y mtodos para conseguir que los objetos acten en nuestra aplicacin.
Miembros de la clase
Los elementos de una clase que contienen sus datos y definen su comportamiento, es decir, las propiedades y
mtodos, reciben adems el nombre de miembros de la clase, trmino que tambin utilizaremos a partir de ahora.
Public
Class
'
'
'
Public
declaramos
para
un
Empleado
campo
en
el
guardar
del
piIdentificador
la
As
End
clase
identificador
empleado
Integer
Class
Para manipular un campo desde cdigo cliente, debemos instanciar un objeto, a continuacin de la variable que
lo contiene situar un punto ( . ), y finalmente el nombre del campo a manipular. Este modo de operacin es comn
para todos los miembros de clases, tanto creadas por el programador, como pertenecientes a la propia plataforma .NET
Framework. Ver el Cdigo fuente 206.
Module
General
Sub
Dim
loEmpleado
'
instanciar
loEmpleado
'
mostrar
Console.WriteLine("El
el
'
asignar
loEmpleado.piIdentificador
un
Main()
Empleado
As
objeto
New
valor
al
Empleado()
campo
del
el
valor
valor
del
de
campo
un
es:
campo
{0}",
del
objeto
75
objeto
loEmpleado.piIdentificador)
Console.ReadLine()
End
Sub
End
Module
Como habr observado el lector, al escribir el nombre del objeto y el punto, aparece una lista con los miembros
de la clase accesibles desde el cdigo cliente. De momento slo disponemos del campo y el mtodo GetType( ), que
devuelve un objeto de la clase Type, conteniendo informacin sobre el tipo del objeto. Esta lista ir aumentando
progresivamente segn aadimos ms propiedades y mtodos a la clase, constituyendo una inestimable ayuda para el
programador, que le evita el tener que recordar los nombres de todos los elementos de la clase, o consultar
continuamente su documentacin.
Una propiedad en la clase se define, por norma general, mediante dos elementos: una variable de propiedad y un
procedimiento de propiedad.
La variable de propiedad, tal y como su nombre indica, es una variable con mbito privado a nivel de la clase,
que se encarga de guardar el valor de la propiedad. Por su parte el procedimiento de propiedad o Property, es el
encargado de actuar de puente entre el cdigo cliente y la variable de propiedad, realizando las operaciones de acceso
y asignacin de valores a dicha variable.
Por lo tanto, para crear una propiedad en nuestra clase, declararemos en primer lugar una variable Private, y en
segundo lugar un procedimiento de tipo Property, que consta de dos bloques: Get, para devolver el valor de la variable
de propiedad; y Set, para asignrselo. La sintaxis a emplear se muestra en el Cdigo fuente 207.
Public
'
'
Private
'
'
Public
Class
declarar
para
variable
la
msNombre
declarar
para
Property
'
'
una
Empleado
el
la
Nombre()
bloque
el
propiedad
As
de
propiedad
Nombre
String
procedimiento
propiedad
As
Property
Nombre
String
Get
valor
para
de
devolver
la
propiedad
Get
Return
msNombre
Get
End
'
bloque
'
valor
Set(ByVal
msNombre
End
End
End
Set
para
a
Value
la
As
asignar
propiedad
String)
Value
Set
Property
Class
Cuando declaramos un procedimiento Property, debemos, al igual que en una funcin, tipificarlo, ya que una de
sus labores consiste en la devolucin de un valor.
Para devolver el valor, en el bloque Get podemos utilizar la palabra clave Return, seguida del valor de retorno, o
bien la sintaxis clsica de asignar el valor al nombre de la funcin. Nuestra recomendacin es el uso de Return por las
ventajas explicadas en el tema del lenguaje.
En cuanto a la asignacin de valor, el bloque Set utiliza un parmetro con el nombre Value, que contiene el
Sub
Dim
loEmpleado
'
loEmpleado.Nombre
As
Main()
Empleado()
New
asignar
'
mostrar
el
valor
Console.WriteLine("El valor de
loEmpleado.Nombre)
Console.ReadLine()
End
valor
una
de
la
una
propiedad
propiedad Nombre
propiedad
"Guillermo"
del
objeto
es: {0}", _
Sub
Dado que los procedimientos Property no son otra cosa que rutinas de cdigo, tambin se les denomina mtodos
de acceso y asignacin en el argot OOP.
Module
Sub
Dim
loEmpleado
loEmpleado.psNombre
loEmpleado.piCategoria
'
atencin,
'
debera
estar
loEmpleado.pdbSueldo
General
loEmpleado
=
Main()
Empleado
Empleado()
"Juan"
1
As
New
=
=
el
entre
sueldo
a
200,
=
para
debido
este
a
su
empleado
categora
250
End
Sub
End
Module
Public
Class
Public
msNombre
Public
miCategoria
Public
mdbSueldo
Empleado
String
Integer
Double
As
As
As
End
Class
Que est sucediendo aqu?. Hemos creado un objeto empleado al que le hemos dado categora 1, sin embargo
le estamos asignando un sueldo que no corresponde a su categora, pero se nos permite hacerlo sin ningn problema,
ya que no existe un medio de control que nos lo impida.
Afrontando el problema mediante el uso de propiedades, contamos con la ventaja de escribir cdigo de
validacin en los correspondientes procedimientos Property; con ello encapsulamos el cdigo de la clase,
mantenindolo a salvo de asignaciones incoherentes. Veamos esta solucin en el Cdigo fuente 210.
Module
Sub
Dim
loEmpleado
General
loEmpleado
=
loEmpleado.psNombre
loEmpleado.Categoria
loEmpleado.Sueldo
Console.WriteLine("Asignacin
Console.WriteLine("Empleado
{0}
=
=
loEmpleado.psNombre,
"Pedro"
1
=
-
loEmpleado.psNombre,
loEmpleado.Sueldo
Console.WriteLine("Asignacin
Console.WriteLine("Empleado
{0}
Main()
Empleado
Empleado()
As
New
Categoria
{1}
250
incorrecta")
Sueldo
{2}",
_
loEmpleado.Categoria,
loEmpleado.Sueldo)
=
-
Categoria
{1}
loEmpleado.Categoria,
Sueldo
175
correcta")
{2}",
_
loEmpleado.Sueldo)
Console.ReadLine()
End
Sub
End
Module
Public
Class
Public
psNombre
Empleado
String
As
'
Private
Private
variables
miCategoria
mdbSueldo
'
Public
Get
Return
End
propiedad
Integer
As
Value
As
Integer)
Value
Set
Property
Property
Sueldo()
As
Double
mdbSueldo
Get
'
cuando
'
ejecutamos
Set(ByVal
si
If
asignamos
cdigo
de
Value
la
el
valor
validacin
categora
del
miCategoria
...pero
'
mostrar
Console.WriteLine("La
mdbSueldo
todo
bien,
=
esta
el
empleado
mensaje
no
asignar
propiedad,
bloque
Set
Double)
es
1
supera
>
un
categora
va
a
en
As
=
sueldo
el
Value
Else
'
si
mdbSueldo
de
miCategoria
Get
Public
Get
Return
End
'
If
propiedad
Integer
Double
As
As
procedimientos
Property
Categoria()
Set(ByVal
miCategoria
End
End
'
de
Then
200
Then
200
y
corresponde
=
el
asignar
con
un
el
1...
cero
sueldo")
0
sueldo
Value
End
If
If
End
Set
Property
End
Class
End
End
Module
General
Sub
Dim
loEmpleado
loEmpleado
=
loEmpleado.psNombre
'
a
esta
'
valor,
si
'
loEmpleado.CuentaBancaria
propiedad
intentamos
un
=
loEmpleado.psNombre,
Console.ReadLine()
End
{0}
podemos
se
asignarle
producir
error
"2222-56-7779995555"
EntidadBancaria
slo
intentamos
asignarlo
un
error
es
{1}",
_
loEmpleado.EntidadBancaria)
Sub
End
Public
campo
"Pedro"
slo
obtenerlo,
'
en
esta
lnea,
la
propiedad
'
nos
permite
obtener
valor,
si
'
se
producir
Console.WriteLine("La
entidad
del
empleado
'
Main()
Empleado
Empleado()
As
New
Module
Class
de
Empleado
clase
Public
psNombre
As
String
'
Private
Private
variables
msCtaBancaria
msEntidad
'
Private
variables
msCodigoEntidad
'
'
Public
esta
por
'
'
Public
Value
Case
=
esta
por
lo
ReadOnly
permite
dispone
de
CuentaBancaria()
As
Left(Value,
"Banco
"Caja
"entidad
propiedad
slo
que
no
Property
Get
Return
End
End
End
diversas
String
As
"Banco
propiedad
String
String
As
As
propiedad
slo
que
no
Property
lo
WriteOnly
Set(ByVal
Select
Case
msEntidad
Case
msEntidad
Case
msEntidad
Case
msEntidad
End
End
End
de
sin
asignar
bloque
As
valores,
Get
String
String)
4)
"1111"
Universal"
"2222"
General"
"3333"
Metropolitana"
Else
catalogar"
Select
Set
Property
permite
dispone
de
EntidadBancaria()
obtener
bloque
As
valores,
Set
String
msEntidad
Get
Property
Class
Propiedades virtuales
Otra de las ventajas del uso de propiedades reside en la posibilidad de definir propiedades virtuales; es decir,
una propiedad que no tenga una correspondencia directa con una variable de propiedad, ya que podemos crear un
procedimiento Property que no est obligatoriamente asociado con una variable.
Siguiendo con la clase Empleado, en esta ocasin creamos una propiedad para almacenar la fecha en la que el
empleado ha sido incorporado a la empresa; esto no entraa ninguna novedad. Sin embargo, seguidamente
necesitamos disponer de una propiedad que nos permita mostrar el nombre del mes en el que se ha dado de alta al
empleado.
Podemos resolver esta cuestin creando una variable de propiedad, guardando en ella una cadena con el nombre
del mes; pero si disponemos de la fecha de alta, que ya contiene el mes, nos ahorraremos ese trabajo extra creando una
propiedad, en este caso de slo lectura, en la que extraigamos el nombre del mes de la fecha de alta y lo devolvamos
como resultado. Veamos como hacerlo en el Cdigo fuente 212.
Module
Sub
General
Main()
Dim
loEmpleado
loEmpleado
=
As
New
loEmpleado.psNombre
loEmpleado.FechaAlta
Empleado
Empleado()
"Antonio"
"12/6/2002"
'
mostramos
el
mes
'
a
una
propiedad
Console.WriteLine("El
empleado
{0}
se
ha
de
dado
alta,
virtual
de
alta
en
que
del
el
mes
loEmpleado.psNombre,
corresponde
objeto
de
{1}",
_
loEmpleado.MesAlta)
Console.ReadLine()
End
End
Sub
Module
Public
Class
'
campo
de
Public
psNombre
As
'
Private
Empleado
clase
String
variables
mdtFechaAlta
'
'
Public
propiedad
de
Property
de
para
alta
manejar
la
fecha
empleado
Date
del
FechaAlta()
As
Get
Return
End
mdtFechaAlta
Get
Set(ByVal
mdtFechaAlta
End
End
'
'
en
'
de
Public
propiedad
Date
As
ella
alta
Value
As
Date)
Value
Set
Property
propiedad
devolvemos
el
nombre
del
al
empleado,
utilizando
ReadOnly
Property
Get
Return
End
End
End
mes
en
el
la
variable
MesAlta()
Format(mdtFechaAlta,
que
de
se
otra
As
virtual
ha
dado
propiedad
String
"MMMM")
Get
Property
Class
correspondiente al nombre del empleado, ya que en l utilizamos convenciones de notacin para facilitar el
mantenimiento del cdigo, pero por otra parte, estamos contribuyendo a dificultar la legibilidad de los miembros de la
clase desde el cdigo cliente.
Es cierto que podemos obviar las convenciones de notacin en el cdigo, pero esto, como ya comentamos en el
tema sobre el lenguaje, puede hacer que la lectura del programa sea ms complicada.
Como hemos comprobado tambin en los pasados ejemplos, si utilizamos propiedades, podemos mantener
nuestras normas de notacin en cuanto a las variables de la clase, sea cual sea su tipo, y ofrecer al cdigo cliente,
nombres ms naturales a travs de los procedimientos Property.
Por lo tanto, si en lugar de utilizar un campo de clase para el nombre del empleado, la convertimos en una
propiedad, habremos ganado en claridad de cara al programador usuario de nuestra clase. Vemoslo en el Cdigo
fuente 213.
Module
Sub
Dim
loEmpleado
'
al
'
siempre
'
propiedad
'
a
loEmpleado.Nombre
End
utilizar
es
Nombre,
claridad
New
un
objeto
ms
que
del
desde
sencillo
msNombre,
cdigo
cdigo
manipular
en
se
cliente
la
cuanto
refiere
"Juan"
Sub
Module
End
Public
'
antes
'Public
As
General
Main()
Empleado()
Class
un
campo
de
As
String
usbamos
psNombre
'
...pero
Private
'
...creando
Public
Empleado
clase...
<---
lo
convertimos
en
una
msNombre
su
procedimiento
de
Property
Nombre()
variable
As
propiedad
As
de
propiedad...
String
correspondiente
String
Get
Return
End
Set(ByVal
msNombre
End
End
End
Value
msNombre
Get
String)
As
=
Value
Set
Property
Class
Propiedades
predeterminadas
Una propiedad predeterminada o por defecto, es aquella que nos permite su manipulacin omitiendo el nombre.
Para establecer una propiedad como predeterminada en una clase, la variable de propiedad asociada deber ser
Module
General
Sub
Dim
Dim
loEmpleado
liContador
'
primero
'
igual
loEmpleado.Viajes(0)
'
'
loEmpleado(1)
aqu
As
Main()
Empleado()
Integer
New
As
manejamos
la
que
propiedad
una
predeterminada
normal
"Valencia"
propiedad
su
predeterminada
nombre
"Toledo"
manipulamos
sin
la
indicar
=
For
liContador
Console.WriteLine("Visita:
liContador,
Next
=
{0}
0
To
1
Ciudad:
{1}",
_
loEmpleado(liContador))
Console.ReadLine()
End
End
Sub
Module
Public
Class
'
este
es
el
array
'
la
propiedad
Private
msViajes()
'
Default
declaracin
Public
Property
Get
'
'
'
Return
para
el
Empleado
asociado
a
predeterminada
As
String
de
Viajes(ByVal
la
Indice
devolver
nmero
propiedad
As
Integer)
un
de
predeterminada
As
String
valor,
ndice
empleamos
pasado
parmetro
msViajes(Indice)
como
End
'
'
Get
Set(ByVal
para
comprobamos
'
'
al
asignar
primero
comprobar
ser
Value
un
si
el
si
valor
el
el
array
As
a
array
array
tambin
la
est
est
un
String)
propiedad,
vaco
vaco,
objeto,
'
utilizamos
If
el
msViajes
operador
Is
Is
Nothing
Then
msViajes(0)
ReDim
'
'
ReDim
Else
si
el
aadir
Preserve
array
ya
contena
un
nuevo
msViajes(UBound(msViajes)
valores,
elemento
1)
End
If
'
msViajes(Indice)
End
End
asignar
el
valor
al
array
Value
Set
Property
End
Class
El uso de propiedades predeterminadas proporciona una cierta comodidad a la hora de escribir el cdigo, sin
embargo, si nos acostumbramos a especificar en todo momento las propiedades en el cdigo, ganaremos en
legibilidad.
'
'
'
'
La
este
Esto
es
cdigo
VB6
==================
variable
txtCaja
contiene
un
objeto
TextBox,
objeto
tiene
la
propiedad
Text
como
predeterminada
'
estas
dos
lneas
son
equivalentes,
'
asignan
valores
a
la
propiedad
Text
txtCaja.Text
=
"coche"
txtCaja
=
"tren"
'
Si
no
dispusiramos
en
VB6
de
Set,
en
la
'
siguiente
lnea
no
sabramos
si
se
est
'
intentando
asignar
un
valor
a
la
propiedad
Text
'
o
un
nuevo
objeto
a
la
variable
txtCaja
=
txtNuevaCaja
'
esto
produce
error
en
VB6
'
'
'
Set
esto es lo
asignamos
a
txtCaja
correcto
un
la
=
y nos
nuevo
indica que
objeto
variable
txtNuevaCaja
Debido a la restriccin impuesta por VB.NET, que nos obliga a que las propiedades predeterminadas sean un
array, el uso de Set deja de tener sentido, ya que siempre que hagamos referencia a una propiedad predeterminada
tendremos que usar el ndice de su array, generndose un cdigo ms claro y eliminando la incomodidad de usar Set
para cada asignacin de objetos a variables. Ver el Cdigo fuente 216.
'
'
Dim
esto
es
cdigo
VB.NET
=====================
loEmpleado
As
Empleado
'
no
'
un
loEmpleado
utilizamos
Set
para
asignar
objeto
a
una
variable
=
New
Empleado()
Mtodos
espacios
de
nombre
En la clase Empleado necesitamos realizar un clculo del da en que va a finalizar un empleado sus vacaciones;
para ello precisamos conocer la fecha de comienzo y la cantidad de das que va a estar de vacaciones, por lo que
escribiremos un mtodo en nuestra clase al que llamaremos CalcularVacaciones( ); a este mtodo le pasaremos los
parmetros de la fecha de inicio y el nmero de das, devolviendo, al ser de tipo Function, la fecha de finalizacin del
periodo vacacional.
Module
General
Sub
Main()
'
instanciar
Dim
objeto
loEmpleado
loEmpleado
As
Property
=
=
mtodo
15)
Sub
Module
Empleado
propiedad
Integer
String
String
de
propiedad
Integer
......
Property
As
Nombre()
As
String
......
Property
'
End
Public
Property
propiedades
78
"Antonio"
"Iglesias"
procedimientos
Property
Identificador()
Public
Empleado()
valores
'
llamar
loEmpleado.CalcularVacaciones("20/07/2002",
End
End
'
Public
'
End
Empleado
New
'
asignar
loEmpleado.Identificador
loEmpleado.Nombre
loEmpleado.Apellidos
Public
Class
'
variables
de
Private
miID
As
Private
msNombre
As
Private
msApellidos
As
Empleado
Apellidos()
As
String
......
Property
'
End
'
mtodos
Public
Sub
CalcularVacaciones(ByVal
ldtInicio
As
Date,
_
ByVal
liDias
As
Integer)
'
en
este
mtodo
calculamos
el
periodo
'
de
vacaciones
del
empleado,
'
mostrando
los
resultados
en
consola
Dim
ldtFinal
As
Date
ldtFinal
=
DateAdd(DateInterval.Day,
liDias,
ldtInicio)
Console.WriteLine("Empleado
{0}
{1}
{2}",
_
Identificador,
Console.WriteLine("Vacaciones
Nombre,
desde
Apellidos)
{0}
hasta
{1}",
Format(ldtInicio,
Format(ldtFinal,
"dd/MMM/yy"),
_
"d/MMMM/yyyy"))
Console.ReadLine()
End
Sub
End
Class
Llegados a este punto, hemos completado todos los pasos elementales en cuanto a la creacin de una clase.
Retomemos pues, el caso del ejemplo expuesto al comienzo del tema, de manera que si sustituimos el enfoque
procedural de los procesos del empleado, por uno orientado a objeto, la clase Empleado resultante podra ser algo
similar a la mostrada en el Cdigo fuente 218.
Public
Class
'
variables
de
Private
miID
As
Private
msNombre
As
Private
msApellidos
As
Private
msDNI
As
Private
mdtFechaAlta
As
Private
mdbSueldo
As
Private
Private
'
Public
Get
Empleado
propiedad
Integer
String
String
String
Date
Double
mdtInicioVacaciones
miDiasVacaciones
As
procedimientos
Property
Identificador()
Return
End
Set(ByVal
Value
miID
Date
Integer
As
de
propiedad
Integer
As
miID
Get
Integer)
As
=
Value
Set
Property
End
End
Public
Property
Nombre()
As
String
Get
Return
End
Set(ByVal
Value
msNombre
msNombre
Get
String)
As
=
Value
Set
Property
End
End
Public
Property
Apellidos()
As
String
Get
Return
End
Set(ByVal
msApellidos
End
Value
As
=
msApellidos
Get
String)
Value
Set
End
Property
Public
Property
DNI()
As
String
Get
Return
End
Set(ByVal
Value
msDNI
msDNI
Get
String)
As
=
Value
Set
Property
End
End
Public
Property
FechaAlta()
As
Date
Get
Return
End
Set(ByVal
Value
mdtFechaAlta
Get
Date)
As
mdtFechaAlta
Value
Set
Property
End
End
Public
Property
Sueldo()
As
Double
Get
Return
End
Set(ByVal
Value
mdbSueldo
Get
Double)
As
mdbSueldo
Value
Set
Property
End
End
Public
Property
InicioVacaciones()
As
Date
Get
Return
End
Set(ByVal
Value
mdtInicioVacaciones
Get
Date)
As
mdtInicioVacaciones
Value
Set
Property
End
End
Public
Property
DiasVacaciones()
As
Integer
Get
Return
End
Set(ByVal
Value
miDiasVacaciones
miDiasVacaciones
Get
Integer)
As
=
Value
Set
Property
End
End
Public
Sub
'
en
este
mtodo
'
de
vacaciones
'
mostrando
los
Dim
ldtFinal
ldtFinal
=
DateAdd(DateInterval.Day,
Console.WriteLine("Empleado
{0}
calculamos
del
resultados
As
miDiasVacaciones,
{1}
CalcularVacaciones()
el
periodo
empleado,
en
consola
Date
mdtInicioVacaciones)
{2}",
_
miID,
msNombre,
Console.WriteLine("Vacaciones
Format(mdtInicioVacaciones,
Format(ldtFinal,
msApellidos)
desde
{0}
hasta
"dd/MMM/yy"),
{1}",
_
_
"d/MMMM/yyyy"))
Console.ReadLine()
End
Sub
Public
'
crear
un
'
grabar
'
'
Console.WriteLine("Se
nuevo
los
en
ha
Sub
registro
valores
la
que
base
las
grabado
miID,
Console.ReadLine()
End
en
el
empleado:
{0}
msNombre,
CrearEmpleado()
de
datos,
debe
haber
propiedades
.......
{1}
{2}",
_
msApellidos)
Sub
Public
'
realizamos
la
'
a
un
empleado,
'
'
obtener
los
datos
del
'
y
traspasarlos
'
'
visualizamos
Console.WriteLine("Pago
Console.WriteLine("Empleado:
{0}
Console.WriteLine("Ingresado:
Console.ReadLine()
Sub
transferencia
utilizando
empleado
de
su
de
la
las
base
el
de
{1}",
{0}",
msNombre,
TransfNomina()
nmina
identificador
......
de
datos
propiedades
......
resultado
nmina")
msApellidos)
mdbSueldo)
End
Public
'
buscar
la
'
usando
Dim
'
Console.WriteLine("El
Sub
Sub
informacin
del
el
valor
lsDatosEmpleado
empleado
empleado
de
la
seleccionado
en
MostrarEmpleado()
de
datos
identificador
String
......
{0}",
msNombre,
la
base
propiedad
As
es:
msApellidos)
Console.ReadLine()
End
End
Sub
Class
Gracias a que la codificacin de todos los procesos reside ahora en la clase, el cdigo cliente que tenga que
tratar ahora con el empleado, quedara simplificado y reducido a lo que se muestra en el Cdigo fuente 219.
Module
Sub
'
Dim
loEmpleado
loEmpleado.Identificador
loEmpleado.Nombre
loEmpleado.Apellidos
'
asignar
'
'
'
llamar
loEmpleado.MostrarEmpleado()
loEmpleado.TransfNomina()
General
instanciar
As
New
=
=
=
resto
a
de
sus
Main()
objeto
Empleado()
850
"Juan"
"Garca"
propiedades
.....
.....
mtodos
'
'
.....
.....
End
End
Sub
Module
Hemos podido comprobar lo sencillo e intuitivo que resulta trabajar con determinados procesos a travs de
tcnicas OOP, ya que una vez codificada la clase, tan slo hemos de hacer uso de ella instanciando el correspondiente
objeto; con la ventaja aadida de que podemos tener varios objetos de la misma clase funcionando al mismo tiempo.
Module
General
Sub
'
Dim
loEmpleado
crear
loEmpleado
=
'
asignar
loEmpleado.Identificador
loEmpleado.Nombre
loEmpleado.Apellidos
valores
a
=
=
=
'
esta
sera
la
parte
nueva
en
'
asignar
la
fecha
de
inicio
y
'
de
vacaciones,
y
obtener
de
la
'
el
da
en
que
termina
las
'
en
este
caso,
un
formato
a
loEmpleado.InicioVacaciones
=
loEmpleado.DiasVacaciones
=
Console.WriteLine("El
empleado
{0}
{1}
{2}"
&
"finaliza
sus
loEmpleado.Identificador,
loEmpleado.Apellidos,
Main()
Empleado
Empleado
Empleado()
objeto
As
New
vacaciones
propiedades
78
"Antonio"
"Iglesias"
el
cdigo
cliente:
nmero
de
das
propiedad
FinVacaciones
vacaciones,
aplicando
la
fecha
obtenida
"20/07/2002"
15
ControlChars.CrLf
&
_
el
da
loEmpleado.Nombre,
Format(loEmpleado.FinVacaciones,
{3}",
"d-MMMM-yy"))
Console.ReadLine()
End
End
'
Sub
Module
Public
en
esta
clase
Class
creamos
3
_
_
_
propiedades
Empleado
nuevas,
'
'
para
guardar
la
los
das
fecha
y
'
'
'
Private
Private
Private
de
la
inicio
de
fecha
vacaciones,
de
fin
variables
de
mdtInicioVacaciones
mdtFinVacaciones
miDiasVacaciones
'
'
'
Public
As
As
As
procedimientos
Property
propiedad
.....
.....
Date
Date
Integer
de
InicioVacaciones()
propiedad
.....
.....
Date
As
Get
Return
End
Set(ByVal
Value
mdtInicioVacaciones
Get
Date)
As
mdtInicioVacaciones
Value
Set
Property
End
End
Public
Property
DiasVacaciones()
As
Integer
Get
Return
End
Set(ByVal
Value
miDiasVacaciones
Get
Integer)
As
miDiasVacaciones
Value
Set
Property
End
End
'
'
'
'
Public
Get
'
Return
en
realizamos
la
fecha
devolvemos
ReadOnly
calcular
la
este
el
de
dicha
Property
procedimiento
clculo
fin
de
fecha
al
FinVacaciones()
fecha
de
fin
DateAdd(DateInterval.Day,
DiasVacaciones,
de
para
vacaciones
cdigo
As
de
propiedad
obtener
y
cliente
Date
vacaciones
_
InicioVacaciones)
End
Get
Property
.....
.....
End
Class
End
'
'
Queda por lo tanto, en manos del programador, determinar el criterio por el cul un proceso se resolver
mediante una propiedad o un mtodo, debiendo ser una decisin flexible y no basarse en unas normas rgidas.
Este elemento del lenguaje nos facilita la escritura de cdigo cuando hacemos referencia a los miembros de un
objeto, ya que nos ahorra tener que escribir el nombre del objeto, siendo preciso indicar slo sus miembros. La sintaxis
de esta estructura se muestra en el Cdigo fuente 221.
With
.Campo
.Propiedad
.Mtodo()
Objeto
End
UIT
Pongamos como ejemplo, que hemos creado una clase con el nombre Empleado que tiene las propiedades
Nombre, Apellidos, y el mtodo MostrarDatos( ), para manipular un objeto de esta clase mediante With, lo haramos
como muestra el Cdigo fuente 222.
Dim
With
.Nombre
.Apellidos
.MostrarDatos()
loEmp
As
=
=
loEmp
"Ana"
"Naranjo"
Empleado
New
Empleado()
End
UIT
Podemos tambin anidar esta estructura, con el fin de manipular ms de un objeto, veamos el Cdigo fuente
223.
Dim
Dim
loEmp
loUsu
With
.Nombre
.Apellidos
.MostrarDatos()
As
Empleado = New
As
New
=
=
Empleado()
Usuario()
loEmp
"Ana"
"Naranjo"
With
.AsignarNombre("Jacinto")
End
End
Cdigo fuente 223
loUsu
With
With
La capacidad de instanciar al mismo tiempo varios objetos de la misma clase nos lleva a una interesante
cuestin: la obtencin de resultados distintos a partir de objetos del mismo tipo, cuando dichos objetos tienen datos
diferentes en sus propiedades, ya que aunque el cdigo ejecutado es el mismo, los valores de sus propiedades difieren
entre s.
Un ejemplo ilustrativo de esta situacin sera la creacin de dos objetos de la clase Empleado, en los que cada
uno tuviera fechas de comienzo y das de vacaciones distintos. En este caso, aunque los objetos son del mismo tipo, la
finalizacin de sus vacaciones sera distinta. Ver el Cdigo fuente 224.
Dim
Dim
loEmpleado1
loEmpleado2
loEmpleado1
loEmpleado2
=
As
As
New
New
Empleado
Empleado
Empleado()
Empleado()
loEmpleado1.InicioVacaciones
loEmpleado1.DiasVacaciones
loEmpleado2.InicioVacaciones
loEmpleado2.DiasVacaciones
'
'
'
'
"25/07/2002"
20
"25/07/2002"
30
Module
Sub
Dim
loEmp.piID
loEmp.Nombre
loEmp.VerDatos()
Module1
loEmp
As
New
=
"Almudena
Main()
Empleado()
980
Bosque"
Console.ReadLine()
End
Sub
End
Public
Public
Private
Module
Class
piID
As
msNombre
As
Public
Empleado
Integer
String
Property
Nombre()
As
String
Get
Return
End
Set(ByVal
Value
msNombre
msNombre
Get
String)
As
=
Value
End
Set
Property
End
Public
Sub
VerDatos()
'
utilizamos
Me
y
MyClass
en
este
mtodo
para
tomar
'
el
valor
de
la
variable
piID
que
est
en
esta
'
misma
clase,
y
para
llamar
al
mtodo
NombreMay()
'
que
tambin
est
en
la
clase
Console.WriteLine("Cdigo
del
empleado:
{0}",
Me.piID)
Console.WriteLine("Nombre
del
empleado:
{0}",
MyClass.NombreMay())
End
Public
Return
End
End
Sub
Function
NombreMay()
As
String
UCase(msNombre)
Function
Class
Como acabamos de ver, desde el cdigo de la propia clase Empleado llamamos a una variable y a un mtodo
situados tambin en la clase, anteponiendo la palabra clave Me y MyClass respectivamente.
Aunque el uso de estas palabras clave no es obligatorio, ya que el compilador reconoce el miembro que
queremos ejecutar, s es recomendable ya que facilita la lectura de nuestro cdigo.
tareas, pero todas ellas relacionadas con el sueldo del empleado. Veamos el Cdigo fuente 226.
Module
General
Sub
Dim
Dim
loEmpleado.Salario
loEmpleado
ldbResultadoIncent
Main()
Empleado()
Double
1020.82
New
As
=
'llamada
loEmpleado.Sueldo()
'llamada
Console.WriteLine("El
loEmpleado.Sueldo(29))
As
al
primer
al
sueldo
'llamada
ldbResultadoIncent
segundo
se
transferir
al
mtodo
el
sobrecargado
sobrecargado
{0}",
_
da
tercer
mtodo
loEmpleado.Sueldo(50.75,
Console.WriteLine("El
mtodo
incentivo
pagar
ser
sobrecargado
"Extras")
{0}",
ldbResultadoIncent)
Console.ReadLine()
End
End
Sub
Module
Public
Private
Class
mdbSalario
Public
Empleado
Double
As
Property
Salario()
As
Double
Get
Return
End
Set(ByVal
Value
mdbSalario
Get
Double)
As
mdbSalario
Value
Set
Property
End
End
'
Public
'
aqu
mostramos
Console.WriteLine("El
Console.ReadLine()
mtodos
Overloads
en
consola
sueldo
es
sobrecargados
Sub
el
importe
del
sueldo
{0}",
Format(Me.Salario,
Sueldo()
formateado
"#,#.##"))
End
Sub
Public
Overloads
Function
Sueldo(ByVal
liDia
As
'
aqu
mostramos
la
fecha
del
'
en
la
que
se
realizar
'
del
sueldo
al
banco
Dim
ldtFechaActual
As
Dim
lsFechaCobro
As
ldtFechaActual
=
lsFechaCobro
CStr(liDia)
&
Integer)
As
String
mes
actual
la
transferencia
del
empleado
Date
String
Now()
"/"
&
CStr(Month(ldtFechaActual))
CStr(Year(ldtFechaActual))
&
"/"
&
Return
lsFechaCobro
Function
End
Public
Overloads
Function
Sueldo(ByVal
lsTipoIncentivo
As
aqu
calculamos
la
que
se
aadir
al
en
funcin
del
ldbIncentivo
ByVal
'
'
'
Dim
'
'
'
Select
segn
se
de
Case
ldbIncentivo
Case
ldbIncentivo
End
el
la
ldbImporteIncentivo
As
String)
As
cantidad
de
sueldo
del
tipo
de
As
tipo
descuenta
cantidad
Case
de
un
del
ldbImporteIncentivo
ldbImporteIncentivo
Double,
_
Double
incentivo
empleado,
incentivo
Double
incentivo,
importe
incentivo
lsTipoIncentivo
"Viajes"
30
"Extras"
15
Select
Return
ldbIncentivo
End
Function
End
Class
Vemos pues, cmo a travs de la sobrecarga conseguimos tambin polimorfismo para una clase, ya que el
mismo nombre de mtodo, en funcin de los parmetros pasados, actuar de diferente forma.
A pesar de haber indicado que la palabra clave Overloads nos permite sobrecargar los mtodos con nombres
iguales en la clase, realmente no sera necesario su uso, ya que el compilador detecta la diferencia entre dichos
mtodos a travs de su lista de parmetros. Sin embargo se recomienda el uso de esta palabra clave por motivos de
legibilidad del cdigo, de forma que nos ayude a reconocer ms rpidamente los mtodos sobrecargados.
Cuando realmente necesitaremos emplear Overloads ser al sobrecargar un mtodo en una clase derivada,
aspecto este que se explicar en un prximo apartado.
Enlace temprano
Tambin conocido como early binding o static binding, este enlace establece que las referencias entre la
variable y el objeto que contiene van a ser resueltas en tiempo de compilacin.
El enlace temprano se realiza en el momento de declarar la variable, asignndole a esta el tipo de objeto con el
que va a trabajar. Con ello conseguimos un mejor rendimiento del programa, puesto que el cdigo generado, al
conocer de forma precisa qu propiedades y mtodos debe usar, se ejecutar de modo ms veloz. En nuestros
anteriores ejemplos con la clase Empleado, al declarar una variable de dicha clase, tenemos desde ese momento,
acceso directo a todos sus miembros. Ver Figura 194.
Adems, y como habr podido comprobar hasta ahora el lector, la escritura de cdigo mediante enlace temprano
tambin se facilita, ya que en todo momento, los asistentes del IDE muestran las listas de miembros disponibles para el
objeto que estemos codificando. Ver Figura 195
El enlace temprano, debido a su mejor rendimiento, es el tipo de enlace utilizado por defecto dentro del CLR.
Enlace tardo
Tambin conocido como late binding o dynamic binding, este enlace establece que las referencias entre la
variable y el objeto que contiene van a ser resueltas en tiempo de ejecucin.
El principal inconveniente en este tipo de enlace radica en que el cdigo generado ser ms lento, ya que
desconoce con qu miembros de objeto tendr que trabajar, debiendo averiguar esta informacin durante la ejecucin
del programa. Adicionalmente, el trabajo del programador ser tambin mayor, ya que tendr que conocer con
antelacin, la lista de miembros o interfaz que implementa el objeto.
Como ventaja nos aporta una mayor flexibilidad, ya que con la misma variable podemos manipular objetos de
distinto tipo. Para ello, tendremos que tipificar la variable como Object. Ver Figura 196.
Por ejemplo, si aparte de nuestra conocida clase Empleado, escribimos otra nueva llamada Proveedor, con
algunos aspectos similares, como las propiedades Nombre, Apellidos, el mtodo MostrarDatos( ), etc., podremos
utilizar la misma variable para manipular cada uno de los objetos que instanciemos de estas clases; evidentemente,
tendremos que asignar el objeto pertinente a la variable antes de poder manejarlo.
Vamos incluso a crear otra clase ms, llamada Horario, con un mtodo que devuelva la hora actual del sistema,
y ejecutaremos dicho mtodo asignando un objeto de esta clase a la misma variable utilizada para manejar los objetos
Empleado y Proveedor. Veamos todo en el Cdigo fuente 227.
Figura 196. Esquema de funcionamiento del enlace tardo de objetos.
Module
General
Sub
'
'
Dim
por
tipificamos
lo
que
loVariosObj
como
obtendremos
As
enlace
Main()
Object,
tardo
Object
'
instanciamos
loVariosObj
loVariosObj.Nombre
loVariosObj.Apellidos
loVariosObj.MostrarDatos()
un
objeto
New
de
=
=
'
instanciamos
loVariosObj
loVariosObj.Nombre
loVariosObj.Apellidos
loVariosObj.MostrarDatos()
un
objeto
New
de
=
=
'
instanciamos
loVariosObj
loVariosObj.HoraActual()
un
objeto
New
As
As
Empleado
String
String
End
de
Empleado
Empleado()
"Juan"
"Rollo"
Proveedor
Proveedor()
"Alicia"
"Caaveral"
Horario
Horario()
Sub
Module
End
Public
Private
Private
Class
msNombre
msApellidos
Public
Property
Nombre()
As
String
Get
Return
End
Set(ByVal
Value
msNombre
msNombre
Get
String)
As
=
Value
Set
Property
End
End
Public
Property
Apellidos()
As
String
Get
Return
End
Set(ByVal
Value
msApellidos
Get
String)
As
msApellidos
Value
Set
Property
End
End
Public
Console.WriteLine("El
msNombre,
Console.ReadLine()
End
End
Public
Private
Private
Public
Sub
empleado seleccionado
Class
msNombre
msApellidos
es:
MostrarDatos()
{0} {1}", _
msApellidos)
Sub
Class
As
As
Property
Proveedor
String
String
Nombre()
As
String
Get
Return
End
msNombre
Get
Set(ByVal
Value
As
msNombre
String)
Value
Set
Property
End
End
Public
Property
Apellidos()
As
String
Get
Return
End
Set(ByVal
Value
msApellidos
Get
String)
As
msApellidos
Value
Set
Property
End
End
Public
Console.WriteLine("El
msNombre,
Console.ReadLine()
End
End
Sub
proveedor
MostrarDatos()
{0}
{1}",
_
msApellidos)
Class
Public
Console.WriteLine("Hora
Console.ReadLine()
End
es:
Sub
Class
Public
End
actual
del
Sub
sistema:
Horario
{0}",
Format(Now(),
HoraActual()
"HH:mm"))
Sub
Class
Otro de los factores indicativos de que se est produciendo enlace tardo reside en que si depuramos este cdigo
lnea a lnea, el depurador no saltar al cdigo de los miembros de los objetos, ya que durante la compilacin no ha
podido localizar dnde se encuentra su implementacin.
De cara a prximos apartados referentes a la herencia, tengamos en cuenta la siguiente regla respecto a los tipos
de enlace.
El enlace temprano se basa en el tipo de la referencia o clase establecida al declarar la variable, mientras que el
enlace tardo se basa en el tipo del propio objeto asignado a la variable, sin tener en cuenta la clase con que haya sido
declarada la variable.
Cada vez que creamos un nuevo proyecto en VB.NET, se crea un espacio de nombres a nivel del ensamblado,
con su mismo nombre, y que engloba a todos los tipos o clases que vayamos creando. Este espacio de nombres recibe
la denominacin de espacio de nombres raz, y podemos verlo abriendo la ventana de propiedades del proyecto. Ver
Figura 197.
Figura 197. Nombre del espacio de nombres raz en las propiedades del proyecto / ensamblado.
Como muestra la imagen, tanto el ensamblado como su espacio de nombres tienen como nombre
ConsoleApplication1, por lo que todas las clases que escribamos dentro de este proyecto estarn dentro de dicho
espacio de nombres.
Vamos a ir construyendo progresivamente un ejemplo, para ver las variantes de uso de clases en funcin del
espacio de nombres en el que estn contenidas. Crearemos para ello una nueva aplicacin de consola, y en el fichero
de cdigo que incluye por defecto, adems del mdulo Module1 ya incluido al crearse el proyecto, escribiremos la
clase Factura, ver Cdigo fuente 228.
Module
Sub
'
como
'
en
'
Dim
loFac.piID
loFac.piImporte
loFac.Datos()
Console.ReadLine()
End
End
Module1
la
el
loFac
Factura
de
se
nombres
New
=
=
Main()
encuentra
raz,
normalmente
Factura()
5
200
Sub
Module
'
'
esta
clase
'
del
espacio
de
Public
Public
Public
clase
espacio
instanciamos
As
clase
se
nombres
Class
encuentra
raz
del
Factura
dentro
ensamblado
Factura
piID
piImporte
As
As
Integer
Integer
Public
Sub
Datos()
Console.WriteLine("La factura {0}, tiene un importe de {1}",
_
Me.piID,
Me.piImporte)
End
Sub
End
Class
Seguidamente, y en el mismo fichero de cdigo, creamos la clase Empleado, pero la incluimos en el espacio de
nombres Personal. Para crear un espacio de nombres en el cdigo de la aplicacin debemos utilizar las palabras clave
Namespace...End Namespace. Ver Cdigo fuente 229.
'
clase
Empleado
'
esta
clase
se
encuentra
dentro
'
del
espacio
de
nombres
raz
del
ensamblado,
'
y
a
su
vez,
dentro
del
espacio
de
'
nombres
Personal
Namespace
Personal
Public
Public
Class
psID
Public
Console.WriteLine("Identificador
Console.ReadLine()
Empleado
Integer
As
Sub
del
empleado:
{0}",
MostrarDatos()
Me.psID)
End
End
End
Sub
Class
Namespace
Debido a que hemos creado una clase dentro de un nuevo espacio de nombres definido en el cdigo, dicho
espacio de nombres queda anidado dentro del espacio de nombres raz del ensamblado. Para instanciar objetos de una
clase escrita en un espacio de nombres de esta forma, en primer lugar, debemos importar dicho espacio de nombres en
la cabecera del fichero de cdigo, utilizando la palabra clave Imports, como se muestra en el Cdigo fuente 230.
Module
Module1
Sub
'
como
hemos
importado
'
podemos
instanciar
un
Dim
loEmp
loEmp
=
loEmp.piID
loEmp.MostrarDatos()
el
espacio
objeto
de
As
New
=
de
su
nombres
clase
Main()
Personal
Empleado
Empleado
Empleado()
5
Console.ReadLine()
End
End
Sub
Module
Cdigo fuente 230
Si no utilizamos Imports, tambin podemos instanciar objetos de clases halladas en espacios de nombres
distintos, utilizando en este caso la sintaxis calificada, es decir, escribimos en primer lugar el espacio de nombres, un
punto y la clase. El inconveniente de esta forma de codificacin, reside en que cada vez que declaremos e instanciemos
un objeto tenemos que emplear esta sintaxis calificada, por lo cul, es mucho ms cmodo importar el espacio de
nombres al comienzo del fichero. Ver Cdigo fuente 231.
Dim
loEmp
As
Personal.Empleado
loEmp
New
Personal.Empleado()
Finalmente, vamos a agregar una nueva clase al proyecto, a la que daremos el nombre GESTION.VB. Sin
embargo no utilizaremos la clase que crea por defecto, borraremos todo el cdigo de ese fichero y escribiremos dos
nuevas clases en l: Cuenta y Balance, que adems, estarn contenidas en el espacio de nombres Contabilidad. De esta
forma queda demostrado como podemos organizar nuestro cdigo, adems de en clases, en espacios de nombre que
contengan clases con funcionalidades similares. Ver Cdigo fuente 232.
Namespace
Public
Public
Contabilidad
Cuenta
Integer
Class
piCodigo
Public
Return
End
As
Function
Obtener()
As
Integer
Me.piCodigo
Function
End
Class
Public
Public
Class
psDescripcion
Public
Console.WriteLine("La
Me.psDescripcion)
Console.ReadLine()
End
End
End
Sub
descripcin
del
Balance
String
As
MostrarDescrip()
balance es: {0}",
Sub
Class
Namespace
El modo de instanciar, desde Main( ), objetos de las clases del espacio de nombres Contabilidad, es exactamente
el mismo que hemos descrito para el espacio de nombres Personal: bien importamos el espacio de nombres, o
empleamos los nombres calificados. Veamos el Cdigo fuente 233.
Imports
ConsoleApplication1.Contabilidad
Module
Module1
Sub
'
Dim
Dim
loCuen.piCodigo
liDatoCuenta
'
'
'
Dim
instanciamos
loCuen
As
liDatoCuenta
al
podemos
de
con
sintaxis
New
As
=
haber
importado
instanciar
la
loBal
el
espacio
usando
clase
As
Main()
calificada
Contabilidad.Cuenta()
Integer
158
loCuen.Obtener()
de
el
nombres
nombre
directamente
Balance
loBal
loBal.psDescripcion
loBal.MostrarDescrip()
New
"Resultado
Balance()
trimestral"
Console.ReadLine()
End
End
Sub
Module
Cdigo fuente 233
Una cualidad muy de agradecer cuando escribimos clases dentro de espacios de nombre, reside en que podemos
tener las clases de un mismo espacio de nombres diseminadas por todo el cdigo de la aplicacin. Por ejemplo, en el
mdulo Module1 hemos definido el espacio de nombres Personal, y creado en su interior la clase Empleado; pues
bien, si aadimos otra clase al proyecto, podemos incluir tambin esta clase en el espacio de nombres Personal, a pesar
de que dicho cdigo se encuentre en otro fichero distinto. Ver Cdigo fuente 234.
Namespace
Public
Public
Public
Public
Console.WriteLine("El
"
{0}
y
la
End
End
Personal
Class
psID
psDescrip
Sub
proveedor
tiene
descripcin
{1}",
As
As
Proveedor
Integer
String
MuestraProv()
el
cdigo"
&
_
Me.psID,
Me.psDescrip)
Sub
Class
End
Namespace
Cuando importemos el espacio de nombres Personal, todas las clases que contiene pasarn a estar disponibles,
con independencia del fichero de cdigo que las contenga.
Al agregar un proyecto de este tipo a la solucin, la ventana Explorador de soluciones muestra ambos proyectos,
remarcando en negrita el nombre del proyecto AppVariosProy como el proyecto de inicio, puesto que el nuevo que
acabamos de agregar, slo contendr clases que sern utilizadas por otros ensamblados.
Un proyecto de biblioteca de clases aade por defecto una clase con el nombre Class1, cuyo cdigo
eliminaremos y lo sustituiremos por el mostrado en el Cdigo fuente 235, que como podr comprobar el lector, se trata
de dos clases, con la particularidad de que una de ellas est a su vez, contenida en un espacio de nombres.
Public
Class
Public
piID
As
Public
piImporte
As
Public
Sub
Console.WriteLine("La
Me.piID,
End
End
Namespace
Public
Public
Public
Public
Factura
Integer
Integer
Datos()
factura
{0},
tiene
un
importe
de
{1}",
_
Me.piImporte)
Sub
Class
Correo
Class
psTexto
pdtFecha
Console.WriteLine("Atencin,
{1}",
Me.psTexto,
End
End
End
As
As
Sub
mensaje:
{0},
Mensaje
String
Date
Visualizar()
de
fecha:
_
Me.pdtFecha)
Sub
Class
Namespace
Sin embargo, todava no podemos hacer uso de estas clases desde nuestra aplicacin de consola, para lograr que
las clases del proyecto Adicional sean visibles desde el proyecto AppVariosProy, debemos hacer clic sobre este ltimo
en el Explorador de soluciones, y a continuacin seleccionar el men Proyecto + Agregar referencia; en el cuadro de
dilogo que aparece seguidamente, haremos clic en la pestaa Proyectos, seleccionando el nico proyecto que muestra
la lista, y que se trata de la biblioteca de clases que hemos aadido a la solucin. Ver Figura 199.
Completadas todas estas operaciones, pasaremos al fichero de cdigo del proyecto de consola, y dado que
vamos a utilizar las clases contenidas en un ensamblado distinto del que estamos posicionados, debemos importar los
espacio de nombres del ensamblado; tanto su espacio raz, como el que hemos creado manualmente. De forma
adicional, hemos aadido una clase a continuacin de Main( ) para demostrar como para instanciar dicha clase, al estar
en el espacio de nombres raz del proyecto de consola, no es necesario realizar ninguna importacin, veamos el Cdigo
fuente 236.
'
'
'
importamos
el
namespace
Adicional,
este
namespace
es
el
raz
del
proyecto
de
biblioteca
de
clases
y
'
nos
servir
'
Factura
Imports
para
del
acceder
a
proyecto
la
clase
Adicional
Adicional
'
por
otro
lado
importamos
el
namespace
'
Adicional.Correo
que
nos
permitir
'
acceder
a
la
clase
Mensaje,
que
tambin
'
est
en
la
biblioteca
de
clases
Imports
Adicional.Correo
Module
Module1
Sub
Dim
loEmp
loEmp.psID
loEmp.MostrarDatos()
Dim
loFac.piID
loFac.piImporte
loFac.Datos()
loFac
Dim
loMsg.psTexto
loMsg.pdtFecha
loMsg.Visualizar()
loMsg
As
Main()
Empleado()
254
New
=
As
New
Factura()
785
1200
New
Mensaje()
mundo"
Today
=
=
As
=
"Hola
=
Console.ReadLine()
End
End
Sub
Module
Public
Public
psID
Class
As
Empleado
Integer
Public
Console.WriteLine("Identificador
Console.ReadLine()
End
End
Sub
del
empleado:
{0}",
MostrarDatos()
Me.psID)
Sub
Class
Cuando ejecutemos el programa depurando lnea a lnea, comprobaremos como el flujo de la aplicacin pasa al
cdigo de la biblioteca de clases al instanciar sus objetos.
Constructores
Mtodos constructores
herencia
El primer mtodo que es ejecutado al instanciar un objeto de la clase se denomina constructor. Este tipo de
mtodo resulta til para tareas de configuracin iniciales sobre el objeto.
No es necesario escribir un mtodo constructor en la clase, ya que en el caso de que no exista, el compilador se
encarga de crearlo implcitamente.
Para escribir nuestros propios constructores de clase, crearemos un mtodo con el nombre New( ), como vemos
en el Cdigo fuente 237. En dicho ejemplo, al instanciarse un objeto de la clase Empleado, se asignar a una de sus
propiedades la fecha actual.
Module
General
Sub
Dim
loEmp
Console.WriteLine("El
Console.ReadLine()
End
Class
mdtFechaCrea
Public
Get
Return
As
Property
creado
{0}",
Main()
Empleado
Empleado()
loEmp.FechaCrea)
Empleado
Date
FechaCrea()
As
Date
mdtFechaCrea
End
Set(ByVal
mdtFechaCrea
End
End
Value
Get
Date)
Value
Set
Property
As
=
'
Public
'
'
Me.FechaCrea
ha
As
New
el
da
Sub
Module
End
Public
Private
loEmp
=
objeto
se
mtodo
constructor
Sub
asignamos
a
End
End
un
una
valor
de
variable
=
New()
inicial
propiedad
Now
Sub
Class
Al igual que ocurre en un mtodo normal, New( ) admite parmetros; esto nos sirve para asignar valores de
inicio al objeto en el momento de su instanciacin. La denominacin para este tipo de mtodos es constructor
parametrizado. El Cdigo fuente 238 nos muestra una variacin del fuente anterior, utilizando un constructor de este
tipo.
Module
General
Sub
Dim
loEmp
loEmp
=
As
New
Main()
Empleado
Empleado("5/7/2002")
Console.WriteLine("El
Console.ReadLine()
'
'
Dim
objeto
este
un
se
es
End
Sub
Module
Public
Private
Class
creado
el
otro
objeto
loEmp2
End
ha
con
As
da
{0}",
loEmp.FechaCrea)
modo
de
instanciar
constructor
parametrizado
New
Empleado("08/4/2002")
un
Empleado
mdtFechaCrea
Public
Property
FechaCrea()
As
Date
Get
Return
End
Set(ByVal
Value
mdtFechaCrea
Get
Date)
As
mdtFechaCrea
Value
Set
Property
End
End
'
mtodo
Public
'
'
Me.FechaCrea
Sub
asignamos
a
End
constructor
New(ByVal
el
una
con
ldtFecha
parmetro
As
valor
variable
=
Date)
parmetro
propiedad
ldtFecha
del
de
Sub
Class
End
Cdigo fuente 238
Combinando las caractersticas de mtodos constructores junto a las de sobrecarga, podemos crear un conjunto
de constructores sobrecargados para la clase. Ver el Cdigo fuente 239.
Public
Public
Public
Public
Private
Class
'
'
Public
Empleado
psNombre
psApellidos
psCiudad
mdtFechaCrea
en
asignamos
este
constructor
la
Sub
mdtFechaCrea
sin
fecha
parmetros,
actual
New()
Now()
Sub
End
'
'
Public
en
a
ByVal
psNombre
psApellidos
este
todos
Sub
lsApellidos
los
New(ByVal
As
constructor,
campos
lsNombre
String,
ByVal
=
=
asignamos
de
As
lsCiudad
la
String,
valores
clase
_
As
String)
lsNombre
lsApellidos
psCiudad
End
lsCiudad
Sub
Class
End
Cdigo fuente 239
Herencia
Este es uno de los aspectos ms importantes, sino el ms importante, en un lenguaje orientado a objetos.
VB.NET es la primera versin de este lenguaje que incorpora herencia, una caracterstica demandada por un amplio
colectivo de los programadores de esta herramienta; y es que, a pesar de haber sido incorporados progresivamente
aspectos de orientacin a objetos al lenguaje, este era el elemento fundamental que faltaba para ser plenamente OOP.
Empleando la herencia podemos crear una clase base o padre, con especificaciones generales, y a partir de ella,
crear nuevas clases derivadas o hijas.
En el momento de declarar una clase derivada, y sin haber escrito ms cdigo, ya tenemos acceso a todos los
miembros de la clase base; posteriormente, podemos escribir cdigo adicional en la clase derivada para ampliar sus
funcionalidades.
Una clase hija puede servir a su vez como clase base para la creacin de otra clase derivada, y as
sucesivamente, con lo que podemos componer nuestra propia jerarqua con la estructura de clases que necesitemos.
Para crear una clase derivada, debemos declarar una nueva clase, especificando cul es su clase base mediante la
palabra clave Inherits. En el Cdigo fuente 240 se muestran los dos modos disponibles de crear una clase heredada.
'
Public
crear
clase derivada
Class
Inherits
'
crear
clase
derivada
Public
Class
Administrativo
en dos lneas
Administrativo
en
:
Empleado
la
misma
lnea
Inherits
Empleado
Una vez que creemos la clase derivada, tendremos a nuestra disposicin todos los elementos de la clase base,
tanto desde la propia clase, como desde el cdigo cliente.
Por ejemplo, supongamos que se nos plantea la necesidad de crear un tipo de empleado, con caractersticas ms
especializadas de las que ahora tiene nuestra clase Empleado. Podemos optar por modificar toda la implementacin ya
existente para la clase Empleado, lo que afectara al cdigo cliente que ya utiliza dicha clase, y seguramente de forma
negativa; o bien, podemos crear una nueva clase, que herede de Empleado, y en la que definiramos el comportamiento
de este nuevo tipo de empleado. A esta nueva clase le daremos el nombre Administrativo, y su cdigo podemos verlo
en el Cdigo fuente 241.
Public
Inherits
Class
Administrativo
Empleado
Public
Sub
EnviarCorreo(ByVal
Console.WriteLine("Remitente
lsMensaje
del
mensaje:
As
String)
{0}
{1}",
Me.Nombre,
Me.Apellidos)
Console.WriteLine("Texto
del
mensaje:
{0}",
lsMensaje)
Console.ReadLine()
End
Sub
End
Class
Observemos en el nico mtodo de esta clase, que estamos haciendo referencia a las propiedades Nombre y
Apellidos; al heredar de Empleado, no ha sido necesario crear de nuevo dichas propiedades, estamos reutilizando las
existentes en la clase base.
De igual modo sucede al instanciar un objeto de la clase, como vemos en el Cdigo fuente 242, hemos creado
un objeto Administrativo, y estamos haciendo uso tanto del nuevo mtodo que tiene dicho objeto, como de todos los
pertenecientes a su clase padre.
Module
General
Sub
'
Main()
instanciamos
Dim
'
un
objeto
loAdmin
accedemos
de
la
As
los
New
miembros
loAdmin.Nombre
clase
de
Administrativo()
la
clase
loAdmin.Apellidos
derivada
padre
"Almudena"
"Cerro"
loAdmin.MostrarDatos()
'
ahora
accedemos
loAdmin.EnviarCorreo("Acabo
End
End
los
miembros
de
de
esta
propia
clase
llegar")
Sub
Module
'
Public
declaracin
'
Public
Inherits
normal
declaracin
(se hereda
Class
implcitamente
heredando
Class
de
Object)
Empleado
explcitamente
de
Object
Empleado
System.Object
Module
General
Sub
Dim
loUsu
loUsu
=
'
accedemos
al
loUsu.AsignarNombre("Daniel")
As
New
pblico
mtodo
del
Main()
Usuario
Usuario()
objeto
End
Sub
End
Module
Public
Class
Usuario
'
esta
variable
slo
es
accesible
'
por
el
cdigo
de
la
propia
clase
Private
msNombre
As
String
'
Public
msNombre
End
End
este
Sub
Public
Inherits
mtodo
es
accesible
AsignarNombre(ByVal
=
Class
desde
lsValor
cualquier
As
punto
String)
lsValor
Sub
Class
Operador
Usuario
Public
'
accedemos
'
de
Me.AsignarNombre("Alfredo")
Sub
a
un
la
mtodo
clase
New()
pblico
base
End
End
Sub
Class
En el anterior fuente, la variable msNombre de la clase Usuario, declarada privada a nivel de clase, slo es
manipulada por los mtodos de la propia clase. Por otro lado, el mtodo AsignarNombre( ), al declararse pblico, es
utilizado desde clases heredades y cdigo cliente.
Adems de estas normas, ya conocidas, disponemos de los modificadores descritos en los siguientes apartados,
diseados para resolver problemas concretos de mbito entre clases.
Protected
Un miembro de clase declarado con este modificador, ser accesible desde el cdigo de su propia clase y desde
cualquier clase heredada. El Cdigo fuente 245 muestra un ejemplo del uso de Protected
Module
Module1
Sub
'
con
una
'
no
'
Dim
loEmp
loEmp.psNombre
instancia
podemos
del
objeto
acceder
que
Empleado
ya
As
Empleado
al
es
=
"Pedro
Dim
loAdmin
loAdmin.piID
loAdmin.psNombre
loAdmin.pdtFecha
loAdmin.AsignarDNI("11223344")
loAdmin.DatosAdmin()
As
New
New
Administrativo()
567
Iglesias"
"5/9/2002"
=
=
Main()
Administrativo
VerFecha()
Protected
Empleado()
Peral"
o
mtodo
"Juan
=
Console.Read()
End
End
Sub
Module
Public
Class
Public
psNombre
Public
pdtFecha
'
los
'
dentro
Protected
As
As
dos
de
esta
Empleado
String
Date
siguientes
clase
psDNI
Protected
Return
End
End
slo
sus
As
sern
clases
Function
Public
Sub
'
desde
aqu
'
Protected
Me.psDNI
End
miembros
o
en
Sub
Class
AsignarDNI(ByVal
tenemos
declarada
=
visibles
derivadas
String
VerFecha()
pdtFecha
Function
lsDNI
acceso
en
As
la
la
String)
variable
clase
lsDNI
Public
Inherits
Class
Administrativo
Empleado
Public
piID
Public
Console.WriteLine("Datos
Console.WriteLine("Identificador:
Console.WriteLine("Nombre:
'
desde
esta
clase
'
a
lo
miembtos
As
Integer
Sub
DatosAdmin()
administrativo")
Me.piID)
Me.psNombre)
tenemos
acceso
clase
padre
del
{0}",
{0}",
derivada
Protected
Console.WriteLine("Fecha:
Console.WriteLine("DNI:
End
End
s
de
la
{0}",
{0}",
Me.VerFecha())
Me.psDNI)
Sub
Class
Friend
Un miembro de clase declarado con este modificador, ser accesible por todo el cdigo de su proyecto
o ensamblado.
Para poder comprobar el comportamiento utilizando el mbito friend, debemos crear una solucin formada por
un proyecto de tipo consola y uno de biblioteca de clases; en este ltimo escribimos una clase definiendo alguno de sus
miembros con este modificador, como vemos en el Cdigo fuente 246.
Public
Public
Private
'
'
'
Friend
Class
piID
As
msNombre
As
esta
accesible
dentro
Public
Empleado
Integer
String
variable
por
de
mdbSueldo
slo
tipos
puede
que
este
As
Property
Nombre()
ser
estn
ensamblado
Double
As
String
Get
Return
End
Set(ByVal
msNombre
Value
As
=
Value
Set
Property
End
End
Public
Console.WriteLine("Datos
Console.WriteLine("Cdigo:
Console.WriteLine("Nombre:
Console.WriteLine("Sueldo:
msNombre
Get
String)
Sub
del
{0}",
{0}",
{0}",
VerDatos()
empleado")
Me.piID)
Me.msNombre)
Me.mdbSueldo)
End
Sub
End
Class
Public
Public
Dim
loEmp.piID
loEmp.Nombre
Class
loEmp
Plantilla
Sub
Empleado
As
New
Analizar()
Empleado()
50
Perea"
podemos
del
mismo
acceder
objeto
ensamblado
450
=
=
'
desde
'
al
'
Empleado,
loEmp.mdbSueldo
loEmp.VerDatos()
End
ya
"Francisco
esta
miembro
que
clase
mdbSueldo
estamos
en
=
el
Sub
Class
End
Cdigo fuente 246
A continuacin, agregamos una referencia desde el proyecto de consola hacia el proyecto de biblioteca de
clases, y en el mdulo de cdigo, importamos el espacio de nombres del ensamblado correspondiente a la biblioteca de
clases, escribiendo despus en Main( ), cdigo que interacte con un objeto de la clase Empleado, comprobaremos
cmo no es posible manipular los miembros friend del objeto Empleado. Ver Cdigo fuente 247.
Imports
ClassLibrary1
Module
Sub
Dim
loEmplea
'
al
'
desde
'
'
As
acceder
este
el
Empleado
las
miembro
no
del
est
mdbSueldo
Friend
objeto
disponible
ya
en
loEmplea.piID
loEmplea.Nombre
New
propiedades
proyecto,
como
Module1
Main()
Empleado()
que
la
clase
=
=
est
declarado
Empleado
70
"Alicia
Mar"
loEmplea.VerDatos()
Console.Read()
End
End
Sub
Module
Aunque hemos descrito su modo de manejo a travs de clases, la palabra clave Friend tambin puede ser
utilizada como modificador de mbito para variables y procedimientos situados en mdulos de cdigo.
Protected Friend
Los miembros de clase declarados al mismo tiempo con Protected y Friend, obtendrn una combinacin de
ambos modificadores; por lo tanto, sern accesibles desde el cdigo de su clase, clases derivadas, y por todo el cdigo
que se encuentre dentro de su ensamblado.
Module
Module1
Sub
Dim
Main()
loEmp
As
Empleado
loEmp.psNombre
New
Empleado()
"Ana
loEmp.piSalario
loEmp.CalcularIncentivos()
loEmp.VerIncentivos()
Gmez"
Dim
loAdmin
loAdmin.psNombre
loAdmin.piSalario
loAdmin.CalcularIncentivos(10)
loAdmin.VerIncentivos()
As
2000
New
"Jorge
Administrativo()
Peral"
1600
Console.ReadLine()
End
End
Sub
Module
Public
Class
Public
piID
As
Public
psNombre
As
Public
piSalario
As
Public
piIncentivos
As
'
'
Public
calcular
Me.piIncentivos
End
Empleado
Integer
String
Integer
Integer
los
incentivos
al
Sub
=
Me.piSalario
en
base
salario
CalcularIncentivos()
/
10
Sub
Public
Console.WriteLine("Los
Me.psNombre,
End
End
Sub
incentivos
Public
Inherits
Administrativo
Empleado
Class
de
{0}
VerIncentivos()
son
{1}",
_
Me.piIncentivos)
Sub
Class
'
calcular
los
incentivos
en
base
a
horas
Public Overloads Sub CalcularIncentivos(ByVal liHoras As Integer)
Me.piIncentivos
=
liHoras
*
15
End
Sub
End
Class
Hemos de aclarar que si no utilizramos la palabra clave Overloads en la subclase, el programa tambin se
ejecutara, pero obtendramos un aviso del compilador advirtindonos de la situacin. Este mensaje lo podemos ver
utilizando la ventana Lista de tareas, que emplea el IDE para mostrar los errores y avisos del compilador. Ver Figura
200.
Figura 200. Lista de tareas y editor de cdigo mostrando aviso del compilador.
Public
Inherits
Class
Administrativo
Empleado
Public
Overloads
'
llamamos
a
'
en
primer
'
de
MyBase.CalcularIncentivos()
'
despus
Sub
la
lugar
CalcularIncentivos(ByVal
liHoras
clase
base
con
MyBase
los
mismos
clculos
la
clase
se
hacen
'
End
Cdigo fuente 249
de
clculos
propios
esta
Me.piIncentivos
End
los
As
para
Sub
Class
+=
Integer)
hacer
incentivos
Empleado
de
clase
liHoras
15
Al utilizar MyBase, no es obligatorio llamar desde el mtodo en la clase hija, a su misma versin en la clase
padre; podramos perfectamente en el ejemplo anterior, haber llamado desde el mtodo CalcularIncentivos( ) de la
clase Administrativo, al mtodo VerIncentivos( ) de la clase Empleado, todo depende de los requerimientos del diseo
de la clase. Ver Cdigo fuente 250.
MyBase.VerIncentivos()
Module
Module1
Sub
Dim
loEmp.piID
loEmp.Nombre
loEmp.VerDatos()
loEmp
As
Main()
Empleado()
50
casas"
New
=
"juan
Console.WriteLine()
Dim
loAdmin.piID
loAdmin.Nombre
loAdmin.VerDatos()
loAdmin
As
New
Administrativo()
129
redondo"
=
=
"elena
Console.ReadLine()
End
End
Sub
Module
Public
Public
Private
Public
Class
piID
As
msNombre
As
Property
Empleado
Integer
String
Nombre()
As
String
Get
Return
End
Set(ByVal
Value
msNombre
Get
String)
As
msNombre
Value
Set
Property
End
End
'
marcamos
el
mtodo
Public
Overridable
Console.WriteLine("Datos
del
Me.piID,
End
End
como
rescribible
Sub
empleado:
Public
Class
Administrativo
:
'
rescribimos
este
mtodo
totalmente
Public
Overrides
Sub
Console.WriteLine("Datos
Console.WriteLine("==================")
Console.WriteLine("Cdigo:
Console.WriteLine("Nombre:
End
End
con
Overridable
VerDatos()
{0}-{1}",
_
Me.Nombre)
Sub
Class
Inherits
usando
Empleado
Overrides
VerDatos()
del
empleado")
{0}",
{0}",
Me.piID)
UCase(Me.Nombre))
Sub
Class
Pero, qu sucede si queremos utilizar la implementacin del mtodo base en la clase derivada?, pues slo
necesitamos llamar al mtodo de la clase padre usando la palabra clave MyBase.
Para ilustrar esta situacin, aadiremos a la clase Empleado la propiedad Salario, y un mtodo para calcularlo,
de modo que todos los empleados tengan inicialmente el mismo salario, sin embargo, los administrativos necesitan un
pequeo incremento. Para no tener que volver a realizar el clculo en la clase Administrativo, vamos a aprovechar el
clculo que ya se realiza en la clase padre, aadiendo slo las operaciones particulares que necesitemos. Vemoslo en
el Cdigo fuente 252.
Module
Sub
Dim
loEmp
loEmp.piID
loEmp.Nombre
loEmp.VerDatos()
loEmp.CalcularSalario()
Console.WriteLine("Salario
Module1
As
New
=
"juan
{0}",
Main()
Empleado()
50
casas"
loEmp.Salario)
Console.WriteLine()
Dim
loAdmin
loAdmin.piID
loAdmin.Nombre
loAdmin.VerDatos()
loAdmin.CalcularSalario()
Console.WriteLine("Salario
As
New
=
"elena
{0}",
Administrativo()
129
redondo"
loAdmin.Salario)
Console.ReadLine()
End
End
Sub
Module
Public
Class
'......
'......
Public
miSalario
Public
Empleado
As
Integer
Property
Salario()
As
Integer
Get
Return
End
Set(ByVal
Value
miSalario
As
=
Value
Set
Property
End
End
Public
miSalario
Get
Integer)
Overridable
Sub
Me.Salario
End
'......
'......
CalcularSalario()
800
Sub
End
Public
'......
'......
Public
Class
Class
Administrativo
Overrides
Sub
'
utilizamos
MyBase.CalcularSalario()
Me.Salario
End
Inherits
Empleado
CalcularSalario()
el
mtodo
de
la
clase
+=
base
50
Sub
Class
End
Cdigo fuente 252
Debido a cuestiones de diseo, en algunas ocasiones precisaremos que al mismo tiempo que sobrescribimos un
miembro dentro de una clase heredada, dicho miembro no pueda ser sobrescrito por las clases que hereden de esta. En
estas situaciones, al declarar el miembro, usaremos la palabra clave NotOverridable.
Volvamos pues, al ejemplo de la clase Administrativo, en el que sobrescribamos el mtodo VerDatos(). Si
cambiamos la declaracin de dicho mtodo por la mostrada en el Cdigo fuente 253, una tercera clase Directivo, que
heredase de Administrativo, no podra sobrescribir el mencionado mtodo.
Public
'
'
'
Public
Class
rescribimos
e
impedimos
Administrativo
este
que
mtodo
:
totalmente
pueda
ser
derivadas
NotOverridable
Inherits
usando
rescrito
de
Overrides
Empleado
Overrides
por
clases
esta
Sub
VerDatos()
Console.WriteLine("Datos
del
empleado")
Console.WriteLine("==================")
Console.WriteLine("Cdigo:
{0}",
Console.WriteLine("Nombre:
End
Me.piID)
{0}",
UCase(Me.Nombre))
Sub
Class
End
Public
Class
'
se
produce
'
ya
que
Directivo
un
la
Public
error,
clase
no
:
se
Inherits
puede
Administrativo
lo
Overrides
Administrativo
sobrescribir
impide
Sub
'.....
'.....
End
End
con
este
mtodo
NotOverridable
VerDatos()
Sub
Class
No podemos utilizar NotOverridable en mtodos de una clase base, ya que la misin de este modificador es
impedir la sobre-escritura de miembros en clases derivadas, pero desde una clase que a su vez tambin ha sido
derivada desde la clase base. Si no queremos, en una clase base, que un mtodo pueda ser sobrescrito, simplemente no
utilizamos en su declaracin la palabra clave Overridable.
Module
Sub
Dim
loPersona
loPersona.psNombre
loPersona.pdtFHAlta
Module1
Main()
loPersona
=
=
As
New
"Juan
=
Empleado
Administrativo()
Garca"
"15/1/2002"
'
como
la
sobrecarga
'
se
basa
en
el
tipo
'
en
el
objeto
que
se
'
por
ello
slo
es
'
del
mtodo
que
hay
loPersona.VerAlta()
'
si
intentamos
ejecutar
'
que
recibe
una
cadena,
se
'
"Demasiados
argumentos
para
loPersona.VerAlta("Mes")
'
Console.ReadLine()
End
End
utiliza
de
la
asigna
visible
en
la
el
producir
'Public
enlace
variable
a
esa
la
clase
temprano,
y
no
variable,
implementacin
Empleado
mtodo
VerAlta()
siguiente
error:
Sub
VerAlta()'."
<-error
el
Sub
Module
Public
Class
Public
psNombre
Public
pdtFHAlta
As
As
Empleado
String
Date
'
mostrar
la
fecha
de
Public
Sub
Console.WriteLine("El empleado {0} se
Me.psNombre,
End
End
alta
End
Inherits
Empleado
la
fecha
de
alta
parmetro
pasado
lsParteFecha
As
String)
As
String
lsParteFecha
"Mes"
"MMMM")
"DiaSemana"
Format(Me.pdtFHAlta,
lsValorFecha
End
Console.WriteLine("Empleado
Console.WriteLine("Incorporado
End
lsValorFecha
Case
=
completo
VerAlta()
el {1}", _
Me.pdtFHAlta)
Sub
Class
incorpor
Public
Class
Administrativo
'
mostrar
slo
una
parte
de
'
segn
el
Public
Overloads
Sub
VerAlta(ByVal
Dim
Select
Case
lsValorFecha
Case
al
Format(Me.pdtFHAlta,
{0}",
{0}",
"dddd")
Select
Me.psNombre)
lsValorFecha)
Sub
Class
Module
Sub
Dim
loPersona
loPersona.psNombre
'
como
'
se
basa
Module1
loPersona
=
la
en
=
sobre-escritura
el
objeto
As
New
que
"Juan
utiliza
contiene
Main()
Empleado
Administrativo()
Garca"
enlace
tardo,
la
variable
y
'
'
no
en
la
el
versin
tipo
de
del
'
en
la
clase
'
que
contiene
'
instancia
loPersona.MostrarNombre()
Console.ReadLine()
End
End
As
As
Public
Overridable
Console.WriteLine("El
nombre
Me.psNombre)
End
End
End
la
variable,
MostrarNombre()
Administrativo,
variable
ya
que
loPersona
de
se
que
ejecuta
est
el
objeto
es
una
Administrativo
Class
Empleado
String
Date
del
Sub
empleado
MostrarNombre()
es
{0}",
_
Sub
Class
Administrativo
Public
Overrides
Console.WriteLine("Nombre
Console.WriteLine("===================")
Console.WriteLine(UCase(Me.psNombre))
End
de
Sub
Module
Public
Class
Public
psNombre
Public
pdtFHAlta
Public
la
dato
mtodo
:
Sub
del
Inherits
Empleado
MostrarNombre()
empleado")
Sub
Class
La Tabla 25 muestra, al utilizar sobre-escritura, la clase de la cul ser ejecutado el mtodo, en funcin de la
referencia de la variable y el tipo de objeto.
Debido al hecho de que los miembros sobrescritos emplean enlace tardo, otra de las denominaciones que se
utiliza para ellos es la de mtodo virtual.
Module
Module1
Sub
Dim
Dim
Dim
loAdmin.Salario
ldbImporte
loAdmin
As
ldbImporte
lsFecha
=
loAdmin.Sueldo(80,
'
los
'
desde
este
loAdmin.Sueldo()
lsFecha
objeto
Main()
Administrativo()
Double
String
925.86
"Viajes")
New
As
As
siguientes
y
se
mtodos
produce
un
estn
error
ocultos
llamarlos
al
loAdmin.Sueldo(5)
End
Sub
End
Module
Public
Private
Class
mdbSalario
Public
Empleado
Double
As
Property
Salario()
As
Double
Get
Return
End
Set(ByVal
Value
mdbSalario
Get
Double)
As
mdbSalario
Value
Set
Property
End
End
'
mtodos
Public
'
aqu
mostramos
Console.WriteLine("El
Console.ReadLine()
Overloads
en
consola
sueldo
es
sobrecargados
Sub
el
importe
del
sueldo
{0}",
Format(Me.Salario,
Sueldo()
formateado
"#,#.##"))
End
Sub
Public
Overloads
Function
Sueldo(ByVal
liDia
As
'
aqu
mostramos
la
fecha
del
'
en
la
que
se
realizar
'
del
sueldo
al
banco
Dim
ldtFechaActual
As
Dim
lsFechaCobro
As
ldtFechaActual
=
lsFechaCobro
=
CStr(Month(ldtFechaActual))
CStr(Year(ldtFechaActual))
CStr(liDia)
&
Return
"/"
As
String
actual
transferencia
empleado
Date
String
Now()
&
&
lsFechaCobro
Function
Class
End
End
Public
Inherits
&
"/"
Integer)
mes
la
del
Class
Administrativo
Empleado
_
_
'
'
Public
este
de
Shadows
mtodo
Function
ByVal
'
'
lsTipoIncentivo
calculamos
se
aadir
aqu
que
'
en
As
la
segn
se
de
el
la
Case
ldbIncentivo
Case
ldbIncentivo
End
String)
cantidad
sueldo
al
funcin
ldbIncentivo
Dim
'
'
'
Select
ensombrece/oculta
a
los
clase
base
Sueldo(ByVal
ldbImporteIncentivo
As
la
del
tipo
As
tipo
descuenta
cantidad
Case
de
un
del
ldbImporteIncentivo
ldbImporteIncentivo
sobrecargados
Empleado
Double,
_
As
de
del
Double
incentivo
empleado,
de
incentivo
Double
incentivo,
importe
incentivo
lsTipoIncentivo
"Viajes"
30
"Extras"
15
Select
Return
ldbIncentivo
Function
Class
End
End
Cdigo fuente 256
Cuando en una clase hija creamos un mtodo con el mismo nombre y parmetros que en la clase padre, el
compilador realiza un ocultamiento implcito, aunque genera un aviso, recomendando que declaremos el mtodo de la
clase hija con Shadows. Veamos el Cdigo fuente 257.
Public
'....
Public
Class
Sub
Empleado
Sueldo()
'
aqu
mostramos
en
Console.WriteLine("El
sueldo
Console.ReadLine()
consola
es
el
{0}",
importe
del
sueldo
Format(Me.Salario,
formateado
"#,#.##"))
End
Sub
'....
End
Class
Public
'....
'
si
aqu
'
marcara
Public
'
Class
no
aqu
Me.Salario
End
'....
End
utilizramos
este
mtodo
Shadows
incrementamos
Administrativo
Shadows,
con
Sub
el
valor
el
un
entorno
aviso
Sueldo()
actual
+=
de
la
propiedad
Salario
250
Sub
Class
Por otra parte, si aplicamos el ocultamiento en la sobre-escritura, el comportamiento del objeto se ver
profundamente afectado. La mejor situacin para comprobar este particular consiste en declarar una variable de la
clase base y asignarle un objeto de una clase heredada.
A pesar de que, como hemos comentado anteriormente, la sobre-escritura se basa en el enlace tardo, si
ocultamos un miembro de la clase derivada, forzaremos al objeto a dirigirse a la versin de dicho miembro existente
en la clase padre.
El ejemplo del Cdigo fuente 258 muestra este caso. En l creamos nuestras dos clases habituales, Empleado y
Administrativo, relacionadas mediante herencia, con un mtodo sobrescrito en ambas, que tiene la particularidad de
que la versin existente en la clase derivada est oculto con Shadows. Esto har que al instanciar un objeto de la clase
hija, y pasrselo a una variable referenciada hacia la clase padre, la llamada al mtodo sea desviada hacia la
implementacin existente en la clase padre, en lugar de a la clase derivada como sera su comportamiento habitual.
Module
Module1
Sub
Main()
Dim
loPersona
As
Empleado
loPersona
=
New
Administrativo()
loPersona.psNombre
=
"Juan"
'
estamos
utilizando
sobre-escritura,
'
por
lo
que
el
enlace
tardo
emplea
el
objeto
'
que
hay
dentro
de
la
variable
y
no
la
'
referencia
de
la
variable;
'
al
estar
oculta
con
Shadows
la
implementacin
'
del
mtodo
MostrarNombre()
en
la
clase
Administrativo
'
se
ejecuta
dicho
mtodo
pero
de
la
clase
Empleado
loPersona.MostrarNombre()
Console.ReadLine()
End
End
Sub
Module
Public
Class
Public
psNombre
Public
pdtFHAlta
As
As
Public
Overridable
Console.WriteLine("El
nombre
Me.psNombre)
End
End
Public
'
Public
Empleado
String
Date
del
Sub
empleado
MostrarNombre()
es
{0}",
_
Sub
Class
Class
Administrativo
:
Inherits
Empleado
ocultamos
este
mtodo
Shadows
Sub
MostrarNombre()
Console.WriteLine("Nombre
Console.WriteLine("===================")
Console.WriteLine(UCase(Me.psNombre))
End
End
del
empleado")
Sub
Class
La Tabla 26 muestra, al utilizar sobre-escritura y ocultamiento, la clase de la cul ser ejecutado el mtodo, en
Tabla 26. Mtodo ejecutado mediante enlace tardo bajo sobre-escritura, aplicando ocultamiento.
Module
Module1
Public
Dim
loDirec
loDirec.piID
loDirec.psNombre
loDirec.pdtFHAlta
loDirec.DameInformacion()
Console.Read()
End
End
New
"Gema
Main()
Directivo()
980
Peral"
"20/5/2002"
Sub
Module
Public
Class
Public
piID
As
Public
psNombre
As
Public
pdtFHAlta
As
Public
Sub
Directivo
=
As
Empleado
Integer
String
Date
Overridable
Sub
VerDatos()
Console.WriteLine("Informacin
sobre
"
ID:{0}
Nombre:{1}
Me.piID,
Me.psNombre,
el
Fecha
empleado."
&
_
de
alta:{2}",
_
Me.pdtFHAlta)
Console.WriteLine()
End
End
Sub
Class
Public
Class
Administrativo
Public
Overrides
Console.WriteLine("Datos
Console.WriteLine("==================")
de
Empleado
Sub
VerDatos()
empleado")
{0}",
Me.piID)
StrConv(Me.psNombre,
del
Console.WriteLine("Identificador:
Console.WriteLine("Nombre:
VbStrConv.ProperCase))
Console.WriteLine("Fecha
Console.WriteLine()
Inherits
{0}",
alta:
{0}",
Format(Me.pdtFHAlta,
"dd/MMM/yy"))
End
Sub
Public
'
'
'
'
Sub
cuando
es
los
este
Public
el
de
resultados
mtodo
Class
Public
la
de
las
mtodo
al
Directivo
Inherits
Overrides
Console.WriteLine("El
empleado
{0}
DameInformacion()
en
ejecucin
derivada
Directivo
llamadas
desde
VerDatos()
son
objeto
clase
Administrativo
Sub
comenz
trabajar
VerDatos()
en
el
mes
de:",
Me.psNombre)
Console.WriteLine(Format(Me.pdtFHAlta,
"MMMM"))
Console.WriteLine()
End
End
Sub
Class
base. Para llamar explcitamente a un mtodo de la clase base desde una subclase utilizaremos la palabra clave
MyBase, que contiene una referencia hacia la clase padre.
Veamos un ejemplo, en el Cdigo fuente 260 se crea una clase padre Empleado y la subclase Administrativo.
Puesto que Empleado dispone de un constructor parametrizado, en Administrativo debemos crear tambin un
constructor, y dentro de l llamar en primer lugar al constructor base.
Public
Class
Public
Empleado
piID
As
Integer
Public
psNombre
As
String
Public
piSalario
As
Integer
'
constructor
Public
Me.psNombre
End
End
Public
Inherits
Sub
New(ByVal
parametrizado
lsNombre
As
String)
lsNombre
Sub
Class
Class
Administrativo
Empleado
'
constructor
Public
'
'
MyBase.New("Juan")
Me.piSalario
End
normal
Sub
llamada
al
de
la
clase
New()
constructor
base
100
Sub
Class
End
Cdigo fuente 260
Podemos no obstante, evitar la obligacin de escribir un constructor en la clase derivada, si en la clase padre
creamos un constructor sin parmetros. Como ya sabemos, la sobrecarga de mtodos nos permite escribir varios
mtodos con el mismo nombre y diferente lista de parmetros. Modifiquemos para ello la clase Empleado como
muestra el Cdigo fuente 261.
Public
Class
Public
piID
As
Public
psNombre
As
Public
piSalario
As
'
Public
Me.psNombre
End
'
Sub
Empleado
Integer
String
Integer
constructor
New(ByVal
=
constructor
lsNombre
sin
As
parametrizado
String)
lsNombre
Sub
parmetros
Public
psNombre
End
End
Public
Inherits
'
'
'
'
Sub
=
Class
al
un
necesidad
en
New()
"hola"
Sub
Class
Administrativo
Empleado
disponer
constructor
de
en
la
normal,
crear
esta
End
clase
ya
un
clase
base
no
de
hay
constructor
derivada
Class
Finalmente, debemos apuntar dos reglas que debe cumplir todo mtodo constructor de una subclase que llame al
constructor de su clase base: en primer lugar, el constructor base debe ser llamado en la primera lnea del constructor
derivado; en segundo lugar, el constructor base slo puede ser llamado una vez desde el constructor derivado.
Public
MustInherit
Class
Empleado
Dentro de una clase abstracta podemos implementar propiedades y mtodos, en la forma que hemos visto hasta
el momento. Adicionalmente, podemos obligar a que determinados miembros sean sobrescritos por la clase heredada;
son los denominados miembros abstractos, y se declaran usando la palabra clave MustOverride, como vemos en el
Cdigo fuente 263.
Module
Module1
Public
Dim
loAdmin
loAdmin.piID
loAdmin.psNombre
Console.WriteLine("Nombre
Sub
As
New
=
en
=
maysculas
loAdmin.NombreMay)
loAdmin.pdtFHAlta
loAdmin.MesesActivo()
Console.Read()
End
del
"Pedro
administrativo:
Main()
Administrativo()
789
Pinares"
{0}",
_
"8/10/01"
Sub
Module
End
'
'
no
Public
clase
podemos
crear
MustInherit
Public
Public
Public
Public
Get
Return
End
End
'
'
'
Public
abstracta,
Empleado
Empleado
objetos
Class
piID
psNombre
pdtFHAlta
ReadOnly
Property
As
As
As
NombreMay()
As
Integer
String
Date
String
UCase(Me.psNombre)
Get
Property
mtodo
este
mtodo
por
debe
ser
clase
la
MustOverride
Public
Sub
Sub
Console.WriteLine("Informacin
sobre
"
ID:{0}
Nombre:{1}
Me.piID,
Me.psNombre,
abstracto;
sobrescrito
derivada
MesesActivo()
VerDatos()
el
Fecha
empleado."
&
_
de
alta:{2}",
_
Me.pdtFHAlta)
Console.WriteLine()
End
End
'
Sub
Class
'
a
desde
esta
los
miembros
clase
tendremos
de
la
clase
acceso
Empleado
Public
Class
Administrativo
Inherits
'
'
Public
en
declarado
Empleado
esta
clase
como
abstracto
Overrides
Console.WriteLine("Entr
Format(Me.pdtFHAlta,
Console.WriteLine("El
nmero
DateDiff(DateInterval.Month,
End
Public
en
de
el
meses
Overrides
sobrescribimos
en
la
Sub
mes
que
lleva
Me.pdtFHAlta,
este
clase
de
es:
Sub
mtodo
abstracta
MesesActivo()
{0}",
_
"MMMM"))
{0}",
_
Now))
Sub
VerDatos()
'....
'....
End
End
Sub
Class
Cdigo fuente 263
Debemos tener en cuenta que los miembros abstractos slo tienen sentido si son declarados en clases abstractas.
Por tal motivo, slo podremos crear mtodos con MustOverride en clases que hayan sido definidas como MustInherit.
En lo que respecta al polimorfismo conseguido a travs de clases abstractas, podemos crear un procedimiento
que reciba como parmetro tipificado como clase abstracta, de forma que en funcin del objeto pasado, y que debe ser
de un tipo derivado de la clase abstracta, el comportamiento ser diferente en cada caso. Vemoslo en el Cdigo fuente
264.
Module
Public
'....
End
'
'
'
'
Public
Module1
Main()
Sub
Sub
el
objeto
que
reciba
este
procedimiento
ser
de
cualquiera
de
las
clases
que
hereden
de
Empleado
y
ejecutar
la
implementacin
del
mtodo
VerDatos()
que
tenga
dicho
objeto
Sub
MostrarInformacion(ByVal
loEmple
As
Empleado)
loEmple.VerDatos()
End
End
Sub
Module
Cdigo fuente 264.
Elementos
compartidos
interfaces
En algunas circunstancias, puede ser til codificar un procedimiento que reciba como parmetro un objeto
genrico, y dependiendo del tipo del objeto, ejecutar ciertos mtodos.
Si tipificamos un parmetro como un objeto genrico, es decir, de tipo Object, necesitamos implementar dentro
del procedimiento un mecanismo que, en primer lugar, compruebe a qu tipo pertenece el objeto, y por otra parte,
acceda adecuadamente a su lista de miembros.
Como ejemplo consideremos el siguiente caso: creamos una clase Empleado y otra Factura, las cuales vemos en
el Cdigo fuente 265.
Public
Class
Public
piID
As
Public
psNombre
As
Empleado
String
String
Public
Overridable
Console.WriteLine("Cdigo de empleado:
Me.piID,
End
End
Public
Class
Public
pdtFecha
Public
piImporte
As
As
Sub
{0},
Factura
Date
Integer
Public
Sub
Console.WriteLine("Se
Console.WriteLine("Fecha
Console.WriteLine("Importe
End
End
VerDatos()
nombre: {1}", _
Me.psNombre)
Sub
Class
procede
generar
de
de
Emitir()
la
factura:
la
factura:
siguiente
{0}",
{0}",
factura:")
Me.pdtFecha)
Me.piImporte)
Sub
Class
CType( ) sin embargo, tiene la ventaja de que opera bajo enlace temprano, con lo cul, el rendimiento en
ejecucin es mayor. Veamos el cdigo cliente que accedera a estas clases en el Cdigo fuente 266.
Module
Module1
Public
Sub
Dim
loEmple
Main()
As
New
loEmple.piID
Empleado()
loEmple.psNombre
58
"Elena
Peral"
New
Factura()
ManipularVarios(loEmple)
Dim
loFac
As
loFac.pdtFecha
loFac.piImporte
"25/2/2002"
=
475
ManipularVarios(loFac)
Console.Read()
End
Sub
Public
'
obtenemos
Dim
loTipoObj
'
'
Sub
ManipularVarios(ByVal
informacin
sobre
loTipoObj
=
comprobamos
y
'
Select
Case
CType(loUnObjeto,
Case
CType(loUnObjeto,
End
End
End
en
qu
tipo
funcin
de
mtodo
Case
el
loUnObjeto
tipo
As
de
eso,
As
del
Object)
objeto
Type
loUnObjeto.GetType()
objeto
es,
ejecutamos
el
adecuado
loTipoObj.Name
"Empleado"
Empleado).VerDatos()
"Factura"
Factura).Emitir()
Select
Sub
Module
En el caso de clases heredadas, y con mtodos sobrescritos, CType( ) discierne la implementacin de clase a la
que debe dirigirse.
Si aadimos la clase Administrativo como hija de Empleado, y sobrescribimos el mtodo VerDatos( ), cuando
pasemos al procedimiento ManipularVarios( ) un objeto Administrativo, dado que esta clase hereda de Empleado, con
un sencillo cambio en la estructura Select...Case que comprueba el tipo de objeto, ejecutaremos la implementacin
sobrescrita del mtodo VerDatos( ) en la clase Administrativo. Veamos el Cdigo fuente 267.
Module
Module1
Public
Dim
loEmple
loEmple.piID
loEmple.psNombre
ManipularVarios(loEmple)
Sub
As
=
=
Dim
loAdmin
loAdmin.piID
loAdmin.psNombre
ManipularVarios(loAdmin)
Dim
loFac.pdtFecha
loFac.piImporte
ManipularVarios(loFac)
Main()
Empleado()
58
Peral"
New
"Elena
As
New
Administrativo()
80
Iglesias"
=
=
"Alfredo
loFac
As
=
New
Factura()
"25/2/2002"
475
Console.Read()
End
Sub
Public
'
obtenemos
Dim
loTipoObj
'
'
'
Select
Sub
comprobamos
en
qu
funcin
el
tipo
de
loUnObjeto
tipo
As
de
eso,
As
del
Object)
objeto
Type
loUnObjeto.GetType()
objeto
ejecutamos
es,
el
adecuado
loTipoObj.Name
mtodo
Case
Case
CType(loUnObjeto,
Case
CType(loUnObjeto,
End
End
End
Public
Inherits
ManipularVarios(ByVal
informacin
sobre
loTipoObj
=
Class
"Empleado",
"Administrativo"
Empleado).VerDatos()
"Factura"
Factura).Emitir()
Select
Sub
Module
Administrativo
Empleado
Public
pdtFHAlta
Public
Overrides
Console.WriteLine("DATOS
Console.WriteLine("==================")
Console.WriteLine("Cdigo:
As
Sub
DEL
Console.WriteLine("Nombre:
Date
VerDatos()
ADMINISTRATIVO")
{0}",
Me.piID)
{0}",
Me.psNombre)
Sub
End
Public
Return
End
Function
Format(Me.pdtFHAlta,
MesAlta()
"MMMM")
Function
End
Class
Pero cmo podramos ejecutar el mtodo particular MesAlta( ) de Administrativo, que no se encuentra en
Empleado?, pues creando en la estructura Select...Case, un caso particular que compruebe cundo estamos tratando
con un objeto Administrativo. Vemoslo en el Cdigo fuente 268.
Public
Sub
ManipularVarios(ByVal
loUnObjeto
As
Object)
'
obtenemos
informacin
sobre
el
tipo
del
objeto
Dim
loTipoObj
As
Type
loTipoObj
=
loUnObjeto.GetType()
'
'
'
Select
comprobamos
en
qu
funcin
tipo
de
de
eso,
es,
el
adecuado
loTipoObj.Name
mtodo
Case
Case
CType(loUnObjeto,
Case
"Administrativo"
'
<-aadimos
este
CType(loUnObjeto,
Console.WriteLine("El
administrativo
comenz
"Empleado"
Empleado).VerDatos()
caso
a
la
estructura
Administrativo).VerDatos()
en
{0}",
_
CType(loUnObjeto,
Case
CType(loUnObjeto,
End
End
objeto
ejecutamos
Administrativo).MesAlta())
"Factura"
Factura).Emitir()
Select
Sub
El ejemplo del Cdigo fuente 269 demuestra como podemos ejecutar un mtodo compartido sin haber
instanciado antes un objeto de la clase a la que pertenece dicho mtodo.
Module
General
Sub
Dim
'
aunque
'
de
la
'
a
Console.WriteLine("Nombre
lsValor
no
Main()
String
hemos
instanciado
objetos
Empleado,
podemos
llamar
mtodo
compartido
mes:
{0}",
Empleado.VerNombreMes())
As
clase
este
del
'
ahora
creamos
Dim
loEmpleado1
lsValor
Console.WriteLine("Nombre
una
instancia
de
As
New
=
del
da:
la
clase
Empleado()
loEmpleado1.VerNombreDia()
{0}",
lsValor)
Console.ReadLine()
End
End
Sub
Module
Public
Public
'
'
'
Return
Class
Shared
este
directamente
de
Empleado
Function
mtodo
VerNombreMes()
puede
ser
empleando
el
clase
como
Format(Now(),
la
End
End
String
llamado
nombre
calificador
"MMMM")
Function
Public
'
este
'
Return
End
As
Function
mtodo
para
VerNombreDia()
precisa
de
ser
Format(Now(),
As
una
String
instancia
llamado
"dddd")
Function
Class
En el caso de variables de clase declaradas como miembros compartidos, este tipo de variable slo es creado
una vez, manteniendo su valor para todas las instancias de la clase. Esto contrasta con los miembros de instancia, de
los que se crea una copia particular para cada objeto.
El efecto de miembro compartido se hace ms patente cuando se aplica sobre variables, por ello, en el ejemplo
del Cdigo fuente 270, creamos dos campos compartidos para la clase Empleado; uno de ellos actuar como contador
de los objetos creados de la clase, usando el mtodo constructor para ser incrementado. El otro nos servir para
comprobar que siendo compartido no se inicializa, y mantiene el valor asignado previamente.
Module
Sub
'
accedemos
'
y
Empleado.psApellidos
General
a
la
variable
asignamos
le
=
Main()
compartida
valor
"Naranjo"
'
Dim
instanciamos
loEmp1
un
primer
objeto
As
'
asignamos
valor
a
loEmp1.psNombre
'
mostramos
las
dos
Console.WriteLine("Objeto
loEmp1
Console.WriteLine("psNombre:
{0}
Empleado
Empleado()
New
su
=
variable
de
instancia
"Luis"
variables
del
objeto
valores
de
sus
variables")
psApellidos:
{1}",
_
loEmp1.psNombre,
loEmp1.psApellidos)
Console.WriteLine()
'
instanciamos
un
segundo
objeto
Empleado
Dim
loEmp2
As
New
Empleado()
'
asignamos
valor
a
su
variable
de
instancia
loEmp2.psNombre
=
"Juan"
'
mostramos
las
dos
variables
del
objeto
Console.WriteLine("Objeto
loEmp2
valores
de
sus
variables")
Console.WriteLine("psNombre:
{0}
psApellidos:
{1}",
_
loEmp2.psNombre,
Console.WriteLine()
'
ahora
'
la
Console.WriteLine("Se
han
loEmp2.psApellidos)
mostramos
variable
instanciado
{0}
el
objetos
valor
compartida
de
la
clase
de
miContar
Empleado",
_
Empleado.piContar)
Console.ReadLine()
End
End
Sub
Module
Public
Class
Public
psNombre
As
String
'
Public
Shared
psApellidos
As
String
Public
Shared
piContar
As
Integer
Public
'
por
'
Me.piContar
miembro
de
'
miembro
'
miembro
Empleado
instancia
compartido
compartido
Sub
cada
incrementar
End
End
instancia
de
este
la
campo
clase
+=
New()
creada,
compartido
1
Sub
Class
Public
Public
Class
Shared
Comienzo
Sub
Main()
Console.WriteLine("Est
Console.ReadLine()
End
End
comenzando
la
aplicacin")
Sub
Class
Adems de crear la clase con este mtodo, deberemos modificar las propiedades del proyecto, definiendo como
objeto inicial el nombre de la clase o directamente Sub Main. Como habr podido
adivinar el lector, ello hace innecesario el uso de mdulos de cdigo dentro del proyecto, pudiendo de esta
manera, codificar la aplicacin completamente basada en clases.
Como detalle interesante, debemos destacar el hecho de que al utilizar el modo tradicional de inicio de una
aplicacin, es decir, a travs de un procedimiento Main( ) en un mdulo, el compilador convierte internamente dicho
mdulo en una clase y al procedimiento en un mtodo compartido.
ejecutaramos el mtodo Collect( ) de este objeto como vemos en el Cdigo fuente 272.
GC.Collect()
A pesar de tener acceso al recolector de basura del sistema, se recomienda no abusar de su utilizacin en nuestro
cdigo, ya que consume una importante cantidad de recursos cuando est en ejecucin. Lo ms adecuado es dejar esta
labor en manos de la propia plataforma, que activar el proceso de recoleccin en los momentos ms apropiados.
Cuando en VB6 asignamos Nothing a un objeto durante la ejecucin, provocamos explcitamente la destruccin
inmediata del objeto. Durante ese proceso se ejecuta su evento Terminate( ), en el que podemos escribir cdigo para
eliminar elementos que pudiera estar utilizando a su vez el objeto: cierre de conexiones a bases de datos, ficheros, etc.
A este tipo de evento, que se ejecuta justo antes de la destruccin de un objeto se le denomina finalizador.
En .NET Framework los objetos tambin disponen de mtodos finalizadores. Para implementar este tipo de
miembro en nuestras clases, escribiremos un mtodo con el nombre Finalize( ), de mbito Protected, que sobrescriba y
llame al finalizador de su clase padre. Podemos abrir la lista de mtodos en el editor de cdigo del IDE, en donde
encontraremos este mtodo preconstruido, que tendremos que completar con el cdigo necesario. Ver el Cdigo fuente
273.
Protected
Overrides
Sub
Finalize()
MyBase.Finalize()
'
operaciones
'
End
de
finalizacin
del
objeto
....
Sub
Sin embargo, debido al sistema de gestin de recursos que implementa la finalizacin no determinista, no
podemos saber con tanta precisin el momento en el que un objeto es destruido.
Cuando asignamos Nothing a un objeto, o la variable que lo contiene pierde su mbito y es eliminada, transcurre
un tiempo que no es posible determinar hasta que el objeto es definitivamente destruido. Esta circunstancia hace que la
eliminacin de los elementos usados por el propio objeto pueda demorarse hasta varios minutos, con lo que una
conexin a un origen de datos que realizara un excesivo consumo de recursos podra estar abierta un tiempo
innecesario. El uso de un evento finalizador en esta situacin no sera muy efectivo.
La solucin a este problema pasa por crear un mtodo, en el cul realizaramos las tareas de finalizacin que no
fuera conveniente dejar en el mtodo Finalize( ) de la clase. La denominacin para este mtodo puede elegirla el lector
libremente, pero por convencin, se recomienda asignarle el nombre Dispose( ), ya que este es el nombre que utilizan
el resto de clases de la plataforma. Ver el Cdigo fuente 274.
Module
Sub
Module1
Main()
Dim
loEmple
loEmple
As
Empleado
New
Empleado()
'
....
'
....
loEmple.Dispose()
loEmple
'
'
'
partir
de
activar
el
el
aqu,
en
Nothing
cualquier
recolector
de
Finalize()
evento
momento
basura,
el
entorno
que
destruir
ejecutar
el
objeto
'
....
'
....
End
Sub
Module
End
Public
Class
Empleado
'
....
'
....
Public
'
Sub
en
este
'
mtodo
de
cierre
de
'
que
no
End
End
escribiremos
finalizacin
'
'
Dispose()
conexiones,
sea
las
ms
manipuladores
conveniente
tareas
de
dejar
urgentes:
ficheros,
en
etc
Finalize()
....
Sub
Class
Interfaces
Un interfaz proporciona, a modo de declaracin, una lista de propiedades y mtodos, que posteriormente sern
codificados en una o varias clases.
Debido a su naturaleza declarativa, un interfaz no contiene el cdigo de los miembros que expresa; dicho cdigo
ser escrito en las clases que implementen el interfaz.
El concepto de interfaz es anlogo al de contrato, las partes integrantes son el propio interfaz y la clase que lo
implementa. Mientras que el interfaz no puede ser cambiado desde el momento en que sea implementado, la clase que
lo implementa se compromete a crear la lista de miembros en la misma forma que indica el interfaz
Los interfaces nos permiten definir conjuntos reducidos de funcionalidades, constituyendo una til herramienta
de cara al polimorfismo. El mismo interfaz, implementado en distintas clases, podr tener a su vez cdigo distinto, con
lo que los objetos de diferentes clases que implementen un interfaz comn, pueden tener un comportamiento diferente.
Supongamos por ejemplo, que necesitamos que algunas clases dispongan de ciertos miembros para la
manipulacin de cadenas, pero no queremos que estas caractersticas sean algo rgido, es decir, cada clase debe de
cumplir con un conjunto de nombres y parmetros para los miembros que se encargarn de manipular cadenas, pero la
implementacin del cdigo que haga cada clase para gestionarlas es libre.
Ante esta situacin podemos definir un interfaz e implementarlo en cada clase. El ejemplo desarrollado al
completo para este caso se encuentra en el proyecto InterfacesPrueba (hacer clic aqu para acceder al ejemplo).
En primer lugar crearemos un nuevo proyecto de tipo aplicacin de consola. A continuacin, para crear un
interfaz, utilizaremos la palabra clave Interface junto con el nombre que asignemos al interfaz. Para indicar el final del
interfaz usaremos la palabra clave End Interface, situando dentro del interfaz las declaraciones de miembros que
necesitemos. En nuestro ejemplo vamos a crear el interfaz ICadena que declara la propiedad Longitud y el mtodo
ObtenerValor. Aunque no es en absoluto necesario, se recomienda que utilicemos la letra I como prefijo para los
nombres de interfaces, de cara a facilitar la lectura del cdigo, como vemos en el Cdigo fuente 275.
'
las
clases
que
implementen
este
interfaz
'
debern
crear
la
propiedad
Longitud
y
el
'
mtodo
ObtenerValor();
la
codificacin
de
'
dichos
miembros
ser
particular
a
cada
clase
Public
Interface
ICadena
ReadOnly
Function
End
Property
ObtenerValor()
Longitud()
As
As
Integer
String
Interface
Seguidamente crearemos la clase Empleado. Para que dicha clase pueda implementar (utilizar) las definiciones
de un interfaz, emplearemos despus de la declaracin de la clase, la palabra clave Implements junto al nombre del
interfaz que deseamos que implemente la clase. Veamos el Cdigo fuente 276.
Public
Implements
Class
Empleado
Cadena
'....
'....
End
Class
Cdigo fuente 276
Esta accin obligar a la clase a crear, como mnimo, tantos miembros como indica el interfaz que implementa,
es decir, debemos escribir una propiedad Longitud y un mtodo ObtenerValor( ), o en caso contrario, se producir un
error al intentar ejecutar el programa. Observe el lector, que el editor de cdigo sita una marca sobre el nombre del
interfaz en la clase mientras que no se hayan implementado todos sus miembros. Ver Figura 202.
Figura 202. Mensaje del interfaz que indica que no se han implementado todos sus miembros.
Public
Function
ICadena.ObtenerValor
Return
End
ObtenerValor()
As
String
Implements
UCase(Me.Nombre)
Function
La necesidad de especificar el interfaz y miembro del mismo que implementa, tiene como ventaja, el que para el
nombre del mtodo podemos utilizar uno distinto del que indica el interfaz. Por ejemplo, el anterior mtodo podramos
haberlo escrito como muestra el Cdigo fuente 278.
Public Function DameDatos() As String Implements ICadena.ObtenerValor
Return
UCase(Me.Nombre)
End
Function
Un medio muy sencillo de crear un mtodo vaco que implemente un interfaz, consiste en abrir la lista Nombre
de clase del editor de cdigo y all, seleccionar en la clase, el interfaz que implementa. Ver Figura 203.
Figura 203. Seleccin del interfaz implementado por una clase en el editor de cdigo.
Despus pasaremos a la lista Nombre de mtodo y elegiremos el miembro a implementar. Ver Figura 204.
Estas acciones crearn el mtodo vaco con la implementacin del interfaz. Como podemos observar en el
Cdigo fuente 279, en la declaracin del mtodo se incluye el nombre calificado al completo.
Public
Implements
Get
End
End
ReadOnly
Get
Property
En la implementacin del interfaz ICadena para la clase Empleado, devolvemos el nombre en maysculas del
empleado y la longitud de dicho nombre en los dos miembros correspondientes a dicho interfaz.
Naturalmente, aparte de los miembros del interfaz, una clase puede tener todos los dems que necesite.
Posteriormente creamos una segunda clase en nuestro proyecto con el nombre Cuenta, en la que tambin
implementamos el interfaz ICadena, pero en los miembros implementados sobre esta clase las operaciones realizadas
no sern exactamente iguales, ya que como hemos indicado, la implementacin que hagamos de los miembros de un
interfaz en una clase es totalmente libre para el programador.
El Cdigo fuente 280 muestra el cdigo al completo de este ejemplo, incluyendo el interfaz, las clases que lo
implementan y el procedimiento Main( ) que instancia objetos de las clases.
Module
Module1
Sub
Dim
loEmple
loEmple.Nombre
Console.WriteLine("El
As
Empleado
=
"Raquel
tiene
=
nombre
loEmple.Longitud)
Console.WriteLine("Valor
del
del
Dim
loCuenta
loCuenta.Codigo
Console.WriteLine("El
cdigo
empleado
empleado:
As
de
loCuenta.Codigo,
Console.WriteLine("Informacin
cuenta
de
{0}",
Cuenta
=
{0}
tiene
la
cuenta:
New
{0}
Main()
Empleado()
Rodrigo"
caracteres",
_
loEmple.ObtenerValor())
New
una
longitud
{0}",
Cuenta()
700256
{1}",
_
de
loCuenta.Longitud)
loCuenta.ObtenerValor())
Console.Read()
End
End
Sub
Module
'
las
clases
que
implementen
este
interfaz
'
debern
crear
la
propiedad
Longitud
y
el
'
mtodo
ObtenerValor();
la
codificacin
de
'
dichos
miembros
ser
particular
a
cada
clase
Public
Interface
ICadena
ReadOnly
Function
End
Public
Implements
Property
ObtenerValor()
Class
Longitud()
As
Empleado
ICadena
Private
msNombre
Public
Integer
String
Interface
As
As
Property
Nombre()
String
As
String
Get
Return
End
Set(ByVal
Value
As
msNombre
Value
Set
Property
End
End
'
devolvemos
la
msNombre
Get
String)
longitud
de
la
propiedad
Nombre,
'
'
Public
al
se
especificar
el
puede
poner
ReadOnly
Property
Implements
Get
Return
End
End
'
'
'
'
todo
interfaz
el
Longitud()
que
espacio
As
Len(Me.Nombre)
Get
Property
Public Function
ICadena.ObtenerValor
Return
End
End
Public
Implements
implementa,
de
nombres
Integer
_
InterfacesPrueba.ICadena.Longitud
devolvemos
el
nombre
es
necesario
poner
nombres
calificados,
de
interfaz
y
el
no
de
nombre
se
ObtenerValor()
As
String
en
todo
basta
miembro
el
con
a
mayscula;
espacio
el
implementar
Implements
UCase(Me.Nombre)
Function
Class
Class
Cuenta
ICadena
Private
miCodigo
Public
As
Property
Integer
Codigo()
As
Integer
Get
Return
End
Set(ByVal
Value
miCodigo
Get
Integer)
As
miCodigo
Value
Set
Property
End
End
'
'
'
Public
en
el
esta
nmero
miCodigo
ReadOnly
implementacin
del
caracteres
que
de
Property
Longitud()
Implements
Get
Return
End
End
'
'
'
Public
miembro,
devolvemos
tiene
el
campo
la
clase
As
Integer
_
de
InterfacesPrueba.ICadena.Longitud
Len(CStr(miCodigo))
Get
Property
en
diferentes
este
en
Function
mtodo
del
funcin
propiedad
ObtenerValor()
interfaz,
devolvemos
del
contenido
de
As
Implements
Select
Case
0
Return
"Cdigo
en
Case
1001
Return
"El
cdigo
Case
Return
"El
cdigo
no
String
valores
la
Codigo
_
InterfacesPrueba.ICadena.ObtenerValor
Case
To
intervalo
To
es:
"
est
en
hasta
&
el
Me.Codigo
1000
1000"
2000
Me.Codigo
Else
intervalo"
End
End
End
Select
Function
Class
Los interfaces pueden heredar de otros interfaces que hayamos creado. De esta manera, si creamos el interfaz
IGestion, podemos hacer que herede las caractersticas de ICadena y agregue ms declaraciones de miembros. Ver
Cdigo fuente 281.
Public
Inherits
Interface
Sub
IGestion
ICadena
Calcular()
Interface
End
Cdigo fuente 281
Tambin es posible en un interfaz heredar de mltiples interfaces. Ver el Cdigo fuente 282.
Public
Inherits
Interface
ICadena,
IGestion
ICalculo
End
Interface
Estructuras
Una estructura consiste en un conjunto de datos que se unen para formar un tipo de dato compuesto. Este
elemento del lenguaje se conoca en versiones anteriores de VB como tipo definido por el usuario (UDT o User
Defined Type), y nos permite agrupar bajo un nico identificador, una serie de datos relacionados.
Como novedad en VB.NET, los miembros de una estructura pueden ser, adems de los propios campos que
almacenan los valores, mtodos que ejecuten operaciones, por lo cual, su aspecto y modo de manejo es muy parecido
al de una clase.
Por ejemplo, si disponemos de la informacin bancaria de una persona, como pueda ser su cdigo de cuenta,
titular, saldo, etc., podemos manejar dichos datos mediante variables aisladas, o podemos crear una estructura que
contenga toda esa informacin, simplificando la forma en que accedemos a tales datos.
Public
Structure
Public
IDCuenta
As
Public
Titular
As
Public
Saldo
As
DatosBanco
Integer
String
Integer
End
Structure
El modo de utilizar una estructura desde el cdigo cliente, consiste en declarar una variable del tipo
correspondiente a la estructura, y manipular sus miembros de forma similar a un objeto. En el Cdigo fuente 284,
manejamos de esta forma, una variable de la estructura DatosBanco.
Sub
Dim
lDBanco
lDBanco.IDCuenta
lDBanco.Titular
lDBanco.Saldo
Main()
DatosBanco
958
Perea"
900
As
=
"Carlos
=
End
Sub
Como hemos comentado antes, una estructura admite tambin mtodos y propiedades, de instancia y
compartidos, al estilo de una clase. Por lo que podemos aadir este tipo de elementos a nuestra estructura, para dotarla
de mayor funcionalidad. El Cdigo fuente 285 muestra un ejemplo ms completo de la estructura DatosBanco.
Module
Sub
'
declarar
'
Dim
lDBanco1.IDCuenta
lDBanco1.Titular
lDBanco1.DNI
lDBanco1.Saldo
lDBanco1.Informacion()
Module1
una
y
lDBanco1
=
variable
de
manipularla
As
=
"Carlos
=
=
Main()
estructura
directamente
DatosBanco
958
Perea"
"112233"
900
la
Console.WriteLine()
'
declaramos
'
pero
'
comenzar
'
se
Dim
lDBanco2
lDBanco2.IDCuenta
lDBanco2.Titular
lDBanco2.DNI
lDBanco2.Informacion()
Console.WriteLine()
una
aqu
la
a
trabajar
ejecute
lDBanco2
=
variable
su
=
=
de
instanciamos
con
ella,
mtodo
As
New
=
"Alfredo
la
estructura
de
que
constructor
DatosBanco
DatosBanco(450)
580
Peral"
"556677"
antes
para
'
en
'
miembros
'
por
lo
'
con
el
'
usamos
Console.WriteLine("La
esta
ocasin
trabajamos
con
los
compartidos
de
la
estructura,
que
no
es
necesario
una
variable
tipo
de
la
estructura,
sino
que
directamente
los
miembros
compartidos
fecha
de
apertura
de
la
cuenta
es
{0}",
_
DatosBanco.FHApertura)
DatosBanco.SaldoMin()
Console.ReadLine()
End
End
Sub
Module
Public
Structure
Public
IDCuenta
As
Public
Titular
As
Public
Saldo
As
Private
mDNI
As
Shared
FHApertura
As
Shared
SaldoMinimo
As
DatosBanco
Integer
String
Integer
String
Date
Integer
'
el
constructor
de
una
'
parmetros;
si
no
ponemos
'
como
Public
Sub
New(ByVal
estructura
parmetros
debe
hay
liSaldo
Saldo
definirse
con
que
declararlo
compartido
As
Integer)
liSaldo
Sub
End
Public
Property
DNI()
As
String
Get
Return
End
Set(ByVal
Value
mDNI
Get
String)
As
mDNI
Value
Set
Property
End
End
Public
Console.WriteLine("Informacin
Console.WriteLine("Cdigo:
{0}
IDCuenta,
Sub
sobre
Titular:
{1}
DNI:
Titular,
Me.DNI,
End
'
miembros
'
'
si
el
'
debe
ser
'
los
miembros
Shared
compartidos
que
constructor
compartido
maneje
Sub
FHApertura
SaldoMinimo
End
'
Shared
mtodo
que
Sub
devuelve
el
Informacion()
cuenta")
Saldo:
{3}",
_
Saldo)
Sub
de
la
estructura
=====================================
no
tiene
parmetros
(shared),
y
adems,
deben
ser
tambin
compartidos
New()
=
compartido
la
{2}
saldo mnimo
SaldoMin()
Now
200
Sub
Console.WriteLine("El
{0}",
SaldoMinimo)
End
End
saldo
mnimo
necesario
debe
ser
de
_
Sub
Structure
Una estructura es un tipo por valor, lo que quiere decir que los datos que contiene se manejan en la pila (stack)
de la memoria. Si asignamos una variable que contiene una estructura a otra variable, se realizar una copia de la
estructura, y obtendremos dos estructuras cuyos datos sern totalmente independientes.
Esto ltimo contrasta claramente con las clases, que son tipos por referencia, y sus datos se manejan en el
montn (heap) de la memoria. Lo que realmente contiene una variable de objeto no es el objeto en s, sino un puntero
de cuatro bytes, con la referencia hacia la zona de memoria en la que reside el objeto. Por lo tanto, si asignamos una
variable de objeto a otra variable, se realiza lo que se denomina una copia superficial (shallow copy) de una variable a
otra. Esto quiere decir que slo se copia el puntero de cuatro bytes que contiene la referencia hacia el objeto. El efecto
conseguido son dos variables que apuntan al mismo objeto y no dos variables con copias independientes del objeto.
Observemos el Cdigo fuente 286, en el que se crean dos variables de estructura y una se asigna a otra. Si
hacemos un cambio en la segunda, la primera estructura permanecer inalterada. Sin embargo, a continuacin creamos
dos variables de objeto, y asignamos la primera a la segunda. Cuando hagamos un cambio en la segunda, se reflejar
en la primera; esto es debido a que son dos variables que apuntan al mismo objeto.
Siguiendo con este mismo aspecto del manejo en memoria de las estructuras , queremos hacer notar al lector
que al tratarse de tipos por valor, podemos realizar sobre ellas operaciones de embalaje y desembalaje de tipos (boxing
-unboxing). Consulte el lector en el tema dedicado a .NET Framework, el apartado dedicado a este tipo de
operaciones.
Si embalamos una estructura, asignndola a una variable tipificada como Object, o pasndola a un
procedimiento que tiene el parmetro declarado como Object, y posteriormente la desembalamos, volvindola a
asignar a una variable del tipo de la estructura, incurriremos en una penalizacin sobre el rendimiento, debido a que el
CLR debe manipular la variable en el montn cuando es tratada como un objeto y despus devolverla a la pila cuando
se vuelve a tratar como una estructura. Por consiguiente, si vamos a tratar la estructura mayormente como un objeto,
debemos considerar la posibilidad de crear mejor una clase.
Module
Module1
Sub
'
'
'
Dim
Dim
ejemplos
con
Main()
estructura
DateTime
===================================
compartidos
As
Date
As
Date
la
miembros
ldtFechaActual
ldtFechaA,
ldtFechaB
'
la
ldtFechaActual
Console.WriteLine("La
propiedad
Today
devuelve
la
fecha
actual
DateTime.Today
ldtFechaActual)
=
fecha
'
el
mtodo
'
de
das
Console.WriteLine("El
mes
de
de
hoy
DaysInMonth()
que
Febrero
de
es
{0}",
devuelve
tiene
2002
tiene
el
un
{0}
nmero
mes
das",
_
DateTime.DaysInMonth(2002,
2))
'
el
mtodo
Console.WriteLine("Introducir
ldtFechaA
Console.WriteLine("Introducir
ldtFechaB
Select
Case
Case
Console.WriteLine("La
Case
Console.WriteLine("Las
Case
Console.WriteLine("La
End
'
compara
primera
usar
fechas
fecha")
Console.ReadLine()
fecha")
Console.ReadLine()
segunda
=
DateTime.Compare(ldtFechaA,
primera
fecha
fechas
primera
el
dos
ldtFechaB)
-1
menor")
0
iguales")
1
mayor")
Select
es
son
fecha
miembros
loMiFecha
ldtFDias
ldtFMeses
lsFHFormateada
Dim
Dim
Dim
Dim
'
Compare()
es
de
As
instancia
DateTime
Date
Date
String
As
As
As
constructor
de
la
estructura
'
loMiFecha
'
ldtFDias
'
ldtFMeses
'
lsFHFormateada
para
=
agregar
restar
crear
New
das
=
meses
=
formatear
=
Console.WriteLine("Uso
de
Console.WriteLine("Fecha
creada:
"
Restar
meses:
loMiFecha,
ldtFDias,
Console.ReadLine()
End
End
{2}
mtodos
{0}
-
una
DateTime(2002,
a
a
la
fecha
12)
la
fecha
loMiFecha.AddDays(36)
la
fecha
loMiFecha.AddMonths(-7)
fecha
loMiFecha.ToLongDateString()
5,
de
instancia
de
DateTime")
Agregar
das:
{1}"
&
_
Fecha
ldtFMeses,
formateada:
{3}",
_
lsFHFormateada)
Sub
Module
Enumeraciones
Una enumeracin consiste en un conjunto de constantes relacionadas. A cada constante se le asigna un nombre,
mientras que la agrupacin de tales constantes, es decir, la propia enumeracin recibe tambin un nombre
identificativo.
Supongamos por ejemplo, que en un programa debemos realizar clasificaciones por estilos musicales: Rock,
Blues, New Age, Funky, etc. El modo ms sencillo de manipular estos valores en el cdigo es identificarlos mediante
nmeros, de forma que cuando en un procedimiento tengamos que saber la seleccin del estilo que ha realizado un
usuario, empleemos el nmero identificativo en lugar de cadenas de caracteres. Veamos el Cdigo fuente 288.
Public
Select
Sub
SelecEstilo(ByVal
Case
liEstiloMusical
As
Integer)
liEstiloMusical
Case
'
'
se
la
1
Rock
....
seleccionado
Case
'
'
se
la
2
Blues
....
seleccionado
Case
'
'
se
la
seleccionado
Case
'
'
se
End
End
la
seleccionado
New
3
Age
....
4
Funky
....
Select
Sub
Sin embargo, la sencillez que supone el uso de nmeros para identificar determinadas caractersticas en nuestra
aplicacin, tiene el efecto adverso de dificultar la lectura del cdigo, ya que, en todos los procedimientos donde
debamos trabajar con estilos musicales, deberemos de aadir un comentario de cdigo junto al nmero de estilo, para
saber de cul se trata.
Podemos solucionar parcialmente el problema utilizando constantes, de modo que por cada estilo musical,
crearemos una constante a la que asignaremos el nmero de un estilo. Veamos el Cdigo fuente 289.
Public
Const
ROCK
As
Integer
Public
Const
BLUES
As
Integer
Public
Const
NEWAGE
As
Integer
Public
Const
FUNKY
As
Integer
Public
Sub
Select
=
=
=
=
1
2
3
4
SelecEstilo(ByVal
liEstiloMusical
Case
As
Integer)
liEstiloMusical
Case
ROCK
'
....
BLUES
'
....
Case
Case
NEWAGE
'
....
FUNKY
'
....
Case
End
End
Select
Sub
Si bien el uso de constantes mejora la situacin, su proliferacin provocar la aparicin de un nuevo problema:
la organizacin y clasificacin de todas las constantes del programa.
Aqu es donde entran en escena las enumeraciones, ya que con ellas, podemos crear conjuntos de constantes
relacionadas por una cualidad comn, agrupando cada conjunto bajo un identificador genrico.
Para crear una enumeracin debemos utilizar las palabras clave Enum...End Enum, situando junto a Enum el
nombre que vamos a dar a la enumeracin, y a continuacin, la lista de constantes que agrupar. Por lo tanto, si
queremos reunir bajo una enumeracin, las constantes de los estilos musicales, lo haremos del modo mostrado en el
Cdigo fuente 290.
Public
Enum
Rock
Blues
NewAge
Funky
End
Enum
Cdigo fuente 290
Musicas
Una enumeracin debe tener un tipo de dato. Los tipos que podemos asignar a una enumeracin deben ser los
numricos enteros soportados por el lenguaje que estemos utilizando. En el caso de VB.NET, los tipos de datos
admisibles son Byte, Integer, Long y Short. En el caso de que no especifiquemos el tipo, tomar Integer por defecto.
El hecho de tipificar una enumeracin est relacionado con los valores que podemos asignar a cada una de las
constantes que contiene. De ello se deduce, que slo vamos a poder asignar valores numricos a estas constantes.
Cuando creamos una enumeracin, si no asignamos valores a sus constantes, el entorno asigna automticamente
los valores, comenzando por cero y en incrementos de uno. Podemos en cualquier momento, asignar manualmente
valores, no siendo obligatorio tener que asignar a todas las constantes. Cuando dejemos de asignar valores, el entorno
seguir asignando los valores utilizando como valor de continuacin, el de la ltima constante asignada. Veamos unos
ejemplos en el Cdigo fuente 291.
Public
Enum
Musicas
As
Integer
Rock
'
Blues
'
NewAge
'
Funky
End
2
3
Enum
'
Public
Enum
DiasSemana
As
Integer
Para utilizar una enumeracin definida en nuestra aplicacin, debemos declarar una variable, a la que daremos
como tipo de dato el mismo de la enumeracin. Una vez creada, la forma de asignar un valor es muy sencilla, ya que
en cuanto escribamos el operador de asignacin, el editor de cdigo nos abrir una lista con los posibles valores que
admite la variable, que correspondern, evidentemente, slo a los de la enumeracin. De esta forma, facilitamos
enormemente la escritura de cdigo, ya que se reducen las posibilidades de error en la asignacin de valores a la
variable enumerada. Ver Figura 205.
El valor almacenado en una variable de enumeracin corresponder al nmero de la constante que hayamos
seleccionado. Al declarar la variable, su valor inicial ser cero.
No obstante, la manipulacin de una enumeracin va mucho ms all de la asignacin y recuperacin simple de
las constantes que componen la enumeracin. Cuando declaramos una variable de una enumeracin, el contenido real
de dicha variable es un objeto de la clase Enum; por lo tanto, podemos utilizar los mtodos de dicho objeto, para
realizar diversas operaciones. Para tareas genricas, la clase Enum tambin dispone de mtodos compartidos que
podremos ejecutar directamente, sin necesidad de crear una enumeracin previa. El Cdigo fuente 292 muestra
algunos ejemplos.
Module
Public
Module1
Enum
Musicas
As
Integer
Rock
Blues
NewAge
Funky
End
Enum
Sub
'
'
Dim
creamos
y
una
variable
le
lxMusic
lxMusic
'
el
contenido
'
a
Console.WriteLine(lxMusic)
de
la
Musicas.NewAge
variable
es
el
nmero
asignado
constante
la
'
el
mtodo
ToString()
'
de
la
constante
elegida
'
la
Console.WriteLine(lxMusic.ToString("G"))
permite
de
la
mostrar
lista
'
obtener
los
valores
de
las
constantes
de
'
con
GetValues(),
y
los
nombres
con
GetNames();
'
son
compartidos
de
la
clase
Enum,
y
reciben
como
'
variable
de
enumeracin
de
la
que
debe
obtenerse
el
'
su
mtodo
GetType();
devuelven
un
array
con
los
Dim
liValores()
As
Dim
lsNombres()
As
Dim
liContador
As
liValores
lsNombres
Console.WriteLine()
Console.WriteLine("Valor
Main()
enumeracin
valor
Musicas
de
asignamos
As
nombre
tiene
enumeracin
la
enumeracin
estos
mtodos
parmetro
una
tipo
ejecutando
datos
pedidos
Integer
String
Integer
System.Enum.GetValues(lxMusic.GetType())
System.Enum.GetNames(lxMusic.GetType())
'
recorrer
los
arrays
For
liContador
=
Console.WriteLine(liValores(liContador)
lsNombres(liContador))
Next
el
que
y
0
&
Nombre")
mostrar
su
contenido
To
UBound(liValores)
Space(7)
&
_
'
comprobar
si
un
nombre
'
usuario
est
entre
los
'
constantes
en
Dim
lsNombreMusica
Console.WriteLine("Introducir
nombre
lsNombreMusica
=
If
System.Enum.IsDefined(lxMusic.GetType(),
Console.WriteLine("El
tipo
de
msica
s
est
Else
Console.WriteLine("El
tipo
de
msica
no
est
End
introducido
nombres
la
As
de
por
el
de
las
enumeracin
String
constante")
Console.ReadLine()
lsNombreMusica)
Then
en
la
enumeracin")
en
la
enumeracin")
If
Console.ReadLine()
End
End
Sub
Module
Dim
lsCadena
As
Dim
liLongitud
As
lsCadena
=
"esto
es
una
liLongitud
=
Len(lsCadena)
String
Integer
prueba"
'
18
La mayora de estas funciones del lenguaje siguen estando disponibles (el fuente anterior funciona
perfectamente en VB.NET), pero a lo largo de los siguientes apartados, comprobaremos que su uso ser cada vez
menos necesario.
Como ya apuntbamos en el tema dedicado a la plataforma .NET Framework, todos los elementos del lenguaje
se consideran tipos: los propios tipos de datos, clases, estructuras, enumeraciones, etc.,
componen lo que se denomina el CTS, o sistema comn de tipos; una enorme jerarqua que parte del tipo base
Object, y del que heredan el resto de tipos de la plataforma.
Al ser los tipos de datos, uno de los muchos tipos existentes dentro del esquema del CTS, podemos
manipularlos de la forma tradicional o como si fueran objetos; aspecto este, que trataremos en el siguiente apartado.
Dim
Dim
Dim
lsCadena
lsCadena
liLongitud
lsCambiada
=
"esto
As
As
As
es
una
String
Integer
String
prueba"
liLongitud
lsCambiada
=
lsCadena.Length
lsCadena.ToUpper()
'
ESTO
ES
'
UNA
18
PRUEBA
Al ser una cadena, tanto un tipo de dato como un objeto de la clase String, podemos manipularlo como cualquier
otro objeto de la jerarqua de la plataforma. En esta ocasin, hemos recuperado la longitud de la cadena mediante su
propiedad Length, y la hemos convertido a maysculas ejecutando su mtodo ToUpper( ), asignado el resultado a otra
variable.
Para comprobar la versatilidad que ahora nos proporcionan los tipos de datos, cuando declaramos una variable
String, podemos hacerlo como en versiones anteriores del lenguaje, o al estilo OOP. Si consultamos la ayuda de .NET
Framework, encontraremos una entrada con el ttulo String Class, que describe este tipo como una clase ms del
sistema. Veamos el Cdigo fuente 295.
Sub
'
modo
Dim
lsCad1
lsCad1
'
instanciar
loCad2
Dim
'
declarar
String
loCad3
'
Dim
'
'
'
'
'
'
Dim
As
=
Main()
tradicional
String
"mesa"
un
As
String
As
String
variable
la
este
Char;
un
Console.WriteLine("lsCad1
Console.WriteLine("loCad2
Console.WriteLine("loCad3
Console.WriteLine("loCad4
New
asignar
valor
String("silla")
instanciar
la
String
y
New
variable
en
declarar
String
en
utilizado
en
de
objetos
de
crear
loCad4
objeto
As
e
misma
caso
observe
array,
mismo
String(New
un
misma
New
instanciar
lnea;
el
requiere
el
lector
asignando
Char()
-->
-->
-->
-->
objeto
lnea
String("coche")
un
{"t",
objeto
constructor
un
array
la
forma
valores
al
tiempo
"r",
"e",
"n"})
{0}",
{0}",
{0}",
{0}",
lsCad1)
loCad2)
loCad3)
loCad4)
Console.ReadLine()
End
Sub
Cdigo fuente 295
En segundo lugar, y este tambin es un trabajo realizado transparentemente por el entorno, cada vez que
creamos o instanciamos un tipo String, obtenemos lo que se denomina una cadena inalterable. Internamente, cuando
realizamos una operacin sobre la cadena: convertirla a maysculas, extraer una subcadena, etc., el CLR crea una
nueva instancia de String, asignndola a la misma variable. En apariencia, realizamos modificaciones sobre la misma
cadena, pero en realidad, cada operacin genera nuevos objetos String.
Por ltimo, no es ahora posible crear cadenas de longitud fija, como ocurra en versiones anteriores de VB.
En este apartado realizaremos una revisin de los mtodos de esta clase, a travs de un conjunto de ejemplos,
que a modo ilustrativo, nos permitan familiarizarnos con el modo en que se manejan cadenas en VB.NET.
Debido al elevado nmero de miembros que contienen la mayora de los tipos de la plataforma .NET, tanto
clases, como estructuras, tipos de datos, etc,; y a que muchos de ellos disponen de versiones sobrecargadas; en la
descripcin de cada tipo haremos un repaso de sus miembros principales, remitiendo al lector, a la documentacin de
referencia que sobre los tipos existe en la ayuda de la plataforma .NET, en donde encontrar toda la informacin
detallada.
Antes de comenzar a describir los mtodos de esta clase, y puesto que una cadena es un array de tipos Char, es
importante tener en cuenta que la primera posicin corresponde al cero. Esta aclaracin la realizamos
fundamentalmente, de cara a los mtodos que requieran el manejo de posiciones concretas de la cadena.
Trim( ), TrimStart( ), TrimEnd( ). Eliminan los espacios a ambos lados de una cadena, al comienzo o al
final. Ver el Cdigo fuente 296.
Dim
lsCadena
lsCadena
Dim
lsQuitar
lsQuitar
lsQuitar
=
=
=
As
"
lsQuitar
lsCadena.TrimEnd()
lsCadena.TrimStart()
lsCadena.Trim()
String
Hola
.NET
"
As
'
'
"
"Hola
'
Hola
.NET
"Hola
String
.NET"
"
.NET"
PadLeft( ), PadRight( ). Rellenan una cadena por la izquierda o derecha utilizando un determinado carcter
de relleno. Debemos especificar la longitud total de la cadena resultante. Como el carcter de relleno es un tipo Char,
podemos especificar que se trata de este tipo, situando junto al carcter de relleno, la letra c. Ver el Cdigo fuente 297.
Dim
Dim
lsCadena
lsRellena
lsRellena
lsCadena
lsRellena
=
=
=
lsCadena.PadLeft(10)
lsCadena.PadRight(10,
As
As
'
"W"c)
"
'
String
String
"Hola"
Hola"
"HolaWWWWWW"
Insert( ). Inserta en la cadena, una subcadena a partir de una posicin determinada. Ver el Cdigo fuente 298.
Dim
Dim
lsCadena
lsAgregar
lsCadena
lsAgregar
=
lsCadena.Insert(2,
As
As
"HOLA")
"Estamos
'
String
String
programando"
programando"
"EsHOLAtamos
Remove( ). Elimina de la cadena un nmero determinado de caracteres, comenzando por una posicin
especfica. Ver el Cdigo fuente 299.
Dim
Dim
lsCadena
lsQuitar
lsCadena
lsQuitar
=
lsCadena.Remove(5,
As
As
"Estamos
3)
'
String
String
programando"
"Estamprogramando"
Replace( ). Cambia dentro de la cadena, todas las ocurrencias de una subcadena por otra. Ver el Cdigo fuente
300.
Dim
lsCadCompleta
=
"En
Console.WriteLine("Replace
lsCadCompleta
el
bosque
-->
{0}",
se
As
alza
el
castillo
lsCadCompleta.Replace("el",
String
negro"
"la"))
As
=
'
'
String
"veinte"
True
False
.
SubString( ). Obtiene una subcadena comenzando por una posicin de la cadena, y extrayendo un
nmero de caracteres.
.
IndexOf( ), LastIndexOf( ). Buscan una subcadena pasada como parmetro, comenzando por el
principio y el fin respectivamente; y devuelven la posicin de comienzo de dicha subcadena. Ver el Cdigo fuente
302.
Dim
lsCadCompleta
lsCadCompleta
=
"En
el
bosque
Console.WriteLine("Substring
-->
{0}",
"bosqu"
Console.WriteLine("IndexOf
-->
{0}",
Console.WriteLine("LastIndexOf
-->
{0}",
21
As
String
se
alza
el
castillo
negro"
lsCadCompleta.Substring(6,
5))
'
lsCadCompleta.IndexOf("el"))
'
lsCadCompleta.LastIndexOf("el"))
3
'
Dim
lsCadMayMin
=
Console.WriteLine("Pasar
Console.WriteLine("Pasar
lsCadMayMin
"CambIaNDO
a
may.
a
min.
A
-->
-->
As
maysCUlAs
{0}",
{0}",
String
Y
MINscULAS"
lsCadMayMin.ToUpper())
lsCadMayMin.ToLower())
Concat( ). Concatena dos cadenas pasadas como parmetro. Este es un mtodo compartido de la clase String,
por lo que no se requiere una instancia previa de la clase. El modo, sin embargo ms rpido y sencillo para concatenar,
sigue siendo el operador especfico de concatenacin: &. Ver el Cdigo fuente 304.
Dim
lsConcatenar
lsConcatenar
=
"ahora
lsConcatenar
String.Concat("Hola
usamos"
&
"
As
",
operador
el
"a
para
String
todos")
concatenar"
Copy( ). Crea un nuevo objeto String, aunque el medio ms sencillo consiste en asignar una cadena a la
variable. Ver el Cdigo fuente 305.
Dim
Dim
lsCadA
lsCadB
Console.WriteLine("CadenaA
Console.WriteLine("CadenaB
lsCadA
lsCadB
As
As
String
String
"uno"
String.Copy("OTRO")
lsCadA)
lsCadB)
=
=
-->
-->
{0}",
{0}",
Compare( ). Este mtodo compartido compara dos cadenas, y devuelve un valor menor de cero, si la primera
cadena es menor que la segunda; cero si ambas cadenas son iguales; y mayor de cero, si la primera cadena es mayor.
Ver el Cdigo fuente 306.
Dim
lsCompara1
Dim
lsCompara2
Dim
liResultaComp
Console.WriteLine("Introducir
primera
lsCompara1
=
Console.WriteLine("Introducir
segunda
lsCompara2
=
liResultaComp
=
Select
Case
Is
Console.WriteLine("Primera
As
As
As
cadena
cadena
String.Compare(lsCompara1,
Case
<
cadena
es
lsCompara2)
liResultaComp
0
menor")
String
String
Integer
comparar")
Console.ReadLine()
comparar")
Console.ReadLine()
Case
Console.WriteLine("Las
Case
Is
Console.WriteLine("Primera
End
cadenas
son
>
cadena
es
0
iguales")
0
mayor")
Select
Equals( ). Compara el objeto con una cadena pasada como parmetro, y devuelve un valor lgico, que indica
si las cadenas son o no iguales. Ver el Cdigo fuente 307.
Dim
lsCadInicial
As
Dim
lsCadComparar
As
lsCadInicial
=
Console.WriteLine("Introducir
una
cadena
a
comparar
con
lsCadComparar
=
If
lsCadInicial.Equals(lsCadComparar)
Console.WriteLine("Las
Else
Console.WriteLine("Las
End
cadenas
cadenas
son
son
la
String
String
"Prueba"
cadena
inicial")
Console.ReadLine()
Then
iguales")
diferentes")
If
El Cdigo fuente 308 contiene un ejemplo de manejo de un objeto StringBuilder, sobre el que realizamos varias
operaciones antes de pasarlo definitivamente a un String. A lo largo de este fuente se encuentran comentarios
descriptivos de los diferentes miembros utilizados del objeto StringBuilder.
Imports
System.Text
Module
Module1
Sub
Main()
'
Dim
'
instanciar
sbCaracteres
con
el
As
mtodo
un
StringBuilder
Append()
New
aadimos
objeto
StringBuilder()
caracteres
al
objeto
sbCaracteres.Append("hola
")
sbCaracteres.Append("vamos
crear
sbCaracteres.Append("caracteres
'
la
propiedad
'
de
caracteres
Console.WriteLine("Longitud
de
con
Length
que
la
cadena
")
StringBuilder")
devuelve
la
cantidad
real
contiene
el
objeto
del
objeto
StringBuilder:
{0}",
_
sbCaracteres.Length)
'
la
propiedad
Capacity
'
que
el
Console.WriteLine("Capacidad
del
devuelve
objeto
objeto
la
cantidad
de
puede
StringBuilder:
caracteres
contener
{0}",
_
sbCaracteres.Capacity)
'
el
mtodo
'
dentro
del
objeto,
sbCaracteres.Insert(6,
Console.WriteLine("Insercin
Console.WriteLine("Cadena:
Insert()
permite
a
partir
de
'
con
el
mtodo
'
posicin
del
sbCaracteres.Remove(45,
Console.WriteLine("Eliminacin
Console.WriteLine("Cadena:
Remove(),
objeto,
'
con
el
'
por
sbCaracteres.Replace("crear",
Console.WriteLine("Reemplazo
Console.WriteLine("Cadena:
'
la
'
del
objeto
sbCaracteres.Capacity
Console.WriteLine()
cadena
determinada
"SORPRESA")
cadena")
sbCaracteres.ToString())
de
{0}",
mtodo
otra
siguiente
la
incluir
una
una
posicin
un
borramos
a
nmero
de
{0}",
Replace(),
dentro
de
una
caracteres
3)
caracteres")
sbCaracteres.ToString())
sustituimos
del
cadena
objeto
"pintar")
caracteres")
sbCaracteres.ToString())
de
{0}",
lnea
cantidad
real
=
partir
de
ajusta
de
una
la
capacidad
caracteres
que
tiene
sbCaracteres.Length
'
volcamos
el
contenido
del
objeto
a
una
cadena,
'
el
mtodo
ToString()
devuelve
un
tipo
String,
'
que
pasamos
a
una
variable
de
dicho
tipo
Dim
sCadena
As
String
sCadena
=
sbCaracteres.ToString()
Console.WriteLine("La
variable
sCadena
contiene:
{0}",
sCadena)
Console.ReadLine()
End
End
Sub
Module
Cdigo fuente 308
La estructura Char
Cuando necesitemos manipular caracteres independientes, utilizaremos los mtodos compartidos de esta
estructura, que nos informarn del tipo de carcter que estamos manejando, adems de poder realizar determinadas
operaciones sobre el carcter.
El Cdigo fuente 310 muestra un ejemplo de uso de la estructura Char. Cada uno de los miembros de Char
empleados se encuentra con un pequeo comentario aclaratorio de su funcionalidad.
Dim
Dim
Dim
Public
Sub
lcCaracter
lsResultado
lcConvertido
As
As
As
Do
Console.WriteLine("Introducir
lcCaracter
lsResultado
lcConvertido
'
IsDigit()
If
lsResultado
End
Main()
Char
String
Char
un
=
carcter
=
=
indica
si
el
carcter
Char.IsDigit(lcCaracter)
=
es
un
cero
para
salir")
Convert.ToChar(Console.ReadLine())
""
Nothing
dgito
decimal
Then
"dgito"
If
'
IsLetter()
If
lsResultado
End
indica
si
el
carcter
Char.IsLetter(lcCaracter)
=
un
'
IsUpper()
If
lsResultado
'
ToLower()
lcConvertido
comprueba
si
es
espacio
signo
el
una
letra
Then
"letra"
If
en
blanco
Then
"espacio"
If
de
puntuacin
Then
"puntuacin"
If
carcter
est
Char.IsUpper(lcCaracter)
&=
"
convierte
el
carcter
=
en
mayscula
Then
mayscula"
a
minscula
Char.ToLower(lcCaracter)
End
'
If
IsLower()
If
lsResultado
'
ToUpper()
lcConvertido
comprueba
si
el
carcter
est
Char.IsLower(lcCaracter)
&=
"
convierte
el
carcter
=
en
minscula
Then
minscula"
a
mayscula
Char.ToUpper(lcCaracter)
End
If
'
mostramos
Console.WriteLine("El
'
si
hemos
'
If
Console.WriteLine("El
una
cadena
carcter
con
es:
el
tipo
{0}",
convertido
el
caracter
lo
Char.IsLetter(lcConvertido)
carcter
se
ha
convertido:
{0}",
End
de
carcter
lsResultado)
mayscula/minscula,
mostramos
Then
lcConvertido)
If
Console.WriteLine()
'
no
Loop
End
salimos
Until
hasta
que
no
lcCaracter
se
introduzca
=
un
0
"0"c
Sub
Para asignar un valor de manera explcita a una variable, parmetro, etc., de tipo Char, es recomendable situar el
carcter c junto a dicho valor. Veamos el Cdigo fuente 311.
Dim
lcCaracter
As
Char
son
equivalentes,
=
=
pero
se
recomienda
la
primera
"H"c
"H"
Sin embargo, si queremos asignar un valor Char a una variable tipificada como Object, debemos utilizar
irremisiblemente el indicador c junto al valor, o de otro modo, el subtipo almacenado en la variable Object lo tomar
como String en lugar de Char. El mejor modo de comprobarlo, es abriendo la ventana Locales en modo de depuracin.
Veamos un ejemplo en el Cdigo fuente 312.
Dim
loValor
loValor
=
=
"H"
"H"c
loValor
As
Object
'
objeto
de
subtipo
String
'
objeto
de
subtipo
Char
liSigno
ldbRedondear
'
Abs():
'
Console.WriteLine("Abs
'
Ceiling():
'
ms
grande
Console.WriteLine("Ceiling
'
'
ms
Floor():
pequeo
As
As
Main()
Integer
Double
devuelve
pasado
el
valor
-->
devuelve
el
o
igual
-->
devuelve
el
o
igual
absoluto
como
{0}",
que
nmero
el
{0}",
nmero
que
el
sin
pasado
sin
pasado
del
nmero
parmetro
Math.Abs(-1867.79))
precisin
decimal,
como
parmetro
Math.Ceiling(256.7235))
precisin
como
decimal,
parmetro
Console.WriteLine("Floor
-->
'
Sign():
devuelve
'
pasado
Console.WriteLine("Introducir
liSigno
Select
Case
Console.WriteLine("El
Case
Console.WriteLine("El
Case
Console.WriteLine("El
End
un
{0}",
valor
nmero
=
Case
nmero
informando
del
como
para
averiguar
es
nmero
es
nmero
'
Round():
redondea
ldbRedondear
Console.WriteLine("Redondear
el
=
28.3215
ldbRedondear
Console.WriteLine("Redondear
28.63215
Math.Floor(256.7235))
es
nmero
-->
signo
nmero
parmetro
su
signo")
Console.ReadLine()
Math.Sign(liSigno)
-1
negativo")
0
cero")
1
positivo")
Select
pasado
{0}",
como
parmetro
Math.Round(28.3215)
ldbRedondear)
{0}",
Math.Round(28.63215)
ldbRedondear)
=
-->
del
Console.ReadLine()
End
Sub
Cdigo fuente 313
Formateo de valores
La utilizacin de un formato sobre un tipo de dato, nos permite mostrar su valor de un modo distinto a como se
encuentra almacenado en la aplicacin. Por ejemplo, el valor puro de una fecha no muestra el nombre del mes; sin
embargo, si aplicamos un formato a una fecha, podemos hacer que se muestre la fecha en un modo extendido, con el
nombre del mes, da de la semana, etc.
Podemos aplicar los formatos de varias maneras. A continuacin, se muestran algunas de las tcnicas a emplear.
.
Mediante caracteres que representan formatos definidos internamente por la plataforma.
.
A travs de patrones de formato, que consisten en un conjunto de caracteres especiales, cuya
combinacin nos permite crear formatos personalizados.
.
Utilizando alguna de las clases del sistema que implementan el interfaz IFormatProvider. Al instanciar
un objeto de una clase de este tipo, podemos alterar el formato por defecto que utilizar el tipo de dato.
Todos los tipos de datos del entorno que pueden mostrar informacin formateada, disponen del mtodo
ToString( ), al cul podemos pasarle una cadena, con los especificadores de formato (caracteres, patrones, objetos de
formato) que necesitemos.
Fechas
El tipo Date, aparte del mtodo ToString( ), tiene algunos miembros que devuelven un tipo de formato fijo.
Veamos el Cdigo fuente 314.
Sub
Dim
ldtFecha
ldtFecha
Console.WriteLine("ToLongDateString:
Console.WriteLine("ToUniversalTime:
As
=
{0}",
{0}",
Main()
Date
Date.Now()
ldtFecha.ToLongDateString())
ldtFecha.ToUniversalTime())
End
Sub
Empleando alguna de las sobrecargas del mtodo ToString( ), podemos formatear en los modos mostrados
seguidamente.
La Tabla 27 muestra algunos caracteres asociados a los formatos predefinidos.
Tabla
En
el
Cdigo
27.
fuente
Algunos
315
podemos
caracteres
ver
un
de
formateo
de
formatos
fechas
con
predefinidos.
caracteres
Sub
Dim
Dim
Dim
lsListaFormatos()
ldtFecha
As
String
lsFormato
ldtFecha
=
For
Each
lsFormato
Console.WriteLine("Formato:
{0},
lsFormato,
Next
End
{"d",
"D",
As
"g",
"G",
As
"t",
"T",
de
formato.
Main()
Date
"m",
"y"}
String
Date.Now()
In
lsListaFormatos
resultado:
{1}",
_
ldtFecha.ToString(lsFormato))
Sub
La Tabla 28 por otra parte, muestra algunos caracteres utilizados para crear patrones de formato personalizados,
los cuales, se deben combinar entre s, para componer el formato que necesitemos.
\literal Si queremos que un carcter que forma parte de los caracteres especiales de formato, se muestre de
forma literal, debemos anteponerle este marcador
Tabla 28. Caracteres para patrones de formato.
El Cdigo fuente 316 muestra algunos formatos personalizados, construidos a base de patrones de formato.
Sub
Dim
ldtFecha
ldtFecha
Console.WriteLine(ldtFecha.ToString("ddd,
Console.WriteLine(ldtFecha.ToString("dddd,
As
=
a
dd
\de
MMMM
,en
el
Main()
Date
Date.Now()
dd-MMM/yyyy"))
ao
yyyy"))
Console.WriteLine(ldtFecha.ToString("H:mm:s"))
End
Sub
Si queremos obtener un array con todos los posibles formatos de una fecha, usaremos el mtodo
GetDateTimeFormats( ). Ver el Cdigo fuente 317.
Sub
Dim
ldtFecha
ldtFecha
=
'
array
Dim
lsListaFormatos
Dim
For
As
para
Each
Main()
Date
Date.Now()
obtener
todos
los
lsListaFormatos()
=
lsFormato
lsFormato
formatos
de
fecha
del
sistema
As
String
ldtFecha.GetDateTimeFormats()
As
String
In
lsListaFormatos
Console.WriteLine(lsFormato)
Next
Console.ReadLine()
End
Sub
Cdigo fuente 317
importar
este
espacio de nombres
System.Globalization
Module
Sub
Dim
ldtFecha
Module1
ldtFecha
As
=
'
creamos
un
objeto
especfico
de
formato,
'
y
aplicamos
dicho
formato
Dim
loDTFormato
As
New
DateTimeFormatInfo()
'
ahora
mostramos
con
el
objeto
de
formato
'
slo
el
mes
y
da
Console.WriteLine(ldtFecha.ToString(loDTFormato.MonthDayPattern))
Main()
Date
Date.Now()
End
Sub
Module1
End
Cdigo fuente 318
El ejemplo del Cdigo fuente 319 va un poco ms all. En l, despus de instanciar un objeto
DateTimeFormatInfo, altera algunas de sus propiedades, para que al formatear una fecha, los formatos estndar se
alteren en funcin de las modificaciones efectuadas sobre el objeto de formato.
Imports
System.Globalization
Module
Module1
Sub
'
Dim
ldtFecha
'
creamos
ldtFecha
=
#8/6/2002
creamos
un
loDTFormato
Dim
objeto
As
'
al
mostrar
la
'
visualice
indicando
'
con
un
loDTFormato.PMDesignator
loDTFormato.AMDesignator
=
'
'
Dim
de
podemos
los
lsDias()
"3MIRCOLES",
loDTFormato.DayNames
'
aqu,
asignamos
'
este
es
el
formato
loDTFormato.LongDatePattern
=
6:35:02
de
formato
para
fechas
DateTimeFormatInfo()
New
hora,
si
asignar
una
das
de
la
As
String
"4JUEVES",
Main()
fecha
Date
PM#
una
As
podemos
es
literal
hacer
AM
=
"Antes
del
cadena
con
semana
en
un
=
{"1LUNES",
"5VIERNES",
=
un
formato
que
se
muestra
"Diario
e\s\telar:
"6SBADO",
que
se
o
PM
personalizado
"Desp.Medioda"
medioda"
los
estilo
"2MARTES",
nombres
propio
_
"7DOMINGO"}
lsDias
para
la
fecha
larga,
al
pasar
"D"
a
ToString()
ddd,
dd
\de
MMMM
\de
yyyy"
'
una
vez
configurado
el
objeto
de
formato
'
lo
utilizamos
en
la
versin
sobrecargada
'
de
ToString()
correspondiente
Dim
lsFHFormateada
As
String
lsFHFormateada
=
ldtFecha.ToString("D",
loDTFormato)
Console.WriteLine("Formato
largo:
{0}",
lsFHFormateada)
lsFHFormateada
=
ldtFecha.ToString("dddd
MMM
yy",
loDTFormato)
Console.WriteLine("Mostrar
nombre
de
da
personalizado:
{0}",
lsFHFormateada)
lsFHFormateada
=
Console.WriteLine("Mostrar
ldtFecha.ToString("H:m:s
hora
con
AM/PM
propio:
tt",
{0}",
loDTFormato)
lsFHFormateada)
Console.ReadLine()
End
End
Sub
Module
Cdigo fuente 319
Nmeros
Podemos formatear un nmero mediante los caracteres de formato predefinidos. La Tabla 29 muestra los
existentes.
El Cdigo fuente 320 muestra algunos formatos aplicados sobre un tipo numrico.
Sub
Dim
'
Dim
Dim
ldcMiNum
crear
un
array
lsFormatos()
As
String
lsNumFormateado
ldcMiNum
'
'
For
850.678
recorrer
uno
Each
el
de
As
con
caracteres
=
{"c",
"e",
As
'
asignar
array
de
los
lsNumFormateado
de
"f",
"g",
valor
formatos
formatos
al
aplicar
al
In
Main()
Decimal
formato
"n"}
String
nmero
cada
nmero
lsFormatos
Console.WriteLine(ldcMiNum.ToString(lsNumFormateado))
Next
Console.ReadLine()
End
Sub
Cdigo fuente 320
Dim
Dim
ldbImporte
ldtFecha
ldbImporte
ldtFecha
=
As
As
Double
Date
58.367
Date.Now()
ldbImporte)
ldbImporte)
ldtFecha)
ldtFecha)
ldtFecha)
Dim
Dim
Dim
ldbImporte
ldtFecha
lsCadFormateada
ldbImporte
ldtFecha
lsCadFormateada
As
As
As
Double
Date
String
=
=
String.Format("El
=
valor
de
total
de
ldbImporte)
lsCadFormateada
=
String.Format("La
hora
actual
lsCadFormateada = String.Format("Hoy es {0:dddd}, y
la
compra
58.367
Date.Now()
{0:C}", _
es
es
{0:T}",
ldtFecha)
el mes es {0:MMM}", _
ldtFecha)
Module
Module1
Public
Sub
Dim
loNombre
As
loNombre
=
New
CadenaFmt("anToNIo
Console.WriteLine(loNombre.ToString("NOMPROPIO",
New
'
resultado:
Console.ReadLine()
End
End
'
Public
Implements
Private
Antonio
mEsa
Main()
CadenaFmt
pErAl")
_
System.Globalization.CultureInfo("es")))
Mesa
Peral
Sub
Module
clase
para
formatear
nombres
Class
msCadValor
As
propios
CadenaFmt
IFormattable
String
Public
msCadValor
End
'
'
ya
Public
Sub
debemos
que
forma
Overloads
ByVal
Else
'
'
'
Return
lsCadValor
As
String)
lsCadValor
Sub
escribir
el
mtodo
ToString()
parte
de
la
implementacin
del
Function
ToString(ByVal
format
formatProvider
String
As
If
'
'
'
'
Return
New(ByVal
As
Implements
format
el
nombre
NOMPROPIO,
convierte
letra
cuando
sea
que
si
no
personalizado,
parmetro
en
esta
clase,
interfaz
IFormattable
As
String,
_
System.IFormatProvider)
_
System.IFormattable.ToString
=
del
llamar
a
de
"NOMPROPIO"
Then
formato
a
aplicar
a
un
mtodo
maysculas
la
primera
cada
palabra
Me.ConvertirProperCase()
queremos
utilizar
aplicar
el
formarProvider
de
String.Format(format,
nuestro
formato
indique
el
este
mtodo
formatProvider)
que
End
If
Function
End
Private
Function
lcCaracteres()
lcUnCaracter
lbPasarMay
liContador
Dim
Dim
Dim
Dim
'
pasamos
lcCaracteres
la
'
lbPasarMay
For
el
ConvertirProperCase()
As
As
As
String
Char
Char
Boolean
Integer
un
array
Char
msCadValor.ToCharArray()
As
As
cadena
convertir
recorrer
array
liContador
If
lbPasarMay
'
convertir
a
lcCaracteres(liContador)
mayscula
=
hacer
=
0
las
oportunas
conversiones
True
UBound(lcCaracteres)
To
lbPasarMay
Then
=
False
cada
primera
letra
del
nombre
Char.ToUpper(lcCaracteres(liContador))
Else
'
convertir
lcCaracteres(liContador)
End
If
lbPasarMay
End
Next
'
'
'
Return
End
minscula
=
el
resto
de
letras
Char.ToLower(lcCaracteres(liContador))
If
Char.IsWhiteSpace(lcCaracteres(liContador))
=
aunque
devolvemos
previamente
a
el
pasamos
un
New
Function
Then
True
If
nombre
el
tipo
convertido,
Char
String
String(lcCaracteres)
array
End
Class
Cdigo fuente 323
Como puede observar el lector, la no existencia de un tipo determinado de formato no es un problema, ya que
con este sistema, podemos crear nuestro propios formatos.
Delegacin
de
cdigo
eventos
Delegados (delegates)
Un delegado o delegate, es un objeto al que otros objetos ceden (delegan) la ejecucin de su cdigo. Tambin se
conocen como punteros a funcin con seguridad de tipos.
Al instanciar un delegado, se asocia con un mtodo de instancia o compartido de un objeto, y posteriormente,
durante la ejecucin, ser el delegado el que se encargue de ejecutar dicho mtodo y no el propio objeto. Tambin se
pueden asociar los delegados con procedimientos Sub o Function de mdulos.
Declaracin de delegados
Para declarar un delegado, debemos utilizar la palabra clave Delegate, seguida del tipo de mtodo (Sub o
Function) al que posteriormente deberemos asociar el delegado; y finalmente, el nombre del delegado con la lista de
parmetros y valor de retorno si es necesario. El lugar de declaracin debe ser la zona de declaraciones de la clase o
mdulo. Veamos unos ejemplos en el Cdigo fuente 324.
'
Public
'
Public
delegado
Delegate
Delegate
'
Public
sin
Sub
parmetro
VerMensaje()
delegado
con
Sub
Aviso(ByVal
lsTexto
delegado
Delegate
Function
As
parametros
String)
de
Obtener(ByVal
tipo
ldtFecha
As
function
Date)
As
String
Para que el lector pueda reproducir los ejemplos mostrados en este tema, abra un nuevo proyecto de tipo
aplicacin de consola en VS.NET.
Creacin de delegados
Seguidamente, y ya en un procedimiento, declaramos una variable correspondiente al tipo del delegado. A
continuacin, conectamos el delegado con el procedimiento que posteriormente deber ejecutar, empleando la palabra
clave AddressOf, seguida del nombre del procedimiento.
AddressOf devuelve el puntero o direccin de entrada al procedimiento, que ser lo que utilice el delegado para
saber la ubicacin del procedimiento que debe ejecutar. Por ltimo, para ejecutar el procedimiento al que apunta el
delegado, llamaremos a su mtodo Invoke( ). En el Cdigo fuente 325, se muestran dos tcnicas para crear un
delegado; la segunda es mucho ms simple, pero en ambas, el resultado es el mismo: la ejecucin indirecta del
procedimiento MostrarTexto( ), a travs del delegado.
Module
Public
Delegate
Module1
VerMensaje()
Sub
'
Modo
-----------------------------
Sub
'
Dim
declarar
loDelegTexto
'
obtener
'
y
loDelegTexto
'
ejecutar
loDelegTexto.Invoke()
End
la
direccin
asignarla
del
el
Main()
delegado
VerMensaje
un
As
procedimiento
procedimiento
al
AddressOf
travs
del
ejecutar
delegado
MostrarTexto
delegado
Sub
'
Modo
Sub
'
declarar
el
'
o
Dim
loDelegTexto
loDelegTexto.Invoke()
2
delegado
puntero
As
-----------------------------
asociar
a
New
con
un
VerMensaje(AddressOf
End
'
'
'
Public
una
Main()
direccin
procedimiento
MostrarTexto)
Sub
este
ser
el
por
Console.WriteLine("Hola,
End
End
esto
es
***********************************************
procedimiento
invocado
(ejecutado)
el
delegado
Sub
MostrarTexto()
una
prueba
con
delegados")
Sub
Module
Una de las ventajas de este tipo de entidades de la plataforma, consiste en que un mismo delegado puede llamar
a mtodos diferentes de objetos distintos. En el caso del Cdigo fuente 326, un delegado invoca a dos procedimientos
diferentes.
Module
Public
Delegate
Module1
VerMensaje()
Sub
Sub
Dim
loDelegMensa
loDelegMensa
loDelegMensa.Invoke()
loDelegMensa
loDelegMensa.Invoke()
End
AddressOf
VisualizarFecha
Sub
Public
Dim
ldtFecha
Console.WriteLine("La
End
MostrarTexto
AddressOf
'
procedimientos
ejecutados
Public
Sub
Console.WriteLine("Hola,
esto
es
una
End
End
Main()
VerMensaje
As
por
los
prueba
delegados
MostrarTexto()
con
delegados")
Sub
Sub
ldtFecha
=
actual
fecha
VisualizarFecha()
Date
Date.Today
{0:G}",
ldtFecha)
As
es
Sub
Module
Si delegamos un procedimiento que admite parmetros, a la hora de invocarlo con el delegado, debemos pasar al
mtodo Invoke( ) los valores de los parmetros, en el mismo orden que especifica el procedimiento. Veamos el
ejemplo del Cdigo fuente 327.
Module
Public
Delegate
Sub
Aviso(ByVal
lsTexto
As
Module1
String)
Sub
Dim
loGestionarAviso
loGestionarAviso
=
loGestionarAviso.Invoke("Recuerda
loGestionarAviso
=
loGestionarAviso.Invoke("Realizar
Main()
Aviso
As
New
apagar
New
la
Aviso(AddressOf
el
Aviso(AddressOf
copia
de
Normal)
servidor")
Urgente)
seguridad")
Console.ReadLine()
End
Sub
Public
Sub
Console.WriteLine("*
End
Public
Sub
Normal(ByVal
lsTexto
{0}
Urgente(ByVal
As
*",
lsTexto
As
String)
lsTexto)
Sub
String)
Console.WriteLine("
{0}
!!!",
lsTexto.ToUpper)
Sub
Module
End
End
En el caso de delegacin hacia funciones, cuando invoquemos el cdigo con el delegado, deberemos obtener el
valor de retorno de la funcin. Veamos el ejemplo del Cdigo fuente 328.
Module
Public
Delegate
Function
Obtener(ByVal
Sub
'
obtener
Dim
ldtFecha
Console.WriteLine("Introducir
ldtFecha
'
'
Dim
Dim
If
crear
el
ldtFecha
Date)
As
Module1
String
Main()
fecha
Date
fecha")
Console.ReadLine()
una
As
una
=
un
delegado,
y
segn
delegado
ejecutar
loManipFecha
lsResultado
ldtFecha.Month
loManipFecha
Else
loManipFecha
End
As
=
=
el
mes
una
de
la
funcin
fecha
As
As
<
AddressOf
AddressOf
obtenida,
determinada
Obtener
String
Then
RecuperaMes
DameDiaSemana
If
'
como
el
delegado
ejecuta
funciones,
recuperamos
el
valor
'
de
retorno
al
invocar
la
funcin
correspondiente
lsResultado
=
loManipFecha.Invoke(ldtFecha)
Console.WriteLine("El
resultado
obtenido
es:
{0}",
lsResultado)
Console.ReadLine()
End
Sub
Public
Return
End
Function
RecuperaMes(ByVal
ldtFecha
As
Date)
As
String
ldtFecha.ToString("MMMM")
Function
Aunque en los anteriores ejemplos, hemos invocado los delegados desde el mismo procedimiento en que han
sido creados, podemos, naturalmente, pasar un delegado como parmetro a un procedimiento, y que sea dicho
procedimiento el encargado de ejecutar el cdigo que guarda el delegado. De esta forma, si el anterior ejemplo lo
variamos ligeramente, y aadimos un procedimiento que reciba el delegado y el parmetro, obtendramos el Cdigo
fuente 329.
Sub
'
'
'
llamar
a
un
procedimiento
Gestionar(loManipFecha,
'
'
que
ejecuta
el
Main()
......
......
delegado
ldtFecha)
......
......
End
Sub
ldtUnaFecha
Dim
lsResultado
Console.WriteLine("El
lsResultado
=
resultado
As
obtenido
Date)
As
String
loDelObtener.Invoke(ldtUnaFecha)
es:
{0}",
lsResultado)
End
Sub
Module
Module1
Sub
Dim
loManipFecha
loManipFecha.Fecha
Console.WriteLine("Fecha
loManipFecha
=
=
larga:
As
New
#6/27/2002
{0}",
Main()
ManipFecha
ManipFecha()
7:40:00
PM#
loManipFecha.DevFechaLarga())
Console.ReadLine()
End
End
Public
Private
Sub
Module
Class
mdtFecha
As
ManipFecha
Date
Public
mdtFecha
End
Public
Get
Return
End
Sub
New()
Date.Now
Sub
Property
Fecha()
As
Date
mdtFecha
Get
Set(ByVal
mdtFecha
End
End
Public
Return
End
End
Value
As
Date)
Value
Set
Property
Function
DevFechaLarga()
As
String
mdtFecha.ToLongDateString()
Function
Class
Despus de finalizar el desarrollo de la clase y distribuirla, se presenta el siguiente problema: los programadores
que la utilizan, disponen de rutinas de formateo propias que necesitaran implementar en nuestra clase.
Este punto, evidentemente, lo podramos resolver utilizando herencia; no obstante, vamos a solucionar el
problema mediante delegados. Por lo tanto, aadiremos un delegado a la clase ManipFecha, y un mtodo que lo
invoque; al ejecutar este mtodo, le pasaremos la direccin del procedimiento que contiene la rutina personalizada de
formateo. Ver Cdigo fuente 331.
Module
Sub
'
crear
Dim
loManipFecha
loManipFecha.Fecha
Module1
un
loManipFecha
=
=
objeto
de
As
New
#6/27/2002
la
7:40:00
Main()
clase
ManipFecha
ManipFecha()
PM#
'
llamar
ahora
al
mtodo
que
ejecuta
un
delegate;
'
le
pasamos
a
este
mtodo
la
direccin
del
'
procedimiento
que
el
delegate
debe
invocar
Dim
lsFormatoResultado
As
String
lsFormatoResultado
=
loManipFecha.FormateoExterno(AddressOf
ObtenerHora)
Console.WriteLine("Formateo
externo
resultante:
{0}",
lsFormatoResultado)
Console.ReadLine()
End
'
'
'
Public
Sub
este
es
un
procedimiento
que
personalizada
de
formateo,
y
desde
el
delegate
Function
ObtenerHora(ByVal
ldtFecha
Return
End
End
Public
Class
'
'
'
declarar
un
delegado,
a
'
ejecutaremos
rutinas
de
cdigo
Public
Delegate
Function
RealizaFormato(ByVal
'
'
'
este
mtodo
utiliza
un
'
parmetro
para
invocar
a
'
a
contiene
una
que
ser
del
As
Date)
As
rutina
invocado
objeto
String
ldtFecha.ToString("H:m")
Function
Module
ManipFecha
....
....
travs
del
cual,
externas
a
la
clase
ldtFecha
As
Date)
As
String
....
....
delegado
pasado
como
un
procedimiento
externo
la
clase
Public
Function
FormateoExterno(ByVal
String
Return
End
End
loDelegFormat
As
RealizaFormato)
As
loDelegFormat.Invoke(mdtFecha)
Function
Class
Public
'
los
mtodos
'
aplican
un
'
Public
Function
Return
Class
clase,
reciben
y
devuelven
formato
Marinero(ByVal
ldtFecha
de
esta
formato
fecha
a
cadena
As
Date)
ldtFecha.ToString("Cua\derno
"en
el
ao
Formatos
la
que
con
el
resultante
As
String
una
una
\de
yyyy,
bi\tcora:
dd
"
\de
End
Shared
Return
"MMM-d-yyyy
End
End
Function
Espacial(ByVal
ldtFecha.ToString("Diario
/
ldtFecha
As
e\s\telar:
Sec\tor
Date)
"
As
&
MMMM")
Function
String
&
_
Ga\m\ma")
Function
Class
Para conseguir, ya en Main( ), que el delegado de la clase ManipFecha ejecute el cdigo de la clase Formatos,
podemos utilizar dos tcnicas.
Por un lado, instanciamos un objeto de Formatos, y pasamos al mtodo FormateoExterno( ), del objeto
ManipFecha, la direccin del mtodo Marinero( ) del objeto Formatos.
Por otra parte, en lo referente al mtodo Espacial( ) de la clase Formatos, no es necesario crear un objeto.
Debido a que dicho mtodo es compartido, podemos pasar su direccin al mtodo FormateoExterno( ), del objeto
ManipFecha.
Module
Sub
'
crear
Dim
loManipFecha
loManipFecha.Fecha
Module1
un
loManipFecha
=
=
objeto
#6/27/2002
de
As
New
la
7:40:00
Main()
clase
ManipFecha
ManipFecha()
PM#
Dim
'
'
Dim
lsFormatoResultado
instanciar
un
objeto
los
mtodos
oFormato
'
ahora
'
ManipFecha,
'
Formatos,
'
lsFormatoResultado
pasamos
la
en
de
oFormato.Marinero)
Console.WriteLine("Formato
de
la
clase
personalizados
As
al
mtodo
direccin
de
donde
tenemos
formateo
=
estilo
marinero:
'
aqu
efectuamos
la
'
pero
pasamos
como
'
de
la
clase
Formatos,
'
instanciar
un
lsFormatoResultado
=
Formatos.Espacial)
Console.WriteLine("Formato
As
estilo
en
New
String
la
de
que
tenemos
formateo
Formatos()
FormateoExterno()
del
objeto
un
mtodo
del
objeto
una
rutina
personalizada
de
fecha
loManipFecha.FormateoExterno(AddressOf
{0}",
lsFormatoResultado)
misma
operacin
que
antes,
parmetro
un
mtodo
shared
es
decir,
no
es
necesario
objeto
de
Formatos
loManipFecha.FormateoExterno(AddressOf
espacial:
{0}",
lsFormatoResultado)
Console.ReadLine()
End
End
Sub
Module
Cdigo fuente 333
Eventos. Qu es un evento?
Un evento es un suceso o situacin, que acontece en una ubicacin de espacio y tiempo no predecible.
Cuando una mquina deja de funcionar por una avera, o cuando una persona resbala y cae, estamos en ambos
casos, ante ejemplos de eventos, ya que ocurren en momentos inesperados.
Para que se desencadene un evento, se deben dar determinadas circunstancias, las cuales favorecen el que dicho
evento se produzca.
Eventos en .NET
Cindonos al mbito de la programacin, un evento es, dentro de una aplicacin, una notificacin lanzada por
un objeto, que podr ser respondida por aquellos otros objetos interesados en darle soporte.
Public
Class
'
variables
de
Private
msNombre
Private
mdbSueldo
'
Public
Get
Empleado
propiedad
String
Double
As
As
propiedad
Nombre()
Property
Return
End
Set(ByVal
Nombre
String
As
Value
msNombre
Get
String)
As
msNombre
Value
Set
Property
End
End
'
Public
Get
Return
End
'
Property
propiedad
Sueldo()
Sueldo
Double
As
mdbSueldo
Get
al
'
si
'
mostrar
'
Set(ByVal
If
asignar
un
valor
el
valor
un
mensaje
asignacin
Value
Value
es
y
>
Console.WriteLine("Asignacin
de
la
superior
no
del
As
propiedad,
a
permitir
1000
1000
la
sueldo
Double)
Then
sueldo
incorrecta")
Console.ReadLine()
Else
mdbSueldo
End
End
End
End
Value
If
Set
Property
Class
Una vez finalizado el desarrollo de la clase, la distribuimos a nuestro cliente. Posteriormente, un nuevo cliente
nos requiere la clase, pero en esta ocasin, aunque necesita la validacin sobre la propiedad Sueldo, no quiere que se
muestre el mensaje al sobrepasar el sueldo asignado.
Se nos plantea en este caso un problema, ya que si escribimos una nueva versin de la clase Empleado,
tendremos el trabajo extra de mantener ambas. Para solucionarlo mediante una nica versin de la clase recurriremos a
los eventos.
Dejemos ya atrs los aspectos conceptuales sobre eventos que estamos discutiendo, y veamos en los siguientes
apartados, cada uno de los integrantes de la gestin de eventos en detalle.
El emisor de eventos
Un emisor de eventos, tambin denominado origen de eventos (event source o event sender), es un objeto
capacitado para generar y lanzar eventos al sistema, que puedan ser recuperados por otros objetos preparados para
realizar su tratamiento.
Para que un objeto pueda desencadenar eventos, en su clase debemos realizar dos tareas:
.
Declarar el propio evento usando la palabra clave Event, especificando si es necesario una lista de
parmetros que acompaan al evento.
.
Lanzar el evento mediante la palabra clave RaiseEvent, seguida del nombre del evento a disparar. Si
hemos declarado el evento con parmetros, deberemos aadir los valores para cada uno de los parmetros en el mismo
orden en el que los hemos declarado.
Situndonos pues ante el problema planteado por la clase Empleado en un apartado anterior, la solucin que
proponemos consistir en generar desde la clase Empleado un evento cuando se produzca un fallo en la validacin del
sueldo. De esta manera, el cdigo cliente que lo necesite, responder al evento; y el que no lo precise, har caso omiso
del evento lanzado.
En primer lugar, declaramos en la zona de declaraciones de la clase el evento LimiteSueldo, que ir
acompaado de un parmetro que nos informar del importe errneo que se intentaba asignar a la propiedad.
A continuacin, en la propiedad Sueldo, cuando detectemos que el sueldo sobrepasa el valor permitido, en lugar
de lanzar all el mensaje a la consola, generaremos el evento LimiteSueldo, que podr ser recuperado por el cdigo
cliente que haga uso de la clase, actuando como necesite en cada ocasin. Observe el lector, que al mismo tiempo que
lanzamos el evento, le pasamos el importe del sueldo que se intentaba asignar. Veamos el Cdigo fuente 335.
Public
'
Public
Class
Empleado
declaramos
LimiteSueldo(ByVal
Event
Private
Private
el
ldbImporte
msNombre
mdbSueldo
Public
evento
Double)
As
As
As
Property
Nombre()
String
Double
As
String
Get
Return
End
Set(ByVal
Value
msNombre
Get
String)
As
msNombre
Value
Set
Property
End
End
Public
Property
Sueldo()
As
Double
Get
Return
End
Set(ByVal
'
'
If
Value
si
al
el
sueldo
As
valor
Else
mdbSueldo
End
End
End
End
que
supera
Value
'
...lanzamos
el
'
como
parmetro
'
incorrecto
que
RaiseEvent
mdbSueldo
Get
Double)
>
intentamos
el
1000
asignar
permitido...
Then
evento,
y
le
pasamos
informativo
el
valor
intentbamos
asignar
LimiteSueldo(Value)
=
Value
If
Set
Property
Class
Con estas modificaciones sobre la clase Empleado, ya tenemos listo nuestro emisor de eventos. Queda ahora por
completar la parte que captura los eventos lanzados por el emisor.
El receptor de eventos
Un receptor de eventos, tambin denominado manipulador de eventos (event receiver o event handler), es
aquella parte del cdigo cliente, que configuramos para que sea capaz de recibir los eventos generados por un objeto
emisor. Para que ambos elementos, en este canal de comunicacin que es la transmisin de eventos puedan operar, es
necesario conectarlos.
Module
Private
'......
'......
Module1
WithEvents
moEmple
As
Empleado
A continuacin, tenemos que escribir el procedimiento manipulador, que ser invocado cada vez que se dispare
el evento. Dicho procedimiento debe ser de tipo Sub, ya que un evento no puede devolver valores, por lo que no
podremos utilizar un Function; tambin debemos finalizar su declaracin con la palabra clave Handles, seguida del
nombre de la variable del objeto que hemos declarado en la zona de declaraciones, y el nombre del evento que el
procedimiento va a tratar. En el Cdigo fuente 337, el procedimiento moEmple_LimiteSueldo( ), ser llamado cada
vez que se produzca el evento LimiteSueldo en el objeto Empleado.
Public
Handles
Sub
moEmple_LimiteSueldo(ByVal
ldbImporte As Double) _
moEmple.LimiteSueldo
Console.WriteLine("Se
ha
"
establecido
moEmple.Nombre)
Console.WriteLine("El
Console.ReadLine()
End
importe
sobrepasado
de
{0}
no
es
para
{0}
vlido",
el
lmite"
sueldo",
&
_
_
ldbImporte)
Sub
El nombre utilizado para el procedimiento puede ser cualquiera, aunque en este caso hemos empleado la
convencin NombreObjeto_NombreEvento simplemente para facilitar la lectura del cdigo, pero podramos haber
empleado, por ejemplo, el que se muestra en el Cdigo fuente 338.
Public
Handles
'
Sub
'
End
Sobrepasado(ByVal
ldbImporte As Double) _
moEmple.LimiteSueldo
....
....
Sub
Un pequeo truco que tenemos en el editor de cdigo de VS.NET, para facilitar la creacin de los
procedimientos manipuladores de evento, consiste en abrir la lista Nombre de clase y seleccionar el nombre de la
variable que hemos declarado WithEvents. Ver Figura 207.
Seguidamente pasamos a la lista Nombre de mtodo, y all elegimos el nombre del evento que vamos a
codificar. Ver Figura 208.
Esto nos crea el procedimiento manipulador de evento vaco, en base a una convencin de nombres predefinida
en el IDE. Ver Cdigo fuente 339.
End
ldbImporte
As
Double)
Handles
Sub
Como hemos escrito el manipulador de evento para el objeto Empleado en un mdulo, vamos ahora a escribir
un procedimiento Main(), instanciando en el mismo, un objeto de esta clase. Asignaremos en primer lugar, un valor
correcto a la propiedad Sueldo, y a continuacin un valor que provocar el evento en la clase. Recomendamos al lector
que ejecute el cdigo lnea a lnea con el depurador, para observar el efecto cuando se produzca el evento.
Sub
Main()
moEmple
New
moEmple.Nombre
Empleado()
moEmple.Sueldo
moEmple.Sueldo
500
=
'
8000
esta
'
"Juan"
asignacin
esta
no
provoca
provoca
el
el
evento
evento
End
Sub
Module
Module1
'....
'....
'
manipuladores
de
evento
que
conectaremos
en
tiempo
de
ejecucin
Public
Sub
SobreAsignacionSueldo(ByVal
ldbImporte
As
Double)
Console.WriteLine("Se
intent
asignar
a
un
empleado
el
sueldo
{0}"
&
_
ControlChars.CrLf
&
"ESTO
ES
INCORRECTO!",
ldbImporte)
End
Sub
Public
Sub
SalarioIncorrecto(ByVal
Console.WriteLine("INFORME
DE
Console.WriteLine("======================")
Console.WriteLine("Error
al
intentar
asignar
el
ldbImporte)
End
Sub
'....
'....
End
Module
Cdigo fuente 341
ldbImporte
salario
{0}
As
a
un
Double)
INCIDENCIAS")
empleado",
Como ventaja adicional, el objeto sobre el que vamos a manipular sus eventos podemos declararlo tanto a nivel
local como en la zona de declaraciones, a diferencia del enlace esttico, que nos obligaba a declarar el objeto en la
zona de declaraciones del mdulo en el que furamos a utilizarlo.
Para establecer un enlace dinmico entre un evento y un manipulador, utilizaremos la instruccin AddHandler.
Esta instruccin, recibe como primer parmetro el evento a conectar en el formato NombreObjeto.NombreEvento.
Como segundo parmetro, pasaremos la direccin de entrada al procedimiento que deber ejecutar el evento, y que
obtenemos a travs de la instruccin AddressOf. El Cdigo fuente 342, muestra el procedimiento Main( ), en el que
pedimos al usuario que introduzca un nmero, y segn el valor obtenido, conectamos el evento con uno de los dos
procedimientos manipuladores antes descritos.
Module
Module1
'....
'....
Sub
'
pedir
un
nmero
al
usuario
para
conectar
a
'
dos
procedimientos
manipuladores
de
evento
que
Dim
liTipoManip
As
Console.WriteLine("Introduzca
el
nmero
1
"
para
liTipoManip
seleccionar
'
manipulador
=
instanciar
loMiEmpleado
Dim
'
'
en
Select
el
asignar
un
funcin
manejador
del
nmero
uno
hemos
2,"
de
evento
un
As
de
que
Main()
de
los
escrito
Integer
&
_
a
utilizar")
Console.ReadLine()
objeto
New
evento
el
en
Empleado
Empleado()
tiempo
usuario
de
ha
Case
Case
AddHandler
loMiEmpleado.LimiteSueldo,
AddressOf
ejecucin
introducido
liTipoManip
1
SobreAsignacionSueldo
Case
2
AddHandler loMiEmpleado.LimiteSueldo, AddressOf SalarioIncorrecto
End
Select
loMiEmpleado.Nombre
'
esta
'
ello
'
de
loMiEmpleado.Sueldo
Console.ReadLine()
End
'....
'....
End
asignacin
ejecutar
uno
evento
Sub
Module
Un evento es un delegado
"ANTONIO"
provoca
de
que
=
el
los
hemos
evento,
manipuladores
conectado
2500
El sistema interno que utiliza .NET Framework para la creacin, conexin y ejecucin de eventos, est basado
en delegados.
Cuando declaramos en una clase, un evento con la instruccin Event, se crea de modo transparente para el
programador, un nuevo delegado con el nombre del evento ms la palabra EventHandler. Ver Cdigo fuente 343.
Public
'
al
Public
Event
Class
declarar
LimiteSueldo(ByVal
'
...internamente
Public
Delegate
Sub
el
ldbImporte
se
crea
As
Empleado
evento...
Double)
el
LimiteSueldoEventHandler(ByVal
siguiente
ldbImporte
'....
'....
End
As
delegado
Double)
Class
Al conectar el evento de un objeto con un procedimiento manipulador, en alguno de los modos descritos en los
anteriores apartados, se crea, tambin de un modo transparente, una nueva instancia
del delegado. No obstante, en este caso, el programador s puede de forma explcita, realizar la creacin del
delegado. El Cdigo fuente 344, muestra como en el segundo parmetro de AddHandler creamos manualmente el
delegado, que internamente ejecuta el procedimiento manipulador de evento.
New
AddHandler
loMiEmpleado.LimiteSueldo,
Empleado.LimiteSueldoEventHandler(AddressOf
_
SobreAsignacionSueldo)
Finalmente, cuando desde la clase se lanza el evento con RaiseEvent, internamente se ejecuta el mtodo Invoke(
) del delegado, lo cual producir la ejecucin del procedimiento asociado al delegado. Ver Cdigo fuente 345.
'
la
RaiseEvent
'
instruccin
RaiseEvent...
LimiteSueldo(Value)
...realmente
'
En los ejemplos sobre captura de eventos realizados hasta ahora con la clase Empleado, dentro de los
procedimientos manipuladores de evento, no disponemos de acceso a los miembros del objeto que ha originado el
evento.
El nico modo de los vistos hasta ahora de conseguir tal acceso, es declarar el objeto en la zona de declaraciones
del mdulo y, en ese caso, al tener visibilidad sobre la variable del objeto en todos los procedimientos del mdulo, s
podramos manejar el objeto.
Sin embargo, qu ocurre cuando instanciamos un objeto Empleado con mbito local en Main( ), y asociamos
sus manipuladores de evento con AddHandler?. Simplemente, que desde dichos procedimientos manipuladores de
evento, no podemos obtener informacin del objeto Empleado para, por ejemplo, recuperar el valor de la propiedad
Nombre.
Una solucin simple, pero no eficaz, consistira en pasar la/s propiedad/es como parmetro cuando lanzamos el
evento, es decir, al llamar a RaiseEvent( ) en la clase Empleado. Ver Cdigo fuente 346.
Public
Class
Empleado
'....
RaiseEvent
'....
End
LimiteSueldo(Value,Me.Nombre)
Class
Pero seguiramos limitados, en el caso de que necesitramos pasar cualquier otro tipo de informacin que no
estuviera directamente relacionada con el objeto.
Para solucionar este problema, podemos utilizar la tcnica empleada por la propia plataforma .NET en la
retransmisin de eventos, y que explicamos a continuacin.
La jerarqua de clases de .NET dispone de la clase EventArgs, diseada para guardar la informacin adicional
que pasamos a un procedimiento manipulador de evento.
Podemos crear una clase que herede de EventArgs, y adaptarla, en este caso, para que contenga la informacin
adicional sobre un evento que se ha producido en la clase Empleado, de modo que cuando se ejecute su manipulador
asociado, pasemos a dicho manipulador, como primer parmetro, el propio objeto Empleado, y como segundo, un
objeto de nuestra clase EventArgs personalizada, con datos adicionales sobre el evento generado. Este es el esquema
general de trabajo con los eventos en .NET.
Escribiremos por lo tanto la clase EmpleadoEventArgs, que hereda de EventArgs, y que servir para que cuando
a un objeto Empleado se le intente asignar un sueldo incorrecto, se almacene en ella dicho valor errneo. Ver Cdigo
fuente 347.
'
clase
para
guardar
informacin
sobre
'
los
eventos
lanzados
por
la
clase
Empleado;
' esta clase en concreto, guardar el valor del sueldo
'
errneo
que
se
ha
intentado
asignar
a
un
empleado
Public
Class
EmpleadoEventArgs
Inherits
EventArgs
Private
mdbSueldoIntentadoAsig
Public
Property
As
Double
SueldoIntentadoAsig()
As
Double
Get
SueldoIntentadoAsig
End
Set(ByVal
=
Value
mdbSueldoIntentadoAsig
Get
Double)
As
mdbSueldoIntentadoAsig
Value
Set
Property
Class
End
End
End
Seguidamente retocaremos el cdigo de la clase Empleado, cambiando la declaracin del evento LimiteSueldo,
y la seccin Set de su procedimiento Property Sueldo, tal y como se muestra en el Cdigo fuente 348.
Public
Class
Empleado
'
declaramos
el
evento
LimiteSueldo,
'
el
primer
parmetro
ser
la
instancia
y
objeto
'
Empleado
actualmente
en
ejecucin;
'
el
segundo
parmetro
ser
un
objeto
EmpleadoEventArgs,
'
con
la
informacin
adicional
del
evento
producido
Public
Event
LimiteSueldo(ByVal
sender
As
Empleado,
_
ByVal
As
EmpleadoEventArgs)
'....
'....
Public
Property
Sueldo()
As
Double
Get
Return
End
Set(ByVal
'
'
If
Value
si
al
el
sueldo
Value
As
valor
que
intentamos
el
1000
supera
>
'
...creamos
un
'
y
le
pasamos
a
'
informacin
sobre
el
'
caso
slo
pasamos
'
que
se
intent
asignar
Dim
loEvArgs
As
loEvArgs.SueldoIntentadoAsig
End
End
el
sueldo
asignar
permitido...
Then
objeto
EmpleadoEventArgs
sus
propiedades
la
evento;
en
este
el
valor
incorrecto
a
la
propiedad
Sueldo
New
EmpleadoEventArgs()
=
Value
'
despus
lanzamos
el
evento
y
le
'
como
parmetro
el
propio
objeto
Empleado
'
y
el
objeto
con
la
informacin
del
RaiseEvent
LimiteSueldo(Me,
Else
'
si
mdbSueldo
mdbSueldo
Get
Double)
es
=
pasamos
actual
evento
loEvArgs)
correcto,
se
asigna
Value
If
Set
End
Property
End
Class
'....
'....
Los nombres empleados en la declaracin del evento de esta clase: sender, para designar al emisor del evento; y
e, para designar los argumentos del evento, no son en absoluto obligatorios, pudiendo el lector utilizar los nombres que
estime oportunos. El haber utilizado estas denominaciones se debe a seguir la misma convencin que utiliza la
plataforma. En los temas dedicados a formularios y controles Windows, el lector podr comprobar que los
procedimientos manipuladores de evento, usan estos mismos nombres.
Para terminar, escribimos en el mdulo un procedimiento manipulador para el evento LimiteSueldo, y en Main(
) instanciamos un objeto Empleado, asociando el evento del objeto al manipulador de evento que acabamos de
escribir. Ver el Cdigo fuente 349.
Module
Module1
Sub
'
declarar
Dim
loEmpleado
'
aadir
AddHandler
e
loEmpleado
=
instanciar
un
manipulador
de
loEmpleado.LimiteSueldo,
loEmpleado.Nombre
loEmpleado.Sueldo
5000
un
As
New
evento
para
AddressOf
el
=
esto
'
Main()
Empleado
Empleado
Empleado()
objeto
evento
LimiteSueldo
SobreAsignacionSueldo
provoca
"ANA"
evento
el
Console.ReadLine()
End
Sub
'
'
'
'
del
del
que
Public
ByVal
procedimiento
manipulador
del
parmetro
sender
obtenemos
el
parmetro
e
obtenermos
intentbamos
asignar
al
Sub
SobreAsignacionSueldo(ByVal
e
As
Console.WriteLine("Se
intent
ControlChars.CrLf
&
sender.Nombre,
e.SueldoIntentadoAsig)
asignar
"ESTO
al
evento
nombre
del
el
importe
sueldo
del
sender
empleado
ES
{0},
As
LimiteSueldo;
Empleado,
incorrecto
empleado
Empleado,
_
EmpleadoEventArgs)
el
sueldo
{1}"
INCORRECTO!",
&
_
_
_
End
Sub
End
Module
Aunque este modo de trabajo suponga un esfuerzo adicional por nuestra parte en cuanto a que tengamos que
escribir algo ms de cdigo, los eventos de nuestras clases tendrn una estructura de llamada ms acorde con el resto
de eventos de las clases pertenecientes a la plataforma.
Arrays
Aspectos bsicos
Tambin conocido con las denominaciones de matriz y vector, un array es aquel elemento del lenguaje que nos
permite agrupar un conjunto de valores del mismo tipo, y acceder a ellos a travs de una misma variable o
identificador, especificando la posicin o ndice en donde se encuentra el dato a recuperar. El Cdigo fuente 350,
muestra las operaciones esenciales que podemos realizar con un array.
Sub
'
declarar
un
array
de
tipo
'
el
nmero
de
elementos
es
el
'
en
la
declaracin
ms
uno,
porque
la
'
posicin
de
un
array
es
Dim
sNombres(3)
As
'
sNombres(0)
sNombres(1)
sNombres(2)
sNombres(3)
'
Dim
sValor
asignar
pasar
un
'
mostrar
en
'
y
un
Console.WriteLine("Valor
Console.WriteLine("Valor
Main()
String,
indicado
primera
cero
String
valores
=
=
=
=
valor
sValor
del
al
array
As
array
"Ana"
"Pedro"
"Antonio"
"Laura"
una
la
consola
valor
de
la
del
el
valor
directamente
variable
array,
posicin
pasado
desde
sValor:
1:
una
el
{0}",
{0}",
variable
String
sNombres(2)
variable
array
sValor)
sNombres(1))
Console.ReadLine()
End
Sub
Cdigo fuente 350
A lo largo de este texto, emplearemos de forma genrica el trmino array, para referirnos a este elemento del
lenguaje. Por otra parte, recomendamos al lector la creacin de un nuevo proyecto en el IDE de tipo consola, para
realizar las pruebas mostradas a lo largo del tema.
La clase Array
Esta clase, perteneciente a la jerarqua de clases del sistema, es decir, incluida en el espacio de nombres System,
proporciona a travs de sus miembros, acceso orientado a objeto para los arrays que manipulemos en nuestras
aplicaciones. Esto quiere decir que los arrays, como sucede con otros elementos del lenguaje, son tambin objetos.
Al igual que el resto de elementos del entorno, los arrays son tipos pertenecientes al sistema comn de tipos de
la plataforma o CTS, y se encuentran clasificados como tipos por referencia; esto quiere decir, que durante la
ejecucin, un array ser gestionado en la zona de memoria conocida como montn o heap.
Aunque podemos trabajar con los arrays como objetos, no ser necesario instanciar un objeto de esta clase para
poder disponer de un array. Al declarar una variable como array, implcitamente se instancia un objeto de la clase. En
sucesivos apartados de este tema, haremos una descripcin de los miembros de instancia y compartidos ms
importantes de la clase Array.
Cdigo
==========
Option
VB6
Base
Public
Sub
Dim
sNombres(2)
sNombres(1)
sNombres(2)
End
Main()
As
=
"Ana"
Sub
String
"Pedro"
Cdigo
=============
Public
Sub
VB.NET
Main()
'
array
de
Dim
sNombres(2)
elementos
As
sNombres(0)
String
sNombres(1)
"Pedro"
=
sNombres(2)
"Ana"
"Jaime"
Sub
End
Cdigo fuente 351
Cdigo
VB6,
no
soportado
==================================
Public
Sub
'
array
VB.NET
Main()
de
'
Dim
en
elementos,
ndices
Nombres(5
5
To
Nombres(5)
Nombres(8)
=
=
End
As
los
8
String
"Pedro"
Nombres(6)
Nombres(7)
y
8)
entre
"Ana"
"Jaime"
"Elena"
Sub
Declaracin
Declararemos un array de igual forma que hacemos con una variable normal, con la excepcin de que junto al
nombre de la variable, situaremos unos parntesis. Esto indica que dicha variable contiene un array. Opcionalmente,
podemos especificar entre los parntesis las dimensiones del array, o nmero de elementos que va a contener. Es
posible tambin, realizar una asignacin de valores al array en el mismo momento de su declaracin. El Cdigo fuente
353, muestra algunos ejemplos.
Sub
Main()
'
formas
de
declaracin
de
arrays
'
===============================
'
1)
'
estableciendo
el
nmero
de
elementos
Dim
sNombres(2)
As
String
'
2)
'
asignando
valores
al
array
al
mismo
tiempo
que
se
declara,
'
la
lista
de
valores
debe
ir
encerrada
entre
llaves
Dim
sEstaciones()
As
String
=
{"Ana",
"Pedro",
"Luis"}
'
3)
'
indicando
el
tipo
de
dato
pero
no
el
nmero
de
elementos,
'
de
este
modo
la
variable
todava
no
es
considerada
un
array
'
ya
que
contiene
una
referencia
a
Nothing
Dim
iValores()
As
Integer
'
4)
'
indicando
el
tipo
de
dato
y
estableciendo
una
'
lista
vaca
de
elementos,
'
a
diferencia
del
caso
anterior,
la
variable
ahora
s
'
es
considerada
un
array
aunque
de
longitud
cero
Dim
iDatos()
As
Integer
=
{}
'
5)
'
instanciando
el
tipo
de
dato,
estableciendo
el
nmero
' de elementos al instanciar, e indicando que se trata de un array
'
al
situar
las
llaves
Dim
iCantidades()
As
Integer
=
New
Integer(20)
{}
'
6)
'
declarar
primero
la
variable
que
contendr
el
array,
'
asignar
valores
al
array
al
mismo
tiempo
que
se
instancia
'
la
lista
de
valores
debe
ir
encerrada
entre
llaves
Dim
iNumeros()
As
Integer
iNumeros
=
New
Integer()
{10,
20,
30,
10,
50,
60,
10,
70,
80}
End
Sub
Recomendamos al lector, que en estos ejemplos con arrays, utilice el depurador para ejecutar lnea a lnea el
cdigo, y abra la ventana Locales del depurador para ver en cada caso, el contenido de los elementos del array.
Sub
Main()
'
asignacin
de
valores
a
los
elementos
de
un
array
'
=================================================
Dim
sNombres(4)
As
String
'
directamente
sobre
la
variable,
'
haciendo
referencia
sNombres(0)
=
sNombres(1)
=
sNombres(2)
=
'
o
con
el
mtodo
SetValue(),
'
valor
en
el
primer
parmetro
'
la
posicin
en
sNombres.SetValue("Elena",
sNombres.SetValue("Miguel",
al
ndice
"Juan"
"Ana"
"Luis"
asignando
el
y
especificando
el
segundo
3)
4)
'
obtencin
de
valores
de
un
array
'
================================
Dim
sValorA
As
String
Dim
sValorB
As
String
sValorA
=
sNombres(2)
'
directamente
de
la
variable
sValorB
=
sNombres.GetValue(3)
'
usando
el
meth
GetValue
Console.WriteLine("Contenido
de
las
variables")
Console.WriteLine("==========================")
Console.WriteLine("ValorA:
{0}
-ValorB:
{1}",
sValorA,
sValorB)
Console.ReadLine()
End
Sub
Recorrer el contenido
Para realizar un recorrido por los elementos de un array, disponemos de las funciones LBound( ) y UBound( ),
que devuelven el nmero de ndice inferior y superior respectivamente del array que pasemos como parmetro. No
obstante, la orientacin a objetos proporcionada por el entorno, pone a nuestra disposicin el nuevo conjunto de
caractersticas que comentamos seguidamente.
.
Length. Esta propiedad de un objeto array devuelve el nmero de elementos que contiene.
.
GetLowerBound( ), GetUpperBound( ). Estos mtodos de un objeto array, devuelven
respectivamente, el nmero de ndice inferior y superior de una dimensin del array. El resultado es el mismo que
usando LBound( ) y UBound( ), pero desde una perspectiva orientada a objetos.
.
Enumeradores. Un objeto enumerador pertenece al interfaz IEnumerator, diseado para realizar un
recorrido o iteracin a travs de uno de los diferentes tipos de coleccin (arrays incluidos) existentes en .NET
Framework. Mediante el mtodo GetEnumerator( ) de un objeto array, obtenemos un objeto que implementa el
interfaz Ienumerator, que slo puede realizar labores de lectura sobre el array, en ningn caso de modificacin.
La estructura de control utilizada para recorrer el array, puede ser indistintamente un bucle For...Next, For
Each...Next, o la novedosa tcnica de los objetos enumeradores proporcionados por el objeto array.
Como muestra de estas funcionalidades, el Cdigo fuente 355 que vemos a continuacin, contiene algunos
ejemplos de cmo realizar una iteracin sobre los elementos de un array.
Sub
'
'
Dim
Dim
Dim
recorrer
sNombres()
As
String
iContador
sUnNombre
un
=
{"Ana",
As
As
Main()
array
=================
"Luis",
"Pablo"}
Integer
String
'
Console.WriteLine("Recorrido
For
iContador
modo
array
con
LBound(sNombres)
del
=
Console.WriteLine("Posicion:
{0}
LBound()
To
Valor:
iContador,
Next
Console.WriteLine()
'
con
Console.WriteLine("Recorrido
For
Each
{1}",
sNombres(iContador))
bucle
array
sUnNombre
del
Console.WriteLine("Nombre
Next
Console.WriteLine()
'
usando
Console.WriteLine("Recorrido
For
iContador
=
tradicional
UBound()")
UBound(sNombres)
con
actual:
Console.WriteLine("Posicion:
{0}
Each
Each")
sNombres
For
{0}",
la
array
To
del
For
bucle
In
sUnNombre)
propiedad
con
propiedad
(sNombres.Length
-
Valor:
iContador,
Next
Console.WriteLine()
Length
Length")
1)
{1}",
sNombres(iContador))
'
usando
los
mtodos
GetLowerBound()
y
GetUpperBound()
Console.WriteLine("Recorrido
del
array
con
mtodos
GetLowerBound()
y
GetUpperBound()")
For
iContador
=
sNombres.GetLowerBound(0)
To
sNombres.GetUpperBound(0)
Console.WriteLine("Posicion:
{0}
Valor:
{1}",
_
iContador,
Next
Console.WriteLine()
sNombres(iContador))
'
recorrer
con
un
enumerador
Console.WriteLine("Recorrido
del
array
con
un
enumerador")
Dim
sLetras()
As
String
=
{"a",
"b",
"c",
"d"}
Dim
oEnumerador
As
System.Collections.IEnumerator
'
obtener
el
enumerador
del
array
oEnumerador
=
sLetras.GetEnumerator()
'
con
un
enumerador
no
es
necesario
posicionarse
'
en
el
primer
elemento
ni
calcular
la
cantidad
'
de
elementos
del
array,
slo
hemos
de
avanzar
'
posiciones
con
MoveNext()
y
obtener
el
valor
'
actual
con
Current
While
oEnumerador.MoveNext()
Console.WriteLine("Valor
End
Console.ReadLine()
End
actual:
{0}",
oEnumerador.Current)
While
Sub
Modificacin de tamao
Para aumentar o disminuir el nmero de elementos de un array disponemos de la palabra clave ReDim. Esta
instruccin crea internamente un nuevo array, por lo que los valores del array original se pierden.
Evitaremos este problema utilizando junto a ReDim la palabra clave Preserve, que copia en el nuevo array, los
valores del array previo. Veamos unos ejemplos en el Cdigo fuente 356.
'
'
Sub
modificar
Main()
el
tamao
de
un
array
===============================
Dim
sNombres(0)
sNombres(1)
sNombres(2)
Console.WriteLine("Array
MostrarArray(sNombres)
sNombres(2)
'
ampliamos
ReDim
sMasNombres(3)
sMasNombres(4)
Console.WriteLine("Array
MostrarArray(sMasNombres)
'
reducimos
'
ReDim
Console.WriteLine("Array
MostrarArray(sMasNombres)
String
"Juan"
"Pedro"
"Elena"
original")
sNombres
'
ampliamos
'
pero
ReDim
sNombres(3)
sNombres(4)
Console.WriteLine("Array
MostrarArray(sNombres)
'
Dim
sMasNombres(0)
sMasNombres(1)
sMasNombres(2)
Console.WriteLine("Array
MostrarArray(sMasNombres)
As
=
=
=
el
nmero
el
perdemos
de
contenido
elementos
previo
sNombres(4)
"Isabel"
"Raquel"
ampliado")
=
=
sNombres
con
tamao
creamos
sMasNombres(2)
otro
As
array
String
"Juan"
"Pedro"
"Miguel"
original")
=
=
=
sMasNombres
el
array
Preserve
=
=
ampliado
sMasNombres
el
sin
array,
primeros
Preserve
perder
sin
pero
perder
sin
sMasNombres
elementos
sMasNombres(4)
"Antonio"
"Paco"
valores")
perder
los
elementos
sMasNombres(1)
reducido")
Console.ReadLine()
End
'
'
Dim
For
Sub
Private
Sub
MostrarArray(ByVal
sMiLista()
As
String)
este
es
un
procedimiento
de
apoyo
que
muestra
el
array
pasado
como
parmetro
iContador
As
Integer
iContador
=
0
To
sMiLista.Length
1
Console.WriteLine("Elemento:
iContador,
Next
Console.WriteLine()
End
{0}
Valor:
{1}",
sMiLista(iContador))
Sub
Sub
Main()
'
declarar
un
array
del
modo
habitual:
'
este
array
tiene
cuatro
elementos,
'
desde
el
ndice
0
al
3
Dim
sEstaciones(3)
As
String
sEstaciones(0)
=
"Primavera"
sEstaciones(1)
=
"Verano"
sEstaciones(2)
=
"Otoo"
sEstaciones(3)
=
"Invierno"
Console.WriteLine("Array
sEstaciones")
MostrarArray(sEstaciones)
'
crear
un
array
instancindolo
'
con
el
mtodo
CreateInstance()
'
de
la
clase
Array
Dim
sColores
As
Array
'
este
array
tendr
tres
elementos
reales
'
que
van
desde
el
ndice
0
hasta
el
2
sColores
=
Array.CreateInstance(GetType(String),
3)
sColores(0)
=
"Azul"
sColores(1)
=
"Rojo"
sColores(2)
=
"Verde"
Console.WriteLine("Array
sColores")
MostrarArray(sColores)
Console.ReadLine()
End
'
Dim
For
Sub
Private
Sub
MostrarArray(ByVal
sMiLista()
As
String)
muestra
el
array
pasado
como
parmetro
iContador
As
Integer
iContador
=
0
To
sMiLista.Length
1
Console.WriteLine("Elemento:
iContador,
Next
Console.WriteLine()
End
{0}
Valor:
{1}",
sMiLista(iContador))
Sub
Sub
Main()
Dim
iValores()
As
Integer
=
{10,
20,
30}
'
en
ambos
casos,
se
pasa
una
referencia
del
array
ManipArrayVal(iValores)
ManipArrayRef(iValores)
'
al
volver
de
las
llamadas
a
los
procedimientos,
'
el
array
ha
sido
modificado
en
ambas
llamadas,
'
independientemente
de
que
haya
sido
pasado
por
'
valor
o
referencia
MostrarArray(iValores)
Console.ReadLine()
End
'
Sub
este
procedimiento
le
pasamos
Private
Sub
ManipArrayVal(ByVal
iListaPorValor
'
cambiar
elemento
del
iListaPorValor(0)
=
As
un
array
por
Integer())
array
888
End
'
Sub
este
procedimiento
le
pasamos
Private
Sub
ManipArrayRef(ByRef
iListaPorReferencia
'
cambiar
elemento
del
iListaPorReferencia(2)
=
un
array
As
por
referencia
Integer())
array
457
End
'
Dim
For
valor
Sub
Private
Sub
MostrarArray(ByVal
sMiLista()
As
Integer)
muestra
el
array
pasado
como
parmetro
iContador
As
Integer
iContador
=
0
To
sMiLista.Length
1
Console.WriteLine("Elemento:
iContador,
Next
Console.WriteLine()
End
{0}
Valor:
{1}",
sMiLista(iContador))
Sub
Clonacin
Para evitar el problema planteado en el apartado anterior, si necesitamos disponer de un array con las mismas
caractersticas que uno ya existente, y que sea totalmente independiente del primero, utilizaremos el mtodo Clone( ).
Con esto solucionaremos el problema de que al pasar un array como parmetro, las modificaciones que
precisemos realizar, afecten al array original. Veamos un ejemplo en el Cdigo fuente 359.
Sub
'
crear
Dim
iValores()
As
CambiaArray(iValores)
un
=
Integer
'
mostrar
'
en
este
Console.WriteLine("Array
MostrarArray(iValores)
no
Main()
array
20,
30}
{10,
el
se
array
habrn
original,
cambios
original")
producido
Console.ReadLine()
End
Sub
Private
Sub
CambiaArray(ByVal
'
crear
un
'
cambiarle
valores
Dim
iListaClonada
iListaClonada
=
iListaClonada(0)
iListaClonada(1)
Console.WriteLine("Array
MostrarArray(iListaClonada)
iListaDatos
As
Integer())
array
clnico,
y
mostrarlo
As
Array
iListaDatos.Clone()
=
621
=
900
clnico")
End
Private
Dim
For
Sub
Sub
MostrarArray(ByVal
sMiLista()
As
iContador
As
iContador
=
0
To
sMiLista.Length
Console.WriteLine("Elemento:
iContador,
Next
Console.WriteLine()
End
{0}
Integer)
Integer
1
Valor:
{1}",
sMiLista(iContador))
Sub
Copia
Si intentamos copiar un array asignando la variable que contiene un array a otra, el resultado real sern dos
variables que apuntan a la misma lista de valores, por lo que en definitiva slo tendremos un array, al cual podremos
acceder usando dos variables. Ello es debido a que como explicamos en un apartado anterior, los arrays son tipos por
Sub
Dim
sColores(0)
sColores(1)
sColores(2)
sColores(3)
MostrarArray(sColores)
Main()
sColores(3)
As
String
"Azul"
"Verde"
"Rosa"
"Blanco"
=
=
=
=
'
copiar
usando
'
copiamos
en
'
y
comenzando
por
'
valores
del
Dim
sColorDestino(6)
sColores.CopyTo(sColorDestino,
Console.WriteLine("Array
MostrarArray(sColorDestino)
el
el
su
mtodo
array
posicin
array
As
CopyTo(),
sColorDestino,
2,
los
sColores
String
2)
sColorDestino")
'
copiar
usando
el
mtodo
Copy(),
'
copiamos
en
el
array
sListaColores,
'
a
partir
de
su
posicin
2,
'
2
elementos
del
array
sColores,
comenzando
'
desde
la
posicin
1
de
sColores
Dim
sListaColores(5)
As
String
Array.Copy(sColores,
1,
sListaColores,
2,
2)
Console.WriteLine("Array
sListaColores")
MostrarArray(sListaColores)
Console.ReadLine()
End
Sub
Private
Dim
For
Sub
MostrarArray(ByVal
sMiLista()
As
iContador
As
iContador
=
0
To
sMiLista.Length
Console.WriteLine("Elemento:
iContador,
Next
Console.WriteLine()
End
{0}
String)
Integer
1
Valor:
{1}",
sMiLista(iContador))
Sub
Inicializacin de valores
Para inicializar o eliminar los valores de los elementos de un array, utilizaremos el mtodo Clear, al que
pasaremos el array a inicializar, el ndice a partir del que comenzaremos, y el nmero de elementos.
Los valores sern inicializados en funcin del tipo de dato del array; cadena vaca en arrays String; cero en
arrays numricos, etc Veamos el Cdigo fuente 361.
Sub
'
array
String,
asignar
Dim
sLetras(2)
sLetras(0)
sLetras(1)
sLetras(2)
'
limpiar
elementos
en
un
'
los
elementos
limpiados
Array.Clear(sLetras,
Console.WriteLine("Array
MostrarArray(sLetras)
valores
As
=
=
=
array
quedan
0,
'
array
Integer,
Dim
iNumeros()
As
Integer
'
limpiar
elementos
'
los
elementos
Array.Clear(iNumeros,
Console.WriteLine("Array
MostrarArrayNum(iNumeros)
de
como
Main()
inicializar
String
"a"
"b"
"c"
tipo
String,
cadena
vaca
1)
sLetras")
asignar
{100,
en
un
limpiados
valores
e
200,
300,
400,
array
de
tipo
se
ponen
1,
'
array
Object,
asignar
valores
Dim
oVarios(6)
As
oVarios(0)
=
oVarios(1)
=
oVarios(2)
=
oVarios(3)
=
oVarios(4)
=
oVarios(5)
=
oVarios(6)
=
'
al
ser
este
un
array
de
'
los
elementos
limpiados
se
establecen
Array.Clear(oVarios,
3,
Console.WriteLine("Array
MostrarArrayObj(oVarios)
tipo
a
inicializar
500,
600}
Integer,
a
0
2)
iNumeros")
inicializar
Object
"Hola"
456
1200
#12/25/2001#
900
True
"adelante"
Object
Nothing
2)
oVarios")
Console.ReadLine()
End
Sub
'
recorrer
Private
Sub
Dim
For
iContador
MostrarArray(ByVal
iContador
=
0
To
Console.WriteLine("Elemento:
iContador,
Next
Console.WriteLine()
End
un
{0}
array
de
sMiLista()
As
As
sMiLista.Length
-
Valor:
cadenas
String)
Integer
1
{1}",
sMiLista(iContador))
Sub
'
recorrer
Private
Sub
Dim
For
iContador
un
array
MostrarArrayNum(ByVal
iContador
=
0
To
Console.WriteLine("Elemento:
{0}
de
iMiLista()
As
As
iMiLista.Length
-
nmeros
Integer)
Integer
1
Valor:
{1}",
iContador,
Next
Console.WriteLine()
iMiLista(iContador))
End
Sub
'
recorrer
Private
Sub
Dim
For
iContador
un
array
MostrarArrayObj(ByVal
iContador
=
0
To
Console.WriteLine("Elemento:
{0}
de
oMiLista()
As
oMiLista.Length
-
objetos
As
Object)
Integer
1
Valor:
{1}",
iContador,
Next
Console.WriteLine()
oMiLista(iContador))
End
Sub
Ordenacin
Para ordenar un array disponemos del mtodo Sort( ), que al estar sobrecargado, tiene varias implementaciones;
la ms bsica de ellas es la que ordena la totalidad del array. Tambin podemos ordenar una parte del array, indicando
la posicin inicial y cantidad de elementos a ordenar, etc.
El mtodo Reverse( ), invierte la posicin de todos o parte de los elementos de un array. En este punto, debemos
matizar que no se realiza un orden inverso de los elementos, sino que se cambian las posiciones de los mismos. Ver
Cdigo fuente 362.
Sub
'
ordenar
Dim sLetras1() As String
Array.Sort(sLetras1)
Console.WriteLine("Ordenar
MostrarArray(sLetras1)
'
ordenar
Dim
sLetras2()
As
String
Array.Sort(sLetras2,
Console.WriteLine("Ordenar
MostrarArray(sLetras2)
'
invertir
Dim
sLetras3()
As
String
Array.Reverse(sLetras3,
Console.WriteLine("Invertir
MostrarArray(sLetras3)
todo
{"z", "a",
"g",
"m",
todos
"g",
4,
array")
"m",
parte
valores
{"z",
"i",
Main()
array
"c", "b"}
el
parte
"a",
{"z",
el
"w",
"a",
valores
del
"w",
"i",
"c",
array
"b"}
3)
array")
del
"i",
"c",
array
"b"}
4)
array")
del
dentro
"g",
"m",
2,
"w",
del
Console.ReadLine()
End
Sub
Private
Sub
MostrarArray(ByVal
sMiLista()
As
iContador
As
iContador
=
0
To
sMiLista.Length
Dim
For
Console.WriteLine("Elemento:
{0}
String)
Integer
1
Valor:
iContador,
Next
Console.WriteLine()
{1}",
sMiLista(iContador))
End
Sub
Bsqueda
Los mtodos IndexOf( ) y LastIndexOf( ) de la clase Array, nos permiten buscar un elemento en un array
comenzando la bsqueda desde el principio o final respectivamente.
Ya que ambos disponen de diferentes implementaciones al estar sobrecargados, consulte el lector la
documentacin de la plataforma. El Cdigo fuente 363 muestra algunos ejemplos de uso.
Dim
Sub
sNombres()
As
String
'
buscar
una
Console.WriteLine("Paco
{"Alberto",
cadena
est
"Juan",
partir
en
"Ana",
del
la
"Paco",
ndice
posicin
"Miguel",
del
{0}",
Array.IndexOf(sNombres,
'
buscar
array
_
"Paco"))
una
Console.WriteLine("Ana
"
comenzando
Array.IndexOf(sNombres,
Main()
"Ana"}
cadena
est
partir
en
buscar
del
ndice
la
posicin
desde
ndice
"Ana",
del
{0},"
&
3",
'
introducir
un
valor
a
buscar
en
el
'
si
no
existe
se
devuelve
Dim
iPosicionBuscar
As
Console.WriteLine("Introducir
nombre
a
iPosicionBuscar
=
Array.IndexOf(sNombres,
Console.ReadLine())
If
iPosicionBuscar
Console.WriteLine("El
nombre
no
Else
Console.WriteLine("El nombre est
array",
iPosicionBuscar)
End
=
est
en
la
-1
en
el
posicin
Then
array")
{0}
del
_
If
array
_
_
3))
array,
-1
Integer
buscar")
_
'
buscar
Dim
Dim
iNumeros
=
New
Console.WriteLine("El
comenzando
por
la
ltima
iNumeros()
As
iUltPosicionBuscar
As
Integer()
{10,
20,
30,
10,
50,
60,
10,
10
est
en
la
posicin
{0}
comenzando
por
el
posicin
Integer
Integer
70,
80}
final",
_
Array.LastIndexOf(iNumeros,
10))
Console.ReadLine()
End
Sub
Cdigo fuente 363
Arrays multidimensionales
Todos los arrays vistos hasta el momento han sido de tipo unidimensional, es decir, estaban compuestos de una
lista de valores nica.
.NET Framework nos provee tambin de la capacidad de crear arrays formados por ms de una lista de valores,
o lo que es igual, arrays multidimensionales. Un array de este tipo, se caracteriza por estar compuesto de varias
dimensiones o listas anidadas al estilo de filas y columnas.
Si declaramos un array del modo que muestra el Cdigo fuente 364.
Dim
iDatos(2,
4)
As
Integer
Crearamos un array multidimensional formado por tres filas y cinco columnas. En este caso, el nmero
correspondiente a la primera dimensin denota las filas, mientras que el nmero de la segunda dimensin hace lo
propio para las columnas. La Figura 209 muestra un diagrama con la estructura de este array.
Figura 209. Estructura de un array multidimensional.
En este tipo de arrays, para acceder a los valores, debemos especificar la dimensin y la posicin a la que vamos
a asignar o recuperar un dato. Ver Cdigo fuente 365.
Sub
'
Main()
crear
Dim
array
iDatos(2,
iDatos(0, 0) =
1000
iDatos(0, 1) =
2000
iDatos(0, 2) =
3000
iDatos(0, 3) =
4000
multidimensional
4)
rellenar
As
de
valores
Integer
iDatos(0, 4) =
iDatos(1, 0) =
5000
25
iDatos(1, 1) =
35
iDatos(1, 2) =
45
iDatos(1, 3) =
55
iDatos(1, 4) =
iDatos(2, 0) =
65
111
iDatos(2, 1) =
222
iDatos(2, 2) =
333
iDatos(2, 3) =
444
iDatos(2, 4) =
555
End
Cdigo fuente 365
Sub
Tipo de dato
(Nombre de clase)
Byte
SByte
Descripcin
Byte
Int16
Short
Int32
Integer
Int64
Long
UInt16
UInt32
UInt64
Single
Single
Double
Double
Boolean
Boolean
Valor lgico
Char
Char
Decimal
Decimal
IntPtr
UIntPtr
String
Interfaz de usuario
System.Windows.Forms
System.Drawing
Acceso a datos
System.Data
System.XML
Manejo
ensamblados
de
System.Reflection
Procesador
MHz
Mnimo
Recomendado
Pentium II 450
128 MB
Memoria
Espacio
duro
en
disco
3 GB
256 MB
Control
Prefijo
Label
lbl
Button
btn
TextBox
txt
CheckBox
chk
ListBox
lst
ComboBox
cbo
RadioButton
rbt
MainMenu
Mnu
GroupBox
grp
MainMenu
ContextMenu
mnu
FontDialog
ColorDialog
y
dems
controles
de
caja
dilogo
dlg
'
'
'
'
'
Major Version
Minor Version
Build Number
Revision
Tipo de
Tipo
dato
en correspondiente en el
VB.NET
entorno
de
.NET
Framework
Boolean
System.Boolean
Tamao
Rango de valores
1 byte
Byte
System.Byte
1 byte
Char
System.Char
2 bytes
Date
System.DateTime
8 bytes
1 de enero de 1 a 31 de diciembre
de 9999
Decimal
System.Decimal
12 bytes
+/79.228.162.514.264.337.593.543.950.335
sin
punto
decimal;
+/7,9228162514264337593543950335 con
28 posiciones a la derecha del signo
decimal; el nmero ms pequeo distinto
de
cero
es
+/0,0000000000000000000000000001
Double
(punto flotante
con precisin
doble)
Integer
Long
(entero largo)
System.Double
8 bytes
System.Int32
4 bytes
System.Int64
8 bytes
Short
System.Int16
2 bytes
Single
System.Single
4 bytes
System.Object
4 bytes
(punto
flotante
con
precisin
simple)
Object
String
(cadena
de
longitud
variable)
-2.147.483.648 a 2.147.483.647
-9.223.372.036.854.775.808 a
9.223.372.036.854.775.807
-32.768 a 32.767
-3,402823E38 a 1,401298E45 para
valores
negativos;
1,401298E-45 a
3,402823E38 para valores
positivos
Cualquier tipo
10 bytes
Desde 0 a unos 2.000
+ (2 * longitud millones de caracteres Unicode
de la cadena)
System.String
Hereda
Estructura
(tipo de dato System.ValueType
definido por el
usuario)
-1,79769313486232E308 a
4,94065645841247E-324 para valores
negativos; 4,94065645841247E-324 a
1,79769313486232E308 para valores
positivos
de
Suma de
Cada
miembro
de
la
los tamaos de estructura tiene un intervalo de
los miembros
valores determinado por su tipo de
datos e independiente de los
intervalos
de
valores
correspondientes a los dems
miembros
de la
estructura
Resultado
10
' devuelve: 1
Mod 3
Resultado = 100
Mod 27
Resultado = 38
Mod 4
Operador
<
' devuelve: 19
' devuelve: 2
El
resultado
Verdadero cuando
Menor que
ExpresinA
ExpresinB
<=
Menor
o
ExpresinA
igual que
ExpresinB
>
Mayor que
ExpresinA
ExpresinB
>=
Mayor
o
ExpresinA
igual que
ExpresinB
=
Igual a
ExpresinA
ExpresinB
<>
Distinto de
ExpresinA
ExpresinB
Resultado = 10
Resultado
< 45
=
<= 7
Resultado = 25
> 50
es
El resultado
Falso cuando
<
ExpresinA
ExpresinB
ExpresinA
ExpresinB
ExpresinA
ExpresinB
ExpresinA
ExpresinB
ExpresinA
ExpresinB
ExpresinA
ExpresinB
<=
>
>=
=
<>
es
>=
>
<=
<
<>
=
Resultado = 80
>= 100
Resultado = 120
= 220
Resultado = 5
<> 58
Resultado
Resultado
Resultado
Resultado
=
=
=
=
"A"
"M"
"M"
"F"
= "a"
< "Z"
> "m"
<> "f"
'
'
'
'
devuelve:
devuelve:
devuelve:
devuelve:
False
True
False
True
End Sub
End Module
Cdigo fuente 89
Carcter
patrn
del
Coincidencia en la cadena a
buscar
?
[ListaCaracteres]
Cualquier nico
encuentre dentro
carcter
que
se
de la lista.
[!ListaCaracteres]
Cuando
devuelve
la
ExpresinA
True
Y la
El
ExpresinB resultado
devuelve
es
True
True
True
False
False
False
True
False
False
False
False
Cuando el bit de
Y el bit de
El valor del bit
ExpresinA es
ExpresinB es
resultante es
0
Cuando
Expresin
devuelve
la
El
resultado es
True
False
False
True
Cuando
devuelve
la
ExpresinA
True
Y la
El
ExpresinB resultado
devuelve
es
True
True
True
False
True
False
True
True
False
False
False
Cuando el bit de
Y el bit de
El valor del bit
ExpresinA es
ExpresinB es
resultante es
0
Cuando
devuelve
la
ExpresinA
True
Y la
El
ExpresinB resultado
devuelve
es
True
False
True
False
True
False
True
True
False
False
False
Cuando el bit de
Y el bit de
El valor del bit
ExpresinA es
ExpresinB es
resultante es
0
Cuando
devuelve
la
ExpresinA
Y la
El
ExpresinB resultado
devuelve
es
True
True
True
True
False
False
Cuando
ExpresinA devuelve
True
False
False
No se
evala
la
Y
ExpresinB
devuelve
No
evala
True
False
la
se
El
resultado es
True
True
False
False
False
mbito
que
define
Carcter
l
Local
m
p
Mdulo
(privado)
Proyecto
(pblico)
Tipo de dato
que
define
Carcter
b
Boolean
by
Byte
Char
dt
Date
dc
Decimal
db
Double
Integer
Long
sh
Short
sg
Single
Object
String
Descripcin
Nombre de
formato
General Date
Short Date
Short Time
Standard
Currency
Format(MiFecha,
"Long
' "viernes,
julio de
' "19/07/2002"
' "18:25"
' "1.804,00"
' "1.804 pta"
' "180400,00%"
Descripcin
Carcter de
formato
:
Separador de hora.
Separador de fecha.
ddd
dddd
dd
M
MM
MMM
MMMM
yy
yyyy
HH
19
de
mm
s
ss
0
#
,
.
Si la referencia de la
...y el tipo de objeto es
...el mtodo ejecutado
variable es de la clase...
de la clase...
ser de la clase
Base
Base
Base
Base
Derivada
Derivada
Derivada
Derivada
Derivada
Si la referencia de la
...y el tipo de objeto es
...el mtodo ejecutado
variable es de la clase...
de la clase...
ser de la clase
Base
Base
Base
Base
Derivada
Base
Derivada
Derivada
Derivada
' llama a
' llama
temprano
' llama a
' llama a
Sub Main()
Dim lDBanco1 As DatosBanco
Dim lDBanco2 As DatosBanco
lDBanco1.IDCuenta = 55
lDBanco2 = lDBanco1
lDBanco2.IDCuenta = 188
Console.WriteLine("lDBanco1.IDCuenta
lDBanco1.IDCuenta)
Console.WriteLine("lDBanco2.IDCuenta
lDBanco2.IDCuenta)
-->
{0}",
-->
{0}",
' 55
' 188
Console.WriteLine()
Dim loEmpleado1 As Empleado
Dim loEmpleado2 As Empleado
loEmpleado1 = New Empleado()
loEmpleado1.piIdentificador = 55
loEmpleado2 = loEmpleado1
loEmpleado2.piIdentificador = 188
Console.WriteLine("loEmpleado1.piIdentificador --> {0}", _
loEmpleado1.piIdentificador)
' 188
Console.WriteLine("loEmpleado2.piIdentificador --> {0}", _
loEmpleado2.piIdentificador)
Console.ReadLine()
End Sub
Lunes
Martes
Miercoles
' 0
' 1
=
278
Jueves
Viernes
Sabado
Domingo
End Enum
'
'
'
'
279
280
281
282
' 188
Carcter
formato
d
de
' "150"
' 150
Tipo de formato
Fecha corta
Fecha larga
g
t
Hora larga
m, M
Mes y da
y, Y
Ao y da
Carcter
Resultado
para
patrn
formato
D
de
Da del mes sin cero a la
izquierda
Da del mes con cero a la
izquierda
Dd
Ddd
Dddd
MM
MMM
MMMM
Yy
Ao en dos dgitos
Yyyy
Ao en cuatro dgitos
Mm
S
Ss
Carcter
formato
c,C
de
Tipo de formato
Monetario
d,D
Decimal
e,E
Cientfico
a la
a la
a la
a la
f,F
Punto fijo
g,G
General
n,N
Numrico
r,R
Redondeo en ambas
direcciones.
Asegura
que
las
conversiones de nmero
a
cadena
y
viceversa, no alteren el
valor de los
nmeros
x,X
Hexadecimal
Para recorrer arrays multidimensionales, la clase Array dispone de varios miembros, algunos de los
cuales, describimos seguidamente.
Rank. Devuelve el nmero de dimensiones del array.
GetLength(Dimension). Devuelve el nmero de elementos de la dimensin de array pasada como
parmetro.
GetLowerBound(Dimension). Devuelve el nmero de ndice inferior de la dimensin pasada como
parmetro.
GetUpperBound(Dimension). Devuelve el nmero de ndice superior de la dimensin pasada como
parmetro.
Vamos a completar el ejemplo anterior con las lneas del Cdigo fuente 366, necesarias para recorrer
el array multidimensional mostrado.
Sub
'....
'....
Dim
Dim
Dim
iContadorDimUno
iContadorDimDos
sTextoFila
'
"Col
"Col
Main()
poner
ttulos
As
As
As
de
Integer
Integer
String
la
Console.WriteLine("Fila"
0"
&
ControlChars.Tab
2"
&
ControlChars.Tab
&
'
el
bucle
fila
&
&
"Col
"Col
3"
externo
columnas
del
array
mostrar
ControlChars.Tab
&
1"
&
ControlChars.Tab
&
&
ControlChars.Tab
&
"Col
recorre
la
primera
_
_
4")
dimensin
For
iContadorDimUno
=
iDatos.GetLowerBound(0)
To
iDatos.GetUpperBound(0)
'
aqu
obtenemos
el
nmero
de
fila
'
que
se
est
procesando
sTextoFila
=
iContadorDimUno
&
ControlChars.Tab
'
este
bucle
recorre
la
segunda
dimensin
For
iContadorDimDos
=
iDatos.GetLowerBound(1)
To
iDatos.GetUpperBound(1)
sTextoFila
sTextoFila
&
iDatos(iContadorDimUno,
iContadorDimDos)
&
ControlChars.Tab
Next
'
mostrar
en
la
consola
el
contenido
Console.WriteLine(sTextoFila)
sTextoFila
Next
Console.WriteLine()
Console.WriteLine("El
Console.WriteLine("El
Console.ReadLine()
nmero
nmero
de
total
dimensiones
de
elementos
""
es:
es:
End
{0}",
{0}",
iDatos.Rank)
iDatos.Length)
Sub
Colecciones
preciso momento.
Por ejemplo, sera una gran idea poder manejar un array que creciera dinmicamente, sin tener que
preocuparnos por aumentar o disminuir su tamao; o tambin, disponer de un array a cuyos valores pudiramos
acceder, a travs de identificadores claves, y no por el nmero de ndice, que en algunas situaciones es ms incmodo
de manejar.
No se preocupe el lector, ya que no va a necesitar escribir complicados algoritmos para implementar estas
caractersticas en sus arrays. Todas las funcionalidades mencionadas, y algunas ms, se encuentran disponibles en un
tipo especial de array denominado coleccin (collection).
Una coleccin es un objeto que internamente gestiona un array, pero que est preparado, dependiendo del tipo
de coleccin, para manejar el array que contiene de una manera especial; podramos definirlo como un array
optimizado o especializado en ciertas tareas.
La clase ArrayList
Los objetos de tipo coleccin creados con esta clase, implementan un array cuyo nmero de elementos puede
modificarse dinmicamente.
Sub
Main()
'
crear
Dim
'
una
alEstaciones
crear
una
lista
'
pero
Dim
alDatos
'
Dim
lista
crear
alLetras
una
As
New
sin
As
indicando
New
el
ArrayList(New
New
utilizando
String()
de
darles
As
End
ArrayList()
nmero
sin
lista
elementos
una
{"a",
"b",
elementos
valor
ArrayList(3)
coleccin
dinmica
"c"})
Sub
Una coleccin dinmica se crea de forma muy similar a un array, con la diferencia de que no es necesario usar
una variable a la que asignar la coleccin, ya que en su lugar, se pasa como parmetro al constructor de ArrayList. El
modo de creacin de una coleccin dinmica consiste en utilizar la palabra clave New, seguida del tipo de dato de la
coleccin, los parntesis indicativos de array, y por ltimo, encerrados entre llaves, los valores de la coleccin.
.
InsertRange(Posicin, Coleccin). Inserta un conjunto de valores mediante una coleccin dinmica,
a partir de una posicin determinada dentro del array.
.
SetRange(Posicin, Coleccin). Sobrescribe elementos en un array con los valores de la coleccin
Coleccin, comenzando en la posicin Posicin.
El Cdigo fuente 368 muestra algunos ejemplos de asignacin de nuevos valores a un ArrayList.
Sub
Dim
alDatos
As
Main()
ArrayList(10)
New
alDatos.Add("a")
alDatos.AddRange(New
Console.WriteLine("ArrayList
RecorrerAList(alDatos)
String()
despus
alDatos.Insert(2,
Console.WriteLine("ArrayList
RecorrerAList(alDatos)
de
{"b",
usar
despus
alDatos.InsertRange(1,
Console.WriteLine("ArrayList
RecorrerAList(alDatos)
New
despus
alDatos.SetRange(3,
Console.WriteLine("ArrayList
RecorrerAList(alDatos)
New
despus
de
Integer()
de
String()
de
"c",
y
Add()
"d"})
AddRange()")
"hola")
Insert()")
usar
{55,
usar
77,
88})
InsertRange()")
{"zzz",
usar
"yyy"})
SetRange()")
Console.ReadLine()
End
Dim
While
Sub
Private
Sub
oEnumerador
RecorrerAList(ByVal
As
IEnumerator
Console.WriteLine("Valor:
End
Console.WriteLine()
alValores
As
ArrayList)
alValores.GetEnumerator()
oEnumerador.MoveNext()
{0}",
End
oEnumerador.Current)
While
Sub
Los valores que espera recibir una coleccin son del tipo genrico Object, por lo que podemos insertar valores
de diferentes tipos de dato.
Sub
'
crear
ArrayList
Dim
alLetras
As
alLetras.Add("a")
alLetras.AddRange(New
String()
aadir
New
{"b",
Main()
valores
ArrayList(6)
"c",
"d"})
'
recorrer
con
un
bucle
For
y
usando
la
propiedad
'
tener
en
cuenta
que
al
ser
cero
el
primer
ndice
del
'
tenemos
que
restar
uno
a
la
propiedad
Console.WriteLine("Recorrer
objeto
ArrayList
con
bucle
Dim
iContador
As
For
iContador
=
0
To
(alLetras.Count
Console.WriteLine("Elemento
iContador,
Next
actual
{0},
Count,
array,
Count
For")
Integer
1)
valor:
{1}",
_
alLetras(iContador))
Console.WriteLine()
'
recorrer
el
Console.WriteLine("Recorrer
objeto
Dim
oEnumerador
oEnumerador
=
While
Console.WriteLine("Elemento
de
array
ArrayList
con
con
As
la
lista:
{0}",
End
un
un
enumerador
enumerador")
IEnumerator
alLetras.GetEnumerator()
oEnumerador.MoveNext()
oEnumerador.Current())
While
Console.ReadLine()
End
Sub
Cdigo fuente 369
Console.WriteLine("Valores
Console.WriteLine("Capacidad
asignados
al
del
array:
array:
{0}",
alLetras.Count)
{0}",
alLetras.Capacity)
La capacidad es un aspecto de la clase ArrayList que mejora el rendimiento a la hora de aadir o eliminar
elementos del array. Analicemos esta caracterstica con ms detenimiento.
En primer lugar, todo objeto ArrayList dispone de una propiedad oculta llamada _items, conteniendo el array
que internamente gestiona los valores asignados. Esta es una propiedad que no puede manipular el programador, pero
que puede visualizar a travs del depurador, abriendo la ventana Locales y expandiendo el contenido de un objeto
Cuando creamos un objeto ArrayList con un tamao como el del ltimo ejemplo, la accin de aadir un valor a
la coleccin no redimensiona su array subyacente, puesto que ya est creado con un tamao determinado, sino que
asigna un valor al siguiente elemento libre que no hubiera sido previamente asignado. Vemoslo en el esquema de la
Figura 211.
Este comportamiento del objeto tiene la ventaja de que mejora el rendimiento y optimiza recursos, puesto que
cada vez que aadimos o eliminamos valores, el array _items no siempre tiene que ser redimensionado.
Qu sucede, sin embargo, cuando se han aadido valores y el array est completo?, pues que el objeto
ArrayList detecta esta situacin y en la siguiente ocasin en que se aade un nuevo valor, automticamente
redimensiona el array _items, duplicando el nmero de elementos inicial que contena. La Figura 212 muestra un
esquema con los pasos de este proceso.
En el caso que muestra la anterior figura, despus de aadir la letra m al objeto, la propiedad Capacity
devolvera 12 y la propiedad Count devolvera 9.
Un detalle muy importante que debe tener en cuenta el lector, es que al crear un objeto ArrayList, si no
especificamos el tamao, la propiedad _items tiene una capacidad por defecto de 16 elementos.
Sub
Dim
alLetras
alLetras.AddRange(New
String()
As
{"a",
"b",
New
"c",
"d",
"e",
Main()
ArrayList(10)
"f",
"g"})
Console.WriteLine("Array
RecorrerAList(alLetras)
alLetras")
'
obtener
un
subarray
Dim
alRangoLetras
alRangoLetras
=
Console.WriteLine("Array
RecorrerAList(alRangoLetras)
'
obtener
'
se
'
no
Dim
alLetrasFijo
'alLetrasFijo.Add("m")
alLetrasFijo(2)
Console.WriteLine("Array
RecorrerAList(alLetrasFijo)
un
pueden
se
As
<--
un
rango
As
alLetras.GetRange(4,
subarray
modificar
pueden
ArrayList
=
esto
=
'
ArrayList
Dim
alRepetidos
alRepetidos
=
alRepetidos.Add("otro
Console.WriteLine("Array
RecorrerAList(alRepetidos)
'
copiar
Dim
aNuevo
aNuevo(2)
Console.WriteLine("Array
RecorrerArray(aNuevo)
con
de
ArrayList
aNuevo
tamao
fijo,
sus
elementos,
aadir
valores
ArrayList.FixedSize(alLetras)
provocara
error
"vvv"
alLetrasFijo")
valores
As
ArrayList.Repeat("hola",
sobre
un
As
=
=
'
crear
ArrayList
'
a
partir
de
Dim
alLetrasSoloLeer
As
ArrayList
'
solamente
Console.WriteLine("ArrayList
de
RecorrerAList(alLetrasSoloLeer)
'
las
dos
'alLetrasSoloLeer.Add("yyy")
'alLetrasSoloLeer(2)
de
lneas
determinado
ArrayList
2)
alRangoLetras")
de
un
=
podemos
siguientes
repetidos
ArrayList
3)
valor")
alRepetidos")
array
normal
Array
alLetras.ToArray()
"zzz"
aNuevo")
slo
lectura
array
existente
ArrayList.ReadOnly(alLetras)
recorrerlo
slo
lectura")
provocaran
un
error
"wwer"
Console.ReadLine()
End
Dim
While
Sub
Private
Sub
oEnumerador
RecorrerAList(ByVal
As
IEnumerator
Console.WriteLine("Valor:
End
Console.WriteLine()
alValores
As
ArrayList)
alValores.GetEnumerator()
oEnumerador.MoveNext()
{0}",
End
Dim
While
Private
Sub
oEnumerador
oEnumerador.Current)
While
Sub
RecorrerArray(ByVal
As
IEnumerator
=
aValores
As
Array)
aValores.GetEnumerator()
oEnumerador.MoveNext
Console.WriteLine("Valor:
End
Console.WriteLine()
{0}",
oEnumerador.Current)
While
End
Sub
Respecto a los ArrayList de tamao fijo, tipo FixedSize, queremos advertir al lector que a la hora de ver su
contenido en el depurador, no debe consultar la propiedad _items mencionada anteriormente, ya que esta contendr un
array de valores vacos.
Este punto puede crear confusin, ya que el lector al ejecutar la aplicacin s obtendr los valores de la
coleccin FixedSize, por lo que se preguntar dnde han ido a parar esos valores.
El secreto reside en el siguiente lugar: al ejecutar con el depurador, debemos expandir la propiedad
[System.Collections.ArrayList.FixedSizeArrayList] del ArrayList con tamao fijo. Dentro de esta propiedad, que es
realmente una variante del objeto ArrayList, abriremos la propiedad _list, y de nuevo dentro de esta propiedad
encontraremos otra con el nombre _items, la cual ser la que contiene realmente los valores del array de tamao fijo.
La Figura 213 muestra la ventana Locales del depurador ejecutando el ejemplo.
Sub
Dim
alLetras
alLetras.AddRange(New
"jj",
As
String()
"ee",
New
{"jj",
"oo",
"tt",
Main()
ArrayList(10)
"aa",
_
"mm",
"xx"})
Dim
iPosicIndexOf
'
buscar
un
elemento
de
iPosicIndexOf
=
Console.WriteLine("Posicin
al
buscar
As
la
coleccin
con
Dim
iPosicLastIndexOf
'
buscar
un
elemento
de
la
iPosicLastIndexOf
=
Console.WriteLine("Posicin
al
buscar
Integer
el
principio
alLetras.IndexOf("aa")
{0}",
iPosicIndexOf)
desde
IndexOf:
As
Integer
desde
el
final
alLetras.LastIndexOf("jj")
LastIndexOf:
{0}",
_
coleccin
con
iPosicLastIndexOf)
Dim
'
comprobar
si
bEncontrado
Console.WriteLine("Resultado
bEncontrado
existe
un
=
de
la
bsqueda
As
valor
con
Boolean
la
coleccin
alLetras.Contains("oo")
Contains:
{0}",
bEncontrado)
en
Console.ReadLine()
End
Sub
Cdigo fuente 372
Sub
'
borra
Dim
alLetras1
alLetras1.AddRange(New
String()
alLetras1.Clear()
Estado("alLetras1",
todos
As
{"a",
"e",
Main()
elementos
ArrayList(10)
"f",
"g"})
alLetras1)
'
borra
un
Dim
alLetras2
alLetras2.AddRange(New
String()
alLetras2.Remove("c")
Estado("alLetras2",
'
borra
Dim
alLetras3
alLetras3.AddRange(New
String()
"b",
los
New
"c",
"d",
elemento
As
{"a",
"b",
"c",
por
New
"d",
el
"e",
valor
ArrayList(10)
"f",
"g"})
alLetras2)
un
elemento
As
{"a",
"b",
"c",
por
New
"d",
"e",
posicin
ArrayList(10)
"f",
"g"})
alLetras3.RemoveAt(5)
Estado("alLetras3",
alLetras3)
'
borra
un
rango
de
Dim
alLetras4
As
alLetras4.AddRange(New
String()
{"a",
"b",
alLetras4.RemoveRange(2,
Console.WriteLine("Array
alLetras4:
estado
Estado("alLetras4",
'
reajustar
alLetras4.TrimToSize()
Console.WriteLine("Array
alLetras4:
Estado("alLetras4",
elementos
New
"c",
"d",
antes
por
posicin
ArrayList(10)
"e",
"f",
"g"})
3)
reajustar
tamao")
alLetras4)
de
capacidad
estado
despus
del
de
reajustar
array
tamao")
alLetras4)
Console.ReadLine()
End
Sub
Sub
Dim
alLetras
alLetras.AddRange(New
String()
As
{"z",
'
alLetras.Sort()
Console.WriteLine("ArrayList
RecorrerAList(alLetras)
"t",
New
"c",
"a",
"k",
Main()
ArrayList(10)
"f",
"m"})
ordenar
despus
'
invertir
alLetras.Reverse(3,
Console.WriteLine("ArrayList
RecorrerAList(alLetras)
de
posiciones
despus
de
de
invertir
Console.ReadLine()
End
Dim
While
Sub
Private
Sub
oEnumerador
RecorrerAList(ByVal
As
IEnumerator
alValores
As
ArrayList)
alValores.GetEnumerator()
oEnumerador.MoveNext()
ordenar")
elementos
3)
elementos")
Console.WriteLine("Valor:
End
Console.WriteLine()
{0}",
End
oEnumerador.Current)
While
Sub
La clase Hashtable
Esta clase tiene la particularidad de que el acceso a los valores del array que gestiona internamente se realiza a
travs de una clave asociada a cada elemento, al estilo de los objetos Dictionary de versiones anteriores de VB. Como
dato significativo, esta clase implementa el interfaz IDictionary, por lo que si hemos utilizado anteriormente objetos
Dictionary, ya conocemos gran parte de su filosofa de trabajo.
En este tipo de coleccin no es necesario preocuparse por la posicin o ndice de los elementos, ya que
accedemos a ellos a travs de literales, lo cual en algunas circunstancias es mucho ms cmodo de manejar.
Dim
aCliente
aCliente(0)
aCliente(1)
aCliente(2)
aCliente(3)
=
aCliente(4)
aCliente(5)
Array.CreateInstance(GetType(Object),
6)
=
22
=
"Pedro"
=
"C/Rio
=
=
"Naranjo"
Bravo,
25"
35
250
En un planteamiento como el anterior, debemos acordarnos, a la hora de obtener los datos del array, que la
primera posicin corresponde al cdigo de cliente, la siguiente al nombre, etc.,. Bien es cierto que podemos utilizar
constantes numricas para cada posicin, pero sigue siendo una solucin poco flexible.
Utilizando un objeto Hashtable sin embargo, tenemos la ventaja de que no necesitamos saber la posicin en que
se encuentra cada valor, ya que precisamente a cada posicin le damos un nombre clave que es mediante el que
accedemos posteriormente cuando queremos obtener los valores. El Cdigo fuente 376, mejora sustancialmente el
fuente del caso anterior, al estar basado en una coleccin Hashtable.
Sub
'
declarar
Dim
htCliente
htCliente
=
'
coleccin
As
New
Main()
Hashtable
Hashtable
Hashtable()
aadir
valores
htCliente.Add("ID",
htCliente.Add("Nombre",
htCliente.Add("Apellidos",
htCliente.Add("Domicilio",
htCliente.Add("Edad",
htCliente.Add("Credito",
'
mostrar
Console.WriteLine("El
htCliente.Count)
Console.WriteLine()
"C/Rio
el
nmero
de
objeto
Hashtable
'
obtener
Console.WriteLine("Obtener
algunos
Console.WriteLine("Domicilio:
{0}
Console.WriteLine("Nombre:
{0}
Console.WriteLine("Credito:
{0}
Console.WriteLine()
'
recorrer
el
Console.WriteLine("Recorrer
objeto
Dim
oEnumerador
oEnumerador
=
While
Console.WriteLine("Clave:
oEnumerador.Key,
End
{0}
22)
"Pedro")
"Naranjo")
25")
35)
250)
Bravo,
elementos
tiene
{0}
que
contiene
elementos",
_
algunos
del
valores
",
",
",
array
Hashtable
As
con
Valor:
valores
objeto
Hashtable")
htCliente.Item("Domicilio"))
htCliente("Nombre"))
htCliente("Credito"))
al
completo
un
enumerador")
IDictionaryEnumerator
htCliente.GetEnumerator()
oEnumerador.MoveNext()
{1}",
_
oEnumerador.Value)
While
Console.ReadLine()
End
Sub
Cdigo fuente 376
Para crear un nuevo objeto Hashtable hemos utilizado el constructor sin parmetros, que es el ms bsico
disponible. Puesto que se trata de un constructor sobrecargado, sugerimos al lector que consulte la documentacin de
.NET Framework para ver una lista completa de todos los constructores disponibles.
Respecto a la asignacin de valores a la coleccin, esta clase utiliza el mtodo Add( ), cuyo primer parmetro
corresponde a la clave del elemento y el segundo corresponde al valor que vamos a asignar a la posicin de su array.
Para obtener un valor del array utilizamos el mtodo Item( ), pasando como parmetro el nombre de la clave de
la que vamos a obtener el valor correspondiente. Al tratarse del mtodo por defecto de esta clase no es necesario
especificarlo. Como hemos podido comprobar, el resultado es el mismo tanto si especificamos como si no el nombre
del mtodo.
Si queremos recorrer el array al completo contenido en el objeto, podemos utilizar el mtodo GetEnumerator( ),
que nos devuelve un enumerador para poder obtener todos los valores del objeto en un bucle. La diferencia con los
otros algoritmos de recorrido que hemos visto anteriormente, es que al estar la coleccin Hashtable basada en una
combinacin de clave/valor, necesitamos un enumerador basado en el interfaz IDictionaryEnumerator, especialmente
adaptado para manipular arrays de este tipo.
Como habr comprobado el lector, un enumerador IDictionaryEnumerator proporciona la informacin de la
coleccin mediante las propiedades Key y Value, a diferencia de un enumerador simple, basado en IEnumerator, en el
que usamos la propiedad Current, para extraer los datos.
La clase Hashtable no sita los valores que se aaden al array en posiciones consecutivas, por lo que al obtener
los valores mediante un enumerador posiblemente no aparecern en el mismo orden en el que los aadimos
inicialmente. Dada la filosofa de funcionamiento de este tipo de objetos, el orden en el que se graban los valores
dentro del array no debera ser un problema, ya que nosotros accedemos al array utilizando claves y no ndices, como
sucede en un array estndar.
Sub
'
Main()
crear
Dim
coleccin
Hashtable
htCliente
As
aadir
valores
New
Hashtable()
htCliente.Add("ID",
22)
htCliente.Add("Nombre",
"Pedro")
htCliente.Add("Apellidos",
"Naranjo")
htCliente.Add("Domicilio",
"C/Rio
Bravo,
25")
htCliente.Add("Edad",
35)
htCliente.Add("Credito",
'
comprobar
la
Dim
Console.WriteLine("Introducir
sClave
If
Console.WriteLine("La
sClave,
Else
250)
existencia
de
elementos
sClave
As
la
clave
=
htCliente.ContainsKey(sClave)
clave
Console.WriteLine("La
End
Console.WriteLine()
{0}
clave
existe,
{0}
su
valor
la
clave
String
buscar")
Console.ReadLine()
Then
es:
{1}",
_
htCliente(sClave))
no
'
comprobar
la
existencia
de
elementos
Dim
oValor
As
Console.WriteLine("Introducir
el
valor
oValor
=
'
antes
de
comprobar
si
existe
'
debemos
hacer
una
conversin
'
especfico
de
dato
del
'
la
variable
If
IsNumeric(oValor)
oValor
por
CType(oValor,
existe",
por
sClave)
If
el
valor
Object
a
buscar")
Console.ReadLine()
el
valor
al
tipo
contenido
de
oValor
Then
Integer)
Else
oValor
End
'
If
CType(oValor,
String)
If
comprobamos
Then
ahora
htCliente.ContainsValue(oValor)
Console.WriteLine("El
valor
Else
Console.WriteLine("El
valor
{0}
End
'
para
borrar
htCliente.Remove("Nombre")
Console.WriteLine()
RecorrerHT(htCliente)
'
ahora
htCliente.Clear()
{0}
no
un
borramos
el
existe",
existe",
elemento
contenido
se
al
oValor)
oValor)
If
usa
completo
la
clave
del
objeto
Console.ReadLine()
End
Sub
Public
Sub
RecorrerHT(ByVal
Dim
oEnumerador
As
oEnumerador
=
While
Console.WriteLine("Clave:
oEnumerador.Key,
End
End
htTabla
As
Hashtable)
IDictionaryEnumerator
htTabla.GetEnumerator()
oEnumerador.MoveNext()
{0}
Valor:
{1}",
_
oEnumerador.Value)
While
Sub
Las propiedades Keys y Values de la clase Hashtable, devuelven un array con los nombres de las claves y los
valores de un objeto Hashtable respectivamente.
Realmente devuelven un objeto del interfaz ICollection, pero ya que un array implementa este interfaz, dicho
objeto podemos manipularlo como un array.
Seguidamente mostramos un ejemplo del uso de estas propiedades en el Cdigo fuente 378. Observe el lector el
diferente modo de declarar y obtener los objetos ICollection e IEnumerator, que en definitiva, nos llevan al mismo
resultado, demostrando as, la gran flexibilidad sintctica que la especificacin CLS proporciona al lenguaje.
Sub
'
crear
y
Dim
htCliente
htCliente.Add("ID",
htCliente.Add("Nombre",
htCliente.Add("Apellidos",
htCliente.Add("Domicilio",
htCliente.Add("Edad",
htCliente.Add("Credito",
'
'
Dim
aClaves
obtener
y
llenar
As
"C/Rio
Main()
coleccin
Hashtable()
22)
"Pedro")
"Naranjo")
Bravo,
25")
35)
250)
la
New
un
recorrer
aClaves
array
con
con
As
las
un
claves,
enumerador
ICollection
htCliente.Keys
Dim
oEnumerador
oEnumerador
Console.WriteLine("Claves
RecorrerEnumerador(oEnumerador)
'
obtener
'
y
Dim
aValores
Dim
oEnumVal
Console.WriteLine("Valores
RecorrerEnumerador(oEnumVal)
As
=
del
un
recorrer
As
As
IEnumerator
aClaves.GetEnumerator()
Hashtable")
objeto
array
con
ICollection
IEnumerator
del
con
los
un
=
=
objeto
valores,
enumerador
htCliente.Values
aValores.GetEnumerator()
Hashtable")
Console.ReadLine()
End
Sub
Public
Sub
RecorrerEnumerador(ByVal
While
oEnumerador
As
IEnumerator)
oEnumerador.MoveNext
Console.WriteLine(oEnumerador.Current)
End
Console.WriteLine()
While
End
Sub
'
Dim
Sub
crear
htCliente
un
As
htCliente.Add("ID",
htCliente.Add("Nombre",
htCliente.Add("Apellidos",
htCliente.Add("Domicilio",
htCliente.Add("Edad",
htCliente.Add("Credito",
array
New
Main()
Hashtable
Hashtable()
"C/Rio
Bravo,
22)
"Pedro")
"Naranjo")
25")
35)
250)
'
crear
Dim
un
array
aDeposito(10)
estndar
As
Object
aDeposito(0)
"aaa"
aDeposito(1)
"bbb"
aDeposito(2)
"ccc"
aDeposito(3)
"ddd"
'
volcar
elementos
del
'
comenzando
a
copiar
'
del
htCliente.CopyTo(aDeposito,
'
'
Dim
Dim
For
obtener
que
algunos
se
han
oEntradaDicc
iContador
iContador
oEntradaDicc
Console.WriteLine("Clave:
oEntradaDicc.Key,
Next
Hashtable
desde
una
array
valores
pasado
al
del
al
array
posicin
estndar,
determinada
estndar
2)
objeto
array
Hashtable
normal
DictionaryEntry
Integer
6
As
As
=
To
=
{0}
aDeposito(iContador)
{1}",
_
oEntradaDicc.Value)
Valor:
Console.ReadLine()
End
Sub
Cdigo fuente 379
Como el array normal tena valores asignados previamente, algunos de ellos se pierden, puesto que el mtodo
CopyTo( ) no redimensiona el array normal. Tenga este hecho en cuenta el lector, ya que el array destino deber tener
el suficiente tamao cuando traspasamos valores desde una coleccin de este tipo.
La clase SortedList
Esta clase es una variacin de Hashtable, ya que nos permite crear colecciones basadas en pares de claves y
valor, pero con la diferencia de que en una coleccin SortedList, los elementos se ordenan por la clave segn van
siendo agregados. El funcionamiento general, es bsicamente igual que para los objetos Hashtable. Veamos un
ejemplo en el Cdigo fuente 380.
Sub
Main()
'
Dim
crear
una
slListaOrden
'
segn
'
slListaOrden.Add("H",
slListaOrden.Add("A",
slListaOrden.Add("Z",
slListaOrden.Add("M",
As
aadimos
ordenando
coleccin
New
elementos,
SortedList()
se
van
dinmicamente
111)
222)
333)
444)
'
Dim
recorrer
oEnumerador
oEnumerador
While
Console.WriteLine("Clave:
oEnumerador.Key,
End
la
coleccin
As
=
{0}
SortedList
IDictionaryEnumerator
slListaOrden.GetEnumerator()
oEnumerador.MoveNext()
Valor:
{1}",
_
oEnumerador.Value)
While
Console.ReadLine()
End
Sub
Cdigo fuente 380
La clase Queue
Esta clase implementa toda la operativa de una lista de tipo FIFO (first in, first out), primero en entrar/primero
en salir; tambin denominada cola de valores. A pesar de lo bsico de su funcionalidad, es un aspecto que el
programador agradece en muchas situaciones. La Figura 214 muestra un esquema del funcionamiento de este tipo de
objeto.
Como el resto de clases en el espacio de nombres System.Collections, los objetos de tipo Queue contienen un
array gestionado por la propia clase e inaccesible para el programador, que almacena los valores que vamos
encolando. Este array parte con un tamao inicial y es redimensionado por el propio objeto cuando todos sus
elementos han sido asignados y se intenta aadir un nuevo valor.
'
Dim
Sub
crear
objeto
aqListaMensa
Dim
'
Do
Queue,
As
Main()
valores
Queue()
cola
de
New
Console.WriteLine("Introducir
sMensaje
bucle
de
de
mensajes")
String
mensajes
Console.ReadLine()
algo...
Then
la
cola
As
recepcin
sMensaje
'
If
si
sMensaje.Length
hemos
escrito
>
'
aadimos
aqListaMensa.Enqueue(sMensaje)
Else
'
Exit
salimos
Do
End
If
Loop
'
la
propiedad
'
elementos
Console.WriteLine("Hay
{0}
Count
mensajes
'
con
un
Dim
oEnumerador
Console.WriteLine("Contenido
RecorrerEnumerador(oEnumerador)
nos
en
para
enumerador
=
del
indica
la
la
procesar",
cantidad
de
lista
aqListaMensa.Count)
recorremos
la
lista
aqListaMensa.GetEnumerator()
objeto
Queue")
Console.ReadLine()
End
Sub
Public
Sub
RecorrerEnumerador(ByVal
While
Console.WriteLine(oEnumerador.Current)
End
Console.WriteLine()
End
oEnumerador
As
IEnumerator)
oEnumerador.MoveNext
While
Sub
Normalmente, en un sistema de gestin de mensajes, una vez que solicitamos un mensaje, este es enviado y
borrado de su contenedor. Pues algo similar es lo que haremos seguidamente, ya que despus de que el usuario haya
introducido todos los mensajes, utilizaremos el mtodo Dequeue( ), que ir extrayendo o desencolando cada uno de los
valores de la lista, comenzando por el primero que fue introducido. Este mtodo, adems de devolver el valor, lo
elimina de la lista. Ver el Cdigo fuente 382.
Sub
Dim
Dim
Dim
aqListaMensa
sMensaje
iContador
'
As
As
As
bucle
de
Do
iContador
Console.WriteLine("Mensaje
"Pulse
iContador)
sMensaje
'
If
Main()
Queue()
String
Integer
New
recepcin
de
mensajes
+=
nro.
[INTRO]
{0}.
para
"
finalizar
=
hemos
si
sMensaje.Length
captura",
escrito
>
'
aadimos
aqListaMensa.Enqueue(sMensaje)
1
_
&
Console.ReadLine()
algo...
Then
la
lista
Else
'
Exit
salimos
Do
End
Loop
Console.WriteLine()
If
'
la
propiedad
'
elementos
Console.WriteLine("Hay
{0}
Console.WriteLine()
'
procesar
iContador
Console.WriteLine("Procesar
While
Count
mensajes
de
cantidad
de
lista
aqListaMensa.Count)
la
de
>
lista
0
mensajes")
0
+=
nro.
{0}
mensajes
{0}
por
texto:
procesar",
1
_
{1}",
aqListaMensa.Dequeue())
aqListaMensa.Count)
While
Console.ReadLine()
Sub
Cdigo fuente 382
la
la
procesar",
mensajes
=
lista
aqListaMensa.Count
End
End
indica
los
iContador
Console.WriteLine("Mensaje
iContador,
Console.WriteLine("Quedan
Console.WriteLine()
nos
en
para
Pero supongamos que queremos comprobar el contenido del prximo mensaje a procesar antes de sacarlo de la
lista. En ese caso, el mtodo Peek( ) de la clase Queue es el indicado, ya que precisamente devuelve el siguiente valor
de la lista sin eliminarlo, como ilustra el Cdigo fuente 383.
Console.WriteLine("Obtenemos
aqListaMensa.Peek())
el
primer
valor
sin
eliminar:
{0}",
Puede ocurrir tambin, que necesitemos obtener los valores de la lista pero sin eliminarlos, por ejemplo, para
poder repetir el proceso posteriormente. Tenemos que volver a pedirlos al usuario?, no en absoluto, ya que mediante
el mtodo Clone( ) de la clase Queue, podemos obtener un nuevo objeto independiente, pero con los mismo elementos.
A partir de ese momento, aunque procesemos la lista original, mantendremos los datos en una copia del objeto.
Otra tcnica consiste en utilizar el mtodo ToArray( ), que copia los valores de la lista a un array estndar.
Dicho array deber haber sido previamente creado con el tamao adecuado, ya que si tiene menos elementos que el
objeto Queue, cuando copiemos los valores al array se producir un error. Para saber el tamao del array que tenemos
que crear, podemos ayudarnos de la propiedad Count del objeto Queue. El Cdigo fuente 384 muestra unos ejemplos.
Public
Sub
'
crear
Dim
objeto
Main()
Queue
aqListaMensa
introducir
valores
As
New
Queue()
seguridad
de
'....
'....
'
crear
Dim
'
'
Dim
copia
de
aqCopiaMensajes
tambin,
elementos
aListaDatos
As
As
podemos
'
procesar
'
mantendremos
'
crear
del
=
Array
aqListaMensa.Count)
aListaDatos
Queue
un
array
normal
con
objeto
Array.CreateInstance(GetType(Object),
los
Queue
_
aqListaMensa.ToArray()
mensajes
los
lista
aqListaMensa.Clone()
los
la
valores
en
de
en
la
lista
el
objeto
un
original,
clonado
array
'....
'....
End
Sub
Cdigo fuente 384
Copiando los valores a un array, tenemos la ventaja de poder ordenarlos, o hacer cualquier operacin que nos
permita la clase Array.
Y ya para terminar con esta clase, el mtodo Clear( ) elimina todos los valores del array interno que mantiene un
objeto Queue. Podemos utilizar este mtodo en el caso de que despus de haber obtenido algunos valores de la lista, no
queramos seguir extrayendo informacin, pero necesitemos el objeto vaco para poder repetir el proceso de captura de
datos.
La clase Stack
Al igual que en el caso anterior, esta clase nos permite gestionar colas de valores, pero los objetos de este tipo,
crean listas de valores al estilo de pilas LIFO (last in, first out), ltimo en entrar/primero en salir.
Su modo de manejo es similar a las colecciones Queue, con la caracterstica de que en una pila, los valores que
extraemos son los ltimos que han entrado. Veamos un ejemplo en el Cdigo fuente 385.
Public
'
Sub
creamos
una
Dim
de
aadir
oPila.Push("C")
oPila.Push("D")
oPila.Push("E")
para
dicho
este
valores,
ser
'
este
ser
Console.WriteLine("El
valor
se
oPila.Count
valor
Console.ReadLine()
Sub
Cdigo fuente 385
de
obtenido
End
End
pila
Stack
New
'
extraer
un
valor
tipo
As
'
para
oPila.Push("A")
oPila.Push("B")
'
coleccin
oPila
oPila
'
While
Main()
usamos
el
el
ltimo
mtodo
en
Push()
salir
el
primero
en
salir
la
pila,
eliminar
de
Stack()
la
usamos
de
>
lista
el
es:
mtodo
la
{0}",
Pop(),
lista
0
oPila.Pop)
While
Colecciones
personalizadas
Situmonos en primer lugar en un escenario de ejemplo: estamos desarrollando una aplicacin en la que
utilizamos colecciones de tipo ArrayList. Sin embargo, necesitamos que dichas colecciones admitan slo nmeros, y
que adems, el array de la coleccin est ordenado.
Dado que estas caractersticas no estn implementadas en los objetos ArrayList, pero este tipo de coleccin se
adapta en gran medida a nuestras necesidades, crearemos una nueva clase con el nombre NumerosOrden, que herede
de ArrayList, y en la que codificaremos el comportamiento personalizado que necesitamos. Ver el Cdigo fuente 386.
Inherits
ArrayList
'
sobrescribimos
el
mtodo
Add()
'
slo
vamos
a
permitir
aadir
Public
Overrides
Function
Add(ByVal
value
'
si
es
If
MyBase.Add(value)
Me.Sort()
Return Me.Count
de
nmeros
As
un
IsNumeric(value)
la
a
Object)
clase
la
As
nmero,
base;
coleccin
Integer
aadimos
Then
Else
'
Return
End
End
si
no
es
un
End
nmero...
-1
If
Function
Class
Sub
'
instanciar
un
objeto
'
coleccin
personalizada
que
Dim
oNumOr
As
New
oNumOr.Add(980)
oNumOr.Add(500)
oNumOr.Add(25)
oNumOr.Add(700)
'
recorrer
Main()
de
nuestra
ordena
nmeros
NumerosOrden()
la
coleccin
Dim
oEnumera
Console.WriteLine("Coleccin
While
As
Console.WriteLine("valor:
IEnumerator
ordenada
{0}",
End
=
de
oNumOr.GetEnumerator()
nmeros")
oEnumera.MoveNext
oEnumera.Current)
While
Console.ReadLine()
End
Sub
Cdigo fuente 387
En este ejemplo, el lector ha podido comprobar cmo con una mnima cantidad de cdigo en una clase derivada,
conseguimos toda la potencia de una coleccin base, y le proporcionamos un comportamiento del que originalmente
careca.
No codificamos todos los miembros del interfaz para simplificar el presente ejemplo, y al mismo tiempo,
demostramos que slo hemos de escribir cdigo para aquellos aspectos del interfaz que necesitemos, aunque lo
recomendable sera, evidentemente, implementar correctamente todos los mtodos y propiedades que indica el
interfaz. Vemoslo en el Cdigo fuente 388.
'
'
' esta
admite
y
Class
'
para
'
en
Implements
'
'
Protected
'
'
'
Public
el
declaramos
los
a
del
partir
de
interfaz,
ReadOnly
comportamiento
implementamos
el
un
valores
aValores()
aqu,
y
Property
de
una
siguiente
array
de
ListaMay
coleccin
interfaz
IList
que
la
As
contendr
coleccin
String
debemos
declarar
todos
los
miembros
codificar
aquellos
que
necesitemos
----------------------------------------------------Count()
As
Integer
_
Implements
System.Collections.IList.Count
Get
If
Count
End
End
Not
(aValores
=
Is
Nothing)
Then
aValores.Length
If
Get
End
Public
Implements
Property
ReadOnly
Property
IsSynchronized()
As
Boolean
_
System.Collections.IList.IsSynchronized
Get
End
Get
End
Public
Implements
Property
ReadOnly
Property
SyncRoot()
As
Object
_
System.Collections.IList.SyncRoot
Get
End
Get
End
Public
Implements
Property
Function
GetEnumerator()
As
System.Collections.IEnumerator
_
System.Collections.IList.GetEnumerator
Return
aValores.GetEnumerator()
End
Public
Implements
Function
Function
If
ReDim
aValores(0)
Add(ByVal
value
aValores
As
Object)
As
Integer
_
System.Collections.IList.Add
Is
Nothing
Preserve
=
Else
Dim
iIndiceMayor
ReDim
Preserve
aValores(iIndiceMayor
As
Integer
=
aValores(iIndiceMayor
1)
=
Then
aValores(0)
CStr(value).ToUpper()
aValores.GetUpperBound(0)
+
1)
CStr(value).ToUpper()
End
If
Return
Me.Count
Function
End
Public
Implements
Sub
Clear()
_
System.Collections.IList.Clear
Array.Clear(aValores,
0,
aValores.Length)
End
Public
Implements
Sub
Function
Dim
oEnumera
While
Contains(ByVal
value
As
Object)
As
Boolean
_
System.Collections.IList.Contains
oEnumera
As
=
IEnumerator
aValores.GetEnumerator()
oEnumera.MoveNext
Return
False
End
Public
Implements
Function
Function
IndexOf(ByVal
value
As
Object)
As
Integer
_
System.Collections.IList.IndexOf
End
Public
Implements
Get
Function
ReadOnly
Property
IsFixedSize()
As
Boolean
_
System.Collections.IList.IsFixedSize
End
Get
End
Property
Public
Implements
ReadOnly
Property
IsReadOnly()
As
Boolean
_
System.Collections.IList.IsReadOnly
Get
End
Get
End
Property
Default
Implements
Public
Property
Item(ByVal
index
As
Integer)
As
Object
_
System.Collections.IList.Item
Get
Item
End
Set(ByVal
=
Value
Dim
As
oTipo
oTipo
aValores.GetValue(index)
Get
Object)
As
Type
Value.GetType()
If
oTipo.Name
aValores.SetValue(CType(Value,
Else
aValores.SetValue(Value,
End
End
=
"String"
String).ToUpper(),
Then
index)
index)
If
Set
End
Property
Public
Implements
Sub
Remove(ByVal
value
As
Object)
_
System.Collections.IList.Remove
End
Sub
Public
Implements
Sub
RemoveAt(ByVal
index
As
Integer)
_
System.Collections.IList.RemoveAt
End
Public
Sub
Sub
Insert(ByVal
index
As
Integer,
Implements
value
As
Object)
System.Collections.IList.Insert
End
Public
Implements
ByVal
Sub
Sub
CopyTo(ByVal
array
As
System.Array,
ByVal
index
As
Integer)
_
System.Collections.IList.CopyTo
End
Sub
End
Class
Desde cdigo cliente, el modo de utilizar nuestra nueva clase es igual que para una de las colecciones normales,
aunque debemos tener en cuenta los mtodos no codificados, para no utilizarlos. Veamos el Cdigo fuente 389.
Public
'
instanciar
Dim
oLis
Sub
un
objeto
de
la
As
ListaMay
Console.WriteLine("Nmero
Console.WriteLine()
Main()
personalizada
ListaMay()
coleccin
=
New
de
elementos
'
oLis.Add("Esta
oLis.Add("mi
oLis.Add("de
RecorrerMiLista(oLis)
{0}",
oLis.Count)
aadir
valores
es")
clase")
personalizados")
arrays
Console.WriteLine("Nmero
Console.WriteLine()
de
elementos
{0}",
'
comprobar
si
existe
Dim
sValorBuscar
As
Console.WriteLine("Introducir
un
valor
a
buscar
sValorBuscar
=
If
oLis.Contains(sValorBuscar)
oLis.Count)
un
valor
String
la
coleccin")
Console.ReadLine()
Then
en
Console.WriteLine("El
valor
introducido
existe")
Console.WriteLine("El
End
Console.WriteLine()
valor
introducido
no
existe")
If
'
eliminar
oLis.Clear()
de
Else
'
asignar
oLis(2)
oLis.Item(0)
valores
valores
la
los
coleccin
ndices
=
=
(no
existentes
RecorrerMiLista(oLis)
Console.ReadLine()
End
Sub
Public
Sub
RecorrerMiLista(ByVal
oListaValores
As
ListaMay)
elimina
de
la
elementos)
coleccin
"mesa"
"coche"
Dim
oEnumera
While
oEnumera
=
Console.WriteLine("valor
As
IEnumerator
oListaValores.GetEnumerator()
oEnumera.MoveNext
{0}",
oEnumera.Current)
While
End
Console.WriteLine()
End
Sub
Cdigo fuente 389.
Manipulacin
de
errores
Errores de escritura
Son los de localizacin ms inmediata, ya que se producen por un error sintctico al escribir nuestro cdigo, y
gracias al IDE de Visual Studio .NET, podemos detectarlos rpidamente.
Cuando escribimos una sentencia incorrectamente, dejamos algn parntesis sin cerrar, etc., el IDE subraya la
parte de cdigo errnea, y nos muestra un mensaje informativo del error al situar el cursor del ratn sobre el mismo.
En el ejemplo de la Figura 215, hemos declarado una estructura While que no hemos cerrado con la correspondiente
instruccin End While; por lo tanto, el IDE nos lo indica.
Errores de ejecucin
Este tipo de errores son los que provocan un fallo en la ejecucin del programa y su interrupcin. No obstante, si
utilizamos los gestores de error que proporciona la herramienta de desarrollo correspondiente, podremos en algunos
casos, evitar la cancelacin de la ejecucin, recuperando su control. El ejemplo del Cdigo fuente 390 provoca un
error, ya que se intenta asignar un valor que no corresponde al tipo de dato de una variable.
Dim
dtFecha
dtFecha
=
As
Date
"prueba"
Los errores de ejecucin son el objetivo del presente tema; sobre su captura y manipulacin nos centraremos a
lo largo de los prximos apartados.
Errores lgicos
Estos errores son los de ms difcil captura, ya que el cdigo se encuentra correctamente escrito, producindose
el problema por un fallo de planteamiento en el cdigo, motivo por el cual, por ejemplo, el control del programa no
entra en un bucle porque una variable no ha tomado determinado valor; el flujo del programa sale antes de lo previsto
de un procedimiento, al evaluar una expresin que esperbamos que tuviera un resultado diferente, etc.
Errores y excepciones
Dentro del esquema de gestin de errores del entorno .NET Framework, encontramos las figuras del error y la
excepcin. Estos elementos son utilizados indistintamente en muchas ocasiones para hacer referencia genrica a los
errores producidos; sin embargo, aunque complementarios, cada uno tiene su propia funcionalidad dentro del proceso
de tratamiento de un error.
.
Error. Un error es un evento que se produce durante el funcionamiento de un programa, provocando
una interrupcin en su flujo de ejecucin. Al producirse esta situacin, el error genera un objeto excepcin.
.
Excepcin. Una excepcin es un objeto generado por un error, que contiene informacin sobre las
caractersticas del error que se ha producido.
Manipuladores de excepciones
Un manipulador de excepcin es un bloque de cdigo que proporciona una respuesta al error que se ha
producido, y que se incluye en una estructura proporcionada por el lenguaje a tal efecto, es decir, para la captura de
excepciones.
Try
cdigo
'
que
puede
'
'
[Catch
[Excepcion
[As
respuesta
a
'
provocar
errores
....
....
TipoExcepcionA]]
error
de
[When
Expresin]
tipo
A
....
....
Try]
TipoExcepcionN]]
error
de
[When
Expresin]
tipo
N
....
....
'
'
[Exit
]
[Catch
[Excepcion
[As
respuesta
a
'
'
'
[Exit
Try]
[Finally
cdigo
'
posterior
al
control
de
errores
'
....
....
'
]
End
Try
Dim
Dim
Public
sValor
iNumero
Sub
Main()
String
Integer
As
As
Try
'
comienza
Console.WriteLine("Introducir
sValor
'
si
no
iNumero
=
sValor
'
iNumero
...y
no
el
'
=
hemos
...aqu
llegaremos
=
control
un
de
introducido
se
producir
a
iNumero
esta
parte
+
un
errores
nmero")
Console.ReadLine()
nmero...
un
error...
del
cdigo
1000
Catch
'
si
se
produce
'
que
capturamos
'
manipulador
de
Console.WriteLine("Error
al
ControlChars.CrLf
"El
valor
sValor)
un
error,
en
este
excepcin,
introducir
{0}
es
se
genera
una
bloque
de
definido
por
el
nmero"
excepcin
cdigo
Catch
&
_
&
_
_
incorrecto",
End
Try
'
resto
'
Console.ReadLine()
del
cdigo
del
procedimiento
....
End
Sub
Tanto si se produce un error como si no, la sentencia Finally de la estructura Try...End Try, nos permite escribir
un bloque de cdigo que ser ejecutado al darse una condicin de error, o bajo ejecucin normal del procedimiento.
El Cdigo fuente 393 muestra el mismo ejemplo anterior, pero introduciendo un bloque Finally. Pruebe el lector
alternativamente, a forzar un error, y a ejecutar sin errores este fuente; en ambos casos ver que el bloque Finally es
ejecutado. Para completar el ejemplo, tras la estructura Try...End Try se han escrito varias lneas de cdigo
potencialmente problemticas; en el caso de que se produzca un error, la ejecucin ser cancelada, al no estar dichas
lneas situadas en un controlador de errores.
Dim
Dim
Public
sValor
iNumero
Sub
Main()
String
Integer
As
As
Try
'
comienza
Console.WriteLine("Introducir
sValor
'
si
no
iNumero
=
sValor
'
iNumero
...y
no
el
'
Finally
=
hemos
...aqu
llegaremos
=
Catch
'
si
se
produce
'
que
capturamos
'
manipulador
de
Console.WriteLine("Error
al
ControlChars.CrLf
"El
valor
sValor)
control
un
de
introducido
se
producir
a
iNumero
esta
un
error,
en
este
excepcin,
introducir
{0}
es
se
parte
+
un
errores
nmero")
Console.ReadLine()
nmero...
un
error...
del
genera
una
bloque
de
definido
por
el
nmero"
&
incorrecto",
cdigo
1000
excepcin
cdigo
Catch
&
_
_
_
'
si
se
produce
'
si
no
se
Console.WriteLine("El
un
error,
despus
de
produce
error,
despus
controlador
de
Catch
se
de
Try
errores
ejecuta
tambin
ha
este
bloque;
se
ejecuta
finalizado")
End
Try
'
resto
del
cdigo
del
procedimiento
Dim
dtFecha
As
Date
Console.WriteLine("Introducir
una
fecha")
'
si
ahora
se
produce
un
error,
'
al
no
disponer
de
una
estructura
para
controlarlo
'
se
cancelar
la
ejecucin
dtFecha
=
Console.ReadLine()
Console.WriteLine("La
fecha
es
{0}",
dtFecha)
Console.ReadLine()
End
Sub
La clase Exception
Como hemos explicado en anteriores apartados, cada vez que se produce un error, el entorno de ejecucin
genera una excepcin con la informacin del error acaecido.
Para facilitarnos la tarea de manipulacin de la excepcin producida, en un controlador de excepciones
obtenemos un objeto de la clase Exception, o de alguna de sus derivadas, de forma que, a travs de sus miembros,
podemos saber qu ha pasado. Entre las propiedades y mtodos que podemos utilizar, se encuentran las siguientes.
.
Message. Descripcin del error.
.
Source. Nombre del objeto o aplicacin que provoc el error.
.
StackTrace. Ruta o traza del cdigo en la que se produjo el error.
.
ToString( ). Devuelve una cadena con informacin detallada del error. En esta cadena podemos
encontrar tambin, los valores obtenidos de las propiedades anteriores; por lo que el uso de este mtodo, en muchas
ocasiones ser el modo ms recomendable para obtener los datos de la excepcin.
Podemos obtener el objeto de excepcin creado a partir de un error, utilizando la sentencia Catch de la
estructura Try. Para ello, a continuacin de Catch, escribimos el nombre de un identificador, definindolo como tipo
Exception o alguno de los tipos de su jerarqua.
El Cdigo fuente 394 muestra la captura de la excepcin en el ejemplo anterior, dentro de la sentencia Catch,
pero en este caso utilizando un objeto Exception. El resto del cdigo es igual que el anterior ejemplo.
'
....
Try
'
'
....
....
Catch
oExcep
As
Exception
'
si
se
produce
un
error,
se
crea
un
objeto
excepcin
'
que
capturamos
volcndolo
a
un
identificador
'
de
tipo
Exception
Console.WriteLine("Se
produjo
un
error.
Informacin
de
la
excepcin")
Console.WriteLine("================================================")
Console.WriteLine("Message:
{0}",
oExcep.Message)
Console.WriteLine()
Console.WriteLine("Source:
Console.WriteLine()
Console.WriteLine("StackTrace:
Console.WriteLine()
Console.WriteLine(oExcep.ToString())
{0}",
oExcep.Source)
{0}",
oExcep.StackTrace)
Finally
'
'
....
....
End
'
Try
....
El Cdigo fuente 395 contiene una pequea muestra de los valores obtenidos a partir de las propiedades
Message, Source y StackTrace, tras la ejecucin del fuente anterior.
Message:
Cast
from
String
('hola')
to
Integer
Source:
StackTrace:
Value)
is
not
valid.
Microsoft.VisualBasic
at
Microsoft.VisualBasic.Helpers.IntegerType.FromString(String
at
ErroresPru.Module1.Main()
K:\CursoVBNET\Texto\t16Errores\ErroresPru\Module1.vb:line
in
12
Exception representa la clase base en la jerarqua de tipos de excepcin que se pueden producir dentro del
entorno de ejecucin.
Partiendo de Exception, disponemos de un conjunto de clases derivadas, que nos permiten un tratamiento ms
particular del error producido, como ApplicationException, IOException, SystemException, etc. Cada una de ellas
puede tener, adems de los miembros generales de Exception, una serie de mtodos y propiedades particulares de su
tipo de excepcin; por ello, lo ms conveniente, ser utilizar estas clases, a travs de las que podremos averiguar ms
detalles sobre el problema producido.
Public
Sub
Main()
Dim
sValor
As
String
Dim
iNumero
As
Integer
Dim
sLetras()
As
Try
'
comienza
Console.WriteLine("Introducir
sValor
'
si
no
iNumero
=
sValor
'
...y
'
'
introducir
{"a",
"b",
control
un
=
hemos
...aqu
de
introducido
se
producir
llegaremos
'
el
no
iNumero
String
esta
letra
del
cdigo
"d"}
errores
nmero")
Console.ReadLine()
nmero...
un
error...
parte
iNumero
una
posicin
un
"c",
1000
asignarla
del
una
array
Dim
sNuevaLetra
As
String
Dim
iPosicion
As
Integer
Console.WriteLine("Introducir
una
letra")
sNuevaLetra
=
Console.ReadLine()
Console.WriteLine("Introducir
posicin
del
array
para
la
letra")
iPosicion
=
Console.ReadLine()
'
si
al
asignar
la
letra
al
array
no
existe
'
el
ndice,
se
producir
un
error
sLetras(iPosicion)
=
sNuevaLetra
Catch
oExcep
'
excepcin
producida
'
realizar
una
Console.WriteLine(oExcep.ToString())
un
conversin
System.InvalidCastException
error
al
intentar
de
tipos
Catch
oExcep
As
'
excepcin
producida
por
'
al
intentar
usar
un
'
de
array,
o
ndice
Console.WriteLine(oExcep.ToString())
System.IndexOutOfRangeException
un
error
ndice
inexistente
fuera
de
rango
Finally
'
si
se
produce
'
si
no
se
Console.WriteLine("El
As
por
un
error,
despus
de
produce
error,
despus
controlador
de
Catch
se
de
Try
errores
ejecuta
tambin
ha
este
bloque;
se
ejecuta
finalizado")
End
Try
Console.ReadLine()
End
Sub
Cdigo fuente 396
Dim
Dim
Public
Sub
byMiNum
dtFHActual
'
dtFHActual
Main()
Byte
Date
As
As
obtener
la
Try
'
comienza
el
Console.WriteLine("Introducir
'
si
introducimos
'
en
el
byMiNum
'
Catch
oExcep
...saltar
As
este
se
Finally
Console.WriteLine("El
End
un
control
un
nmero
rango
encuentra
controlador
de
en
When
de
excepciones
el
introducido
en
errores
de
errores
nmero")
no
incluido
Byte...
Console.ReadLine()
(dtFHActual.Month
excepciones,
pero
de
mes
de
"
el
ha
actual
System.DateTime.Today()
de
OverflowException
manipulador
'
cuando
las
'
se
produzcan
Console.WriteLine("El
nmero
"no
fecha
rango
3)
slo
desbordamiento
Marzo
&
_
adecuado")
finalizado")
Try
Console.ReadLine()
End
Sub
Cdigo fuente 397
Si queremos capturar tambin el resto de excepciones de desbordamiento, u otro tipo de excepciones, tenemos
varias alternativas que describimos seguidamente.
.
Quitar la condicin de filtro al manipulador de excepciones actual. De este modo, capturaremos
todas las excepciones de desbordamiento, pero no podremos filtrar por un mes determinado.
.
Aadir un nuevo manipulador a la estructura de control, para todas las excepciones de
desbordamiento. En esta situacin, si se produce un error de desbordamiento, y no estamos en el mes definido por el
anterior manipulador, se ejecutar este nuevo manipulador. Ver el Cdigo fuente 398.
'
'
'
'
Catch
oExcep
As
OverflowException
When
...saltar
este
manipulador
de
cuando
las
excepciones
se
produzcan
en
el
....
(dtFHActual.Month
=
3)
excepciones,
pero
slo
de
desbordamiento
mes
de
Marzo
Console.WriteLine("El
"no
nmero
se
introducido
encuentra
Catch
Console.WriteLine("Error
'
en
oExcep
"
el
&
rango
As
_
adecuado")
OverflowException
desbordamiento")
....
de
Aadir un manipulador de excepciones genrico. Con esto evitaremos el mensaje de error no controlado,
generado por el IDE. Si por ejemplo, adems de las operaciones con el tipo Byte, nos encontramos manipulando
fechas, podremos capturar todas las excepciones producidas. Veamos este caso en el Cdigo fuente 399.
Public
Sub
Dim
Dim
Dim
byMiNum
dtFecha
dtFHActual
'
dtFHActual
Main()
Byte
Date
Date
As
As
As
obtener
la
fecha
actual
System.DateTime.Today()
Try
'
comienza
el
control
Console.WriteLine("Introducir
'
si
introducimos
un
'
en
el
rango
de
Byte,
segn
'
a
uno
de
los
manipuladores
byMiNum
=
'
si
introducimos
un
'
iremos
al
controlador
Console.WriteLine("Introducir
dtFecha
=
un
nmero
el
de
valor
de
una
de
errores
nmero")
no
incluido
mes
actual
iremos
excepcin
existentes
Console.ReadLine()
incorrecto
para
la
fecha,
errores
genrico
fecha")
Console.ReadLine()
Catch
oExcep
As
OverflowException
When
(dtFHActual.Month
=
3)
'
manipulador
de
excepciones
slo
'
cuando
las
excepciones
de
desbordamiento
'
se
produzcan
en
el
mes
de
Marzo
Console.WriteLine("El
nmero
introducido
"
&
_
"no
se
encuentra
Catch
'
manipulador
Console.WriteLine("Se
Finally
Console.WriteLine("El
End
Console.ReadLine()
en
el
oExcep
controlador
de
adecuado")
un
Exception
excepciones
error")
As
genrico
producido
ha
rango
errores
ha
de
finalizado")
Try
End
Sub
Cdigo fuente 399
El manipulador genrico de excepciones de este ltimo ejemplo tiene un problema, ya que aunque las captura
correctamente, no proporciona suficiente informacin, por lo que no podremos saber si el error se produjo por asignar
un valor incorrecto a la variable Byte o a la fecha.
Este problema tiene una fcil solucin: al ser una excepcin un objeto, y por lo tanto, un tipo del sistema,
mediante su mtodo GetType( ) obtendremos el tipo de excepcin producida, mostrndola en el mensaje del
manipulador de excepciones. Ver el Cdigo fuente 400.
'
'
Catch
oExcep
As
....
....
Exception
'
manipulador
Dim
oTipo
oTipo
=
Console.WriteLine("Se
ha
producido
'
'
genrico
de
excepciones
Type
oExcep.GetType()
{0}",
oTipo.Name)
As
un
error
de
tipo
....
....
Public
Sub
Dim
byMiNum
Dim
aValores()
'
esta
que
String
el
un
nmero
Byte
{"a",
control
un
Byte
"b",
de
se
lnea
no
As
As
Try
'
comienza
Console.WriteLine("Introducir
'
si
no
es
byMiNum
'
Main()
existe
produce
el
error
ndice
en
"c"}
errores
nmero")
produce
error
Console.ReadLine()
siempre,
ya
el
array
aValores(5)
Catch
'
manipulador
'
captura
todo
'
tambin
se
'
se
ejecutar
Console.WriteLine("Se
Catch
oExcep
As
genrico
de
tipo
de
excepciones,
por
produce
una
excepcin
este
manipulador,
por
estar
ha
producido
oExcep
'
'
"d"
captura
este
As
de
nunca
uno
se
Finally
Console.WriteLine("El
End
de
se
controlador
introducido
en
de
por
estar
genrico
nmero
encuentra
desbordamiento,
ejecutar,
ms
Console.WriteLine("El
"no
OverflowException
errores
manipulador
'
Exception
excepciones,
lo
que
si
OverflowException,
situado
primero
un
error")
errores
el
ha
antes
"
&
rango
adecuado")
finalizado")
Try
Console.ReadLine()
End
Sub
Cdigo fuente 401
En este caso que acabamos de ver, situaremos en primer lugar el manejador de excepciones de desbordamiento,
y por ltimo, el genrico.
....
Try
'
comienza
el
control
Console.WriteLine("Introducir
'
si
no
es
un
nmero
Byte
byMiNum
=
'
salimos
de
'
Exit
'
'
que
aValores(5)
de
errores
un
nmero")
se
produce
error
Console.ReadLine()
controlador
de
sin
esta
no
lnea
existe
el
produce
ndice
=
error
5
en
siempre,
el
errores
finalizarlo
Try
ya
array
"d"
Catch
oExcep
As
OverflowException
....
Catch
oExcep
As
Exception
....
....
'
'
'
End
Try
....
'
'
clase
Public
Private
Private
que
contiene
Class
msTitular
mdbDisponible
Public
As
As
informacin
sobre
una
cuenta
bancaria
CtaCredito
String
Double
Property
Titular()
As
String
Get
Return
End
Set(ByVal
Value
msTitular
msTitular
Get
String)
As
=
Value
Set
Property
End
End
Public
Get
Return
End
End
'
'
'
'
Public
ReadOnly
Property
Credito()
en
este
mtodo,
si
se
superior
al
permitido,
se
utilizando
un
objeto
de
heredado
Sub
AsignarCredito(ByVal
As
Double
mdbDisponible
Get
Property
intenta
asignar
un
importe
lanza
una
excepcin,
la
clase
CreditoException,
de
Exception
ldbCredito
As
Double)
If
ldbCredito
>
2500
Then
Throw New CreditoException("Lmite disponible: 2500 " & _
"Se
intent
asignar
"
&
CType(ldbCredito,
String))
Else
mdbDisponible
End
End
End
ldbCredito
If
Sub
Class
'
------------------------------------------------'
esta
clase
contiene
la
informacin
sobre
un
error
'
producido
en
un
objeto
CtaCredito
Public
Class
CreditoException
Inherits
Exception
Private
msDescripcion
Public
msDescripcion
End
Public
Get
Return
End
End
End
Sub
As
New(ByVal
lsDescripcion
String
As
ReadOnly
Property
Descripcion()
As
String)
lsDescripcion
Sub
String
msDescripcion
Get
Property
Class
El esquema del proceso es el siguiente: cuando al mtodo AsignarCredito( ), de un objeto CtaCredito, se intente
asignar un valor no permitido, se genera un nuevo objeto CreditoException y se lanza a travs de la palabra clave
Throw, que es la encargada de emitir las excepciones en el entorno de ejecucin.
Desde cdigo cliente, el uso de estas clases sera el que muestra el Cdigo fuente 404.
Module
'
Dim
Module1
Public
crear
Sub
un
oCredito
objeto
de
la
New
As
Try
'
asignar
valores
oCredito.Titular
=
oCredito.AsignarCredito(1000)
'
esto
Console.WriteLine("El
credito
actual
de
a
"Jaime
no
{0}
nueva
propiedades
Peral"
produce
error
es
{1:C}",
_
oCredito.Titular,
'
esta
oCredito.AsignarCredito(5000)
Catch
'
'
manipulador
sobre
Main()
clase
CtaCredito()
oCredito.Credito)
instruccin
oExcep
para
produce
As
las
un
excepciones
objeto
error
CreditoException
producidas
CtaCredito
Console.WriteLine("Error
Finally
Console.WriteLine("El
End
al
asignar
controlador
de
errores
crdito:
ha
{0}",
oExcep.Descripcion)
finalizado")
Try
Console.ReadLine()
End
End
Sub
Module
Cdigo fuente 404
El objeto Err
Este objeto se crea automticamente al iniciarse la aplicacin, y proporciona al usuario informacin sobre los
errores producidos en el transcurso de la aplicacin. Tiene mbito pblico, por lo que podremos usarlo desde cualquier
punto del programa.
Cuando se produzca un error, la propiedad Number de este objeto tendr un valor mayor de cero, mientras que
la propiedad Description, nos dar una informacin textual del error producido.
On Error
Esta instruccin activa o desactiva una rutina de manejo de errores. Tiene diversos modos de empleo, que
describimos en los siguientes apartados.
On
Public
Error
Dim
dtFecha
Exit
Sub
Goto
Main()
ControlErrores
dtFecha
=
As
"valor
Date
incorrecto"
Sub
'
-----------'
etiqueta
de
control
de
errores
ControlErrores:
Console.WriteLine("Error: {0} - {1}", Err.Number,
Err.Description)
Console.ReadLine()
End
Sub
Cdigo fuente 405
Si queremos reintentar la ejecucin de la lnea que produjo el error, debemos utilizar en la etiqueta de control de
errores la instruccin Resume, como muestra el Cdigo fuente 406.
On
Public
Error
Sub
Goto
Main()
ControlErrores
Dim
Console.WriteLine("Introducir
dtFecha
Console.WriteLine("Esta
dtFecha
As
una
=
lnea
se
ejecuta
despus
Date
fecha")
Console.ReadLine()
del
error")
Console.ReadLine()
Exit
Sub
'
'
etiqueta
ControlErrores:
-----------de
control
Console.WriteLine("Error:
de
{0}
errores
-
{1}",
Err.Number,
Err.Description)
Console.ReadLine()
Resume
End
Sub
Cdigo fuente 406
De esta forma, en el ejemplo anterior, damos una nueva oportunidad al usuario, en el caso de que haya
introducido una fecha incorrecta.
Si no queremos volver a reintentar la lnea del error, usaremos la instruccin Resume Next, que despus de
ejecutar la etiqueta de control de errores, seguir la ejecucin en la siguiente lnea a la que provoc el error. Tambin
podemos utilizar el formato Resume Etiqueta, en donde Etiqueta representa a otra etiqueta de control, a la que saltar
el cdigo despus de finalizar la ejecucin de la actual.
Esta variante de la instruccin On Error, hace que al producirse un error, la ejecucin contine con la siguiente
lnea de cdigo, por lo que no utiliza etiquetas de control para desviar la ejecucin.
Debido a sus caractersticas, en este tipo de captura de errores, tras cada lnea susceptible de provocar un error,
debemos consultar los valores del objeto Err, para comprobar si existe un error, y actuar en consecuencia.
En este tipo de situaciones, despus de comprobar un error, debemos inicializar el objeto Err, llamando a su
mtodo Clear( ).
Veamos pues, un ejemplo de este tipo de gestin de errores en el Cdigo fuente 407.
On
Public
Error
Sub
Resume
Dim
Console.WriteLine("Introducir
dtFecha
Main()
Next
dtFecha
As
Date
fecha")
Console.ReadLine()
una
=
If
Err.Number
Console.WriteLine("Error:
{0}
Console.ReadLine()
Err.Clear()
>
{1}",
0
Err.Number,
Then
Err.Description)
End
If
On
Public
Error
Sub
Goto
Dim
Console.WriteLine("Introducir
iValor
If
Err.Raise(5100,
End
iValor
"El
Console.WriteLine("Esta
Console.ReadLine()
Exit
Main()
ControlErrores
iValor
As
Integer
nmero")
Console.ReadLine()
un
=
nmero
lnea
>
debe
se
ser
ejecuta
500
menor
de
Then
500")
If
despus
de
un
posible
error")
Sub
'
'
etiqueta
ControlErrores:
Console.WriteLine("Error:
Console.ReadLine()
Resume
de
{0}
control
{1}",
-----------errores
de
Err.Number,
Err.Description)
Next
End
Sub
On Error Goto 0
Este uso de la instruccin On Error, desactiva el manejador de errores que hubiera activado hasta el momento;
de modo, que a no ser que activemos otro manejador, los errores que se produzcan a partir de esa lnea, provocarn un
error fatal, cancelando la ejecucin del programa. Ver el Cdigo fuente 409.
Public
On
Error
Sub
Goto
Main()
ControlErrores
Dim
Console.WriteLine("Introducir
iValor
iValor
On
Console.WriteLine("Introducir
iValor
Error
As
Integer
nmero")
Console.ReadLine()
un
=
Goto
0
nmero")
Console.ReadLine()
otro
=
Console.ReadLine()
Exit
Sub
'
'
etiqueta
ControlErrores:
Console.WriteLine("Error:
Console.ReadLine()
Resume
End
de
{0}
control
-
{1}",
de
Err.Number,
-----------errores
Err.Description)
Next
Sub
Objetos Stream
Un objeto Stream representa un flujo o corriente de datos, es decir, un conjunto de informacin guardada en
formato de texto o binario, que podremos leer y escribir sobre un soporte fsico, tambin denominado en la plataforma
.NET, almacn de respaldo (backing store).
Algunos tipos de Stream, para optimizar el flujo de transferencia de datos entre el objeto y su medio fsico de
almacenamiento, disponen de una caracterstica denominada almacenamiento intermedio (buffering), que consiste en
mantener un bfer intermedio con los datos. En el caso, por ejemplo, de tareas de escritura, todas las operaciones se
realizaran en el bfer, mientras este dispusiera de capacidad. Una vez terminado el proceso de escritura, o cuando el
bfer estuviera lleno, su contenido pasara al archivo fsico. Podemos tambin, alterar el comportamiento por defecto
del bfer a travs de diversas propiedades y mtodos del objeto Stream correspondiente.
La clase StreamWriter
Un objeto StreamWriter realiza operaciones de escritura de texto sobre un archivo.
El proceso tpico de escritura de datos mediante un StreamWriter, comprende los siguientes pasos:
.
Instanciar un objeto de esta clase mediante alguno de los constructores disponibles. Aqu
creamos un nuevo archivo para escribir datos sobre l, o abrimos uno existente.
.
Escritura de texto mediante los mtodos WriteLine( ) y Write( ). El primero escribe el texto
pasado como parmetro, y aade los caracteres especiales de retorno de carro y nueva lnea. El segundo escribe el
texto pasado y deja el puntero de escritura a partir del ltimo carcter escrito, con lo que no produce un cambio
automtico de lnea. Deberemos utilizar la propiedad NewLine para introducir manualmente un salto de lnea.
.
Cierre del Stream con el mtodo Close( ). Esta accin vuelca el contenido del bfer del objeto en el
archivo.
Imports
System.IO
Module
Sub
Dim
'
creamos
'
nuevo
swEscritor
Module1
un
Main()
swEscritor
As
StreamWriter
stream
de
escritura,
y
al
mismo
tiempo
un
archivo
para
escribir
texto
sobre
l
=
New
StreamWriter("\pruebas\NOTAS.txt")
'
swEscritor.WriteLine("esta
swEscritor.WriteLine("segunda
escribir
es
la
lnea
'
ahora
escribimos
texto
swEscritor.Write("Juan
swEscritor.Write("van
swEscritor.Write(swEscritor.NewLine)
pero
y
'
esto
swEscritor.WriteLine("con
'
cerrar
swEscritor.Close()
End
End
el
sin
provocar
de
introduce
esta
stream
el
lneas
lnea")
texto")
primera
de
un
Luna
salto
el
salto
lnea
archivo
de
de
lnea
")
paseo")
lnea
cerramos")
asociado
Sub
Module
Algunas de las clases de tipo Stream de escritura disponen del campo compartido Null, que permite realizar una
operacin de escritura que no ser volcada en el medio fsico de almacenamiento, con lo que se perdern los datos
escritos. Ver el Cdigo fuente 411.
'
escribir
a
swEscritor.Null.WriteLine("este
un
medio
texto
no
inexistente
llegar
al
(nulo)
archivo")
En el caso de que el archivo sobre el que vamos a escribir ya exista, podemos utilizar un constructor de
StreamWriter que nos permite especificar si vamos a aadir texto al archivo o vamos a sobrescribir, perdiendo el texto
que hubiera. Veamos un ejemplo en el Cdigo fuente 412.
' abre el archivo y se sita al final del texto para aadir
swEscritor
=
New
StreamWriter("\pruebas\NOTAS.txt",
True)
'
se
swEscritor
elimina
New
el
contenido
previo
del
StreamWriter("\pruebas\NOTAS.txt",
archivo
False)
Despus de crear un objeto de este tipo, y escribir algunas lneas de texto sin cerrar el Stream, si abrimos su
archivo de texto correspondiente, nos encontraremos con que no hay texto dentro del archivo. Ello es debido a que
todava no se ha volcado el contenido del bfer del objeto sobre el archivo. Para forzar dicho volcado, deberemos
llamar al mtodo Flush( ), que se encarga de traspasar el bfer al archivo asociado al Stream. Veamos el Cdigo fuente
413.
Dim
'
creamos
swEscritor
=
swEscritor
As
StreamWriter
un
stream
de
escritura
New
StreamWriter("\pruebas\NOTAS.txt",
False)
'
escribir
swEscritor.WriteLine("la
primera
swEscritor.WriteLine("un
poco
ms
' si abrimos el
swEscritor.Flush()
'
ahora
el
' cerrar el
swEscritor.Close()
archivo
antes
de
archivo
stream
el
de
lneas
lnea")
texto")
la
siguiente,
ya
estar
contendr
archivo
vaco
texto
asociado
La clase StreamReader
Un objeto StreamReader realiza operaciones de lectura de texto sobre un archivo.
El proceso que debemos llevar a cabo para leer el contenido de un Stream de lectura es muy similar al de
escritura: instanciar el objeto con uno de sus constructores, abriendo un archivo para leer; ejecutar alguno de los
mtodos de lectura del StreamReader, y cerrar el objeto con Close( ).
Entre los mtodos de lectura de este objeto, tenemos ReadLine( ), que devuelve una lnea del archivo; y
ReadToEnd( ), que devuelve el resto del contenido del archivo, desde el punto en el que se encontrara el Stream al
realizar la ltima lectura. Veamos unos ejemplos en el Cdigo fuente 414.
Dim
srLector
As
Console.WriteLine("**Leer
Dim
Linea
Linea
=
Console.WriteLine("La
lnea
StreamReader
una
New
StreamReader("\pruebas\NOTAS.txt")
primera
As
contiene
lnea**")
String
srLector.ReadLine()
-->
{0}",
Linea)
Console.WriteLine()
Console.WriteLine("**Ahora
leemos
el
resto
Dim
Texto
As
Texto
=
Console.WriteLine("El
texto
restante
contiene
del
archivo**")
String
srLector.ReadToEnd()
-->
{0}",
Texto)
srLector.Close()
' ***********************************************
'
leer
lnea
a
Dim
srLector
As
StreamReader
=
Dim
Linea
Dim
ContadorLin
As
Linea
=
Do
While
Not
Console.WriteLine("Lnea:
ContadorLin
Linea
lnea
mediante
un
bucle
New
StreamReader("\pruebas\Datos.txt")
As
String
Integer
=
1
srLector.ReadLine()
(Linea
Is
Nothing)
{0}
Contenido:
+=
{1}",
ContadorLin,
Linea)
1
srLector.ReadLine()
Loop
Otro de los mtodos de lectura es ReadBlock( ), que recibe como parmetro un array de tipo Char, sobre el que
se depositarn una cierta cantidad de caracteres ledos del archivo. En el segundo parmetro de este mtodo indicamos
la posicin del array desde la que se comenzarn a guardar los caracteres. En el tercer parmetro, el nmero de
caracteres a leer.
El mtodo Read( ), tambin permite realizar una lectura igual que ReadBlock( ), pero en el caso de no utilizar
parmetros, devuelve un valor numrico, correspondiente al cdigo del carcter que acaba de leer. Cuando llega al
final del Stream, devuelve 1.
Para convertir de nuevo a carcter los valores que devuelve Read( ), debemos pasar estos valores a un array de
tipo Byte, y despus, utilizando un objeto ASCIIEncoding, mediante su mtodo GetString( ), pasaramos el array a una
cadena. Veamos unos ejemplos de estos mtodos en el Cdigo fuente 415.
Imports
Imports
System.IO
System.Text
Module
Module1
Sub
'
Dim
crear
srLector
As
un
StreamReader
Stream
New
Main()
de
lectura
StreamReader("\pruebas\NOTAS.txt")
'
obtener
valores
del
Stream
con
el
mtodo
ReadBlock()
'
---------------------------------------------------'
crear
un
array
Char
que
contendr
los
caracteres
ledos
Dim
Caracteres(15)
As
Char
'
leemos
16
caracteres
del
archivo
y
los
pasamos
al
array
'
comenzando
a
grabarlos
a
partir
de
su
posicin
0
srLector.ReadBlock(Caracteres,
0,
16)
'
pasamos
el
array
de
valores
Char
a
String
mediante
'
el
constructor
de
la
clase
String
que
recibe
como
'
parmetro
un
array
Char
Dim
Parte1
As
String
=
New
String(Caracteres)
Console.WriteLine("Resultado
de
la
lectura
con
ReadBlock()")
Console.WriteLine(Parte1)
Console.WriteLine()
'
obtener
valores
'
Dim
Dim
del
Valor
Codigos()
'
'
Valor
While
vamos
leidos
(Valor
If
ir
desde
<>
volcando
el
-1)
Codigos
ReDim
Else
ReDim
End
Preserve
'
en
=
cuando
Is
stream
con
el
mtodo
Read()
----------------------------------------------As
Integer
As
Byte
un
bucle
los
archivo
a
lleguemos
Nothing
Codigos(Codigos.GetUpperBound(0)
Codigos(Codigos.GetUpperBound(0))
Valor
End
Then
Codigos(0)
+
1)
If
Valor
srLector.Read()
While
Dim
Dim
'
'
'
al
cdigos
de
carcter
un
array
Byte
srLector.Read()
final,
obtendremos
-1
con
obtenemos
Codificador
Parte2
el
objeto
una
cadena,
de
Parte2
Console.WriteLine("Resultado
Console.WriteLine(Parte2)
As
New
As
ASCIIEncoding,
pasando
como
tipos
=
de
la
lectura
mtodo
parmetro
ASCIIEncoding()
String
GetString(),
un
array
Byte
Codificador.GetString(Codigos)
con
ReadBlock()")
Console.ReadLine()
End
End
Sub
Module
Cdigo fuente 415
Finalmente, el mtodo Peek( ), al igual que Read( ), devuelve el siguiente valor disponible del Stream, pero sin
extraerlo del bfer, con lo que deberemos utilizar alguno de los mtodos anteriormente descritos para realizar una
lectura real.
alguna de sus clases derivadas como son FileStream, MemoryStream, BufferedStream, etc.
La clase FileStream
Realiza escritura y lectura de bytes sobre un archivo; en el caso de que el archivo no exista, lo crearamos al
mismo tiempo que instanciamos este objeto.
Uno de los constructores de esta clase, nos permite especificar una cadena con la ruta del archivo a utilizar,
mientras que en el segundo parmetro utilizaremos un valor de la enumeracin FileMode, mediante la que indicamos
el modo de trabajo sobre el archivo: aadir, abrir, crear, etc.
Las propiedades CanRead, CanWrite y CanSeek, devuelven un valor lgico que nos informa de si en el objeto
podemos realizar operaciones de lectura, escritura y desplazamiento por los bytes que contiene.
Para escribir datos, disponemos del mtodo WriteByte( ), que escribe un byte en el archivo; y tambin tenemos
el mtodo Write( ), que escribe de un array de bytes pasado como parmetro, una cantidad de elementos determinada
empezando por una de las posiciones de dicho array. Veamos un ejemplo de escritura en el Cdigo fuente 416.
'
Dim
oFileStream
escrituras
con
oFileStream
As
New
FileStream("\pruebas\apuntes.dtt",
oFileStream.Close()
oFileStream
=
88,
40,
67,
Filestream
FileStream
FileMode.CreateNew)
24,
37,
50,
el
IIf(oFileStream.CanRead,
IIf(oFileStream.CanWrite,
IIf(oFileStream.CanSeek,
21},
0,
6)
FileStream")
"SI",
"NO"))
"SI",
"NO"))
"SI",
"NO"))
Nothing
Para las operaciones de lectura, tenemos ReadByte( ), que devuelve el valor sobre el que est posicionado el
objeto en ese momento. Tambin disponemos del mtodo Read( ), que traspasa valores un array de bytes.
Si queremos desplazarnos por los elementos del Stream, podemos utilizar el mtodo Seek( ), pasando la
cantidad de posiciones a movernos, y el punto desde el que queremos realizar dicho desplazamiento, mediante los
valores de la enumeracin SeekOrigin.
Para averiguar el elemento del Stream en el que estamos situados, disponemos de la propiedad Position.
Veamos algunos ejemplos de lectura sobre este tipo de objetos, en el Cdigo fuente 417.
'
lectura
con
Dim
oFileStream
As
oFileStream
=
New
FileStream("\pruebas\apuntes.dtt",
Dim
Valor
As
Valor
=
oFileStream.ReadByte()
'
obtener
Console.WriteLine("Se
ha
leido
el
valor:
FileStream
FileStream
FileMode.Open)
Byte
un
valor
{0}",
Valor)
Console.WriteLine("Nos
oFileStream.Seek(2,
desplazamos
dos
Valor
Console.WriteLine("Se
leido
oFileStream.ReadByte()
valor:
{0}",
Valor)
=
ha
Console.WriteLine("La
oFileStream.Position)
el
posicin
Console.WriteLine("Leer
Dim
Enumerador
Enumerador
=
While
Console.WriteLine("Valor:
actual
bytes
del
en el stream")
SeekOrigin.Begin)
stream
es:
{0}",
pasndolos
a un array
dimensionado
As
Byte
0,
4)
bloque
de
valores
del
stream")
As
IEnumerator
VariosValores.GetEnumerator()
Enumerador.MoveNext
{0}",
End
Enumerador.Current)
While
Console.ReadLine()
Las clases BufferedStream y MemoryStream, que tambin heredan de Stream, disponen de los mismos
miembros que FileStream, teniendo como principal diferencia el que utilizan la memoria de la mquina como almacn
de respaldo.
'
Dim
oBin
As
New
FileMode.CreateNew))
oBin.Write("H"c)
oBin.Write("D"c)
oBin.Write("U"c)
oBin.Close()
oBin
escritura
BinaryWriter(New
binaria
FileStream("\pruebas\info.bin",
'
Dim
oBinLector
oBinLector
=
New
BinaryReader(New
Console.WriteLine("Valor
1
del
Console.WriteLine("Valor
2
del
Console.WriteLine("Valor
3
del
oBinLector.Close()
Nothing
lectura
binaria
As
BinaryReader
FileStream("\pruebas\info.bin",
FileMode.Open))
lector:
{0}",
oBinLector.ReadChar())
lector:
{0}",
oBinLector.ReadChar())
lector:
{0}",
oBinLector.ReadChar())
Console.ReadLine()
Dim
Dim
Dim
sNombreFich
srLector
As
swEscritor
As
As
String
StreamReader
StreamWriter
Console.WriteLine("Introducir
sNombreFich
If
srLector
Console.WriteLine("El
ruta
=
archivo")
Console.ReadLine()
File.Exists(sNombreFich)
Then
=
File.OpenText(sNombreFich)
archivo
contiene:{0}{1}",
_
ControlChars.CrLf,
srLector.Close()
Else
swEscritor
=
swEscritor.WriteLine("este
swEscritor.WriteLine("un
swEscritor.Close()
srLector.ReadToEnd())
File.CreateText(sNombreFich)
es")
nuevo
archivo")
End
Console.WriteLine("Proceso
Console.ReadLine()
If
finalizado")
Para obtener los atributos de un archivo, disponemos del mtodo GetAttributes( ), al que pasamos la ruta de un
archivo, y devuelve un valor de la enumeracin FileAttributes con la informacin sobre los atributos. En el caso de
que al intentar acceder a un archivo, este no exista, se producir una excepcin de tipo FileNotFoundException, que
podemos tratar en una estructura de manejo de excepciones. Ver el Cdigo fuente 420.
Dim
Dim
sNombreFich
oAtributos
As
As
String
FileAttributes
Try
Console.WriteLine("Introducir
sNombreFich
oAtributos
Console.WriteLine("Atributos
Catch
Console.WriteLine("Se
ControlChars.CrLf,
ruta
archivo")
Console.ReadLine()
File.GetAttributes(sNombreFich)
{0}",
oAtributos.ToString())
=
=
del
oExcep
ha
archivo:
As
producido
Finally
Console.WriteLine("Proceso
Console.ReadLine()
un
error
FileNotFoundException
{0}{1}",
_
oExcep.Message)
finalizado")
End
Try
Adems de esta excepcin, el espacio de nombres IO proporciona algunas clases de excepcin adicionales para
tratar otras diversas circunstancias de error. Consulte el lector la documentacin de la plataforma referente a IO.
Los mtodos Copy( ), Move( ) y Delete( ), nos permiten copiar, mover y borrar respectivamente el nombre de
archivo que pasemos como parmetro. El mtodo GetCreationTime( ) nos devuelve un tipo Date con la fecha de
creacin del archivo.
Por otro lado, si queremos obtener informacin adicional sobre un archivo, como su nombre, extensin, ruta,
etc., instanciaremos un objeto FileInfo( ), pasando al constructor una cadena con el nombre del archivo, y utilizaremos
algunas de sus propiedades como Name, Extensin, DirectoryName. Veamos una muestra de todo esto en el Cdigo
fuente 421.
Dim
Dim
Dim
sNombreFich
As
String
iOperacion
As
Integer
oFInfo
As
FileInfo
Console.WriteLine("Introducir
sNombreFich
=
ruta
y
archivo")
Console.ReadLine()
Console.WriteLine("Fecha
creacin
File.GetCreationTime(sNombreFich))
oFInfo
archivo:
Console.WriteLine("Introducir
Console.WriteLine("1
Console.WriteLine("2
{0}",
New
el
nmero
-
de
operacin
FileInfo(sNombreFich)
realizar:")
Copiar")
Mover")
Console.WriteLine("3
iOperacion
Borrar")
Console.ReadLine()
Select
Case
iOperacion
Case
1
File.Copy(sNombreFich, "\pruebas\distinto"
&
oFInfo.Extension)
Case
Console.WriteLine("Vamos
a
Console.WriteLine("que
est
File.Move(sNombreFich,
Console.WriteLine("Completado")
Console.ReadLine()
mover
el
en
la
"\pruebas\"
archivo
ruta
{0}",
&
2
{0}",
oFInfo.Name)
oFInfo.DirectoryName)
oFInfo.Name)
Case
File.Delete(sNombreFich)
End
Select
Dim
Dim
Dim
Dim
sNombreDir
Archivos()
Archivo
oDirInfo
As
As
String
As
String
As
String
DirectoryInfo
Console.WriteLine("Introducir
sNombreDir
=
un
nombre
de
directorio")
Console.ReadLine()
If
Directory.Exists(sNombreDir)
Console.WriteLine("Fecha
ltimo
acceso:
Directory.GetLastAccessTime(sNombreDir))
Console.WriteLine("Archivos
Archivos
del
=
directorio
{0}",
Then
_
{0}",
sNombreDir)
Directory.GetFiles(sNombreDir)
For
Each
Archivo
In
Archivos
Console.WriteLine(Archivo)
Next
oDirInfo
New
DirectoryInfo(sNombreDir)
oDirInfo.CreateSubdirectory("bak")
Else
Directory.CreateDirectory(sNombreDir)
Console.WriteLine("No
exista
el
directorio,
se
acaba
End
de
crear")
If
Para obtener el directorio actual de ejecucin, disponemos del mtodo GetCurrentDirectory( ), mientras que si
queremos subir al directorio de nivel superior, tenemos el mtodo GetParent( ), que devuelve un tipo DirectoryInfo,
con el que podemos, por ejemplo, mostrar su nombre completo mediante la propiedad FullName, y fecha de creacin
con CreationTime. Veamos el Cdigo fuente 423.
Dim
Dim
sNombreDir
oDirInfo
As
As
String
DirectoryInfo
'
obtenemos
el
directorio
actual
de
ejecucin
sNombreDir
=
Directory.GetCurrentDirectory()
Console.WriteLine("Directorio
actual:
{0}",
sNombreDir)
'
obtenemos
el
directorio
'
y
mostramos
informacin
oDirInfo
=
Console.WriteLine("Directorio
padre
y
fecha
ControlChars.CrLf,
padre
del
actual,
de
dicha
directorio
Directory.GetParent(sNombreDir)
de
creacin
{0}{1}{2}{3}",
_
oDirInfo.FullName,
ControlChars.CrLf,
_
oDirInfo.CreationTime)
En el siguiente ejemplo, el mtodo GetDirectories( ) devuelve un array de cadenas, con los nombres de los
subdirectorios que se encuentran dentro del directorio pasado como parmetro a este mtodo. A continuacin,
mediante el mtodo Move( ), cambiamos de lugar un directorio; con Delete( ) borramos otro de los directorios.
Observe el lector, cmo utilizando de forma combinada CType( ), Directory.GetFiles( ), y un elemento del array que
contiene la lista de directorios, creamos una expresin que nos permite averiguar, si en un determinado directorio hay
o no archivos. Ver el Cdigo fuente 424.
Dim
Dim
sNombreDir
oDirInfo
As
As
String
DirectoryInfo
Dim
sDirectorios()
As
Dim
String
sDirectorio
Console.WriteLine("Introducir
sNombreDir
=
'
obtener
sDirectorios
'
If
un
As
nombre
String
de
directorio")
Console.ReadLine()
directorios
del
directorio
especificado
=
Directory.GetDirectories(sNombreDir)
subdirectorios")
Console.ReadLine()
Exit
contiene a su vez
negativo,
finalizar
>
1)
Then
directorio
especificado
debe
contener
al
menos
dos
Sub
End
'
mostrar
For
Each
Console.WriteLine(sDirectorio)
Next
If
nombres
sDirectorio
otra
de
In
ubicacin
del
directorios
sDirectorios
disco actual
"\temp\BIS")
'
'
'
'
If
borrar
otro
de
los
directorios;
el
directorio
a
borrar
debe
estar
vaco;
comprobar
con
la
siguiente
expresin
si
dicho
directorio
contiene
o
no
archivos
(CType(Directory.GetFiles(sDirectorios(1)),
String()).Length()
>
0)
Then
Console.WriteLine("Completado")
Console.ReadLine()
Cdigo fuente 424
La clase Path
Esta clase nos proporciona un conjunto de campos y mtodos compartidos, para la obtencin de informacin y
manipulacin de rutas de archivos. El Cdigo fuente 425 muestra un ejemplo en el que, una vez introducido un
directorio, se muestra la informacin de cada uno de sus archivos, en lo que respecta a los mtodos de esta clase.
Console.WriteLine("Introducir
nombre
de
directorio")
Dim
sDirectorio
Dim
sArchivos
sDirectorio
As
=
String
Console.ReadLine()
sArchivos()
As
String
Directory.GetFiles(sDirectorio)
{0}",
{0}",
Console.WriteLine("GetFileName()
Console.WriteLine("GetFileNameWithoutExtension()
Path.GetDirectoryName(sArchivo))
Path.GetExtension(sArchivo))
{0}",
Path.GetFileNameWithoutExtension(sArchivo))
Console.WriteLine("GetFullPath()
{0}",
Console.WriteLine()
Path.GetFileName(sArchivo))
{0}",
Path.GetFullPath(sArchivo))
Next
Console.ReadLine()
Module
Private
Sub
'....
'....
Cdigo fuente 426
Module1
WithEvents
oFSW
As
FileSystemWatcher
Main()
Sub
Main()
'
instanciar
oFSW
objeto
New
'
FileSystemWatcher()
configurar
oFSW.Path
objeto
oFSW.Filter
"C:\pruebas"
=
"*.txt"
oFSW.IncludeSubdirectories
'
oFSW.EnableRaisingEvents
'
'
FileSystemWatcher
mientras
que
no
sistema
While
End
activar
True
el
End
True
pulsemos
de
(Console.ReadLine()
S,
el
objeto
archivos
del
<>
inspeccionar
equipo
"S")
While
Sub
Para completar este proceso que estamos describiendo, slo nos queda escribir los procedimientos que van a
ejecutarse cuando se realice la creacin, borrado, modificacin, etc., de un archivo.
Puesto que hemos declarado la variable FileSystemWatcher a nivel del mdulo de cdigo, seleccionaremos
dicha variable en la lista desplegable Nombre de clase, del editor de cdigo. Seguidamente, abriremos la lista Nombre
de mtodo, tambin del editor; seleccionando el evento a codificar.
Las anteriores acciones, crearn el procedimiento de evento correspondiente, pero vaco, por lo que tendremos
que escribir el cdigo que queramos ejecutar en respuesta a tal evento. La lista de parmetros de este procedimiento
consiste en un tipo Object, que contiene la referencia al objeto FileSystemWatcher que origin el evento; y un tipo
FileSystemEventArgs, que contiene informacin adicional sobre el evento ocurrido, como el nombre y ruta del
archivo.
El Cdigo fuente 428 muestra los procedimientos de evento que se ejecutarn cuando se cree o borre un archivo.
' al crear un fichero se ejecutar este procedimiento de evento
Public
Sub
oFSW_Created(ByVal
sender
As
Object,
ByVal
e
As
System.IO.FileSystemEventArgs)
Handles
oFSW.Created
Console.WriteLine("Se
ha
creado
un
archivo
{0}",
End
ha
e.FullPath)
Sub
el
borrado:
End
{0}",
e.FullPath)
Sub
'
Dim
Sub
instanciar
oFSW
As
objeto
New
Main()
FileSystemWatcher
FileSystemWatcher()
'
oFSW.Path
oFSW.Filter
oFSW.IncludeSubdirectories
'
'
con
AddHandler
AddHandler
conectamos
los
configurar
=
=
=
manualmente
procedimientos
oFSW.Created,
oFSW.Changed,
los
eventos
manipuladores
de
AddressOf
AddressOf
'
oFSW.EnableRaisingEvents
'
'
While
End
mientras
el
objeto
"C:\pruebas"
"*.txt"
True
del
esos
objeto
eventos
oFSW_Created
CambioProducido
activar
True
que
no
pulsemos
sistema
de
(Console.ReadLine()
S,
el
archivos
objeto
del
inspeccionar
equipo
"S")
While
<>
End
Sub
Public
Sub
oFSW_Created(ByVal
System.IO.FileSystemEventArgs)
Console.WriteLine("Se
ha
creado
End
Public Sub CambioProducido(ByVal
FileSystemEventArgs)
Console.WriteLine("Se
ha
sender
un
Object,
archivo:
emisor
cambiado
As
el
As
Object,
archivo:
End
{0}",
ByVal
{0}",
ByVal
As
e.FullPath)
Sub
argumentos
As
argumentos.FullPath)
Sub
Observe el lector, que para el nombre del procedimiento manipulador de evento, podemos emplear tanto el
formato que utiliza el editor de cdigo, como otro nombre cualquiera.
Para el evento de creacin de archivo hemos utilizado el formato que usa tambin el editor, consistente en poner
el nombre de objeto, guin bajo, y nombre de evento: oFSW_Created( ).
Sin embargo para el evento de modificacin de archivo hemos utilizado un nombre que no se ajusta en absoluto
al formato del editor: CambioProducido( ).
Sub
Main()
'....
oFSW.Path
"\pruebas"
'....
End
Sub
Public
Sub
oFSW_Created(ByVal
sender
As
Object,
ByVal
As
System.IO.FileSystemEventArgs)
'
al
intentar
utilizar
Console.WriteLine("Se
ha
la
propiedad
creado
un
FullPath
ocurrir
archivo:
{0}",
End
un
error
e.FullPath)
Sub
Para que en el anterior ejemplo no se produzca un error, debemos indicar tambin la letra de unidad
correspondiente al asignar la ruta a Path. Ver Cdigo fuente 431.
oFSW.Path
"C:\pruebas"
Dim
oFSW
As
New
FileSystemWatcher()
'....
'
crear
un
objeto
de
espera
para
un
evento
Dim
oWFCR
As
WaitForChangedResult
oWFCR
=
oFSW.WaitForChanged(WatcherChangeTypes.Created)
Console.WriteLine("Se
ha
creado
el
archivo:
{0}",
oWFCR.Name)
'....
Como comentbamos al comienzo de este tema, en anteriores versiones de VB, el programador tena a su
disposicin un grupo de instrucciones como Open, Input, Write, etc., para la lectura y escritura de informacin en
archivos.
Por cuestiones de compatibilidad y migracin de aplicaciones existentes, estas instrucciones han sido
transformadas en funciones, para facilitar su manejo.
Funciones como FileOpen( ), para abrir un archivo; FileClose( ), para cerrarlo; LineInput( ), para leer una lnea
de texto de un archivo, etc, son las que permiten en la actual versin del lenguaje, realizar las operaciones que
anteriormente efectubamos mediante sus correspondientes instrucciones.
El Cdigo fuente 433 muestra un pequeo ejemplo, en el que se abre un fichero de texto y se lee su contenido
utilizando algunas de estas funciones. Consulte el lector, la documentacin de la plataforma, para una mayor
informacin.
Dim
'
obtener
iNumArchivo
iNumArchivo
nmero
de
manipulador
=
'
abrir
FileOpen(iNumArchivo,
Dim
'
recorrer
While
sLinea
archivo
Not
'
Integer
archivo
libre
FreeFile()
archivo
para
"\cubo\notas.txt",
lectura
OpenMode.Input)
As
String
hasta
el
final
EOF(iNumArchivo)
leer
una
sLinea
Console.WriteLine(sLinea)
End
'
cerrar
el
FileClose(iNumArchivo)
As
de
lnea
=
del
archivo
LineInput(iNumArchivo)
While
archivo
Console.ReadLine()
A pesar de que estas funciones nos permiten la manipulacin de ficheros, debemos tener muy presente que se
trata de elementos fundamentalmente proporcionados para compatibilidad con versiones anteriores, por lo que se
recomienda que cuando tengamos que hacer cualquier tipo de operacin con archivos en cuanto a su lectura, escritura,
manipulacin, etc., utilicemos las clases del espacio de nombres IO.
Formularios
Windows
para diferenciarlas de los formularios Web o WebForms, que son los que se ejecutan en pginas ASP.NET.
System.Windows.Forms
Este espacio de nombres contiene todos los tipos del entorno, a travs de los cuales podremos desarrollar
aplicaciones compuestas por formularios Windows, junto a los correspondientes controles que permiten al usuario la
interaccin con el programa.
El conjunto de clases, estructuras, enumeraciones, etc., de System.Windows.Forms, permiten la creacin de
aplicaciones Windows, basadas en el nuevo motor de generacin de formularios (Form Engine), ms potente y verstil
que el disponible en anteriores versiones de VB.
La clase Form
Esta clase contiene todos los miembros para la creacin y manipulacin de formularios.
Tras instanciar un objeto de Form, mediante la configuracin de las adecuadas propiedades, podemos crear
formularios estndar, de dilogo, de interfaz mltiple o MDI, con diferentes bordes, etc.
superficie de la ventana. Si por algn motivo, necesitamos eliminar dicha imagen de fondo para el formulario, haremos
clic derecho sobre el pequeo rectngulo situado al lado del nombre de la propiedad, y seleccionaremos la opcin
Restablecer del men contextual. Ver Figura 218.
El icono por defecto lo cambiaremos con la propiedad Icon, seleccionndolo de igual forma que para la imagen
de fondo, y asignando un archivo con extensin .ICO.
Finalmente, asignaremos el valor False a la propiedad MaximizeBox, con lo que se deshabilitar el botn del
formulario que permite maximizarlo. La Figura 219 muestra el formulario de este ejemplo en ejecucin.
Public
Inherits
Class
Form1
System.Windows.Forms.Form
#Region
"
Windows
Form
Public
MyBase.New()
generated
any
is
required
initialization
by
the
after
the
'Form
overrides
dispose
to
clean
up
Protected Overloads Overrides Sub Dispose(ByVal
If
disposing
If
Not
(components
Is
components.Dispose()
End
End
MyBase.Dispose(disposing)
"
New()
Windows
Form
InitializeComponent()
End
End
code
Sub
'This
call
InitializeComponent()
'Add
Designer
Designer.
call
Sub
the
component
list.
disposing As Boolean)
Then
Nothing)
Then
If
If
Sub
'Required
Private
by
components
the
Windows
As
'NOTE:
The
following
procedure
is
'It
can
be
modified
using
'Do
not
modify
it
<System.Diagnostics.DebuggerStepThrough()>
required
the
using
Private
by
Form
Designer
System.ComponentModel.Container
the
Windows
Form
Designer
Windows
Form
Designer.
the
code
editor.
Sub
InitializeComponent()
Dim
resources
As
System.Resources.ResourceManager
System.Resources.ResourceManager(GetType(frmPrueba))
'
'frmPrueba
'
Me.AutoScaleBaseSize
Me.BackgroundImage
=
=
New
New
System.Drawing.Size(5,
13)
CType(resources.GetObject("$this.BackgroundImage"),
System.Drawing.Bitmap)
Me.ClientSize
=
New
System.Drawing.Size(336,
101)
Me.Icon
=
CType(resources.GetObject("$this.Icon"),
System.Drawing.Icon)
Me.Location
=
New
System.Drawing.Point(3200,
6000)
Me.MaximizeBox
=
False
Me.Name
=
"frmPrueba"
Me.Text
=
"Ejemplo
sencillo
con
formularios
Windows"
End
#End
End
Sub
Region
Class
Entre los diferentes miembros de esta clase, podemos identificar el mtodo constructor New( ); el mtodo
Dispose( ), que podemos utilizar para destruir explcitamente el objeto formulario; y el mtodo InitializeComponent( ),
que sirve para inicializar los valores tanto del propio formulario, como de los controles que pudiera contener.
Sin embargo, esta accin tiene ms implicaciones de las que en un principio pudiera parecer, ya que si
intentamos ahora ejecutar el programa, se producir un error.
Esto es debido a que al crear el proyecto, el objeto inicial del mismo era el formulario, pero tena como nombre
Form1, al cambiar el nombre a frmPrueba, el IDE no puede encontrarlo y genera el error.
Para solucionarlo, debemos abrir la ventana del Explorador de soluciones; hacer clic en el nombre del proyecto,
y despus clic en el ltimo botn de esta ventana, que abrir la ventana correspondiente a las propiedades del proyecto.
En dicha ventana, abriremos la lista desplegable Objeto inicial, y seleccionaremos el nombre del nuevo formulario.
Ver Figura 221.
Public
Inherits
Class
frmManual
System.Windows.Forms.Form
Public
Sub
Me.Name
Me.Text
Me.StartPosition
Me.ClientSize
New()
=
=
"formulario
=
=
"frmManual"
creado
desde
cdigo"
FormStartPosition.CenterScreen
New
End
End
System.Drawing.Size(300,
50)
Sub
Class
Como puede comprobar el lector, lo que hacemos en esta clase es heredar de Form, y mediante un mtodo
constructor, asignamos valores a las propiedades del formulario que ser creado cuando se instancie un objeto de
nuestra clase frmManual.
Antes de poder ejecutar este proyecto, debemos, al igual que en el ejemplo anterior, abrir la ventana de
propiedades de proyecto, y establecer como objeto inicial esta clase. Nuestro formulario en ejecucin tendr el aspecto
mostrado en la Figura 222.
La posibilidad de manipular el formulario mediante cdigo de esta manera, abre la puerta a un elevado nmero
de posibilidades, que hasta la fecha, estaban vetadas a los programadores de VB. De esta forma, podemos construir la
base principal del formulario con el diseador, y dinmicamente, en ejecucin, modificar sus propiedades, aadir y
quitar controles, etc.
Figura 223. Configurar un proyecto Windows para comenzar por un procedimiento Main( ).
Despus aadimos un mdulo al proyecto, empleando la opcin de men Proyecto + Agregar mdulo, de
VS.NET, y en dicho mdulo codificamos un procedimiento Main( ), que se encargue de instanciar un objeto del
formulario. Si escribimos algo parecido a lo que muestra el Cdigo fuente 436, el programa, en efecto, se iniciar,
crear el formulario, pero inmediatamente lo cerrar.
Module
Entrada
Public
'
Sub
instanciar
Dim
frmVentana.Show()
End
Cdigo fuente 436.
objeto
frmVentana
frmVentana.Text
End
un
Sub
Module
de
Main()
la
As
"probando
clase
del
New
desde
formulario
Form1()
cdigo"
El cdigo anterior, aunque vlido, tiene un problema: un formulario, al tratarse de una ventana Windows,
necesita lo que se denomina un bucle de mensajes, que le permita detectar los mensajes que le enva el sistema
operativo, y actuar en consecuencia.
En .NET, para conseguir que un formulario disponga de un bucle de mensajes, debemos utilizar la clase
Application, entre cuyos miembros compartidos, se encuentra el mtodo Run( ). Cuando a dicho mtodo, le pasemos
un objeto formulario como parmetro, crear un bucle de mensajes para dicho formulario y lo mantendr en ejecucin
hasta que el usuario de la aplicacin lo cierre.
Modificando pues, el cdigo anterior, por el mostrado en el Cdigo fuente 437, conseguiremos que el
formulario permanezca en ejecucin una vez creado. Como detalle adicional, y a efectos meramente estticos,
asignamos un color de fondo a la ventana, de modo que el lector compruebe lo sencillo que resulta mediante el uso de
la propiedad BackColor, y la estructura Color.
Module
Entrada
Public
'
Sub
instanciar
Dim
un
objeto
'
de
frmVentana
frmVentana.Text
'
Main
asignamos
utilizando
color
de
End
End
Color
de
los
de
el
para
para
del
formulario
New
"probando
el
uno
'
utilizamos
'
mtodo
Run()
'
mensajes
'
ponerlo
Application.Run(frmVentana)
clase
As
'
estructura
frmVentana.BackColor
la
()
Form1()
desde
fondo
miembros
la
cdigo"
al
de
plataforma
Color.Aquamarine
objeto
Application
y
su
crear
un
bucle
de
el
formulario
y
en
ejecucin
Sub
Module
formulario
la
El Cuadro de herramientas
Una vez creado un proyecto, o despus de aadir un nuevo formulario, para utilizar controles en el mismo,
tendremos que tomarlos de la ventana Cuadro de herramientas disponible en el IDE de VS.NET, y aadirlos al
formulario. Ver Figura 225.
Un control, al igual que un formulario, dispone a su alrededor de un conjunto de guas de redimensin, de modo
que si despus de situarlo en el formulario, queremos modificar su tamao, slo tenemos que hacer clic sobre alguna
de estas guas, y arrastrar modificando las dimensiones del control.
Adems de utilizando el ratn, podemos desplazar un control, manteniendo pulsada la tecla [CONTROL], y
pulsando adems, algunas de las teclas de direccin.
El otro modo consiste en asignar en el formulario, a la propiedad SnapToGrid, el valor False; esto deshabilita el
ajuste a la cuadrcula automtico de los controles, con lo que perdemos en precisin de ajuste, pero ganamos en
libertad de ubicacin para el control. Si no queremos que la cuadrcula se visualice, asignaremos False a la propiedad
DrawGrid del formulario.
Los anteriores ajustes los podemos realizar tambin de modo genrico para todos los formularios.
Seleccionaremos para ello, la opcin de men del IDE Herramientas + Opciones, y en la ventana Opciones, haremos
clic sobre el elemento Diseador de Windows Forms. En el panel derecho de esta ventana, podremos configurar estas
propiedades de modo general para todo el IDE. Ver Figura 228.
Figura 228. Ajuste general de las propiedades para la cuadrcula de diseo de formularios.
Cuando tenemos un grupo numeroso de controles en el formulario, que necesitamos mover de posicin, o
cambiar su tamao, para redistribuir el espacio; podemos optar por cambiar uno a uno los controles, tarea pesada y
nada aconsejable; o bien, podemos seleccionar todos los controles a modificar, y realizar esta tarea en un nico paso,
mediante las opciones del men Formato del IDE.
Supongamos que en el formulario tenemos dos controles Button y un ListBox distribuidos como muestra la
Figura 229.
En primer lugar, para seleccionarlos todos, debemos hacer clic sobre el formulario y arrastrar, de modo que el
rectngulo de seleccin que aparece, abarque a los controles, que quedarn con sus correspondientes marcas de
redimensin visibles, seal de que estn seleccionados.
En este punto, podemos hacer clic en uno de los controles y desplazarlos todos conjuntamente por el formulario,
o bien, hacer clic en una de las guas de redimensin y cambiar su tamao, lo que afectar a todos los controles
seleccionados. Si necesitamos de alguna accin especial, utilizaremos las opciones del men Formato del IDE.
Por ejemplo, podemos ejecutar la opcin Formato + Alinear + Lados izquierdos, de modo que todos los
controles se alinearn por la izquierda, tomando como referencia el control que tiene las marcas de redimensin
negras. Ver Figura 230.
Despus ejecutaremos la opcin de men Formato + Igualar tamao + Ambos, que ajustar tanto el ancho
como el alto de todos los controles seleccionados. Ver Figura 231.
Para evitar que, una vez completado el diseo y ajuste de todos lo controles, accidentalmente podamos
modificar alguno, seleccionaremos la opcin de men Formato + Bloquear controles, que bloquear los controles
seleccionados, impidiendo que puedan ser movidos o modificado su tamao. Para desbloquear los controles del
formulario, debemos seleccionar al menos uno y volver a utilizar esta opcin de men, que desbloquear todos los
controles.
Una caracterstica interesante del bloqueo de controles, consiste en que una vez que tengamos bloqueados los
controles del formulario, si aadimos un nuevo control, este no estar inicialmente bloqueado, lo que facilita su
diseo. Una vez que hayamos finalizado de disear el ltimo control, lo seleccionaremos en el formulario y
seleccionaremos la opcin de bloqueo de controles, de modo que ya estarn bloqueados todos de nuevo.
El men Formato de VS.NET consta de un numeroso conjunto de opciones. Acabamos de ver una muestra de
sus posibilidades, por lo que recomendamos al lector, que realice pruebas con el resto de opciones, para ver todas las
posibilidades en cuanto a la disposicin de los controles dentro del formulario.
Anclaje de controles
La propiedad Anchor, existente en un gran nmero de controles, nos permite anclar dicho control a uno o varios
bordes del formulario.
Cuando un control es anclado a un borde, la distancia entre el control y dicho borde ser siempre la misma,
aunque redimensionemos el formulario.
Para establecer esta propiedad, debemos pasar a la ventana de propiedades del control, y en Anchor, pulsar el
botn que dispone, y que nos mostrar una representacin de los bordes para anclar. Ver Figura 232.
Las zonas de color gris oscuro representan los bordes del control que ya estn anclados a los bordes del
formulario. Debemos marcar y desmarcar respectivamente estos elementos segn los bordes que necesitemos anclar.
Por defecto, los controles se encuentran inicialmente anclados a los bordes superior e izquierdo (Top, Left), como
hemos comprobado en la anterior figura.
La Figura 233 muestra un ejemplo en el que vemos dos controles que tienen distintos tipos de anclaje. Button1
tiene el anclaje normal: Top-Left, mientras que Button2 tiene slo Right, por ello, su borde derecho siempre
mantendr la misma distancia con ese borde del formulario.
Acople de controles
A travs de la propiedad Dock de los controles, podremos acoplar un control a uno de los bordes de un
formulario, consiguiendo que dicho control permanezca pegado a ese borde del formulario en todo momento.
Para seleccionar el tipo de acople, haremos clic en el botn que tiene la propiedad Dock en la ventana de
propiedades, y que nos mostrar un gua de los tipos de acople disponibles. Ver Figura 234.
Por defecto, los controles no se encuentran acoplados al insertarse en el formulario, y slo es posible establecer
un tipo de acople en cada ocasin. La Figura 235 muestra un control Button acoplado a la izquierda del formulario.
Si pulsamos en la propiedad Dock el botn central de los indicadores de acoplamiento, la propiedad tomar el
valor Fill, es decir, el control llenar la superficie del formulario. Veamos en la Figura 236, el mismo control con este
valor de acople.
Controles
Windows
Controles ms habituales
Como habr comprobado el lector, el nmero de controles del cuadro de herramientas es muy numeroso, por lo
que en los prximos apartados, vamos a trabajar con los que se consideran controles bsicos o estndar, dada su gran
frecuencia de uso.
La Tabla 30 relaciona este conjunto de controles bsico, junto a una breve descripcin.
Control
Descripcin
Button
Botn
pulsacin
Label
Etiqueta
literal
TextBox
Cuadro
texto
ListBox
Lista
valores
Lista
valores
ComboBox
desplegable,
cuadro
de texto
CheckBox
Casilla
verificacin
de
de
de
de
de
y
de
Button
Este control representa un botn de pulsacin, conocido en versiones anteriores de VB como CommandButton.
Entre el nutrido conjunto de propiedades de este control, destacaremos las siguientes.
.
Text. Cadena con el ttulo del botn.
.
TextAlign. Alineacin o disposicin del ttulo dentro del rea del botn; por defecto aparece centrado.
.
BackColor. Color de fondo para el botn.
.
Cursor. Permite modificar el cursor del ratn que por defecto tiene el botn.
.
Image. Imagen que podemos mostrar en el botn como complemento a su ttulo, o bien, en el caso de
que no asignemos un texto al botn, nos permitir describir su funcionalidad.
.
ImageAlign. Al igual que para el texto, esta propiedad nos permite situar la imagen en una zona del
botn distinta de la central, que es en la que se ubica por defecto.
.
BackgroundImage. Imagen de fondo para el botn.
.
FlatStyle. Tipo de resaltado para el botn. Por defecto, el botn aparece con un cierto relieve, que al
ser pulsado, proporciona el efecto de hundirse y recuperar nuevamente su estado, pero podemos, mediante esta
propiedad, hacer que el botn se muestre en modo plano, con un ligero remarcado al pulsarse, etc.
.
Font. Cambia el tipo de letra y todas las caractersticas del tipo elegido, para el texto del botn.
La Figura 237 muestra un ejemplo de control Button, sobre el que se han modificado algunos valores por
defecto de sus propiedades.
Private Sub
System.EventArgs)
btnMensaje_Click(ByVal sender
Handles
MessageBox.Show("Se
End
acaba
de
As
pulsar
System.Object, ByVal e As
btnMensaje.Click
el
botn
del
formulario")
Sub
Figura 238. Resultado de la ejecucin del evento Click de un control Button, al ser pulsado.
Como ya sabemos, el enlace procedimiento-evento de objeto mediante la palabra Handles, se produce de modo
esttico. Esto requiere que en el cdigo, el identificador que contenga el objeto del control, deba ser declarado con
mbito a nivel de clase, y utilizando adems la palabra clave WithEvents. Dicha tarea es realizada automticamente
por el diseador del formulario cuando genera el cdigo del mismo. Veamos en el Cdigo fuente 439, el fragmento de
cdigo generado por el diseador que realiza esta labor.
'
esta
declaracin
es
situada
a
nivel
del
cdigo
'
de
la
clase
del
formulario,
es
decir,
'
fuera
de
cualquier
mtodo
Friend
WithEvents
btnMensaje
As
System.Windows.Forms.Button
A continuacin, abriremos la otra lista desplegable del editor de cdigo: Nombre de mtodo, situada en la parte
superior derecha del editor. En ella aparecern los nombres de todos los eventos de que dispone el control.
Localizaremos el evento MouseEnter, y lo seleccionaremos. Ver Figura 240.
De igual modo que sucedi con el evento Click en el apartado anterior, el editor de cdigo crear el
procedimiento manipulador de evento vaco, para el evento que acabamos de seleccionar. Lo que vamos a hacer a
continuacin, es escribir el cdigo que permita cambiar el color del botn cuando el ratn entre al mismo. Veamos el
Cdigo fuente 440.
Private Sub
System.EventArgs)
btnMensaje_MouseEnter(ByVal
Handles
Me.btnMensaje.BackColor
End
sender
As
Object, ByVal e As
btnMensaje.MouseEnter
Color.Cyan
Sub
Cuando al ejecutar, situemos el ratn en el botn, este cambiar su color, mostrando el aspecto de la Figura 241.
sender
As
Object,
ByVal
As
System.EventArgs)
Handles
Me.btnMensaje.ResetBackColor()
End
Sub
A partir de ahora, cuando ejecutemos el programa, al quitar el ratn de la superficie del botn, el control volver
a tomar su color original.
"Coordenadas
sender As
Handles
ratn:
Object, ByVal e As
MyBase.MouseMove
X:"
&
e.X
&
"
Y:"
End
e.Y
Sub
If
MessageBox.Show("Cerrar
la
ventana?",
"Atencin",
MessageBoxButtons.YesNo,
MessageBoxIcon.Hand)
=
DialogResult.No
e.Cancel
&
_
_
Then
True
End
If
End
Sub
El evento MouseMove se produce al mover el ratn por el formulario, mientras que Closing se produce cuando
el formulario est en proceso de cierre. Este ltimo evento tiene la caracterstica de que nos permite cancelar el
proceso de cierre del formulario, mediante la manipulacin del parmetro que contiene los argumentos de evento, en
concreto se trata de los argumentos de cancelacin. La Figura 242 muestra este evento en ejecucin.
Label
El control Label o Etiqueta, muestra un texto informativo al usuario. Podemos utilizar este control como
complemento a otro control, por ejemplo, situndolo junto a un TextBox, de modo que indiquemos al usuario el tipo
de dato que esperamos que introduzca en la caja de texto.
Se trata de un control esttico; esto quiere decir que el usuario no puede interaccionar con l, a diferencia, por
ejemplo, de un control Button, sobre el que s podemos actuar pulsndolo; o de un TextBox, en el que podemos
escribir texto.
Una de sus propiedades es BorderStyle, que permite definir un borde o recuadro alrededor del control,
o que dicho borde tenga un efecto 3D; por defecto se muestra sin borde. Veamos unos ejemplos en la Figura
243.
Foco de entrada
Para que las pulsaciones de teclado puedan ser recibidas por un determinado control, dicho control debe tener lo
que se denomina el foco de entrada.
El modo de dar a un control el foco de entrada, consiste en hacer clic sobre l, o bien, pulsar la tecla [TAB],
pasando el foco hasta el control deseado. Cuando un control recibe el foco, el sistema operativo lo remarca
visualmente o en el caso de controles de escritura, muestra el cursor de escritura en su interior.
TextBox
Un control TextBox muestra un recuadro en el que podemos introducir texto. Para poder escribir texto en un
control de este tipo, debemos darle primeramente el foco, lo que detectaremos cuando el control muestre el cursor de
escritura en su interior.
Entre las propiedades disponibles por este control, destacaremos las siguientes.
.
Text. Cadena con el texto del control.
.
Multiline. Permite establecer si podemos escribir una o varias lneas. Por defecto contiene False, por
lo que slo podemos escribir el texto en una lnea.
.
WordWrap. En controles multilnea, cuando su valor es True, al llegar al final del control cuando
estamos escribiendo, realiza un desplazamiento automtico del cursor de escritura a la siguiente lnea de texto.
.
Enabled. Contiene un valor lgico mediante el que indicamos si el control est o no habilitado para
poder escribir texto sobre l.
.
ReadOnly. Permite indicar si el contenido del control ser de slo lectura o bien, podremos editarlo.
.
CharacterCasing. Esta propiedad, permite que el control convierta automticamente el texto a
maysculas o minsculas segn lo estamos escribiendo.
.
MaxLength. Valor numrico que establece el nmero mximo de caracteres que podremos escribir en
el control.
.
PasswordChar. Carcter de tipo mscara, que ser visualizado por cada carcter que escriba el
usuario en el control. De esta forma, podemos dar a un cuadro de texto el estilo de un campo de introduccin de
contrasea.
.
AutoSize. Cuando esta propiedad tenga el valor True, al modificar el tamao del tipo de letra del
control, dicho control se redimensionar automticamente, ajustando su tamao al del tipo de letra establecido.
La Figura 244 muestra un formulario con varios controles TextBox, a los cuales se han aplicado diferentes
efectos mediante sus propiedades.
Al comenzar a ejecutar el programa, observaremos que el foco de entrada no est situado en el primer TextBox
del formulario. Para asignar por cdigo el foco a un determinado control, disponemos del mtodo Focus( ). En este
caso, al pulsar el botn Foco nombre, desviamos el foco al primer TextBox del formulario. Ver Cdigo fuente 443.
Private Sub
System.EventArgs)
btnFoco_Click(ByVal
sender
Handles
As
System.Object,
ByVal e As
btnFoco.Click
Me.txtNombre.Focus()
End
Sub
Observe el lector, que en el botn Foco nombre, que acabamos de mencionar, la letra F se encuentra subrayada,
actuando de acelerador o hotkey. De este modo, no es necesario pulsar con el ratn sobre ese botn para ejecutarlo,
basta con pulsar la tecla [CONTROL] junto a la letra subrayada para conseguir el mismo efecto.
Para definir una tecla aceleradora en un control, debemos anteponer el carcter & a la letra que vamos a definir
como acelerador, en este ejemplo se ha logrado con &Foco nombre.
Por otro lado, mediante el botn btnSoloLectura conseguimos activar/desactivar la propiedad ReadOnly del
TextBox txtNombre, cambiando el estado de dicha propiedad en cada pulsacin del botn. Ver Cdigo fuente 444.
Private Sub
System.EventArgs)
btnSoloLectura_Click(ByVal sender
Handles
If
Me.txtNombre.ReadOnly
Else
Me.txtNombre.ReadOnly
End
As
(Me.txtNombre.ReadOnly)
=
=
System.Object, ByVal e As
btnSoloLectura.Click
Then
False
True
If
End
Sub
Sin embargo, hay otro modo mucho ms eficiente de cambiar el estado de una propiedad que contiene un tipo
Boolean: utilizando el operador Not.
Con el botn btnActivar, cambiamos el valor de la propiedad Enabled del cuadro de texto que contiene los
apellidos. Para ello, aplicamos el operador Not a dicha propiedad, y el resultado lo asignamos a esa misma propiedad.
Ver Cdigo fuente 445.
Private Sub
System.EventArgs)
'
btnActivar_Click(ByVal sender
Handles
utilizando
Me.txtApellidos.Enabled
As
System.Object, ByVal e As
btnActivar.Click
operador
=
End
Not
Not
simplificamos
(Me.txtApellidos.Enabled)
Sub
Finalizando con este ejemplo, y aunque no tiene relacin directa con el control TextBox, el formulario se
muestra con un tipo de borde especial que no permite su redimensin. La propiedad del formulario con la que
podemos establecer el tipo de borde es FormBorderStyle, y en este caso, su valor es Fixed3D. Alterando los valores de
esta propiedad, conseguiremos distintos bordes y tipos de redimensin para el formulario.
Si por el contrario, no queremos dar el foco a un control pulsando [TAB], debemos asignar a la propiedad
TabStop de dicho control el valor False. Por defecto, TabStop vale True, permitiendo de esta el paso de foco entre
controles mediante la tecla [TAB].
El control de este formulario, que vamos a emplear para las operaciones de seleccin es txtOrigen. En primer
lugar, y aunque no se trata de una seleccin de texto, veremos su evento TextChanged, el cual se produce cada vez que
cambia el contenido del cuadro de texto; lo usaremos por tanto, para contar la cantidad de caracteres escritos y
mostrarlos en un Label. Ver Cdigo fuente 446.
'
al
cambiar
el
texto
'
este
Private
Sub
txtOrigen_TextChanged(ByVal
System.EventArgs)
Handles
'
calculamos
la
del
control
sender
As
longitud
Me.lblContador.Text
se
produce
evento
Object,
ByVal
e
As
txtOrigen.TextChanged
del
texto
escrito
Me.txtOrigen.TextLength
End
Sub
Los eventos MouseMove y KeyDown del TextBox, se producen respectivamente, cuando movemos el ratn
sobre el control, o cada vez que pulsamos una tecla para escribir texto. Detectaremos en este
caso, si existen teclas o botones especiales presionados, que nos indiquen que se est realizando una seleccin
de texto, y mostraremos en el formulario el texto seleccionado, el nmero de caracteres y la posicin del carcter de
inicio de la seleccin. Veamos los procedimientos manipuladores de estos eventos en el Cdigo fuente 447.
'
al
mover
el
ratn
por
el
TextBox
se
produce
'
este
evento
Private
Sub
txtOrigen_MouseMove(ByVal
sender
As
Object,
ByVal
e
As
System.Windows.Forms.MouseEventArgs)
Handles
txtOrigen.MouseMove
'
comprobamos
si
al
mover
el
ratn
'
est
'
'
'
'
If
pulsado
su
botn
en
caso
afirmativo
es
que
seleccionando
texto,
por
lo
que
la
informacin
de
seleccin
propiedades
de
seleccin
del
e.Button.Left
Me.lblTextoSelec.Text
Me.lblLongitud.Text
Me.lblPosicion.Text
izquierdo
se
con
est
obtenemos
las
TextBox
Then
Me.txtOrigen.SelectedText
Me.txtOrigen.SelectionLength
Me.txtOrigen.SelectionStart
=
=
End
If
End
Sub
'
este
evento
se
'
una
tecla
Private
Sub
txtOrigen_KeyDown(ByVal
System.Windows.Forms.KeyEventArgs)
'
comprobamos
'
'
'
'
'
'
If
si
y
obtener
de
las
teclas
pulsada
la
tecla
est
pulsando
derecha,
quiere
decir
est
seleccionando
la
informacin
de
las
seleccin
del
control
e.Shift
pulsadas
est
adems
flecha
produce
cuando
se
pulsa
en
el
TextBox
sender
As
Object,
ByVal
e
As
Handles
txtOrigen.KeyDown
If
Me.lblTextoSelec.Text
Me.lblLongitud.Text
Me.lblPosicion.Text
se
e.KeyCode.Right
=
=
=
la
que
maysculas,
tecla
se
texto;
propiedades
TextBox
Then
Then
Me.txtOrigen.SelectedText
Me.txtOrigen.SelectionLength
Me.txtOrigen.SelectionStart
End
If
If
End
Sub
End
Finalmente, tras introducir un valor en los controles txtPosicion y txtLongitud, pulsaremos el botn
btnSeleccionar. Con ello conseguiremos realizar una seleccin de texto en el TextBox txtOrigen, y pasar el texto
seleccionado al control txtDestino. El efecto ser el mismo que si lo hubiera realizado el usuario, pero en este caso sin
su intervencin. Veamos en el Cdigo fuente 448, el evento Click del botn btnSeleccionar.
'
'
del
Private
Sub
System.EventArgs)
btnSeleccionar_Click(ByVal
sender
Handles
Me.txtOrigen.SelectionStart
As
System.Object,
ByVal
e
As
btnSeleccionar.Click
Me.txtPosicion.Text
Me.txtOrigen.SelectionLength
Me.txtDestino.Text
=
=
Me.txtLongitud.Text
Me.txtOrigen.SelectedText
End
Sub
CheckBox
Este control muestra una casilla de verificacin, que podemos marcar para establecer un estado.
Generalmente el estado de un CheckBox es marcado (verdadero) o desmarcado (falso), sin embargo, podemos
configurar el control para que sea detectado un tercer estado, que se denomina indeterminado, en el cual, el control se
muestra con la marca en la casilla pero en un color de tono gris.
Las propiedades remarcables de este control son las siguientes.
.
Checked. Valor lgico que devuelve True cuando la casilla est marcada, y False cuando est
desmarcada.
.
CheckState. Valor del tipo enumerado CheckState, que indica el estado del control. Checked,
marcado; Unchecked, desmarcado; e Indeterminate, indeterminado.
.
ThreeState. Por defecto, un control de este tipo slo tiene dos estados, pero asignando True a esta
propiedad, conseguimos que sea un control de tres estados.
.
CheckAlign. Permite establecer de modo visual la ubicacin de la casilla de verificacin dentro del
rea del control.
Como detalle destacable de las propiedades Checked y CheckState, si modificamos desde cdigo sus valores,
conseguiremos alterar el estado de la casilla del control.
El ejemplo CheckBoxPru, muestra un formulario con dos controles CheckBox. El control chkPonColor asigna
un color de fondo al formulario o restablece el color original. Esto lo conseguimos codificando el evento
CheckedChanged del control. Ver Cdigo fuente 449.
'
este
evento
se
produce
'
en
el
CheckBox
y
cambia
el
Private
Sub
chkPonColor_CheckedChanged(ByVal
sender
System.EventArgs)
Handles
If
Me.chkPonColor.CheckState
Me.BackColor
=
Else
Me.ResetBackColor()
End
End
cuando
se
hace
clic
contenido
de
la
casilla
As
System.Object,
ByVal
e
As
chkPonColor.CheckedChanged
CheckState.Checked
Then
Color.LightBlue
If
Sub
Por su parte, el control chkMostrar, definido con tres estados, muestra, al estar marcado, una cadena en un
control Label; elimina la cadena al desmarcarlo; y muestra la mitad al entrar en el estado indeterminado. El evento
CheckStateChanged es el que debemos de utilizar para detectar el estado del CheckBox en cada ocasin. Para
mantener el valor de la cadena a mostrar, utilizamos una variable a nivel de la clase que inicializamos en el constructor
del formulario. Ver Cdigo fuente 450.
Public
Inherits
Class
Form1
System.Windows.Forms.Form
Private
Public
'....
'
inicializar
'
a
sCadenaOriginal
Me.lblMuestra.Text
End
sCadenaOriginal
As
String
Sub
la
mostrar
=
variable
en
"Estamos
New()
que
el
contiene
label
visualizando
la
y
una
cadena
asignarla
cadena"
sCadenaOriginal
Sub
'....
'
este
evento
se
produce
'
de
Private
Sub
chkMostrar_CheckStateChanged(ByVal
System.EventArgs)
Handles
Select
Case
Me.lblMuestra.Text
Case
Me.lblMuestra.Text
cuando
la
sender
Case
cambia
el
estado
casilla
As
Object,
ByVal
e
As
chkMostrar.CheckStateChanged
Me.chkMostrar.CheckState
CheckState.Checked
sCadenaOriginal
CheckState.Unchecked
""
Case
Me.lblMuestra.Text
(sCadenaOriginal.Length
=
/
CheckState.Indeterminate
sCadenaOriginal.Substring(0,
2))
End
Select
End
Sub
RadioButton y GroupBox
Los controles RadioButton nos permiten definir conjuntos de opciones autoexcluyentes, de modo que situando
varios controles de este tipo en un formulario, slo podremos tener seleccionado uno en cada ocasin.
Vamos a crear un proyecto de ejemplo con el nombre RadioButtonPru, en el que situaremos dentro de un
formulario, una serie de controles RadioButton y un TextBox, de modo que mediante los RadioButton cambiaremos el
tipo de fuente y color del cuadro de texto. La Figura 249 muestra un diseo inicial del formulario.
Al ejecutar el proyecto, sin embargo, no podemos conseguir establecer simultneamente un tipo de letra y color,
puesto que al pulsar cualquiera de los botones de radio, se quita el que hubiera seleccionado previamente.
Para solucionar este problema, disponemos del control GroupBox, que nos permite, como indica su nombre,
agrupar controles en su interior, tanto RadioButton como de otro tipo, ya que se trata de un control contenedor.
Una vez dibujado un GroupBox sobre un formulario, podemos arrastrar y soltar sobre l, controles ya existentes
en el formulario, o crear nuevos controles dentro de dicho control. De esta forma, podremos ya, en este ejemplo,
seleccionar ms de un RadioButton del formulario, como vemos en la Figura 250.
El evento CheckedChanged, al igual que ocurra con los controles CheckBox, ser el que tendremos que escribir
para ejecutar el cdigo en respuesta a la pulsacin sobre un control RadioButton. El Cdigo fuente 451 muestra los
eventos correspondientes a los controles de radio de este ejemplo. Para cambiar el tipo de fuente, instanciamos un
objeto Font y lo asignamos a la propiedad Font del TextBox; mientras que para cambiar el color, utilizamos la
estructura Color y la propiedad BackColor, tambin del TextBox.
End
New
sender
Sub
System.Object,
ByVal
e
As
rbtGaramond.CheckedChanged
As
Font("Garamond",
As
System.Object,
Handles
Me.txtNombre.Font
=
New
End
Private
Sub
rbtVerde_CheckedChanged(ByVal
System.EventArgs)
Me.txtNombre.BackColor
sender
Handles
=
rbtComic.CheckedChanged
Font("Comic
sender
ByVal
8)
Sub
e
As
As
Sans
System.Object,
MS",
ByVal
15)
Sub
e
As
rbtVerde.CheckedChanged
Color.Green
Sub
Private Sub
System.EventArgs)
rbtAzul_CheckedChanged(ByVal
Handles
sender
As
Me.txtNombre.BackColor
System.Object, ByVal e As
rbtAzul.CheckedChanged
Color.Blue
End
Private Sub
System.EventArgs)
Sub
rbtAmarillo_CheckedChanged(ByVal
Handles
sender
Me.txtNombre.BackColor
As
System.Object, ByVal e As
rbtAmarillo.CheckedChanged
Color.Yellow
End
Sub
ListBox
Un control ListBox contiene una lista de valores, de los cuales, el usuario puede seleccionar uno o varios
simultneamente. Entre las principales propiedades de este control, podemos resaltar las siguientes.
Items. Contiene la lista de valores que visualiza el control. Se trata de un tipo ListBox.ObjectCollection, de
manera que el contenido de la lista puede ser tanto tipos carcter, como numricos y objetos de distintas clases. Al
seleccionar esta propiedad en la ventana de propiedades del control, y pulsar el botn que contiene, podemos
introducir en una ventana elementos para el control. Ver Figura 251.
El control quedara por lo tanto con valores asignados en la etapa de diseo, como muestra la Figura 252.
.
Sorted. Cuando esta propiedad contiene el valor True, ordena el contenido de la lista. Cuando
contiene False, los elementos que hubiera previamente ordenados, permanecen con dicho orden, mientras que los
nuevos no sern ordenados.
.
IntegralHeight. Los valores de la lista son mostrados al completo cuando esta propiedad contiene
True. Sin embargo, al asignar el valor False, segn el tamao del control, puede que el ltimo valor de la lista se
visualiza slo en parte. La Figura 253 muestra un ListBox con esta propiedad a False.
Figura 253. ListBox mostrando parte del ltimo elemento debido a la propiedad IntegralHeight.
.
MultiColumn. Visualiza el contenido de la lista en una o varias columnas en funcin de si asignamos
False o True respectivamente a esta propiedad.
.
SelectionMode. Establece el modo en el que vamos a poder seleccionar los elementos de la lista. Si
esta propiedad contiene None, no se realizar seleccin; One, permite seleccionar los valores uno a uno; MultiSimple
permite seleccionar mltiples valores de la lista pero debemos seleccionarlos independientemente; por ltimo,
MultiExtended nos posibilita la seleccin mltiple, con la ventaja de que podemos hacer clic en un valor, y arrastrar,
seleccionando en la misma operacin varios elementos de la lista.
.
SelectedItem. Devuelve el elemento de la lista actualmente seleccionado.
.
Selecteditems. Devuelve una coleccin ListBox.SelectedObjectCollection, que contiene los elementos
de la lista que han sido seleccionados.
.
SelectedIndex. Informa del elemento de la lista seleccionado, a travs del ndice de la coleccin que
contiene los elementos del ListBox.
Para mostrar algunas de las funcionalidades de este control, utilizaremos el proyecto de ejemplo ListBoxPru. La
Figura 254 muestra esta aplicacin en ejecucin.
El ejemplo, como puede comprobar el lector, consiste en un formulario que contiene un ListBox principal, con
el nombre lstValores, que dispone de una serie de valores asignados en tiempo de diseo.
Cada vez que hacemos clic en alguno de los valores, se produce el evento SelectedIndexChanged, que
utilizamos para mostrar en este caso, el nombre del elemento en el ttulo del formulario, como muestra el Cdigo
fuente 452, de la clase frmListas, correspondiente al formulario.
'
'
Private
As
'
'
Me.Text
este
Sub
evento
se
produce
cada
vez
ndice
seleccionado
lstValores_SelectedIndexChanged(ByVal
sender
System.EventArgs)
Handles
mostrar
actualmente
=
en
el
ttulo
seleccionado
TITULO
que
se
cambia
el
del
ListBox
As
System.Object,
ByVal
e
lstValores.SelectedIndexChanged
del
formulario
de
&
el
valor
la
lista
Me.lstValores.SelectedItem
End
Sub
A travs de los RadioButton, cambiamos el tipo de seleccin que podemos efectuar en el control lstValores. Ver
Cdigo fuente 453.
Private Sub
System.EventArgs)
rbtUno_CheckedChanged(ByVal
Handles
sender
As
System.Object, ByVal e As
rbtUno.CheckedChanged
'
establecer
tipo
Me.lstValores.SelectionMode
de
seleccin
en
=
el
ListBox
un
elemento
SelectionMode.One
End
Sub
Private Sub
System.EventArgs)
'
rbtMultiple_CheckedChanged(ByVal
Handles
establecer
tipo
de
sender
seleccin
en
As
System.Object, ByVal e As
rbtMultiple.CheckedChanged
el
ListBox
un
'
mltiples
elementos
Me.lstValores.SelectionMode
SelectionMode.MultiSimple
End
Sub
Private Sub
System.EventArgs)
'
rbtExtendida_CheckedChanged(ByVal
Handles
establecer
'
tipo
de
seleccin
elementos
sender
As
en
System.Object, ByVal e As
rbtExtendida.CheckedChanged
el
de
Me.lstValores.SelectionMode
ListBox
modo
mltiples
extendido
SelectionMode.MultiExtended
End
Sub
Private Sub
System.EventArgs)
'
'
chkOrdenar_CheckedChanged(ByVal
Handles
segn
el
la
valor
del
opcin
sender
System.Object, ByVal e As
chkOrdenar.CheckedChanged
CheckBox,
de
Me.lstValores.Sorted
As
ordenamos
ordenar
o
del
quitamos
ListBox
Me.chkOrdenar.Checked
End
Sub
Private Sub
System.EventArgs)
'
'
chkColumnas_CheckedChanged(ByVal
Handles
segn
el
en
valor
varias
del
sender
CheckBox,
columnas
As
System.Object, ByVal e As
chkColumnas.CheckedChanged
mostramos
o
el
en
ListBox
una
Me.lstValores.MultiColumn
Me.chkColumnas.Checked
End
Sub
El TextBox de este formulario lo usaremos para aadir nuevos elementos al ListBox lstValores, y buscar
tambin elementos existentes, pulsando los botones btnAgregar y btnBuscar en cada caso. Observemos el miembro
NoMatches del ListBox, mediante el que averiguamos si la bsqueda tuvo xito. Ver el Cdigo fuente 455.
Private Sub
System.EventArgs)
btnAgregar_Click(ByVal sender
Handles
'
aadimos
el
'
un
elemento
Me.lstValores.Items.Add(Me.txtValor.Text)
As
System.Object, ByVal e As
btnAgregar.Click
contenido
del
TextBox
la
como
lista
End
Sub
Private Sub
System.EventArgs)
btnBuscar_Click(ByVal sender
Handles
Dim
'
As
System.Object, ByVal e As
btnBuscar.Click
iPosicion
el
mtodo
As
FindString()
iPosicion
de
'
el
campo
NoMatches
If
iPosicion
MessageBox.Show("No
la
Integer
lista
busca
un
valor
Me.lstValores.FindString(Me.txtValor.Text)
indica
=
existe
si
no
existe
el
valor
Me.lstValores.NoMatches
el
buscado
Then
valor")
Else
'
si
'
encontramos
lo
Me.lstValores.SelectedIndex
el
valor
seleccionamos
en
por
la
lista,
cdigo
iPosicion
End
If
End
Sub
La seleccin de los elementos de un ListBox no es competencia exclusiva del usuario. El programador puede
tambin, si lo necesita, seleccionar valores de la lista mediante el cdigo del programa. Al pulsar el botn
btnSelecCod, utilizaremos el mtodo SetSelected( ) del ListBox para realizar esta tarea. En este mtodo pasamos como
parmetro el ndice de la lista con el que vamos a operar, y el valor True para seleccionarlo, o False para quitarle la
Private Sub
System.EventArgs)
'
para
'
btnSelecCod_Click(ByVal sender
Handles
seleccionar
podemos
As
elementos
System.Object, ByVal e As
btnSelecCod.Click
de
utilizar
un
el
ListBox
por
mtodo
Me.rbtMultiple.Checked
cdigo
SetSelected()
True
Me.lstValores.SetSelected(1,
True)
Me.lstValores.SetSelected(3,
True)
Me.lstValores.SetSelected(5,
True)
End
Sub
El botn btnTraspasarSelec lo usaremos para tomar los elementos seleccionados de lstValores, y pasarlos al otro
ListBox del formulario. La propiedad SelectedItems del control lstValores, devuelve una coleccin con sus elementos
seleccionados. Por otra parte, podemos eliminar los elementos de un ListBox llamando al mtodo Clear( ) de la
coleccin de valores del control, cosa que hacemos pulsando el botn btnLimpiar. Ver Cdigo fuente 457.
Private Sub
System.EventArgs)
btnTrapasarSelec_Click(ByVal
Handles
Dim
oSeleccion
'
obtenemos
'
con
los
Dim
oEnumerador
System.Object, ByVal e As
btnTrapasarSelec.Click
ListBox.SelectedObjectCollection
SelectedItems
los
de
'
As
As
oSeleccion
'
If
sender
elementos
un
=
ListBox
Me.lstValores.SelectedItems
si
existen
traspasamos
a
oSeleccion.Count
elementos
ListBox
otro
>
oEnumerador
del
0
As
=
seleccionados,
formulario
Then
IEnumerator
oSeleccion.GetEnumerator()
While
oEnumerador.MoveNext()
Me.lstTraspaso.Items.Add(oEnumerador.Current)
End
End
End
Private Sub
System.EventArgs)
seleccionados
While
If
Sub
btnLimpiar_Click(ByVal sender
Handles
As
System.Object, ByVal e As
btnLimpiar.Click
'
con
el
'
de
un
mtodo
Clear()
ListBox,
de
borramos
la
los
coleccin
elementos
de
elementos
del
controls
Me.lstTraspaso.Items.Clear()
End
Sub
ComboBox
El ComboBox es un control basado en la combinacin (de ah su nombre) de dos controles que ya hemos
tratado: TextBox y ListBox.
Un control ComboBox dispone de una zona de edicin de texto y una lista de valores, que podemos desplegar
desde el cuadro de edicin.
El estilo de visualizacin por defecto de este control, muestra el cuadro de texto y la lista oculta, aunque
mediante la propiedad DropDownStyle podemos cambiar dicho estilo. La Figura 255 muestra un formulario con
diversos ComboBox, cada uno con diferente estilo.
La propiedad DropDownStyle tambin influye en una diferencia importante de comportamiento entre el estilo
DropDownList y los dems, dado que cuando creamos un ComboBox con el mencionado estilo, el cuadro de texto
slo podr mostrar informacin, no permitiendo que esta sea modificada.
En el caso de que la lista desplegable sea muy grande, mediante la propiedad MaxDropDownItems, asignaremos
el nmero de elementos mximo que mostrar la lista del control.
El resto de propiedades y mtodos son comunes con los controles TextBox y ListBox. En el Cdigo fuente 458
se muestra el cdigo del botn btnAgregar, mediante el que llenamos de valores los controles de este ejemplo.
Private Sub
System.EventArgs)
btnAgregar_Click(ByVal sender
Handles
As
System.Object, ByVal e As
btnAgregar.Click
Me.cboColores.Items.AddRange(New
"BLANCO",
String()
{"AZUL",
"MARRN",
Me.cboNombres.Items.AddRange(New
"LUIS",
String()
"ANGEL",
Me.cboCiudades.Items.AddRange(New
"TOLEDO",
String()
"VERDE",
{"ELENA",
"JOSE",
{"SEVILLA",
"AMARILLO",
"ROJO",
"GRANATE"})
"ANA",
"VALENCIA",
"ALFREDO",
"RAQUEL"})
"ALICANTE",
"SEGOVIA"})
End
Sub
Codificacin
herencia visual
avanzada
de
controles
Index del control, el nmero correspondiente a la posicin de dicho control dentro del array. Como restriccin, el array
deba estar compuesto por controles del mismo tipo.
Una caracterstica de los arrays de controles era que el cdigo de los eventos era compartido entre todos los
controles. El procedimiento de evento correspondiente, reciba un nmero que identificaba el control del array que
haba provocado dicho evento. De esta forma, podamos tener cdigo comn para ejecutar sobre cualquiera de los
controles del array, y cdigo particular, slo para ciertos controles.
El Cdigo fuente 459 muestra el evento Click de un array de controles CommandButton en VB6.
'
'
Private
'
'
cdigo
Sub
cmdPulsar_Click(Index
utilizamos
control
Select
una
Case
Case
'
As
para comprobar qu
el
evento
Index
0
cdigo
'
'
'....
VB6
==========
Integer)
pulsemos
que
control
del
el
se
de
ejecutar
la
posicin
Case
'
cdigo
'
cuando
0
array
que
pulsemos
el
'
se
control
ejecutar
de
la
cuando
posicin
del
1
array
'....
'....
End
Select
'
cdigo
general
que
se
ejecutar
sobre
cualquier
control
del
array
'....
'....
End
Sub
Los arrays de controles no estn soportados por VB.NET, ya que existe un medio mucho ms potente y flexible
de escribir cdigo comn para un conjunto de controles: la creacin de manejadores de evento comunes.
En versiones anteriores de VB, el nombre del procedimiento que manipulaba un determinado evento de un
control era algo riguroso que no poda ser cambiado.
Pero como hemos visto anteriormente, VB.NET supera esta limitacin, permitindonos dar el nombre que
queramos a un procedimiento manipulador del evento de un control, y asociando dicho procedimiento al evento
mediante la palabra clave Handles.
Handles encierra una potencia mayor de la que en un principio pudiera parecer, ya que si disponemos de un
formulario con varios controles, y escribimos un procedimiento manipulador de evento, podemos asociar dicho
procedimiento a los eventos de ms de un control del formulario al mismo tiempo, basta con escribir a continuacin de
Handles, los nombres de objeto-evento separados por comas. El resultado ser que cada vez que se produzca en esos
controles el evento en cuestin, se llamar al mismo procedimiento de evento; y dentro de ese cdigo, deberemos
discernir cul control origin el evento.
Para demostrar cmo enfocar desde VB.NET, el escenario descrito al comienzo de este apartado, que estaba
escrito en VB6, crearemos un proyecto con el nombre CompartirEventos (hacer clic aqu para acceder a este ejemplo),
y en su formulario, insertaremos tres Button. Ver Figura 256.
El trabajo a desempear consiste en que al pulsar cualquiera de los botones, la cadena de caracteres de su
propiedad Text sea convertida a mayscula.
Podramos hacer doble clic en cada uno de estos controles y realizar dicha operacin. Sin embargo, en esta
ocasin, escribiremos un nico procedimiento manipulador para el evento Click de estos controles, ya que como la
accin a realizar es idntica para todos los controles, ahorraremos una importante cantidad de tiempo y cdigo. Ver el
Cdigo fuente 460.
Figura 256. Formulario con controles que tendrn un manipulador de evento comn.
Private Sub
btnUno.Click,
Pulsar(ByVal
sender As Object,
btnDos.Click,
ByVal
As
EventArgs) Handles
btnTres.Click
'
antes
de
convertir
a
maysculas,
debemos
realizar
'
un
moldeado
de
tipo
con
CType()
del
parmetro
que
contiene
'
el
objeto
que
provoc
el
evento
CType(sender,
Button).Text
=
CType(sender,
Button).Text.ToUpper()
End
Sub
Complicando un poco ms la situacin, puede ocurrir que para este evento, tengamos que realizar tareas
comunes y otras particulares para cada control; por ejemplo, poner a cada botn un color de fondo diferente. Pues no
existe problema en ese sentido, ya que el parmetro sender del manipulador de evento, nos va a informar de cul de los
controles ha sido pulsado. El Cdigo fuente 461 muestra, en ese sentido, una ampliacin del cdigo del evento.
Private
Sub
Pulsar(ByVal
sender
As
Object,
ByVal
As
EventArgs)
Handles
btnUno.Click,
btnDos.Click,
btnTres.Click
'
antes
de
convertir
a
maysculas,
debemos
realizar
'
un
moldeado
de
tipo
con
CType()
del
parmetro
que
contiene
'
el
objeto
que
provoc
el
evento
CType(sender,
Button).Text
=
CType(sender,
Button).Text.ToUpper()
'
comprobar
cul
botn
ha
sido
pulsado,
'
y
en
funcin
de
esto,
dar
un
color
'
distinto
a
cada
control
If
sender
Is
Me.btnUno
Then
Me.btnUno.BackColor
End
If
sender
=
Is
Me.btnDos.BackColor
End
If
sender
Me.btnTres.BackColor
Me.btnDos
Color.BurlyWood
If
Then
Me.btnTres
Color.Cornsilk
If
Then
=
Is
=
End
End
Color.HotPink
If
Sub
No slo es posible escribir un manipulador de evento para varios controles del mismo tipo, sino que tambin
podemos establecer esta asociacin entre controles de distinto tipo, naturalmente, siempre y cuando todos esos
controles dispongan de dicho evento comn.
En el siguiente ejemplo, EventoVariosCtl (hacer clic aqu para acceder a este ejemplo), creamos un formulario
con tres controles de diferente tipo. Seguidamente escribimos en el cdigo de la clase del formulario, un mtodo con el
nombre ControlPulsado( ), que asociamos con Handles, al evento Click de cada uno de estos controles, tal y como
muestra el Cdigo fuente 462.
Public
Inherits
'....
'....
Class
Form1
System.Windows.Forms.Form
'
este
procedimiento
'
click
de
distintos
'
mediante
la
Private
Sub
ControlPulsado(ByVal
'
Handles
comprobar
btnPulsar.Click,
sobre
cul
'
si
es
If
sender
Me.lblNombre.BorderStyle
End
'
If
Me.Close()
End
si
es
sender
'
si
es
If
sender
Me.txtNombre.BackColor
End
End
el
=
de
tipos
evento
lo
de
control
palabra
sender
As
Object,
txtNombre.Click,
control
se
ha
asignamos
en
clave
ByVal
e
al
el
As
evento
formulario
Handles
EventArgs)
lblNombre.Click
hecho
click
Label,
cambiar
estilo
borde
Is
Me.lblNombre
Then
System.Windows.Forms.BorderStyle.Fixed3D
If
el
Button,
cerrar
el
Me.btnPulsar
Is
formulario
Then
If
el
TextBox,
Is
=
cambiar
su
color
Me.txtNombre
Then
Color.LightSeaGreen
If
Sub
End
Class
Figura 258. Controles diferentes utilizando el mismo manipulador para el evento Click.
En cualquier caso, si el programador necesita arrays de controles en sus programas, puede utilizar cualquiera de
los tipos de la plataforma para esta finalidad, desde un array simple, hasta alguno de los diferentes tipos de coleccin
que nos proporciona el entorno de ejecucin de .NET Framework.
Al igual que hemos visto la posibilidad de crear un formulario slo con cdigo, sin utilizar su diseador, es
tambin posible la creacin de los controles que componen el formulario, as como la definicin de los manipuladores
de evento, tanto para controles como para formulario.
Como ejemplo, crearemos un proyecto con el nombre ControlCodigo (hacer clic aqu para acceder al ejemplo),
y en l escribiremos el cdigo para crear, tanto el interfaz de usuario como los eventos que necesitemos detectar, para
formulario y controles.
Public
Inherits
Class
frmDatos
Windows.Forms.Form
Private
Private
Private
Private
Private
Private
WithEvents
lblContador
btnMostrar
btnCerrar
rbtFecha
rbtHora
Public
MyBase.New()
'
Me.txtInfo
Me.txtInfo.Location
Me.txtInfo.Name
Me.txtInfo.Size
Me.txtInfo.TabIndex
Me.txtInfo.Text
'
Me.lblContador
Me.lblContador.Location
Me.lblContador.Name
Me.lblContador.Size
Me.lblContador.TabIndex
'
Me.btnMostrar
Me.btnMostrar.Location
Me.btnMostrar.Name
Me.btnMostrar.Size
Me.btnMostrar.TabIndex
Me.btnMostrar.Text
txtInfo
As
As
As
As
As
As
Sub
=
=
New()
New
New
=
New
Point(20,
Size(132,
=
=
=
=
=
New
New
=
New
Point(175,
Size(55,
=
Button:
=
=
=
New
New
=
New
Point(20,
Size(103,
=
TextBox
Label
Button
Button
RadioButton
RadioButton
TextBox
TextBox()
24)
"txtInfo"
20)
0
""
Label
Label()
28)
"lblContador"
16)
1
Mostrar
Button()
66)
"btnMostrar"
23)
2
"&Mostrar"
'
Me.btnCerrar
Me.btnCerrar.Location
Me.btnCerrar.Name
Me.btnCerrar.Size
Me.btnCerrar.TabIndex
Me.btnCerrar.Text
Button:
=
=
Size(103,
RadioButton:
=
=
Fecha
RadioButton()
66)
"rbtFecha"
23)
4
"&Fecha"
New
New
=
New
Point(160,
Size(100,
=
RadioButton:
=
=
Hora
RadioButton()
95)
"rbtHora"
23)
5
"&Hora"
New
New
=
New
Point(160,
Size(100,
=
'
Me.Controls.AddRange(New
End
Point(20,
=
'
Me.rbtHora
Me.rbtHora.Location
Me.rbtHora.Name
Me.rbtHora.Size
Me.rbtHora.TabIndex
Me.rbtHora.Text
End
New
=
New
'
Me.rbtFecha
Me.rbtFecha.Location
Me.rbtFecha.Name
Me.rbtFecha.Size
Me.rbtFecha.TabIndex
Me.rbtFecha.Text
Me.btnMostrar,
Me.ClientSize
Me.Name
Me.Text
=
Me.FormBorderStyle
Cerrar
Button()
100)
"btnCerrar"
23)
3
"&Cerrar"
New
Control()
Me.btnCerrar,
New
=
"Creacin
de
=
Form
Me.lblContador,
{Me.txtInfo,
Me.rbtFecha,
Size(292,
controles
Me.rbtHora})
140)
"frmDatos"
desde
cdigo"
FormBorderStyle.Fixed3D
Sub
Class
A continuacin, aadimos una nueva clase al proyecto con el nombre Inicio, que utilizaremos para iniciar la
aplicacin. Al tratarse de una clase, necesitamos escribir un mtodo Main( ) compartido, que instancie un objeto
formulario, como muestra el Cdigo fuente 464.
Public
Public
Application.Run(New
End
End
Class
Shared
Sub
Inicio
Main()
frmDatos())
Sub
Class
La Figura 259 muestra en ejecucin nuestro formulario y controles creados exclusivamente con cdigo.
'
'
Private
Handles
'
'
'
Me.Text
este
manipulador
de
evento
se
produce
cuando
se
mueve
el
ratn
por
el
formulario
Sub PosicionRaton(ByVal sender As Object, ByVal e As MouseEventArgs)
MyBase.MouseMove
mostramos
las
coordenadas
utilizando
el
parmetro
con
adicionales
del
=
"Coordenadas
ratn:
X:"
&
e.X
&
del
los
"
Y:"
ratn
argumentos
evento
&
e.Y
End
Sub
'
este
manipulador
de
evento
'
el
contenido
Private Sub TextoCambiado(ByVal sender As
txtInfo.TextChanged
se
produce
de
Object, ByVal
cada
vez
que
este
e As EventArgs)
cambie
TextBox
Handles
'
mostramos
Me.lblContador.Text
la
longitud
de
caracteres
=
en
el
Label
del
formulario
Me.txtInfo.Text.Length
End
Sub
Public
'....
Public
Class
frmDatos
Sub
'....
'
Me.btnCerrar
'....
'
asociar
'
AddHandler
'....
New()
Button:
=
el
de
Cerrar
Button()
New
botn
evento
btnCerrar.Click,
Cerrar
un
procedimiento
AddHandler
CerrarVentana
con
AddressOf
End
'
'
Private
Sub
este
manipulador
se
pulse
Sub
CerrarVentana(ByVal
de
sender
evento
el
As
Object,
se
botn
ByVal
producir
e
As
cuando
btnCerrar
EventArgs)
Me.Close()
End
'....
Sub
End
Class
Public
'....
Public
Class
Sub
'....
'
Me.rbtFecha
'....
'
asociar
'
AddHandler
'
Me.rbtHora
'....
'
asociar
'
AddHandler
'....
End
'....
'....
'
este
'
se
Private
Sub
New()
RadioButton:
=
RadioButton
evento
Me.rbtFecha.Click,
un
procedimiento
AddHandler
PulsaFecha
con
AddressOf
RadioButton:
=
Hora
RadioButton()
New
este
de
RadioButton
evento
Me.rbtHora.Click,
un
procedimiento
AddHandler
PulsaHora
con
AddressOf
Sub
manipulador
pulse
PulsaFecha(ByVal
de
sender
de
un
nuevo
manipulador
btnMostrar.Click,
evento
pulse
sender
se
producir
RadioButton
ByVal
e
As
para
el
AddressOf
evento
el
As
sender
este
manipulador
de
cuando
se
Sub
MuestraFecha(ByVal
Dim
dtFecha
MessageBox.Show("Fecha
evento
el
As
Object,
un
nuevo
manipulador
btnMostrar.Click,
este
manipulador
se
pulse
Sub
PulsaHora(ByVal
'
asociamos
AddHandler
End
'
'
Private
Fecha
RadioButton()
New
este
de
'
asociamos
AddHandler
End
'
'
Private
frmDatos
se
As
Object,
para
el
AddressOf
asociar
el
Object,
&
botn
cuando
rbtHora
EventArgs)
btnMostrar
MuestraHora
Sub
al
control
RadioButton
ByVal
e
As
As
=
"
btnMostrar
MuestraFecha
Sub
se
producir
RadioButton
ByVal
e
As
dtFecha
actual:
botn
cuando
rbtFecha
EventArgs)
btnMostrar
rbtFecha
EventArgs)
Date
DateTime.Today
dtFecha.ToString("D"))
End
'
'
Private
Sub
este
manipulador
de
cuando
se
Sub
MuestraHora(ByVal
Dim
dtFecha
MessageBox.Show("Hora
evento
pulse
sender
se
As
asociar
al
control
el
RadioButton
Object,
ByVal
e
As
dtFecha
As
Date
DateTime.Now
dtFecha.ToString("T"))
=
actual:
"
btnMostrar
rbtHora
EventArgs)
&
End
Sub
End
Class
Sin embargo, este modo de asignacin del procedimiento manipulador, al evento Click del botn btnMostrar,
tiene la siguiente pega: cada vez que pulsamos uno de los RadioButton, el manipulador del evento Click antiguo no se
elimina, sino que se va apilando a los ya existentes.
Como consecuencia, cuando hayamos pulsado repetidas veces los controles de radio del formulario, se
ejecutarn tambin repetidamente los manipuladores del evento Click de btnMostrar.
El motivo de este comportamiento se debe a que el delegado en el que est basado el evento, contiene lo que se
denomina una lista de invocacin, y cada vez que usamos AddHandler, se aade el nombre del procedimiento de
evento a dicha lista. Si no quitamos de la lista de manipuladores de evento la referencia a un procedimiento, cada vez
que se produzca el evento se ejecutarn todos los procedimientos de su lista de invocacin. Para quitar un
procedimiento de la lista de un evento, emplearemos la instruccin RemoveHandler.
Para que todo funcione ya correctamente, cuando pulsemos los RadioButton, en el cdigo de los eventos de
estos controles haremos un pequeo aadido, consistente en quitar al botn btnMostrar, el manipulador de evento que
tena hasta ese momento. Vemoslo en el Cdigo fuente 469.
'
'
Private
este
manipulador
se
pulse
Sub PulsaFecha(ByVal
'
quitamos
RemoveHandler
'
...y
AddHandler
el
de
evento
se
producir
cuando
el
RadioButton
rbtFecha
sender As Object, ByVal e As EventArgs)
manipulador
btnMostrar.Click,
asociamos
un
nuevo
btnMostrar.Click,
que
manipulador
hubiera
AddressOf
para
AddressOf
para
el
botn
End
'
'
Private
btnMostrar...
MuestraHora
btnMostrar
MuestraFecha
Sub
este
manipulador
de
evento
se
producir
cuando
se
pulse
el
RadioButton
rbtHora
Sub PulsaHora(ByVal sender As Object, ByVal e As EventArgs)
'
quitamos
RemoveHandler
el
manipulador
btnMostrar.Click,
que
hubiera
AddressOf
para
btnMostrar...
MuestraFecha
'
...y
AddHandler
asociamos
un
nuevo
btnMostrar.Click,
manipulador
para
AddressOf
el
botn
End
btnMostrar
MuestraHora
Sub
Al ejecutar ahora, cuando pulsemos el control btnMostrar, slo se ejecutar un nico procedimiento
manipulador de su evento Click. Esto nos proporciona de nuevo una idea de la potencia que encierra el lenguaje en
esta versin de VB.
Al pulsar el botn Recorrer de este formulario, ejecutaremos el Cdigo fuente 470, en el que podemos ver cmo
recorrer su coleccin de controles, realizando cambios en alguno de ellos.
Private Sub
System.EventArgs)
btnRecorrer_Click(ByVal sender
Handles
Dim
'
obtener
'
oListaControles
oListaControles
una
controles
As
System.Object, ByVal e As
btnRecorrer.Click
As
coleccin
del
=
con
ControlCollection
los
formulario
Me.Controls
Dim
'
For
oUnControl
la
oUnControl
recorrer
Each
MessageBox.Show("El
If
'
'
Me.txtDatos.Text
control
oUnControl
actuar
control;
=
As
coleccin
de
Control
controles
oListaControles
&
oUnControl.Name)
In
actual
es:
Is
directamente
"
Me.txtDatos
sobre
aadir
EL
"PROBANDO
End
If
'
'
'
'
Then
el
texto
CONTROL"
If
oUnControl
hacer
un
variable
que
coleccin,
control
adecuado;
CType(oUnControl,
String()
"LUIS",
End
Next
Is
moldeado
usamos
conviertiendo
aadir
Me.cboNombres
tipo
de
para
recorrer
al
tipo
elementos
a
la
de
Then
la
la
de
lista
ComboBox).Items.AddRange(New
{"JUAN",
"MARTA",
"ANA"})
If
End
Sub
Temporizadores
En VB.NET disponemos al igual que en anteriores versiones, del control Timer, que nos permite la ejecucin de
cdigo a intervalos de tiempo predeterminados.
Este control ha sufrido una importante reestructuracin, ya que internamente hace uso de la clase Timer,
perteneciente al conjunto de clases del sistema. El hecho de poder acceder a esta clase, nos proporciona una gran
flexibilidad en nuestros desarrollos, ya que, a partir de ahora tambin crearemos temporizadores por cdigo, sin
necesidad de utilizar el control Timer.
En el ejemplo TimerPru que comentamos a continuacin, vamos a construir un formulario en el que
utilizaremos ambos tipos de temporizadores, el propio control Timer y un objeto de la clase (hacer clic aqu para
acceder a este ejemplo).
El primer proceso a codificar, consistir en traspasar a intervalos de tiempo, el contenido de un TextBox del
formulario, a otro control de este mismo tipo. El formulario del proyecto se muestra en la Figura 261.
Tras incluir los controles de usuario en el formulario, aadiremos un control Timer, al que daremos el nombre
tmrTemporizador. Esta accin abrir, bajo el diseador del formulario, un panel para controles especiales, como es el
caso de Timer, en el que se mostrar dicho control. Ver Figura 262.
En este panel se depositan los controles del formulario que no tienen una interaccin directa con el usuario, o
cuyo diseo es diferente al de los controles habituales.
Para especificar el espacio de tiempo en el que este control ser ejecutado cuando lo activemos, utilizaremos la
propiedad Interval, a la que tenemos que asignar un valor numrico, que establece dicho tiempo en milisegundos. En
nuestro caso, asignaremos 500, con lo que el control se ejecutar cada medio segundo.
El control Timer lo activaremos llamando a su mtodo Start( ), cosa que hacemos al pulsar el botn
btnTraspasar. Ver Cdigo fuente 471.
Private Sub
System.EventArgs)
'
btnTraspasar_Click(ByVal sender
Handles
iniciar
As
System.Object, ByVal e As
btnTraspasar.Click
el
temporizador
Me.tmrTemporizador.Start()
End
Sub
Una vez activado un temporizador, cada vez que transcurre el tiempo indicado en Interval, genera un evento
Tick. Es precisamente en este evento en el que debemos escribir el cdigo que necesitamos que se ejecute a intervalos
regulares de tiempo. Haremos, por consiguiente, doble clic en el control Timer del diseador, para acceder al
procedimiento manipulador de este evento, cuyo contenido lo podemos ver en el Cdigo fuente 472.
'
este
evento
se
produce
'
en
el
Private
Sub
tmrTemporizador_Tick(ByVal
System.EventArgs)
Handles
'
quitamos
Dim
sLetra
Me.txtOrigen.Text
'
...y
Me.txtDestino.Text
'
una
sLetra
en
sender
letra
=
=
lo
el
TextBox
de
As
Me.txtOrigen.Text.Substring(0,
Me.txtOrigen.Text.Remove(0,
pasamos
cuando
'
If
intervalo
especificado
control
Timer
As
Object,
ByVal
e
As
tmrTemporizador.Tick
se
haya
detener
Me.txtOrigen.Text.Length
del
al
&=
TextBox
traspaso
el
=
origen...
String
1)
1)
de
todo
destino
sLetra
el
0
texto
temporizador
Then
Me.tmrTemporizador.Stop()
MessageBox.Show("Traspaso
finalizado")
If
End
End
Sub
En cuanto a los temporizadores por cdigo, vamos a crear un proceso en el que intercambiaremos los colores de
fondo de los TextBox del formulario cada segundo.
En primer lugar, vamos a declarar una variable de tipo Timer en la clase del formulario, y otra variable Boolean.
Ver Cdigo fuente 473.
Public
Inherits
'
Private
Class
Form1
System.Windows.Forms.Form
temporizador
oTiempo
por
As
cdigo
Timer
'
'
Private
'....
'....
esta
los
variable
la
colores
de
bIntercambio
utilizaremos
fondo
para
de
As
intercambiar
TextBox
Boolean
los
End
Class
Al marcar el CheckBox del formulario, instanciaremos un objeto Timer. Asignaremos valores a sus
propiedades, lo asociaremos a un procedimiento que manipule su evento Tick, y lo pondremos en marcha con Start( ).
Como puede ver el lector, los mtodos y propiedades son los mismos que para el control Timer. En el Cdigo fuente
474 vemos el cdigo del CheckBox y del manipulador del evento Tick.
Private Sub
System.EventArgs)
'
chkActivar_CheckedChanged(ByVal
Handles
cuando
sender
As
System.Object, ByVal e As
chkActivar.CheckedChanged
marquemos
el
CheckBox...
If
Me.chkActivar.Checked
'
creamos
el
oTiempo
=
New
oTiempo.Interval
=
1000
'
se
ejecutar
'
le
asignamos
un
manipulador
para
el
AddHandler
oTiempo.Tick,
AddressOf
oTiempo.Start()
'
arrancamos
el
Else
'
cuando
oTiempo.Stop()
oTiempo
desmarquemos
el
CheckBox
Then
temporizador
Timer()
cada
segundo
evento
Tick
CambioDeColor
temporizador
paramos
el
temporizador
Nothing
End
If
End
Sub
'
'
Private
mtodo
Sub
'
'
manipulador
creado
CambioDeColor(ByVal
segn
cada
el
vez
'
intercambiarn
bIntercambio
If
Me.txtOrigen.BackColor
Me.txtDestino.BackColor
Else
Me.txtOrigen.BackColor
Me.txtDestino.BackColor
End
del
evento
sender
As
estado
que
los
=
Tick
del
por
Object, ByVal e
de
se
colores
la
ejecute
de
bIntercambio
=
=
=
=
variable
este
fondo
Not
temporizador
cdigo
As EventArgs)
de
bIntercambio
mtodo,
se
los
TextBox
bIntercambio
Then
Color.Aquamarine
Color.LightSteelBlue
Color.LightSteelBlue
Color.Aquamarine
If
End
Sub
Al ejecutar el ejemplo, podemos poner en marcha ambos temporizadores, comprobando as, como son
ejecutados simultneamente sin interferencia.
Public
Inherits
'
'
'
Public
Class
cuando
TextNumeros
TextBox
declaramos
se
un
asigne
evento
un
no
AsignacionNoNum(ByVal
Event
para
poder
valor
al
control
sea
As
system.Object,
ByVal
sender
generarlo
que
numrico
e
As
EventArgs)
Public
'
en
Me.BackColor
Sub
el
constructor
dar
=
un
New()
al
control
Color.PaleGreen
color
End
Sub
'
'
Public
implementamos
de
la
Overloads
Overrides
nuestra
propia
propiedad
Text()
Property
As
versin
Text
String
Get
Return
End
Set(ByVal
Value
'
'
End
eludimos
de
texto
al
control
As
la
en
MyBase.Text
Get
String)
el
asignacin
bloque
Set
del
por
Property
Set
cdigo
End
Property
'
'
Private
en
cuando
Sub
este
procedimiento
el
contenido
TextNumeros_TextChanged(ByVal
System.EventArgs)
'
...si
de
evento
detectamos
que
del
control
cambie...
sender
As
Object,
ByVal
e
As
Handles
el
'
If
valor
lanzar
actual
del
control
el
IsNumeric(Me.Text)
Not
RaiseEvent
MyBase.TextChanged
AsignacionNoNum(Me,
no
es
New
EventArgs())
If
End
End
End
numrico,
evento
Then
Sub
Class
A continuacin pasaremos al formulario del proyecto, y en el cdigo del mismo, declararemos a nivel de clase
una variable del tipo correspondiente a nuestro control. Seguidamente, insertaremos un control Button para crear en
tiempo de ejecucin una instancia de nuestro control y mostrarlo en el formulario; al crear nuestro control,
conectaremos con AddHandler, su evento AsignacionNoNum con un procedimiento del formulario que acte como
manipulador.
Finalmente, y para demostrar cmo no podemos asignar por cdigo, valores a la propiedad Text del control,
aadiremos otro botn adicional. Veamos todo ello en el Cdigo fuente 476.
Public
Inherits
Private
'....
'....
Private
Sub
Class
Form1
System.Windows.Forms.Form
txtNum
btnCrear_Click(ByVal
System.EventArgs)
'
creamos
un
objeto
Me.txtNum
=
Me.txtNum.Location
=
Me.txtNum.Name
Me.txtNum.Size
=
Me.txtNum.TabIndex
'
asociamos
'
con
un
'
AddHandler
sender
As
TextNumeros
System.Object,
ByVal
As
Handles
btnCrear.Click
de
nuestra
clase
control
New
TextNumeros()
New
Point(60,
50)
=
"txtNum"
New
Size(100,
40)
=
1
evento
que
procedimiento
en
txtNum.AsignacionNoNum,
'
aadimos
'
de
Me.Controls.Add(Me.txtNum)
End
As
el
el
hemos
manejador
control
controles
creado
de
en
el
evento
control
escrito
clase
ValorIncorrecto
esta
AddressOf
la
del
coleccin
formulario
Sub
'
procedimiento
manipulador
del
evento
AsignacionNoNum
de
'
control;
aqu
mostramos
un
mensaje
informativo
'
escribamos
un
valor
que
no
sea
Private
Sub
ValorIncorrecto(ByVal
sender
As
System.Object,
ByVal
nuestro
cuando
numrico
e
As
System.EventArgs)
MessageBox.Show("En
"Atencin")
este
control
slo
se
deben
introducir
End
Sub
'
al
pulsar
este
botn
'
propiedad
Text
de
nuestro
'
programado
en
el
control,
Private
Sub
btnAsignar_Click(ByVal
intentamos
asignar
una
cadena
en
la
control,
pero
debido
al
comportamiento
no
podremos
realizar
esta
asignacin
sender
As
System.Object,
ByVal
e
As
System.EventArgs)
Me.txtNum.Text
End
End
nmeros",
Handles
btnAsignar.Click
"PRUEBA"
Sub
Class
El formulario en ejecucin, con nuestro control propio ya creado, lo muestra la Figura 263.
Herencia visual
Adems de la herencia habitual por cdigo que hemos utilizado en los ejemplos de escritura de clases, los
formularios Windows disponen de los mecanismos necesarios para crear un formulario base, a partir del cual,
posteriormente podremos heredar en formularios derivados; todo ello de modo visual.
Vamos a desarrollar por lo tanto un ejemplo, en el que mostraremos los pasos necesarios a dar, tanto en la
creacin del formulario base como del heredado (hacer clic aqu, para obtener la solucin de proyectos HerenciaVisual
con el ejemplo).
La situacin planteada en este ejemplo es la siguiente: necesitamos crear un formulario para identificar y validar
a un usuario antes de permitirle el acceso a una aplicacin. Como norma general, los datos mnimos que todo usuario
debe teclear son su nombre (login) y contrasea (password); pero en algunos casos, dependiendo del programa a
escribir, esta ventana de identificacin puede requerir la introduccin de datos adicionales, como un cdigo adicional,
una fecha, etc.
Dado que a priori, desconocemos los datos adicionales que podrn ser necesarios para este formulario,
crearemos el formulario base incluyendo la introduccin del login, password, y un botn para validar dichos datos, y
posteriormente, en otro proyecto, heredaremos este formulario en uno derivado, al que aadiremos nuevos controles.
El formulario base
Comencemos por tanto, abriendo Visual Studio .NET, y creando un nuevo proyecto VB.NET, de tipo Windows,
al que daremos el nombre HerenciaVisual.
A continuacin, abriremos la ventana del explorador de soluciones, seleccionaremos el formulario por defecto
de este proyecto y lo eliminaremos pulsando la tecla [SUPR].
Siguiendo en el explorador de soluciones, en esta ocasin haremos clic sobre el nombre del proyecto, y
pulsaremos el botn de propiedades de esta ventana. En la ventana de propiedades, abriremos la lista desplegable Tipo
de resultado, y seleccionaremos la opcin Biblioteca de clases. Para poder utilizar un formulario como clase base de
otro formulario, el proyecto que contiene el formulario base debe ser de tipo librera, para que al compilarlo, genere un
fichero .DLL con dicho formato de biblioteca. Ver Figura 264.
El siguiente paso consiste en aadir a este proyecto, el formulario que va a actuar como base. Para ello,
seleccionaremos del IDE, la opcin de men Proyecto + Agregar formulario de Windows, y daremos el nombre
frmValidar al nuevo formulario.
En el formulario frmValidar, insertaremos los controles necesarios para introducir los datos de login de usuario,
su password, y un botn de validacin de dichos datos. La Figura 265 muestra el aspecto de este formulario una vez
concluido su diseo.
Respecto al cdigo de este formulario, escribiremos el correspondiente a la pulsacin del Button que contiene.
Ver Cdigo fuente 477.
Private
Handles
'
Sub
si
btnValidar_Click(ByVal
el
nombre
'
If
End
As
usuario
Object,
es
ByVal
superior
As
System.EventArgs)
btnValidar.Click
permitir
Me.txtLogin.Text.Length
MessageBox.Show("Bienvenido
End
de
sender
caracteres
acceso
>
al
Then
sistema")
If
Sub
Para finalizar con el formulario base, seleccionaremos en el IDE la opcin de men Generar + Generar, que
crear la biblioteca de clases, es decir, el fichero HERENCIAVISUAL.DLL.
A partir de este punto, deberemos crear el proyecto que contenga un formulario que herede el formulario base
que acabamos de crear. Esto lo podemos conseguir de dos modos: agregando un nuevo proyecto a la solucin, o bien,
creando un nuevo proyecto aparte. En ambos casos, tendremos que establecer la oportuna referencia, bien hacia el
proyecto del formulario base en el primer caso, o hacia el archivo que contiene la librera de clases. Veamos ambos
modos.
Figura 266. Solucin con proyecto de formulario base y proyecto de formulario derivado.
El siguiente paso ser eliminar el formulario que contiene el proyecto FormuDerivado1, de igual modo que el
mostrado anteriormente.
Permaneciendo posicionados en el proyecto FormuDerivado1, seleccionaremos el men Proyecto + Agregar
formulario heredado, al que daremos el nombre frmAcceso. Ver Figura 267.
Al aceptar la ventana de creacin del formulario, el entorno de desarrollo buscar la biblioteca de clases con el
mbito ms prximo, y que disponga de formularios heredables, mostrando el resultado en la ventana Selector de
herencia. En nuestro caso, naturalmente, aparecer el formulario base frmValidar, contenido en la DLL que hemos
generado anteriormente. Ver Figura 268.
Figura 268. Seleccionar formulario base a partir del que se realizar la herencia.
Al pulsar Aceptar en esta ventana, ser creado el nuevo formulario, en base al formulario base especificado, y
establecida una referencia en el proyecto FormuDerivado1 hacia el proyecto base HerenciaVisual. Ver Figura 269.
Figura 269. Proyecto con formulario heredado y con referencia hacia proyecto base.
Al abrir el formulario frmAcceso en el diseador de formularios, se mostrar con los controles pertenecientes al
formulario base bloqueados; ello es debido a que tales controles pertenecen a la clase base del formulario, y slo
pueden ser manipulados desde el proyecto del formulario base. En este formulario derivado aadiremos algunos
controles ms, quedando con el aspecto que muestra la Figura 270.
En lo que respecta al cdigo de este formulario, slo podemos escribir los eventos de los nuevos controles, ya
que el cdigo de los controles heredados se encuentra protegido, siendo slo modificable desde el proyecto del
formulario base. El nico evento, por lo tanto que vamos a escribir aqu, ser el del botn btnCerrar, que llamar al
mtodo de cierre del formulario, como vemos en el Cdigo fuente 478. Observemos tambin la declaracin de clase, y
como se establece la herencia con el formulario base.
Public
Inherits
'....
Class
frmAcceso
HerenciaVisual.frmValidar
'....
Private Sub
System.EventArgs)
'
Me.Close()
btnCerrar_Click(ByVal sender
Handles
cerramos
As
System.Object,
ByVal e As
btnCerrar.Click
el
formulario
End
Sub
End
Class
Para poder ya finalmente, ejecutar este formulario derivado, debemos establecerlo como objeto inicial en las
propiedades de su proyecto, ya que al crear su proyecto estaba configurado para que arrancar por Form1.
Al pulsar Abrir, el selector de herencia nos avisa de que no puede localizar en el mbito de que dispone, un
ensamblado (biblioteca de clases en este caso) que contenga formularios de los que heredar. Ver Figura 272.
Tenemos por lo tanto, que pulsar el botn Examinar y buscar el archivo HERENCIAVISUAL.DLL, que
creamos en el ejemplo anterior y se encuentra en la ruta de dicho proyecto, en su directorio bin:
LetraUnidad:\HerenciaVisual\bin. Una vez localizado, aceptaremos esta ventana. Ver Figura 273.
Como podemos comprobar, hemos agregado un control Timer, un CheckBox y un Label. Cuando hagamos clic
sobre el CheckBox, se visualizar el Label mostrando la hora actual, que ser actualizada cada segundo en el evento
Tick del control Timer. Observe el lector los mtodos Show( ) y Hide( ), que nos permiten mostrar y ocultar
respectivamente un control. El Cdigo fuente 479 muestra el cdigo necesario para los eventos de estos controles.
Public
Inherits
'....
'....
'
al
hacer
clic
en
'
la
hora
segn
e
Private
As
Sub
Class
frmEntrada
HerenciaVisual.frmValidar
el
CheckBox,
el
valor
mostrar
u
de
la
chkMostrarHora_CheckedChanged(ByVal
System.EventArgs)
Handles
ocultar
casilla
sender
As
System.Object,
ByVal
chkMostrarHora.CheckedChanged
If
Me.lblHora.Show()
Me.tmrTemporizador.Start()
Me.chkMostrarHora.Checked
Then
Else
Me.lblHora.Hide()
Me.tmrTemporizador.Stop()
End
If
End
Sub
'
'
Private
cuando
el
temporizador
evento
mostrar
la
Sub
tmrTemporizador_Tick(ByVal
System.EventArgs)
Me.lblHora.Text
End
End
Cdigo fuente 479.
Mens
activo,
hora
sender
As
Handles
Sub
Class
est
al
en
Object,
lanzarse
el
ByVal
este
Label
As
tmrTemporizador.Tick
DateTime.Now.ToString("H:mm:ss")
La creacin de las diferentes opciones que compondrn el men es un proceso que se ha mejorado y
simplificado al mximo respecto a versiones anteriores de VB. El proceso de edicin del men se realiza directamente
en el formulario, en el mismo lugar en el que el men aparecer en tiempo de ejecucin.
Al hacer clic en la primera opcin del men, podemos dar nombre y propiedades a esa opcin. Al mismo
tiempo, de un modo muy intuitivo, veremos las prximas opciones disponibles, tanto las desplegables a partir de dicho
men, como las de la barra principal. Slo hemos de movernos en la direccin que necesitemos y dar nombre a las
opciones, y valores a sus propiedades. Ver Figura 276.
Cada una de las opciones que componen el men es a su vez un control MenuItem. Si durante su creacin slo
proporcionamos el nombre, el IDE va asignando a dicho control valores por defecto en sus propiedades.
Para modificar las propiedades de una opcin de men, slo hemos de seleccionarlo en la estructura de men
que estamos creando en el diseador del formulario, y pasar a la ventana de propiedades. Entre las propiedades
disponibles para un MenuItem, podemos destacar las siguientes.
. Text. Contiene una cadena con el literal o texto descriptivo de la opcin de men.
.
Enabled. Permite habilitar/deshabilitar la opcin de men. Cuando se encuentra deshabilitada, se
muestra su nombre en un tono gris, indicando que no puede ser seleccionada por el usuario.
.
DefaultItem. Permite establecer opciones por defecto. En una opcin de men por defecto, su texto se
resalta en negrita.
.
Checked. Marca/desmarca la opcin. Cuando una opcin est marcada, muestra junto a su nombre un
pequeo smbolo de verificacin o punteo.
.
RadioCheck. En el caso de que la opcin de men se encuentre marcada, si asignamos True a esta
propiedad, en lugar de mostrar el smbolo de verificacin estndar, se muestra uno con forma de punto.
.
ShortCut. Se trata de un atajo de teclado, o combinacin de teclas que nos van a permitir ejecutar la
opcin de men sin tener que desplegarlo. Al elegir esta propiedad, aparecer una lista con todos los atajos disponibles
para asignar.
.
ShowShortCut. Permite mostrar u ocultar la combinacin de teclas del atajo de teclado que tenga
asignado una opcin de men.
.
Visible. Muestra u oculta la opcin de men.
.
MdiList. Esta propiedad se utiliza habitualmente en opciones situadas en la barra de men, y permite
establecer que dicha opcin al desplegarse, muestre, adems de las opciones de men que le hayamos asignado, la lista
de ventanas secundarias MDI, en el caso de que el men principal est contenido en un formulario de tipo MDI. Los
formularios MDI sern tratados posteriormente.
Podemos adicionalmente, asignar una tecla de acceso rpido o hotkey a una opcin de men, anteponiendo el
carcter & a la letra que deseemos, de las que se encuentran en la propiedad Text del control MenuItem. Al igual que
sucede con los dems tipos de controles, en el texto de la opcin de men, aparecer subrayada la mencionada letra.
De este modo, cuando despleguemos un men, no ser necesario posicionarnos en una de ellas para ejecutarla, sino
que simplemente pulsando la tecla rpida, se ejecutar el cdigo de dicha opcin.
Tambin podemos establecer separadores entre las opciones de men simplemente creando una opcin y
asignando a su propiedad Text el carcter de guin ( - ).
En nuestro formulario de ejemplo, vamos pues a disear un men con la estructura del esquema mostrado en la
Figura 277.
Para todas las opciones se ha asignado una tecla de acceso rpido, y adicionalmente, para las opciones que se
indican a continuacin, se han modificado algunas propiedades por defecto.
.
.
.
.
.
Guardar. Deshabilitada.
Salir. Atajo de teclado en Ctrl. + S.
Copiar. Opcin por defecto.
Pegar. Marcada con smbolo normal.
Cortar. Marcada con smbolo de crculo.
Figura
La
Figura
277.
278
muestra
Esquema
el
formulario
del
en
ejecucin
men
con
una
de
parte
del
ejemplo.
men
abierta.
Una vez finalizada la fase de diseo del men, debemos proceder a escribir el cdigo para sus opciones. El
evento Click es el que permite a un control MenuItem ejecutar cdigo cuando la opcin de men es seleccionada.
Abriendo por tanto, el men desde el diseador del formulario, y haciendo doble clic en la opcin correspondiente, nos
situaremos en el editor de cdigo, dentro del procedimiento manipulador del evento Click para esa opcin. El Cdigo
fuente 480 muestra el cdigo que se ejecutar cuando seleccionemos las opciones de men Abrir y Salir de nuestro
ejemplo.
Private Sub
System.EventArgs)
mnuAbrir_Click(ByVal sender
Handles
MessageBox.Show("Opcin
As
Abrir
System.Object, ByVal e As
mnuAbrir.Click
del
End
Private Sub
System.EventArgs)
men")
Sub
mnuSalir_Click(ByVal sender
Handles
As
System.Object, ByVal e As
mnuSalir.Click
Me.Close()
End
Sub
Puesto que muchas de las propiedades de un control MenuItem son manipulables en tiempo de ejecucin,
aadiremos al formulario varios botones, mediante los cuales realizaremos operaciones sobre las opciones del men
tales como habilitar y deshabilitar, mostrar y ocultar, cambiar el nombre, etc. La Figura 279 muestra el formulario con
estos nuevos botones.
Figura 279. Controles Button para manipular por cdigo las propiedades de las opciones del men.
En el Cdigo fuente 481 podemos ver los manipuladores de evento de estos botones.
sender
Handles
System.Object, ByVal e As
btnHabilitar.Click
Me.mnuGuardar.Enabled
As
System.Object,
Not
sender
As
btnMostrar.Click
Me.mnuElipse.Visible
Sub
Not
As
Me.mnuAbrir.Text
System.Object, ByVal e As
btnNombre.Click
Me.mnuAbrir.Text
Sub
ByVal
e
As
btnMarcar.Click
Me.mnuPegar.Checked
Sub
System.Object,
ByVal
e
As
Handles
=
btnNombre_Click(ByVal sender
Handles
If
As
"A&brir"
=
Then
"HO&LA"
Else
Me.mnuAbrir.Text
"A&brir"
If
End
End
Private Sub
System.EventArgs)
Sub
btnDefecto_Click(ByVal sender
Handles
Me.mnuCopiar.DefaultItem
End
As
System.Object, ByVal e As
btnDefecto.Click
Not
Me.mnuCopiar.DefaultItem
Sub
men con un control o formulario, utilizaremos la propiedad ContextMenu de que disponen la mayora de los
controles Windows. En este ejemplo, insertaremos el control txtValor, de tipo TextBox, y le asociaremos el men de
contexto que acabamos de crear.
Como resultado, cuando ejecutemos la aplicacin, al hacer clic derecho sobre el TextBox, aparecer el men
contextual que hemos asignado, mediante el que cambiaremos el tipo de fuente de la caja de texto, transformaremos el
texto a maysculas y minsculas. El Cdigo fuente 482 muestra el cdigo de los eventos Click correspondiente a las
opciones del men contextual.
Private
Sub
System.EventArgs)
Dim
oFuente
As
Me.txtValor.Font
mnuFuente_Click(ByVal
sender
System.Object,
ByVal
As
Handles
mnuFuente.Click
New
Font("Comic",
15)
=
oFuente
End
Private
Sub
mnuMayusculas_Click(ByVal
sender
System.EventArgs)
Handles
Me.txtValor.Text
=
End
Private
Sub
mnuMinusculas_Click(ByVal
System.EventArgs)
Me.txtValor.Text
End
As
sender
As
As
Handles
=
Sub
System.Object,
ByVal
e
As
mnuMayusculas.Click
Me.txtValor.Text.ToUpper()
Sub
System.Object,
ByVal
e
As
mnuMinusculas.Click
Me.txtValor.Text.ToLower()
Sub
La Figura 281 muestra el aspecto del men contextual, cuando es utilizado desde el control TextBox.
'
al
'
declaramos
'
los
tipos
Public
comienzo
de
la
clase
las
variables
que
contendrn
MenuItem
creados
en
ejecucin
Class
Form1
Inherits
'
'
Private
Private
Private
'....
'....
los
System.Windows.Forms.Form
declaracin
de
las
variables
tipos
MenuItem
creados
mnuContabilidad
As
WithEvents
mnuApuntes
mnuBalances
As
que
en
As
End
'***************
Private
Sub
btnCrear_Click(ByVal
System.EventArgs)
contendrn
ejecucin
MenuItem
MenuItem
MenuItem
Class
sender
As
Handles
System.Object,
ByVal
e
As
btnCrear.Click
'
'
crear
y
opciones
aadirlas
de
men
'
opcin
Me.mnuContabilidad
Me.mnuContabilidad.Text
de
=
de
New
desplegar
del
New
ejecucin
formulario
mens
MenuItem()
"&Contabilidad"
men
Contabilidad
MenuItem()
"&Apuntes"
True
True
=
=
=
'
aadir
al
men
Me.mnuContabilidad.MenuItems.AddRange(New
Me.mnuBalances})
'
aadir
al
men
Me.Menu.MenuItems.AddRange(New
End
Private Sub
mnuApuntes.Click
de
del
barra
Me.mnuBalances
=
Me.mnuBalances.Text
Me.mnuBalances.DefaultItem
AddHandler
mnuBalances.Click,
'***************
este
procedimiento
la
opcin
tiempo
'
opciones
Me.mnuApuntes
Me.mnuApuntes.Text
Me.mnuApuntes.Checked
Me.mnuApuntes.RadioCheck
'
'
en
men
al
se
del
formulario
MenuItem()
sender
MessageBox.Show("Opcin
MenuItem()
"&Balances"
True
OpcionBalances
=
AddressOf
Contabilidad
MenuItem()
lanzar
al
de
men
OpcionApuntes(ByVal
New
=
la
sus
opciones
{Me.mnuApuntes,
opcin
de
la
barra
{Me.mnuContabilidad})
Sub
seleccionar
Apuntes
As
Object,
ByVal
Apuntes
As
EventArgs)
del
End
se
lanzar
sender
ha
de
As
Object,
seleccionado
al
men
ByVal e
la
seleccionar
Balances
As EventArgs)
opcin
End
Balances")
Sub
'***************
'
al
pulsar
este
botn,
eliminamos
'
del
men
principal
Private
Sub
btnEliminar_Click(ByVal
sender
As
System.EventArgs)
Handles
Dim
men")
Sub
'***************
'
este
procedimiento
'
la
opcin
Private Sub OpcionBalances(ByVal
MessageBox.Show("Se
Handles
oMenuItem
el
men
Contabilidad
del
formulario
System.Object,
ByVal
e
As
btnEliminar.Click
As
MenuItem
'
recorrer
For
Each
oMenuItem
buscar
por
el
oMenuItem.Text.IndexOf("Contabilidad")
'
If
la
coleccin
'
si
lo
Me.Menu.MenuItems.Remove(oMenuItem)
End
Next
de
mens
In
nombre
>
encontramos,
del
formulario
Me.Menu.MenuItems
de
men
0
Then
quitarlo
If
End
Sub
En la Figura 282 se visualiza este formulario al ser ejecutado, incluyendo el nuevo men creado por cdigo.
Aunque en este ejemplo hemos aadido opciones en tiempo de ejecucin a un men de formulario ya existente,
podemos partir de un formulario sin men, y crear todas las opciones partiendo de cero, asignando el men construido
por cdigo a la propiedad Menu de nuestro objeto formulario.
Programacin
con
hebras
ejecuta.
La clase Thread
Esta es la clase que nos va a permitir la creacin y manipulacin de procesos en hebras independientes. Se
encuentra ubicada dentro del espacio de nombres Threading, el cual, contiene todas las clases de la plataforma .NET
relacionadas con la programacin basada en hebras. Entre los miembros de Thread destacaremos los siguientes.
.
New. Se trata del constructor de la clase, y como parmetro debemos incluir la direccin de entrada
del procedimiento que debe ejecutar la hebra. Para indicar dicha direccin del procedimiento utilizaremos el operador
AddressOf.
.
Start( ). Inicia la ejecucin de la hebra.
.
Abort( ). Cancela la ejecucin de la hebra.
.
Suspend( ). Suspende la ejecucin de la hebra.
.
Sleep( ). Permite establecer un retardo en milisegundos para la ejecucin de la hebra.
.
CurrentThread. Devuelve una instancia del objeto Thread actualmente en ejecucin.
.
Join( ). Devuelve un valor lgico que indica si la hebra ya ha finalizado.
.
IsAlive( ). Devuelve un valor lgico que indica si la hebra est todava activa o viva.
De forma adicional a los miembros de esta clase, y como veremos en los siguientes ejemplos, en la clase
AppDomain disponemos de la propiedad GetCurrentThreadId, que devuelve un valor numrico con el identificador de
la hebra que se encuentra actualmente en ejecucin.
Tambin disponemos de la estructura SyncLock...End SyncLock, que evita el que varias hebras intenten hacer
uso de un mismo objeto.
Imports
Public
Inherits
Private
'....
Cdigo fuente 484
System.Threading
Class
Form1
System.Windows.Forms.Form
oHebra
As
Thread
Para terminar, escribiremos un mtodo en la clase que ser el que realice el llenado del ListBox, y codificaremos
el evento Click del botn del formulario, que crea la hebra y la pone en marcha. Observe el lector, como mientras se
produce el llenado del ListBox, podemos escribir texto en el control TextBox. Si no utilizramos la hebra, hasta que el
control de lista no estuviera lleno, no podramos pasar el foco al TextBox para trabajar con l. Ver Cdigo fuente 485.
Private Sub
System.EventArgs)
btnIniciar_Click(ByVal sender
Handles
'
instanciar
la
hebra
'
en
el
constructor
'
qu
procedimiento
deber
oHebra
=
New
oHebra.Start()
As
System.Object, ByVal e As
btnIniciar.Click
y
ponerla
en
de
la
hebra,
ejecutar
al
ser
Thread(AddressOf
marcha
indicamos
iniciada
LlenarLista)
End
Dim
Dim
Sub
Private
Sub
iContador
iCuentaBis
As
As
LlenarLista()
Integer
Integer
For
iContador
Me.lstProceso.Items.Add("Contador:
For
iCuentaBis
To
"
&
To
'
Next
Next
'
oHebra.Abort()
End
finalizamos
la
10000
iContador)
50000
retardo
hebra
Sub
Control
de
procesos
indefinidos
Otro escenario de trabajo consistira en la capacidad de manipular un proceso ejecutado sin un punto
determinado de finalizacin.
El ejemplo del proyecto HebraInfinito (hacer clic aqu para acceder a este ejemplo), consta de un formulario con
dos botones y un control de lista. El control btnIniciar pone en funcionamiento, a travs de una hebra, la ejecucin de
un procedimiento que llena un ListBox dentro de un bucle infinito.
En otras circunstancias, este diseo de la aplicacin sera impensable, pero en nuestro caso, al estar gestionado
por una hebra, vamos a pararla en el momento en que consideremos oportuno mediante la pulsacin del otro botn,
btnDetener. El Cdigo fuente 486 muestra el cdigo de la clase de este formulario.
Imports
System.Threading
Public
Inherits
Class
Form1
System.Windows.Forms.Form
Private
oHebra
As
Thread
'....
'....
Private Sub
System.EventArgs)
btnIniciar_Click(ByVal sender
Handles
'
Me.lstProceso.Items.Clear()
'
creamos
oHebra
=
'
oHebra.Start()
As
limpiamos
System.Object, ByVal e As
btnIniciar.Click
el
una
hebra
New
iniciamos
que
ejecute
Thread(AddressOf
la
ListBox
un
procedimiento
LlenarLista)
hebra
End
Private Sub
System.EventArgs)
Sub
btnDetener_Click(ByVal sender
Handles
As
System.Object, ByVal e As
btnDetener.Click
oHebra.Abort()
Me.lstProceso.Items.Add("Hebra
detenida")
End
Sub
Private
Dim
Dim
Sub
iContador
iCuentaBis
As
As
LlenarLista()
Integer
Integer
'
con
AppDomain.GetCurrentThreadId
obtenemos
el
'
identificador
de
la
hebra
que
est
actualmente
'
en
ejecucin
Me.lstProceso.Items.Add("ID
hebra:
"
&
AppDomain.GetCurrentThreadId)
While
iContador
Me.lstProceso.Items.Add("Contador
For
iCuentaBis
+=
pasos:
"
&
To
'
Next
End
True
1
iContador)
50000
retardo
While
Sub
Class
End
End
Cdigo fuente 486
En la Figura 284 podemos ver esta aplicacin una vez que la hebra ha sido detenida.
El lector habr observado que en este ejemplo, tambin incluimos un bucle de retardo al llenar el ListBox. Esto
no obstante, no es necesario utilizando la clase Thread, puesto que su mtodo Sleep( ), nos permitir establecer un
tiempo de parada en la ejecucin de la hebra, determinado en milisegundos.
Podemos acceder a la hebra actual mediante el mtodo compartido GetCurrentThread de esta clase. Esta es la
manera en que ejecutamos, en este ejemplo, el mtodo Sleep( ).
Por lo tanto, si modificamos el cdigo del procedimiento LlenarLista( ) de este ejemplo, por el mostrado en el
Cdigo fuente 487 conseguiremos el mismo resultado
Dim
Private
Sub
iContador
As
LlenarLista()
Integer
Dim
iCuentaBis
As
'
con
'
identificador
'
Me.lstProceso.Items.Add("ID
Integer
de
AppDomain.GetCurrentThreadId
la
hebra
que
en
hebra:
"
&
While
iContador
Me.lstProceso.Items.Add("Contador
'
frenar
Thread.CurrentThread.Sleep(500)
End
End
obtenemos
est
el
actualmente
ejecucin
AppDomain.GetCurrentThreadId)
True
1
iContador)
+=
pasos:
la
"
&
ejecucin
de
la
hebra
While
Sub
Ejecucin multihebra
En los anteriores apartados hemos creado una hebra, y llamado desde la misma a un nico procedimiento, para
ejecutar un determinado proceso. Sin embargo la verdadera potencia de las hebras radica en su capacidad para ejecutar
simultneamente varios procesos.
En el proyecto de ejemplo VariasHebras (hacer clic aqu para acceder a este ejemplo), se muestra un formulario
con las mismas caractersticas de los pasados ejemplos: un ListBox y un Button. En esta ocasin, sin embargo, al
pulsar el botn, crearemos varias hebras que al ponerse en ejecucin, llamarn al mismo procedimiento. Ver el Cdigo
fuente 488.
Imports
System.Threading
Public
Class
Form1
Inherits
System.Windows.Forms.Form
'....
'....
'
Private Sub
System.EventArgs)
al
pulsar
btnIniciar_Click(ByVal sender
Handles
este
As
botn
System.Object, ByVal e As
btnIniciar.Click
Dim
iContador
As
Integer
Dim
oHebra
As
Thread
limpiamos
el
ListBox
'
Me.lstValores.Items.Clear()
'
creamos
varias
For
hebras
iContador
oHebra
que
ejecuten
el
mismo
New
procedimiento
To
10
Thread(AddressOf
LlenarLista)
oHebra.Start()
Next
End
'
Private
Dim
Sub
procedimiento
que
ejecutado
iContador
'
indicamos
'
en
'
en
recorremos
cada
el
iContador
por
las
hebras
LlenarLista()
Integer
As
que
identificador
ejecutando
Me.lstValores.Items.Add("Sub
AppDomain.GetCurrentThreadId)
'
'
For
ser
Sub
LlenarLista
hebra
se
este
-
un
iteracin
contador
=
Me.lstValores.Items.Add(ControlChars.Tab
AppDomain.GetCurrentThreadId
&
"
Next
de
procedimiento
ejecutndose
en
hebra:
bucle
"
la
hebra
actual
de
To
&
paso
est
"
&
&
indicamos
y
paso
7
_
iContador)
End
Sub
End
Class
En la anterior figura aparece un identificador de hebra, del que no se muestran a continuacin las
correspondientes iteraciones; estos elementos se encuentran ms adelante, mezclados con los valores de otro proceso.
Esto se debe a una cuestin de sincronizacin de la que trataremos ms adelante.
Tenga en cuenta tambin el lector, que al probar este ejemplo, puede que los valores le aparezcan correctamente,
puesto que no podemos precisar las prioridades que asigna el procesador a la hora de ejecutar las hebras.
'
al
pulsar
Private
Sub
btnIniciar_Click(ByVal
sender
System.EventArgs)
Handles
As
este
botn
System.Object,
ByVal
e
As
btnIniciar.Click
Dim
iContador
As
Integer
Dim
oHebra
As
Thread
Dim
oHebraBis
'
Me.lstValores.Items.Clear()
limpiamos
As
el
Thread
ListBox
'
creamos
For
oHebra
oHebra.Start()
varias
hebras
iContador
oHebraBis
oHebraBis.Start()
Next
que
New
New
ejecuten
varios
1
Thread(AddressOf
Thread(AddressOf
procedimientos
To
10
LlenarPrimero)
OtroLlenado)
End
Sub
iContador
As
Integer
'
indicamos
en
qu
identificador
de
'
ejecutando
este
Me.lstValores.Items.Add("Sub
LlenarPrimero
ejecutndose
hebra
en
se
est
procedimiento
hebra:
"
&
AppDomain.GetCurrentThreadId)
'
'
'
For
en
recorremos
cada
el
iContador
un
iteracin
contador
=
Me.lstValores.Items.Add(ControlChars.Tab
AppDomain.GetCurrentThreadId
&
"
Next
bucle
la
hebra
actual
de
To
&
paso
"
indicamos
y
paso
7
_
iContador)
&
End
Dim
Sub
Private
Sub
iContador
As
OtroLlenado()
Integer
'
indicamos
en
qu
identificador
de
'
ejecutando
este
Me.lstValores.Items.Add("Sub
OtroLlenado
ejecutndose
hebra
en
se
est
procedimiento
hebra:
"
&
AppDomain.GetCurrentThreadId)
'
'
'
For
en
recorremos
cada
el
iContador
un
iteracin
contador
=
Me.lstValores.Items.Add(ControlChars.Tab
AppDomain.GetCurrentThreadId
&
"
Next
End
bucle
la
hebra
actual
de
To
&
paso
"
&
indicamos
y
paso
7
_
iContador)
Sub
Veamos en la Figura 286 el formulario en ejecucin. En este caso tambin aparecen los valores mezclados de
las hebras, al igual que anteriormente, por cuestiones de sincronizacin.
Private Sub
System.EventArgs)
btnIniciar_Click(ByVal sender
Handles
As
System.Object, ByVal e As
btnIniciar.Click
Dim
Contador
As
Integer
Dim
Hebra
As
Thread
Me.lstValores.Items.Clear()
Hebra
Hebra.Start()
New
Thread(AddressOf
AgregarConRetardo)
'
'
si
la
devuelve
hebra
no
False;
se
pero
If
ha
si
terminado,
ha
el
terminado
mtodo
Join()
devuelve
True
Hebra.Join(1000)
Me.lblMensaje.Text
Else
Me.lblMensaje.Text
End
Then
"Hebra
"Hebra
finalizada"
NO
finalizada"
If
End
Sub
'procedimiento
'
Private
especificando
Dim
que
un
se
retardo
Sub
ejecutar
en
el
bucle
dentro
una
As
Me.lstValores.Items.Add("Sub
AgregarConRetardo
AppDomain.GetCurrentThreadId().ToString())
1
&
"
End
hebra
del
procedimiento
AgregarConRetardo()
Contador
For
Contador
=
Me.lstValores.Items.Add("
hebra
AppDomain.GetCurrentThreadId().ToString()
Contador.ToString())
Thread.CurrentThread.Sleep(250)
Next
de
To
"
paso
ejecutandose
"
Integer
en
hebra
"
&
20
&
&
Sub
btnIniciar_Click(ByVal sender
Handles
Dim
Contador
Dim
Hebra
HebraBis
Dim
As
System.Object, ByVal e As
btnIniciar.Click
As
Integer
As
As
Thread
Thread
Me.lstValores.Items.Clear()
Me.lstDatos.Items.Clear()
Hebra
Hebra.Start()
HebraBis
HebraBis.Start()
End
New
New
Thread(AddressOf
Thread(AddressOf
LlenaListaValores)
LlenaListaDatos)
Sub
'
'
Private
este
y
procedimiento
se
llenar
Sub
ejecutar
en
una
hebra
un
ListBox
LlenaListaValores()
Dim
Contador
As
Integer
Me.lstValores.Items.Add("Sub LlenaListaValores - ejecutandose en hebra
"
&
AppDomain.GetCurrentThreadId().ToString())
For
Contador
=
1
Me.lstValores.Items.Add("
hebra
AppDomain.GetCurrentThreadId().ToString()
Contador.ToString())
Thread.CurrentThread.Sleep(500)
Next
End
'
'
Private
este
y
procedimiento
llenar
Sub
Dim
se
el
&
To
"
" paso
30
&
" &
Sub
ejecutar
en
una
hebra
otro
ListBox
LlenaListaDatos()
Contador
As
Me.lstDatos.Items.Add("Sub
LlenaListaDatos
AppDomain.GetCurrentThreadId().ToString())
For
Contador
=
1
Me.lstDatos.Items.Add("
hebra
AppDomain.GetCurrentThreadId().ToString()
Contador.ToString())
Thread.CurrentThread.Sleep(150)
Next
End
&
To
"
" paso
ejecutandose
50
&
" &
Sub
Sincronizacin de hebras
Integer
en
hebra
"
&
En un ejemplo anterior, en el cual, varias hebras llamaban a su vez a mltiples procedimientos, es posible como
se comentaba al final de dicho apartado, que el resultado obtenido mostrara la ejecucin mezclada de varias hebras. El
motivo es que todas las hebras creadas trabajaban contra el mismo objeto: el control ListBox del formulario,
interfirindose mutuamente en algunas ocasiones.
Para evitar este problema, .NET nos proporciona la estructura SyncLock, que nos permite bloquear un objeto
que se est ejecutando dentro del proceso de una hebra, de forma que hasta que dicha hebra no haya finalizado de usar
el objeto, no se desbloquear para ser utilizado por otra hebra, o lo que es igual, SyncLock permite que un objeto slo
pueda ser utilizado por una hebra a la vez.
Para demostrar el uso de SyncLock, crearemos una nueva aplicacin con el nombre HebraSincro (hacer clic
aqu para acceder a este ejemplo), incluyendo un control Button y un ListBox en su formulario.
Al pulsar el botn de este formulario, crearemos dos hebras que ejecutarn un procedimiento diferente cada una.
El procedimiento rellenar de valores el ListBox, con una diferencia respecto a los anteriores ejemplos, consistente en
que cuando una de las hebras ejecute su procedimiento, bloquear el ListBox y hasta que no termine de rellenarlo, no
ceder el objeto a la siguiente hebra. Veamos estas operaciones en el Cdigo fuente 492.
Private Sub
System.EventArgs)
btnIniciar_Click(ByVal sender
Handles
'
crear
Dim
HebraUno
Dim
HebraDos
HebraUno.Start()
HebraDos.Start()
As
dos
As
As
System.Object, ByVal e As
btnIniciar.Click
hebras
y
Thread(AddressOf
Thread(AddressOf
New
New
lanzarlas
ManipListaUno)
ManipListaDos)
End
Sub
'procedimiento
que
ser
ejecutado
en
una
de
las
hebras
Private
Sub
ManipListaUno()
Dim
Contador
As
Integer
'
si
hay
hebras
que
utilizan
objetos
comunes,
'
(en
este
caso
el
listbox)
'
es
necesario
sincronizar
el
objeto
de
forma
'
que
slo
pueda
ser
utilizado
por
una
hebra
a
la
vez
SyncLock
(Me.lstValores)
For
Contador
Me.lstValores.Items.Add("Sub
Next
End
End
' procedimiento
Private
Dim
'
'
SyncLock
que
sincronizar
ser
=
ManipListaUno
ejecutado
Sub
1
-
en
una
Contador
tambin
To
paso:
"
&
100
Contador)
SyncLock
Sub
de las hebras
ManipListaDos()
As
en
el
For
Contador
=
1
To
100
Me.lstValores.Items.Add("Sub ManipListaDos - paso: " &
Contador)
Next
End
SyncLock
este
Integer
procedimiento
listbox
(Me.lstValores)
End
Sub
En esta ocasin, no aparecern en el ListBox, valores entremezclados producto de los intentos de las hebras de
acaparar el uso del control del formulario, por el contrario, aparecern en primer lugar los valores de la ejecucin de la
primera hebra, y a continuacin los de la segunda.
Debido a que el cdigo se ejecuta a gran velocidad, para comprobar mejor este efecto, puede ser buena idea
introducir un retardo en cada procedimiento que ejecutan las hebras, de manera que podamos observar con ms
detenimiento el proceso.
Private
oHebra
Private Sub
System.EventArgs)
'
As
btnIniciar_Click(ByVal sender
Handles
instanciar
oHebra
una
=
hebra
As
System.Object, ByVal e As
btnIniciar.Click
New
Thread
ponerla
en
Thread(AddressOf
ejecucin
ComprobarClave)
oHebra.Start()
End
Sub
Private Sub
System.EventArgs)
'
btnParar_Click(ByVal sender
Handles
detener
la
hebra
As
System.Object, ByVal e As
btnParar.Click
que
est
en
ejecucin
oHebra.Abort()
Me.lblContador.Text
Me.lblEstado.Text
End
=
=
""
""
Sub
'
'
de
Public
procedimiento
que
se
ejecutar
dentro
la
hebra
creada
en
la
aplicacin
Sub
ComprobarClave()
Dim
iContadorPasos
As
Integer
While
True
iContadorPasos
+=
Me.lblContador.Text
If
iContadorPasos
Me.txtClave.Text.Length
If
Me.txtClave.Text
Me.lblEstado.Text
Else
Me.lblEstado.Text
=
End
Else
Me.lblEstado.Text
End
'
frenar
oHebra.Sleep(250)
End
la
"778899"
Then
"CORRECTA"
=
"NO
Then
ES
CORRECTA"
If
""
If
ejecucin
de
la
hebra
While
End
Sub
Podemos observar que una vez iniciada la hebra, se comienza la ejecucin de un bucle infinito, que muestra en
un Label la cantidad de ocasiones en que se realiza la comprobacin, y si el valor introducido en el TextBox es o no
correcto. En cualquier momento, podemos detener el proceso, pulsando el botn btnParar, que ejecuta el mtodo
Abort() de la hebra.
Otro detalle que se nos puede pasar por alto, radica en el hecho de que si iniciamos la hebra y cerramos el
formulario, la hebra sigue en ejecucin; podemos comprobar esto abriendo el men Depurar de Visual Studio, en el
que sorprendentemente, aparecer la opcin Detener depuracin, lo cual indica que hay todava un proceso en
ejecucin, "pero como?, si yo he cerrado el formulario", pues s, hemos cerrado el formulario, pero no hemos
detenido el proceso que pusimos en marcha.
Para que no se quede ningn proceso fuera de control, lo que hacemos en este caso, es codificar el evento
Closed( ) del formulario, que se desencadena cuando el formulario es cerrado. En este evento, comprobamos si la
hebra est todava activa mediante su propiedad IsAlive; en el caso de que esta propiedad devuelva True, cancelamos
la ejecucin de la hebra. Ver Cdigo fuente 494.
Private
Handles
'
'
'
If
Sub
Form1_Closed(ByVal
si
cdigo
hebra,
la
la
Not
If
sender
As
Object,
ByVal
de
la
aplicacin
debemos
hacerlo
ejecucin
(oHebra
Is
oHebra.IsAlive
As
System.EventArgs)
MyBase.Closed
no
ha
antes
de
del
Nothing)
finalizado
terminar
programa
Then
Then
oHebra.Abort()
End
End
If
If
End
Sub
Public
Public
'
Application.Run(New
Application.Run(New
End
Class
Inicio
Shared
esto
Sub
no
Main()
funciona
Form1())
Form2())
Sub
End
Class
Si optamos por poner en el Form1, un botn que al ser pulsado, abra el Form2, habremos solucionado el
problema slo en parte, puesto que cuando cerremos Form1, tambin se cerrar Form2 sin que podamos evitarlo.
El motivo de este comportamiento reside en que ambos formularios se ejecutan en la denominada hebra
principal de ejecucin del programa.
Para solucionar este problema debemos hacer lo siguiente: crear dos nuevos procedimientos o mtodos, en los
que cada uno instancie una copia de cada uno de los formularios, y desde Main( ) crear dos hebras que ejecuten dichos
procedimientos, y los pongan en marcha. De este modo, cada formulario se ejecutara en su propia hebra
independiente, y el cierre del primero no implicara el cierre del segundo. Vemoslo en el Cdigo fuente 496.
Imports
System.Threading
Public
'
'
Dim
Dim
Class
Public
crear
dos
que
oHebraUno
oHebraDos
'
oHebraUno.Start()
oHebraDos.Start()
Shared
hebras
que
lanzan
As
New
As
New
Inicio
Sub
apunten
los
Thread(AddressOf
Thread(AddressOf
iniciar
las
End
Public
Application.Run(New
End
Public
Application.Run(New
End
Main()
mtodos
formularios
LanzaPrimerForm)
LanzaSegundoForm)
los
hebras
Sub
Shared
Shared
Sub
Sub
End
LanzaPrimerForm()
Form1())
Sub
LanzaSegundoForm()
Form2())
Sub
Class
El cdigo del botn que realiza la grabacin del texto lo podemos ver en el Cdigo fuente 497. Debemos
importar el espacio de nombres System.IO, ya que en esta clase del formulario hacemos uso de los tipos File y
StreamWriter.
Private Sub
System.EventArgs)
btnGrabar_Click(ByVal sender
Handles
'
escribir
en
'
Dim
oEscritor
oEscritor
=
oEscritor.Write(Me.txtCarta.Text)
oEscritor.Close()
End
un
del
As
System.Object, ByVal e As
btnGrabar.Click
archivo
el
contenido
TextBox
As
StreamWriter
File.CreateText(Me.txtArchivo.Text)
Sub
El otro formulario hijo, frmInfo, muestra la fecha y hora actual; esta ltima es actualizada a travs del control
Timer tmrTiempo. Ver la Figura 292.
Figura 292. Formulario hijo de MDI para mostrar fecha y hora actuales.
El Cdigo fuente 498 muestra las instrucciones que se ejecutan en el evento Tick del control Timer.
Private Sub
System.EventArgs)
tmrTiempo_Tick(ByVal sender
Handles
Dim
dtFecha
Dim
dtHora
As
System.Object, ByVal e As
tmrTiempo.Tick
dtFecha
As
=
dtHora
Me.lblFecha.Text
Me.lblHora.Text
End
As
=
Date
DateTime.Today
Date
DateTime.Now
dtFecha.ToString("d/MMM/yyyy")
=
dtHora.ToString("h:m:s")
Sub
El siguiente paso consiste en crear un men para poder abrir los formularios hijos a travs de sus opciones. Ver
Figura 293.
En las opciones Carta e Informacin del men, instanciaremos un objeto del formulario correspondiente,
teniendo en cuenta que para conseguir que dichos formularios se comporten como hijos del MDI, debemos asignar a
su propiedad MdiParent, la instancia actual del formulario en ejecucin, es decir, Me. Veamos este punto en el Cdigo
fuente 499.
Private Sub
System.EventArgs)
mnuCarta_Click(ByVal sender
Handles
Dim
'
con
'
formulario
ofrmCarta.MdiParent
ofrmCarta.Show()
la
ofrmCarta
siguiente
se
comporte
As
System.Object, ByVal e As
mnuCarta.Click
As
lnea
como
=
New
conseguimos
hijo
que
del
End
Private Sub
System.EventArgs)
Sub
mnuInformacion_Click(ByVal sender
Handles
Dim
'
con
'
formulario
ofrmInfo.MdiParent
ofrmInfo.Show()
End
frmCarta()
el
actual
Me
la
ofrmInfo
siguiente
se
comporte
As
As
lnea
como
=
System.Object, ByVal e As
mnuInformacion.Click
New
conseguimos
hijo
que
del
frmInfo()
el
actual
Me
Sub
En la Figura 294 mostramos el formulario MDI en ejecucin, conteniendo a los formularios hijos dependientes.
Private Sub
System.EventArgs)
mnuCascada_Click(ByVal sender
Handles
As
System.Object, ByVal e As
mnuCascada.Click
Me.LayoutMdi(MdiLayout.Cascade)
End
Private Sub
System.EventArgs)
Sub
mnuHorizontal_Click(ByVal sender
Handles
As
System.Object, ByVal e As
mnuHorizontal.Click
Me.LayoutMdi(MdiLayout.TileHorizontal)
End
Sub
La Figura 295 muestra el mencionado men Ventana de este proyecto, en cual contiene en este caso los
nombres de los formularios abiertos que acaban de ser organizados en mosaico vertical.
Private Sub
System.EventArgs)
'
mnuInformacion_Click(ByVal sender
Handles
deshabilitamos
Me.mnuInformacion.Enabled
Dim
con
'
formulario
ofrmInfo.MdiParent
ofrmInfo.Show()
opcin
la
comporte
de
False
As
siguiente
se
System.Object, ByVal e As
mnuInformacion.Click
esta
ofrmInfo
'
As
men
'
<-----
New
lnea
frmInfo()
conseguimos
como
=
hijo
que
del
el
actual
Me
End
Sub
En segundo lugar, dentro del cdigo del formulario hijo, en nuestro caso frmInfo, debemos escribir el
manipulador para el evento Closed del formulario. Este evento se produce cuando se ha cerrado el formulario, por lo
que desde aqu volveremos a activar la opcin de men del formulario padre, que habamos deshabilitado.
Para acceder desde un formulario hijo a su MDI contenedor, disponemos de la propiedad MdiParent, que nos
devuelve una referencia de dicho formulario padre. Observe el lector en el Cdigo fuente 502, cmo adems de utilizar
la mencionada propiedad, la potencia de la funcin CType( ) nos permite en una sola lnea de cdigo, llevar a cabo
esta accin.
'
al
cerrar
este
formulario,
activamos
'
la
opcin
de
men
del
formulario
'
permite
crear
instancias
de
este
Private Sub frmInfo_Closed(ByVal sender As Object, ByVal e As
Handles
'
utilizando
'
la
'
correspondiente
'
'
con
propiedad
End
obtenemos
a
funcin
MdiParent
a
ello
particular
'
CType(Me.MdiParent,
la
la
la
acceso
opcin
del
clase
a
de
de
nuevo
padre
que
formulario
System.EventArgs)
MyBase.Closed
CType(),
moldeamos
formulario
del
sus
men
frmPrincipal).mnuInformacion.Enabled
al
tipo
formulario
MDI;
miembros,
que
en
necesitamos
=
habilitar
True
Sub
La Figura 296 muestra el resultado al ejecutar. Mientras que el formulario de informacin est abierto, su
opcin de men en el MDI estar deshabilitada.
Dim
oFormHijos
oFormHijos()
As
Form
=
Me.MdiChildren
Dim
For
oForm
Each
MessageBox.Show("Ttulo
oForm.BackColor
As
oForm
de
ventana:
Form
In
"
oFormHijos
&
oForm.Text)
Color.Beige
Next
Cdigo fuente 503
Otra caracterstica de los formularios no modales reside en que una vez creados y visualizados, el resto del
cdigo de la aplicacin contina su ejecucin. Ver Cdigo fuente 504.
Dim
ofrmCarta
'
crear
formulario
ofrmCarta.MdiParent
ofrmCarta.Show()
As
New
frmCarta()
hijo
de
un
mdi
=
Me
'
despus
de
'
se
muestra
a
MessageBox.Show("Se
acaba
mostrar
el
continuacin
de
abrir
un
formulario
este
formulario
hijo
mensaje
hijo")
Private Sub
System.EventArgs)
'
Dim
'
mnuDialogo_Click(ByVal sender
Handles
instanciar
el
ofrmDialogo
dar
formulario
mostrarlo
que
As
una
ofrmDialogo.StartPosition
'
de
ofrmDialogo.ShowDialog()
As
System.Object, ByVal e As
mnuDialogo.Click
mostraremos
New
posicin
modal,
un
al
=
forma
como
dilogo
frmDialogo()
formulario
FormStartPosition.CenterParent
como
cuadro
de
dilogo
MessageBox.Show("Se
ha
cerrado
el
dilogo")
End
Sub
Para cerrar un formulario modal podemos, al igual que para cualquier formulario, ejecutar su mtodo Close( ).
No obstante, un formulario de dilogo suele proporcionar, aunque esto no es obligatorio, los tpicos botones para
aceptar, cancelar, reintentar, etc.; de modo que una vez cerrado el formulario, podamos averiguar qu botn puls el
usuario.
Podemos proporcionar este comportamiento en nuestros formularios modales, asignando a la propiedad
DialogResult de la clase Form, uno de los valores del tipo enumerado DialogResult. Esto tendr como efecto adicional
el cierre del cuadro de dilogo.
Por lo tanto, vamos a aadir a nuestro formulario frmDialogo, dos controles Button: btnAceptar y btnCancelar,
en los que escribiremos las instrucciones del Cdigo fuente 506.
Private Sub
System.EventArgs)
btnAceptar_Click(ByVal sender
Handles
'
asignar
'
cierra
un
al
As
valor
mismo
Me.DialogResult
System.Object, ByVal e As
btnAceptar.Click
tiempo
esta
propiedad,
el
formulario
DialogResult.OK
End
Private
Handles
Sub
Sub
btnCancelar_Click(ByVal
'
asignar
'
cierra
Me.DialogResult
End
un
al
sender
valor
mismo
=
As
Object,
ByVal
a
tiempo
As
System.EventArgs)
btnCancelar.Click
esta
propiedad,
el
formulario
DialogResult.Cancel
Sub
Como ayuda en la construccin de formularios modales de dilogo, la clase Form dispone de las propiedades
AcceptButton y CancelButton, a las que podemos asignar sendos controles Button que sern ejecutados al pulsar las
teclas [INTRO] y [ESCAPE] respectivamente.
Esto es lo que haremos en el formulario frmDialogo, asignando a AcceptButton el control btnAceptar, y en
CancelButton asignaremos btnCancelar.
Finalmente, en el evento de la opcin de men que abre este formulario modal, correspondiente a frmPrincipal,
aadiremos, tras la llamada a ShowDialog( ), el cdigo que comprobar el resultado de la ejecucin del formulario de
dilogo. Ver el Cdigo fuente 507.
Private Sub
System.EventArgs)
mnuDialogo_Click(ByVal sender
Handles
As
System.Object, ByVal e As
mnuDialogo.Click
'
instanciar
el
formulario
que
mostraremos
como
un
dilogo
Dim
ofrmDialogo
As
New
frmDialogo()
'
dar
una
posicin
al
formulario
ofrmDialogo.StartPosition
=
FormStartPosition.CenterParent
'
mostrarlo
de
forma
modal,
como
cuadro
de
dilogo
ofrmDialogo.ShowDialog()
'
'
Dim
Resultado
If
comprobar
en
lo
el
Resultado
ha
cuadro
=
Resultado
MessageBox.Show("Datos
ofrmDialogo.txtNombre.Text
ofrmDialogo.txtApellidos.Text)
Else
MessageBox.Show("Se
End
End
que
ha
=
del
&
cancelado
usuario
dilogo
As
DialogResult
ofrmDialogo.DialogResult
DialogResult.OK
Then
dilogo:
"
el
hecho
el
de
"
"
&
&
_
_
dilogo")
If
Sub
La Figura 297 muestra el programa en ejecucin. Como puede comprobar el lector, el formulario modal, debido
a su comportamiento, no se encuentra limitado a los bordes del formulario MDI; pero depende de este ltimo, ya que
si intentamos pasar el foco a un formulario hijo, no podremos.
Una vez dibujado un control de cuadro de dilogo en el formulario, dicho control quedar ubicado en el panel de
controles especiales, al igual que sucede con los mens. Para abrir un control de este tipo en tiempo de ejecucin,
emplearemos su mtodo ShowDialog( ).
A continuacin describiremos cada uno de los controles de dilogo utilizados en este ejemplo.
ColorDialog
Este control muestra el cuadro de dilogo del sistema para la seleccin de colores. Entre sus propiedades
podemos destacar las siguientes.
.
Color. Contiene un tipo de la estructura Color, que nos permite obtener el color seleccionado por el
usuario mediante este cuadro de dilogo, para poder aplicarlo sobre alguno de los elementos del formulario.
.
AllowFullOpen. Contiene un valor lgico que permite habilitar y deshabilitar el botn que muestra el
conjunto de colores personalizados del cuadro de dilogo de seleccin de colores.
Al seleccionar en el formulario, la opcin de men Color, ejecutaremos el Cdigo fuente 508 que nos permitir,
utilizando el control dlgColor, de tipo ColorDialog, elegir un color y aplicarlo a la propiedad BackColor, del control
TextBox.
Private Sub
System.EventArgs)
mnuColor_Click(ByVal sender
Handles
As
System.Object, ByVal e As
mnuColor.Click
Me.dlgColor.ShowDialog()
Me.txtTexto.BackColor
End
Me.dlgColor.Color
Sub
La Figura 299 muestra esta aplicacin con el formulario y el cuadro de seleccin de color abiertos.
FontDialog
Este control muestra el cuadro de dilogo del sistema para la seleccin del tipo de fuente. Entre sus propiedades
podemos destacar las siguientes.
.
Font. Contiene un tipo de la clase Font. Una vez seleccionada una fuente por el usuario en el cuadro
de dilogo, podremos cambiar el fuente de los controles del formulario.
.
ShowApply. Contiene un valor lgico que permite mostrar-ocultar el botn Aplicar, que nos permitir
asignar el tipo de letra sin cerrar el dilogo. Al pulsar este botn se desencadenar el
evento Apply de este control de dilogo, en el que podremos escribir el cdigo necesario para aplicar la nueva
fuente seleccionada.
Al seleccionar en el formulario la opcin de men Fuente, ejecutaremos el Cdigo fuente 509 que nos permitir,
utilizando el control dlgFuente, de tipo FontDialog, elegir un tipo de letra, y aplicarlo a la propiedad Font del control
TextBox; con la particularidad de que el cambio de letra lo haremos tanto al pulsar el botn Aceptar, como Aplicar del
cuadro de dilogo.
'
al
hacer
clic
en
este
'
de
seleccin
Private
Sub
mnuFuente_Click(ByVal
sender
System.EventArgs)
Handles
men,
As
mostramos
de
System.Object,
el
cuadro
fuente
ByVal
e
As
mnuFuente.Click
Me.dlgFuente.ShowApply
True
Me.dlgFuente.ShowDialog()
Me.AplicarFuente()
End
Sub
' este
Private
mtodo
cambia
Sub
el
Me.txtTexto.Font
Me.dlgFuente.Font
End
'
'
Private
Handles
Sub
al
pulsar
el
botn
seleccin
de
fuente,
Sub dlgFuente_Apply(ByVal sender As
Aplicar
del
dilogo
de
se
produce
este
evento
Object, ByVal e As System.EventArgs)
dlgFuente.Apply
Me.AplicarFuente()
End
Sub
Figura 300. Cuadro de dilogo del sistema para seleccin de tipo de letra.
SaveFileDialog
Este control muestra el cuadro de dilogo del sistema, mediante el que escribimos un nombre de archivo, y
elegimos un directorio, sobre el cual grabaremos informacin.
Es importante precisar que el control no se ocupa del proceso de grabacin de datos; su cometido es el
permitirnos navegar por la estructura del sistema de archivos del equipo, y la seleccin de un nombre para el archivo a
grabar.
Entre las propiedades del control, podemos destacar las siguientes.
.
Title. Contiene una cadena con el ttulo que aparecer en el cuadro de dilogo.
.
InitialDirectory. Ruta inicial que mostrar el control al abrirse.
.
Filter. Cadena con el tipo de archivos que mostrar el cuadro de dilogo al navegar por el sistema de
archivos. El formato de esta cadena es el siguiente: NombreArchivo (*.Extensin)|*.Extensin; pudiendo situar varios
filtros separados por el carcter de barra vertical ( | ).
.
FilterIndex. Nmero que corresponde a alguno de los tipos de archivo establecidos en la propiedad
Filter.
.
FileName. Nombre del archivo en el que se realizar la escritura
.
DefaultExt. Cadena con la extensin por defecto a aplicar sobre el nombre del archivo.
.
CheckFileExists. Valor lgico que nos permite comprobar si el archivo sobre el que vamos a grabar
ya existe.
.
ValidateNames. Valor lgico que comprobar si el nombre de archivo proporcionado contiene
caracteres especiales, es decir, si se trata de un nombre vlido.
Al seleccionar en el formulario la opcin de men Grabar, ejecutaremos el Cdigo fuente 510, que nos
permitir, utilizando el control dlgGrabar, de tipo SaveFileDialog, seleccionar el nombre de un archivo, y grabar el
TextBox del formulario sobre el mismo, mediante un StreamWriter.
Private Sub
System.EventArgs)
mnuGuardar_Click(ByVal sender
Handles
'
configurar
por
Me.dlgGrabar.Filter
=
Me.dlgGrabar.FilterIndex
Me.dlgGrabar.ValidateNames
Me.dlgGrabar.ShowDialog()
cdigo
el
"Documento
'
As
System.Object, ByVal e As
mnuGuardar.Click
dilogo
de
grabacin
(*.doc)|*.doc|Texto
=
=
abrir
'
si
todo
es
correcto,
escribir
'
el
contenido
del
TextBox
en
'
las
propiedades
del
Dim
swEscritor
swEscritor
=
New
swEscritor.Write(Me.txtTexto.Text)
swEscritor.Close()
MessageBox.Show("Texto
grabado
el
cuadro
de
dilogo
mediante
un
objeto
Stream
el
archivo
indicado
por
cuadro
de
dilogo
As
IO.StreamWriter
IO.StreamWriter(Me.dlgGrabar.FileName)
en
End
Cdigo fuente 510 La
de
archivos
(*.txt)|*.txt"
2
True
archivo")
Sub
OpenFileDialog
Este control muestra el cuadro de dilogo del sistema, mediante el que seleccionamos un archivo para poder
abrirlo posteriormente, y realizar sobre el mismo operaciones de lectura-escritura.
Al igual que en el control anterior, la lectura y escritura de informacin es algo que deberemos realizar por
cdigo, una vez que hayamos elegido el archivo mediante este cuadro de dilogo
Las propiedades de este control son prcticamente las mismas que las de SaveFileDialog, con algunas
excepciones como las siguientes.
.
Multiselect. Contiene un valor lgico, que nos permitir la seleccin de mltiples archivos.
.
ShowReadOnly. Permite mostrar la casilla de verificacin para mostrar los archivos de slo lectura.
.
ReadOnlyChex. Permite obtener y establecer el valor para la casilla de verificacin de slo lectura
del cuadro de dilogo.
Al seleccionar en el formulario la opcin de men Abrir, ejecutaremos el Cdigo fuente 511, que nos permitir,
utilizando el control dlgAbrir, de tipo OpenFileDialog, seleccionar un archivo existente, y pasar su contenido al
TextBox del formulario, utilizando un StreamReader.
Private
Sub
System.EventArgs)
mnuAbrir_Click(ByVal
'
configurar
Me.dlgAbrir.Title
=
Me.dlgAbrir.InitialDirectory
Me.dlgAbrir.Filter
=
'
As
System.Object,
cuadro
"Seleccionar
de
dilogo
archivo
el
sender
Handles
=
"Cdigo
abrir
fuente
(*.vb)|*.vb|Texto
el
ByVal
e
As
mnuAbrir.Click
por
a
cdigo
leer"
"C:\CUBO"
(*.txt)|*.txt"
dilogo
Me.dlgAbrir.ShowDialog()
'
'
If
si
se
han
mostrar
Me.dlgAbrir.FileNames.Length
Dim
sArchivo
For
Each
sArchivo
In
MessageBox.Show("Archivo
seleccionado:
Next
End
'
abrir
'
y
Dim
srLector
Me.txtTexto.Text
el
As
seleccionado
su
>
archivos
nombre
Then
As
String
Me.dlgAbrir.FileNames
"
&
sArchivo)
primer
volcarlo
New
=
End
varios
If
archivo
con
un
Stream
al
TextBox
IO.StreamReader(Me.dlgAbrir.FileName)
srLector.ReadToEnd()
Sub
Formularios
avanzados
dependientes
controles
permite a travs de una serie de propiedades, que la configuracin de formularios dependientes sea un trabajo
realmente fcil y rpido de conseguir.
Por otra parte, un formulario fijo en primer plano, tambin denominado topmost form, consiste en un formulario
que siempre aparece en primer plano respecto al resto de formularios de la aplicacin. Se trata de una ligera variacin
de comportamiento respecto al formulario dependiente; mientras que este ltimo, en algunas ocasiones puede ser
tapado por otros formularios del programa, un formulario topmost siempre permanece visible en primer plano.
Para ilustrar el modo de creacin y funcionamiento de este tipos de formularios, se acompaa el proyecto de
ejemplo FormDependiente (hacer clic aqu para acceder al ejemplo), del que comentaremos los pasos principales para
su creacin.
Una vez creado este proyecto, eliminaremos su formulario por defecto, y aadiremos el formulario frmPrincipal,
que configuraremos como contenedor MDI, y al que aadiremos un men que nos permitir abrir un formulario hijo
para escribir un texto, y otro de dilogo para mostrar un literal. La Figura 304 muestra esta ventana MDI de la
aplicacin.
El siguiente paso consistir en crear el formulario frmCarta, que utilizaremos para abrir los formularios
dependientes que crearemos posteriormente en este proyecto. La Figura 305 muestra este formulario.
El Cdigo fuente 512 muestra el cdigo del men de frmPrincipal que instancia este objeto y lo muestra como
formulario hijo del MDI.
Private Sub
System.EventArgs)
'
este
mnuCarta_Click(ByVal sender
Handles
formulario
se
As
System.Object, ByVal e As
mnuCarta.Click
abre
como
hijo
del
MDI
Dim
ofrmCarta
As
New
ofrmCarta.MdiParent
frmCarta()
Me
ofrmCarta.Show()
End
Sub
A continuacin agregaremos al proyecto el formulario frmBuscar. Este formulario actuar como dependiente de
frmCarta, permitindonos buscar una cadena en el TextBox de este ltimo. La Figura 306 muestra el aspecto de
frmBuscar. Aunque no sera necesario, para adaptarlo mejor a su funcionamiento, hemos variado mediante la
propiedad FormBorderStyle, el estilo de su borde a ventana de herramientas con el valor FixedToolWindow.
Para conseguir que frmBuscar se comporte como formulario dependiente, al pulsar dentro de frmCarta el botn
Buscar, instanciaremos un objeto frmBuscar, aadindolo a la coleccin de formularios dependientes de frmCarta
mediante el mtodo AddOwnedForm( ), de la clase Form. El Cdigo fuente 513 muestra el cdigo del botn Buscar en
el formulario frmCarta.
Private Sub
System.EventArgs)
btnBuscar_Click(ByVal sender
Handles
'
crear
Dim
'
ofrmBuscar
establecer
As
System.Object, ByVal e As
btnBuscar.Click
un
As
dependencia
objeto
frmBuscar
New
frmBuscar()
entre
forms
Me.AddOwnedForm(ofrmBuscar)
ofrmBuscar.Show()
End
Sub
Podemos eliminar la asociacin entre un formulario propietario y uno dependiente mediante el mtodo
RemoveOwnedForm( ) en el formulario propietario. Esto no quiere decir que el formulario dependiente sea eliminado,
simplemente se elimina su dependencia con respecto al propietario.
En lo que respecta al cdigo de frmBuscar, al pulsar su botn Buscar, buscamos el contenido del control
txtBuscar en el formulario propietario frmCarta.
Si la bsqueda tiene xito, seleccionamos el texto encontrado dentro del propietario. La propiedad Owner del
formulario nos devuelve una referencia del propietario, mientras que para manipular los controles de dicho propietario,
realizaremos un moldeado de tipo o type casting sobre Owner utilizando la funcin CType( ) (observe el lector de
nuevo, la enorme potencia que encierra esta funcin).
Adems mostramos una etiqueta en el formulario dependiente, que slo se visualizar al localizar el texto;
cuando volvamos a escribir de nuevo texto a buscar, se ocultar dicha etiqueta. El Cdigo fuente 514 muestra los
mtodos de frmBuscar que llevan a cabo estas labores.
'
al
pulsar
este
botn,
buscamos
en
el
formulario
'
propietario
de
este
dependiente
Private
Sub
btnBuscar_Click(ByVal
sender
As
System.Object,
ByVal
e
As
System.EventArgs)
Handles
btnBuscar.Click
Dim
'
iResultadoBuscar
la
propiedad
Owner
As
contiene
el
Integer
formulario
propietario
iResultadoBuscar
=
CType(Me.Owner,
frmCarta).txtDocumento.Text.IndexOf(Me.txtBuscar.Text)
'
If
'
pasamos
'
y
CType(Me.Owner,
CType(Me.Owner,
CType(Me.Owner,
si
el
encontramos
iResultadoBuscar
foco
al
seleccionamos
el
texto
buscado...
>
0
Then
formulario
propietario
texto
encontrado
frmCarta).txtDocumento.Focus()
frmCarta).txtDocumento.SelectionStart
=
iResultadoBuscar
frmCarta).txtDocumento.SelectionLength
=
TextBox
el
del
Me.txtBuscar.Text.Length
Me.lblEncontrado.Show()
End
If
End
'
al
volver
a
teclear
un
valor
a
Private
Sub
txtBuscar_TextChanged(ByVal
sender
System.EventArgs)
Handles
Sub
buscar,
se
oculta
el
Label
As
System.Object,
ByVal
e
As
txtBuscar.TextChanged
Me.lblEncontrado.Hide()
End
Sub
La Figura 307 muestra la aplicacin con ambos formularios abiertos. El formulario frmCarta tiene el foco
actualmente, pero eso no impide que frmBuscar tambin permanezca abierto, para poder pasar a l en cualquier
momento.
Un formulario dependiente, aunque se muestra en todo momento encima de su propietario, puede ser ocultado
por otro formulario de la aplicacin. Para demostrarlo, aadiremos al proyecto el formulario frmDatosUsuario, que se
mostrar como cuadro de dilogo, visualizando un Label en su interior. Ver Figura 308.
El cdigo de la opcin de men de frmPrincipal que abre este formulario se muestra en el Cdigo fuente 515.
Private Sub
System.EventArgs)
mnuUsuario_Click(ByVal sender
Handles
As
System.Object, ByVal e As
mnuUsuario.Click
'
mostrar
Dim
este
ofrmUsuario
formulario
As
como
New
un
dilogo
frmDatosUsuario()
ofrmUsuario.ShowDialog()
End
Sub
Para lograr que un formulario se muestre en todo momento por encima del resto de formularios de la aplicacin,
hemos de asignar el valor True a su propiedad TopMost; obtenemos de esta manera, un formulario con estilo de
visualizacin fijo en primer plano.
Ilustraremos este particular aadiendo un nuevo formulario al proyecto, con el nombre frmPonerColor, en el que
asignaremos a su propiedad TopMost el valor True. Ver la Figura 310.
El Cdigo fuente 516 muestra el cdigo del botn Color de frmCarta, en el que se crea un formulario
frmPonerColor y se visualiza.
Private Sub
System.EventArgs)
'
abrir
Dim
btnColor_Click(ByVal sender
Handles
el
formulario
ofrmPonerColor
As
System.Object, ByVal e As
btnColor.Click
para
poner
As
New
color
al
texto
frmPonerColor(Me)
ofrmPonerColor.Show()
End
Sub
En este momento debemos hacer dos observaciones: en primer lugar, no aadimos el formulario frmPonerColor
a la coleccin de formularios dependientes del propietario; en segundo lugar, al instanciar el objeto frmPonerColor,
estamos pasando al constructor de esta clase la referencia del formulario propietario.
La explicacin a este modo de proceder la encontramos dentro del cdigo del formulario dependiente; en donde
aadimos dicho formulario, a la lista de formularios dependientes del propietario, utilizando la propiedad Owner de la
clase base Form. Esto tiene el mismo efecto que usar el mtodo AddOwnedForm( ). El Cdigo fuente 517 muestra el
constructor de la clase frmPonerColor, en donde llevamos a cabo esta operacin.
Public
Inherits
Class
System.Windows.Forms.Form
'....
'
'
Public
crear
un
el
Sub
New(ByVal
constructor
para
establecer
formulario
propietario
frmPropietario
As
frmCarta)
frmPonerColor
Me.New()
Me.Owner
End
frmPropietario
Sub
Al volver a ejecutar ahora el programa, si abrimos el formulario frmPonerColor y despus el cuadro de dilogo,
ser el formulario de configuracin de color el que prevalezca por encima, al ser dependiente y TopMost. Ver Figura
311.
Este formulario ser abierto tambin desde frmCarta, mediante su botn Color, y lo utilizaremos para cambiar el
color del control de texto de frmCarta. El Cdigo fuente 518 muestra el procedimiento manipulador de evento de los
controles RadioButton, en el que se realiza el cambio de color en el formulario propietario.
'
'
Private
Handles
Dim
en
Sub
este
mtodo
del
PonerColor(ByVal sender
rbtMadera.Click,
oColor
ponemos
el
color
formulario
As System.Object, ByVal e As
rbtVerde.Click,
As
al
TextBox
propietario
System.EventArgs)
rbtTurquesa.Click
Color
If
oColor
End
sender
If
oColor
End
sender
If
oColor
End
Is
Me.rbtMadera
Then
Color.BurlyWood
If
Is
Me.rbtVerde
Then
Color.MediumSpringGreen
If
sender
Is
=
CType(Me.Owner,
Me.rbtTurquesa
Then
Color.Turquoise
If
frmCarta).txtDocumento.BackColor
oColor
End
Sub
Para finalizar con los formularios dependientes, debemos indicar que la clase Form dispone de la propiedad
OwnedForms, que contiene una coleccin con los formularios dependientes de un formulario que acte como
propietario.
Ya que en este ejemplo es el formulario frmCarta el que se comporta como propietario, aadiremos un botn
con el nombre btnDependientes, que nos permitir recorrer la mencionada coleccin, y hacer, desde el propietario, una
manipulacin sobre los formularios dependientes, en el caso de que haya alguno abierto. El Cdigo fuente 519 muestra
el cdigo de este botn.
Private Sub
System.EventArgs)
'
Dim
Dim
btnDependientes_Click(ByVal
Handles
obtener
los
oFormularios()
As
oFormulario
'
If
'
'
For
sender
si
oFormularios.Length
recorrer
la
manipular
los
Each
oFormulario
Select
As
System.Object, ByVal e As
btnDependientes.Click
formularios
Form
As
existen
dependientes...
>
Then
y
dependientes
oFormularios
0
coleccin
formularios
In
Case
Case
CType(oFormulario,
CType(oFormulario,
"LOCALIZADO!"
Case
CType(oFormulario,
dependientes
Me.OwnedForms
Form
oFormulario.GetType().Name
"frmBuscar"
frmBuscar).lblEncontrado.Show()
frmBuscar).lblEncontrado.Text
=
frmPonerColor).rbtTurquesa.Text
"frmPonerColor"
"AZULADO"
CType(oFormulario,
frmPonerColor).rbtTurquesa.BackColor
Color.Blue
'
con
'
CType(oFormulario,
el
mtodo
simulamos
PerformClick()
de
un
control,
una
pulsacin
frmPonerColor).rbtTurquesa.PerformClick()
End
Select
Next
End
If
End
Sub
Validacin de controles
Los controles Windows vienen provistos de un potente y flexible sistema de validacin, que nos permitir
comprobar si el usuario introduce los valores adecuados en un control, de modo que le permitiremos pasar el foco a
otro control, u obligarle a permanece en el actual hasta que su valor no sea correcto.
En este esquema de validacin, los miembros principales de la clase Control que intervienen son los siguientes.
.
CausesValidation. Esta propiedad nos permite establecer un valor lgico, de manera que cuando un
control capture el foco, provocar la validacin para otro control del formulario que la requiera.
.
Validating. Este evento se produce para que podamos escribir el cdigo de validacin oportuno en un
manipulador de evento. El procedimiento manejador de evento recibe entre sus parmetros un objeto de tipo
CancelEventArgs, por lo que si la validacin no es correcta, asignaremos False a la propiedad Cancel de dicho objeto.
.
Validated. Este evento se produce en el caso de que la validacin haya tenido xito.
El proyecto de ejemplo ValidarControl (hacer clic aqu para acceder a este ejemplo) consta de un formulario con
tres controles TextBox. Todos tienen el valor True en su propiedad CausesValidation, y adicionalmente, para el
control txtImporte hemos escrito el procedimiento que actuar como manipulador del evento Validating; con ello
impediremos el paso desde dicho control a los dems hasta que su contenido no sea numrico. Si pasamos la
validacin, se ejecutar en ese caso el cdigo del evento Validated. Veamos estos manipuladores de evento en el
Cdigo fuente 520.
If
Not
MessageBox.Show("Se
Object, ByVal e As
txtImporte.Validating
IsNumeric(Me.txtImporte.Text)
e.Cancel
End
As
=
requiere
Then
True
un
nmero")
If
End
Sub
La Figura 312 muestra esta aplicacin en funcionamiento, durante la ejecucin del evento de validacin.
En el control txtFecha por otro lado, podemos teclear cualquier valor, aunque no sea fecha, ya que no
proporcionamos manipuladores de evento para validar su contenido.
Cuando escribimos cdigo de validacin empleando estos miembros de la clase Control hemos de tener presente
el comportamiento, a veces no muy intuitivo, del sistema de validacin para controles en los formularios Windows.
Como hemos mencionado anteriormente, cuando la propiedad CausesValidation de un control contiene True, al
recibir el foco dicho control, se provocar el evento de validacin para el control que acaba de perder el foco. Pero si
pasamos el foco a un control en el que CausesValidation contiene False, la validacin no se producir sobre el control
que acaba de perder el foco.
Esto lo podemos comprobar muy fcilmente sobre nuestro proyecto de ejemplo, asignando al control txtFecha el
valor False en su CausesValidation. A partir de ahora, cuando estemos situados en el control txtImporte, si este no
contiene un nmero, se producir la validacin si pasamos el foco a txtNombre, pero no se validar si pasamos a
txtFecha.
Controles avanzados
Los controles del Cuadro de herramientas del IDE tratados hasta el momento, son los que podramos considerar
bsicos o estndar en todas las aplicaciones; no obstante, esta ventana de herramientas dispone de otra serie de
controles avanzados o adicionales, que si bien, no son imprescindibles para conseguir la funcionalidad elemental del
programa, sirven como un magnfico complemento a la hora de dotar a nuestras aplicaciones de un interfaz de usuario
plenamente operativo.
En los siguientes apartados desarrollaremos un proyecto con el nombre ControlAvanzado (hacer clic aqu para
acceder a este ejemplo), a travs del cual, realizaremos una descripcin general de algunos de estos controles
adicionales y su modo de uso.
Como primer paso en este proyecto, eliminaremos el formulario por defecto, aadiendo a continuacin uno
nuevo con el nombre frmPrincipal, al que daremos la caracterstica MDI mediante la propiedad IsMdiContainer. En
este formulario crearemos un men con un conjunto de opciones generales: Abrir, Guardar, Salir, etc.
ImageList
Este control acta como repositorio de imgenes, del que se alimentarn otros controles del formulario que
necesiten mostrar grficos en su interior.
Una vez aadido este control en el formulario, se situar en el panel de controles especiales del diseador, y
haciendo clic en su propiedad Images, se abrir la ventana de la Figura 313, en la que podremos aadir y quitar las
imgenes que van a formar parte de la lista del control, as como ver en el panel complementario, la informacin sobre
cada imagen asignada.
Las imgenes que insertamos en el control tienen un tamao por defecto, en el caso de que necesitemos
modificarlo, expandiremos la propiedad ImageSize en la ventana de propiedades y asignaremos nuevos valores en
Width y Height.
Otra ventaja de este control es que nos permite manipular las imgenes por cdigo, por ejemplo, para aadir
nuevas imgenes, debemos usar el mtodo Add( ) de su propiedad Images, como muestra el Cdigo fuente 521.
Me.imlImagenes.Images.Add(New
Bitmap("tutorias.gif"))
ToolBar
Este control representa la barra de herramientas o botones de acceso rpido que facilitan al usuario la ejecucin
de los procesos principales del programa, evitndole la navegacin por el men del formulario.
Al ser dibujado, este control queda acoplado a la parte superior del formulario. Despus de ponerle tbrBarra
como nombre, asignaremos a su propiedad ImageList, el control de ese mismo tipo que acabamos de crear; esto nos
permitir asignar los grficos de la lista a los botones que vayamos creando en el ToolBar. Para establecer el tamao
de los botones de la barra utilizaremos la propiedad ButtonSize de este control.
Seguidamente haremos clic en la propiedad Buttons, que abrir una ventana con la coleccin de botones de la
barra, en la que podremos crear y configurar dichos botones. Ver Figura 314.
Cada botn en un ToolBar es un objeto de tipo ToolBarButton, del que podemos destacar las siguientes
propiedades.
.
Text. Cadena con el texto que muestra el botn.
.
ImageIndex. En el caso de asociar el ToolBar con un control ImageList, en esta propiedad asignamos
para un botn una de las imgenes del ImageList, indicando el nmero de orden de la imagen.
.
Style. Permite establecer el estilo del botn: de pulsacin; separador; o de tipo desplegable, que abre
un subconjunto de opciones.
.
DropDownMenu. Si asociamos el botn con una opcin de la barra de men del formulario, y
configuramos su estilo como DropDownButton, al pulsar el botn desplegable, se mostrarn las opciones de men; el
efecto ser el mismo que si hubiramos desplegado directamente el men del formulario.
La Figura 315 muestra la ventana principal de la aplicacin con la barra de herramientas
Una vez terminado el diseo del ToolBar, debemos codificar su evento ButtonClick, que ser provocado cada
vez que se pulse un botn de la barra. Dentro del procedimiento de este evento, comprobaremos qu botn ha sido
pulsado y ejecutaremos las acciones oportunas. El Cdigo fuente 522 muestra este evento. Tanto el botn Abrir como
la opcin de men del mismo nombre realizan la misma tarea, por lo que llaman al mtodo AbrirArchivo( ), que es
quien realmente muestra el formulario necesario.
'
comprobar
qu
If
e.Button
'
llamamos
al
'
formulario
Me.AbrirArchivo()
botn
de
As System.Object, ByVal e As
Handles
tbrBarra.ButtonClick
la
barra
Is
mtodo
para
abrir
se
Me.btnAbrir
que
un
ha
abre
End
pulsado
Then
el
archivo
If
If
'
Me.Close()
e.Button
cerrar
Is
Me.btnSalir
Then
aplicacin
la
End
If
End
Sub
Private
Sub
mnuAbrir_Click(ByVal
sender
As
System.Object,
ByVal
As
System.EventArgs)
Handles
'
al
'
llamar
'
que
Me.AbrirArchivo()
al
mnuAbrir.Click
seleccionar
mtodo
permite
esta
que
opcin
abre
abrir
de
el
un
End
men
formulario
archivo
Sub
Private
Sub
Dim
ofrmAbrirArchivo
AbrirArchivo()
As
New
ofrmAbrirArchivo.MdiParent
frmAbrirArchivo()
Me
ofrmAbrirArchivo.Show()
End
Sub
Cdigo fuente 522
Al haber asignado al botn btnPersonal uno de los mens de la barra del formulario, no ser necesario escribir
cdigo para detectar este botn en el evento ButtonClick, ya que se ejecutar directamente el cdigo del evento Click
de las opciones de men. El Cdigo fuente 523 muestra el cdigo perteneciente a la opcin de men Personal +
Datos.
Private Sub
System.EventArgs)
mnuDatos_Click(ByVal sender
Handles
Dim
ofrmPersonal
ofrmPersonal.MdiParent
As
System.Object, ByVal e As
mnuDatos.Click
As
New
=
frmDatosPersonal()
Me
ofrmPersonal.Show()
End
Sub
StatusBar
Para mostrar una barra informativa de estado recurriremos a este control, que al dibujarse queda situado en la
parte inferior del formulario; como nombre le daremos sbrEstado. De forma similar al ToolBar, un control StatusBar
est compuesto de una coleccin de objetos Panel, que iremos aadiendo al control mediante la propiedad Panels, la
cual mostrar una ventana para la creacin y configuracin de tales paneles. Ver Figura 316.
Entre las propiedades destacables de un objeto Panel podemos mencionar las siguientes.
.
BorderStyle. Muestra el panel con efecto resaltado, hundido o normal.
.
Icon. Permite asociar un icono al panel.
.
AutoSize. Con esta propiedad podemos conseguir que el panel se redimensione ajustndose a su
contenido o que tenga un tamao fijo.
En este ejemplo, hemos aadido dos paneles a la barra de estado del formulario. En uno mostramos un texto
fijo; mientras que en el otro, visualizamos la hora actual a travs de un objeto Timer que ponemos en marcha en el
evento Load del formulario. Veamos los mtodos implicados, en el Cdigo fuente 524.
Private
Handles
Sub
frmPrincipal_Load(ByVal
'
al
cargar
el
'
le
asociamos
un
'
y
Dim
oTiempo
oTiempo.Interval
AddHandler
oTiempo.Tick,
oTiempo.Start()
sender
As
Object,
formulario,
manejador
ByVal
As
creamos
para
su
lo
New
As
System.EventArgs)
MyBase.Load
un
=
AddressOf
temporizador
evento
Tick
iniciamos
Timer()
1000
PonerHoraActual
End
Private
Sub
Sub
PonerHoraActual(ByVal
'
actualizamos
'
de
Me.sbrEstado.Panels(1).Text
End
sender
cada
la
As
Object,
segundo
la
barra
=
ByVal
As
EventArgs)
hora
de
un
panel
de
estado
DateTime.Now.ToString("HH:mm:ss")
Sub
Finalizada la creacin del StatusBar, aadiremos al proyecto un formulario con el nombre frmDatosPersonal, en
el dibujaremos un conjunto de nuevos controles que iremos describiendo seguidamente.
DateTimePicker
Este control permite la seleccin e introduccin de fechas en una caja de texto con capacidades extendidas, o
bien mediante un calendario desplegable que se mostrar al pulsar el botn de expansin que contiene. Ver Figura 318.
Para modificar la fecha en el cuadro de texto, debemos situarnos en la parte a modificar de la fecha y teclear el
nuevo valor, o bien, con las flechas de direccin arriba-abajo, cambiar esa parte de la fecha. Si expandimos el
calendario, podremos realizar la seleccin de un modo ms grfico.
Por defecto el control muestra la fecha actual, pero con la propiedad Text podemos cambiar la fecha por cdigo,
cosa que hacemos al cargar el formulario, asignando una fecha distinta de la actual. Ver Cdigo fuente 525.
Private Sub
System.EventArgs)
'
frmDatosPersonal_Load(ByVal sender
Handles
modificar
As
fecha
Me.dtpFNacim.Text
Object,
ByVal e As
MyBase.Load
del
DateTimePicker
"15/06/2002"
'....
End
Sub
Cdigo fuente 525
Podemos restringir el rango de fechas a mostrar por este control con las propiedades MinDate y MaxDate. Si
queremos, por otra parte, que la fecha se muestre con un formato personalizado, aplicaremos dicho formato mediante
la propiedad CustomFormat, teniendo en cuenta que no se har efectivo hasta que a la propiedad Format no le
asignemos el valor Custom.
El botn btnCambiosFecha del formulario realiza algunas modificaciones por cdigo sobre el control
DateTimePicker dtpFNacim del formulario, que vemos en el Cdigo fuente 526.
Private Sub
System.EventArgs)
btnCambiosFecha_Click(ByVal
Handles
'
configurar
'
Me.dtpFNacim.MinDate
Me.dtpFNacim.MaxDate
Me.dtpFNacim.CustomFormat
Me.dtpFNacim.Format
sender
As
por
System.Object, ByVal e As
btnCambiosFecha.Click
cdigo
control
=
=
=
=
End
el
DateTimePicker
"1/4/2002"
"1/10/2002"
"d-MMM-yy"
DateTimePickerFormat.Custom
Sub
NumericUpDown
Control que muestra una caja de texto con un valor numrico que podremos ir aumentandodisminuyendo al
pulsar los botones para esta labor de que dispone el control. La Figura 319 muestra este control en nuestro formulario
de pruebas.
.
InterceptArrowKeys. Permite que las flechas de direccin arriba-abajo tengan el mismo efecto que si
pulsamos los botones para incrementar o disminuir, de este control.
.
Maximum, Minimun. Contienen los lmites superior e inferior en cuanto al nmero que podr
contener el control.
.
TextAlign. Permite alinear el nmero dentro la caja de texto del control.
.
UpDownAlign. Permite situar los botones del control a la izquierda o derecha de la caja de texto que
contiene el valor.
Entre los eventos de que dispone este control, ValueChanged se produce cada vez que cambia el valor del
control, de modo que en este caso, vamos a cambiar el color de fondo en funcin del nmero que contenga. Veamos el
Cdigo fuente 527.
Private Sub
System.EventArgs)
nupEdad_ValueChanged(ByVal sender
Handles
Select
Case
Me.nupEdad.BackColor
As
Case
20
Case
Me.nupEdad.BackColor
End
Me.nupEdad.Value
30
Color.Gold
To
=
Case
Me.nupEdad.BackColor
System.Object, ByVal e As
nupEdad.ValueChanged
30
To
40
Color.LimeGreen
=
Else
Me.nupEdad.DefaultBackColor
Select
End
Sub
DomainUpDown
Este control nos permite desplazarnos por una lista de valores, al mismo estilo que el control anterior. Dicha
lista de valores la crearemos mediante la propiedad Items, en tiempo de diseo o ejecucin.
El Cdigo fuente 528 muestra como al cargar el formulario frmDatosPersonal, con la propiedad Items y su
mtodo AddRange( ), aadimos los valores que seleccionaremos en el control en tiempo de ejecucin.
Private Sub
System.EventArgs)
frmDatosPersonal_Load(ByVal sender
Handles
As
Object,
ByVal e As
MyBase.Load
'....
'
crear
la
Me.dudCategoria.Items.AddRange(New
"Coordinador"})
lista
String()
{"Auxiliar",
del
"Jefe
DomainUpDown
departamento",
End
Sub
La Figura 320 muestra el control dudCategora, de este tipo al ser utilizado en el formulario. En el caso de que
necesitemos los valores ordenados, asignaremos True a su propiedad Sorted.
MonthCalendar
Este control muestra en modo grfico un calendario por el que podemos desplazarnos para seleccionar una
fecha. El control DateTimePicker utiliza internamente un MonthCalendar para mostrar su calendario desplegable.
Por defecto se visualiza un mes, pero si asignamos a su propiedad CalendarDimensions un objeto Size, podemos
expandir el tamao del calendario para que muestre varios meses. El Cdigo fuente 529 muestra el cdigo de un botn
del formulario mediante el que cambiamos el tamao del calendario.
Private Sub
System.EventArgs)
btnTamCalendario_Click(ByVal
Handles
Me.mclCalendario.CalendarDimensions
sender
=
As
System.Object, ByVal e As
btnTamCalendario.Click
New
Size(2,
End
Cdigo fuente 529 En
2)
Sub
Para detectar la seleccin de una fecha utilizaremos el evento DateChanged. Debido a que en un control
MonthCalendar podemos seleccionar un rango de fechas, las propiedades que tenemos que manipular para averiguar la
fecha/s seleccionada/s son: SelectionStart, SelectionEnd y SelectionRange, aunque en muchas ocasiones slo ser
necesario utilizar una de ellas. Veamos el Cdigo fuente 530.
'
mostrar
'
en
Me.lblCalendario.Text
End
en
un
el
Label
=
As
System.Object, ByVal e As
mclCalendario.DateChanged
la
control
fecha
seleccionada
MonthCalendar
Me.mclCalendario.SelectionStart
Sub
LinkLabel
Este control permite tener en un formulario Windows un enlace hacia una pgina de Internet, con un
comportamiento similar al que encontramos en un hiperenlace de una pgina web.
Su propiedad Text muestra un literal, de modo que al hacer clic sobre el mismo, se provocar el evento
LinkClicked en el que escribiremos el cdigo a ejecutar.
En nuestro formulario de ejemplo, hemos creado un control de este tipo con el nombre lnkEidos, que tiene el
aspecto de la Figura 322, ya que adems del enlace, le hemos asignado una imagen.
Para conseguir que al hacer clic en este enlace, se abra Internet Explorer y navegue hacia una determinada
pgina, vamos a utilizar la clase Process, que como su nombre indica, nos permite la gestin de procesos del sistema,
tales como su inicio y finalizacin.
En este caso, el mtodo compartido Start( ), de Process, va a ejecutar el navegador al pasarle como parmetro
una direccin web en forma de cadena. Veamos el Cdigo fuente 531.
Private
Sub
lnkEidos_LinkClicked(ByVal
sender
System.Windows.Forms.LinkLabelLinkClickedEventArgs)
'
inicia
Internet
Explorer
As
System.Object,
ByVal
e
As
Handles
lnkEidos.LinkClicked
navega
hacia
una
pgina
Process.Start("http://www.eidos.es")
End
Sub
Private Sub
System.EventArgs)
'
mnuAgregaElementos(ByVal sender
Handles
aadir
por
cdigo
As
System.Object, ByVal e As
mnuAgregar.Click
imgenes
la
lista
Me.imlImagenes.Images.Add(New
Bitmap("tutorias.gif"))
Me.imlImagenes.Images.Add(New
Bitmap("camera1.gif"))
Dim
oBoton
oBoton.Text
oBoton.ImageIndex
Me.tbrBarra.Buttons.Add(oBoton)
As
New
=
ToolBarButton()
"TUTORIAS"
Dim
oPanel
As
oPanel.Text
oPanel.BorderStyle
oPanel.ToolTipText
=
oPanel.Icon
=
Me.sbrEstado.Panels.Add(oPanel)
New
=
StatusBarPanel()
"BUSCAR"
StatusBarPanelBorderStyle.Raised
sobre
bsquedas"
Icon("magnify.ico")
=
"Informacin
New
End
Sub
Para detectar la pulsacin del nuevo botn de la barra de herramientas, aadimos el siguiente cdigo en su
evento ButtonClick, que vemos en el Cdigo fuente 533.
Private
Sub
tbrBarra_ButtonClick(ByVal
sender
System.Windows.Forms.ToolBarButtonClickEventArgs)
'....
If
e.Button.Text
MessageBox.Show("Se
ha
el
System.Object,
Handles
=
pulsado
As
botn
de
tutoras")
If
Sub
La Figura 323 muestra este formulario en ejecucin tras aadir los nuevos elementos.
NotifyIcon
tbrBarra.ButtonClick
"TUTORIAS"
End
End
ByVal
Then
As
Este control permite aadir un icono asociado con nuestra aplicacin en el panel de iconos del sistema
(Windows System Tray) situado en la parte derecha de la barra de tareas de Windows.
Tales iconos suelen utilizarse por aplicaciones que permanecen ocultas, y al hacer clic derecho sobre su icono en
este panel, aparece un men contextual que permite mostrar la aplicacin.
En nuestro caso vamos a utilizar este control para ejecutar y parar la calculadora del sistema empleando la clase
Process, comentada en un apartado anterior.
Despus de agregar un control de este tipo al formulario, asignaremos un icono a su propiedad Icon y una
cadena a su propiedad Text, que ser mostrada al situar el ratn encima de este control en tiempo de ejecucin.
Crearemos despus un men contextual con las opciones Abrir y Cerrar, que asignaremos a la propiedad
ContextMenu del control NotifyIcon.
Para poder controlar la calculadora de Windows cuando est en ejecucin, declararemos una variable de tipo
Process a nivel de la clase. Al ejecutar la calculadora mediante el mtodo Start( ) de la clase Process, obtendremos un
objeto de dicho tipo, que pasaremos a esta variable, y nos permitir posteriormente, cerrar el proceso en el que se est
ejecutando la calculadora mediante el mtodo Kill( ). Veamos esta parte en el Cdigo fuente 534.
Public
Inherits
Private
Class
frmPrincipal
System.Windows.Forms.Form
oCalculadora
As
Process
'....
Private Sub
System.EventArgs)
'
oCalculadora
mnuCalcAbrir_Click(ByVal sender
Handles
As
iniciar
System.Object, ByVal e As
mnuCalcAbrir.Click
la
=
calculadora
Process.Start("calc.exe")
End
Private Sub
System.EventArgs)
'
oCalculadora.Kill()
Sub
mnuCalcCerrar_Click(ByVal sender
Handles
cerrar
As
System.Object, ByVal e As
mnuCalcCerrar.Click
la
calculadora
End
Sub
End
Class
Al ejecutar el programa, se mostrar un nuevo icono en la lista del panel de iconos del sistema de la barra de
tareas, como muestra la Figura 324.
Figura 324. Control NotifyIcon en el panel de iconos del sistema de la barra de tareas.
Como puede comprobar el lector, la clase Process ampla enormemente nuestra capacidad de manipulacin de
los procesos del sistema.
grficos, el programador gana en flexibilidad, ya que no debe preocuparse de si el grfico generado se va a mostrar por
el monitor, impresora, etc.; esta labor es resuelta por GDI+, que asla el programa del hardware a manejar.
GDI+ divide su campo de trabajo en tres reas principales.
. Generacin de grficos vectoriales 2D
. Manipulacin de imgenes en los formatos grficos ms habituales.
. Visualizacin de texto en un amplio abanico de tipos de letra.
En versiones anteriores del lenguaje, el objeto Form dispona de una serie de mtodos y controles para el dibujo
sobre la superficie del formulario. La mayor parte de esos elementos han desaparecido en la actual versin de VB,
integrndose todas las operaciones de dibujo en las clases de .NET Framework; con ello, lo que aprendamos sobre
trabajo con grficos en VB.NET utilizando GDI+, nos servir igualmente si en un futuro debemos abordar un proyecto
en otro lenguaje de la plataforma, ya que las clases pertenecen a .NET Framework y no a un lenguaje en particular.
Otro problema con el que nos enfrentbamos anteriormente era el hecho de que al necesitar alguna
manipulacin grfica especial, tenamos que recurrir al API de Windows. A partir de ahora esto no ser necesario, ya
que como hemos comentado, es el propio entorno de ejecucin de .NET el que nos proporciona dicho acceso, por lo
que no ser necesario acudir al API del sistema operativo.
System.Drawing
Para utilizar las clases relacionadas con la manipulacin de grficos, es preciso importar este espacio de
nombres.
System.Drawing contiene el conjunto de clases principales, aunque no es el nico namespace de GDI+; para
tareas de mayor especializacin con grficos deberemos recurrir a alguno de los siguientes espacios de nombre que
estn dentro de System.Drawing: Drawing2D, Imaging y Text.
'
Dim
oPen
'
'
Dim
As
crear
New
objeto
Pen(Color.DeepPink,
obtener
el
contexto
grfico
del
oGraphics
As
Graphics
=
'
dibujar
oGraphics.DrawEllipse(oPen,
Pen
10)
de
dispositivo
formulario
Me.CreateGraphics()
en
el
Rectangle(150,
New
formulario
100,
100))
20,
Asociando este cdigo a la pulsacin de un botn en el formulario, el resultado ser el dibujo del crculo
mostrado en la Figura 325.
Sin embargo, el dibujo de figuras de esta manera tiene un inconveniente, puesto que si el formulario es ocultado
parcial o totalmente por otro, la zona ocultada se dice que ha quedado invalidada, y requiere un repintado, labor que
actualmente, no indicamos que se haga en el cdigo del formulario.
Para mantener las figuras dibujadas en el formulario en todo momento, debemos recurrir al evento Paint( ) de la
clase Form. Dicho evento se produce cada vez que el formulario necesita repintarse porque parte o la totalidad de su
superficie ha quedado invalidada
Vamos por lo tanto a observar las diferencias codificando el mencionado evento Paint( ), en el que dibujaremos
un rectngulo. Ver Cdigo fuente 536.
'
crear
Dim
oPen
'
'
'
'
'
Dim
sender As Object,
Handles
As
obtener
en
los
grfico
este
caso
argumentos
contexto
oGraph
New
ByVal e As
MyBase.Paint
objeto
Pen(Color.MediumVioletRed,
el
contexto
del
usaremos
el
de
evento
de
As
Graphics
de
objeto
para
que
obtener
=
Pen
6)
dispositivo
formulario;
contiene
dicho
dispositivo
e.Graphics
'
dibujar
oGraph.DrawRectangle(oPen,
New
en
Rectangle(40,
el
80,
70,
formulario
70))
End
Sub
Al ejecutar el programa, el rectngulo ser mostrado en todo momento, aunque minimicemos el formulario, lo
ocultemos parcial, totalmente, etc., ya que este evento se ejecuta automticamente cada vez que el formulario detecta
que su superficie ha quedado invalidada y necesita repintarse. La Figura 326 muestra el formulario con ambas figuras
dibujadas, si ocultamos y mostramos de nuevo la ventana, comprobaremos como el crculo ha desaparecido mientras
que el rectngulo persiste.
Figura 326. Figuras dibujadas en la superficie del formulario desde un botn y el evento Paint.
El proyecto GraficosGDI (hacer clic aqu para acceder a este ejemplo), contiene a travs de las opciones de sus
mens, el conjunto de operaciones de dibujo que describiremos seguidamente.
Mediante el men Dibujo con Pen, dibujaremos un crculo, rectngulo, curva, polgono, etc. Consulte el lector
sus opciones para comprobar el cdigo para cada tipo de figura. A continuacin comentaremos las ms destacables.
Al dibujar un rectngulo vamos a modificar el estilo de lnea mediante la propiedad DashStyle. Esta propiedad
contiene una enumeracin con la que podemos hacer que la lnea se muestre como guiones, guiones y puntos, etc. Ver
Cdigo fuente 537.
Private Sub
System.EventArgs)
mnuPenRectangulo_Click(ByVal
Handles
'
Dim
oPen
'
aplicar
un
'
DashStyle
oPen.DashStyle
crear
As
sender
New
estilo
=
de
-->
As
System.Object, ByVal e As
mnuPenRectangulo.Click
objeto
Pen(Color.Firebrick,
lnea
Pen
4)
con
la
propiedad
guin,
punto
Drawing.Drawing2D.DashStyle.DashDot
'
'
Dim
obtener
el
grfico
oGraphics
As
'
dibujar
oGraphics.DrawRectangle(oPen,
New
contexto
del
Graphics
de
=
en
Rectangle(280,
dispositivo
formulario
Me.CreateGraphics()
el
75,
120,
End
formulario
40))
Sub
Si queremos aplicar ms estilos a la lnea del objeto Pen, disponemos tambin de las propiedades StartCap,
EndCap, DashCap. El Cdigo fuente 538 muestra el dibujo de una curva con varios efectos de lnea. Al dibujar una
curva, necesitamos pasar al mtodo DrawCurve( ) un array de tipos Point, con las coordenadas de referencia a usar
para el dibujo de la curva.
Private Sub
System.EventArgs)
mnuPenCurva_Click(ByVal sender
Handles
'
Dim
crear
As
oPen
'
oPen.DashStyle
oPen.StartCap
oPen.EndCap
oPen.DashCap
estilo
=
=
obtener
el
grfico
'
'
Dim
oPuntos(0)
oPuntos(1)
oPuntos(2)
oPuntos(3)
oPuntos(4)
objeto
Pen(Color.MediumPurple,
=
=
oGraphics
crear
As
un
oPuntos(4)
'
dibujar
oGraphics.DrawCurve(oPen,
End
de
dibujar
New
New
New
New
New
en
Pen
5)
de
lnea
Drawing.Drawing2D.DashStyle.DashDot
Drawing.Drawing2D.LineCap.Triangle
Drawing.Drawing2D.LineCap.DiamondAnchor
Drawing.Drawing2D.DashCap.Triangle
contexto
del
Graphics
array
para
=
=
=
=
=
System.Object, ByVal e As
mnuPenCurva.Click
New
configurar
'
'
Dim
As
de
=
dispositivo
formulario
Me.CreateGraphics()
puntos-coordenadas
una
As
Point(10,
Point(40,
Point(100,
Point(130,
Point(200,
el
necesario
curva
Point
200)
100)
20)
100)
200)
formulario
oPuntos)
Sub
En cuanto a las curvas de tipo Bezier, el mtodo DrawBezier( ) recibe como parmetros, el objeto Pen y una
lista de coordenadas para el dibujo. Ver el Cdigo fuente 539.
Private Sub
System.EventArgs)
mnuPenBezier_Click(ByVal sender
Handles
As
'
dibujar
curva
Dim
oGraphics
As
Graphics
oGraphics.DrawBezier(New
Pen(Color.MediumSeaGreen,
200,
System.Object, ByVal e As
mnuPenBezier.Click
estilo
2),
=
20,
45,
Bezier
Me.CreateGraphics()
100,
90,
140,
300,
25)
End
Sub
La Figura 327 muestra todas las formas dibujadas con objetos Pen.
Si en un momento dado, necesitamos borrar los elementos grficos dibujados en la superficie del formulario,
utilizaremos el mtodo Invalidate( ) de la clase Form, que en este ejemplo est disponible en la opcin de men Abrir
+ Borrar. Ver Cdigo fuente 540.
Private
Sub
mnuBorrar_Click(ByVal
System.EventArgs)
'
borrar
las
figuras
Me.Invalidate()
Handles
dibujadas
en
sender
System.Object,
ByVal
As
mnuBorrar.Click
el
formulario
End
Cdigo fuente 540 Figura 327. Figuras dibujadas con objetos de la clase Pen.
La clase Brush
As
Sub
Esta clase representa un objeto de tipo brocha, utilizado para rellenar de diferentes formas, las figuras dibujadas
sobre el formulario.
Se trata de una clase abstracta, por lo que tendremos que utilizar alguna de sus diversas clases derivadas, segn
el estilo de brocha que necesitemos aplicar. Debido a las caractersticas 2D de algunas de estas clases, tendremos que
importar en nuestro cdigo el espacio de nombres Drawing2D.
Los mtodos de la clase Graphics que utilizaremos para dibujar con brochas sern los que comienzan por el
nombre FillXXX( )
El men Dibujo con Brush del formulario de este ejemplo, muestra algunas de las operaciones de dibujo y
estilos de relleno, que podemos aplicar con las clases de tipo Brush.
La clase ms bsica es SolidBrush, que permite rellenar en un estilo sencillo un rea dibujada. Ver el Cdigo
fuente 541.
Private Sub
System.EventArgs)
mnuBrushSolid_Click(ByVal sender
Handles
Dim
oBrush
Dim
oGraphics
As
As
System.Object, ByVal e As
mnuBrushSolid.Click
New
As
SolidBrush(Color.MidnightBlue)
Graphics
oGraphics.FillRectangle(oBrush,
New
Rectangle(150,
Me.CreateGraphics()
160,
150,
End
50))
Sub
A continuacin tenemos la clase HatchBrush, que permite la creacin de brochas que al pintar aplican un efecto
de tramado con un color de fondo y frente. Ver el Cdigo fuente 542.
Private Sub
System.EventArgs)
'
'
'
mnuBrushHatch_Click(ByVal sender
Handles
pintar
para
'
Dim oHatchBrush
Color.Aqua)
con
utilizar
necesitamos
As
System.Object, ByVal e As
mnuBrushHatch.Click
brocha
este
importar
crear
objeto
New HatchBrush(HatchStyle.Vertical,
'
dibujar
Dim
oGraphics
As
oGraphics.FillEllipse(oHatchBrush,
End
As
y
New
de
tipo
tipo
hatch;
de
brocha
System.Drawing.Drawind2D
HatchBrush
Color.Fuchsia,
pintar
Graphics
=
Rectangle(25,
un
40,
polgono
Me.CreateGraphics()
150,
50))
Sub
Podemos emplear un bitmap como base para la zona de relleno que tendr que pintarse, para ello usaremos la
clase TextureBrush, pasndole como parmetro un objeto Bitmap, que previamente habremos creado, y que contendr
un fichero con la textura necesaria. Ver Cdigo fuente 543.
Private Sub
System.EventArgs)
mnuBrushTextura_Click(ByVal
Handles
'
sender
As
System.Object, ByVal e As
mnuBrushTextura.Click
crear
Dim
un
oBitmap
'
crear
oTextureBrush
Dim
New
bitmap
Bitmap("textura1.bmp")
brocha
New
de
textura
TextureBrush(oBitmap)
As
una
As
'
dibujar
una
figura
Dim
oGraphics
As
oGraphics.FillEllipse(oTextureBrush,
pintarla
con
la
Graphics
=
New
Rectangle(220,
brocha
de
textura
Me.CreateGraphics()
15,
100,
75))
End
Sub
Para efectos avanzados de relleno, consistentes en degradados de colores, utilizaremos las clases
LinearGradientBrush y PathGradientBrush. Una vez creado un objeto Brush de estas clases, aplicaremos un conjunto
de colores que sern mezclados para crear un efecto de degradado o fundido en el rea a pintar, mediante el
constructor y/o las propiedades de la clase que corresponda. Ver Cdigo fuente 544.
'
pintar
figura
con
Private
Sub
mnuBrushLinearG_Click(ByVal
sender
System.EventArgs)
Handles
'
crear
Dim
oLGB
As
New
Color.Aquamarine,
'
brocha
de
LinearGradientBrush(New
Color.Azure,
crear
Dim
brocha
LinearGradientBrush
As
System.Object,
ByVal
e
As
mnuBrushLinearG.Click
tipo
LinearGrad.
Rectangle(10,
50,
40,
60),
LinearGradientMode.Horizontal)
array
oPuntos(2)
oPuntos(0)
oPuntos(1)
oPuntos(2)
'
Dim
oGraphics
End
New
New
New
=
=
obtener
As
'
dibujar
oGraphics.FillClosedCurve(oLGB,
de
coordenadas
Point
As
Graphics
pintar
Point(20,
Point(75,
Point(140,
contexto
=
una
200)
100)
220)
grfico
Me.CreateGraphics()
curva
cerrada
oPuntos)
Sub
'------------------------------------------'
pintar
figura
con
Private
Sub
mnuBrushPathG_Click(ByVal
sender
System.EventArgs)
Handles
'
Dim
oPuntos(0)
oPuntos(1)
oPuntos(2)
'
crear
'
y
Dim
oPGB
oPGB.CenterColor
oPGB.SurroundColors
As
array
oPuntos(2)
=
=
=
'
crear
Dim
oGraphics
oGraphics.FillPolygon(oPGB,
de
brocha
de
configurar
As
New
=
New
Color()
grfico
tipo
PathGradient,
el
objeto
PathGradientBrush(oPuntos)
Color.Indigo
{Color.Beige,
Color.LightGreen}
y
Graphics
coordenadas
Point
150)
80)
150)
As
Point(100,
Point(175,
Point(210,
New
New
New
As
brocha
PathGradientBrush
System.Object,
ByVal
e
As
mnuBrushPathG.Click
pintar
=
polgono
Me.CreateGraphics()
oPuntos)
End
Sub
La Figura 328 muestra todas las formas dibujadas con objetos de los tipos derivados de Brush.
podemos realizar operaciones de dibujo de texto en la superficie del formulario, empleando el mtodo DrawString( )
de la clase Graphics.
El texto visualizado mediante esta tcnica no es evidentemente editable, se encamina fundamentalmente a
mostrar texto con efectos adicionales que no podramos conseguir mediante los controles tpicos.
En el formulario de nuestro ejemplo, la opcin de men Texto + Dibujar texto, crea un objeto HatchBrush con
un tramado especfico, un objeto Font de una determinada familia, y con ambos elementos, pinta el texto mediante un
objeto Graphics. Ver el Cdigo fuente 545.
Private Sub
System.EventArgs)
'
Dim
oBrush
crear
As
'
Dim
mnuTextoTxt_Click(ByVal sender
Handles
oFont
New
oFont,
oBrush,
System.Object, ByVal e As
mnuTextoTxt.Click
un
objeto
Brush
con
efectos
HatchBrush(HatchStyle.Wave,
Color.Aqua,
Color.DarkGreen)
crear
As
'
obtener
'
y
Dim
oGraf
oGraf.DrawString("Texto
As
el
New
el
tipo
Font(New
dispositivo
pintar
Graphics
As
en
New
de
FontFamily("Georgia"),
grfico
del
el
=
modo
RectangleF(20,
letra
50)
20,
formulario
texto
Me.CreateGraphics()
grfico",
_
500,
End
200))
Sub
En un tema anterior explicamos que la propiedad BackgroundImage nos permite asignar un fichero de imagen
para el fondo del formulario. La facilidad que proporciona esta propiedad tiene desafortunadamente su lado negativo,
ya que el tamao de la imagen asignada, no se adapta automticamente al del formulario.
Por tal motivo, en este apartado vamos a proporcionar al lector un par de tcnicas, que le permitirn crear
imgenes de fondo para formularios con ajuste dinmico, para que la imagen adapte sus dimensiones a las del
formulario, cuando este cambie su tamao en tiempo de ejecucin.
'
Dim
sender As Object,
Handles
crear
oBitmap
'
pintar
el
'
grfico
'
el
area
a
'
coordenada
0,0
y
'
del
formulario
Dim
oGraphics
As
oGraphics.DrawImage(oBitmap,
0,
End
ByVal e As
MyBase.Paint
un
As
objeto
New
objeto
bitmap
Bitmap("LogoWin.gif")
con
el
contexto
formulario;
pintar
abarca
desde
la
toma
el
ancho
y
alto
de
su
propiedad
Size
Graphics
=
e.Graphics
0,
Me.Size.Width,
Me.Size.Height)
del
Sub
Queda todava un paso ms, ya que aunque la imagen se muestra como fondo del formulario, si
redimensionamos este, slo se repinta la parte nueva redimensionada, produciendo un efecto no deseado. Ver Figura
330.
Para conseguir que se pinte por completo toda la imagen, debemos invalidar la zona grfica del formulario
mediante su mtodo Invalidate( ), en el evento Resize, el cual es provocado cada vez que cambia el formulario de
tamao. Despus de escribir el Cdigo fuente 547, cuando volvamos a ejecutar el ejemplo, la imagen de fondo se
adaptar en todo momento a las medidas del formulario.
Private
Handles
'
Sub
Form1_Resize(ByVal
cada
vez
'
invalidamos
'
el
evento
sender
As
Object,
que
cambie
el
su
rea
Paint
de
pinte
ByVal
As
System.EventArgs)
MyBase.Resize
tamao
del
dibujo
toda
formulario
para
la
que
superficie
Me.Invalidate()
End
Sub
A continuacin asignaremos el fichero con la imagen a la propiedad Image, y por ltimo, tenemos que
establecer la propiedad SizeMode al valor StretchImage. Esto ser todo, por lo que si ejecutamos el programa, la
imagen quedar en todo momento ajustada al formulario al igual que en el anterior caso. Ver Figura 331.
Figura 332. Propiedad Opacity establecida desde la ventana de propiedades del IDE. La
El Cdigo fuente 548 establece por cdigo la opacidad del formulario a un grado del cuarenta y cinco por
ciento, en el evento DoubleClick del formulario.
Private
Handles
Sub
Form1_DoubleClick(ByVal
sender
Me.Opacity
As
Object,
ByVal
As
System.EventArgs)
MyBase.DoubleClick
4.5
End
Sub
El proyecto Opacidad (hacer clic aqu para acceder a este ejemplo) contiene un control TrackBar, que con el
estilo de un control de volumen, nos va a permitir graduar el nivel de opacidad del formulario.
Mediante las propiedades Maximum y Minimum establecemos el rango de opacidad respectivamente a diez y
cero.
En la propiedad Value asignaremos el valor 10, para partir de la mxima opacidad e ir disminuyendo.
Como efectos visuales de este control, las propiedades Orientation y TickStyle nos permiten establecer la
orientacin del indicador de posicin y su apariencia.
Finalmente, el evento Scroll se producir cada vez que movamos el indicador de posicin en el control,
ejecutando el cdigo de su procedimiento manipulador, que vemos en el Cdigo fuente 549.
Private
Handles
Sub
tkbOpaco_Scroll(ByVal
sender
As
Object,
ByVal
As
System.EventArgs)
tkbOpaco.Scroll
'
cada
'
del
vez
que
se
TrackBar
se
Select
mueve
modifica
Case
el
desplazador
la
opacidad
Me.tkbOpaco.Value
Case
Me.Opacity
Case
Me.Opacity
Case
Me.Opacity
End
10
1
"0,"
&
Else
Me.tkbOpaco.Value
Select
End
Sub
En el procedimiento del evento Tick, crearemos el efecto de fundido, disminuyendo el grado de opacidad del
formulario hasta hacerlo invisible, punto en el que cerraremos el formulario. Esto har que se vuelva a pasar por el
evento Closing, pero en esta ocasin, como la opacidad del formulario estar a cero, no se volver a realizar el proceso
de fundido. Todo esto lo vemos en el Cdigo fuente 550.
Dim
oTiempo
'
'
If
el
formulario
Opacity
Me.Opacity
en
'
e.Cancel
As
debe
para
tener
conseguir
Timer
el
<>
cancelamos
el
valor
el
0
cierre
del
formulario
True
'
iniciamos
oTiempo
oTiempo.Interval
'
conectamos
'
de
AddHandler
oTiempo.Start()
un
=
temporizador
cada
medio
New
=
el
temporizador
su
oTiempo.Tick,
con
1
efecto
Then
un
evento
AddressOf
segundo
Timer()
500
manipulador
Tick
TickTiempo
End
If
End
Sub
Private
Sub
TickTiempo(ByVal
'
este
manipulador
'
cada
medio
segundo
'
de
opacidad
del
Static
dbContador
dbContador
Me.Opacity
'
If
'
CType(sender,
'
Me.Close()
cuando
el
Me.Opacity
parar
cerrar
sender
As
Object,
del
ByVal
As
EventArgs)
evento
del
temporizador,
disminuyendo
el
grado
hasta
hacerlo
invisible
Double
=
1
0.1
dbContador
ir
formulario
As
-=
=
formulario
=
es
0
el
el
invisible
Then
temporizador
Timer).Stop()
formulario
End
If
End
Sub
Imports
'....
'....
Private
Sub
Circulo_Click(ByVal
System.EventArgs)
'
crear
un
Dim
oGPath
'
aadir
System.Drawing.Drawing2D
sender
As
Handles
objeto
grfico
As
crear
'
para
un
crculo
regin
asignarla
Me.Region
la
New
GraphicsPath()
0,
200,
260))
el
objeto
grfico
del
New
formulario
Region(oGPath)
End
Sub
Private Sub
System.EventArgs)
'
curvas
grfico
regin
objeto
con
lneas
al
Rectangle(0,
una
ByVal
e
As
Circulo.Click
conectar
GraphicsPath
oGPath.AddEllipse(New
'
System.Object,
btnPoligono_Click(ByVal sender
Handles
mostrar
el
As
System.Object, ByVal e As
btnPoligono.Click
formulario
'
de
Dim
oPuntos(2)
con
el
un
aspecto
tringulo
As
Point
oPuntos(0)
New
Point(-20,
-20)
oPuntos(1)
New
Point(-20,
200)
oPuntos(2)
Dim
oGPath
As
oGPath.AddPolygon(oPuntos)
Me.Region
=
End
New
Point(220,
GraphicsPath
=
New
New
90)
GraphicsPath()
Region(oGPath)
Sub
elegida. Al seleccionar un directorio del TreeView, se rellenar el ListView con una lista de ficheros de tipo grfico,
de los que al seleccionar uno, se cargar su contenido en un PictureBox; al realizar dicha carga, podremos optar por
ajustar la imagen a las dimensiones del PictureBox o bien mantener el tamao original de la imagen. Debido a que
algunos de estos controles necesitan de imgenes asociadas como iconos, utilizaremos tambin un control ImageList
para almacenar estos iconos.
El control TreeView muestra una lista de elementos dispuestos en forma de rbol o nodos expandibles. La
propiedad Nodes es una coleccin que contiene los nodos del control, que en este caso rellenaremos desde el cdigo
del programa. Las propiedades ImageIndex y SelectedImageIndex muestran respectivamente una de las imgenes del
control ImageList asociado, con el icono indicativo de si un nodo se encuentra o no seleccionado.
Por otro lado, el control ListView consiste en un ListBox al que podemos asociar una imagen para cada
elemento o item que muestra en la lista.
Para poder mostrar los elementos de un ListView de esta forma estableceremos la propiedad View al valor
Details; crearemos una columna en su propiedad Columns, y asociaremos el control ImageList a las propiedades
Large/Small/StateImageList. Tambin es conveniente que la propiedad MultiSelect est a False para poder seleccionar
slo un elemento en cada ocasin. El llenado de este control tambin lo haremos desde el cdigo de la aplicacin. La
Figura 337 muestra el formulario de este proyecto una vez completada su fase de diseo.
Pasando al cdigo de la clase del formulario, debido a que vamos a trabajar con objetos que manipulan
directorio y ficheros, importaremos en la cabecera del fichero de cdigo el espacio de nombres System.IO. En el
evento Load del formulario, cargaremos el ComboBox con las unidades lgicas detectadas por el sistema, empleando
el objeto Environment del sistema, y su mtodo GetLogicalDrives( ). Ver Cdigo fuente 552.
Imports
System.IO
Public
Inherits
Class
Form1
System.Windows.Forms.Form
Private
Sub
Form1_Load(ByVal
sender
As
Object,
ByVal
As
System.EventArgs)
Handles
MyBase.Load
'
al
cargar
el
formulario
llenar
'
el
combo
con
las
letras
de
unidad
Dim
sUnidades()
As
String
sUnidades
=
System.Environment.GetLogicalDrives()
Me.cboUnidades.Items.AddRange(sUnidades)
End
Sub
'....
Cdigo fuente 552
Private
'
'
Sub
cboUnidades_SelectedIndexChanged(ByVal
sender
As
Object,
ByVal
As
System.EventArgs)
Handles
cboUnidades.SelectedIndexChanged
este
evento
se
dispara
cuando
se
cambia
el
elemento
seleccionado
del
combo
'
obtener
los
directorios
Dim
oDirUnidadSelec
As
Dim
sDirectorios()
sDirectorios
=
raz
New
de
la
unidad
seleccionada
DirectoryInfo(Me.cboUnidades.Text)
As
DirectoryInfo
oDirUnidadSelec.GetDirectories()
'
vaciar
Me.tvDirectorios.Nodes.Clear()
'
dibujar
Dim
Dim
For
cada
nombre
oDirInfo
oNodo
Each
oNodo
=
New
Me.tvDirectorios.Nodes.Add(oNodo)
Next
End
el
de
directorio
As
treeview
raz
en
el
As
oDirInfo
In
TreeNode(oDirInfo.FullName,
0,
treeview
DirectoryInfo
TreeNode
sDirectorios
1)
Sub
El siguiente paso lgico es la seleccin de un directorio en el TreeView. Cuando esto suceda, se provocar el
evento AfterSelect de dicho control; en l comprobaremos si existen directorios anidados al seleccionado, y al mismo
tiempo, llenaremos el ListView con los nombres de ficheros del directorio seleccionado, asociando a cada elemento de
la lista, una imagen del control ImageList por el nmero de orden que ocupa la imagen en la lista. Ver Cdigo fuente
554.
Private
'
If
Sub
tvDirectorios_AfterSelect(ByVal
As
Object,
ByVal
As
System.Windows.Forms.TreeViewEventArgs)
Handles
tvDirectorios.AfterSelect
si
el
nodo
pulsado
no
est
expandido...
Not
e.Node.IsExpanded
Then
'
Dim
oSubDirInfo
comprobar
oSubDirInfo
=
si
tiene
'
crear
New
oNodo
=
e.Node.Nodes.Add(oNodo.Text)
Next
'
Dim
oArchivos
obtener
New
directorio
seleccionado
DirectoryInfo
oSubDirInfo.GetDirectories()
As
subdirectorio
As
As
In
en
TreeNode(oSubDirI.Name,
los
oArchivos()
archivos
del
rellenar
que
Each
limpiar
el
listview
con
tengan
oArchInfo
oArchInfo
Select
Case
Case
".BMP",
Me.lstFicheros.Items.Add(oArchInfo.Name,
treeview
DirectoryInfo
TreeNode
oSubDirectorios
1)
As
subdirectorio
FileInfo
oSubDirInfo.GetFiles()
el
listview
los
nombres
tipo
de
As
In
archivo
grfico
FileInfo
oArchivos
oArchInfo.Extension.ToUpper()
".PNG",
".WMF"
3)
Case
".JPG",
Me.lstFicheros.Items.Add(oArchInfo.Name,
Case
Me.lstFicheros.Items.Add(oArchInfo.Name,
End
Next
End
End
el
0,
'
Me.lstFicheros.Items.Clear()
'
del
nodos
para
cada
oSubDirI
oNodo
Each
oSubDirI
Dim
Dim
For
subdirectorios
DirectoryInfo
DirectoryInfo(e.Node.FullPath)
As
'
obtener
subdirectorios
Dim
oSubDirectorios()
oSubDirectorios
=
'
Dim
For
sender
".JPEG"
4)
".GIF"
5)
Select
If
Sub
Finalmente, ya slo queda comprobar cundo se pulsa en uno de los ficheros de imagen del ListView, cosa que
haremos con su evento SelectedIndexChanged. Al producirse esta situacin, lo que haremos ser invalidar el rea de
dibujo del PictureBox, forzando a que se desencadene su evento Paint, en donde realmente realizaremos la carga de la
imagen. A pesar de todo, en el Cdigo fuente 555 tambin se acompaa el cdigo para hacer una carga directa de la
Private Sub
System.EventArgs)
If
'
'
'
lstFicheros_SelectedIndexChanged(ByVal
Handles
Me.lstFicheros.SelectedItems.Count
>
CARGA
MANUAL
EN
si
invalidamos
la
regin
grfica
obligamos
a
que
se
produzca
su
'
y
en
'
la
Me.picImagen.Invalidate()
ese
evento
imagen
escribimos
en
el
0
del
evento
cdigo
el
Then
PICTUREBOX:
picturebox
Paint,
que
carga
control
'
CARGA
AUTOMTICA
DE
IMAGEN:
'
escribimos
en
este
evento
el
cdigo
para
'
asignar
una
imagen
al
picturebox
'Me.picImagen.Image
=
New
Bitmap(
_
'
Me.tvDirectorios.SelectedNode.FullPath
&
"\"
&
_
'
Me.lstFicheros.SelectedItems(0).Text)
End
If
End
Sub
En el evento Paint del PictureBox, mostramos la imagen seleccionada, ajustada al tamao del control o con su
propio tamao, segn el RadioButton seleccionado del formulario. Adicionalmente, para el caso en el que se
redimensione el formulario, tambin invalidamos el PictureBox, de manera que la imagen que actualmente se est
mostrando ser recargada. Vemoslo en el Cdigo fuente 556.
Private
'
If
Sub
picImagen_Paint(ByVal
sender
As
Object,
ByVal
As
System.Windows.Forms.PaintEventArgs)
Handles
picImagen.Paint
si
el
nodo
seleccionado
tiene
contenido
Not
(IsNothing(Me.tvDirectorios.SelectedNode))
Then
'
crear
imagen
Dim
oBitmap
Me.tvDirectorios.SelectedNode.FullPath
"\"
&
'
Dim
obtener
oGraf
If
'
dibujar
oGraf.DrawImage(oBitmap,
Me.picImagen.Size.Width,
Else
partir
As
dispositivo
As
imagen
del
fichero
seleccionado
New
Bitmap(
_
&
_
Me.lstFicheros.SelectedItems(0).Text)
grfico
Graphics
Me.rbtAjustar.Checked
ajustada
0,
del
picturebox
e.Graphics
al
0,
Then
picturebox
_
Me.picImagen.Size.Height)
'
dibujar
oGraf.DrawImage(oBitmap,
imagen
con
0,
su
oBitmap.Size.Width,
tamao
0,
oBitmap.Size.Height)
If
If
End
End
End
Private
original
_
Sub
Sub
picImagen_Resize(ByVal
Handles
'
al
redimensionar,
Me.picImagen.Invalidate()
invalidar
End
rea
sender
As
grfica
Object,
ByVal
As
System.EventArgs)
picImagen.Resize
del
picturebox
Sub
Terminada la escritura de cdigo del programa, slo queda ejecutarlo para comprobar su resultado, como
muestra la Figura 338.
Acceso
datos
con
ADO
.NET
En los siguientes temas vamos a tratar el acceso a datos desde VB.NET, haciendo uso del nuevo modelo de
acceso a datos incluido en la plataforma .NET Framework: ADO .NET.
Mostraremos las tareas bsicas para el acceso a datos desde aplicaciones basadas en formularios Windows,
empleando la tecnologa proporcionada por ADO .NET.
ADO .NET es la nueva versin del modelo de objetos ADO (ActiveX Data Objects), es decir, la estrategia que
ofrece Microsoft para el acceso a datos. ADO .NET ha sido ampliado para cubrir todas las necesidades que ADO no
ofreca, y est diseado para trabajar con conjuntos de datos desconectados, lo que permite reducir el trfico de red.
ADO .NET utiliza XML como formato universal de transmisin de los datos.
ADO .NET posee una serie de objetos que son los mismos que aparecen en la versin anterior de ADO, como
pueden ser el objeto Connection o Command, e introduce nuevos objetos tales como el objeto DataReader, DataSet o
DataView.
ADO .NET se puede definir como:
.
Un conjunto de interfaces, clases, estructuras y enumeraciones que permiten el acceso a datos desde la
Tabla
31
De los anteriores puntos podemos obtener muy buenas conclusiones en cuanto a las mejoras introducidas en el
nuevo modelo ADO .NET. Se puede resumir en un mejor mecanismo de comunicacin entre procesos gracias a XML
y una independencia del cliente con respecto al servidor, que posibilita el funcionamiento autnomo de la aplicacin
(mejor tolerancia a fallos, independencia del estado de la red).
Interoperabilidad
Las aplicaciones basadas en ADO .NET obtienen ventaja de la flexibilidad y la masiva aceptacin del estndar
XML para el intercambio de datos. Puesto que XML es el estndar de envo de informacin entre capas, cualquier
componente capaz de Interpretar los datos XML puede acceder a la informacin de ADO .NET, se encuentre donde se
encuentre, y procesarla. Adems, puesto que la informacin se enva en flujos de XML, no importa la implementacin
empleada para enviar o recoger la informacin as como la plataforma empleada-. Simplemente se exige a los
componentes que reconozcan el formato XML empleado para el proceso, envo y recepcin de un DataSet.
Mantenimiento
En el ciclo de vida de una aplicacin los cambios poco sustanciales y modestos son permisibles. Pero cuando es
necesario abordar un cambio estructural o arquitectnico del sistema, la tarea se vuelve demasiado compleja y a veces
inviable. Esto es una gran desventaja de los sistemas actuales, pues muchas veces se trata de una cuestin de
actualizacin de los procesos de la propia empresa. Adems, cuanto ms se aumenta el proceso de la operativa de la
empresa, las necesidades de proceso crecen hasta desbordar las mquinas. Es por ello que se separa la estructura de un
programa en varias capas. Una de esas capas es la de datos, que es fundamental desarrollar correctamente. Gracias a
los DataSets, la tarea de portar y aumentar los procesos de datos y de negocio ser mas sencillo: el intercambio de
informacin a travs de XML, hace que sea ms sencilla la tarea de estructurar en ms capas la aplicacin,
convirtindola en ms modular y fcil de mantener.
Programacin
Los programadores pueden acceder a un API de programacin estructurado, de fuerte tipificado y que adems se
concentra en la correcta forma de presentar los datos. Centra en la estructura del lenguaje lo que un programador
necesita para disear los programas sin dar muchos rodeos. El Cdigo fuente 557 muestra un ejemplo de cdigo sin
tipificar:
....
If
CosteTotal
....
>
Table("Cliente")("Luis").Column("CreditoDisponible")
Then
Como se puede observar, aparecen nombres de objetos genricos del sistema que complican la lectura del
cdigo, a la par que los operadores complican tambin la visin de la secuencia de acceso a los datos. Podramos
interpretar lo que hace gracias a que aparecen los nombres propios de los datos que necesitamos. El Cdigo fuente 558
muestra un ejemplo un poco ms tipificado:
....
If
CosteTotal
....
>
DataSet1.Cliente("Luis").CreditoDisponible
Then
El ejemplo es exactamente igual al anterior, pero en este caso, el cdigo se centra ms en los objetos reales que
en el objeto del lenguaje en s: las palabras Table y Column ya no aparecen. En su lugar vemos que aparecen los
nombres de los objetos empleados de la vida real, lo que hace el cdigo ms legible. Si a esto unimos que los entornos
ya son capaces de ayudarnos a escribir el cdigo, todava lo tenemos ms sencillo, ya que podemos ver con nuestras
palabras el modelo de objetos de datos que necesitamos en cada momento. Incluso a nivel de ejecucin nos vemos
respaldado por un sistema de control de tipos y errores que nos permitirn proporcionar una robustez innata, que antes
no se tena sin pasar por el uso de funciones externas.
Rendimiento
Puesto que trabajamos con objetos de datos desconectados, todo el proceso se acelera, ya que no tenemos que
estar comunicndonos por Marshalling con el servidor. Adems, gracias al modelo de XML la conversin de tipos no
es necesaria a nivel de COM. Se reduce pues el ancho de banda disponible, se independiza ms el cliente del servidor,
y se descarga ms a ste, que puede estar dedicado a otras tareas en lo que el cliente analiza sus datos.
Escalabilidad
Las aplicaciones Web tienen un nmero ilimitado de conexiones potenciales debido a la naturaleza de
Internet. Los servidores son capaces de atender muy bien decenas y decenas de conexiones. Pero cuando
hablamos de miles y millones, los servidores ya no son capaces de realizar correctamente su trabajo. Esto es
debido a que por cada usuario se mantiene una memoria de proceso y conexin, un conjunto de bloqueos de
recursos como puedan ser tablas, ndices, etc., y una comprobacin de sus permisos; todo ello consume
tiempo y recursos. ADO .NET favorece la escalabilidad, puesto que su modelo de conexin Off-Line evita
que se mantengan los recursos reservados ms tiempo del considerado necesario. Esto permite que ms
usuarios por unidad de tiempo puedan acceder a la aplicacin sin problemas de tiempos. Adems se pueden
montar servicios en Cluster de alta disponibilidad que sern balanceados automticamente por el sistema sin
afectar a las conexiones ADO. Lo cual garantiza la ampliacin del servicio sin representar un cambio de
arquitectura de diseo.
aumenta el proceso del sistema al mantener una poltica de bloqueos y transacciones. Al mismo tiempo, si la
aplicacin mantiene ms de un objeto simultneamente, se encuentra con el problema de tener que estar continuamente
conectando con el servidor para alimentar las relaciones existentes entre ambas, subiendo y bajando informacin va
RPC.
Con ADO .NET se consigue estar conectado al servidor slo lo estrictamente necesario para realizar la
operacin de carga de los datos en el DataSet. De esta manera se reducen los bloqueos y las conexiones a la mnima
expresin. Se pueden soportar muchos ms usuarios por unidad de tiempo y disminuyen los tiempos de respuesta, a la
par que se aceleran las ejecuciones de los programas.
Tradicionalmente, el recoger informacin de una base de datos ha ido destinado a realizar un proceso con dicha
informacin: mostrarla por pantalla, procesarla o enviarla a algn componente. Frecuentemente, la aplicacin no
necesita una nica fila, sino un buen conjunto de ellas. Adems, tambin frecuentemente, ese conjunto de filas procede
no de una tabla sino de una unin de mltiples tablas (join de tablas). Una vez que estos datos son cargados, la
aplicacin los trata como un bloque compacto. En un modelo desconectado, es inviable el tener que conectar con la
base de datos cada vez que avanzamos un registro para recoger la informacin asociada a ese registro (condiciones del
join). Para solucionarlo, lo que se realiza es almacenar temporalmente toda la informacin necesaria donde sea
necesario y trabajar con ella. Esto es lo que representa un DataSet en el modelo ADO .NET.
Un DataSet es una cach de registros recuperados de una base de datos que acta como un sistema de
almacenamiento virtual, y que contiene una o ms tablas basadas en las tablas reales de la base de datos.
Adicionalmente, almacena las relaciones y reglas de integridad existentes entre ellas para garantizar la estabilidad e
integridad de la informacin de la base de datos. Muy importante es recalcar, que los DataSets son almacenes pasivos
de datos, esto es, no se ven alterados ante cambios subyacentes de la base de datos. Es necesario recargarlos siempre
que queramos estar al da, en cuanto a datos se refiere.
Una de las mayores ventajas de esta implementacin, es que una vez obtenido el DataSet, ste puede ser enviado
(en forma de flujo XML) entre distintos componentes de la capa de negocio, como si de una variable ms se tratase,
ahorrando as comunicaciones a travs de la base de datos.
Una consecuencia lgica de este tipo de arquitecturas, es la de conseguir que los DataSets sean independientes
de los orgenes de datos. Los drivers OLE-DB transformarn la consulta SQL en un cursor representado con una
estructura XML, que es independiente del motor de la base de datos.
Esto nos permitir trabajar con mltiples orgenes de datos, de distintos fabricante e incluso en formatos que no
pertenezcan a bases de datos, por ejemplo, ficheros planos u hojas de clculo, lo que representa un importante punto de
compatibilidad y flexibilidad.
Si a esto unimos el hecho de que disponemos de un modelo consistente de objetos (xmlDOM) que es
independiente del origen de datos, las operaciones de los DataSets no se vern afectadas por dicho origen.
La persistencia es un concepto muy interesante en el mundo del desarrollo. Es un mecanismo por el cual un
componente puede almacenar su estado (valores de variables, propiedades, datos...en un momento concreto del
tiempo) en un soporte de almacenamiento fijo. De manera, que cuando es necesario, se puede recargar el componente
tal y como qued en una operacin anterior.
En un sistema de trabajo Off-Line como el que plantea ADO .NET, la persistencia es un mecanismo
fundamental. Podemos cerrar la aplicacin y mantener persistentes todos los DataSets necesarios, de manera que al
reiniciarla, nos encontramos los DataSets tal y como los dejamos. Ahorrando el tiempo que hubiera sido necesario
para recuperar de nuevo toda esa informacin del servidor. Optimizando todava ms el rendimiento del sistema
distribuido.
El formato que emplea ADO .NET para almacenar su estado es XML. Puesto que ya es un estndar de la
industria, esta persistencia nos ofrece las siguientes cualidades:
.
La informacin puede estar accesible para cualquier componente del sistema que entienda XML.
.
Es un formato de texto plano, no binario, que lo hace compatible con cualquier componente de
cualquier plataforma, y recuperable en cualquier circunstancia.
DataSet
El API de ADO .NET proporciona una superclase, DataSet, que encapsula lo que sera la base de datos a un
nivel lgico: tablas, vistas, relaciones, integridad entre todos ellos, etc., pero siempre con independencia del tipo de
fabricante que la dise. Aqu se tiene el mejor concepto de datos desconectados: una copia en el cliente de la
arquitectura de la base de datos, basada en un esquema XML que la independiza del fabricante, proporcionando al
desarrollador la libertad de trabajo independiente de la plataforma. La Figura 339 muestra una representacin de este
tipo de objeto.
Esta clase se compone a su vez, de clases de soporte, que representan cada una, los elementos arquitecturales de
la base de datos: tablas, columnas, filas, sus reglas de chequeo, sus relaciones, las vistas asociadas a la tabla, etc.
Un DataSet puede contener diversas tablas, que se representan mediante objetos DataTable. Para mostrar el
contenido de un DataSet, mediante Data Binding, por ejemplo, necesitamos el objeto DataView. Un objeto DataView
nos permite obtener un subconjunto personalizado de los datos contenidos en un objeto DataTable. Cada objeto
DataTable de un DataSet posee la propiedad DefaultView, que devuelve la vista de los datos por defecto de la tabla.
Otro objeto de ADO .NET es DataReader, que representa un cursor de slo lectura y que slo permite
desplazamiento hacia adelante (read-only/forward-only), cada vez existe un nico registro en memoria, el objeto
DataReader mantiene abierta la conexin con el origen de los datos hasta que es cerrado. Al igual que ocurra con
otros objetos de ADO .NET, de este objeto tenemos dos versiones, que como el lector sospechar se trata de los
objetos SqlDataReader y OleDbDataReader.
Adems de estas clases, existe otro grupo de clases consistente en las clases especficas de un
proveedor de datos. Estas clases conforman los aspectos particulares de un fabricante de proveedores de datos .NET.
Tienen una sintaxis con el formato XXXClase, donde XXX es un prefijo que determina el tipo de plataforma de
Clase
Descripcin
SqlCommand
OleDbCommand
SqlConnection
OleDbConnection
SqlCommandBuilder
Generador de comandos SQL de insercin,
OleDbCommandBuilder
modificacin y borrado desde una consulta SQL de
seleccin de datos.
SqlDataReader
OleDbDataReader
SqlDataAdapter
es
OleDbDataAdapter
SqlParameter
OleDbParameter
SqlTransaction
OleDbTransaction
Tabla 32
Para aquellos conocedores de ADO en alguna de sus versiones anteriores, podemos hacer una analoga
o comparacin entre las antiguas clases de ADO y las nuevas de ADO .NET. En la Figura 341 se puede ver esta
aproximacin.
Hasta aqu hemos realizado una introduccin a la tecnologa ADO .NET, repasando su arquitectura y
comentando las clases principales. En lo que resta de tema vamos a utilizar las distintas clases que nos ofrece ADO
.NET desde VB.NET, para realizar tareas comunes de acceso a datos, como pueden ser establecer una conexin,
obtener un conjunto de registros, realizar operaciones con los datos, etc.
conjunto a las clases SqlConnection y OleDbConnection de ADO .NET) se encuentra sobrecargado, y en una de sus
versiones recibe como parmetro una cadena que ser la cadena de conexin que se aplique a su propiedad
ConnectionString.
Si hacemos uso de la clase SqlConnection, en la cadena de conexin no podremos especificar una DSN de
ODBC, ya que la conexin se va a realizar en este caso directamente con SQL Server. Y si utilizamos la clase
OleDbConnection debemos especificar el proveedor OLEDB que se va a utilizar para establecer la conexin, una
excepcin es el proveedor OLEDB para ODBC (MSDASQL), que no puede ser utilizado, ya que el proveedor
OLEDB de .NET no soporta el proveedor de ODBC, en este caso deberemos realizar la conexin utilizando el
proveedor adecuado al almacn de datos. Los proveedores OLEDB que son compatibles con ADO .NET son:
. SQLOLEDB: Microsoft OLE DB Provider for SQL Server.
. MSDAORA: Microsoft OLE DB Provider for Oracle.
. Microsoft.Jet.OLEDB.4.0: OLE DB Provider for Microsoft Jet.
La sintaxis utilizada para indicar la cadena de conexin, con las particularidades propias de cada proveedor,
veremos que es muy similar a la utilizada en ADO clsico. El Cdigo fuente 559 muestra un ejemplo de conexin con
un servidor SQL Server 2000, y su posterior desconexin, utilizando un objeto SqlConnection. Debemos importar el
espacio de nombres Data.SqlClient para poder utilizar el objeto. Este cdigo lo podemos asociar a la pulsacin de un
botn en un formulario.
Imports
System.Data.SqlClient
'....
Try
'
Dim
'
crear
el
objeto
oConexion
pasar
As
la
oConexion.ConnectionString
de
New
cadena
=
"server=(local);"
conexin
SqlConnection()
de
conexin
&
"database=Xnorthwind;uid=sa;pwd=;"
'
oConexion.Open()
MessageBox.Show("Conectado")
abrir
conexin
'
oConexion.Close()
MessageBox.Show("Desconectado")
cerrar
conexin
Catch
oExcep
As
SqlException
'
si
se
produce
algn
error,
'
lo
capturamos
mediante
el
objeto
'
de
excepciones
particular
para
'
el
proveedor
de
SQL
Server
MessageBox.Show("Error
al
conectar
con
datos"
&
_
ControlChars.CrLf
&
_
oExcep.Message
&
ControlChars.CrLf
&
_
oExcep.Server)
End
Try
El Cdigo fuente 560 muestra la misma operacin pero usando el objeto de conexin para el proveedor de
OLEDB. Observe el lector las diferencias en las cadenas de conexin y el objeto de excepcin con respecto al anterior
ejemplo, as como el espacio de nombres a importar.
Imports
System.Data.OleDb
'....
Try
'
Dim
crear
oConexion
el
objeto
As
oConexion.ConnectionString
=
"Server=(local);Database=Northwind;uid=sa;pwd=;"
de
New
"Provider=SQLOLEDB;"
conexin
OleDbConnection()
&
'
oConexion.Open()
MessageBox.Show("Conectado")
abrir
conexin
'
oConexion.Close()
MessageBox.Show("Desconectado")
cerrar
conexin
Catch
oExcep
As
OleDbException
'
si
se
produce
algn
error,
'
lo
capturamos
mediante
el
objeto
'
de
excepciones
particular
para
'
el
proveedor
de
OLEDB
MessageBox.Show("Error
al
conectar
con
datos"
&
_
ControlChars.CrLf
&
_
oExcep.Message
&
ControlChars.CrLf
&
_
oExcep.Source())
End
Try
'
crear
Dim
oConexion
As
oConexion.ConnectionString
=
conexin
New
SqlConnection()
"Server=(local);"
&
_
"Database=Gestion;uid=sa;pwd=;"
'
Dim
sSQL
"INSERT
crear
sSQL
INTO
Clientes
sentencia
As
(IDCliente,Nombre,FIngreso)
SQL
String
"
&
_
"VALUES(10,'Alfredo','18/7/2002')"
'
Dim
oComando
As
New
crear
SqlCommand(sSQL,
Dim
iResultado
As
oConexion.Open()
'
abrir
iResultado
=
oComando.ExecuteNonQuery()
'
oConexion.Close()
'
cerrar
MessageBox.Show("Registros
comando
oConexion)
ejecutar
Integer
conexin
comando
conexin
aadidos:"
&
iResultado)
En el Cdigo fuente 562 realizamos tambin la insercin con un SqlCommand, pero utilizando en este caso
parmetros. En la cadena que tiene la sentencia SQL indicaremos los parmetros con el formato
@NombreParmetro.
Para crear cada uno de los parmetros utilizaremos la clase SqlParameter, mientras que para aadir los
parmetros usaremos la coleccin Parmeters del objeto SqlCommand y su mtodo Add( ).
Respecto a la creacin de los parmetros, podemos observar que es muy flexible, ya que como vemos en este
ejemplo, cada uno de ellos se crea de un modo distinto, especificando el nombre, tipo de dato y valor.
'
crear
Dim
oConexion
As
oConexion.ConnectionString
=
conexin
New
SqlConnection()
"Server=(local);"
&
_
"Database=Gestion;uid=sa;pwd=;"
'
crear
sentencia
SQL
para
insertar
un
registro
con
'
parmetros;
indicamos
el
nombre
del
parmetro
con
'
@NombreParmetro
Dim
sSQL
As
String
sSQL
=
"INSERT
INTO
Clientes
(IDCliente,Nombre,FIngreso)
"
&
_
"VALUES(@CodCli,@Nombre,@Fecha)"
'
Dim
oComando
As
New
crear
SqlCommand(sSQL,
comando
oConexion)
'
aadir
'
parmetro
oComando.Parameters.Add(New
parmetros
al
comando:
primer
campo
SqlParameter("@CodCli",
_
SqlDbType.Int))
oComando.Parameters("@CodCli").Value
'
parmetro
oComando.Parameters.Add(New
25
segundo
SqlParameter("@Nombre",
campo
"Raquel"))
'
parmetro
tercer
campo
Dim
oParametro
As
New
SqlParameter()
oParametro.ParameterName
=
"@Fecha"
oParametro.SqlDbType
=
SqlDbType.DateTime
oParametro.Value
=
"25/10/2002"
oComando.Parameters.Add(oParametro)
Dim
iResultado
As
oConexion.Open()
'
abrir
iResultado
=
oComando.ExecuteNonQuery()
'
ejecutar
oConexion.Close()
'
cerrar
MessageBox.Show("Registros
Integer
conexin
comando
conexin
aadidos:"
&
iResultado)
Si empleamos un objeto OleDbCommand, la sintaxis de la sentencia SQL cambia, ya que los parmetros
deberemos indicarlos como hacamos en ADO clsico, utilizando el carcter ?. Veamos un ejemplo en el Cdigo
fuente 563.
'
crear
el
Dim
oConexion
As
oConexion.ConnectionString
=
objeto
de
conexin
New
OleDbConnection()
"Provider=SQLOLEDB;"
&
_
"Server=(local);Database=Gestion;uid=sa;pwd=;"
'
Dim
sSQL
IDCliente
'
crear
comando
Dim
oComando
As
New
OleDbCommand(sSQL,
oConexion)
oComando.Parameters.Add(New
OleDbParameter("NombreCli",
_
OleDbType.VarChar,
oComando.Parameters("NombreCli").Value
Dim
oConexion.Open()
iResultado
'
As
abrir
50))
"David"
Integer
conexin
2"
iResultado
=
oComando.ExecuteNonQuery()
'
oConexion.Close()
'
cerrar
MessageBox.Show("Registros
ejecutar
comando
conexin
modificados:"
&
iResultado)
En el caso de que necesitemos ejecutar un procedimiento almacenado, debemos indicarlo mediante las
propiedades CommandType y CommandText del objeto Command que estemos utilizando. En la primera
establecemos el tipo de comando (procedimiento almacenado) seleccionando el valor de la enumeracin asociada a la
propiedad; y en la segunda asignamos una cadena con el nombre del procedimiento almacenado. El Cdigo fuente 564
muestra un ejemplo, en el que podemos comprobar que hemos utilizado un constructor de SqlCommand sin
parmetros, por lo que el objeto Connection lo asignamos despus mediante la propiedad Connection
'
crear
Dim
oConexion
As
oConexion.ConnectionString
=
conexin
New
SqlConnection()
"Server=(local);"
&
_
"Database=Gestion;uid=sa;pwd=;"
'
aadir
parmetro
al
oComando.Parameters.Add(New
SqlParameter("@IDCliente",
SqlDbType.Int))
oComando.Parameters("@IDCliente").Value
=
Dim
iResultado
25
As
oConexion.Open()
'
abrir
iResultado
=
oComando.ExecuteNonQuery()
'
ejecutar
oConexion.Close()
'
cerrar
MessageBox.Show("Registros
comando
_
borrados:"
Integer
conexin
comando
conexin
&
iResultado)
Para obtener el resultado de una funcin del lenguaje SQL, por ejemplo Count( ), emplearemos el mtodo
ExecuteScalar( ) del objeto Command. En el Cdigo fuente 565, la ejecucin de este mtodo nos devuelve el nmero
de filas de una tabla de la base de datos, que mostramos en un mensaje.
'
Dim
oConexion
crear
As
New
conexin
SqlConnection()
oConexion.ConnectionString
"Database=Gestion;uid=sa;pwd=;"
'
Dim
sSQL
crear
sSQL
"SELECT
oComando
As
"Server=(local);"
comando
As
COUNT(*)
FROM
'
Dim
New
Dim
iResultado
As
oConexion.Open()
'
abrir
iResultado
=
oComando.ExecuteScalar()
'
oConexion.Close()
'
cerrar
de
escalar
String
Clientes"
crear
SqlCommand(sSQL,
MessageBox.Show("Nmero
&
comando
oConexion)
ejecutar
registros
de
Integer
conexin
comando
conexin
clientes:"
&
iResultado)
un conjunto de registros, no debemos confundir este mtodo con el mtodo MoveNext() de ADO, ya que en
este caso no nos movemos al siguiente registro, sino al siguiente conjunto de registros.
.
Read( ). Desplaza el cursor actual al siguiente registro permitiendo obtener los valores del mismo a
travs del objeto DataReader. Este mtodo devolver True si existen ms registros dentro del objeto DataReader, False
si hemos llegado al final del conjunto de registros. La posicin por defecto del objeto DataReader en el momento
inicial es antes del primer registro, por lo tanto para recorrer un objeto DataReader debemos comenzar con una
llamada al mtodo Read(), y as situarnos en el primer registro.
El proyecto PruDataReader (hacer clic aqu para acceder al ejemplo), contiene un formulario con algunos
controles, que muestran el uso de objetos DataReader.
El botn Empleados crea a partir de un comando, un objeto DataReader que recorremos para llenar un ListBox
con los valores de una de las columnas de la tabla que internamente contiene el DataReader. Veamos este caso en el
Cdigo fuente 566.
Private Sub
System.EventArgs)
btnEmpleados_Click(ByVal sender
Handles
'
Dim
oConexion
oConexion.ConnectionString
crear
As
=
As
System.Object, ByVal e As
btnEmpleados.Click
conexion
SqlConnection()
&
_
New
"Server=(local);"
"Database=Northwind;uid=sa;pwd=;"
'
Dim
oComando
oConexion)
As
'
Dim
oConexion.Open()
oDataReader
New
crear
SqlCommand("SELECT
FROM
comando
Employees",
_
crear
oDataReader
=
oComando.ExecuteReader()
'
recorrer
While
Me.lstEmpleados.Items.Add(oDataReader("LastName"))
End
DataReader
SqlDataReader
As
'
obtener
DataReader
filas
oDataReader.Read()
While
oDataReader.Close()
oConexion.Close()
End
Sub
Como tambin hemos indicado anteriormente, un objeto Command puede estar basado en mltiples sentencias
SQL, separadas por el carcter de punto y coma ( ; ), que se ejecuten en lote. Al crear un DataReader desde un
comando de este tipo, podemos recorrer el conjunto de consultas mediante el mtodo NextResult( ) del DataReader.
Un ejemplo de este tipo lo tenemos al pulsar el botn Clientes/Productos del formulario, cuyo fuente vemos a
continuacin en el Cdigo fuente 567. Observe en este caso que conectamos a travs de OLE DB, por lo que
btnCliProd_Click(ByVal sender
Handles
'
Dim
oConexion
oConexion.ConnectionString
crear
As
=
As
System.Object, ByVal e As
btnCliProd.Click
conexion
OleDbConnection()
&
_
New
"Provider=SQLOLEDB;"
"Server=(local);Database=Northwind;uid=sa;pwd=;"
'
crear
Dim oComando As
Products",
Dim
oConexion.Open()
oDataReader
New
comando
compuesto
OleDbCommand("SELECT *
por
varias
consultas
FROM Customers; SELECT * FROM
oConexion)
oDataReader
=
As
oComando.ExecuteReader()
'
recorrer
filas
de
la
While
Me.lstClientes.Items.Add(oDataReader("CompanyName"))
End
'
pasar
'
oDataReader.NextResult()
While
la
siguiente
las
OleDbDataReader
'
obtener
DataReader
primera
consulta
oDataReader.Read()
While
consulta
recorrer
filas
oDataReader.Read()
Me.lstProductos.Items.Add(oDataReader("ProductName"))
End
While
oDataReader.Close()
oConexion.Close()
End
Sub
La Figura 342 muestra este formulario despus de haber rellenado los controles ListBox usando objetos
DataReader.
lo que no existe una versin particular para SqlClient u OleDb,. En la introduccin que sobre ADO .NET realizamos
en el anterior tema, hemos comentado algunos aspectos sobre esta clase.
Bsicamente, un objeto DataSet va a ser similar a un objeto Recordset de ADO, pero ms potente y complejo.
Es el almacn de datos por excelencia en ADO .NET, representando una base de datos en memoria y desconectada del
proveedor de datos, que contiene tablas y sus relaciones.
El objeto DataSet nos proporciona el mejor concepto sobre datos desconectados: una copia en el cliente de la
arquitectura de la base de datos, basada en un esquema XML que la independiza del fabricante, proporcionando al
desarrollador la libertad de trabajo independiente de la plataforma.
Cada tabla contenida dentro de un objeto DataSet se encuentra disponible a travs de su propiedad Tables, que
es una coleccin de objetos System.Data.DataTable. Cada objeto DataTable contiene una coleccin de objetos
DataRow que representan las filas de la tabla. Y si seguimos con esta analoga tenemos que decir que cada objeto
DataRow, es decir, cada fila, posee una coleccin de objetos DataColumn, que representan cada una de las columnas
de la fila actual. Existen adems, colecciones y objetos para representan las relaciones, claves y valores por defecto
existentes dentro de un objeto DataSet.
Cada objeto DataTable dispone de una propiedad llamada DefaultView, que devuelve un objeto de la clase
DataView, el cual nos ofrece una vista de los datos de la tabla para que podamos recorrer los datos, filtrarlos,
ordenarlos, etc.
Para poder crear e inicializar las tablas del DataSet debemos hacer uso del objeto DataAdapter, que posee las
dos versiones, es decir, el objeto SqlDataAdapter para SQL Server y OleDbDataAdapter genrico de OLE DB.
Al objeto DataAdapter le pasaremos como parmetro una cadena que representa la consulta que se va a ejecutar,
y que va a rellenar de datos el DataSet. Del objeto DataAdapter utilizaremos el mtodo Fill(), que posee dos
parmetros; el primero es el DataSet a rellenar de informacin; y el segundo, una cadena con el nombre que tendr la
tabla creada dentro del DataSet, producto de la ejecucin de la consulta.
En el siguiente apartado veremos los objetos DataAdapter, que van a funcionar como intermediarios entre el
almacn de datos, y el objeto DataSet, que contiene la versin desconectada de los datos.
Entre los mtodos ms destacables de la clase DataSet podemos mencionar los siguientes.
.
Clear( ). Elimina todos los datos almacenados en el objeto DataSet, vaciando todas las tablas
contenidas en el mismo.
.
AcceptChanges( ). Confirma todos los cambios realizados en las tablas y relaciones contenidas en el
objeto DataSet, o bien los ltimos cambios que se han producido desde la ltima llamada al mtodo AcceptChanges.
.
GetChanges( ). Devuelve un objeto DataSet que contiene todos los cambios realizados desde que se
carg con datos, o bien desde que se realiz la ltima llamada al mtodo AcceptChanges.
.
HasChanges( ). Devuelve true o false para indicar si se han realizado cambios al contenido del
DataSet desde que fue cargado o bien desde que se realiz la ltima llamada al mtodo AcceptChanges.
.
RejectChanges( ). Abandona todos los cambios realizados en las tablas contenidas en el objeto
DataSet desde que fue cargado el objeto o bien desde la ltima vez que se lanz el mtodo AcceptChanges.
.
Merge( ). Toma los contenidos de un DataSet y los mezcla con los de otro DataSet, de forma que
contendr los datos de ambos objetos DataSet.
En lo que respecta a las propiedades de la clase DataSet, podemos remarcar las siguientes.
.
CaseSensitive. Propiedad que indica si las comparaciones de texto dentro de las tablas distinguen
entre maysculas y minsculas. Por defecto tiene el valor False.
.
DataSetName. Establece o devuelve mediante una cadena de texto el nombre del objeto DataSet.
.
HasErrors. Devuelve un valor lgico para indicar si existen errores dentro de las tablas del DataSet.
.
Relations. Esta propiedad devuelve una coleccin de objetos DataRelation, que representan todas las
relaciones existentes entre las tablas del objeto DataSet.
.
Tables. Devuelve una coleccin de objetos DataTable, que representan a cada una de las tablas
existentes dentro del objeto DataSet.
En el ejemplo del Cdigo fuente 568 ofrecemos un sencillo ejemplo de creacin de un objeto DataSet que
llenaremos con un DataAdapter. Una vez listo el DataSet, recorreremos la tabla que contiene y mostraremos valores de
sus columnas en un ListBox.
'
Dim
oConexion
oConexion.ConnectionString
'
Dim oDataAdapter
ContactName",
'
Dim
crear
oDataSet
As
'
Dim
oTabla
una
vez
crear
SqlDataAdapter("SELECT
New
conjunto
As
New
oConexion.Open()
' utilizar el adaptador
oDataAdapter.Fill(oDataSet,
oConexion.Close()
FROM
adaptador
ORDER BY
oConexion)
Customers
de
datos
DataSet()
para
desconectados,
oTabla
=
Dim
crear
conexin
As
New
SqlConnection()
"Server=(local);Database=Northwind;uid=sa;pwd=;"
llenar
el
dataset
con
una tabla
"Customers")
oFila
As
DataRow
For
Each
oFila
In
'
mostrar
los
datos
mediante
un
Me.lstCustomers.Items.Add(oFila.Item("CompanyName")
oTabla.Rows
objeto
fila
&
_
"
"
&
oFila.Item("Country"))
Next
&
oFila.Item("ContactName")
"
"
&
InsertCommand. Objeto de la clase Command, que se va a utilizar para realizar una insercin de
.
de SQL.
.
los datos.
.
datos.
SelectCommand. Objeto de la clase Command que se va a utilizar para ejecutar una sentencia Select
datos.
UpdateCommand. Objeto de la clase Command que se va a utilizar para realizar una modificacin de
DeleteCommand. Objeto de la clase Command que se va a utilizar para realizar una eliminacin de
Para demostrar el uso de los objetos DataAdapter vamos a desarrollar un proyecto con el nombre
PruDataAdapter (hacer clic aqu para acceder a este ejemplo). En esta aplicacin vamos a utilizar el mismo objeto
DataAdapter para realizar una consulta contra una tabla e insertar nuevas filas en esa misma tabla.
En primer lugar disearemos el formulario del programa. Como novedad, introduciremos el control DataGrid,
que trataremos con ms profundidad en un prximo apartado. Baste decir por el momento, que a travs del DataGrid
visualizaremos una o varias tablas contenidas en un DataSet. La Figura 345 muestra el aspecto de esta aplicacin en
funcionamiento.
Respecto al cdigo del formulario, en primer lugar, vamos a declarar varios objetos de acceso a datos a nivel de
la clase para poder tenerlos disponibles en diversos mtodos. Veamos el Cdigo fuente 569.
Imports
System.Data.SqlClient
Public
Inherits
Class
Form1
System.Windows.Forms.Form
Private
oConexion
Private
As
oDataSet
Private
oDataAdapter
As
SqlConnection
As
DataSet
SqlDataAdapter
'....
'....
En el siguiente paso escribiremos el procedimiento del evento Load del formulario, y el mtodo CargarDatos( ),
que se ocupa de cargar el DataSet, y asignrselo al DataGrid a travs de su propiedad DataSource. Observe el lector
que en el mtodo CargarDatos( ) lo primero que hacemos es vaciar el DataSet, puesto que este objeto conserva los
datos de tablas y registros; en el caso de que no limpiramos el DataSet, se acumularan las sucesivas operaciones de
llenado de filas sobre la tabla que contiene. Veamos el Cdigo fuente 570.
Private
MyBase.Load
Sub
Form1_Load(ByVal
'
oConexion
oConexion.ConnectionString
'
As
Object,
ByVal
As
System.EventArgs)
conexin
New
SqlConnection()
"Server=(local);Database=MUSICA;uid=sa;pwd=;"
crear
=
crear
comandos
y
oCmdInsercion
Handles
crear
=
'
oDataAdapter
'
Dim
sender
para
As
New
adaptador
SqlDataAdapter()
New
insercin,
consulta
con
sus
asignarlos
al
SqlCommand("INSERT
INTO
AUTORES
"(IDAutor,Autor)
VALUES(@IDAutor,@Autor)",
oDataAdapter.InsertCommand
=
oDataAdapter.InsertCommand.Parameters.Add(New
"
parmetros
adaptador
&
_
oConexion)
oCmdInsercion
SqlParameter("@IDAutor",
SqlDbType.Int))
oDataAdapter.InsertCommand.Parameters.Add(New SqlParameter("@Autor",
SqlDbType.NVarChar))
Dim oCmdConsulta As
oConexion)
oDataAdapter.SelectCommand
'
oDataSet
New
SqlCommand("SELECT
=
crear
Me.CargarDatos()
'
Sub
Private
vaciar
Sub
el
FROM
AUTORES",
CargarDatos()
dataset
oCmdConsulta
conjunto
=
End
de
New
datos
DataSet()
oDataSet.Clear()
oConexion.Open()
'
utilizar
el
adaptador
oDataAdapter.Fill(oDataSet,
oConexion.Close()
'
para
llenar
'
'
enlazar
'
en
DataSource
'
en
DataMember
el
'
dataset
que
Me.grdDatos.DataSource
Me.grdDatos.DataMember
abrir
dataset
el
conexin
una
tabla
"Autores")
conexin
con
cerrar
dataset
se
asigna
nombre
de
mostrar
=
=
con
el
la
tabla
el
datagrid;
dataset,
del
datagrid
oDataSet
"Autores"
End
Sub
Finalmente, en el botn Grabar, escribiremos las instrucciones para insertar un nuevo registro en la tabla.
Veamos el Cdigo fuente 571.
Private Sub
System.EventArgs)
btnGrabar_Click(ByVal sender
Handles
Dim
As
System.Object, ByVal e As
btnGrabar.Click
iResultado
As
'
asignar
valores
a
los
'
comando
oDataAdapter.InsertCommand.Parameters("@IDAutor").Value
oDataAdapter.InsertCommand.Parameters("@Autor").Value
'
oConexion.Open()
'
ejecutar
iResultado
'
oConexion.Close()
parmetros
de
=
=
Integer
para
el
insercin
Me.txtIDAutor.Text
Me.txtAutor.Text
abrir
comando
=
de
cerrar
conexin
insercin
del
adaptador
oDataAdapter.InsertCommand.ExecuteNonQuery()
conexin
Me.CargarDatos()
MessageBox.Show("Registros
aadidos:
"
&
End
iResultado)
Sub
Pero como tambin ya sabemos, la arquitectura de ADO .NET est orientada a un modelo de trabajo
desconectado del almacn de datos, al que recurriremos slo cuando necesitemos obtener los datos para su consulta y
manipulacin, o bien, cuando esos mismos datos desconectados, los hayamos modificado y tengamos que actualizarlos
en la fuente de datos.
El objeto DataSet, combinado con un grupo de objetos enfocados al mantenimiento de datos desconectados,
como son DataAdapter, DataTable, DataRow, etc., nos van a permitir realizar tareas como la navegacin entre los
registros de una tabla del DataSet, adems de la modificacin de sus datos en las operaciones habituales de insercin,
modificacin y borrado de filas.
El proyecto NavegaEdita que se acompaa como ejemplo (hacer clic aqu para acceder a este ejemplo), muestra
los pasos necesarios que debemos dar para crear un sencillo mantenimiento de datos para una tabla albergada en un
DataSet, junto a las tpicas operaciones de navegacin por las filas de dicha tabla. Seguidamente iremos desgranando
el conjunto de pasos a realizar.
Partimos de una sencilla base de datos en SQL Server, que contiene la tabla Clientes, con los campos ms
caractersticos de esta entidad de datos: cdigo cliente, nombre, fecha ingreso, crdito. Una vez creado un nuevo
proyecto en VB.NET, disearemos el formulario de la aplicacin que como vemos en la Figura 346, a travs de sus
controles, nos permitir realizar las operaciones mencionadas.
Pasando a la escritura del cdigo del programa, en primer lugar importaremos el espacio de nombres
System.Data.SqlClient, y declararemos a nivel de clase un conjunto de variables para la manipulacin de los datos.
Veamos el Cdigo fuente 572.
Imports
System.Data.SqlClient
Public
Class
Form1
Inherits
System.Windows.Forms.Form
'
variables
'
la
nivel
clase
manipulacin
Private
oDataAdapter
Private
oDataSet
Private
de
iPosicFilaActual
'....
'....
Cdigo fuente 572 Figura 346. Formulario de navegacin y edicin manual de datos.
de
As
para
datos
SqlDataAdapter
As
DataSet
As
Integer
Como siguiente paso, escribiremos el manipulador del evento Load del formulario y un mtodo para cargar los
datos del registro actual en los controles del formulario, el Cdigo fuente 573 muestra esta parte.
Private
MyBase.Load
Sub
Form1_Load(ByVal
sender
'
Dim
oConexion
oConexion
=
oConexion.ConnectionString
As
Object,
ByVal
As
System.EventArgs)
crear
conexin
SqlConnection
SqlConnection()
&
_
As
New
"Server=(local);"
Handles
"Database=Gestion;uid=sa;pwd=;"
'
Me.oDataAdapter
oConexion)
New
crear
SqlDataAdapter("SELECT
As
crear
SqlCommandBuilder
'
Dim
oCommBuild
'
Me.oDataSet
FROM
New
adaptador
Clientes", _
commandbuilder
SqlCommandBuilder(oDataAdapter)
crear
=
'
establecer
'
a
Me.iPosicFilaActual
cargar
dataset
DataSet()
New
oConexion.Open()
'
llenar
con
Me.oDataAdapter.Fill(oDataSet,
oConexion.Close()
'
el
el
mostrar
columnas
adaptador
indicador
de
=
del
el
del
la
registro
dataset
"Clientes")
registro
tabla
0
en
'
Me.CargarDatos()
los
controles
del
formulario
End
Sub
Private
'
Dim
oDataRow
'
'
Sub
obtener
un
oDataRow
=
cargar
los
CargarDatos()
objeto
la
fila
actual
As
DataRow
Me.oDataSet.Tables("Clientes").Rows(Me.iPosicFilaActual)
los
con
controles
valores
de
del
los
formulario
campos
con
del
registro
Me.txtIDCliente.Text
oDataRow("IDCliente")
Me.txtNombre.Text
oDataRow("Nombre")
Me.txtFIngreso.Text
oDataRow("FIngreso")
Me.txtCredito.Text
oDataRow("Credito")
'
'
mostrar
y
la
posicin
el
nmero
Me.lblRegistro.Text
Me.iPosicFilaActual
=
+
actual
del
total
del
"Registro:
1
&
registros
"
"
registro
de
&
"
_
&
Me.oDataSet.Tables("Clientes").Rows.Count
End
Sub
Observe el lector que en el evento Load hemos creado un objeto CommandBuilder, pasndole como parmetro
el DataAdapter. Como ya sabemos, un DataAdapter contiene una serie de objetos Command para las operaciones de
consulta, insercin, etc. La misin en este caso del objeto CommandBuilder, es la de construir automticamente tales
comandos y asignrselos al DataAdapter, ahorrndonos ese trabajo de codificacin.
En cuanto a las operaciones de navegacin por la tabla, no hay un objeto, como ocurra con el Recordset de
ADO, que disponga de mtodos especficos de movimiento como MoveNext( ), MoveLast( ), etc. Lo que debemos
hacer en ADO .NET, tal y como muestra el mtodo CargarDatos(), es obtener del DataSet, la tabla que necesitemos
mediante su coleccin Tables, y a su vez, a la coleccin Rows de esa tabla, pasarle el nmero de fila/registro al que
vamos a desplazarnos. En nuestro ejemplo utilizaremos la variable iPosicFilaActual, definida a nivel de clase, para
saber en todo momento, la fila de la tabla en la que nos encontramos.
El Cdigo fuente 574 muestra el cdigo de los botones de navegacin, reunidos en el GroupBox Navegar, del
formulario.
Private Sub
System.EventArgs)
btnAvanzar_Click(ByVal sender
Handles
As
System.Object, ByVal e As
btnAvanzar.Click
'
si
estamos
'
en
el
no
If
ltimo
registro,
hacer
movimiento
Me.iPosicFilaActual
(Me.oDataSet.Tables("Clientes").Rows.Count
1)
Then
MessageBox.Show("ltimo
registro")
Else
'
'
incrementar
el
marcador
de
registro
actualizar
'
los
datos
controles
del
con
registro
Me.iPosicFilaActual
los
actual
+=
Me.CargarDatos()
End
If
End
Sub
Private Sub
System.EventArgs)
'
si
'
If
btnRetroceder_Click(ByVal sender
Handles
estamos
no
Me.iPosicFilaActual
As
en
System.Object, ByVal e As
btnRetroceder.Click
el
hacer
=
primer
registro,
movimiento
Then
MessageBox.Show("Primer
registro")
Else
'
disminuir
'
y
actualizar
'
datos
Me.iPosicFilaActual
Me.CargarDatos()
el
marcador
de
controles
registro
-=
los
del
con
registro
los
actual
1
End
If
End
Sub
Private Sub
System.EventArgs)
btnPrimero_Click(ByVal sender
Handles
'
establecer
Me.iPosicFilaActual
Me.CargarDatos()
el
marcador
As
System.Object, ByVal e As
btnPrimero.Click
de
registro
en
el
End
Private Sub
System.EventArgs)
primero
0
Sub
btnUltimo_Click(ByVal sender
Handles
As
System.Object, ByVal e As
btnUltimo.Click
'
establecer
'
obteniendo
el
Me.iPosicFilaActual
Me.CargarDatos()
el
nmero
=
marcador
de
registro
en
el
primero
de
filas
que
contiene
la
tabla
menos
uno
(Me.oDataSet.Tables("Clientes").Rows.Count
1)
End
Sub
Respecto a las operaciones de edicin, debemos utilizar los miembros del objeto tabla del DataSet, como se
muestra en el Cdigo fuente 575. Una vez terminado el proceso de edicin, actualizaremos el almacn de datos
original con el contenido del DataSet, empleando el DataAdapter.
Private Sub
System.EventArgs)
Dim
'
obtener
oDataRow
btnInsertar_Click(ByVal sender
Handles
un
nuevo
oDataRow
objeto
=
'
asignar
oDataRow("IDCliente")
oDataRow("Nombre")
oDataRow("FIngreso")
oDataRow("Credito")
valor
As
System.Object, ByVal e As
btnInsertar.Click
As
DataRow
de
la
tabla
del
dataset
Me.oDataSet.Tables("Clientes").NewRow()
fila
los
campos
de
=
=
=
=
'
aadir
el
objeto
fila
'
de
la
Me.oDataSet.Tables("Clientes").Rows.Add(oDataRow)
a
tabla
la
la
nueva
fila
Me.txtIDCliente.Text
Me.txtNombre.Text
Me.txtFIngreso.Text
Me.txtCredito.Text
coleccin
del
de
End
Private Sub
System.EventArgs)
Dim
'
obtener
'
en
oDataRow
Sub
btnModificar_Click(ByVal sender
Handles
el
=
'
modificar
'
excepto
la
oDataRow("Nombre")
oDataRow("FIngreso")
oDataRow("Credito")
As
System.Object, ByVal e As
btnModificar.Click
oDataRow
As
DataRow
objeto
fila
de
la
tabla
del
dataset
el
que
estamos
posicionados
Me.oDataSet.Tables("Clientes").Rows(Me.iPosicFilaActual)
las
columnas
correspondiente
al
=
=
=
de
la
fila
identificador
cliente
Me.txtNombre.Text
Me.txtFIngreso.Text
Me.txtCredito.Text
End
Private Sub
System.EventArgs)
filas
dataset
Sub
btnActualizar_Click(ByVal sender
Handles
As
System.Object, ByVal e As
btnActualizar.Click
'
actualizar
los
'
contra
la
Me.oDataAdapter.Update(Me.oDataSet,
cambios
base
realizados
de
en
el
datos
End
dataset
real
"Clientes")
Sub
El caso del borrado de filas es algo diferente, por ello lo mostramos aparte del resto de operaciones de edicin.
En el Cdigo fuente 576 vemos el cdigo del botn Eliminar, dentro del cual, obtenemos la fila a borrar mediante un
objeto DataRow, procediendo a su borrado con el mtodo Delete( ). Para actualizar los borrados realizados,
empleamos el mtodo GetChanges( ) del objeto DataTable, obteniendo a su vez, un objeto tabla slo con las filas
borradas; informacin esta, que pasaremos al DataAdapter, para que actualice la informacin en el origen de datos.
Private Sub
System.EventArgs)
Dim
'
obtener
'
en
oDataRow
oDataRow.Delete()
btnEliminar_Click(ByVal sender
Handles
el
'
mediante
'
con
Dim
oTablaBorrados
As
System.Object, ByVal e As
btnEliminar.Click
oDataRow
As
DataRow
objeto
fila,
de
la
tabla
del
dataset
el
que
estamos
posicionados
Me.oDataSet.Tables("Clientes").Rows(Me.iPosicFilaActual)
'
borrar
la
fila
el
mtodo
GetChanges(),
las
oTablaBorrados
obtenemos
filas
As
una
tabla
borradas
DataTable
=
Me.oDataSet.Tables("Clientes").GetChanges(DataRowState.Deleted)
'
actualizar
en
el
Me.oDataAdapter.Update(oTablaBorrados)
almacn
de
datos
'
confirmar
los
Me.oDataSet.Tables("Clientes").AcceptChanges()
'
reposicionar
Me.btnPrimero.PerformClick()
End
en
las
cambios
la
primera
filas
borradas
realizados
fila
Sub
Pasando al cdigo de la clase del formulario, deberemos realizar las siguientes declaraciones a nivel de clase,
mostradas en el Cdigo fuente 577.
Imports
System.Data.SqlClient
Public
Inherits
Class
Form1
System.Windows.Forms.Form
Private
Private
Private
'....
'....
oDataAdapter
oDataSet
oBMB
As
As
SqlDataAdapter
DataSet
BindingManagerBase
As
En el evento de carga del formulario, aparte de la creacin de los objetos de conexin, adaptador, etc.,
estableceremos el enlace entre los controles y el DataSet, como se muestra en el Cdigo fuente 578.
Private
MyBase.Load
Sub
Form1_Load(ByVal
'
Dim
oConexion
oConexion.ConnectionString
"Database=Gestion;uid=sa;pwd=;"
sender
As
Object,
crear
As
=
ByVal
As
New
"Server=(local);"
System.EventArgs)
Handles
conexin
SqlConnection()
&
_
'
oDataAdapter
'
Dim
oCB
crear
SqlDataAdapter("SELECT
New
crear
SqlCommandBuilder
As
'
oDataSet
oDataAdapter.Fill(oDataSet,
FROM
Clientes",
commandbuilder
SqlCommandBuilder(oDataAdapter)
New
crear
=
adaptador
oConexion)
dataset
DataSet()
"Clientes")
New
'
enlazar
controles
del
formulario
con
el
dataset;
'
se
debe
utilizar
un
objeto
Binding,
al
crear
este
objeto
'
indicar
en
su
constructor
qu
propiedad
del
control
'
se
debe
enlazar,
el
dataset,
y
el
nombre
de
tabla-columna;
'
una
vez
creado
el
objeto
Binding,
aadirlo
a
la
coleccin
'
de
enlaces
de
datos,
DataBindings,
del
control
que
necesitemos,
'
con
el
mtodo
Add()
de
dicha
coleccin
Dim
oBind
As
Binding
oBind
=
New
Binding("Text",
oDataSet,
"Clientes.IDCliente")
Me.txtIDCliente.DataBindings.Add(oBind)
oBind
=
Nothing
oBind
=
New
Me.txtNombre.DataBindings.Add(oBind)
oBind
Binding("Text",
Nothing
oBind
=
New
Binding("Text",
Me.txtCredito.DataBindings.Add(oBind)
oBind
=
obtener
enlace
del
de
un
"Clientes.Nombre")
oBind
=
New
Binding("Text",
'AddHandler
oBind.Format,
Me.txtFIngreso.DataBindings.Add(oBind)
oBind
=
'
'
el
Me.oBMB
oDataSet,
oDataSet,
AddressOf
"Clientes.FIngreso")
FormatoFecha
Nothing
oDataSet,
"Clientes.Credito")
Nothing
contexto
de
enlace
dataset
y
una
Me.BindingContext(oDataSet,
del
tabla
formulario,
determinadas
"Clientes")
Me.VerContadorReg()
End
Sub
Private
Sub
VerContadorReg()
'
mostrar
informacin
sobre
el
nmero
de
'
registro
actual
y
registros
totales
'
en
la
tabla
del
dataset
Me.lblRegistro.Text
=
"Registro:
"
&
_
Me.oBMB.Position
End
&
"
de
"
&
Me.oBMB.Count
Sub
Debido al enlace automtico, el cdigo para las operaciones de navegacin se simplifica en gran medida, como
muestra el Cdigo fuente 579, en el que vemos los manipuladores de evento para los botones de desplazamiento del
formulario.
Private Sub
System.EventArgs)
'
avanzar
'
la
'
de
'
btnAvanzar_Click(ByVal sender
Handles
a
actualizacin
la
es
As
la
de
fila
en
automtica,
System.Object, ByVal e As
btnAvanzar.Click
siguiente
los
controles
la
que
gracias
con
acabamos
al
Me.oBMB.Position
fila;
objeto
los
de
datos
posicionarnos
BindingManagerBase
+=
Me.VerContadorReg()
End
Private
Sub
System.EventArgs)
Sub
btnRetroceder_Click(ByVal
sender
Handles
As
Me.oBMB.Position
Me.VerContadorReg()
System.Object,
ByVal
e
As
btnRetroceder.Click
-=
End
Private
Sub
System.EventArgs)
Sub
btnPrimero_Click(ByVal
sender
Handles
As
Me.oBMB.Position
Me.VerContadorReg()
System.Object,
ByVal
e
As
btnPrimero.Click
End
Private
Sub
System.EventArgs)
Me.oBMB.Position
Me.VerContadorReg()
Sub
btnUltimo_Click(ByVal
sender
Handles
End
As
System.Object,
Me.oBMB.Count
ByVal
e
As
btnUltimo.Click
Sub
Como detalle importante a observar en las operaciones de navegacin entre los registros, destacaremos el hecho
de que al mostrar el campo que contiene una fecha, dicho dato se muestra con toda la informacin al completo, fecha y
hora, sin ningn formato especfico.
Para conseguir en este caso, que la fecha se muestre con el formato que necesitemos, al crear el objeto Binding
para ese control, deberemos asignar a su evento Format un procedimiento manipulador, que realice tal formateo y lo
devuelva a travs del objeto ConvertEventArgs, que recibe ese evento. Veamos estas operaciones en el Cdigo fuente
580.
Private
Sub
Form1_Load(ByVal
sender
MyBase.Load
'....
oBind
=
New
Binding("Text",
AddHandler
oBind.Format,
Me.txtFIngreso.DataBindings.Add(oBind)
oBind
=
'....
As
Object,
oDataSet,
AddressOf
ByVal
As
System.EventArgs)
"Clientes.FIngreso")
FormatoFecha
Nothing
End
'
Private
Handles
Sub
manipulador
del
Sub FormatoFecha(ByVal
Dim
dtFecha
e.Value
Evento
sender As
format
del
Object, ByVal e
dtFecha
As
objeto
Binding
ConvertEventArgs)
As
=
End
DateTime
e.Value
dtFecha.ToString("dd-MMMM-yyyy")
Sub
Figura 349. Control enlazado a datos, que muestra una fecha con formato personalizado.
El proceso de edicin (insercin en este ejemplo), es muy similar al caso anterior. Aunque debemos tener en
cuenta que debido a las particularidades del Data Binding, no podemos borrar el contenido de los TextBox, teclear
datos e insertarlos, ya que eso realmente modificara el registro sobre el que estbamos posicionados. Por ese motivo,
en el botn Insertar, asignamos los valores directamente a las columnas del objeto DataRow. Ver el Cdigo fuente
581.
Private Sub
System.EventArgs)
Dim
btnInsertar_Click(ByVal sender
Handles
As
System.Object, ByVal e As
btnInsertar.Click
oDataRow
'
crear
un
oDataRow
=
'
aadir
datos
a
las
oDataRow("IDCliente")
oDataRow("Nombre")
oDataRow("FIngreso")
oDataRow("Credito")
'
aadir
el
objeto
'
de
filas
Me.oDataSet.Tables("Clientes").Rows.Add(oDataRow)
As
nuevo
objeto
fila
Me.oDataSet.Tables("Clientes").NewRow()
columnas
de
la
fila
=
100
=
"Isabel"
=
"12/9/01"
=
228
fila
a
la
coleccin
de
la
tabla
End
Private
Sub
System.EventArgs)
Sub
btnActualizar_Click(ByVal
sender
Handles
Me.oDataAdapter.Update(Me.oDataSet,
End
DataRow
As
System.Object,
ByVal
e
As
btnActualizar.Click
"Clientes")
Sub
DataGrid
Este control, del que ya realizamos una pequea demostracin en un apartado anterior, nos va a permitir realizar
enlace complejo de datos con ADO .NET.
Se trata de la versin mejorada del control DataGrid de ADO, disponible en Visual Basic 6, pero con una serie
de funcionalidades optimizadas, y otras nuevas aadidas.
Para utilizar algunas de sus caractersticas, crearemos un proyecto de prueba con el nombre DataGridPru (hacer
clic aqu para acceder a este ejemplo), consistente en un formulario MDI, con una serie de opciones de men, a travs
de las cuales, mostraremos diversas caractersticas de este control, y algunas otras adicionales sobre ADO .NET.
La opcin de men DataGrid + Normal, mostrar el formulario frmNormal, que contiene un sencillo DataGrid
con una tabla. Podemos editar los registros de la tabla y aadir nuevos; al trabajar en desconexin, hasta que no
pulsemos el botn Actualizar de este formulario, el objeto DataAdapter del mismo no actualizar los datos del DataSet
hacia la base de datos fsica. Otra caracterstica incluida por defecto es la ordenacin de las filas por columna al hacer
clic en su ttulo. Finalmente, al redimensionar el formulario, tambin cambiar el tamao del DataGrid, puesto que
hemos utilizado su propiedad Anchor para anclarlo a todos los bordes de la ventana. La Figura 350 muestra este
formulario.
El Cdigo fuente 582 muestra el cdigo principal de este formulario. Recordamos al lector, la necesidad de
crear un objeto CommandBuilder para el DataAdapter, ya que en caso contrario, al intentar actualizar el DataSet
contra la base de datos, se producir un error.
Private
Private
oDataAdapter
oDataSet
As
As
SqlDataAdapter
DataSet
Private
Handles
Sub
frmNormal_Load(ByVal
sender
As
Object,
ByVal
As
System.EventArgs)
MyBase.Load
Private
Handles
Sub
frmNormal_Load(ByVal
sender
As
Object,
ByVal
As
System.EventArgs)
MyBase.Load
'
Dim
oConexion
oConexion.ConnectionString
crear
As
=
New
"Server=(local);"
conexin
SqlConnection()
&
_
"Database=Musica;uid=sa;pwd=;"
'
oDataAdapter
New
'
Dim
oCB
As
crear
SqlDataAdapter("SELECT
crear
SqlCommandBuilder
'
oDataSet
oDataAdapter.Fill(oDataSet,
FROM
New
crear
=
New
Grabaciones",
adaptador
oConexion)
commandbuilder
SqlCommandBuilder(oDataAdapter)
dataset
DataSet()
"Grabaciones")
'
asignar
Me.grdDatos.DataSource
Me.grdDatos.DataMember
dataset
End
Private
Sub
btnActualizar_Click(ByVal
sender
System.EventArgs)
Handles
Me.oDataAdapter.Update(oDataSet,
End
al
=
As
datagrid
oDataSet
"Grabaciones"
Sub
System.Object,
ByVal
e
As
btnActualizar.Click
"Grabaciones")
Sub
En el siguiente paso, abriremos el Cuadro de herramientas, y pulsaremos la ficha Data, aadiendo al formulario
un control SqlDataAdapter, lo que abrir un asistente para la configuracin de este control. Ver Figura 352.
Tras la ventana de presentacin, al pulsar el botn Siguiente, deberemos elegir la conexin que el adaptador
utilizar. Ver Figura 353.
A continuacin seleccionaremos el tipo de consulta, en este caso una sencilla sentencia SQL. Ver Figura 354.
Continuaremos con la escritura de la sentencia SQL que quedar incluida en el DataAdapter. Ver Figura 355.
Como paso final, se muestra un resumen de lo que este asistente ha generado en el DataAdapter. Figura 356.
Finalizada la creacin del adaptador de datos, seleccionaremos el men Datos + Generar conjunto de datos del
IDE, que nos mostrar una ventana en la que daremos el nombre del DataSet que utilizar el formulario, y nos
permitir elegir las tablas que contendr. Ver Figura 357.
Completado este ltimo paso, el DataGrid mostrar en tiempo de diseo, la disposicin de las columnas de la
tabla en su interior. Ver Figura 359.
Figura 359. DataGrid mostrando informacin de las columnas de la tabla del DataSet.
En cuanto al cdigo que debemos escribir, en el evento Load, inicializaremos el DataSet, rellenndolo a
continuacin mediante el DataAdapter. Ver Cdigo fuente 583.
Private
Handles
Sub
frmGridAsist_Load(ByVal
sender
As
Object,
ByVal
As
System.EventArgs)
MyBase.Load
Me.DsMusica1.Clear()
Me.SqlDataAdapter1.Fill(Me.DsMusica1)
End
Sub
Podremos ver este formulario en ejecucin al seleccionar en el formulario principal del ejemplo, el men
DataGrid + Asistente.
Private Sub
System.EventArgs)
frmGridPropCod_Load(ByVal sender
Handles
'
Dim
oConexion
oConexion.ConnectionString
crear
As
As
Object,
ByVal e As
MyBase.Load
New
"Server=(local);"
conexin
SqlConnection()
&
_
"Database=Musica;uid=sa;pwd=;"
'
oDataAdapter
'
Dim
oCB
As
New
crear
SqlDataAdapter("SELECT
crear
SqlCommandBuilder
=
New
FROM
Grabaciones",
adaptador
oConexion)
commandbuilder
SqlCommandBuilder(oDataAdapter)
'
oDataSet
oDataAdapter.Fill(oDataSet,
crear
=
'
asignar
Me.grdDatos.DataSource
Me.grdDatos.DataMember
'
Me.grdDatos.Anchor
dataset
configurar
=
crear
columna
de
grid
AnchorStyles.Bottom
+
listado
=
=
"El
objeto
As
por
AnchorStyles.Left
de
las
para
estilos
=
=
=
objetos
la
tabla
oColGrid
de
oColGrid
=
oColGrid.TextBox.Enabled
oColGrid.Alignment
oColGrid.HeaderText
=
oColGrid.MappingName
oColGrid.Width
oColGrid.Format
=
oEstiloGrid.GridColumnStyles.Add(oColGrid)
oColGrid
As
objeto
para
cada
el
datagrid
DataGridTextBoxColumn
de
columna-grid
DataGridTextBoxColumn()
=
False
HorizontalAlignment.Center
"Descripcin
grabac."
columna
del
dataset
que
esta
columna
del
grid
=
"Titulo"
=
300
al
objeto
que
contiene
datagrid,
en
concreto,
de
estilos
de
columna
New
Nothing
New
=
=
"Fecha
=
=
"ddd,
=
=
=
=
"Valor
=
=
=
=
DataGridTextBoxColumn()
False
HorizontalAlignment.Left
COMPRA"
"FCompra"
110
d-MMM-yyy"
Nothing
New
oColGrid.Width
oColGrid.Format
oEstiloGrid.GridColumnStyles.Add(oColGrid)
oColGrid
del
datagrid
DataGridTableStyle()
"Grabaciones"
Color.LightGoldenrodYellow
Color.Aquamarine
columna-grid
mostrar
en
cdigo
+
AnchorStyles.Top
grabaciones"
Color.Turquoise
Color.Black
New
'
configurar
cada
oColGrid
=
oColGrid.TextBox.Enabled
oColGrid.Alignment
=
oColGrid.HeaderText
=
'
nombre
de
la
'
se
mapea
hacia
oColGrid.MappingName
oColGrid.Width
'
aadir
la
columna
'
los
estilos
del
'
a
la
coleccin
oEstiloGrid.GridColumnStyles.Add(oColGrid)
oColGrid
oColGrid
oColGrid.TextBox.Enabled
oColGrid.Alignment
oColGrid.HeaderText
oColGrid.MappingName
datagrid
oDataSet
"Grabaciones"
'
crear
un
Dim
oEstiloGrid
oEstiloGrid.MappingName
oEstiloGrid.BackColor
oEstiloGrid.AlternatingBackColor
'
al
=
AnchorStyles.Right
Me.grdDatos.CaptionText
=
Me.grdDatos.CaptionBackColor
Me.grdDatos.CaptionForeColor
'
Dim
dataset
DataSet()
"Grabaciones")
New
DataGridTextBoxColumn()
False
HorizontalAlignment.Right
pagado"
"Precio"
85
"#,#"
Nothing
'
una
vez
creadas
'
estilos
para
el
'
que
contiene
'
a
la
coleccin
'
del
Me.grdDatos.TableStyles.Add(oEstiloGrid)
todas
grid,
el
de
las
aadir
estilo
estilos
columnas
de
el
objeto
personalizado
de
tablas
datagrid
End
Sub
Private
Sub
frmGridTablas_Load(ByVal
sender
Handles
'
As
Object,
ByVal
As
System.EventArgs)
MyBase.Load
crear
conexin
Dim
oConexion
As
oConexion.ConnectionString
New
SqlConnection()
"Server=(local);"
&
"Database=Musica;uid=sa;pwd=;"
'
Dim
Dim
oDAAutores
As
oDAGrabaciones
New
As
crear
SqlDataAdapter("SELECT
*
New
SqlDataAdapter("SELECT
FROM
*
adaptadores
Autores",
oConexion)
FROM
Grabaciones",
New
dataset
DataSet()
"Autores")
"Grabaciones")
oConexion)
'
Dim
oDataSet
oDAAutores.Fill(oDataSet,
oDAGrabaciones.Fill(oDataSet,
'
asignar
Me.grdDatos.DataSource
crear
As
dataset
a
=
End
datagrid
oDataSet
Sub
Como al asignar el DataSet al DataGrid no hemos indicado qu tabla queremos que muestre, el DataGrid en el
formulario visualizar un nodo que al expandir, nos permitir seleccionar la tabla a mostrar. Podremos contraer dicha
tabla para seleccionar otra, y as sucesivamente. Ver Figura 362.
(hacer clic aqu para acceder a este ejemplo), en el que a travs de un formulario MDI, crearemos varios formularios
hijos, cada uno con un tipo de relacin.
Private
Sub
frmManual_Load(ByVal
Handles
'
crear
Dim
oConexion
As
oConexion.ConnectionString
=
sender
As
Object,
ByVal
As
System.EventArgs)
MyBase.Load
conexin
New
SqlConnection()
"server=(local);"
&
_
"database=Northwind;uid=sa;pwd=;"
Dim
Dim
'
daCustomers
As
daOrders
As
crear
SqlDataAdapter("SELECT
SqlDataAdapter("SELECT
New
New
'
oDataSet
FROM
Customers",
FROM
Orders",
adaptadores
oConexion)
oConexion)
instanciar
=
relacionar
las
dataset
DataSet()
New
oConexion.Open()
'
utilizar
los
dataadapters
daCustomers.Fill(oDataSet,
daOrders.Fill(oDataSet,
oConexion.Close()
'
*
*
dos
para
llenar
tablas
del
el
dataset
dataset
por
con
tablas
"Customers")
"Orders")
campo
comn
oDataSet.Relations.Add("Customers_Orders",
oDataSet.Tables("Customers").Columns("CustomerID"),
oDataSet.Tables("Orders").Columns("CustomerID"))
'
Dim
For
"-"
Next
End
llenar
el
Each
combobox
oDataRow
oDataRow
con
_
_
los
In
nombres
de
cliente
As
DataRow
oDataSet.Tables("Customers").Rows
Me.cboCustomers.Items.Add(oDataRow("CustomerID")
&
_
&
oDataRow("CompanyName"))
Sub
'
cada
vez
que
se
selecciona
'
se
produce
Private
Sub
cboCustomers_SelectedIndexChanged(ByVal
System.EventArgs)
Handles
'
limpiar
Me.lstOrders.Items.Clear()
los
un
valor
en
el
combo
este
evento
sender
As
Object,
ByVal
e
As
cboCustomers.SelectedIndexChanged
valores
del
listbox
Dim
'
obtener
drFilaPadre
Dim
'
obtener
'
gracias
drFilasHijas
'
For
"-"
"-"
Dim
rellenar
la
=
las
el
Each
drFilaPadre
As
DataRow
fila
de
la
tabla
maestra:
Customers
oDataSet.Tables("Customers").Rows(Me.cboCustomers.SelectedIndex)
drFilasHijas()
filas
a
=
drFila
listbox
hijas
la
con
drFila
As
DataRow
la
tabla
Orders,
relacin
Customers-Orders
drFilaPadre.GetChildRows("Customers_Orders")
de
valores
Me.lstOrders.Items.Add(drFila("CustomerID")
&
drFila("OrderID")
&
As
de
In
las
&
DataRow
filas
hijas
drFilasHijas
_
&
_
drFila("OrderDate"))
Next
End
Sub
El formulario frmRelacGrid, al que accederemos con el men Relacionar + DataGrid, es un ejemplo de este
tipo de relacin de datos. El cdigo de su evento Load es igual al del anterior formulario, por lo que el Cdigo fuente
587 slo muestra la creacin de la relacin en el DataSet, y la asignacin de la tabla maestra al DataGrid.
'
relacionar
las
dos
tablas
del
dataset
por
campo
comn
oDataSet.Relations.Add("Customers_Orders",
oDataSet.Tables("Customers").Columns("CustomerID"),
oDataSet.Tables("Orders").Columns("CustomerID"))
'
asignar
la
Me.grdDatos.DataSource
tabla
=
maestra
al
datagrid
oDataSet.Tables("Customers")
Al abrir este formulario, se visualizarn los datos de la tabla maestra Customers. Cada fila contiene un nodo
expandible, que al ser pulsado muestra la relacin existente. Si volvemos a hacer clic sobre la relacin, se mostrarn en
este caso las filas hijas de la tabla Orders, relacionadas con la que hemos seleccionado en la tabla padre. Ver Figura
364 y Figura 365.
En todo momento, desde la vista de las tablas hijas, podemos volver a la vista de la tabla padre, haciendo clic en
el icono con forma de flecha situado en el ttulo del DataGrid.
'
relacionar
las
dos
tablas
del
dataset
por
campo
comn
oDataSet.Relations.Add("Customers_Orders",
oDataSet.Tables("Customers").Columns("CustomerID"),
oDataSet.Tables("Orders").Columns("CustomerID"))
'
maestro
=
asignar
'
que
acabamos
Me.grdOrders.DataSource
Me.grdOrders.DataMember
la
=
al
Customers
oDataSet
"Customers"
datagrid
de
tabla
detalles
la
relacin
crear
por
cdigo
=
oDataSet
"Customers.Customers_Orders"
La Figura 366 muestra el formulario con ambos DataGrid trabajando en modo conjunto; al hacer clic en una fila
del DataGrid maestro, el DataGrid detalle se actualizar con los datos relacionados.
'
relacionar
las
dos
tablas
del
dataset
por
campo
comn
oDataSet.Relations.Add("Customers_Orders",
oDataSet.Tables("Customers").Columns("CustomerID"),
oDataSet.Tables("Orders").Columns("CustomerID"))
maestro
la
tabla
=
=
datagrid
al
acabamos
maestro
=
=
Customers
oDataSet
"Customers"
la
tabla
Customers
oDataSet
"Customers"
datagrid
de
detalles
crear
=
la
por
relacin
cdigo
oDataSet
"Customers.Customers_Orders"
Private
MyBase.Load
Sub
Form1_Load(ByVal
sender
'
Dim
oConexion
oConexion.ConnectionString
As
Object,
crear
As
=
ByVal
As
New
"Server=(local);"
System.EventArgs)
Handles
conexin
SqlConnection()
&
_
"Database=Northwind;uid=sa;pwd=;"
'crear
oDataSet
New
dataset
DataSet()
Dim
'
crear
oDataAdapter
un
=
oDataAdapter
adaptador
de
datos
New
SqlDataAdapter("SELECT
'
aadir
tabla
oDataAdapter.Fill(oDataSet,
oDataAdapter
'
crear
oDataAdapter
=
un
New
al
As
para
*
FROM
dataset
la
tabla
Customers",
con
SqlDataAdapter
Customers
oConexion)
el
adaptador
"Customers")
Nothing
adaptador
de
datos
SqlDataAdapter("SELECT
*
'
aadir
tabla
oDataAdapter.Fill(oDataSet,
oDataAdapter
al
para
FROM
dataset
la
tabla
Products",
con
el
Products
oConexion)
adaptador
"Products")
Nothing
End
Sub
Private
Sub
mnuNormal_Click(ByVal
System.EventArgs)
'
crear
una
vista
'
a
Dim
dvNormal
dvNormal
=
New
Me.grdDatos.CaptionText
Me.grdDatos.DataSource
'
tomar
la
'
del
dataset
Me.grdDatosBIS.CaptionText
Me.grdDatosBIS.DataSource
sender
As
System.Object,
ByVal
As
Handles
mnuNormal.Click
por
cdigo
y
asignarla
un
datagrid
As
DataView
DataView(oDataSet.Tables("Customers"))
=
"Customers"
=
dvNormal
vista
y
=
por
defecto
de
una
tabla
asignarla
a
un
datagrid
=
"Products"
oDataSet.Tables("Products").DefaultView
End
Sub
Private Sub
System.EventArgs)
mnuPais_Click(ByVal
'
Dim
oDataView
oDataView.Table
'
establecer
oDataView.RowFilter
Me.grdDatos.CaptionText
Me.grdDatos.DataSource
End
sender
Handles
As
System.Object,
crear
As
dataview
New
DataView()
oDataSet.Tables("Customers")
un
filtro
"Country='Spain'"
=
=
"Filtrar
ByVal e As
mnuPais.Click
Customers
=
por
pas
Spain"
oDataView
Sub
Como hemos comentado anteriormente, a partir de un DataTable podemos obtener varios filtros mediante
distintos objetos DataView, sin que ello suponga una penalizacin en el consumo de recursos. Para demostrar este
punto, la opcin Vistas + Combinada, crea una vista basada en un filtro combinado, y una vista normal, ambas
empleando la misma tabla base. Veamos el Cdigo fuente 593.
Private Sub
System.EventArgs)
'
tomar
'
...filtro
mnuCombinada_Click(ByVal sender
Handles
la
tabla
combinado
Dim
por
dos
Dim
"ContactTitle
"Filtro
depositar
campos
por
Me.grdDatosBIS.CaptionText
Me.grdDatosBIS.DataSource
en
aplicar...
un
New
un
LIKE
campo
'%Manager%'
por
AND
campos
DataView()
Country
IN
ContactTitle
depositar
As
otro
Country"
oDataView
datagrid
DataView()
oDataSet.Tables("Customers")
"ContactName
en
New
=
=
datagrid
oDataSet.Tables("Customers")
combinado
oDV
oDV.RowFilter
oDV.Table
End
dataset
Me.grdDatos.CaptionText
Me.grdDatos.DataSource
...filtro
del
As
oDataView.Table
'
System.Object, ByVal e As
mnuCombinada.Click
Customers
oDataView
oDataView.RowFilter
('Spain','USA')"
As
LIKE
"Filtro
por
=
campo
'%an%'"
ContactName"
oDV
Sub
Private Sub
System.EventArgs)
mnuBuscarFila_Click(ByVal sender
Handles
'
crear
un
dataview
y
'
estableciendo
Dim
oDataView
oDataView.Table
=
oDataView.RowFilter
=
"CustomerID
Me.grdDatosBIS.CaptionText
=
"Buscar
Me.grdDatosBIS.DataSource
End
buscar
As
System.Object, ByVal e As
mnuBuscarFila.Click
una
fila
en
la
vista
filtro
As
New
DataView()
oDataSet.Tables("Customers")
=
'"
&
Me.txtCustomerID.Text
&
"'"
ID
cliente:
"
&
Me.txtCustomerID.Text
=
oDataView
un
Sub
En la Figura 371 vemos el resultado de una bsqueda, mostrado en uno de los DataGrid del formulario.
Figura 371. Bsqueda de una fila en una tabla de un DataSet, empleando un DataView.
Private Sub
System.EventArgs)
mnuOrdNormal_Click(ByVal sender
Handles
'
crear
'
con
Dim
oDataView
oDataView.Table
oDataView.Sort
Me.grdDatos.CaptionText
Me.grdDatos.DataSource
dataview
As
y
la
As
=
=
"Ordenar
End
System.Object, ByVal e As
mnuOrdNormal.Click
ordenar
las
filas
propiedad
Sort
New
DataView()
oDataSet.Tables("Customers")
"Country"
por
campo
Country"
oDataView
Sub
oDataView.Sort
"Country,
PostalCode"
Tambin es factible asignar a un DataView una combinacin de filtro y ordenacin, utilizando en la misma
operacin las propiedades RowFilter y Sort. El men del formulario Ordenacin + Con filtro realiza este trabajo, que
vemos en el Cdigo fuente 597.
Private Sub
System.EventArgs)
mnuOrdenFiltro_Click(ByVal sender
Handles
Dim
oDataView
oDataView.Table
=
'
establecer
un
oDataView.RowFilter
'
ordenar
las
oDataView.Sort
Me.grdDatos.CaptionText
=
"Filtrar
Me.grdDatos.DataSource
As
System.Object, ByVal e As
mnuOrdenFiltro.Click
As
filtro
=
filas
=
por
USA.
=
New
DataView()
oDataSet.Tables("Customers")
al
dataview
"Country='USA'"
del
filtro
"City"
Ordenar
por
campo
City"
oDataView
End
Los datos con el filtro y orden podemos verlos en el DataGrid del formulario, que muestra la Figura 373.
Sub
Private Sub
System.EventArgs)
btnEsquema_Click(ByVal sender
Handles
'
Dim
oConexion
oConexion.ConnectionString
As
crear
As
System.Object, ByVal e As
btnEsquema.Click
conexin
SqlConnection()
&
_
New
"Server=(local);"
"Database=Northwind;uid=sa;pwd=;"
'
Dim
'
'
Dim
crear
As
oDataSet
crear
aadir
adaptadores
cada
tabla
oDataAdapter
oDataAdapter
=
New
oDataAdapter.Fill(oDataSet,
oDataAdapter
oDataAdapter
=
New
oDataAdapter.Fill(oDataSet,
de
al
dataset
DataSet()
New
datos
dataset
As
SqlDataAdapter("SELECT
para
con
FROM
las
tablas
el
adaptador
SqlDataAdapter
Customers",
oConexion)
"Customers")
Nothing
Orders",
oConexion)
"Orders")
SqlDataAdapter("SELECT
FROM
oDataAdapter
oDataAdapter
=
New
oDataAdapter.Fill(oDataSet,
oDataAdapter
oDataAdapter
New
SqlDataAdapter("SELECT
'
'
For
la
SqlDataAdapter("SELECT
crear
un
informacin
objeto
del
oDataTable
oDataColumn
la
For
Each
Me.lstEsquema.Items.Add("Campo:
oDataColumn.ColumnName
"Tipo:
"
Products",
oConexion)
"Products")
Nothing
FROM
Territories",
oConexion)
"Territories")
Nothing
tabla
esquema
y
que
columna
el
del
tablas
In
de
"
coleccin
de
mostrar
contiene
DataTable
DataColumn
In
de
la
tabla
oDataTable.Columns
_
"
&
_
oDataColumn.DataType.Name)
&
--&
DataSet")
DataSet
oDataSet.Tables
oDataTable.TableName)
columnas
"
"
del
&
oDataColumn
&
para
dataset
As
As
Me.lstEsquema.Items.Add("Tabla:
recorrer
FROM
Me.lstEsquema.Items.Add("Estructura
recorrer
la
coleccin
Each
oDataTable
'
oDataAdapter.Fill(oDataSet,
oDataAdapter
'
Dim
Dim
Nothing
Next
Next
End
Sub
La Figura 374 muestra el ListBox relleno con el esquema del DataSet tras haber pulsado el botn del
formulario.
Grupo EIDOS
http://www.eidos.es