P. 1
Ceballos: Microsoft Visual Basic .NET - Curso de programación

Ceballos: Microsoft Visual Basic .NET - Curso de programación

4.87

|Views: 11.590|Likes:
Programación orientada a objetos. Elementos del lenguaje. Sentencias de control. Clases de uso común. Matrices, cadenas y colecciones. Clases, espacios de nombres y estructuras. Operadores sobrecargados. Clases derivadas e interfaces. Tipos y métodos genéricos. Excepciones. Ficheros. Estructuras dinámicas. Algoritmos. Hilos. Introducción a las interfaces gráficas y aplicaciones para Internet. Ejercicios resueltos.
Programación orientada a objetos. Elementos del lenguaje. Sentencias de control. Clases de uso común. Matrices, cadenas y colecciones. Clases, espacios de nombres y estructuras. Operadores sobrecargados. Clases derivadas e interfaces. Tipos y métodos genéricos. Excepciones. Ficheros. Estructuras dinámicas. Algoritmos. Hilos. Introducción a las interfaces gráficas y aplicaciones para Internet. Ejercicios resueltos.

More info:

Published by: Fco. Javier Ceballos Sierra on Jan 07, 2009
Copyright:Traditional Copyright: All rights reserved

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
See more
See less

12/06/2015

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................................................................................ 3
LENGUAJES DE PROGRAMACIÓN.............................................................. 4
Compiladores................................................................................................. 6
Intérpretes...................................................................................................... 6
QUÉ ES Visual Basic .NET ............................................................................... 7
¿POR QUÉ APRENDER Visual Basic? ............................................................ 8
REALIZACIÓN DE UN PROGRAMA EN Visual Basic ................................. 8
Cómo crear un programa ............................................................................... 9
Interfaz de línea de órdenes ........................................................................... 9
¿Qué hace este programa?........................................................................ 10
Guardar el programa escrito en el disco ................................................... 11
Compilar y ejecutar el programa .............................................................. 11
Biblioteca de clases .................................................................................. 14
Guardar el programa ejecutable en el disco.............................................. 14
Depurar un programa................................................................................ 15
Entornos de desarrollo integrado................................................................... 15
EJERCICIOS RESUELTOS .............................................................................. 15
EJERCICIOS PROPUESTOS............................................................................ 17


X VISUAL BASIC .NET. CURSO DE PROGRAMACIÓN

CAPÍTULO 2. INTRODUCCIÓN A Visual Basic .NET ................................... 19
DECLARACIÓN DE UNA VARIABLE........................................................... 19
ASIGNAR VALORES....................................................................................... 22
AÑADIR COMENTARIOS............................................................................... 24
MOSTRAR DATOS POR LA PANTALLA...................................................... 24
EXPRESIONES ARITMÉTICAS...................................................................... 25
EXPRESIONES CONDICIONALES ................................................................ 27
ESCRIBIR NUESTROS PROPIOS PROCEDIMIENTOS................................ 29
EJERCICIOS PROPUESTOS............................................................................ 31

CAPÍTULO 3. INTRODUCCIÓN A LA POO................................................... 33
PENSAR EN OBJETOS .................................................................................... 34
Clases y objetos ............................................................................................. 34
Mensajes y métodos ...................................................................................... 35
DISEÑO DE UNA CLASE DE OBJETOS........................................................ 36
Atributos........................................................................................................ 37
Propiedades y métodos .................................................................................. 38
CONSTRUCTORES .......................................................................................... 45
HERENCIA........................................................................................................ 47
EJERCICIOS RESUELTOS .............................................................................. 54
EJERCICIOS PROPUESTOS............................................................................ 59

CAPÍTULO 4. ELEMENTOS DEL LENGUAJE .............................................. 61
CARACTERES DE Visual Basic....................................................................... 61
TIPOS................................................................................................................. 62
LITERALES....................................................................................................... 64
Literales enteros ............................................................................................ 64
Literales reales............................................................................................... 65
Literales de un solo carácter .......................................................................... 65
Literales de cadenas de caracteres ................................................................. 66
Literales de fecha y hora................................................................................ 66
Literal Nothing .............................................................................................. 67
IDENTIFICADORES......................................................................................... 68
PALABRAS CLAVE......................................................................................... 68
DECLARACIÓN DE CONSTANTES SIMBÓLICAS ..................................... 69
¿Por qué utilizar constantes? ......................................................................... 70
VARIABLES...................................................................................................... 70
CONVERSIÓN ENTRE TIPOS PRIMITIVOS................................................. 72
CONTENIDO XI

