Microsoft Visual Basic .

NET™
Curso de programación
Fco. Javier Ceballos Sierra
Profesor titular de la
Escuela Politécnica Superior
Universidad de Alcalá

http://www.fjceballos.es

Microsoft Visual Basic .NET. Curso de programación.
© Fco. Javier Ceballos Sierra
© De la edición: RA-MA 2007
MARCAS COMERCIALES: Las marcas de los productos citados en el contenido de este libro
(sean o no marcas registradas) pertenecen a sus respectivos propietarios. RA-MA no está
asociada a ningún producto o fabricante mencioado en la obra, los datos y los ejemplos
utilizados son ficticios salvo que se indique lo contrario.
RA-MA es una marca comercial registrada.
Se ha puesto el máximo empeño en ofrecer al lector una información completa y precisa.
Sin embargo, RA-MA Editorial no asume ninguna responsabilidad derivada de su uso,
ni tampoco por cualquier violación de patentes ni otros derechos de terceras partes que pudieran
ocurrir. Esta publicación tiene por objeto proporcionar unos conocimientos precisos y acreditados
sobre el tema tratado. Su venta no supone para el editor ninguna forma de asistencia legal,
administrativa ni de ningún otro tipo. En caso de precisarse asesoría legal u otra forma de ayuda
experta, deben buscarse los servicios de un profesional competente.
Reservados todos los derechos de publicación en cualquier idioma.
Según lo dispuesto en el Código Penal vigente ninguna parte de este libro puede ser
reproducida, grabada en sistema de almacenamiento o transmitida en forma alguna ni
por cualquier procedimiento, ya sea electrónico, mecánico, reprográfico, magnético o
cualquier otro, sin autorización previa y por escrito de RA-MA; su contenido está protegido
por la Ley vigente que establece penas de prisión y/o multas a quienes intencionadamente,
reprodujeren o plagiaren, en todo o en parte, una obra literaria, artística o científica.
Editado por:
RA-MA Editorial
C/ Jarama, 3A, Polígono industrial Igarsa
28860 PARACUELLOS DEL JARAMA, Madrid
Teléfono: 91 658 42 80
Telefax: 91 662 81 39
Correo electrónico: editorial@ra-ma.com
Internet: www.ra-ma.es y www.ra-ma.com
ISBN: 978-84-7897-812-0
Depósito Legal: M-32335-2007
Autoedición: Fco. Javier Ceballos
Filmación e impresión: Albadalejo, S.L.
Impreso en España
Primera impresión: julio 2007

CONTENIDO
PRÓLOGO........................................................................................................ XXIII

PARTE 1. PROGRAMACIÓN BÁSICA.................................

1

CAPÍTULO 1. FASES EN EL DESARROLLO DE UN PROGRAMA ...........

3

QUÉ ES UN PROGRAMA ................................................................................
LENGUAJES DE PROGRAMACIÓN ..............................................................
Compiladores.................................................................................................
Intérpretes......................................................................................................
QUÉ ES Visual Basic .NET ...............................................................................
¿POR QUÉ APRENDER Visual Basic? ............................................................
REALIZACIÓN DE UN PROGRAMA EN Visual Basic .................................
Cómo crear un programa ...............................................................................
Interfaz de línea de órdenes ...........................................................................
¿Qué hace este programa? ........................................................................
Guardar el programa escrito en el disco ...................................................
Compilar y ejecutar el programa ..............................................................
Biblioteca de clases ..................................................................................
Guardar el programa ejecutable en el disco..............................................
Depurar un programa................................................................................
Entornos de desarrollo integrado ...................................................................
EJERCICIOS RESUELTOS ..............................................................................
EJERCICIOS PROPUESTOS ............................................................................

3
4
6
6
7
8
8
9
9
10
11
11
14
14
15
15
15
17

X

VISUAL BASIC .NET. CURSO DE PROGRAMACIÓN

CAPÍTULO 2. INTRODUCCIÓN A Visual Basic .NET ...................................

19

DECLARACIÓN DE UNA VARIABLE...........................................................
ASIGNAR VALORES .......................................................................................
AÑADIR COMENTARIOS...............................................................................
MOSTRAR DATOS POR LA PANTALLA......................................................
EXPRESIONES ARITMÉTICAS......................................................................
EXPRESIONES CONDICIONALES ................................................................
ESCRIBIR NUESTROS PROPIOS PROCEDIMIENTOS................................
EJERCICIOS PROPUESTOS ............................................................................

19
22
24
24
25
27
29
31

CAPÍTULO 3. INTRODUCCIÓN A LA POO ...................................................

33

PENSAR EN OBJETOS ....................................................................................
Clases y objetos .............................................................................................
Mensajes y métodos ......................................................................................
DISEÑO DE UNA CLASE DE OBJETOS........................................................
Atributos........................................................................................................
Propiedades y métodos ..................................................................................
CONSTRUCTORES ..........................................................................................
HERENCIA........................................................................................................
EJERCICIOS RESUELTOS ..............................................................................
EJERCICIOS PROPUESTOS ............................................................................

34
34
35
36
37
38
45
47
54
59

CAPÍTULO 4. ELEMENTOS DEL LENGUAJE ..............................................

61

CARACTERES DE Visual Basic.......................................................................
TIPOS.................................................................................................................
LITERALES.......................................................................................................
Literales enteros ............................................................................................
Literales reales...............................................................................................
Literales de un solo carácter ..........................................................................
Literales de cadenas de caracteres .................................................................
Literales de fecha y hora................................................................................
Literal Nothing ..............................................................................................
IDENTIFICADORES.........................................................................................
PALABRAS CLAVE .........................................................................................
DECLARACIÓN DE CONSTANTES SIMBÓLICAS .....................................
¿Por qué utilizar constantes? .........................................................................
VARIABLES......................................................................................................
CONVERSIÓN ENTRE TIPOS PRIMITIVOS.................................................

61
62
64
64
65
65
66
66
67
68
68
69
70
70
72

CONTENIDO

XI

OPERADORES..................................................................................................
Operadores lógicos ........................................................................................
Operadores unitarios......................................................................................
Operadores a nivel de bits .............................................................................
Operadores de asignación..............................................................................
Operador de concatenación ...........................................................................
PRIORIDAD Y ORDEN DE EVALUACIÓN...................................................
EJERCICIOS RESUELTOS ..............................................................................
EJERCICIOS PROPUESTOS ............................................................................

74
74
75
76
77
77
78
79
81

CAPÍTULO 5. ESTRUCTURA DE UN PROGRAMA ..........................................

83