OPERADORES.................................................................................................. 74
Operadores lógicos ........................................................................................ 74
Operadores unitarios...................................................................................... 75
Operadores a nivel de bits ............................................................................. 76
Operadores de asignación.............................................................................. 77
Operador de concatenación ........................................................................... 77
PRIORIDAD Y ORDEN DE EVALUACIÓN................................................... 78
EJERCICIOS RESUELTOS .............................................................................. 79
EJERCICIOS PROPUESTOS............................................................................ 81

CAPÍTULO 5. ESTRUCTURA DE UN PROGRAMA.......................................... 83
ESTRUCTURA DE UN PROGRAMA Visual Basic ........................................ 83
Espacios de nombres ..................................................................................... 87
Protección de una clase ................................................................................. 90
Sentencias Option.......................................................................................... 91
Sentencia Imports .......................................................................................... 91
Especificación de alias .................................................................................. 92
Definiciones y declaraciones ......................................................................... 93
Sentencia simple............................................................................................ 93
Sentencia compuesta o bloque....................................................................... 94
Procedimientos .............................................................................................. 94
Definición de un procedimiento ............................................................... 94
Procedimiento Main ...................................................................................... 95
Crear objetos de una clase ............................................................................. 96
Cómo acceder a los miembros de un objeto .................................................. 97
Protección de los miembros de una clase ...................................................... 98
Miembro de un objeto o de una clase ............................................................ 99
Clases versus módulos estándar..................................................................... 102
Referencias a objetos..................................................................................... 102
Pasando argumentos a los métodos ............................................................... 105
EJERCICIOS RESUELTOS .............................................................................. 106
EJERCICIOS PROPUESTOS............................................................................ 109

CAPÍTULO 6. CLASES DE USO COMÚN........................................................ 111
ENTRADA Y SALIDA...................................................................................... 111
Flujos de entrada ........................................................................................... 113
Flujos de salida.............................................................................................. 115
Salida con formato......................................................................................... 117
Excepciones................................................................................................... 118
XII VISUAL BASIC .NET. CURSO DE PROGRAMACIÓN

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

CAPÍTULO 7. SENTENCIAS DE CONTROL .................................................. 141
SENTENCIA If .................................................................................................. 141
ANIDAMIENTO DE SENTENCIAS If............................................................. 143
ESTRUCTURA Else If ...................................................................................... 146
SENTENCIA Select ........................................................................................... 148
SENTENCIA While ........................................................................................... 152
Bucles anidados............................................................................................. 154
SENTENCIA Do ... Loop While........................................................................ 156
SENTENCIA For ............................................................................................... 159
SENTENCIA For Each ...................................................................................... 163
SENTENCIA Continue ...................................................................................... 163
SENTENCIA GoTo............................................................................................ 164
SENTENCIAS Try ... Catch............................................................................... 165
EJERCICIOS RESUELTOS .............................................................................. 166
EJERCICIOS PROPUESTOS............................................................................ 171

CAPÍTULO 8. MATRICES.................................................................................. 173
INTRODUCCIÓN A LAS MATRICES ............................................................ 174
MATRICES NUMÉRICAS UNIDIMENSIONALES ....................................... 175
Declarar una matriz ....................................................................................... 175
Crear una matriz ............................................................................................ 176
Iniciar una matriz........................................................................................... 177
Acceder a los elementos de una matriz.......................................................... 178
CONTENIDO XIII

Tamaño y dimensión de una matriz............................................................... 179
Métodos de una matriz .................................................................................. 179
Trabajar con matrices unidimensionales........................................................ 180
Matriz de tipo ArrayList ................................................................................ 181
Añadir un elemento .................................................................................. 182
Insertar un elemento................................................................................. 182
Modificar un elemento ............................................................................. 183
Obtener el valor de un elemento............................................................... 183
Tamaño..................................................................................................... 183
Eliminar elementos................................................................................... 183
Buscar elementos...................................................................................... 183
Copiar listas.............................................................................................. 183
Iteradores.................................................................................................. 184
Ejemplo .................................................................................................... 184
Matrices asociativas....................................................................................... 187
Diccionario.................................................................................................... 189
CADENAS DE CARACTERES........................................................................ 192
Clase String ................................................................................................... 194
New(cad() As Char) ................................................................................. 195
ToString()................................................................................................. 195
CopyTo(IndFuente As Integer, destino() As Char, .................................. 196
IndDes As Integer, nCars As Integer) ...................................................... 196
Concat(str1 As String, str2 As String)...................................................... 196
CompareTo(otroString As String) ............................................................ 196
Length ...................................................................................................... 198
ToLower() ................................................................................................ 198
ToUpper()................................................................................................. 198
Trim() ....................................................................................................... 198
StartsWith(prefijo As String) ................................................................... 198
EndsWith(sufijo As String) ...................................................................... 198
Substring(pos As Integer, ncars As Integer)............................................. 199
Chars(i As Integer) ................................................................................... 199
IndexOf(str As String).............................................................................. 199
IndexOfAny(cad() As Char)..................................................................... 199
Replace(str As String, nuevaStr As String) .............................................. 200
Insert(pos As Integer, str As String)......................................................... 200
Split(seps() As Char) ................................................................................ 200
Clase StringBuilder ....................................................................................... 200
New([arg])................................................................................................ 200
Length ...................................................................................................... 201
Capacity.................................................................................................... 201
Append(x As tipo) .................................................................................... 201
Insert(índice As Integer, x As tipo) .......................................................... 201
XIV VISUAL BASIC .NET. CURSO DE PROGRAMACIÓN

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

CAPÍTULO 9. MÁS SOBRE PROCEDIMIENTOS Y COLECCIONES........ 223
PASAR UNA MATRIZ COMO ARGUMENTO A UN PROCEDIMIENTO........................ 223
PROCEDIMIENTO QUE RETORNA UNA MATRIZ..................................... 225
PASAR UN ARGUMENTO DE UN TIPO PRIMITIVO....................................... 228
PASAR TIPOS REFERENCIA POR REFERENCIA........................................ 229
PASAR ARGUMENTOS EN LA LÍNEA DE ÓRDENES................................ 231
PROCEDIMIENTOS RECURSIVOS................................................................ 234
PROCEDIMIENTOS SOBRECARGADOS...................................................... 236
NÚMERO VARIABLE DE PARÁMETROS.................................................... 237
LA CLASE Object ............................................................................................. 239
Equals(Object obj)......................................................................................... 240
ToString() ...................................................................................................... 241
Finalize() ....................................................................................................... 241
GetHashCode() .............................................................................................. 241
MÁS SOBRE REFERENCIAS Y OBJETOS String ......................................... 242
LA CLASE Array............................................................................................... 245
Clear .............................................................................................................. 245
Sort ................................................................................................................ 245
BinarySearch ................................................................................................. 246
Reverse.......................................................................................................... 247
COLECCIONES................................................................................................. 247
Crear una colección....................................................................................... 247
Colecciones predefinidas............................................................................... 249
Colecciones genéricas ................................................................................... 249
EJERCICIOS RESUELTOS .............................................................................. 251
EJERCICIOS PROPUESTOS............................................................................ 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........................................................................ 261
Atributos........................................................................................................ 263
Métodos de una clase..................................................................................... 264
Propiedades ................................................................................................... 265
Control de acceso a los miembros de la clase................................................ 266
Acceso público ......................................................................................... 268
Acceso privado......................................................................................... 268
Acceso protegido...................................................................................... 268
Acceso interno.......................................................................................... 268
IMPLEMENTACIÓN DE UNA CLASE........................................................... 269
MÉTODOS SOBRECARGADOS ..................................................................... 272
NÚMERO VARIABLE DE PARÁMETROS.................................................... 274
IMPLEMENTACIÓN DE UNA APLICACIÓN ............................................... 275
CONTROL DE ACCESO A UNA CLASE ....................................................... 276
REFERENCIA Me ............................................................................................. 277
INICIACIÓN DE UN OBJETO......................................................................... 278
Constructor .................................................................................................... 280
Sobrecarga del constructor ............................................................................ 282
Llamar a un constructor................................................................................. 284
Asignación de objetos.................................................................................... 284
Constructor copia .......................................................................................... 286
DESTRUCCIÓN DE OBJETOS........................................................................ 287
Destructor ...................................................................................................... 287
Sentencia Using............................................................................................. 289
Ejecutar el recolector de basura..................................................................... 290
REFERENCIAS COMO MIEMBROS DE UNA CLASE................................. 291
REDEFINIR MÉTODOS HEREDADOS DE Object ........................................ 298
Método Equals............................................................................................... 299
MIEMBROS SHARED DE UNA CLASE......................................................... 300
Atributos Shared............................................................................................ 300
Acceder a los atributos Shared ...................................................................... 302
Métodos Shared............................................................................................. 303
DECLARACIONES PARCIALES .................................................................... 305
CLASES ANIDADAS ....................................................................................... 307
DELEGADOS.................................................................................................... 308
Multidifusión................................................................................................. 311
MATRICES DE OBJETOS................................................................................ 312
ESPACIO DE NOMBRES................................................................................. 321
Utilizar espacios de nombres......................................................................... 322
XVI VISUAL BASIC .NET. CURSO DE PROGRAMACIÓN