ESTRUCTURA DE UN PROGRAMA Visual Basic ........................................
Espacios de nombres .....................................................................................
Protección de una clase .................................................................................
Sentencias Option..........................................................................................
Sentencia Imports ..........................................................................................
Especificación de alias ..................................................................................
Definiciones y declaraciones .........................................................................
Sentencia simple............................................................................................
Sentencia compuesta o bloque.......................................................................
Procedimientos ..............................................................................................
Definición de un procedimiento ...............................................................
Procedimiento Main ......................................................................................
Crear objetos de una clase .............................................................................
Cómo acceder a los miembros de un objeto ..................................................
Protección de los miembros de una clase ......................................................
Miembro de un objeto o de una clase ............................................................
Clases versus módulos estándar.....................................................................
Referencias a objetos .....................................................................................
Pasando argumentos a los métodos ...............................................................
EJERCICIOS RESUELTOS ..............................................................................
EJERCICIOS PROPUESTOS ............................................................................

83
87
90
91
91
92
93
93
94
94
94
95
96
97
98
99
102
102
105
106
109

CAPÍTULO 6. CLASES DE USO COMÚN........................................................ 111
ENTRADA Y SALIDA......................................................................................
Flujos de entrada ...........................................................................................
Flujos de salida..............................................................................................
Salida con formato.........................................................................................
Excepciones...................................................................................................

111
113
115
117
118

XII

VISUAL BASIC .NET. CURSO DE PROGRAMACIÓN

Trabajar con tipos de datos numéricos ..........................................................
Estructuras que encapsulan los tipos primitivos .......................................
Conversión entre tipos valor y tipos referencia ........................................
Clase Leer......................................................................................................
¿DÓNDE SE UBICAN LAS CLASES QUE DAN SOPORTE? .......................
CARÁCTER FIN DE FICHERO .......................................................................
CARACTERES CR+LF .....................................................................................
OTROS MÉTODOS DE LA CLASE Console...................................................
Controlar la posición y los colores del texto .................................................
Dimensiones de la ventana de la consola.......................................................
Detección de las pulsaciones del teclado.......................................................
MÉTODOS MATEMÁTICOS...........................................................................
NÚMEROS ALEATORIOS...............................................................................
EJERCICIOS RESUELTOS ..............................................................................
EJERCICIOS PROPUESTOS ............................................................................

120
120
123
124
126
127
128
130
131
132
132
133
135
135
139

CAPÍTULO 7. SENTENCIAS DE CONTROL .................................................. 141
SENTENCIA If ..................................................................................................
ANIDAMIENTO DE SENTENCIAS If.............................................................
ESTRUCTURA Else If ......................................................................................
SENTENCIA Select ...........................................................................................
SENTENCIA While ...........................................................................................
Bucles anidados .............................................................................................
SENTENCIA Do ... Loop While ........................................................................
SENTENCIA For ...............................................................................................
SENTENCIA For Each ......................................................................................
SENTENCIA Continue ......................................................................................
SENTENCIA GoTo............................................................................................
SENTENCIAS Try ... Catch...............................................................................
EJERCICIOS RESUELTOS ..............................................................................
EJERCICIOS PROPUESTOS ............................................................................

141
143
146
148
152
154
156
159
163
163
164
165
166
171

CAPÍTULO 8. MATRICES.................................................................................. 173
INTRODUCCIÓN A LAS MATRICES ............................................................
MATRICES NUMÉRICAS UNIDIMENSIONALES .......................................
Declarar una matriz .......................................................................................
Crear una matriz ............................................................................................
Iniciar una matriz...........................................................................................
Acceder a los elementos de una matriz..........................................................

174
175
175
176
177
178

CONTENIDO

XIII

Tamaño y dimensión de una matriz...............................................................
Métodos de una matriz ..................................................................................
Trabajar con matrices unidimensionales........................................................
Matriz de tipo ArrayList................................................................................
Añadir un elemento ..................................................................................
Insertar un elemento .................................................................................
Modificar un elemento .............................................................................
Obtener el valor de un elemento...............................................................
Tamaño.....................................................................................................
Eliminar elementos...................................................................................
Buscar elementos......................................................................................
Copiar listas..............................................................................................
Iteradores..................................................................................................
Ejemplo ....................................................................................................
Matrices asociativas.......................................................................................
Diccionario ....................................................................................................
CADENAS DE CARACTERES ........................................................................
Clase String ...................................................................................................
New(cad() As Char) .................................................................................
ToString().................................................................................................
CopyTo(IndFuente As Integer, destino() As Char, ..................................
IndDes As Integer, nCars As Integer) ......................................................
Concat(str1 As String, str2 As String)......................................................
CompareTo(otroString As String) ............................................................
Length ......................................................................................................
ToLower() ................................................................................................
ToUpper().................................................................................................
Trim() .......................................................................................................
StartsWith(prefijo As String) ...................................................................
EndsWith(sufijo As String) ......................................................................
Substring(pos As Integer, ncars As Integer).............................................
Chars(i As Integer) ...................................................................................
IndexOf(str As String)..............................................................................
IndexOfAny(cad() As Char).....................................................................
Replace(str As String, nuevaStr As String) ..............................................
Insert(pos As Integer, str As String).........................................................
Split(seps() As Char) ................................................................................
Clase StringBuilder .......................................................................................
New([arg])................................................................................................
Length ......................................................................................................
Capacity....................................................................................................
Append(x As tipo) ....................................................................................
Insert(índice As Integer, x As tipo) ..........................................................

179
179
180
181
182
182
183
183
183
183
183
183
184
184
187
189
192
194
195
195
196
196
196
196
198
198
198
198
198
198
199
199
199
199
200
200
200
200
200
201
201
201
201

XIV

VISUAL BASIC .NET. CURSO DE PROGRAMACIÓN

Remove(p As Integer, n As Integer).........................................................
Replace(str As String, nuevaStr As String, p As Integer, n As Integer).............
Chars(i As Integer) ...................................................................................
ToString().................................................................................................
MATRICES MULTIDIMENSIONALES Y DE REFERENCIAS ....................
Matrices numéricas........................................................................................
Matrices de cadenas de caracteres .................................................................
Matrices de objetos String o StringBuilder....................................................
SENTENCIA For Each ......................................................................................
EJERCICIOS RESUELTOS ..............................................................................
EJERCICIOS PROPUESTOS ............................................................................

202
202
202
203
203
204
210
211
214
214
219