Espacio de nombres global ............................................................................ 323
ESTRUCTURAS................................................................................................ 324
EJERCICIOS RESUELTOS .............................................................................. 325
EJERCICIOS PROPUESTOS............................................................................ 332

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

CAPÍTULO 12. CLASES DERIVADAS E INTERFACES............................... 367
CLASES DERIVADAS Y HERENCIA ............................................................ 368
DEFINIR UNA CLASE DERIVADA ............................................................... 371
Control de acceso a los miembros de las clases............................................. 373
Qué miembros hereda una clase derivada...................................................... 374
ATRIBUTOS CON EL MISMO NOMBRE...................................................... 379
REDEFINIR MÉTODOS DE LA CLASE BASE.............................................. 380
CONSTRUCTORES DE LAS CLASES DERIVADAS.................................... 382
COPIA DE OBJETOS........................................................................................ 385
DESTRUCTORES DE LAS CLASES DERIVADAS....................................... 387
JERARQUÍA DE CLASES................................................................................ 388
REFERENCIAS A OBJETOS DE UNA CLASE DERIVADA ........................ 395
Conversiones implícitas................................................................................. 396
Conversiones explícitas ................................................................................. 398
INFORMACIÓN DE TIPOS DURANTE LA EJECUCIÓN............................. 399
MÉTODOS VIRTUALES.................................................................................. 399
CONTENIDO XVII

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

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

CAPÍTULO 14. EXCEPCIONES......................................................................... 451
EXCEPCIONES DE Visual Basic...................................................................... 452
MANEJAR EXCEPCIONES ............................................................................. 454
Lanzar una excepción.................................................................................... 455
Capturar una excepción ................................................................................. 455
Excepciones derivadas................................................................................... 457
Capturar cualquier excepción ........................................................................ 458
Relanzar una excepción................................................................................. 459
BLOQUE DE FINALIZACIÓN......................................................................... 459
CREAR EXCEPCIONES................................................................................... 461
XVIII VISUAL BASIC .NET. CURSO DE PROGRAMACIÓN

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