CAPÍTULO 9. MÁS SOBRE PROCEDIMIENTOS Y COLECCIONES........ 223
PASAR UNA MATRIZ COMO ARGUMENTO A UN PROCEDIMIENTO........................
PROCEDIMIENTO QUE RETORNA UNA MATRIZ .....................................
PASAR UN ARGUMENTO DE UN TIPO PRIMITIVO .......................................
PASAR TIPOS REFERENCIA POR REFERENCIA........................................
PASAR ARGUMENTOS EN LA LÍNEA DE ÓRDENES................................
PROCEDIMIENTOS RECURSIVOS................................................................
PROCEDIMIENTOS SOBRECARGADOS......................................................
NÚMERO VARIABLE DE PARÁMETROS....................................................
LA CLASE Object .............................................................................................
Equals(Object obj).........................................................................................
ToString() ......................................................................................................
Finalize() .......................................................................................................
GetHashCode() ..............................................................................................
MÁS SOBRE REFERENCIAS Y OBJETOS String .........................................
LA CLASE Array...............................................................................................
Clear ..............................................................................................................
Sort ................................................................................................................
BinarySearch .................................................................................................
Reverse ..........................................................................................................
COLECCIONES.................................................................................................
Crear una colección .......................................................................................
Colecciones predefinidas...............................................................................
Colecciones genéricas ...................................................................................
EJERCICIOS RESUELTOS ..............................................................................
EJERCICIOS PROPUESTOS ............................................................................

223
225
228
229
231
234
236
237
239
240
241
241
241
242
245
245
245
246
247
247
247
249
249
251
255

CONTENIDO

XV

PARTE 2. MECANISMOS DE ABSTRACCIÓN .................. 259
CAPÍTULO 10. CLASES, ESPACIOS DE NOMBRES Y ESTRUCTURAS .. 261
DEFINICIÓN DE UNA CLASE........................................................................
Atributos........................................................................................................
Métodos de una clase.....................................................................................
Propiedades ...................................................................................................
Control de acceso a los miembros de la clase................................................
Acceso público .........................................................................................
Acceso privado.........................................................................................
Acceso protegido......................................................................................
Acceso interno..........................................................................................
IMPLEMENTACIÓN DE UNA CLASE...........................................................
MÉTODOS SOBRECARGADOS .....................................................................
NÚMERO VARIABLE DE PARÁMETROS....................................................
IMPLEMENTACIÓN DE UNA APLICACIÓN ...............................................
CONTROL DE ACCESO A UNA CLASE .......................................................
REFERENCIA Me .............................................................................................
INICIACIÓN DE UN OBJETO .........................................................................
Constructor ....................................................................................................
Sobrecarga del constructor ............................................................................
Llamar a un constructor.................................................................................
Asignación de objetos....................................................................................
Constructor copia ..........................................................................................
DESTRUCCIÓN DE OBJETOS ........................................................................
Destructor ......................................................................................................
Sentencia Using .............................................................................................
Ejecutar el recolector de basura.....................................................................
REFERENCIAS COMO MIEMBROS DE UNA CLASE.................................
REDEFINIR MÉTODOS HEREDADOS DE Object ........................................
Método Equals...............................................................................................
MIEMBROS SHARED DE UNA CLASE.........................................................
Atributos Shared............................................................................................
Acceder a los atributos Shared ......................................................................
Métodos Shared .............................................................................................
DECLARACIONES PARCIALES ....................................................................
CLASES ANIDADAS .......................................................................................
DELEGADOS ....................................................................................................
Multidifusión .................................................................................................
MATRICES DE OBJETOS................................................................................
ESPACIO DE NOMBRES .................................................................................
Utilizar espacios de nombres .........................................................................

261
263
264
265
266
268
268
268
268
269
272
274
275
276
277
278
280
282
284
284
286
287
287
289
290
291
298
299
300
300
302
303
305
307
308
311
312
321
322

XVI

VISUAL BASIC .NET. CURSO DE PROGRAMACIÓN

Espacio de nombres global ............................................................................
ESTRUCTURAS................................................................................................
EJERCICIOS RESUELTOS ..............................................................................
EJERCICIOS PROPUESTOS ............................................................................

323
324
325
332

CAPÍTULO 11. OPERADORES SOBRECARGADOS......................................... 337
SOBRECARGAR UN OPERADOR..................................................................
UNA CLASE PARA NÚMEROS RACIONALES............................................
SOBRECARGA DE OPERADORES BINARIOS ............................................
Sobrecarga de operadores asignación ............................................................
Sobrecarga de operadores aritméticos ...........................................................
Aritmética mixta............................................................................................
Sobrecarga de operadores de relación ...........................................................
Métodos adicionales ......................................................................................
SOBRECARGA DE OPERADORES UNARIOS .............................................
Operadores unarios/binarios ..........................................................................
CONVERSIONES PERSONALIZADAS..........................................................
Conversiones implícitas.................................................................................
Conversiones explícitas .................................................................................
INDEXACIÓN ...................................................................................................
EJERCICIOS RESUELTOS ..............................................................................
EJERCICIOS PROPUESTOS ............................................................................

337
343
345
345
346
347
348
349
351
352
352
354
354
355
358
365

CAPÍTULO 12. CLASES DERIVADAS E INTERFACES ............................... 367
CLASES DERIVADAS Y HERENCIA ............................................................
DEFINIR UNA CLASE DERIVADA ...............................................................
Control de acceso a los miembros de las clases.............................................
Qué miembros hereda una clase derivada......................................................
ATRIBUTOS CON EL MISMO NOMBRE ......................................................
REDEFINIR MÉTODOS DE LA CLASE BASE..............................................
CONSTRUCTORES DE LAS CLASES DERIVADAS....................................
COPIA DE OBJETOS........................................................................................
DESTRUCTORES DE LAS CLASES DERIVADAS.......................................
JERARQUÍA DE CLASES................................................................................
REFERENCIAS A OBJETOS DE UNA CLASE DERIVADA ........................
Conversiones implícitas.................................................................................
Conversiones explícitas .................................................................................
INFORMACIÓN DE TIPOS DURANTE LA EJECUCIÓN.............................
MÉTODOS VIRTUALES..................................................................................

368
371
373
374
379
380
382
385
387
388
395
396
398
399
399

CONTENIDO

Constructores virtuales ..................................................................................
Destructores virtuales ....................................................................................
POLIMORFISMO ..............................................................................................
MÉTODOS EN LÍNEA ........................................................................................
CLASES Y MÉTODOS ABSTRACTOS ..........................................................
CLASES Y MÉTODOS FINALES....................................................................
INTERFACES....................................................................................................
Definir una interfaz........................................................................................
Un ejemplo: la interfaz IFecha ......................................................................
Utilizar una interfaz.......................................................................................
Clase abstracta frente a interfaz.....................................................................
Utilizar una interfaz como un tipo .................................................................
Interfaces frente a herencia múltiple..............................................................
Para qué sirve una interfaz.............................................................................
Implementar múltiples interfaces ..................................................................
EJERCICIOS RESUELTOS ..............................................................................
EJERCICIOS PROPUESTOS ............................................................................

XVII

405
408
408
417
418
420
420
420
421
422
425
426
428
428
429
429
433

CAPÍTULO 13. TIPOS Y MÉTODOS GENÉRICOS ....................................... 435
DEFINICIÓN DE CLASES GENÉRICAS ........................................................
Valor predeterminado para una variable de tipo T ........................................
Parámetros de tipos genéricos .......................................................................
Herencia ........................................................................................................
MÉTODOS GENÉRICOS .................................................................................
DELEGADOS GENÉRICOS.............................................................................
Delegado genérico Predicate .........................................................................
EJERCICIOS RESUELTOS ..............................................................................
EJERCICIOS PROPUESTOS ............................................................................

436
438
439
440
441
443
445
446
448

CAPÍTULO 14. EXCEPCIONES......................................................................... 451
EXCEPCIONES DE Visual Basic......................................................................
MANEJAR EXCEPCIONES .............................................................................
Lanzar una excepción ....................................................................................
Capturar una excepción .................................................................................
Excepciones derivadas...................................................................................
Capturar cualquier excepción ........................................................................
Relanzar una excepción .................................................................................
BLOQUE DE FINALIZACIÓN.........................................................................
CREAR EXCEPCIONES...................................................................................

452
454
455
455
457
458
459
459
461

XVIII

VISUAL BASIC .NET. CURSO DE PROGRAMACIÓN

FLUJO DE EJECUCIÓN ...................................................................................
CUÁNDO UTILIZAR EXCEPCIONES Y CUÁNDO NO ...............................
EJERCICIOS RESUELTOS ..............................................................................
EJERCICIOS PROPUESTOS ............................................................................

463
466
466
472

CAPÍTULO 15. FLUJOS ...................................................................................... 473
VISIÓN GENERAL DE LOS FLUJOS DE E/S ................................................
ABRIENDO FICHEROS PARA ACCESO SECUENCIAL .............................
Flujos de bytes...............................................................................................
FileStream ................................................................................................
Flujos de caracteres .......................................................................................
StreamWriter ............................................................................................
StreamReader ...........................................................................................
Clases File, Directory y Path .........................................................................
Flujos de datos de tipos primitivos ................................................................
BinaryWriter ............................................................................................
BinaryReader............................................................................................
Un ejemplo de acceso secuencial ..................................................................
Escribir en un fichero ...............................................................................
Leer de un fichero ....................................................................................
ABRIENDO FICHEROS PARA ACCESO ALEATORIO ...............................
Propiedades y métodos para acceso aleatorio................................................
Position.....................................................................................................
Length ......................................................................................................
Seek ..........................................................................................................
La clase CPersona..........................................................................................
La clase CListaTfnos.....................................................................................
Constructor de CListaTfnos .....................................................................
Escribir un registro en el fichero ..............................................................
Añadir un registro al final del fichero ......................................................
Leer un registro del fichero ......................................................................
Eliminar un registro del fichero................................................................
¿Hay registros marcados para eliminar?...................................................
Buscar un registro en el fichero................................................................
Un ejemplo de acceso aleatorio a un fichero .................................................
Modificar un registro................................................................................
Actualizar el fichero .................................................................................
UTILIZACIÓN DE DISPOSITIVOS ESTÁNDAR ..........................................
SERIACIÓN DE OBJETOS...............................................................................
EJERCICIOS RESUELTOS ..............................................................................
EJERCICIOS PROPUESTOS ............................................................................

475
476
476
476
482
482
484
485
487
488
489
491
491
494
496
496
496
497
497
499
500
501
503
504
504
505
506
506
507
509
510
511
516
518
524

CONTENIDO

XIX

PARTE 3. DISEÑO Y PROGRAMACIÓN............................. 527
CAPÍTULO 16. ESTRUCTURAS DINÁMICAS ............................................... 529
LISTAS LINEALES ..........................................................................................
Listas lineales simplemente enlazadas...........................................................
Operaciones básicas.......................................................................................
Inserción de un elemento al comienzo de la lista .....................................
Buscar en una lista un elemento con un valor x .......................................
Inserción de un elemento en general ........................................................
Borrar un elemento de la lista...................................................................
Recorrer una lista .....................................................................................
Borrar todos los elementos de una lista ....................................................
UNA CLASE PARA LISTAS LINEALES........................................................
Clase genérica para listas lineales..................................................................
Alternativas al método Obtener................................................................
LISTAS CIRCULARES.....................................................................................
Clase CListaCircularSE(Of T).......................................................................
PILAS.................................................................................................................
COLAS...............................................................................................................
EJEMPLO ..........................................................................................................
LISTA DOBLEMENTE ENLAZADA ..............................................................
Lista circular doblemente enlazada ...............................................................
Clase CListaCircularDE(Of T).................................................................
Ejemplo ....................................................................................................
ÁRBOLES..........................................................................................................
Árboles binarios ............................................................................................
Formas de recorrer un árbol binario ..............................................................
ÁRBOLES BINARIOS DE BÚSQUEDA .........................................................
Clase CArbolBinB(Of T)...............................................................................
Buscar un nodo en el árbol ............................................................................
Insertar un nodo en el árbol ...........................................................................
Borrar un nodo del árbol................................................................................
Utilización de la clase CArbolBinB(Of T) ....................................................
ÁRBOLES BINARIOS PERFECTAMENTE EQUILIBRADOS .....................
Clase CArbolBinE(Of T)...............................................................................
Utilización de la clase CArbolBinE(Of T) ....................................................
EJERCICIOS RESUELTOS ..............................................................................
EJERCICIOS PROPUESTOS ............................................................................

530
530
533
534
536
536
537
538
538
539
543
553
554
555
559
561
562
564
565
566
571
573
574
575
577
578
581
582
583
586
589
590
595
597
611

XX

VISUAL BASIC .NET. CURSO DE PROGRAMACIÓN

CAPÍTULO 17. ALGORITMOS ......................................................................... 615
RECURSIVIDAD ..............................................................................................
ORDENACIÓN DE DATOS .............................................................................
Método de la burbuja.....................................................................................
Método de inserción ......................................................................................
Método quicksort...........................................................................................
Comparación de los métodos expuestos ........................................................
BÚSQUEDA DE DATOS..................................................................................
Búsqueda secuencial......................................................................................
Búsqueda binaria ...........................................................................................
Búsqueda de cadenas .....................................................................................
ORDENACIÓN DE FICHEROS EN DISCO ....................................................
Ordenación de ficheros. Acceso secuencial...................................................
Ordenación de ficheros. Acceso aleatorio .....................................................
ALGORITMOS HASH ......................................................................................
Matrices hash.................................................................................................
Método hash abierto ......................................................................................
Método hash con desbordamiento .................................................................
Eliminación de elementos..............................................................................
Clase CHashAbierto ......................................................................................
Un ejemplo de una matriz hash .....................................................................
EJERCICIOS RESUELTOS ..............................................................................
EJERCICIOS PROPUESTOS ............................................................................