CAPÍTULO 15. FLUJOS...................................................................................... 473
VISIÓN GENERAL DE LOS FLUJOS DE E/S................................................ 475
ABRIENDO FICHEROS PARA ACCESO SECUENCIAL ............................. 476
Flujos de bytes............................................................................................... 476
FileStream................................................................................................ 476
Flujos de caracteres ....................................................................................... 482
StreamWriter ............................................................................................ 482
StreamReader ........................................................................................... 484
Clases File, Directory y Path......................................................................... 485
Flujos de datos de tipos primitivos ................................................................ 487
BinaryWriter ............................................................................................ 488
BinaryReader............................................................................................ 489
Un ejemplo de acceso secuencial .................................................................. 491
Escribir en un fichero ............................................................................... 491
Leer de un fichero .................................................................................... 494
ABRIENDO FICHEROS PARA ACCESO ALEATORIO ............................... 496
Propiedades y métodos para acceso aleatorio................................................ 496
Position..................................................................................................... 496
Length ...................................................................................................... 497
Seek.......................................................................................................... 497
La clase CPersona.......................................................................................... 499
La clase CListaTfnos..................................................................................... 500
Constructor de CListaTfnos ..................................................................... 501
Escribir un registro en el fichero .............................................................. 503
Añadir un registro al final del fichero ...................................................... 504
Leer un registro del fichero ...................................................................... 504
Eliminar un registro del fichero................................................................ 505
¿Hay registros marcados para eliminar?................................................... 506
Buscar un registro en el fichero................................................................ 506
Un ejemplo de acceso aleatorio a un fichero ................................................. 507
Modificar un registro................................................................................ 509
Actualizar el fichero................................................................................. 510
UTILIZACIÓN DE DISPOSITIVOS ESTÁNDAR .......................................... 511
SERIACIÓN DE OBJETOS............................................................................... 516
EJERCICIOS RESUELTOS .............................................................................. 518
EJERCICIOS PROPUESTOS............................................................................ 524
CONTENIDO XIX

PARTE 3. DISEÑO Y PROGRAMACIÓN............................. 527
CAPÍTULO 16. ESTRUCTURAS DINÁMICAS ............................................... 529
LISTAS LINEALES .......................................................................................... 530
Listas lineales simplemente enlazadas........................................................... 530
Operaciones básicas....................................................................................... 533
Inserción de un elemento al comienzo de la lista ..................................... 534
Buscar en una lista un elemento con un valor x ....................................... 536
Inserción de un elemento en general ........................................................ 536
Borrar un elemento de la lista................................................................... 537
Recorrer una lista ..................................................................................... 538
Borrar todos los elementos de una lista .................................................... 538
UNA CLASE PARA LISTAS LINEALES........................................................ 539
Clase genérica para listas lineales.................................................................. 543
Alternativas al método Obtener................................................................ 553
LISTAS CIRCULARES..................................................................................... 554
Clase CListaCircularSE(Of T)....................................................................... 555
PILAS................................................................................................................. 559
COLAS............................................................................................................... 561
EJEMPLO .......................................................................................................... 562
LISTA DOBLEMENTE ENLAZADA.............................................................. 564
Lista circular doblemente enlazada ............................................................... 565
Clase CListaCircularDE(Of T)................................................................. 566
Ejemplo .................................................................................................... 571
ÁRBOLES.......................................................................................................... 573
Árboles binarios ............................................................................................ 574
Formas de recorrer un árbol binario .............................................................. 575
ÁRBOLES BINARIOS DE BÚSQUEDA......................................................... 577
Clase CArbolBinB(Of T)............................................................................... 578
Buscar un nodo en el árbol ............................................................................ 581
Insertar un nodo en el árbol ........................................................................... 582
Borrar un nodo del árbol................................................................................ 583
Utilización de la clase CArbolBinB(Of T) .................................................... 586
ÁRBOLES BINARIOS PERFECTAMENTE EQUILIBRADOS ..................... 589
Clase CArbolBinE(Of T)............................................................................... 590
Utilización de la clase CArbolBinE(Of T) .................................................... 595
EJERCICIOS RESUELTOS .............................................................................. 597
EJERCICIOS PROPUESTOS............................................................................ 611


XX VISUAL BASIC .NET. CURSO DE PROGRAMACIÓN

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

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

Bloqueado ................................................................................................ 687
Dormido ................................................................................................... 687
Esperando................................................................................................. 688
SINCRONIZACIÓN DE HILOS ....................................................................... 689
Mecanismos de sincronización...................................................................... 689
Objetos de sincronización.............................................................................. 690
Secciones críticas ..................................................................................... 692
Ejemplo que implementa una sección crítica ........................................... 694
Exclusión mutua....................................................................................... 698
Monitor reentrante.................................................................................... 700
Utilizar Wait y Pulse/PulseAll ................................................................. 701
¿Por qué los métodos Almacenar y Obtener utilizan un bucle?.......... 708
Objeto Mutex............................................................................................ 709
Objeto Semaphore .................................................................................... 711
Problema del productor-consumidor ........................................................ 712
Controladores de espera ........................................................................... 718
Detener un hilo de forma controlada ........................................................ 723
Interbloqueo................................................................................................... 725
GRUPO DE HILOS ........................................................................................... 725
PLANIFICACIÓN DE HILOS........................................................................... 726
Asignar prioridades a los hilos ...................................................................... 727
EJERCICIOS RESUELTOS .............................................................................. 731
EJERCICIOS PROPUESTOS............................................................................ 737