615
622
623
625
627
631
631
631
631
633
636
636
643
646
646
648
649
650
650
654
657
661

CAPÍTULO 18. HILOS......................................................................................... 663
CONCEPTO DE PROCESO..............................................................................
HILOS ................................................................................................................
Estados de un hilo..........................................................................................
Cuándo se debe crear un hilo.........................................................................
PROGRAMAR CON HILOS.............................................................................
Clase Thread..................................................................................................
Resumen de los métodos y propiedades de Thread ..................................
CREACIÓN Y DESTRUCCIÓN DE HILOS ....................................................
Parámetros del método que ejecuta el hilo ....................................................
Un ejemplo ....................................................................................................
Espera activa y pasiva ...................................................................................
Finalizar un hilo.............................................................................................
Hilos en segundo plano .................................................................................
Ciclo de vida de un hilo.................................................................................
Preparado..................................................................................................

663
668
670
671
671
672
672
673
676
677
681
681
684
685
686

CONTENIDO

XXI

Bloqueado ................................................................................................
Dormido ...................................................................................................
Esperando .................................................................................................
SINCRONIZACIÓN DE HILOS .......................................................................
Mecanismos de sincronización ......................................................................
Objetos de sincronización..............................................................................
Secciones críticas .....................................................................................
Ejemplo que implementa una sección crítica ...........................................
Exclusión mutua .......................................................................................
Monitor reentrante....................................................................................
Utilizar Wait y Pulse/PulseAll .................................................................
¿Por qué los métodos Almacenar y Obtener utilizan un bucle? ..........
Objeto Mutex............................................................................................
Objeto Semaphore ....................................................................................
Problema del productor-consumidor ........................................................
Controladores de espera ...........................................................................
Detener un hilo de forma controlada ........................................................
Interbloqueo...................................................................................................
GRUPO DE HILOS ...........................................................................................
PLANIFICACIÓN DE HILOS...........................................................................
Asignar prioridades a los hilos ......................................................................
EJERCICIOS RESUELTOS ..............................................................................
EJERCICIOS PROPUESTOS ............................................................................

687
687
688
689
689
690
692
694
698
700
701
708
709
711
712
718
723
725
725
726
727
731
737

CAPÍTULO 19. INTERFACES GRÁFICAS Y APLICACIONES PARA INTERNET... 739
INTERFACES GRÁFICAS ...............................................................................
Crear un nuevo proyecto ...............................................................................
El formulario .................................................................................................
Dibujar los controles......................................................................................
Borrar un control ...........................................................................................
Propiedades de los objetos.............................................................................
Bloquear la posición de todos los controles...................................................
Icono de la aplicación....................................................................................
Escribir los controladores de eventos ............................................................
Guardar la aplicación.....................................................................................
Verificar la aplicación ...................................................................................
Propiedades del proyecto...............................................................................
Crear soluciones de varios proyectos ............................................................
ADO.NET...........................................................................................................
Componentes de ADO.NET ..........................................................................
ACCEDER A LA WEB .....................................................................................

740
741
745
746
750
751
753
753
753
756
756
758
759
760
761
762

XXII

VISUAL BASIC .NET. CURSO DE PROGRAMACIÓN

Crear un nuevo formulario Web ....................................................................
Agregar controles y texto a la página ............................................................
Ciclo de vida de una página...........................................................................
Crear controladores de eventos para los controles.........................................
Generar la aplicación Web y ejecutarla .........................................................

762
765
767
768
771

PARTE 4. APÉNDICES ............................................................ 773
A. ENTORNOS DE DESARROLLO................................................................... 775
VISUAL STUDIO 2005.....................................................................................
Ediciones Visual Studio 2005 Express ..........................................................
Visual Studio 2005 Standard Edition ............................................................
Visual Studio 2005 Professional Edition .......................................................
Visual Studio 2005 Tools para Microsoft Office System ..............................
Visual Studio 2005 Team System .................................................................
APLICACIÓN DE CONSOLA..........................................................................
DEPURAR UNA APLICACIÓN.......................................................................
ARGUMENTOS EN LA LÍNEA DE ÓRDENES .............................................
VISUAL WEB DEVELOPER ...........................................................................

775
775
776
776
776
776
777
780
781
782

B. .NET PARA LINUX ......................................................................................... 783
INSTALACIÓN DE MONO.............................................................................. 784
EJECUTAR UN PROGRAMA Visual Basic..................................................... 784
ENTORNO DE DESARROLLO DE MONO .................................................... 785
C. CÓDIGOS DE CARACTERES....................................................................... 787
UTILIZACIÓN DE CARACTERES ANSI CON WINDOWS .........................
JUEGO DE CARACTERES ANSI ....................................................................
UTILIZACIÓN DE CARACTERES ASCII ......................................................
JUEGO DE CARACTERES ASCII ...................................................................
JUEGO DE CARACTERES UNICODE ...........................................................

787
788
789
790
791

ÍNDICE................................................................................................................... 793

PRÓLOGO
Visual Basic es actualmente, junto con C# y Java, uno de los lenguajes de programación más populares en Internet. Pero, además, está disponible para el desarrollo de programas de propósito general. La idea fundamental de esta obra es dar
a conocer estas facetas del lenguaje Visual Basic, sin olvidar que tiene un alcance
completo sobre la Web.
En los últimos tiempos C y C++ han sido los lenguajes más utilizados en el
desarrollo de aplicaciones en general. Ambos lenguajes proporcionan al programador el nivel de abstracción preciso para abordar el desarrollo de cualquier aplicación por compleja que sea, así como mecanismos de bajo nivel para utilizar las
características más avanzadas de las plataformas sobre las que se desarrolla; pero,
en general, el tiempo necesario para desarrollar una aplicación resulta largo comparado con otros lenguajes como Visual Basic, que ofrecen, además de facilidad,
una elevada productividad en el desarrollo de aplicaciones, aunque eso sí, sacrificando la flexibilidad que los desarrolladores de C y C++ requieren. La solución
que Microsoft da a este problema son los lenguajes Visual Basic y C#. Visual Basic, al igual que C#, es un lenguaje moderno orientado a objetos que permite desarrollar una amplia gama de aplicaciones para la nueva plataforma Microsoft
.NET, la cual se caracteriza por proporcionar utilidades y servicios para sacar un
provecho total tanto de la informática como de las comunicaciones.
Más que otra cosa, el objetivo de Visual Basic es permitir a todos los desarrolladores en general abordar el desarrollo de aplicaciones complejas con facilidad,
eliminando los errores de programación más comunes en C y C++. Por ejemplo:

El recolector de basura libera al programador del peso que conlleva el manejo
manual de la memoria.

XXIV

VISUAL BASIC .NET. CURSO DE PROGRAMACIÓN

Todos los objetos creados dinámicamente así como las matrices son iniciados
a cero, así como las variables locales.

Visual Basic unifica el sistema de tipos permitiendo ver a cada uno de ellos
en el lenguaje como un objeto.

Resumiendo, Visual Basic permite escribir aplicaciones tanto para Internet
como aplicaciones de propósito general; esto es, como muchos lenguajes, permite
trabajar con todo tipo de datos, crear estructuras dinámicas, trabajar con ficheros,
atacar a bases de datos, diseñar interfaces gráficas de usuario, etc. Más aún, Visual Basic es un lenguaje simple, potente y orientado a objetos. Su sintaxis incita
al programador a generar programas modulares y fácilmente mantenibles.
Actualmente en el mercado hay multitud de herramientas de programación
Visual Basic como Microsoft Visual Studio en sus distintas versiones o SharpDevelop por citar algunas. Pero la mejor forma de ver el alcance de Visual Basic es
utilizando directamente el paquete de desarrollo Microsoft .NET Framework
Software Development Kit (SDK). Se trata de un software que se puede obtener de
la red basado en un conjunto de herramientas de órdenes en línea para editar,
compilar, ejecutar y depurar programas Visual Basic, entre otros.
Este libro está dedicado, casi en su totalidad, al aprendizaje del lenguaje Visual Basic, de la programación orientada a objetos y al desarrollo de aplicaciones.
Un capítulo final le introducirá también en otros conceptos como interfaces gráficas y páginas Web. Esta materia puede agruparse en los siguientes apartados:


Programación básica
Mecanismos de abstracción
Diseño y programación

La primera parte está pensada para que en poco tiempo pueda convertirse en
programador de aplicaciones Visual Basic. Y para esto, ¿qué necesita? Pues simplemente leer ordenadamente los capítulos del libro, resolviendo cada uno de los
ejemplos que en ellos se detallan.
La segunda parte abarca en profundidad la programación orientada a objetos.
En la primera parte el autor ha tratado de desarrollar aplicaciones sencillas, para
introducirle más bien en el lenguaje y en el manejo de la biblioteca de clases de
.NET Framework que en el diseño de clases de objetos. No obstante, sí ha tenido
que quedar claro que un programa orientado a objetos sólo se compone de objetos. Es hora pues de entrar con detalle en la programación orientada a objetos, la
cual tiene un elemento básico: la clase.

PRÓLOGO

XXV

Pero si el autor finalizara el libro con las dos partes anteriores, privaría al lector de saber que aún Visual Basic proporciona mucho más. Por eso hay una tercera parte que se dedica a estudiar las estructuras dinámicas de datos, los algoritmos
de uso común, los hilos, y a introducirle en el diseño de interfaces gráficas de
usuario y en aplicaciones que se ejecutan en un servidor.
Todo ello se ha documentado con abundantes problemas resueltos. Cuando
complete todas las partes, todavía no sabrá todo lo que es posible hacer con Visual Basic, pero sí habrá dado un paso importante.
El autor considera importante que antes de continuar eche una ojeada a los
apéndices. En ellos se exponen cómo utilizar el entorno de desarrollo integrado
(EDI) para Visual Basic o cómo proceder para trabajar sobre la plataforma Linux,
entre otras cosas.

Agradecimientos
He recibido ayuda de algunas personas durante la preparación de este libro y, por
ello, estoy francamente agradecido. También, deseo expresar mi agradecimiento a
Microsoft Ibérica por poner a mi disposición, en particular, y de todos los lectores, en general, el EDI y el SDK que el estudio de esta obra requiere.
Francisco Javier Ceballos Sierra
http://www.fjceballos.es/

PARTE

________________________
_________________________________
__________________________________________

Programación básica

Fases en el desarrollo de un programa

Introducción a Visual Basic .NET

Introducción a la POO

Elementos del lenguaje

Estructura de un programa

Clases de uso común

Sentencias de control

Matrices

Más sobre procedimientos y colecciones

PARTE

________________________
_________________________________
__________________________________________

Mecanismos de abstracción

Clases, espacios de nombres y estructuras

Operadores sobrecargados

Clases derivadas e interfaces

Tipos y métodos genéricos

Excepciones

Flujos

PARTE

________________________
_________________________________
__________________________________________

Diseño y programación

Estructuras dinámicas

Algoritmos

Hilos

Interfaces gráficas y aplicaciones para Internet

PARTE

________________________
_________________________________
__________________________________________

Apéndices

Entornos de desarrollo

.NET para Linux

Códigos de caracteres

APÉNDICE A
© F.J.Ceballos/RA-MA

ENTORNOS DE DESARROLLO
Cuando se utiliza un entorno de desarrollo integrado (EDI), lo primero que hay
que hacer una vez instalado es asegurarse de que las rutas donde se localizan las
herramientas, las bibliotecas, la documentación y los ficheros fuente hayan sido
establecidas; algunos EDI sólo requieren la ruta donde se instaló el compilador.
Este proceso normalmente se ejecuta automáticamente durante el proceso de instalación de dicho entorno. Si no es así, el entorno proporcionará algún menú con
las órdenes apropiadas para realizar dicho proceso. Por ejemplo, en los EDI que se
presentan a continuación las rutas a las que nos referimos quedan establecidas durante la instalación de los mismos.

VISUAL STUDIO 2005
Visual Studio 2005 proporciona una variedad de herramientas tanto para desarrolladores individuales como para equipos de desarrollo.
http://www.microsoft.com/spanish/msdn/vs2005/default.mspx

Ediciones Visual Studio 2005 Express
Es la nueva línea de productos que expanden Visual Studio ofreciendo herramientas ligeras y sencillas de aprender y de usar para aficionados, entusiastas y aprendices que quieren crear sitios Web y aplicaciones para Windows.



Visual Web Developer 2005 Express Edition.
Visual C# 2005 Express Edition.
Visual Basic 2005 Express Edition.
Visual C++ 2005 Express Edition.

776

VISUAL BASIC .NET. CURSO DE PROGRAMACIÓN


SQL Server 2005 Express Edition.
y Visual J# 2005 Express Edition.

Visual Studio 2005 Standard Edition
Una flexible herramienta de desarrollo para desarrolladores de aplicaciones de línea de negocio o programadores ocasionales que estén construyendo aplicaciones
móviles, basadas en Windows o para la Web.

Visual Studio 2005 Professional Edition
La completa herramienta de desarrollo para desarrolladores profesionales que trabajan solos o en pequeños equipos.

Visual Studio 2005 Tools para Microsoft Office System
La completa herramienta de desarrollo para desarrolladores profesionales construyendo soluciones sobre Microsoft Office System utilizando Excel, Word e InfoPath.