CAPÍTULO 19. INTERFACES GRÁFICAS Y APLICACIONES PARA INTERNET... 739
INTERFACES GRÁFICAS ............................................................................... 740
Crear un nuevo proyecto ............................................................................... 741
El formulario ................................................................................................. 745
Dibujar los controles...................................................................................... 746
Borrar un control ........................................................................................... 750
Propiedades de los objetos............................................................................. 751
Bloquear la posición de todos los controles................................................... 753
Icono de la aplicación.................................................................................... 753
Escribir los controladores de eventos ............................................................ 753
Guardar la aplicación..................................................................................... 756
Verificar la aplicación ................................................................................... 756
Propiedades del proyecto............................................................................... 758
Crear soluciones de varios proyectos ............................................................ 759
ADO.NET........................................................................................................... 760
Componentes de ADO.NET.......................................................................... 761
ACCEDER A LA WEB ..................................................................................... 762
XXII VISUAL BASIC .NET. CURSO DE PROGRAMACIÓN

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

PARTE 4. APÉNDICES............................................................ 773
A. ENTORNOS DE DESARROLLO................................................................... 775
VISUAL STUDIO 2005..................................................................................... 775
Ediciones Visual Studio 2005 Express .......................................................... 775
Visual Studio 2005 Standard Edition ............................................................ 776
Visual Studio 2005 Professional Edition....................................................... 776
Visual Studio 2005 Tools para Microsoft Office System.............................. 776
Visual Studio 2005 Team System ................................................................. 776
APLICACIÓN DE CONSOLA.......................................................................... 777
DEPURAR UNA APLICACIÓN....................................................................... 780
ARGUMENTOS EN LA LÍNEA DE ÓRDENES ............................................. 781
VISUAL WEB DEVELOPER ........................................................................... 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 ......................... 787
JUEGO DE CARACTERES ANSI .................................................................... 788
UTILIZACIÓN DE CARACTERES ASCII ...................................................... 789
JUEGO DE CARACTERES ASCII ................................................................... 790
JUEGO DE CARACTERES UNICODE ........................................................... 791

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









PRÓLOGO

Visual Basic es actualmente, junto con C# y Java, uno de los lenguajes de pro-
gramación más populares en Internet. Pero, además, está disponible para el desa-
rrollo 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 progra-
mador el nivel de abstracción preciso para abordar el desarrollo de cualquier apli-
cació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 com-
parado con otros lenguajes como Visual Basic, que ofrecen, además de facilidad,
una elevada productividad en el desarrollo de aplicaciones, aunque eso sí, sacrifi-
cando 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 Ba-
sic, al igual que C#, es un lenguaje moderno orientado a objetos que permite desa-
rrollar 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 desarro-
lladores 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, Vi-
sual 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 SharpDe-
velop 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 Vi-
sual 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áfi-
cas 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 sim-
plemente 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 obje-
tos. 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 lec-
tor de saber que aún Visual Basic proporciona mucho más. Por eso hay una terce-
ra 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 Vi-
sual 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 lecto-
res, en general, el EDI y el SDK que el estudio de esta obra requiere.
Francisco Javier Ceballos Sierra
http://www.fjceballos.es/




P A R T E


________________________
_________________________________
__________________________________________

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





P A R T E


________________________
_________________________________
__________________________________________


Mecanismos de abstracción
• Clases, espacios de nombres y estructuras
• Operadores sobrecargados
• Clases derivadas e interfaces
• Tipos y métodos genéricos
• Excepciones
• Flujos















P A R T E


________________________
_________________________________
__________________________________________




Diseño y programación
• Estructuras dinámicas
• Algoritmos
• Hilos
• Interfaces gráficas y aplicaciones para Internet










P A R T E


________________________
_________________________________
__________________________________________




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 ins-
talació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 du-
rante la instalación de los mismos.
VISUAL STUDIO 2005
Visual Studio 2005 proporciona una variedad de herramientas tanto para desarro-
lladores 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 herramien-
tas ligeras y sencillas de aprender y de usar para aficionados, entusiastas y apren-
dices 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 tra-
bajan solos o en pequeños equipos.
Visual Studio 2005 Tools para Microsoft Office System
La completa herramienta de desarrollo para desarrolladores profesionales cons-
truyendo soluciones sobre Microsoft Office System utilizando Excel, Word e In-
foPath.
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 Vi-
sual 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: Pro-
yecto... para crear un proyecto nuevo, o bien ejecutamos la orden Archivo >
Nuevo > Proyecto. Esta acción hará que se visualice una ventana que mos-
trará los tipos de plantillas que puede utilizar; la elección de una u otra depen-
derá 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 proyec-
tos al crearlos”. Para ello, ejecute la orden Herramientas > Opciones > Pro-
yectos 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 fiche-
ro .vb, haga clic sobre éste último utilizando el botón derecho del ratón y se-
leccione 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: Proyec-
to > Propiedades de HolaMundo > Aplicación > Tipo de resultado > Apli-
cación de consola (esto se puede conseguir también eligiendo directamente
como plantilla “Aplicación de consola”). Borre también el nombre especifica-
do para el espacio de nombres.

780 VISUAL BASIC .NET. CURSO DE PROGRAMACIÓN

3. Para compilar el programa, ejecutamos la orden Generar HolaMundo del me-
nú 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 depura-
ció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 correspondien-
tes 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 usua-
rio, 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 últi-
ma 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á ba-
jo 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 de-
purar (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 co-
rrespondiente.
• Generar solución. Compila y genera todos los proyectos que componen la so-
lución.
• Cancelar. Detiene el proceso de compilación o de generación del fichero eje-
cutable.
ARGUMENTOS EN LA LÍNEA DE ÓRDENES
Si ejecuta una aplicación desde el EDI que requiere argumentos en la línea de ór-
denes, ¿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. Des-
pués, en la ventana que se visualiza, seleccione el panel Depurar y escriba los ar-
gumentos 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 exclu-
sivamente 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á es-
cribir 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 aplica-
ció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 aplica-
ciones multiplataforma basadas en .NET gracias al proyecto Mono.
¿Qué es Mono? Es un proyecto para construir una plataforma de desarrollo li-
bre, 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 norteameri-
cana Novell adquirió esta empresa y se constituyó en uno de sus principales pa-
trocinadores.
Mono, en su versión 1.2, incluye un compilador para C# y bibliotecas de eje-
cución (runtimes) para Java y Visual Basic, así como otras herramientas de ayuda
al desarrollo de aplicaciones multiplataforma (cross-platform; para varias compu-
tadoras/sistemas operativos).
Mono 1.2 se encuentra disponible para Linux, Mac OS X y Windows, pu-
diéndose disponer del código fuente o bien de paquetes precompilados para la úl-
tima versión de Mac OS (10.3, Panther), Windows 2000 o superior, y las distribu-
ciones 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) Cambie a root (administrador): $ su -
b) Cambie a la carpeta donde está mono-1.2.4_4-installer.bin.
c) Ejecute la orden: # chmod +x mono-1.2.4_4-installer.bin
d) Ejecute la orden: # ./mono-1.2.4_4-installer.bin
e) Siga las instrucciones dadas por el asistente para la instalación.
f) 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 SU-
SE 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) Cambie a root (administrador): $ su -
b) Descomprima mono-1.2.4.zip en una carpeta, por ejemplo en mono-1.2.4.
c) Desde la carpeta anterior, ejecute la orden: # rpm —Uvh *.rpm
d) Ahora puede borrar la carpeta mono-1.2.4.
e) Salga de la sesión de root: # exit
Otra alternativa es descargar una imagen de la máquina virtual VMware e ins-
talarla. La imagen de VMware contiene una instalación de SUSE Linux con Mono
y varias herramientas de desarrollo y programas necesarios para probar las aplica-
ciones .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 Sharp-
Develop 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 al-
ternativa 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 si-
guiente (en el momento de escribir este libro, aún no era posible realizar desarro-
llos en Visual Basic):
786 VISUAL BASIC .NET. CURSO DE PROGRAMACIÓN


You're Reading a Free Preview

Descarga
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->