Visual Studio 2005 Team System
Herramientas de software de ciclo de vida productivas, integradas y extensibles
que permiten a las empresas reducir la complejidad en la creación de soluciones
orientadas a servicios.
Visual Studio Team System incluye:


Visual Studio Team Edition para Arquitectos de Software.
Visual Studio Team Edition para Desarrolladores.
Visual Studio Team Edition para Testers.

La nueva línea Visual Studio Team System también incluye Visual Studio
Team Suite, que contiene los tres productos basados en estos roles, y el nuevo Visual Studio Team Foundation Server, para una colaboración en equipo mucho más
eficiente.

APÉNDICE A: ENTORNOS DE DESARROLLO

777

APLICACIÓN DE CONSOLA
En el capítulo 2 vimos una introducción al desarrollo de aplicaciones con interfaz
gráfica de usuario, pero no abordamos el desarrollo de aplicaciones de consola
que en ocasiones puede ser útil. Veamos un ejemplo a continuación utilizando
cualquiera de las ediciones de Visual Studio.
Para editar y ejecutar el programa HolaMundo utilizando cualquiera de las
ediciones de Visual Studio, los pasos a seguir son los siguientes:
1. Partiendo de la página de inicio de Visual Studio, hacemos clic en Crear: Proyecto... para crear un proyecto nuevo, o bien ejecutamos la orden Archivo >
Nuevo > Proyecto. Esta acción hará que se visualice una ventana que mostrará los tipos de plantillas que puede utilizar; la elección de una u otra dependerá del tipo de aplicación que deseemos construir. La figura siguiente
muestra esta ventana:

Para que la ventana anterior muestre la lista Ubicación y la caja Nombre de la
solución tiene que habilitar, si no lo está, la opción “Guardar nuevos proyectos al crearlos”. Para ello, ejecute la orden Herramientas > Opciones > Proyectos y soluciones y seleccione esta opción en la ventana que se visualiza:

778

VISUAL BASIC .NET. CURSO DE PROGRAMACIÓN

Para nuestro ejemplo, elegimos la plantilla “Aplicación de consola”. Después,
especificamos el nombre del proyecto y su ubicación; observe que el proyecto
será creado en una carpeta con el mismo nombre. A continuación pulsamos el
botón Aceptar y obtendremos el esqueleto del proyecto de acuerdo con la
plantilla seleccionada. Para cambiar el nombre asignado al módulo y al fichero .vb, haga clic sobre éste último utilizando el botón derecho del ratón y seleccione del menú contextual que se visualiza la orden Cambiar nombre;
también podemos hacer este cambio a través de la ventana de propiedades.

Si necesitáramos añadir un fichero nuevo a este proyecto, haríamos clic con el
botón derecho del ratón sobre el nombre del proyecto y seleccionaríamos
Agregar > Nuevo elemento. Después, elegiríamos el tipo de elemento que de-

APÉNDICE A: ENTORNOS DE DESARROLLO

779

seamos añadir (por ejemplo Clase o Módulo) y, finalmente, haríamos clic en
el botón Agregar.

2. A continuación editamos el código que compone el programa. Después, antes
de compilar, especificamos que se trata de una aplicación de consola: Proyecto > Propiedades de HolaMundo > Aplicación > Tipo de resultado > Aplicación de consola (esto se puede conseguir también eligiendo directamente
como plantilla “Aplicación de consola”). Borre también el nombre especificado para el espacio de nombres.

780

VISUAL BASIC .NET. CURSO DE PROGRAMACIÓN

3. Para compilar el programa, ejecutamos la orden Generar HolaMundo del menú Generar. Finalmente, para ejecutar el programa seleccionamos la orden
Iniciar sin depurar del menú Depurar, o bien pulsamos las teclas Ctrl+F5.
También puede ejecutar el programa seleccionando la orden Iniciar depuración del menú Depurar, o bien pulsando las tecla F5. Los resultados de la
compilación se muestran en la ventana Resultados. La acción de ejecutar el
programa acarrea también su compilación si fuera necesario.

DEPURAR UNA APLICACIÓN
¿Por qué se depura una aplicación? Porque los resultados que estamos obteniendo
con la misma no son correctos y no sabemos por qué. El proceso de depuración
consiste en ejecutar la aplicación paso a paso, indistintamente por sentencias o por
métodos, con el fin de observar el flujo seguido durante su ejecución, así como los
resultados intermedios que se van sucediendo, con la finalidad de detectar las
anomalías que producen un resultado final erróneo.
Por ejemplo, para depurar una aplicación utilizando el depurador del entorno
de desarrollo de Visual Basic 2005 Express, ejecute la orden Depurar > Paso por
instrucciones y utilice las órdenes del menú Depurar o los botones correspondientes de la barra de herramientas (para saber el significado de cada botón, ponga el
puntero del ratón sobre cada uno de ellos).

De forma resumida, las órdenes disponibles para depurar una aplicación son
las siguientes:

Iniciar o F5. Inicia la ejecución de la aplicación en modo depuración hasta
encontrar un punto de parada o hasta el final si no hay puntos de parada.

Alternar puntos de interrupción o F9. Pone o quita un punto de parada en la
línea sobre la que está el punto de inserción.

Detener depuración o Mayús+F5. Detiene el proceso de depuración.

Paso a paso por instrucciones o F11. Ejecuta la aplicación paso a paso. Si la
línea a ejecutar coincide con una llamada a un método definido por el usuario,
dicho método también se ejecutará paso a paso.

Paso a paso por procedimientos o F10. Ejecuta la aplicación paso a paso. Si
la línea a ejecutar coincide con una llamada a un método definido por el usuario, dicho método no se ejecutará paso a paso, sino de una sola vez.

APÉNDICE A: ENTORNOS DE DESARROLLO

781

Paso a paso para salir o Mayús+F11. Cuando un método definido por el
usuario ha sido invocado para ejecutarse paso a paso, utilizando esta orden se
puede finalizar su ejecución en un solo paso.

Ejecutar hasta el cursor o Ctrl+F10. Ejecuta el código que hay entre la última línea ejecutada y la línea donde se encuentra el punto de inserción.

Inspección rápida o Ctrl+Alt+Q. Visualiza el valor de la variable que está bajo el punto de inserción o el valor de la expresión seleccionada (sombreada).

Para ejecutar la aplicación en un solo paso, seleccione la orden Iniciar sin depurar (Ctrl+F5) del menú Depurar.
Además de la barra de herramientas Depurar, dispone también de la barra de
herramientas Generar reducida que se muestra en la figura siguiente:

Esta barra de herramientas pone a su disposición las órdenes siguientes:

Generar aplicación. Compila la aplicación y genera el fichero ejecutable correspondiente.

Generar solución. Compila y genera todos los proyectos que componen la solución.

Cancelar. Detiene el proceso de compilación o de generación del fichero ejecutable.

ARGUMENTOS EN LA LÍNEA DE ÓRDENES
Si ejecuta una aplicación desde el EDI que requiere argumentos en la línea de órdenes, ¿dónde se introducen estos argumentos? Haga clic sobre el nombre del
proyecto con el botón derecho del ratón y seleccione la orden Propiedades. Después, en la ventana que se visualiza, seleccione el panel Depurar y escriba los argumentos según puede observar en la figura:

782

VISUAL BASIC .NET. CURSO DE PROGRAMACIÓN

VISUAL WEB DEVELOPER
Visual Web Developer 2005 Express (VWD) es una herramienta enfocada exclusivamente al desarrollo de aplicaciones Web dinámicas con ASP.NET 2.0. Para
ello, proporciona:

Diseñadores visuales para crear las páginas Web.

Un editor de código potente que muestra referencias del lenguaje a medida
que se escribe código, sin tener que dejar el editor. Con este editor podrá escribir código en los diferentes lenguajes .NET (Visual VB o C#) y código
HTML.

Desarrollo rápido de aplicaciones Web integradas con bases de datos. Para
ello proporciona acceso integrado a SQL Server Express.

Crear un sitio Web con VWD y probar su funcionamiento es algo sencillo
porque integra un servidor Web, por lo que no es necesario desplegar la aplicación en el servidor IIS de Windows (Internet Information Server). En realidad,
cualquier carpeta con páginas .aspx puede ser considerada virtualmente como un
sitio Web. Este servidor Web integrado será utilizado automáticamente cuando
elijamos como tipo de sitio Web “sistema de archivos”. Otros tipos de sitios Web
son HTTP y FTP, ambos necesitan tener instalado IIS.
La forma de trabajar con esta herramienta ha sido introducida en el último
capítulo de este libro y es tratada ampliamente en mi otro libro Enciclopedia de
Microsoft Visual Basic.

APÉNDICE B
© F.J.Ceballos/RA-MA

.NET PARA LINUX
Los desarrolladores sobre GNU/Linux pueden ahora también desarrollar aplicaciones multiplataforma basadas en .NET gracias al proyecto Mono.
¿Qué es Mono? Es un proyecto para construir una plataforma de desarrollo libre, basada en Linux, compatible con Microsoft .NET. Durante su desarrollo, ha
contado con el apoyo de algunos pesos pesados de la industria informática, sobre
todo del mundo Linux. Es el caso de Ximian, empresa dirigida por el mejicano
Miguel de Icaza, que se mostró interesada en colaborar con el desarrollo de este
entorno de programación desde el principio. Más tarde, la compañía norteamericana Novell adquirió esta empresa y se constituyó en uno de sus principales patrocinadores.
Mono, en su versión 1.2, incluye un compilador para C# y bibliotecas de ejecución (runtimes) para Java y Visual Basic, así como otras herramientas de ayuda
al desarrollo de aplicaciones multiplataforma (cross-platform; para varias computadoras/sistemas operativos).
Mono 1.2 se encuentra disponible para Linux, Mac OS X y Windows, pudiéndose disponer del código fuente o bien de paquetes precompilados para la última versión de Mac OS (10.3, Panther), Windows 2000 o superior, y las distribuciones Red Hat/Fedora y SuSE (aunque también es instalable en otras).
Para más detalles sobre el futuro de este proyecto visite la página Web
http://www.mono-project.com. En esta página encontrará también un enlace,
Downloads, desde el cual podrá descargarse el software correspondiente a Mono
para las distintas plataformas anteriormente comentadas, así como instrucciones
para su utilización.

784

VISUAL BASIC .NET. CURSO DE PROGRAMACIÓN

INSTALACIÓN DE MONO
La forma más sencilla de instalar Mono es ejecutando el asistente Mono 1.2.4_4
Installer válido para todas las distribuciones Linux. Para ello:
1. Abra en su explorador de Internet la página:
http://www.mono-project.com/Downloads

2. Descargue el paquete mono-1.2.4_4-installer.bin y proceda a su instalación
así:
a)
b)
c)
d)
e)
f)

Cambie a root (administrador): $ su Cambie a la carpeta donde está mono-1.2.4_4-installer.bin.
Ejecute la orden: # chmod +x mono-1.2.4_4-installer.bin
Ejecute la orden: # ./mono-1.2.4_4-installer.bin
Siga las instrucciones dadas por el asistente para la instalación.
Salga de la sesión de root: # exit

Si desea hace una instalación personalizada, siga un procedimiento análogo al
siguiente. Supongamos que nuestra máquina tiene instalada la distribución de SUSE Linux. Para instalar la plataforma Mono para esta distribución, diríjase a la
página Downloads de Mono, descargue el paquete mono-1.2.4.zip y proceda a su
instalación así:
a)
b)
c)
d)
e)

Cambie a root (administrador): $ su Descomprima mono-1.2.4.zip en una carpeta, por ejemplo en mono-1.2.4.
Desde la carpeta anterior, ejecute la orden: # rpm —Uvh *.rpm
Ahora puede borrar la carpeta mono-1.2.4.
Salga de la sesión de root: # exit

Otra alternativa es descargar una imagen de la máquina virtual VMware e instalarla. La imagen de VMware contiene una instalación de SUSE Linux con Mono
y varias herramientas de desarrollo y programas necesarios para probar las aplicaciones .NET en Linux usando la máquina virtual Mono.

EJECUTAR UN PROGRAMA Visual Basic
Una vez instalado Mono, escriba el programa HolaMundo.vb:
Module HolaMundo
Sub main()
System.Console.WriteLine("Hola mundo!!!")

APÉNDICE B: .NET PARA LINUX

785

End Sub
End Module

Ahora compile el programa escribiendo la orden:
mbas HolaMundo.vb

El resultado del proceso de compilación es el fichero HolaMundo.exe. Para
ejecutarlo, escriba la orden:
mono HolaMundo.exe

ENTORNO DE DESARROLLO DE MONO
En el CD de este libro hemos incluido el entorno de desarrollo integrado SharpDevelop para C# y Visual Basic sobre Windows. Pues bien, los creadores de este
EDI lo han reescrito para Linux y para Mac OS X. El resultado es MonoDevelop.
¿Cómo podemos disponer de este EDI? Si cuando instaló Mono siguió la alternativa 1 expuesta anteriormente o descargó la máquina virtual, MonoDevelop
ya estará instalado. Para abrirlo, ejecute la orden:
monodevelop

El resultado después de ejecutar la orden anterior puede verlo en la figura siguiente (en el momento de escribir este libro, aún no era posible realizar desarrollos en Visual Basic):

786

VISUAL BASIC .NET. CURSO DE PROGRAMACIÓN

Sign up to vote on this title
UsefulNot useful