Ceballos: Enciclopedia de Microsoft Visual Basic 3Ed

Enciclopedia de Microsoft® Visual Basic  Interfaces gráficas y aplicaciones para Internet con Windows Forms y ASP.NET 3.ª edición Fco. Javier Ceballos Sierra Profesor titular de la Escuela Politécnica Superior Universidad de Alcalá

www.fjceballos.es

Enciclopedia de Microsoft Visual Basic Interfaces gráficas y aplicaciones para Internet con Windows Forms y ASP.NET 3.ª edición. © Fco. Javier Ceballos Sierra © De la edición: RA-MA 2013 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 mencionado 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: [email protected] Internet: www.ra-ma.es y www.ra-ma.com ISBN: 978-84-9964-265-9 Depósito Legal: M-xxxxx-2013 Autoedición: Fco. Javier Ceballos Filmación e impresión: Closas-Orcoyen, S.L. Impreso en España Primera impresión: octubre 2013

Si no puedo dibujarlo es que no lo entiendo. (Einstein) Dedico esta obra a María del Carmen, mi esposa, y a mis hijos Francisco y Javier.

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

PARTE 1. INTRODUCCIÓN...................................................

1

CAPÍTULO 1. INTRODUCCIÓN A MICROSOFT .NET ................................

3

PLATAFORMA .NET ........................................................................................ .NET Framework................................................................................................. Aplicaciones de cliente .................................................................................. Aplicaciones web ........................................................................................... ADO.NET ...................................................................................................... Biblioteca de clases base ................................................................................ Entorno de ejecución común de los lenguajes ............................................... .NET Framework y COM+ ............................................................................ Visual Studio ..................................................................................................

4 5 7 7 9 9 9 12 13

CAPÍTULO 2. MI PRIMERA APLICACIÓN ....................................................

15

MICROSOFT VISUAL STUDIO ....................................................................... 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 .............................................................

15 17 21 22 27 27 29 29 30

VIII

ENCICLOPEDIA DE MICROSOFT VISUAL BASIC

Guardar la aplicación ..................................................................................... Verificar la aplicación .................................................................................... Propiedades del proyecto ............................................................................... Crear soluciones de varios proyectos ............................................................. Opciones del EDI ........................................................................................... Personalizar el EDI ........................................................................................ WPF ....................................................................................................................

33 33 35 36 37 37 38

PARTE 2. INTERFACES GRÁFICAS ................................... 41 CAPÍTULO 3. APLICACIÓN WINDOWS FORMS .........................................

43

PROGRAMANDO EN WINDOWS................................................................... ESTRUCTURA DE UNA APLICACIÓN.......................................................... Compilar y ejecutar la aplicación ................................................................... DISEÑO DE LA INTERFAZ GRÁFICA ........................................................... Crear un componente ..................................................................................... Controles más comunes ............................................................................ Añadir una etiqueta y editar sus propiedades............................................ Añadir un botón de pulsación y editar sus propiedades ............................ Añadir una descripción abreviada a un componente................................. CONTROL DE EVENTOS ................................................................................ Asignar controladores de eventos a un objeto................................................ CICLO DE VIDA DE UN FORMULARIO ....................................................... PROPIEDADES BÁSICAS DE UN FORMULARIO........................................ Administración de la duración ....................................................................... Administración de formularios ...................................................................... Apariencia y comportamiento ........................................................................ CONFIGURACIÓN DE UNA APLICACIÓN ................................................... RECURSOS DE UNA APLICACIÓN ............................................................... ATRIBUTOS GLOBALES DE UNA APLICACIÓN........................................ CICLO DE VIDA DE UNA APLICACIÓN....................................................... Permitir una sola instancia de la aplicación ................................................... Argumentos en la línea de órdenes ................................................................ Pantalla de presentación .................................................................................

45 47 51 53 53 53 54 56 57 58 61 62 64 64 65 65 66 68 70 71 74 75 76

CAPÍTULO 4. INTRODUCCIÓN A WINDOWS FORMS ...............................

79

BIBLIOTECA DE CLASES DE WINDOWS FORMS ..................................... CAJAS DE TEXTO, ETIQUETAS Y BOTONES ............................................. Desarrollo de la aplicación .............................................................................

79 82 82

CONTENIDO

Objetos ...................................................................................................... Eventos...................................................................................................... Pasos a seguir durante el desarrollo .......................................................... El formulario, los controles y sus propiedades ......................................... Tecla de acceso ......................................................................................... Botón predeterminado ............................................................................... Responder a los eventos ............................................................................ Enfocar un objeto ........................................................................................... Seleccionar el texto de una caja de texto ....................................................... INTERCEPTAR LA TECLA PULSADA .......................................................... VALIDACIÓN DE UN CAMPO DE TEXTO ................................................... Eventos Validating y Validated ..................................................................... Expresiones regulares .................................................................................... Ejemplos de expresiones regulares ........................................................... El motor de expresiones regulares ............................................................ MaskedTextBox ............................................................................................. EJERCICIOS RESUELTOS ............................................................................... Diseño de una calculadora ............................................................................. Objetos ...................................................................................................... Eventos...................................................................................................... Pasos a seguir durante el desarrollo .......................................................... Diseño de la ventana y de los controles ......................................................... Establecer una fuente ..................................................................................... Color .............................................................................................................. Escribir el código ........................................................................................... EJERCICIOS PROPUESTOS.............................................................................

IX

83 83 83 84 85 85 85 89 90 91 93 96 99 99 102 104 105 106 106 106 106 107 109 109 110 119

CAPÍTULO 5. MENÚS Y BARRAS DE HERRAMIENTAS ............................ 121 ARQUITECTURA .............................................................................................. MENÚS ............................................................................................................... DISEÑO DE UNA BARRA DE MENÚS .......................................................... Crear un menú mediante programación ......................................................... Controlador de un elemento de un menú ....................................................... Aceleradores y nemónicos ............................................................................. IMÁGENES EN CONTROLES ......................................................................... Recursos de una aplicación ............................................................................ LISTA DE TAREAS........................................................................................... BARRA DE HERRAMIENTAS......................................................................... Diseño de una barra de herramientas ............................................................. BARRA DE ESTADO ........................................................................................ Diseño de una barra de estado ........................................................................

121 123 124 125 128 129 130 130 133 134 134 136 137

X


DESARROLLO DE UN EDITOR DE TEXTOS ............................................... Caja de texto multilínea ................................................................................. Diseño del editor ............................................................................................ El portapapeles ............................................................................................... Objeto My.Computer.Clipboard ............................................................... Trabajar con texto seleccionado ..................................................................... Diseño de la barra de menús .......................................................................... Diseño de la barra de herramientas ................................................................ Asociar un método con un elemento de un menú .......................................... Archivo - Salir........................................................................................... Edición - Cortar......................................................................................... Edición - Copiar ........................................................................................ Edición - Pegar.......................................................................................... Opciones - Fuente ..................................................................................... Opciones - Tamaño ................................................................................... Habilitar o inhabilitar los elementos de un menú...................................... Marcar el elemento seleccionado de un menú .......................................... Deshacer ......................................................................................................... Recordar las ediciones reversibles ............................................................ Añadir a la interfaz la orden Deshacer ...................................................... Listas desplegables en menús......................................................................... MENÚS CONTEXTUALES .............................................................................. MENÚS DINÁMICOS ....................................................................................... EJERCICIOS PROPUESTOS.............................................................................

138 139 140 142 142 143 144 146 147 148 148 149 149 149 151 152 153 154 154 154 155 159 161 164

CAPÍTULO 6. CONTROLES Y CAJAS DE DIÁLOGO .................................. 169 CAJAS DE DIÁLOGO MODALES Y NO MODALES .................................... CAJAS DE MENSAJE ....................................................................................... Requerir datos con InputBox ......................................................................... Cómo se utilizan estas cajas de diálogo ......................................................... CAJAS DE DIÁLOGO PERSONALIZADAS ................................................... Crear una caja de diálogo ............................................................................... Mostrar una caja de diálogo ........................................................................... Introducción de datos y recuperación de los mismos ..................................... DIÁLOGO ACERCA DE ................................................................................... FORMULARIO PROPIETARIO........................................................................ OTROS CONTROLES WINDOWS FORMS .................................................... Casillas de verificación .................................................................................. Botones de opción .......................................................................................... Listas simples ................................................................................................. Diseñar la lista...........................................................................................

170 170 174 175 176 177 178 179 181 182 183 184 188 193 194

CONTENIDO

Iniciar la lista............................................................................................. Acceder a los elementos seleccionados..................................................... Colección de elementos de una lista ......................................................... Clase CheckedListBox .............................................................................. Listas desplegables ......................................................................................... Diseñar la lista........................................................................................... Iniciar la lista............................................................................................. Acceder al elemento seleccionado ............................................................ Colección de elementos de una lista desplegable ..................................... Controles de rango definido ........................................................................... ScrollBar ................................................................................................... TrackBar ................................................................................................... ProgressBar ............................................................................................... Control con pestañas ...................................................................................... Gestión de fechas ........................................................................................... FlowLayoutPanel y TableLayoutPanel .......................................................... CAJAS DE DIÁLOGO ESTÁNDAR ................................................................. Cajas de diálogo Abrir y Guardar .................................................................. Caja de diálogo Color .................................................................................... Caja de diálogo Fuente ................................................................................... REDIMENSIONAR UN COMPONENTE ......................................................... TEMPORIZADORES ......................................................................................... EJERCICIOS RESUELTOS ............................................................................... EJERCICIOS PROPUESTOS.............................................................................

XI

196 196 197 198 198 200 201 201 202 203 203 207 208 210 211 213 216 217 220 221 222 223 227 238

CAPÍTULO 7. TABLAS Y ÁRBOLES ................................................................ 241 TABLAS ............................................................................................................. Arquitectura de un control DataGridView ..................................................... Construir una tabla ......................................................................................... Añadir las columnas a la tabla ....................................................................... Iniciar la tabla................................................................................................. Tamaño de las celdas ..................................................................................... Acceder al valor de la celda seleccionada ...................................................... ÁRBOLES........................................................................................................... Arquitectura de un árbol ................................................................................ Construir un árbol .......................................................................................... Añadir nodos a un árbol ................................................................................. Imágenes para los nodos del árbol ................................................................. Iniciar el árbol ................................................................................................ Acceder al nodo seleccionado ........................................................................ Recorrer todos los nodos del árbol .................................................................

241 243 244 245 246 252 253 254 255 255 256 257 258 260 264

XII


Añadir y borrar nodos .................................................................................... Añadir un nodo ......................................................................................... Borrar el nodo seleccionado...................................................................... Borrar todos los nodos excepto la raíz ...................................................... Personalizar el aspecto de un árbol ................................................................ VISTAS DE UNA LISTA................................................................................... Personalizar el aspecto de una vista ............................................................... La colección Columns .................................................................................... Elemento de la lista ........................................................................................ La colección Items ......................................................................................... Un ejemplo con ListView, TreeView y SplitContainer ................................. EJERCICIOS RESUELTOS ............................................................................... EJERCICIOS PROPUESTOS.............................................................................

264 265 268 268 269 269 270 271 272 273 273 276 292

CAPÍTULO 8. DIBUJAR Y PINTAR .................................................................. 293 SERVICIOS DE GDI+........................................................................................ OBJETOS DE DIBUJO BÁSICOS .................................................................... Objeto Graphics ............................................................................................. Objeto Color................................................................................................... Objeto Pen ...................................................................................................... Objeto Brush .................................................................................................. Objeto Point ................................................................................................... Objeto Rectangle ............................................................................................ Objeto Font .................................................................................................... Objeto GraphicsPath ...................................................................................... MÉTODOS DE DIBUJO .................................................................................... Líneas y rectángulos....................................................................................... Elipses y arcos ................................................................................................ Tartas.............................................................................................................. Polígonos........................................................................................................ Curvas flexibles.............................................................................................. Trazados ......................................................................................................... Regiones ......................................................................................................... GRÁFICOS PERSISTENTES ............................................................................ SISTEMAS DE COORDENADAS Y TRANSFORMACIONES ...................... Tipos de sistemas de coordenadas.................................................................. Transformaciones de color ............................................................................. MOSTRAR IMÁGENES .................................................................................... Mapas de bits ................................................................................................. Cargar y mostrar un mapa de bits .................................................................. Intercambiar imágenes a través del portapapeles ...........................................

295 296 298 299 300 301 302 302 303 304 304 304 305 306 306 307 308 308 311 313 317 318 320 320 322 327

CONTENIDO

XIII

CAMBIAR LA FORMA DEL PUNTERO DEL RATÓN ................................. 329 EJERCICIOS RESUELTOS ............................................................................... 330 EJERCICIOS PROPUESTOS............................................................................. 340 CAPÍTULO 9. INTERFAZ PARA MÚLTIPLES DOCUMENTOS ................. 343 CREACIÓN DE UNA APLICACIÓN MDI....................................................... Organizar los formularios hijo ....................................................................... EDITOR DE TEXTO MDI ................................................................................. Formulario padre ............................................................................................ Formulario hijo .............................................................................................. Vincular código con los controles .................................................................. Iniciar y finalizar la aplicación.................................................................. Nuevo documento ..................................................................................... Abrir un documento .................................................................................. Guardar un documento .............................................................................. Guardar como............................................................................................ Imprimir un documento ............................................................................ Cortar, copiar y pegar ............................................................................... Recordar las ediciones reversibles ............................................................ Barras de herramientas y de estado ........................................................... Menú Ventana ........................................................................................... Selección actual del texto.......................................................................... El documento ha cambiado ....................................................................... Operaciones de arrastrar y soltar ............................................................... EJERCICIOS RESUELTOS ............................................................................... EJERCICIOS PROPUESTOS.............................................................................

344 347 348 348 350 352 353 353 354 355 356 357 359 360 361 362 363 365 366 366 371

CAPÍTULO 10. CONSTRUCCIÓN DE CONTROLES ......................................... 373 REUTILIZACIÓN DE CONTROLES EXISTENTES ....................................... Control TextBox extendido ............................................................................ Clasificación de las propiedades de un control .............................................. CONTROLES DE USUARIO ............................................................................ Construir el control de usuario ....................................................................... Añadir propiedades ................................................................................... Añadir métodos ......................................................................................... Añadir eventos .......................................................................................... Opciones fecha-hora alarma o actual ........................................................ Verificar el control de usuario........................................................................ EJERCICIOS RESUELTOS ............................................................................... EJERCICIOS PROPUESTOS.............................................................................

373 374 379 379 380 381 382 383 383 384 386 389

XIV


CAPÍTULO 11. PROGRAMACIÓN CON HILOS ............................................ 391 ESPACIO DE NOMBRES System.Threading ................................................... Clase Thread .................................................................................................. Resumen de los métodos y propiedades de Thread........................................ Estados de un hilo .......................................................................................... ACCESO A CONTROLES DESDE HILOS ...................................................... Delegados ....................................................................................................... Componente BackgroundWorker................................................................... Ejecutar una tarea de forma asíncrona ...................................................... Notificar el progreso a la interfaz gráfica del usuario ............................... Recuperar el estado después de la finalización de la tarea ........................ Cancelación anticipada ............................................................................. MECANISMOS DE SINCRONIZACIÓN ......................................................... Objetos de sincronización .............................................................................. Secciones críticas ...................................................................................... Controladores de espera ............................................................................ DETENER UN HILO DE FORMA CONTROLADA ....................................... EJERCICIOS RESUELTOS ............................................................................... EJERCICIOS PROPUESTOS.............................................................................

392 395 398 398 399 399 404 405 406 407 407 408 409 410 412 414 417 420

PARTE 3. ACCESO A DATOS ............................................... 421 CAPÍTULO 12. ENLACE DE DATOS EN WINDOWS FORMS ..................... 423 ASPECTOS BÁSICOS ....................................................................................... Enlace de datos manual .................................................................................. Notificar cuándo cambia una propiedad ........................................................ Enlace de datos con las clases de .NET ......................................................... La clase Binding ....................................................................................... Tipos de enlace ......................................................................................... Componente BindingSource ..................................................................... Notificación de cambios en un enlace de Windows Forms ...................... Crear un enlace ......................................................................................... Enlaces con otros controles.................................................................. Aplicar conversiones............................................................................ ORÍGENES DE DATOS COMPATIBLES CON WINDOWS FORMS ........... Enlace a colecciones de objetos ..................................................................... List ............................................................................................................ BindingList ............................................................................................... BindingSource .......................................................................................... ACCEDIENDO A LOS DATOS ........................................................................

423 423 427 430 431 432 432 433 433 435 435 439 442 442 447 451 454

CONTENIDO

Ventana de orígenes de datos ......................................................................... Vinculación maestro-detalle........................................................................... Operaciones con los datos .............................................................................. Elemento actual ......................................................................................... Navegar ..................................................................................................... Ordenación, filtrado y búsqueda ............................................................... BindingListView ............................................................................................ Elemento actual de la vista........................................................................ Ordenar ..................................................................................................... Filtrar ........................................................................................................ Buscar ....................................................................................................... Datos introducidos por el usuario .................................................................. Error en los datos ...................................................................................... Validación ................................................................................................. Datos que no necesitan validación ............................................................

XV 457 461 465 465 466 469 471 472 473 474 474 475 477 478 479

CAPÍTULO 13. ACCESO A UNA BASE DE DATOS ....................................... 487 SQL ..................................................................................................................... Crear una base de datos .................................................................................. Crear una tabla ............................................................................................... Escribir datos en la tabla ................................................................................ Modificar datos de una tabla .......................................................................... Borrar registros de una tabla .......................................................................... Seleccionar datos de una tabla ....................................................................... Crear una base de datos .................................................................................. Base de datos Microsoft Access................................................................ Base de datos Microsoft SQL Server ........................................................ ADO.NET ........................................................................................................... Componentes de ADO.NET........................................................................... Conjunto de datos........................................................................................... Proveedor de datos ......................................................................................... Objeto conexión ........................................................................................ Objeto orden ............................................................................................. Objeto lector de datos ............................................................................... Adaptador de datos ................................................................................... Modos de conexión ........................................................................................ Probando una conexión .................................................................................. ACCESO CONECTADO A UNA BASE DE DATOS ...................................... ATAQUES DE INYECCIÓN DE CÓDIGO SQL .............................................. Órdenes parametrizadas ................................................................................. Procedimientos almacenados .........................................................................

488 488 488 490 490 491 491 493 493 495 496 497 498 500 501 503 503 504 506 508 509 512 516 517

XVI


TRANSACCIONES ............................................................................................ Transacción implícita TransactionScope ....................................................... Transacciones explícitas................................................................................. ESCRIBIR CÓDIGO INDEPENDIENTE DEL PROVEEDOR ........................ CONSTRUIR COMPONENTES DE ACCESO A DATOS............................... Capa de presentación ..................................................................................... Operaciones contra la base de datos............................................................... Objetos de negocio ......................................................................................... Capa de acceso a datos ................................................................................... Capa de lógica de negocio ............................................................................. Diseño de la capa de presentación ................................................................. Lógica de interacción con la capa de presentación ........................................ Desacoplar la IU del resto de la aplicación .................................................... Adaptar la colección de objetos ................................................................ Capa de lógica de negocio ........................................................................ Lógica de interacción con la capa de presentación ................................... Validación ...................................................................................................... ACCESO DESCONECTADO A UNA BASE DE DATOS ............................... ASISTENTES DE VISUAL STUDIO ................................................................ Crear la infraestructura para el acceso a la base de datos .............................. Crear el conjunto de datos .............................................................................. Agregar un control rejilla al formulario ......................................................... Código subyacente ......................................................................................... Asistente para configurar orígenes de datos................................................... VISTA EN DETALLE DEL CONJUNTO DE DATOS .................................... Diseño del formulario .................................................................................... Vincular las cajas de texto con el conjunto de datos ...................................... Controles de navegación ................................................................................ Añadir, borrar y buscar datos ......................................................................... CONTROL BindingNavigator ............................................................................ DISEÑO MAESTRO-DETALLE ....................................................................... EJERCICIOS RESUELTOS ............................................................................... EJERCICIOS PROPUESTOS.............................................................................

518 519 523 525 531 533 533 535 537 541 542 544 547 548 551 554 555 555 559 561 566 567 568 570 574 576 577 579 582 586 587 596 616

CAPÍTULO 14. LINQ ............................................................................................ 619 RECURSOS DEL LENGUAJE COMPATIBLES CON LINQ.......................... Declaración implícita de variables locales ..................................................... Matrices de tipos definidos de forma implícita .............................................. Tipos anónimos .............................................................................................. Propiedades autoimplementadas .................................................................... Iniciadores de objetos y colecciones ..............................................................

619 620 620 620 621 621

CONTENIDO

Métodos extensores ........................................................................................ Expresiones lambda ....................................................................................... El delegado Func(Of T, TResu)...................................................................... Operadores de consulta .................................................................................. Árboles de expresiones lambda ...................................................................... EXPRESIONES DE CONSULTA...................................................................... Compilación de una expresión de consulta .................................................... Sintaxis de las expresiones de consulta .......................................................... Cláusula Group ......................................................................................... Productos cartesianos ................................................................................ Cláusula Join ............................................................................................. Cláusula Into ............................................................................................. Cláusula Let .............................................................................................. PROVEEDORES DE LINQ ............................................................................... ENTITY FRAMEWORK ................................................................................... MARCO DE ENTIDADES DE ADO.NET ........................................................ Consultar un modelo de objetos ..................................................................... ACCESO A UNA BASE DE DATOS ................................................................ Conectarse a la base de datos ......................................................................... Generar el modelo de entidades ..................................................................... Las clases de entidad y el contexto de objetos ............................................... Propiedades de navegación ............................................................................ Mostrar datos en una interfaz gráfica ............................................................. Una aplicación con interfaz gráfica................................................................ Vincular controles con el origen de datos ...................................................... Proveedor de datos ......................................................................................... Filtros ............................................................................................................. Contextos de corta duración ........................................................................... REALIZAR CAMBIOS EN LOS DATOS ......................................................... Modificar filas en la base de datos ................................................................. Insertar filas en la base de datos ..................................................................... Borrar filas en la base de datos ...................................................................... Problemas de concurrencia ............................................................................ El seguimiento de cambios............................................................................. CODE FIRST: UN NUEVO MODELO DE TRABAJO .................................... Aplicando Code First ..................................................................................... Definir el modelo de entidades ................................................................. Definir el contexto de objetos ................................................................... Anotaciones en datos y convenciones predeterminadas ........................... Cadena de conexión .................................................................................. Generar la base de datos............................................................................ Validación de entidades ................................................................................. Atributos de anotación de datos ................................................................

XVII 622 623 625 626 629 632 635 637 637 638 638 639 640 641 642 643 647 651 652 652 661 664 666 667 668 669 673 675 675 680 682 685 689 695 700 702 702 703 704 705 707 710 710

XVIII


Interfaz fluida ............................................................................................ Code First desde una base de datos existente................................................. Cadena de conexión .................................................................................. Contexto de objetos................................................................................... El modelo de entidades ............................................................................. Acceder a los datos ................................................................................... EJERCICIOS RESUELTOS ............................................................................... EJERCICIOS PROPUESTOS.............................................................................

712 713 715 715 716 717 718 720

PARTE 4. APLICACIONES PARA INTERNET .................. 721 CAPÍTULO 15. ASP.NET ..................................................................................... 723 ASP.NET ............................................................................................................. Conceptos básicos de ASP.NET .................................................................... Páginas web ASP.NET .................................................................................. Controles HTML ............................................................................................ Controles de servidor web.............................................................................. Presentación del texto ............................................................................... Controles de entrada ................................................................................. Envío y devolución ................................................................................... Exploración ............................................................................................... Controles de diseño ................................................................................... Selección de fechas ................................................................................... Controles con enlaces a datos ................................................................... Controles de validación............................................................................. Un ejemplo de diseño de una página web ASP.NET ..................................... Software para el desarrollo de aplicaciones ASP.NET .................................. Componentes de una página web ASP.NET .................................................. ¿Cómo se publica una aplicación web? ......................................................... Crear un directorio virtual ......................................................................... Convertir la aplicación en una aplicación web de IIS ............................... Seguridad asociada con una carpeta.......................................................... Modelo de ejecución de una página web ASP.NET ...................................... Lógica de negocio .......................................................................................... Enlaces de datos en ASP.NET ....................................................................... Expresiones de enlace de datos ................................................................. Controles de lista enlazados a datos .......................................................... Modelo de enlace de ASP.NET ................................................................ GridView ............................................................................................. Seleccionar datos ................................................................................. Actualizar y eliminar datos ..................................................................

725 726 727 728 729 730 730 732 733 733 733 734 734 735 737 739 741 742 744 746 747 749 753 753 754 757 759 761 762

CONTENIDO

XIX

Insertar datos (FormView) ................................................................... 765 Estado del modelo y validación ........................................................... 767 Asistente para publicar un proyecto web ASP.NET ...................................... 768 CAPÍTULO 16. FORMULARIOS WEB ............................................................. 773 APLICACIÓN WEB ASP.NET .......................................................................... Crear la capa de acceso a datos ...................................................................... Añadir un nuevo formulario web ................................................................... Descripción de un formulario web ASP.NET ........................................... Agregar controles y texto a la página ............................................................. Ciclo de vida de una página ........................................................................... Modelo de eventos de ASP.NET ................................................................... Añadir los controladores de eventos .............................................................. Obtener acceso a la base de datos .................................................................. CONTROLES DE VALIDACIÓN ..................................................................... HERRAMIENTA DE PRECOMPILACIÓN ASP.NET .................................... PROCESAMIENTO DE FORMULARIOS ....................................................... Formato de la petición HTTP ......................................................................... Petición HTTP get..................................................................................... Petición HTTP post ................................................................................... Respuestas en el protocolo HTTP .................................................................. Contexto de un formulario web...................................................................... Redireccionar una solicitud a otra URL ......................................................... ESTADO DE UNA PÁGINA ASP.NET ............................................................ Administración de estado en el cliente........................................................... Cookies ..................................................................................................... Cadenas de consulta .................................................................................. Campos de formulario ocultos .................................................................. Estado de vista .......................................................................................... Administración de estado en el servidor ........................................................ Estado de aplicación ................................................................................. Estado de sesión ........................................................................................ Bases de datos ........................................................................................... MEJORANDO EL RENDIMIENTO EN EL SERVIDOR................................. Almacenamiento en la caché de resultados .................................................... Configurar el almacenamiento en caché a nivel de página ....................... Actualización dinámica de fragmentos de una página en caché ............... Configurar el almacenamiento en caché por programación ...................... Almacenamiento en caché de datos procedentes de SQL Server ................ Reducir la información hacia y desde el servidor .......................................... CONTROLES DE SERVIDOR COMO ORIGEN DE DATOS.........................

774 778 780 781 782 784 787 787 790 792 796 798 798 799 800 801 801 803 803 804 804 806 807 807 809 810 810 811 812 812 813 814 815 816 817 819

XX


SQL y desarrollo web .................................................................................... Control SqlDataSource ............................................................................. Responder a los eventos ............................................................................ LINQ y desarrollo web .................................................................................. Control EntityDataSource ......................................................................... Responder a los eventos ............................................................................ Generar la consulta Select mediante código ............................................. Realizar cambios en los datos ................................................................... Actualizar y eliminar filas en la base de datos ..................................... Controlar los errores en una página ASP.NET .................................... Insertar filas en la base de datos .......................................................... MODELO DE ENLACE DE ASP.NET ............................................................. Realizar cambios en los datos ................................................................... Actualizar y eliminar filas en la base de datos ..................................... Controlar los errores en una página ASP.NET .................................... Insertar filas en la base de datos .......................................................... Capa de la lógica de negocio.......................................................................... Paginación, ordenación y filtrado .................................................................. EJERCICIOS PROPUESTOS.............................................................................

820 822 826 828 829 835 836 838 839 841 841 847 852 852 855 855 860 863 869

CAPÍTULO 17. SERVICIOS WEB ...................................................................... 871 Integrar un servicio web en una aplicación .................................................... SERVICIOS WCF .............................................................................................. MODELO DE PROGRAMACIÓN DE WCF .................................................... Implementar un servicio WCF ....................................................................... Definir un contrato .................................................................................... Configuración del servicio WCF .............................................................. Implementar un cliente WCF ......................................................................... Configuración del cliente WCF ................................................................ Obtener acceso al servicio web ................................................................. Ejecución asíncrona .................................................................................. Seguridad en WCF ......................................................................................... SERVICIOS WEB Y LINQ ................................................................................ Arquitectura de N capas lógicas y N niveles físicos ...................................... Crear la base de datos..................................................................................... Crear el servicio WCF.................................................................................... Cliente WCF .................................................................................................. Llenar la lista............................................................................................. Mostrar datos ............................................................................................ Actualizar datos ........................................................................................ Cambiar foto .............................................................................................

872 873 874 875 876 882 884 888 888 890 893 894 895 896 897 904 907 908 909 909

CONTENIDO

XXI

Agregar datos ............................................................................................ Borrar datos............................................................................................... Errores inesperados ................................................................................... EJERCICIOS PROPUESTOS.............................................................................

910 911 911 912

CAPÍTULO 18. SEGURIDAD DE APLICACIONES ASP.NET ...................... 919 ARQUITECTURA ASP.NET ............................................................................. CICLO DE VIDA DE UNA APLICACIÓN ASP.NET ..................................... GRUPOS DE APLICACIONES EN IIS ............................................................. AUTENTICACIÓN DE WINDOWS ................................................................. AUTORIZACIÓN ............................................................................................... SUPLANTACIÓN DE IDENTIDAD ................................................................. AUTENTICACIÓN MEDIANTE FORMULARIOS ......................................... CONTROLES PARA INICIO DE SESIÓN ....................................................... SERVICIO DE SUSCRIPCIONES..................................................................... SEGURIDAD EN LA TRANSMISIÓN DE DATOS ........................................ Criptografía simétrica..................................................................................... Criptografía asimétrica ................................................................................... AUTENTICACIÓN USANDO CERTIFICADOS ............................................. Instalar un certificado SSL en IIS 7.0 o superior ........................................... Certificado de cliente rechazado ....................................................................

920 921 922 923 930 932 933 938 951 958 959 959 961 963 968

CAPÍTULO 19. PÁGINAS MAESTRAS ............................................................. 969 ESTRUCTURA DE UNA PÁGINA MAESTRA ............................................... Controles de usuario web ............................................................................... Mejorar el aspecto de la interfaz .................................................................... Temas y máscaras en ASP.NET ..................................................................... Perfiles ........................................................................................................... EJERCICIOS RESUELTOS ............................................................................... Base de datos .................................................................................................. Cliente web ....................................................................................................

969 974 979 980 983 987 988 992

CAPÍTULO 20. AJAX ........................................................................................... 1001 FUNDAMENTOS DE AJAX ............................................................................. 1003 XMLHttpRequest ........................................................................................... 1004 AJAX con ASP.NET...................................................................................... 1012 GENERACIÓN DE CÓDIGO JAVASCRIPT ................................................... 1014 Fichero JavaScript .......................................................................................... 1015

XXII


Vincular un evento con una función JavaScript ............................................. 1015 Inyectar código JavaScript desde el lado del servidor ................................... 1017 ASP.NET AJAX ................................................................................................. 1018 Crear un sitio web ASP.NET AJAX ................................................................... 1019 Clase ScriptManager ...................................................................................... 1020 Clases ScriptManager y ScriptManagerProxy ............................................... 1028 Clase UpdatePanel ......................................................................................... 1028 Clase AsyncPostBackTrigger......................................................................... 1030 Clase UpdateProgress..................................................................................... 1031 Cancelar una llamada asíncrona ..................................................................... 1033 Clase Timer .................................................................................................... 1034 Servicios web ................................................................................................. 1034 Métodos de página ......................................................................................... 1038 EJERCICIOS RESUELTOS ............................................................................... 1040

PARTE 5. ACERCA DEL MATERIAL ADICIONAL Y DE LOS APÉNDICES ........................................................ 1043

HERRAMIENTAS DE DESARROLLO.............................................................. 1045 PÁGINAS WEB ...................................................................................................... 1061 INTERNACIONALIZACIÓN .............................................................................. 1093 .NET PARA LINUX ............................................................................................... 1103 ÍNDICE ................................................................................................................... 1105

PRÓLOGO Visual Basic es hoy el lenguaje de programación más popular del mundo. Desde que Microsoft liberó Visual Basic 1.0 en 1991 han tenido lugar muchos cambios. Visual Basic 1.0 revolucionó la forma de desarrollar software para Windows; desmitificó el proceso de desarrollo de aplicaciones con interfaz gráfica de usuario y abrió este tipo de programación a las masas. En sus posteriores versiones, Visual Basic ha continuado proporcionando nuevas características que facilitaron la creación de aplicaciones para Windows cada vez más potentes; por ejemplo, la versión 3.0 introdujo el control de datos para facilitar el acceso a bases de datos, y la versión 4.0 mejoró y potenció este acceso con los objetos DAO. Con la aparición de Windows 95, Microsoft liberó Visual Basic 4.0 que abrió la puerta al desarrollo de aplicaciones de 32 bits y a la creación de DLL. La versión 5.0 mejoró la productividad con la incorporación de la ayuda inteligente y la introducción de los controles ActiveX. Posteriormente la versión 6.0 nos introdujo en la programación de Internet con las aplicaciones DHTML y el objeto WebClass. Después dispusimos de Visual Basic .NET que vino a revolucionar el mundo de las comunicaciones permitiendo escribir aplicaciones escalables para Internet. Siguieron Visual Basic 2005, 2008, 2010 y ahora Visual Basic 2012, una evolución del lenguaje Visual Basic, que se diseñó para generar aplicaciones con seguridad de tipos y orientadas a objetos de manera productiva. Esta generación de Visual Basic continúa la tradición de ofrecer una manera rápida y fácil de crear aplicaciones basadas en .NET Framework. Visual Basic .NET, después Visual Basic 2005, 2008, 2010 y ahora Visual Basic 2012, cambian la idea de programar de las versiones iniciales. Ahora se requiere una programación orientada a objetos, lo que obligará al desarrollador a programar de forma ordenada, con unas reglas metodológicas de programación análogas a las de otros lenguajes de programación orientados a objetos como C++, C# o Java por citar algunos de los más utilizados.

XXIV


La palabra “Visual” hace referencia, desde el lado del diseño, al método que se utiliza para crear la interfaz gráfica de usuario si se dispone de la herramienta adecuada (con Microsoft Visual Studio se utiliza el ratón para arrastrar y colocar los objetos prefabricados en el lugar deseado dentro de un formulario) y desde el lado de la ejecución, al aspecto gráfico que toman los objetos cuando se ejecuta el código que los crea, objetos que formarán la interfaz gráfica que el usuario de la aplicación utiliza para acceder a los servicios que ésta ofrece. La palabra “Basic” hace referencia al lenguaje BASIC (Beginners All-Purpose Symbolic Instruction Code), un lenguaje utilizado por más programadores que ningún otro lenguaje en la historia de la informática. Visual Basic ha evolucionado a partir del lenguaje BASIC original y ahora está soportado por una biblioteca orientada a objetos directamente relacionada con la interfaz gráfica de Windows. Y “NET” hace referencia al ámbito donde operarán nuestras aplicaciones web (Network - red). Resumiendo, Visual Basic es un lenguaje orientado a objetos seguro y elegante que permite a los desarrolladores construir un amplio rango de aplicaciones seguras y robustas que se ejecutan sobre .NET Framework. .NET Framework (que incluye entre otras cosas la biblioteca básica de .NET y el compilador Visual Basic) junto con otros componentes de desarrollo, como ASP.NET (formularios web y servicios web) y ADO.NET, forman un paquete de desarrollo denominado Microsoft Visual Studio que podemos utilizar para crear aplicaciones Windows tradicionales (aplicaciones de escritorio que muestren una interfaz gráfica al usuario) y aplicaciones para la Web. Para ello, este paquete proporciona un editor de código avanzado, diseñadores de interfaces de usuario apropiados, depurador integrado y muchas otras utilidades para facilitar un desarrollo rápido de aplicaciones.

Para quién es este libro Este libro está pensado para aquellas personas que quieran aprender a desarrollar aplicaciones que muestren una interfaz gráfica al usuario, aplicaciones para acceso a bases de datos y para Internet (páginas web). Para ello, ¿qué debe hacer el lector? Pues simplemente leer ordenadamente los capítulos del libro, resolviendo cada uno de los ejemplos que en ellos se detallan. Evidentemente, no vamos a enseñar a programar aquí, por eso es necesario tener algún tipo de experiencia con un lenguaje de programación orientado a objetos (Visual Basic, C#, Java, etc., son lenguajes orientados a objetos). Haber programado en .NET y con Visual Basic sería lo ideal, así como tener conocimientos de HTML y XML. Estos requisitos son materia de mis otros libros Microsoft Visual Basic - Lenguaje y aplicaciones y Microsoft Visual Basic - Curso de programación, ambos editados también por RA-MA y Alfaomega Grupo Editor.

PRÓLOGO

XXV

Microsoft Visual Basic - Lenguaje y aplicaciones se centra en la programación básica: tipos, sentencias, matrices, métodos, ficheros, etc., y hace una introducción a las interfaces gráficas, a las bases de datos y a las aplicaciones para Internet, y Microsoft Visual Basic - Curso de programación cubre la programación básica (expuesta en menor medida en el libro anterior) y la programación orientada a objetos (POO) en detalle: clases, clases derivadas, interfaces, espacios de nombres, excepciones, etc.; después, utilizando la POO, añade otros temas como estructuras dinámicas de datos, algoritmos de uso común, hilos (programación concurrente), etc. Éste sí que es un libro de programación con Visual Basic en toda su extensión. Puede ver más detalles de cada uno de ellos en mi web: www.fjceballos.es.

Cómo está organizado el libro El libro se ha estructurado en 20 capítulos más algunos apéndices que a continuación se relacionan. Los capítulos 1 y 2 nos introducen en .NET y en el desarrollo de aplicaciones de escritorio. Los capítulos 3 al 11 nos enseñan a desarrollar aplicaciones de escritorio que muestran una interfaz de ventanas al usuario. Los capítulos 12 al 14 cubren el enlace a datos, el acceso a bases de datos (ADO.NET), el lenguaje de consultas integrado (LINQ) y el acceso a bases de datos con Entity Framework. Y los capítulos 15 al 20 nos enseñan cómo desarrollar aplicaciones para Internet (ASP.NET) a base de formularios web, servicios web WCF y AJAX. CAPÍTULO 1. INTRODUCCIÓN A MICROSOFT .NET CAPÍTULO 2. MI PRIMERA APLICACIÓN CAPÍTULO 3. APLICACIÓN WINDOWS FORMS CAPÍTULO 4. INTRODUCCIÓN A WINDOWS FORMS CAPÍTULO 5. MENÚS Y BARRAS DE HERRAMIENTAS CAPÍTULO 6. CONTROLES Y CAJAS DE DIÁLOGO CAPÍTULO 7. TABLAS Y ÁRBOLES CAPÍTULO 8. DIBUJAR Y PINTAR CAPÍTULO 9. INTERFAZ PARA MÚLTIPLES DOCUMENTOS CAPÍTULO 10. CONSTRUCCIÓN DE CONTROLES CAPÍTULO 11. PROGRAMACIÓN CON HILOS CAPÍTULO 12. ENLACE DE DATOS EN WINDOWS FORMS CAPÍTULO 13. ACCESO A UNA BASE DE DATOS CAPÍTULO 14. LINQ CAPÍTULO 15. ASP.NET CAPÍTULO 16. FORMULARIOS WEB CAPÍTULO 17. SERVICIOS WEB CAPÍTULO 18. SEGURIDAD DE APLICACIONES ASP.NET CAPÍTULO 19. PÁGINAS MAESTRAS CAPÍTULO 20. AJAX APÉNDICE A. HERRAMIENTAS DE DESARROLLO APÉNDICE B. PÁGINAS WEB APÉNDICE C. INTERNACIONALIZACIÓN APÉNDICE D. .NET PARA LINUX

XXVI


Qué se necesita para utilizar este libro Este libro ha sido escrito utilizando el paquete Microsoft .NET Framework Software Development Kit (SDK) versión 4.5 que forma parte del entorno de desarrollo Microsoft Visual Studio 2012 que incluye todo lo necesario para escribir, construir, verificar y ejecutar aplicaciones .NET. Por lo tanto, basta con que instale en su máquina Microsoft Visual Studio 2012, o superior, en cualquiera de sus versiones o, como alternativa, descargue desde http://www.microsoft.com/express/ los paquetes Visual Studio Express 2012 for Windows Desktop y for Web e instálelos (opcionalmente puede instalar también SQL Server 2012 Express, caso del autor). Nota: para probar las aplicaciones web se recomienda instalar el servidor de aplicaciones IIS (Internet Information Services) que incluye Windows (Inicio > Panel de control > Agregar y quitar programas > Windows). Esto tiene que hacerlo antes de instalar Microsoft Visual Studio 2012 o Visual Studio Express 2012 for Web.

Sobre los ejemplos del libro El código fuente de todos los ejemplos del libro podrá descargarse, según se indica en los apéndices, de la web www.ra-ma.es desde la página web correspondiente al libro.

Agradecimientos He recibido ayuda de algunas personas durante la preparación de este libro y, por ello, les 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 software que el estudio de esta obra requiere. Francisco Javier Ceballos Sierra http://www.fjceballos.es/

PARTE

 

 

Introducción 

Introducción a Microsoft .NET



Mi primera aplicación

PARTE

 

 

Interfaces gráficas 

Aplicación Windows Forms



Introducción a Windows Forms



Menús y barras de herramientas



Controles y cajas de diálogo



Tablas y árboles



Dibujar y pintar



Interfaz para múltiples documentos



Construcción de controles



Programación con hilos

PARTE

 

 

Acceso a datos 

Enlace de datos en Windows Forms



Acceso a una base de datos



LINQ

PARTE

 

 

Aplicaciones para Internet  ASP.NET  Formularios web  Servicios web  Seguridad de aplicaciones ASP.NET  Páginas maestras  AJAX

PARTE 

 

 

Acerca del material adicional y de los apéndices  Herramientas de desarrollo  Páginas web  Internacionalización  .NET para Linux  Índice

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

HERRAMIENTAS 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 establecidos; 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 Visual Studio proporciona una variedad de herramientas tanto para desarrolladores individuales como para equipos de desarrollo. http://www.microsoft.com/express/

Ediciones Visual Studio 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. Su descarga es gratuita y dependiendo del tipo de aplicación a desarrollar optaremos por una u otra herramienta de desarrollo de las siguientes:  

Visual Studio Express for Web. Visual Studio Express for Windows 8.

1046   


Visual Studio Express for Windows Desktop. Visual Studio Express for Windows Phone. Visual Studio Team Foundation Server Express.

Ediciones de Visual Studio para profesionales Visual Studio en sus versiones professional, premium y ultimate, ofrece 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, soluciones sobre Microsoft Office System utilizando Excel, Word e InfoPath, y con 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. La utilización de estas versiones requiere comprar una licencia.

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 MS Visual Visual Basic Express, hacemos clic en Nuevo 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:

APÉNDICE A: ENTORNOS DE DESARROLLO

1047

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:

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 fichero .vb, hacemos clic sobre Module1.vb y utilizando el botón derecho del ratón, seleccio-

1048


namos 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 deseamos añadir 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 la aplicación, podemos verificar que se trata de una aplicación de consola: Proyecto > Propiedades de HolaMundo > Aplicación > Tipo de resultado > Aplicación de consola.


1049

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 la 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 Studio, 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).

1050


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.



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.


1051



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:

CONECTAR A LOCALDB O A SQLEXPRESS El servidor de base de datos que se instala con Visual Studio es diferente dependiendo de la versión de Visual Studio que haya instalado: 

Si se utiliza Visual Studio 2010 se creará una base de datos SQL Express.



Si se utiliza Visual Studio 2012 se creará una base de datos LocalDB. Esto no significa que no pueda utilizar una base de datos SQL Express.

SQL Server Express SQL Server 2012 Express es el motor de base de datos gratuito, potente, pero sencillo, que se integra perfectamente con el resto de productos Express. Se trata de

1052


una versión aligerada de la nueva generación de SQL Server que puede descargar gratuitamente del sitio web de Microsoft. Este producto tiene el mismo motor de base de datos que toda la familia SQL Server y utiliza el mismo lenguaje SQL. Otra característica interesante es la movilidad de las bases de datos de un servidor a otro con XCOPY. Con esta utilidad podemos mover un fichero MDF de una máquina a otra a cualquier ubicación dentro de su sistema de ficheros, quedando la base de datos movida lista para trabajar. Para utilizar esta base de datos deberemos hacer uso de la opción AttachDBFilename en la cadena de conexión, según se muestra a continuación: connectionString="Data Source=.\sqlexpress;Initial Catalog=; Integrated Security=True;AttachDBFileName=C:\bd\bd_editorial.mdf"

La entrada Data Source especifica el servidor de base de datos que vamos a utilizar y AttachDBFilename, la localización del fichero de base de datos. Obsérvese que la entrada Initial Catalog está vacía. Para crear una base de datos utilizando SQL Server Express tiene que hacerlo desde la línea de órdenes (véase también el capítulo titulado Acceso a una base de datos). Para iniciar la consola que le permita trabajar contra el motor de base de datos SQL Server, localice en su instalación el fichero SQLCMD.EXE, cambie a ese directorio y ejecute la orden: SQLCMD -S nombre-del-ordenador\SqlExpress

Una vez iniciada la consola, puede escribir órdenes SQL a continuación del símbolo “>”. Para ejecutar un bloque de sentencias escriba GO. Para salir, escriba QUIT. Por ejemplo, el guión que muestra la figura siguiente crea la base de datos


1053

tfnos con una tabla telefonos, añade tres filas a la tabla y, finalmente, selecciona todas las filas de la tabla con todas sus columnas:

Para ver la relación de órdenes que puede utilizar a través de la aplicación SQLCMD ejecute la orden help como se muestra en la figura siguiente. Obsérvese que cada orden va precedida por dos puntos (:).

1054


SQL Server 2012 Express LocalDB Microsoft SQL Server 2012 Express LocalDB es un modo de ejecución de SQL Server Express destinado a los desarrolladores de programas con el fin de sustituir la característica de instancias de usuario de SQL Server Express, que ha quedado obsoleta. La instalación de LocalDB copia un conjunto de archivos mínimo necesario para iniciar el motor de base de datos de SQL Server. Una instancia de SQL Server Express LocalDB se puede administrar con la herramienta de línea de órdenes SqlLocalDB.exe.

SQL SERVER MANAGEMENT STUDIO EXPRESS Si instaló SQL Server, habrá comprobado que no dispone de una herramienta de administración de bases de datos. Por tal motivo, Microsoft también ha desarrollado una nueva aplicación para gestionar bases de datos que puede obtener de forma gratuita de Internet en la dirección especificada a continuación: http://www.microsoft.com/es-es/downloads Esta aplicación presenta una interfaz gráfica, muy sencilla de utilizar, para realizar tareas típicas como crear bases de datos, gestionar las tablas de la base, los procedimientos almacenados, crear usuarios, etc. Cuando inicie SQL Server Management Studio Express, le serán solicitados el nombre del servidor de bases de datos, el tipo de autenticación, y el usuario y la contraseña sólo si eligió autenticación SQL Server:

Una vez realizada la conexión con el gestor de bases de datos, le será mostrada la ventana de la figura siguiente. Seleccione en la lista del panel de la izquierda la base de datos con la que desea trabajar, haga clic en el botón Nueva consulta de


1055

la barra de herramientas y, después, escriba en el mismo las sentencias SQL que desee ejecutar. Para ejecutar una sentencia SQL haga clic en el botón Ejecutar de la barra de herramientas.

CREAR UNA BASES DE DATOS Si no instaló SQL Server 2012 Express puede crear una nueva base de datos local al proyecto siguiendo los pasos especificados a continuación. Haga clic con el botón secundario del ratón sobre el nombre del proyecto para agregar un nuevo elemento y seleccione Base de datos basada en servicio. A continuación se abrirá el asistente para la configuración de orígenes de datos y, como no hay ningún objeto de base de datos disponible porque la base de datos es nueva, haga clic en Cancelar para crear y agregar la base de datos vacía al proyecto. A continuación puede continuar añadiendo las tablas, los datos de las tablas, las relaciones entre las tablas, etc. Puede ver un ejemplo en el apartado Ejercicios resueltos del capítulo Acceso a una base de datos. Si instaló SQL Server 2012 Express (nombre predeterminado del servidor: sqlexpress), entonces es posible añadir al proyecto elementos nuevos de tipo base

1056


de datos utilizando el explorador de bases de datos. Para ello, abra el Explorador de bases de datos (Ver > Otras ventanas > Explorador de bases de datos). Haga clic con el botón secundario del ratón sobre el nodo Conexiones de datos y seleccione Agregar conexión. Elija como origen de datos Microsoft SQL Server. Se visualizará la ventana siguiente:

Escriba el nombre de la base de datos y haga clic en Aceptar. Se visualizará el mensaje La base de datos ‘bd_telefonos’ no existe. ¿Desea intentar crearla?:

Haga clic en Sí. Observará en el explorador de bases de datos que bd_telefonos ha sido creada.


1057

El paso siguiente es añadir las tablas. Despliegue el árbol correspondiente a la nueva conexión, haga clic con el botón secundario del ratón sobre el nodo Tablas y agregue una nueva tabla. Después complete el proceso de creación de la misma.

Puede ver un ejemplo de este proceso en el apartado Ejercicios resueltos del capítulo Acceso a una base de datos.

INSTALACIÓN DE ASP.NET EN WINDOWS ASP.NET queda instalado automáticamente cuando instaló Visual Studio o, en su defecto, Visual Studio Express for Web. Ahora bien, para crear y ejecutar aplicaciones para Internet necesitará un servidor de aplicaciones, en el caso de la plataforma Windows éste es IIS (Internet Information Server). La instalación de IIS debe ser anterior a la de .NET Framework. Si no se hizo así, ASP.NET no estará habilitado en IIS y no podremos realizar aplicaciones ASP.NET. En este caso, la solución es registrar manualmente ASP.NET en IIS.

Registro manual de ASP.NET en IIS Para registrar manualmente ASP.NET en IIS, abra una ventana de consola, sitúese en la carpeta C:\WINDOWS\Microsoft.NET\Framework\vx.x.xxxxx y ejecute: aspnet_regiis.exe -i -enable

Esto habilitará IIS para la ejecución de ASP.NET, registrará las extensiones de ASP.NET (aspx, amsx, asax, etc.) y ya podremos empezar a trabajar con ASP.NET. Si echa una ojeada a todas las opciones disponibles (aspnet_regiis.exe -help) podrá observar algunas muy interesantes, como -c, que instala las secuencias de órdenes del cliente de esta versión en el subdirectorio aspnet_client de todos los directorios de sitios IIS.

1058


Si la operación anterior no solucionó el problema, pruebe a reparar la instalación actual a partir del material adicional del producto. Si esto tampoco solucionara el problema, sólo queda desinstalar el producto y volverlo a instalar.

DEPURAR CÓDIGO JAVASCRIPT En una aplicación ASP.NET que incluya código JavaScript (véase el capítulo 20) es posible utilizar el depurador de Visual Studio o de Visual Web Developer para depurar ese código. Para poder depurar código JavaScript, el primer paso es habilitar esta opción en el navegador. En el caso de Internet Explorer, seleccione Herramientas > Opciones de Internet > Opciones avanzadas y asegúrese de que no esté seleccionada la opción “Deshabilitar la depuración de scripts”:

Cumplido el requisito anterior, sólo queda poner en el código JavaScript a depurar la sentencia debugger. De esta forma, cuando inicie la depuración de la aplicación y el flujo de ejecución pase por esta sentencia, la ejecución se detendrá y podrá continuarla paso a paso. function CargarTabla(resultado, contexto) { debugger; var elementos =


1059

LoadXmlFromString(resultado).getElementsByTagName("string"); TablaResultados = document.getElementById("TablaDeResultados"); if (TablaResultados != null) { // ...

DESARROLLO Para el desarrollo de una aplicación, lo habitual es crear un modelo de clases siguiendo algún patrón, por ejemplo el patrón de arquitectura de software ModelView-ViewModel (MVVM) utilizado por WPF y Silverlight, que es un sucesor del ampliamente conocido Model-View-Controller (MVC) utilizado por ASP.NET MVC, nacido del entorno Smalltalk a finales de los años 70. En MVC la aplicación se compone de tres tipos de objetos que tienen responsabilidades distintas con el objetivo de separar la capa visual de su correspondiente programación y acceso a datos:   

El modelo. Es el responsable de los datos y de la lógica de negocio de la aplicación. La vista. Es el responsable de mostrar los datos al usuario y de permitir su manipulación desde y hacia el modelo. El controlador. Es el responsable de implementar las respuestas a los eventos o acciones de los usuarios e invocar peticiones al modelo y probablemente a la vista.

Con el modelo MVC cada tipo de objeto es responsable de una cosa, lo que simplifica el desarrollo, comprensión y la realización de pruebas del código fuente. Además, es fácil remplazar las vistas, o tener más de una actuando sobre los mismos datos. En el caso de las aplicaciones Silverlight, el .NET Framework dispone de la capacidad de usar enlaces (bindings) para transferir directamente datos desde el controlador hacia la vista, por lo que el controlador solo es responsable de imple-

1060


mentar el comportamiento de esta. En este caso, el controlador se denomina modelo de vista (view model), dando origen al patrón MVVM donde: 





El modelo. Representa los datos o información con la que se trabaja y en la mayoría de los casos la lógica de negocio asociada. Debe encontrarse completamente aislado de la interfaz de usuario. La vista. Representa la información en la interfaz de usuario y es capaz de aceptar la entrada de datos del usuario a través de controles, teclado, ratón u otros elementos en forma de controles desde la interfaz gráfica. El modelo-vista. Objeto que separa y aísla completamente a la vista del modelo, se puede pensar en este tipo de objetos como una abstracción de la vista, que además hace las funciones de intermediario, transformando los datos recibidos del modelo en datos aptos para la vista y viceversa.

Por lo tanto MVVM comparte todos los beneficios de MVC, pero con una ventaja adicional: la simplificación que resulta de usar enlaces declarativos para transferir los datos desde y hacia el modelo a la vista.

APÉNDICE B

 F.J.Ceballos/RA-MA

PÁGINAS WEB ¿Quién no ha oído hablar de Internet? La respuesta es evidente, porque donde quiera que esté oirá hablar de Internet. ¿Por qué? Porque hoy en día forma parte del mundo de los negocios y del comercio, aunque en sus inicios no fue ésta la intención. Hay muchas empresas que le proporcionan conexión las 24 horas del día por un precio asequible. Pero, ¿qué es Internet?, ¿qué servicios ofrece?

¿QUÉ ES INTERNET? Internet, es decir, inter-red, es una red de redes informáticas distribuidas por todo el mundo que intercambian información entre sí mediante la familia de protocolos TCP/IP. Puede imaginarse Internet como una gran nube con ordenadores conectados:

Cliente

Servidor Cliente

Internet surgió de un programa de investigación realizado por la Agencia de Proyectos de Investigación Avanzados de Defensa (DARPA) de los Estados Unidos sobre la conexión de redes informáticas. El resultado fue ARPANet (1969). Esta red crece y a principios de los años 80 se conecta con CSNet y MILNet, dos redes independientes, lo que se considera como el nacimiento de Internet (Inter-

1062


national Network of computers). También forman parte de esta red NSI (NASA Science Internet) y NSFNet (National Science Foundation Net). Durante muchos años Internet ha servido para que muchos departamentos de investigación de distintas universidades distribuidas por todo el mundo pudieran colaborar e intercambiar información. Sólo recientemente ha comenzado a formar parte de los negocios y de nuestra vida cotidiana. Internet ha hecho que el mundo empresarial se haya replanteado sus sistemas de comunicación internos y externos y en la mayoría de los casos los haya encauzado vía Internet. Esto ha dado lugar a dos subpoblaciones dentro de Internet: intranets y extranets.

Intranet Una intranet no es más que una red local que utiliza los mismos protocolos que Internet, independientemente de que esté o no conectada a Internet. ¿Qué ventajas tiene una intranet? Fundamentalmente dos: independencia de los proveedores habituales de soluciones y una única forma de trabajar que evita tener que aprender sistemas nuevos, lo que redunda en un ahorro de formación. Por otra parte, una intranet suele estar dotada de una velocidad bastante mayor que la habitual en Internet, lo que posibilita una comunicación muy fluida, incluso, cuando se trata de flujos de información multimedia.

Terminología Internet Desde el punto de vista físico, Internet no es una simple red, sino miles de redes informáticas que trabajan conjuntamente bajo los protocolos TCP/IP (Transmision Control Protocol/Internet Protocol - Protocolo de Control de Transmisiones/Protocolo Internet), entendiendo por protocolo un conjunto de normas que regulan la comunicación entre los distintos dispositivos de una red. Desde el punto de vista del usuario, Internet es una red pública que interconecta universidades, centros de investigación, servicios gubernamentales y empresas. El conjunto de protocolos de Internet está compuesto por muchos protocolos relacionados con la asociación formada por TCP e IP y relacionados con las diferentes capas de servicios de la red; esto es, las funciones de una red se pueden agrupar en capas de servicios de la red. Imagínese las capas como distintas estaciones por las que debe pasar un paquete de información cuando realiza la ruta de un ordenador a otro conectados a diferentes puntos dentro de Internet. Por ejemplo, el protocolo TCP/IP visto desde este punto de vista puede imaginárselo de forma resumida así:

APÉNDICE B: PÁGINAS WEB

1063

Aplicación (FTP, Telnet, Gopher, Word Wide Web) API de Windows Sockets Transporte (TCP y UDP) Red (IP) Enlace (controlador de dispositivo, tarjeta de red, protocolos de control de la línea)

Entre dos capas puede haber una interfaz de programación (API) para interpretar los mensajes o paquetes a medida que van pasando. Utilizar una interfaz de programación, como la API de Windows Sockets, libera al programador de tratar con detalles de cómo se pasan los paquetes de información entre las capas inferiores. Las capas de enlace y de red se encargan de empaquetar la información y de llevar los paquetes de un lugar a otro de la red. ¿Cómo se identifican estos lugares? La respuesta es con direcciones de Internet que permitan identificar tanto el ordenador como el usuario, ya que un mismo ordenador puede tener dados de alta diferentes usuarios. Estas direcciones son especificadas según un convenio de sistema de nombres de dominio (DNS). Un DNS tiene el formato siguiente: [subdominio].[subdominio].[...].dominio

Por ejemplo: uni.alcala.es

En este ejemplo, es es el dominio, alcala es un subdominio de es, y uni un subdominio de alcala. Algunos dominios de nivel superior son: Dominio com edu net us de es

Cobertura organizaciones comerciales instituciones educativas suministradores de servicios de red Estados Unidos Alemania España

1064


Cada nombre de dominio se corresponde con una única dirección de Internet o dirección IP. Una dirección IP es un valor de 32 bits dividida en cuatro campos de 8 bits. Por ejemplo: 130.206.82.7

Para referirse a un usuario perteneciente a un determinado dominio, la sintaxis empleada es: usuario@[subdominio].[subdominio].[...].dominio

Los programas que gestionan los nombres de dominio se denominan servidores de nombres. Cada servidor de nombres posee información completa de una determinada zona (subconjunto de un dominio) y de otros servidores de nombres responsables de otras zonas. De esta forma, cuando llega una solicitud de información sobre la zona de la que es responsable un determinado servidor, éste sencillamente proporciona la información. Sin embargo, cuando llega una solicitud de información para una zona diferente, el servidor de nombres se pone en contacto con el servidor de esa zona. Los servidores DNS constituyen la base de datos distribuida de nombres de Internet. La capa de transporte es responsable de la entrega fiable de los datos. En esta capa se emplean dos protocolos diferentes: TCP y UDP. TCP toma mensajes de usuario de longitud variable y los pasa al nivel de red, solicitando acuse de recibo; y UDP es similar, salvo en que no solicita acuse de recibo de los datos. La capa de aplicación proporciona una interfaz a la aplicación que ejecuta un usuario. Dicho de otra forma, proporciona el conjunto de órdenes que el usuario utiliza para comunicarse con otros ordenadores de la red. Existen muchos protocolos en TCP/IP. A continuación, se indican algunos bastante conocidos: 

FTP (File Transfer Protocol - Protocolo de transferencia de ficheros). Copia ficheros de una máquina a otra.



Gopher. Protocolo que permite buscar y recuperar documentos mediante un sistema de menús.



POP 3 (Post Office Protocol - Protocolo de oficina de correos). Protocolo para gestionar el correo electrónico, en base a su recepción y envío posterior, entre el usuario y su servidor de correo. Con este fin son empleados también los protocolos IMAP (Internet Message Access Protocol) y HTTP (correo web).


1065



SMTP (Simple Mail Transfer Protocol - Protocolo de transferencia de correo). Protocolo para controlar el intercambio de correo electrónico entre dos servidores de correo en Internet.



Telnet (Telecomunications NetWork Protocol - Protocolo de telecomunicaciones de red). Protocolo utilizado para establecer conexiones entre terminales remotos. Permite establecer conexiones entre máquinas con diferentes sistemas operativos.



USENet. Nombre con el que se denomina al conjunto de los grupos de discusión y noticias, establecidos en Internet. La idea de USENet es servir como tablón electrónico de anuncios.



HTTP (HyperText Transfer Protocol). Protocolo de transferencia de hipertexto utilizado por WWW (World Wide Web - La telaraña mundial). Se trata de un sistema avanzado para la búsqueda de información en Internet basado en hipertexto y multimedia. El software utilizado consiste en exploradores (browsers), también llamados navegadores, con una interfaz gráfica.

SERVICIOS EN INTERNET Los servicios más comunes son el correo electrónico, la conexión remota, transferencia de ficheros, grupos de noticias y la WWW. Programas que facilitan estos servicios hay muchos, y su manejo, además de sencillo, es similar. Por eso, independientemente de los que se utilicen en los ejemplos, usted puede emplear los suyos de forma análoga. En cualquier caso, tenga presente que sólo podrá acceder a Internet si además de un ordenador y un módem (un módem es un dispositivo que conecta un ordenador a una línea telefónica), ha contratado dicho servicio con un proveedor de Internet, o bien si su ordenador forma parte de una red que le ofrece acceso a Internet. El correo electrónico (correo-e o e-mail) es uno de los servicios más utilizados en todo el mundo. Como su nombre indica, tiene como finalidad permitir enviar y recibir mensajes. Un ejemplo de aplicación que proporciona este servicio es Microsoft Outlook Express. La orden telnet (de Windows, Unix, etc.) proporciona la capacidad de mantener sesiones como un terminal del ordenador remoto, lo que le permite ejecutar órdenes como si estuviera conectado localmente.

1066


El protocolo de transferencia de ficheros (ftp) es un método sencillo y efectivo de transferir ficheros ASCII y binarios entre ordenadores conectados a una red TCP/IP. Las órdenes ftp utilizadas con mayor frecuencia son las siguientes: Orden ftp

Significado

ascii binary bye cd close ftp get help

Establece el modo ASCII para la transferencia de ficheros. Establece el modo binario para la transferencia de ficheros. Finaliza la sesión ftp y sale. Cambia de directorio de trabajo en el ordenador remoto. Finaliza la sesión ftp. Inicia una sesión ftp. Obtiene un fichero del ordenador remoto. Proporciona las órdenes ftp disponibles o información relativa a la orden especificada. Cambia al directorio local de trabajo. Suele utilizarse para seleccionar los directorios a los que irán a parar los ficheros transferidos. Lista el contenido de un directorio remoto. Obtiene un grupo de ficheros que pueden haberse especificado utilizando algún comodín. Envía un grupo de ficheros que pueden haberse especificado utilizando algún comodín. Inicia una conexión ftp con el ordenador remoto especificado. Envía un fichero al ordenador remoto.

lcd ls mget mput open put

Una interfaz de línea de órdenes proporciona un acceso pleno a las facilidades de ftp, pero el riesgo de cometer errores es alto, ya que es fácil equivocarse al escribir la orden. Afortunadamente existen varias interfaces gráficas de usuario que eliminan la posibilidad de error a la que hacíamos mención anteriormente. Los grupos de noticias, noticias USENET, netnews o simplemente news, son foros de discusión en línea. Los artículos de noticias de USENET se clasifican en grupos de noticias por temas (ordenadores, aplicaciones, alpinismo, etc.). La World Wide Web, también conocida por WWW o simplemente Web, es uno de los logros más interesantes en Internet. La Web es un sistema hipermedia interactivo que permite conectarse a grandes cantidades de información en Internet. Un sistema hipermedia está compuesto por páginas que contienen texto cuidadosamente formateado, imágenes llenas de color, sonido, vídeo y enlaces a otras páginas distribuidas por todo el mundo. Puede acceder a esas otras páginas


1067

simplemente seleccionando uno de los enlaces. La información se recupera automáticamente sin necesidad de saber dónde está. El proyecto Web, que fue iniciado en el Centro Europeo de Investigación Nuclear (European Center for Nuclear Research), ha crecido a una velocidad impresionante. Esto se debe fundamentalmente a que soporta información de todo tipo: texto, sonido y gráficos. La forma de establecer una conexión es muy sencilla. Suponiendo que físicamente está conectado a Internet, inicie uno de los programas de los muchos que hay para navegar por este sistema de información, y automáticamente le mostrará una pantalla de información que le conducirá a muchas otras. Por ejemplo, si inicia la aplicación Microsoft Internet Explorer, se visualizará una ventana similar a la siguiente:

La ventana del explorador (también llamado navegador) tiene una barra de menús donde están todas las órdenes que puede utilizar y una barra de herramientas correspondientes a las órdenes más utilizadas para navegar por la Web. Los botones Atrás y Adelante le permiten moverse a través de las páginas que usted ya ha visitado. El botón Detener detiene una página que se está cargando actualmente, quizás porque usted ha cambiado de opinión una vez que ha visto parte de la página.

1068


El botón Actualizar vuelve a cargar la página que se esté visualizando en ese momento. A veces, esto es necesario debido a fallos en la red. El botón Inicio le permite volver a la página de inicio. Para cambiar su página de inicio, vaya a la página que desea que aparezca cuando arranque por primera vez el explorador, ejecute la orden Opciones de Internet del menú Herramientas, haga clic en la pestaña General y después en Usar actual. Cuando hace clic en el botón Búsqueda de la barra de herramientas, aparece el panel de búsqueda del navegador a la izquierda de la ventana. Este panel le proporciona acceso a diversos servicios de búsqueda que ofrecen diferentes clases de capacidades de búsqueda. Pruebe los distintos servicios de búsqueda para ver las clases de información que proporcionan. Si desea buscar información adicional rápidamente, puede escribir go, find o ? seguido de una palabra o una frase, en la barra de direcciones (espacio en el que puede escribir y mostrar la dirección de una página web). Internet Explorer iniciará inmediatamente una búsqueda mediante el servicio de búsqueda predeterminado. También puede utilizar buscadores como Google, por ejemplo. Una vez que esté en una página web, puede buscar un texto específico en dicha página. Para iniciar la búsqueda, haga clic en Buscar en esta página del menú Edición.

PÁGINAS WEB Anteriormente ha aprendido cómo acceder a la Web; si ya lo ha hecho, habrá visto muchas páginas con magníficos gráficos, listas, formularios y otros elementos muy atractivos. Pero, ¿cómo se puede crear una página web de estas características a la que otros usuarios puedan acceder? Hay muchas herramientas que le permitirán realizarlo. Para ello, antes debe conocer básicamente lo que es HTML (HyperText Markup Language - Lenguaje para hipertexto), el lenguaje utilizado para construir páginas web.

Qué es HTML HTML es un lenguaje utilizado para desarrollar páginas y documentos web. A diferencia de los lenguajes convencionales, HTML utiliza una serie de etiquetas especiales intercaladas en un documento de texto sin formato. Dichas etiquetas serán posteriormente interpretadas por los exploradores encargados de visualizar la página o el documento web con el fin de establecer el formato.


1069

Para editar una página HTML y posteriormente visualizarla, todo lo que necesita es un editor de texto sin formato y un explorador web. Para ver una página HTML no necesita una conexión a la red; cualquier explorador web debe permitirle hacerlo trabajando en local. No obstante, existen otras herramientas como FrontPage que facilitan la generación de páginas HTML. Posteriormente, las páginas deben ser colocadas en un servidor web para que otros usuarios puedan acceder a ellas.

Etiquetas básicas HTML Las etiquetas indican a los exploradores web cómo tienen que mostrar el texto y los gráficos. Normalmente se escriben entre los símbolos < y >, y suele haber una etiqueta de comienzo () y otra de fin () para enmarcar el texto que va a ser formateado por ellas. Muchas etiquetas incluyen distintos atributos que detallan la forma de mostrar el texto que aparece entre ellas. HTML no es sensible a las minúsculas y mayúsculas. Por ejemplo, la siguiente línea de código muestra cómo utilizar atributos y valores con la etiqueta font. La etiqueta de apertura incluye el atributo size (tamaño) al que se asigna el valor 10; después aparece el texto que se desea mostrar con el tamaño especificado, y a continuación la etiqueta de cierre. Usuario:

Todas las etiquetas de una página web se colocan dentro de la etiqueta html, la cual define dos secciones: head (cabecera) y body (cuerpo). La etiqueta head contiene etiquetas que afectan a la página web completa, por ejemplo title (título), y la etiqueta body contiene el resto de las etiquetas que definen el contenido de la página web. Según lo expuesto, el esqueleto de una página web puede ser el siguiente: Título del documento Cuerpo del documento: texto, imágenes, sonido y órdenes HTML

Guarde ahora estas líneas en un fichero de texto ASCII con el nombre esqueleto.html. A continuación, diríjase a la carpeta donde lo ha guardado y haga doble clic sobre el nombre del fichero. El resultado será el siguiente:

1070


Etiquetas de formato de texto Igual que en un documento Word, las páginas HTML pueden tener cabeceras. Las cabeceras son insertadas con la etiqueta hn; donde n es un valor de 1 a 6. El tamaño del texto es mayor cuanto mayor es el nivel (el nivel más alto es el 1). Los niveles no tienen por qué emplearse consecutivamente. Si desea insertar algún tipo de separador, por ejemplo, una raya horizontal, puede hacerlo con la etiqueta hr (horizontal rule - raya horizontal). Para introducir un párrafo, utilice la etiqueta p o nada. Un párrafo va precedido automáticamente por una línea en blanco. Los retornos de carro en el texto son ignorados; por lo tanto, cuando quiera introducir uno utilice la etiqueta br. El siguiente ejemplo clarifica lo expuesto hasta ahora (está localizado en el fichero Cap15\HTML\texto.html): Título del documento
Ejemplo de un documento HTML

El cuerpo del documento puede contener:

Texto, imágenes, sonido y órdenes HTML

HTML es un lenguaje utilizado para desarrollar páginas y documentos web.
A diferencia de los lenguajes convencionales, HTML utiliza una serie de etiquetas especiales intercaladas en un documento de texto sin formato.


1071

Dichas etiquetas serán posteriormente interpretadas por los exploradores encargados de visualizar la página o el documento web, con el fin de establecer el formato.

Observe la colocación de las etiquetas. A HTML no le importa que las etiquetas estén al final de la línea o en cualquier otra parte. También hay etiquetas que no requieren poner la etiqueta final; por ejemplo hr, p o br. Los exploradores web ignoran dónde terminan las líneas de texto. El texto se ajustará en todo momento al tamaño de la ventana. El resultado del código HTML anterior es el siguiente:

HTML también proporciona un número de etiquetas para dar formato a las palabras y a los caracteres. Por ejemplo, la etiqueta b indica negrita y la i itálica. La etiqueta code visualiza un texto monoespaciado. La etiqueta font permite especificar el nombre, el tamaño y el color del tipo de letra a utilizar. Por ejemplo: Tipo de fuente Arial, tamaño 2; negrita y cursiva

1072


La información también se puede organizar en listas empleando la etiqueta li. Por ejemplo, si en la página anterior introduce la siguiente modificación, obtendrá esta información en forma de lista en lugar de en línea.
Texto
Imágenes
Sonido
Órdenes HTML

La lista puede numerarse utilizando la etiqueta ol. Por ejemplo, con la siguiente línea, la lista anterior se presentaría numerada.
Texto
Imágenes
Sonido
Órdenes HTML

El resultado será (ejemplo localizado en el fichero Cap15\HTML\listas.html):

URL A los recursos de la Web se accede por medio de una dirección descriptiva conocida como URL (Uniform Resource Locator - Localizador uniforme de recursos). Todo aquello a lo que se puede acceder en la Web tiene un URL. Los URL son básicamente una extensión de la ruta que define a un fichero (path). Un URL añade, además, un prefijo que identifica el método de recuperación de la información que ha de emplearse (http, ftp, gopher, telnet, news, etc.), así como un nombre de dominio o dirección IP que indica el servidor que almacena la información. Finalmente aparece la ruta de acceso al fichero. Por ejemplo: http://msdn.microsoft.com/library/spa/default.asp


1073

Enlaces entre páginas Hemos dicho que la World Wide Web es un servicio de información basado en hipertexto. Se denomina hipertexto a la capacidad de asociar a una palabra o imagen de un documento un código oculto, de forma que cuando un usuario haga clic en esa palabra o imagen, el sistema lo transporta desde el lugar actual a otro lugar del mismo o de otro documento. Estos códigos especiales se denominan enlaces, focos, saltos o accesos directos. Para definir un enlace, se utiliza la etiqueta a (anchor o ancla). Esta etiqueta delimita el texto que se quiere utilizar para enlazar con otra página. Este texto aparecerá subrayado para el usuario. Para indicar al explorador la página que tiene que recuperar cuando el usuario haga clic en un enlace, incluya en la etiqueta de apertura a el atributo href y escriba a continuación el URL de la página que se quiere recuperar. También, en documentos largos, se puede utilizar el atributo name para asignar un nombre a un enlace y después utilizar href en otro lugar dentro de la misma página para saltar a ese enlace. Por ejemplo, el siguiente código implementa estas dos facilidades (ejemplo localizado en Cap15/HTML/enlaces.html): Título del documento


Texto
Imágenes
Sonido
Órdenes HTML

A diferencia de los lenguajes convencionales, HTML utiliza una serie de etiquetas ASCII especiales intercaladas en un documento escrito en ASCII.

1074


Para editar una página HTML y posteriormente visualizarla, todo lo que necesita es un editor de texto ASCII y un explorador web.
Haga clic aquí para ir a la página de inicio

El resultado puede verlo en la figura siguiente:

Gráficos Una forma de insertar imágenes en un documento HTML es utilizando la etiqueta img y sus atributos src, que permite especificar el nombre del fichero que contiene la imagen (habitualmente .gif o .jpeg), y align, que permite indicar cómo el explorador debe alinear la imagen con cualquier texto que esté cerca de ella (top, middle o bottom). Cuando diseñe una página web, piense que puede haber exploradores que no soportan gráficos. Para contemplar esta posibilidad, utilizaremos el atributo alt que permite especificar un texto en el lugar de la imagen cuando el explorador no pueda mostrarla. Por ejemplo: ...
El profesor Ceballos resolviendo dudas a sus alumnos.
Haga clic


1075

aquí para ir a la página de inicio

La etiqueta center centra la imagen y el título de la imagen. También desde un documento puede saltar a otro. Por ejemplo: Haga clic aquí para ir a la biografía de Ceballos.

El ejemplo anterior indica que cuando el usuario haga clic en la palabra “aquí”, se cargará un nuevo documento HTML guardado como ceballos.html. Igual que utilizamos una palabra para enlazar con otro lugar, podemos utilizar una imagen; esto es, un clic sobre una imagen gráfica le puede conducir a otro lugar. Por ejemplo:

El código anterior realizará un salto a la página enlaces.html cuando el usuario haga clic sobre la imagen ceballos.jpg. Cuando ejecute este código, observe que al pasar el ratón por encima de la imagen, el cursor se transforma en una mano y aparece una etiqueta que visualiza “Foto del profesor Ceballos”.

Marcos Las páginas HTML que hemos escrito en los apartados anteriores ocupan toda la ventana del explorador. Sin embargo, utilizando marcos es posible visualizar múltiples documentos en una misma página. Una forma de insertar un marco flotante en una página es utilizando la etiqueta iframe con los atributos src, width y height. El atributo src especifica el URL del documento que se quiere visualizar, y width y height indican la anchura y la altura del marco. Por ejemplo: El autor:
<iframe src="ceballos.html" width=650 height=300>

1076


El código anterior crea un marco para visualizar el documento ceballos.html. Al atributo src se le puede asignar también una dirección URL de cualquier página de cualquier servidor. Esto es, <iframe src="http://www.microsoft.com" width=650 height=300>

La figura siguiente muestra un marco dentro de una página. El código puede verlo en el fichero marco.html de la carpeta Cap15\HTML del material adicional.

Formularios Los formularios permiten crear interfaces gráficas de usuario en el seno de una página web. Los componentes de estas interfaces, denominados también controles, serán cajas de texto, cajas para clave de acceso, botones de pulsación, botones de opción, casillas de verificación, menús, tablas, listas desplegables, etc. Para crear un formulario, se utiliza la etiqueta form. Por ejemplo, el segmento de código siguiente muestra cómo es el esqueleto de un formulario HTML:
Controles que forman el formulario


1077

El atributo method es opcional y su valor por omisión es get indicando así al navegador que debe agregar los nombres de los campos del formulario y sus datos al URL especificado por action (acción a tomar cuando se pulse el botón enviar). La cantidad de datos que se puede concatenar al URL está limitada, truncándose la información en exceso. Esto no ocurre si el valor para este atributo es post; en este caso, se transmite un fichero con los datos del formulario que será recibido en el servidor en la entrada estándar del componente de procesamiento. Los controles que forman parte del formulario se definen dentro de la etiqueta form. En los siguientes apartados se indica cómo crear cada uno de estos controles. En general, por cada control se envía al servidor su nombre y su contenido o valor especificado (si no se especifica un valor, se envía uno por omisión).

Entrada básica de datos Existe una amplia variedad de controles de entrada de datos. Para crearlos, se utiliza la etiqueta input y los atributos type y name:

El valor del atributo type especifica el tipo de control que se creará, y el del atributo name el nombre de la variable que almacenará el dato. Caja de texto Una caja de texto es un control de entrada de tipo text. Se utiliza para solicitar a un usuario que introduzca un dato. Por ejemplo, la siguiente línea de código muestra una caja de texto para solicitar un nombre. El tamaño de la caja es 35 y el valor será almacenado en la variable nombre: Nombre:

El valor del atributo size especifica el tamaño de la caja. Otros atributos que se pueden utilizar son value para especificar un valor inicial, readonly (que no lleva asociado ningún valor) para indicar que la caja es de sólo lectura y maxlength para especificar el número máximo de caracteres que un usuario puede escribir.

1078


Caja de clave de acceso Una caja de clave de acceso es un control de entrada de tipo password. Se trata de una caja de texto en la que los caracteres escritos son reemplazados por asteriscos. Por ejemplo, la siguiente línea de código muestra una caja de texto para solicitar una clave de acceso. El tamaño de caja es 25, el valor será almacenado en la variable clave y el número máximo de caracteres que admite es 20: Clave de acceso:

Casilla de verificación Una casilla de verificación es un control de entrada de tipo checkbox. Se trata de un botón que puede presentar dos estados: seleccionado y no seleccionado. Se utilizan para mostrar y registrar opciones que un usuario puede elegir; puede seleccionar varias de un grupo de ellas. Por ejemplo, las siguientes líneas de código muestran tres casillas de verificación. La primera se mostrará seleccionada: Opción 1
Opción 2
Opción 3

Se debe especificar el atributo name (como caso especial, se puede especificar el mismo nombre para todas). El atributo checked permite iniciar el estado de una casilla a seleccionado. Dicho estado, on u off, es almacenado por el atributo name. Cuando se envíen los datos del formulario, se enviarán el nombre de la variable y el valor que indique su estado. También será enviado el valor indicado por value o nulo si no se especificó. Botón de opción Un botón de opción es un control de entrada de tipo radio. Igual que ocurre con la casilla de verificación, puede presentar dos estados: seleccionado y no seleccionado. Se utilizan para mostrar y registrar una opción que un usuario puede elegir entre varias; cuando selecciona una, la que estaba seleccionada dejará de estarlo. Por ejemplo, las siguientes líneas de código muestran tres botones de opción. El segundo se mostrará seleccionado: Opción 1
Opción 2
Opción 3

Para el comportamiento descrito, todos los botones de opción tendrán el mismo atributo name y con un valor distinto del atributo value. El valor enviado será


1079

el correspondiente al botón seleccionado. El atributo checked permitirá seleccionar por omisión uno de los botones de un grupo. Parámetros ocultos Un parámetro oculto es un control de entrada de tipo hidden. En este caso no se muestra ningún campo de entrada de datos al usuario, pero el par variable valor especificado es enviado junto con el formulario.

Se suelen utilizar para mantener datos durante una sesión. Enviar datos Un botón enviar es un control de entrada de tipo submit. Se utiliza para enviar los datos del formulario, pasando el control al programa indicado por el atributo action del formulario. Todo formulario debe tener un botón submit, a menos que incluya una caja de texto.

El atributo value especifica una etiqueta no editable que se mostrará como título del botón. Lo normal es que este control no envíe datos, pero si se incluye el atributo name con un nombre de variable, será enviada la variable con el valor de value. Esto puede ser útil para distinguir cuál fue el botón pulsado cuando se incluyan varios.

Borrar los datos de un formulario Un botón borrar es un control de entrada de tipo reset. Se utiliza para restablecer los valores iniciales de los controles del formulario.

Imágenes Una imagen es un control de entrada de tipo image. Su finalidad es análoga al botón submit, pero en este caso se presenta una imagen en lugar de un botón. Los datos del formulario se enviarán al hacer clic sobre la imagen .jpg o .gif.

1080


Orden de tabulación Para trasladarse de un control a otro del formulario, el usuario puede utilizar la tecla tab. En este caso, el orden en el que los controles serán recorridos queda determinado por su orden de aparición en el formulario, o bien por el atributo tabindex. Por ejemplo:

El valor de tabindex es un número (1, 2, 3...) que corresponde al orden en el que se seleccionará un control cuando el usuario pulse la tecla tab. El control que se seleccionará en primer lugar es el 1.

Caja de texto multilínea En ocasiones es necesario permitir al usuario escribir varias líneas de texto libre; por ejemplo, un mensaje. Para esto se utiliza un control denominado área de texto (textarea) que incluye una barra de desplazamiento vertical: Mensaje:

El valor del atributo rows especifica el número de filas que visualizará el área de texto a la vez y cols el número de caracteres por fila. El atributo wrap, que no lleva asociado ningún valor, indica que se saltará automáticamente a la línea siguiente cuando se complete la línea en la que se escribe.

Listas desplegables Una lista desplegable permite seleccionar una opción entre varias. Es la mejor alternativa para añadir menús a una interfaz gráfica. La etiqueta que permite crear un control de este tipo es select. Las opciones de la lista se especifican utilizando la etiqueta option. Por ejemplo, el siguiente código mostrará una lista desplegable con tres opciones, de las cuales aparecerá seleccionada inicialmente la segunda:


1081

El atributo value de option indica el valor asociado con la opción especificada; si se omite este atributo, el valor que se toma es el texto especificado para la opción. La etiqueta option que contenga el atributo selected será considerada la opción por omisión; en caso de que no se especifique ninguna se considerará la primera de las opciones. Se puede también especificar el atributo size para indicar el número de opciones que la lista visualizará a la vez. Para permitir realizar selecciones múltiples utilizando las teclas Ctrl o Alt, hay que añadir el atributo multiple; en este caso se mostrará una lista desplegada. Por ejemplo:

Utilizando la etiqueta optgroup, se pueden agrupar las opciones (como si de un submenú se tratara); cada grupo será identificado con una etiqueta especificada por el atributo label. Por ejemplo:

1 2 3

4 5

Aplicando la teoría expuesta hasta ahora, vamos a diseñar un formulario, como el que muestra la figura siguiente, que permita a un alumno concertar una tutoría con su profesor.

1082


El código HTML que da lugar a este formulario puede ser el siguiente (la expresión indica un espacio en blanco). El código puede obtenerlo del fichero Cap15\HTML\tutorias.html del material adicional. Concertar una tutoría
CONCERTAR UNA TUTORÍA

Alumno:

Con el profesor:

Día:

Hora: 10 12 16 18


1083

Asunto:

Tablas Para crear una tabla, se utilizan las etiquetas table, tr, th y td. La etiqueta table define el cuerpo de la tabla; tr define una fila de la tabla; th define una celda de cabecera y td define una celda de datos. Por ejemplo:

Nombre Nota

Javier Ceballos Fernández 10.00

Elena Ortiz Fuentes 7.50

El atributo border de table permite añadir un borde a la tabla de ancho igual al valor especificado en píxeles. Los atributos width y align de td (o de th) permiten definir, respectivamente, el ancho de la celda y el tipo de ajuste del dato en la celda. Otras operaciones que se pueden hacer a la hora de diseñar una tabla son: 

Extender una celda en múltiples columnas: cabecera 1



Extender una celda en múltiples filas: cabecera 1



Modificar el ancho y el alto de la tabla en valor absoluto o respecto al tamaño de la ventana del navegador:

1084 


Modificar el tamaño de una celda:



Alinear el contenido de una celda:



Modificar el color de fondo de una celda:



Modificar el espacio y el margen de las celdas:



Controlar los saltos de línea en una celda:

HOJAS DE ESTILO Es evidente que el lenguaje HTML está limitado a la hora de organizar la presentación de los elementos de una página web. Pues bien, para cubrir esta deficiencia surgen las hojas de estilo (Cascade Style Sheets - CSS). Éstas no sólo permiten organizar la presentación de una página, sino que además, intentan separar el contenido de la forma de presentarlo. Por ejemplo, para introducir un nuevo párrafo en una página web, utilizamos la etiqueta
. Pues bien, con las hojas de estilo también podremos indicar que su texto sea azul, que tenga un margen izquierdo de 20 píxeles y que tenga un borde de ancho 2. Esto se codificaría de la forma siguiente:

En este ejemplo se puede observar que la declaración de los atributos que definen un determinado elemento de la página queda limitada por la etiqueta style. Esta etiqueta sólo puede utilizarse en la cabecera de la página, o bien dentro de la etiqueta de cabecera del elemento, y su parámetro type indica la sintaxis utilizada para definir esos atributos. En el caso de las hojas de estilo en cascada, el tipo deberá ser “text/css”. También observamos que los atributos se especifican a continuación del elemento HTML que se quiere personalizar, encerrados entre llaves. En el ejemplo, son cuatro: el color (en el formato habitual), el margen izquierdo en píxeles y el tipo y el ancho del borde. Tenga presente que CSS es sensible a las mayúsculas y minúsculas. Puede ver un resumen de los atributos CSS en la carpeta docs del material adicional que acompaña al libro.


1085

El siguiente ejemplo muestra una página HTML con estilo: Título del documento




Cuando se muestre la página anterior, los dos párrafos,
, serán visualizados con los atributos definidos. Ahora bien, en este ejemplo, el contenido no está separado de la forma de presentarlo. Para separarlo, podemos colocar la hoja de estilo en un fichero (sólo los estilos, sin style), por ejemplo, en estilo.css: /* estilo.css */ p {color: blue; margin-left: 20; border: solid; border-width: 2}

Una vez definida una hoja de estilos, podemos incorporarla a una página HTML utilizando la etiqueta link que tiene la siguiente sintaxis:

Según lo explicado, el ejemplo anterior quedaría como se indica a continuación. Observe que la etiqueta link está incluida dentro de la cabecera:

1086


Título del documento ...

Clases Cuando se muestre la página anterior, todos sus párrafos,
, serán visualizados con los atributos definidos. Pero supongamos que sólo queremos personalizar algunos de ellos. ¿Cómo lo hacemos? Pues, definiendo distintas clases, en nuestro caso, distintas clases de párrafos, para lo cual utilizaremos el atributo class. Por ejemplo, la siguiente hoja de estilos permite personalizar un párrafo de dos formas, las cuales difieren en el color: azul con borde y ajustado a la izquierda, o bien verde sin borde y centrado: /* estilo.css */ p.azul {color: blue; margin-left: 20; border: solid; border-width: 2} p.verde {color: green; margin-left: 20; text-align: center}

Este código define dos clases de párrafos: el párrafo azul (p.azul) y el verde (p.verde). Cuando apliquemos estos estilos a una página, los párrafos definidos con la cabecera
serán azules y los definidos como
serán verdes. Por ejemplo: Título del documento





1087


Otro caso puede ser que queramos que la mayoría de todos los párrafos sean azules y unos pocos verdes, pero con el resto de las características iguales. En este caso, también podríamos definir dos clases distintas, pero hay una forma mejor: usar el parámetro id. Por ejemplo: /* estilo.css */ p {color: blue; margin-left: 20; border: solid; border-width: 2} #verde {color: green}

Cuando apliquemos estos estilos a una página, los párrafos definidos con la cabecera
serán azules y los definidos como
serán verdes. Los exploradores agregan también varias clases, conocidas como pseudoclases, que definen varios usos para un mismo elemento. Por ejemplo, podemos aplicar estilo a los enlaces para que muestren colores diferentes en función de que aún no hayan sido visitados o sí lo hayan sido. Para ello, CSS define las pseudoclases:   

Enlaces normales: Enlaces visitados: Enlaces activos:

a:link {atributos} a:visited {atributos} a:active {atributos}

Por ejemplo, el siguiente código utiliza las pseudoclases link y visited con el elemento para definir el color azul para el enlace normal y el color magenta para el enlace visitado. Observe la sintaxis; al contrario que con las clases reales, ahora se utilizan dos puntos (:). a:link {color: blue} a:visited {color: magenta}

Etiquetas y
Puede que, a veces, no queramos modificar el comportamiento de un elemento, sino aplicar un estilo completo a una determinada sección de una página. Esto podremos hacerlo utilizando las etiquetas y
.

1088


Para definir estilos en secciones reducidas de una página se utiliza la etiqueta span. Admite los atributos style, id y class. Lo vemos con un ejemplo. El siguiente párrafo visualizará determinadas palabras en color azul y en cursiva:

La etiqueta div es similar a span, con la diferencia de que div define un elemento a nivel de bloque; esto es, una sección de una página que, a su vez, puede contener cabeceras, párrafos, tablas, e incluso otras divisiones, lo que hace a esta etiqueta ideal para definir distintas secciones en un documento (capítulo, resumen, notas, etc.). Por ejemplo:

Divisiones

El elemento div permite utilizar los atributos align, class, style, id y otros muchos.

Definir un bloque, es útil para construir diferentes secciones en un documento.

Es necesario especificar la etiqueta de cierre

La etiqueta div es ideal también para definir capas, entendiendo por capa una sección de un documento para la que se ha definido un comportamiento independiente. Algunos atributos típicos utilizables con capas son: position, posición absoluta en la página, left y top, distancia desde los bordes izquierdo y superior de la página, width y height, anchura y altura de la capa, z-index, para indicar qué capas se ven encima de qué otras, clip, para recortar una capa y hacer que no sean visibles partes de ella, o visibility, para indicar si la capa se puede ver en la página o permanece oculta al usuario. A continuación mostramos un ejemplo sencillo: poner un título con el efecto de sombra. Este ejemplo se ha construido en base a dos bloques con el mismo contenido: uno para visualizar el título en color azul y otro para visualizar la sombra en color negro (se trata del mismo título, pero desplazado un píxel respecto del anterior).


1089

El fichero de estilos que vamos a utilizar incluye dos clases, título y sombra. Obsérvese que delante del nombre de la clase ponemos solamente un punto, ya que en este caso no se trata de una clase definida para un determinado elemento: /* estilos.css */ .titulo {color: blue; position:absolute; margin-left: 20; margin-top: 20; font-size: 32; font-weight: bolder} .sombra {color: black; position:absolute; margin-left: 21; margin-top: 21; font-size: 32; font-weight: bolder}

Y una página ejemplo que utilice este fichero de estilos puede ser la siguiente: Capas
TÍTULO DE LA PÁGINA

TÍTULO DE LA PÁGINA

XML XML (Extensible Markup Language - lenguaje extensible para análisis de documentos) está convirtiéndose rápidamente en el estándar para el intercambio de datos en la Web. Como en el caso de HTML, los datos se identifican utilizando etiquetas, y a diferencia de HTML las etiquetas indican lo que los datos significan en lugar de cómo visualizar los datos. Por ejemplo, la fecha de nacimiento de una persona se puede colocar en un párrafo HTML así:
01/01/2004

Sin embargo, la etiqueta de párrafo no describe que el dato es la fecha de nacimiento. Simplemente indica al navegador que el texto que aparece entre las etiquetas se debe mostrar en un párrafo. En cambio, el dato sí queda descrito en una línea como la siguiente: 01/01/2004

1090


El lenguaje XML es un lenguaje que se utiliza para crear otros lenguajes que definen los componentes de un documento. Por ejemplo, podríamos utilizar XML para describir una persona: fecha de nacimiento, sexo, color, altura, peso, etc. La creación de un documento XML tiene dos partes: crear un esquema XML y crear el documento utilizando los elementos definidos en el esquema. El esquema se puede considerar como un diccionario que define las etiquetas que se utilizan para describir los elementos de un documento. Estas etiquetas son similares a las etiquetas HTML, pero con la diferencia de que quien crea el esquema crea los nombres y los atributos de las etiquetas. Por ejemplo: Profesor Ceballos

La realidad es que un navegador no puede leer y mostrar un documento XML. Pero sí puede convertir un documento XML en un documento HTML mediante una hoja de estilos XSTL (Extensible Stylesheet Language Transformation). Una hoja de estilos se compone de una o más definiciones de plantillas que procesa un procesador XSLT cuando la etiqueta de la plantilla corresponde a un componente del documento XML.

XHTML XHTML (Extensible HyperText Markup Language - lenguaje mejorado para la escritura de páginas web) es la siguiente generación de HTML que incorpora muchas de las características de XML. Utiliza prácticamente todos los elementos de HTML, pero impone nuevas reglas; por ejemplo, es sensible a mayúsculas y minúsculas, toda etiqueta de apertura tiene que tener una etiqueta de cierre, etc.

PÁGINAS WEB DINÁMICAS El lenguaje HTML que hemos visto en los apartados anteriores es suficiente para visualizar documentos, imágenes, sonidos y otros elementos multimedia; pero el resultado es siempre una página estática. Entonces, ¿qué podemos hacer para construir una página dinámica?, entendiendo por página dinámica una página que actualiza su contenido mientras se visualiza. Haciendo un poco de historia, una de las primeras formas que se encontraron para dar dinamismo a las páginas HTML fue la CGI (Common Gateway Interface). Esta interfaz permite escribir pequeños programas que se ejecutan en el servidor para aportar un contenido dinámico. El resultado es un código HTML, que se


1091

incluye en la página web justo antes de ser enviada al cliente. Pese a que la CGI es fácil de utilizar, en general, no es un buen sistema porque cada vez que un cliente solicita una página con algún programa basado en esa interfaz, el programa tiene que ser cargado en memoria para ser ejecutado, lo que ocasiona un tiempo de espera elevado. Además, si el número de usuarios es elevado, los requerimientos de memoria también serán elevados, ya que todos los procesos se deben poder cargar en memoria y ejecutar. Una alternativa a la CGI fue ISAPI (Internet Server Application Programming Interface). Esta API proporciona la funcionalidad necesaria para construir una aplicación servidora de Internet. A diferencia de CGI que trabaja sobre ejecutables, ISAPI trabaja sobre DLL. Esta diferencia hace que ISAPI sea un sistema más rápido, ya que por tratarse de una biblioteca dinámica sólo será cargada una vez y podrá ser compartida por múltiples procesos, lo que supone pocos requerimientos de memoria. Posteriormente, las técnicas anteriores fueron sustituidas por la incorporación de secuencias de órdenes (scripts) ejecutadas directamente en el interior de la página HTML. Esto es, en lugar de consultar al servidor acerca de un ejecutable, el explorador puede ahora procesar las secuencias de órdenes a medida que carga la página HTML. El tratamiento de estas secuencias de órdenes puede hacerse tanto en el servidor web como en el cliente. Los lenguajes más comunes para la escritura de secuencias de órdenes son JavaScript y VBScript. Apoyándose en la técnica anterior y en un intento de potenciar la inclusión de contenido dinámico en páginas web, Microsoft lanza una nueva tecnología, las páginas ASP (Active Server Page - Página activa del servidor o activada en el servidor). Una página ASP, dicho de una forma sencilla, es un fichero .asp que puede contener: texto, código HTML, secuencias de órdenes y componentes ActiveX. Con tal combinación se pueden conseguir de una forma muy sencilla páginas dinámicas y aplicaciones para la Web muy potentes. Un inconveniente de esta tecnología es que su propietaria es Microsoft y solamente está disponible para el servidor IIS (Internet Information Server) que se ejecuta sobre plataformas Windows. También es cierto que hay herramientas que permiten utilizar ASP sobre un servidor Apache en plataformas Unix, pero, hoy por hoy, los componentes ActiveX no están disponibles para plataformas que no sean Microsoft Windows. Cuando un cliente solicita una ASP, el servidor la intenta localizar dentro del directorio solicitado, igual que sucede con las páginas HTML. Si la encuentra, ejecutará las rutinas VBScript o JScript que contenga. Cuando el servidor ejecuta estas rutinas, genera un resultado consistente en código HTML estándar que sustituirá a las rutinas VBScript o JScript correspondientes de la página ASP. Una vez procesada la página, el servidor envía al cliente el contenido de la misma en HTML estándar, siendo así accesible desde cualquier navegador.

1092


También, cuando Sun Microsystems presentó Java, uno de los aspectos que más llamó la atención fueron los applets: pequeños programas interactivos que son ejecutados por un navegador. Esto supuso una alternativa más para crear páginas web dinámicas, ya que esta tecnología permite vincular código estándar Java con las páginas HTML que luego utilizaremos como interfaz de usuario, dotándolas de contenido dinámico e interactivo. Posteriormente, Sun Microsystems introdujo los servlets. Mientras que los applets incorporaron funcionalidad interactiva a los navegadores, los servlets la incorporaron a los servidores. Los servlets es la alternativa de Sun Microsystems para sustituir a la programación CGI. Si comparamos la tecnología ASP o los servlets con la CGI o con la ISAPI, llegaremos a la conclusión de que es bastante más sencilla y más potente. Actualmente, la tecnología ASP ha sido sustituida por ASP.NET, que es parte integrante de Microsoft .NET Framework. ASP.NET es algo más que una nueva versión de ASP; es una plataforma de programación web unificada que proporciona todo lo necesario para que podamos crear aplicaciones web. Al crear una aplicación web, podemos elegir entre formularios web y servicios web XML, o bien combinarlas. Todo esto lo estudiaremos en los próximos capítulos. Los formularios web permiten crear páginas web basadas en formularios. Por lo tanto, este tipo de aplicaciones son una alternativa más para crear páginas web dinámicas. Los servicios web XML proporcionan acceso al servidor de manera remota, permitiendo el intercambio de datos en escenarios cliente-servidor utilizando estándares como HTTP y XML. Las aplicaciones web se ejecutan en un servidor web configurado con los servicios de Internet Information Server (IIS). Sin embargo, para probar una aplicación web, no es necesario trabajar directamente con IIS, sino que se puede hacer a través del servidor web integrado en Visual Studio. No obstante, si para probar sus aplicaciones prefiere utilizar IIS, asegúrese de que lo tiene instalado. Para ello, abra el panel de control, seleccione “agregar o quitar programas”, haga clic en “agregar o quitar componentes Windows” y si no tiene instalado el componente Servicios de Internet Information Server, instálelo. IIS debe instalarse antes de Microsoft .NET Framework SDK.

APÉNDICE C


INTERNACIONALIZACIÓN Si pensamos distribuir nuestra aplicación a un público internacional, deberemos tener en cuenta una serie de puntos durante las fases de diseño y desarrollo. Los servicios integrados en .NET Framework facilitan el desarrollo de aplicaciones que se adaptan a distintas configuraciones de idioma. Preparar una aplicación para su uso mundial tiene dos partes: diseñar la aplicación para que pueda adaptarse a distintas referencias culturales (globalización) y traducir los recursos para una referencia cultural específica (localización).

GLOBALIZACIÓN La globalización es el proceso de diseño y desarrollo de una aplicación que permite el uso de interfaces de usuario en distintos idiomas. El espacio de nombres System.Globalization contiene clases que definen información relativa a la referencia cultural, incluido el idioma, el país o región, los calendarios utilizados, los modelos de formato de fecha, moneda y números, y el criterio de ordenación de las cadenas. Concretamente, la clase CultureInfo representa una referencia cultural específica.

LOCALIZACIÓN Los recursos de la aplicación que requieren una localización tienen que ser independientes del resto del código de la aplicación. Para ello, el código ejecutable se ubicará en el ensamblado principal de la aplicación, mientras que en los ficheros de recursos sólo se ubicarán los recursos: cadenas, mensajes de error, cuadros de

1094


diálogo, menús o recursos de objetos incrustados, entre otros. Finalmente, se traduce la interfaz de usuario a los idiomas de destino. .NET Framework SDK proporciona la herramienta winres.exe (editor de recursos de formularios Windows), que permite localizar rápidamente formularios Windows para las referencias culturales de destino.

CLASE CultureInfo La clase CultureInfo especifica un nombre único para cada referencia cultural como una combinación de un código de referencia cultural (dos letras en minúsculas asociado con un idioma), y un código de referencia cultural secundaria (dos letras en mayúsculas asociado con un país o región) separados por un guión (-). Por ejemplo, “en-US” para el inglés de EEUU y “es-ES” para el español de España. Por ejemplo, el siguiente código muestra todas las referencias culturales por medio del método GetCultures de CultureInfo: Imports System Imports System.Globalization Public Class CInfoCultura Public Shared Sub Main() Dim info As CultureInfo For Each info In CultureInfo.GetCultures(CultureTypes.AllCultures) ' Mostrar todas las referencias culturales Console.WriteLine("{0,-12} {1}", info, info.DisplayName) Next info End Sub End Class

Siguiendo con el ejemplo anterior, vamos a añadir a la clase CInfoCultura un método Cultura que muestre información de una cultura específica. Public Shared Sub Cultura(ByVal sInfo As String) Dim info As CultureInfo = New CultureInfo(sInfo) Console.WriteLine("{0,-12} {1}", info, info.DisplayName) Console.WriteLine("Formato de fecha: {0}", _ DateTime.Now.ToString(info.DateTimeFormat.ShortDatePattern)) Console.WriteLine("Separador de decimales: {0}", _ info.NumberFormat.CurrencyDecimalSeparator) Console.WriteLine() End Sub

Para invocar al método anterior, añada al método Main sentencias análogas a las siguientes:

APÉNDICE C: INTERNACIONALIZACIÓN

1095

Cultura("en-US") Cultura("es-ES")

Propiedad CurrentUICulture La propiedad CurrentUICulture de CultureInfo devuelve la referencia cultural de la interfaz de usuario actual. Por ejemplo: Public Shared Sub CulturaActual() Dim info As CultureInfo = Nothing info = CultureInfo.CurrentUICulture Console.Write("Cultura actual: ") Console.WriteLine("{0, -12} {1}", info, info.DisplayName) End Sub

También puede utilizar la propiedad CurrentUICulture de Thread.CurrentThread. Por ejemplo: info = System.Threading.Thread.CurrentThread.CurrentUICulture

La clase ResourceManager utiliza esta propiedad para buscar recursos específicos de la referencia cultural durante la ejecución. Para configurar la propiedad CurrentUICulture, se puede utilizar una referencia cultural neutra (por ejemplo, “en”) o específica (por ejemplo, “en-US”), o la propiedad InvariantCulture. Por ejemplo, la siguiente línea establece la referencia cultural neutra “en” (inglés). Las referencias culturales neutras se asocian a idiomas pero no a regiones. Thread.CurrentThread.CurrentUICulture = New CultureInfo("en")

Y esta otra línea establece la referencia cultural específica “en-US” (inglés de Estados Unidos): Thread.CurrentThread.CurrentUICulture = New CultureInfo("en-US")

Propiedad CurrentCulture La propiedad CurrentCulture de CultureInfo no es una configuración de idioma, sino que determina los formatos predeterminados para la fecha, hora, moneda y números, el criterio de ordenación de texto, las comparaciones de cadenas y la distinción entre mayúsculas y minúsculas. Sólo se puede establecer para una refe-

1096


rencia cultural específica o para InvariantCulture. Para establecer el valor de esta propiedad puede utilizar la propiedad Thread.CurrentThread. Por ejemplo: Thread.CurrentThread.CurrentCulture = New CultureInfo("en-US")

Propiedad InvariantCulture La propiedad InvariantCulture de CultureInfo no es una referencia cultural neutra ni específica. Es un tercer tipo que no tiene en cuenta la referencia cultural. Se encuentra asociada al idioma inglés pero a ningún país o región. Se puede utilizar InvariantCulture en cualquier método que requiera una referencia cultural. No obstante, deberá utilizarla únicamente para los procesos que requieran resultados independientes de la referencia cultural.

APLICACIÓN EJEMPLO Vamos a realizar un ejemplo sencillo que nos enseñe a internacionalizar una aplicación. Como podremos comprobar, será el propio Visual Studio el que se encargue de adaptar cada elemento de la interfaz a cada idioma. Nuestra aplicación utilizará como idioma predeterminado el español y, además, el idioma inglés. La interfaz gráfica de la misma constará de dos formularios: el formulario principal y el formulario “Acerca de”. El formulario principal incluirá una barra de menús, con los menús “Archivo”, “Opciones” y “Ayuda”, una caja de texto, un botón y una barra de estado. El menú “Archivo” incluirá una orden “Salir”, “Opciones” contendrá un submenú “Idioma” con las órdenes “Español” e “Inglés”, y el menú “Ayuda” la orden “Acerca de...”.

Generar ficheros de recursos automáticamente Para empezar crearemos una nueva aplicación Windows. Se mostrará el formulario Form1. A continuación, asignamos a la propiedad Localizable de Form1 el valor True. De esta forma, todas las propiedades persistirán en el fichero de recursos, con la ventaja de que este fichero se puede traducir sin modificar el código. La propiedad Language asume un valor que hace referencia al lenguaje predeterminado (Default), en nuestro caso al español. Por lo tanto, en principio, no modificaremos el valor de esta propiedad.


1097

Añadimos al formulario todos los recursos enumerados anteriormente. Estos recursos se almacenarán en el fichero Form1.resx.

Para realizar el diseño en otro idioma, asignamos a la propiedad Language dicho idioma; en nuestro caso, le asignamos el valor English. El diseñador mostrará en la pestaña “Form1.vb[Diseñar – Inglés]”. A continuación, modificaremos todos los elementos que deben mostrar su contenido en inglés (menús, aceleradores, botones, etc.). Obsérvese que podemos cambiar el valor, no sólo de la propiedad Text, sino de otras muchas propiedades (ShortcutKeys, Size, Location, etc.).

Cuando finalicemos este proceso, podremos observar en el explorador de soluciones que se ha añadido un nuevo fichero de recursos, Form1.en.resx, que contiene los recursos en inglés.

1098


En este instante (propiedad Language con valor English) estamos visualizando el formulario en la versión inglés. Si cambiamos el valor de la propiedad Language a “Predeterminado - Default”, volveremos a la versión en español. Una vez finalizado el diseño del formulario principal en sus distintos idiomas, haremos lo mismo con el resto de los formularios de la aplicación; en nuestro caso, con el formulario “Acerca de”:

Los controladores para las órdenes “Salir” y “Acerca de” serán los siguientes: Private Sub ArchivoSalir_Click(ByVal sender As System.Object, _ ByVal e As System.EventArgs) Handles ArchivoSalir.Click Close() End Sub Private Sub AyudaAcercaDe_Click(ByVal sender As System.Object, _ ByVal e As System.EventArgs) Handles AyudaAcercaDe.Click Dim dlg As AcercaDe = New AcercaDe() dlg.Show() End Sub


1099

Mostrar recursos específicos Para mostrar los recursos de la aplicación bajo una referencia cultural determinada utilizaremos el siguiente código: Imports System.Globalization Imports System.Threading ' ... Thread.CurrentThread.CurrentCulture = New CultureInfo("en-US") Thread.CurrentThread.CurrentUICulture = New CultureInfo("en-US")

La asignación del objeto CultureInfo deberá hacerse antes de invocar al método InitializeComponent, ya que el gestor de recursos ResourceManager determinará qué recursos recuperar en función de la propiedad CultureInfo.CurrentUICulture del subproceso actual. La clase ResourceManager proporciona acceso a recursos específicos de la referencia cultural en tiempo de ejecución. En nuestro ejemplo, este proceso tendremos que ejecutarlo desde las órdenes “Español” e “Inglés” del menú “Opciones”: Private Sub OpcionesIdiomaEspañol_Click( _ ByVal sender As System.Object, ByVal e As System.EventArgs) _ Handles OpcionesIdiomaEspañol.Click Thread.CurrentThread.CurrentCulture = New CultureInfo("es-ES") Thread.CurrentThread.CurrentUICulture = New CultureInfo("es-ES") Me.Controls.Clear() Me.InitializeComponent() End Sub Private Sub OpcionesIdiomaInglés_Click( _ ByVal sender As System.Object, ByVal e As System.EventArgs) _ Handles OpcionesIdiomaInglés.Click Thread.CurrentThread.CurrentCulture = New CultureInfo("en-US") Thread.CurrentThread.CurrentUICulture = New CultureInfo("en-US") Me.Controls.Clear() Me.InitializeComponent() End Sub

Obsérvese que antes de invocar al método InitializeComponent eliminamos los controles actuales del formulario (colección Controls), porque si no, al crearlos de nuevo, se duplicarían.

1100


Agregar ficheros de recursos de forma manual Ficheros análogos a Form1.en.resx pueden ser también añadidos y editados manualmente. Para ello, simplemente hay que hacer clic con el botón secundario del ratón en el nombre del proyecto y seleccionar Agregar nuevo elemento del menú contextual. Seleccionar en el diálogo que se visualiza la plantilla Archivo de recursos y escribir un nombre para el fichero .resx. Finalizar haciendo clic en el botón Aceptar. El nombre del fichero tendrá la sintaxis siguiente: RaízDelNombre.idioma-region.resx

El fichero se agregará al proyecto en el Explorador de soluciones y se abrirá automáticamente el diseñador que le permitirá editar el fichero. Se obtendrá acceso a estos recursos cada vez que la aplicación no pueda encontrar recursos más adecuados para la referencia cultural de la interfaz de usuario. En cualquier instante durante el diseño, podemos abrir y editar un fichero .resx haciendo clic con el botón secundario del ratón en el nombre del mismo y seleccionando Ver diseñador en el menú contextual. Como ejemplo, vamos a añadir los ficheros .resx con los recursos especificados a continuación: Nombre del fichero .resx

Nombre del recurso

Valor

Form1.es-ES.resx Form1.en-US.resx

cad01 cad01

Hola Hello

La cadena de caracteres nombrada cad01 será mostrada en la caja de texto de Form1 cuando el usuario haga clic en el botón Aceptar. El fichero Form1.es-ES.resx contendrá recursos que son específicos del español hablado en España, y el fichero Form1.en-US.resx contendrá recursos que son específicos del inglés hablado en EEUU. Para acceder a estos recursos, añada a Form1 el controlador del evento Click del botón y edítelo como se indica a continuación: Imports System.Resources ' ... Private Sub btAceptar_Click(ByVal sender As System.Object, _ ByVal e As System.EventArgs) Handles btAceptar.Click Dim rm As Resources.ResourceManager = _ New Resources.ResourceManager("InfoCulturaWin.Form1", _ GetType(Form1).Assembly)


1101

Me.TextBox1.Text = rm.GetString("cad01") End Sub

El constructor de ResourceManager toma dos argumentos: raíz del nombre de los recursos, es decir, el nombre del fichero de recursos sin la referencia cultural ni la extensión .resx, y el ensamblado principal. Obsérvese que para el nombre del fichero se ha especificado el espacio de nombres. Para acceder al recurso String cad01 especificado en la referencia cultural actual, se invoca al método GetString de ResourceManager. De forma predeterminada, el objeto ResourceManager distingue entre mayúsculas y minúsculas. Si no se desea hacer esta distinción, hay que asignar true a la propiedad IgnoreCase de ResourceManager. Si ahora compila y ejecuta la aplicación y hace clic en el botón Aceptar de Form1, observará que la caja de texto mostrará el recurso cad01 correspondiente al idioma elegido. ¿Por qué no hemos añadido estos recursos a los ficheros .resx generados automáticamente cuando diseñamos la aplicación? Porque al ser administrados por el diseñador de formularios, los recursos que introduzcamos serán eliminados la próxima vez que el diseñador modifique esos ficheros. Como alternativa, podríamos añadir estos recursos al fichero Resources.resx del proyecto, pero entonces tendríamos que especificarlos de forma análoga a como se indica a continuación: Nombre del fichero .resx

Nombre del recurso

Valor

Resources.resx Resources.resx

cad01_es cad01_en

Hola Hello

Ahora, para acceder a estos recursos, tendríamos que escribir el controlador del evento Click así: Imports System.Resources ' ...

1102


Private Sub btAceptar_Click(ByVal sender As System.Object, _ ByVal e As System.EventArgs) Handles btAceptar.Click Dim rm As Resources.ResourceManager = _ New Resources.ResourceManager("InfoCulturaWin.Resources", _ GetType(Form1).Assembly) If (CultureInfo.CurrentUICulture.Name = "es-ES") Then Me.TextBox1.Text = rm.GetString("cad01_es") Else Me.TextBox1.Text = rm.GetString("cad01_en") End If End Sub

APÉNDICE D


.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 3.x, 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 3.x se encuentra disponible para Linux, Mac OS X y Windows. 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. Si está interesado en desarrollar sobre una máquina Linux utilizando Mono, puede encontrar información precisa y ejemplos en mi libro Aplicaciones .NET multiplataforma (proyecto Mono); este libro, aunque esté escrito en C#, no es más que una extensión a esta enciclopedia para que vea cómo puede aplicar todo lo aprendido en la misma, sobre una máquina Linux con Mono.

ÍNDICE . .NET, 4, 8 .NET Framework, 5

@ @ Page, 781, 971 @ Register, 977

A a, etiqueta HTML, 1073 abort, 1004 Abort, 398 abrir documento, 354 acceder a un nodo, 260 AcceptButton, 83, 85, 178, 368 AcceptsReturn, 140 AcceptsTab, 140 acceso a datos desde un formulario web, 819 acceso a datos utilizando componentes, 560 acceso anónimo, 924 acceso anónimo, deshabilitar, 926 acceso conectado a bases de datos, 509 acceso desconectado a bases de datos, 555, 559 accesos directos, 1073 Access, 502 aceleradores, 129 Acerca de, 181, 328 acoplar control, 140

acoplar un control a su contenedor, 223 action, 1077, 1079 Activate, 63, 64 Activated, 63 ActiveForm, 63 ActiveMdiChild, 346 actualizar las filas, 680 actualizar y eliminar filas, EntityDataSource, 839 actualizar y eliminar filas, modelo de enlace, 852 adaptador, 504 Add, 55, 126, 231, 583 Add, colección, 162 Added, 499 AddHandler, 61 AddNew, 483 AddRange, 127 address, 882 administración de sitios web, 941 ADO.NET, 9, 496 AfterSelect, 263 agregar datos, 910 AJAX, 1001, 1028 Ajax Control Toolkit, 979 AJAX, envío de datos utilizando el método POST, 1011 AJAX, llamadas fuera de dominio, 1010 AJAX, llamadas que producen errores o que no retornan, 1010 align, 1074 alineación del texto, 54, 364 alisado, 302 AllowFullOpen, 221

1106


AllowMerge, 345 AllowsTransparency, 65 alt, 1074 ámbito de aplicación, 810 ámbito de sesión, 811 Anchor, 223, 367 animación, 336 añadir menú, 128 añadir texto a una caja de texto, 91 añadir un botón a la barra de h., 135 añadir un control a la barra de estado, 137 añadir un nuevo registro, 582 añadir un usuario que tenga una función, 954 añadir una nueva fila a una rejilla, 482 aplicación ASP.NET cliente de un servicio web, 992 aplicación web, 1092 aplicación web de IIS, 744 aplicación, ciclo de vida, 71 aplicación, crear, 16 aplicación, depurar, 33 aplicación, desarrollo, 82 aplicación, instanciar sólo una vez, 75 aplicaciones de consola, 1046 aplicaciones web, 774 App.config, 67 App_Browsers, 778 App_Code, 749, 778 App_Data, 778 App_GlobalResource, 778 App_LocalResources, 778 App_Themes, 778, 980 App_WebReferences, 778 Appearance, 185, 189 AppendText, 144 applets, 1092 Application, 50, 63, 71, 803 Application_Error, 841 ApplicationExit, 72 árbol, 254 árbol, acceder a un nodo, 260 árbol, añadir imágenes para los nodos, 257 árbol, añadir nodos, 256 árbol, añadir y borrar un nodo, 264 árbol, arquitectura, 255 árbol, iniciar, 258 árbol, nodos, 255 árbol, personalizar, 269 árbol, recorrer, 264 árboles de expresiones, 629

archivo de aplicación de ASP.NET, 796 área cliente, 64 área de texto, 1080 argumentos en la línea de órdenes, 75, 1051 arrastrar y soltar, 366 ArrayList, 442 asincrónico, modelo, 893 asociación, 657 ASP, 1091 ASP.NET, 725, 1092 ASP.NET AJAX, 1018 ASP.NET, acceso a los recursos, 790 ASP.NET, arquitectura, 920 ASP.NET, carpetas, 778 ASP.NET, instalación, 1057 aspnet_compiler, 797 aspnet_regiis, 1057 assembly, 11 Assembly, 70 AsyncPostBackErrorMessage, 1021 AsyncPostBackTimeout, 1021 AsyncPostBackTrigger, 1030 ataques de inyección SQL, 513 atributos de anotación de datos, 704, 710 atributos globales de una aplicación, 70 atributos proveedores de valores, 848 Attach, 683, 903 AttachDBFilename, 1052 autenticación ASP.NET, 927 autenticación básica con conexión SSL, 962 autenticación de IIS, 927 autenticación mediante formularios, 934 autenticación Windows, 926 authentication, 927 authorization, 927, 930, 956 AutoEventWireup, 751, 785 AutoPostBack, 786, 787, 1024 AutoResetEvent, 410, 414 autoridad de certificación, 962 autorización, 930 AutoValidate, 96 ayuda dinámica, 18

B BackColor, 109 BackgroundWorker, 404 barra de desplazamiento, 25, 44, 203 barra de desplazamiento, eventos, 206 barra de direcciones, 1068

ÍNDICE

barra de estado, 136 barra de herramientas, 134 barra de herramientas y de estado, 361 barra de menús, 24, 43, 124 barra de menús, crear, 126 barra de progreso, 208 Barra de título, 44 barras de desplazamiento, 323 barras de herramientas, fusionar, 351, 371 barras, añadir, 322 base de datos, 487 base de datos accedida desde un servicio web, 991 base de datos basada en servicio, 597 base de datos local, 597 base de datos SQL Server, crear, 588 base de datos, añadir las tablas, 589, 598 base de datos, crear, 597, 1052 base de datos, diagrama visual, 600, 601 base de datos, navegar, 579 bases de datos, mover, 1052 BeginEdit, 548 BeginInvoke, 400 BeginUpdate, 157, 194 biblioteca de clases, 9 Bin, 778 binary, 897 BinaryExpression, 632 Bind, 756 binding, 882 Binding, 431 BindingComplete, 438 BindingContext, 441 BindingList, 440 BindingList, propiedades, 552 BindingListView, 471, 673 BindingManagerBase, 441 BindingNavigator, 586 BindingSource, 432, 434, 440, 451, 453, 460, 463, 544, 578, 581, 612 BindItem, 756 Bitmap, 296, 322 bloquear los controles, 29 BMP, 321 body, 1069 Bold, 364 border, 1083 borrar datos, 911 borrar registros en una tabla, 491 borrar tabla de la base de datos, 491

1107

borrar un control, 27 borrar un registro, 584 botón borrar, 1079 botón de opción, 24, 188, 1078 botón de pulsación, 23, 56, 82 botón enviar, 1079 botón predeterminado, 83, 85, 178 br, 1070 Brush, 301 bucle de mensajes, 46 buscar en una lista, 194 buscar un registro, 584 Button, 53, 81, 82 ButtonBase, 81

C CA, 962 Cache, 816 caché, 812 caché con SQL Server, 816 cadena de consulta, 806 caja de clave de acceso, 1078 caja de diálogo Abrir, 217 caja de diálogo Color, 220 caja de diálogo de entrada, 174 caja de diálogo Fuente, 221 caja de diálogo Guardar, 219 caja de diálogo modal o no modal, 170 caja de diálogo modal, cerrar, 180 caja de diálogo no modal, cerrar, 236 caja de diálogo para mostrar un mensaje, 170 caja de diálogo, crear, 177 caja de diálogo, mostrar, 178 caja de diálogo, recuperar datos, 179 caja de herramientas, 22 caja de imagen, 24, 320 caja de imagen, Image, 324, 325 caja de texto, 24, 82, 1077 caja de texto multilínea, 139 caja de texto, seleccionar el contenido, 90 cajas de diálogo estándar, 216 cajas de diálogo personalizadas, 176 calculadora, 105 calendario, 25 callback, 1004 cambios en los datos, 675 cambios en los datos, notificar, 433 cambios, seguimiento, 695 campos, 487

1108


Cancel, 96 cancelar una llamada asíncrona, 1033 CancelAsync, 407 CancelButton, 178, 368 CancelEdit, 548 CancelEventArgs, 96 CancellationPending, 407 CanRedo, 360 CanUndo, 143, 154, 360 capa de acceso a datos, 537 capa de lógica de negocio, 541 capa de presentación, 533 capa de presentación, desacoplar, 547 capa de presentación, lógica, 544 capas de servicios de la red, 1062 cargar imagen, 324 carpeta virtual, 741 carpetas ASP.NET, 778 cascada, 362 cascada, operaciones en, 687 casilla de verificación, 24, 184, 1078 Category, 379 CellBeginEdit, 547 CellClick, 253 CellDoubleClick, 482 CellEnter, 467 CellFormatting, 247 Cells, 244 CellValidated, 478 CellValidating, 478 center, 1075 CenterParent, 177 centrar ventana, 283 cerrar, 44 cerrar formulario, 129 certificado de cliente, 963, 966 certificado de cliente es rechazado, 968 certificado de servidor, 961, 964 certificados, generar o solicitar, 963 CGI, 1090 ChangePassword, control, 951 ChangeTracker, 678, 696 chat, 915 CheckBox, 53, 81, 184 Checked, 153, 185, 189 CheckedChanged, 187, 192 CheckedListBox, 198 CheckOnClick, 153 CheckState, 185 CheckStateChanged, 188

ciclo de vida de una aplicación, 71 ciclo de vida de una página web, 784 clase, 57 clase Application, 50 clase Binding, 431 clase Bitmap, 296, 322 clase Button, 53 clase Cache, 816 clase CheckBox, 53, 184 clase CheckedListBox, 198 clase Clipboard, 142 clase Color, 109 clase ColorDialog, 220 clase ColorMatrix, 318 clase ComboBox, 54, 198 clase ConfigurationManager, 827 clase Control, 82 clase Convert, 192 clase ConvertEventArgs, 437 clase CultureInfo, 1094 clase Cursor, 329 clase Cursors, 329 clase DataGridView, 242 clase DataGridViewColumn, 243 clase DataGridViewRow, 243 clase DataRow, 499 clase DataTable, 499 clase DbContext, 662 clase de entidad, 661, 700 clase Debug, 129 clase EventWaitHandle, 413 clase FontDialog, 222 clase Form, 48 clase Graphics, 296 clase GroupBox, 188 clase Image, 322 clase Label, 53 clase ListBox, 54, 193 clase ListView, 269 clase Membership, 953 clase MembershipUser, 953 clase MenuStrip, 126 clase Metafile, 322 clase OpenFileDialog, 217 clase Page, 784 clase Panel, 188 clase Point, 55 clase ProgressBar, 208 clase RadioButton, 54, 188 clase Regex, 102, 438

ÍNDICE

clase ResourceManager, 132 clase ScrollBar, 54, 203 clase seriable, 229 clase Size, 50, 55 clase TextBox, 53, 141 clase TextBoxBase, 143 clase Thread, 395 clase Timer, 224 clase TimeSpam, 226 clase ToolStrip, 121 clase ToolStripButton, 135 clase ToolStripItem, 121 clase ToolStripItemCollection, 127 clase ToolStripMenuItem, 126 clase ToolStripSeparator, 128 clase TrackBar, 207 clase TreeNode, 255 clase TreeView, 254 clase Type, 263 clase UserControl, 375, 976 clase WaitHandle, 412 clase, definición parcial, 86 clases, 9 clases POCO, 701 clave de un nodo, 255 clave pública, 959 Clear, 144, 197 ClearError, 841 clearTimeout, 1011 clic en un botón, 469 clic en un botón, simular, 117, 583 clic sobre un botón, 583 Click, 46, 87 Client certificate revoked, 968 cliente servidor, 723 cliente WCF, 884 ClientScript, 1017 ClientSize, 50 ClientWins, 693 clipboard, 327 Clipboard, 142 Close, 65, 129, 180, 183, 504 CLR, 9 CLS, 6 code, 1071 Code First, 700 Code First, convenciones, 704 CodeFile, 781 código administrado, 11 código intermedio, 9

1109

código no administrado, 11 colección, 162 colección como origen de datos, 440 colección ConstraintCollection, 499 colección ControlBindingsCollection, 579 colección DataColumnCollection, 499 colección DataRelationCollection, 499 colección DataRowCollection, 499, 583 colección DataTableCollection, 499 colección de elementos, 24 colección jerárquica, 25 colección, añadir, 197 colección, borrar, 197 colección, borrar todo, 197 colección, insertar, 197 colocar el control, 29 Color, 109, 220, 299 color, establecer, 109 Color, propiedad, 221, 222 ColorDialog, 217, 220 ColorMatrix, 318 columnas, 487 ColumnCount, 254 Columns, 243 Columns de ListView, 272 COM, 12 COM+, 13 combinar menús, 345 ComboBox, 54, 81, 198 Command, 500, 503 CommandBuilder, 529 CommandField, 866 CommandName, 765 CommonDialog, 216 compilador JIT, 11 Complete, 613 Component, 80 componente, 80 componentes de acceso a datos, 531 concurrencia, 556, 689, 895 ConcurrencyCheck, 691 ConcurrencyMode, 689 conexión abierta/cerrada, 663 conexión, probar, 508 configuración de la aplicación, 67 configuración, fichero, 528, 927 configurar el almacenamiento en caché, 813 configurar IIS, 928 Configuration, 697, 927 ConfigurationManager, 528, 827

1110


confirmar, 173 conjunto de datos, 498 conjunto de datos, crear, 566, 590 Connection, 500 ConnectionStrings, 528, 827 ConstantExpression, 632 Constraint, 499 ConstraintCollection, 499 construir controles, 373 consultas parametrizadas, 838 contenedor, 24 contenedor UpdatePanel, 1028 contenedor UpdateProgress, 1032 Content, 917, 972, 1024 ContentAlignment, 54 ContentPlaceHolder, 971, 1024 ContextMenuStrip, 159, 480 contexto de objetos, 661, 662 contextos de corta duración, 675 contract, 882 contrato, 875 contrato de datos, 880 contrato de servicio, 876 Control, 80, 81, 183 control Button, 732 control Calendar, 733 control ChangePassword, 951 control CheckBox, 730 control CheckBoxList, 730 control CreateUserWizard, 947 control DataGridView, 567, 573 control DetailsView, 1026 control DropDownList, 732 control GridView, 953, 1025 control HyperLink, 733 control Label, 730 control LinkButton, 732 control ListBox, 731 control Literal, 976 control Login, 938 control LoginName, 951 control LoginStatus, 939 control LoginView, 939 control Panel, 733 control PasswordRecovery, 950 control RadioButton, 731 control RadioButtonList, 731 control RichTextBox, 352 control ScriptManagerProxy, 1028 control SqlDataSource, 1024

control Substitution, 814 control Table, 733 control TextBox, 730 control web para acceso a datos, 820 Control, atributo proveedor de valor, 848 control, borrar, 27 control, mover, 27 Control.DataBind, 752 controlador de eventos, 30, 59 controlador para un evento, 61 controladores de espera, 412 controladores de eventos, asignar, 61 ControlBox, 177 controles, 45, 1077 controles con enlaces a datos, 734 controles de rango definido, 203 controles de servidor HTML, 727 controles de servidor web, 727 controles de usuario, 728 controles de usuario web, 974 controles de validación, 727, 734, 792, 793 controles HTML, 728 controles para inicio de sesión, 938 controles Strip, 323 controles web, 729 controles, construir, 373 controles, enlazar o vincular con BD, 577 Controls, 55 ControlUpdateMode, propiedad, 431 conversión de datos, 114 conversiones en enlaces, 435 Convert, 88, 192 ConvertEventArgs, 437 ConvertEventHandler, 436 convertir un Date en un String y viceversa, 385 convertir un entero en base 10, 8 o 16, en una cadena de caracteres, 193 convertir una cadena de caracteres a un entero en base 10, 8 o 16, 192 cookies, 804 coordenadas, 313 coordenadas universales, 332 coordenadas, tipos, 317 coordinador de transacciones distribuidas, 614 Copy, 144 correo electrónico, 1065 cortar, copiar y pegar, 359 Count, 442, 581, 627 crear un adaptador, 561 crear un enlace, 433, 443

ÍNDICE

crear una aplicación, 16 crear una aplicación MDI, 344 crear una base de datos, 488, 493, 495 crear una caja de diálogo, 177 crear una conexión, 565 crear una imagen a partir de un fichero, 260 crear una tabla, 488 CREATE DATABASE, 488 CREATE TABLE, 488 CreateDatabaseIfNotExists, 708 CreateGraphics, 298 CreateUser, 953 CreateUserWizard, control, 947 credentials, 935 criptografía asimétrica, 959 criptografía simétrica, 959 CRL, 968 CRUD, 704 CSDL, 644 CSS, 973, 1001, 1023, 1084 CSS, atributos, 1084 CSS, class, 1086 CSS, div, 1088 CSS, id, 1087 CSS, link, 1085 CSS, pseudoclases, 1087 CSS, span, 1088 CSS, style, 1084 cuadro combinado, 198 cultura, 1094 CultureInfo, 1094 CurrencyManager, 441, 453 Current, 442, 584 CurrentCell, 253 CurrentCulture, 1095 CurrentItem, 465, 472 CurrentUICulture, 1095 CurrentValues, 698 Cursor, 329 cursor del ratón, cambiar, 329 Cursors, 329 curvas cardinales y de Bézier, 307 Cut, 144

D Data Mapper, 649 Data Transfer Object, 532 DataAdapter, 500, 569 DataAdapter, métodos, 556

1111

Database, 705 Database First, 652, 700 DataBind, 752, 753 DataBinder, 755 DataBindings, 432, 577 DataColumn, 499, 575 DataColumnCollection, 499 DataContract, 880 DataError, 477 DataGridView, 81, 242, 456, 460, 533, 544, 567, 573 DataGridView, arquitectura, 243 DataGridView, construir, 244 DataGridView, control de errores, 476 DataGridView, iniciar, 246 DataGridView, n.º de filas y columnas, 254 DataGridView, origen de datos, 249 DataGridView, tamaño de las celdas, 252 DataGridView, validar, 555 DataGridView, valor de la celda, 253 DataGridViewColumn, 243 DataGridViewRow, 243 DataMember, 463, 567, 751, 880 DataReader, 500, 504 DataRelationCollection, 499 DataRow, 499 DataRowCollection, 499, 583 DataRowView, 431, 584 DataSet, 431, 555, 575 DataSet, métodos, 556 DataSource, 442, 445, 460, 521, 558, 567, 751 DataSource de DataGridView, 250 DataSourceID, 751 DataSourceObject, 751 DataSourceUpdateMode, propiedad, 431 DataTable, 431, 499, 575 DataTableCollection, 499 DataTextField, 751 DataTextFormatString, 751 DataValueField, 752 DataView, 431, 471 DataViewManager, 431, 575 Date, 381, 385 DateTime, 381 DateTimeFormatInfo, 385 DateTimePicker, 212 DbCommand, 526 DbCommandBuilder, 529 DBConcurrencyException, 564 DbConnection, 526

1112


DbContext, 650, 659, 700 DbDataAdapter, 526 DbEntityEntry, 678, 683, 697, 764, 853 DbProviderFactories, 526 DbProviderFactory, 501, 526 DbQuery, 650 DbSet, 650, 659 DbSet (Of TEntity), 650 DbSet(Of ), 663 DbUpdateConcurrencyException, 689 DCOM, 13 Deactivate, 63 Debug, 129 debugger, 1058 defaultRedirect, 841 delegado, 59 delegado Func, 625 delegados, 399, 623 Delete, 584, 823 DELETE, 491 DeleteCommand, 505 Deleted, 499 DeleteMethod, 762 depuración, 129 depurar, 1049 depurar una aplicación, 33 descripción abreviada, 56, 57 Description, 379 deshacer, 144, 154, 352, 360 deslizador, 207 Detach, 896 DetailsView, 836, 851, 869, 1026 DHTML, 1002 diálogo Acerca de, 181 diálogo modal, cerrar, 180 diálogo no modal, 233 diálogo no modal, cerrar, 235, 236 diálogo, ¿está visible?, 237 diálogo, ocultar, 236 DialogResult, propiedad de un botón, 179 DialogResult, propiedad de un formulario, 179 DialogResult, valor retornado..., 172 dibujar formas, 341 dirección, 875 dirección de Internet, 1064 dirección IP, 1064 directorio virtual, 741 dirigirse a otra URL, 938 diseño de tipo maestro‐detalle, 461, 587 DisplayMember, 445, 521, 558

Dispose, 50, 180, 183, 511 dispositivos matriciales y vectoriales, 294 DNS, 1063 doble búfer, 339 Dock, 140, 223 documento XML, 1009 DoEvents, 414 DOM, 1002 dominio, 1063 DoubleBuffered, 339 DoWork, 404 DrawArc, 306 DrawBezier, 307 DrawCurve, 307 DrawEllipse, 305 DrawLine, 304 DrawPie, 306 DrawPolygon, 306 DrawRectangle, 304 DROP TABLE, 491 DropCreateDatabase..., 708 DropDown, 161 DropDownItems, 162 DropDownList, 751 DropDownOpening, evento, 152 DropDownStyle, 199 DTC, 614

E editar un recurso, 69, 130 editor de menús, 124 editor de texto MDI, 348 editor de textos, 138 ejecución asíncrona de servicios web, 890 ejecutar, 22 Elapsed, 226 Elapsed, evento, 225 elemento actual, 465, 472 elemento de un menú, marcar, 154 eliminar filas, 685 eliminar un recurso, 131 e‐mail, 1065 Email, 957 EnableAutoDragDrop, 366 Enabled, 153 EnablePageMethods, 1039 EnablePartialRendering, 1021 EndEdit, 548

ÍNDICE

EndInvoke, 400 endpoint, 882 EndUpdate, 157, 194 enfocar un componente, 89 enlace a colecciones, 442 enlace a datos, 753 enlace con otros controles, 435 enlace de datos, 423, 574 enlace de datos .NET, 430 enlaces, 875, 883, 1073 Enter, 90 entidad, 656 Entity Client, 645 Entity Framework, 643 Entity SQL, 645 EntityCollection, 664 EntityDataSource, 829 EntityDataSourceView, 843 EntityKey, 695 EntitySet, 695 entorno de desarrollo integrado, 1045 entorno de ejecución, 9 entrada de datos, 1077 Entries, 693 Entry, 678, 697, 764, 853 Enum, 111 enumeración ContentAlignment, 54 enumeración Keys, 130 error, notificar, 97 errores en una página ASP.NET, controlar, 841, 855 errores, control en DataGridView, 476 ErrorProvider, 97 ErrorText, 479 escribir datos en una tabla, 490 espacios de nombres, 32 especificación de lenguaje común, 6 eSQL, 645 esquinas redondeadas, 979 estado de aplicación, 810 estado de sesión, 810 estado de una página, 803 estado de vista, 807 estado del modelo, 767 estilo del texto, 364 estructura de una aplicación gráfica, 48 etiqueta, 23, 54, 82 etiquetas HTML, 1069 Eval, 755 EventHandler, 59, 403

evento, 46 evento ‐ método, 61 evento ApplicationExit, 72 evento CellBeginEdit, 547 evento CellFormatting, 247 evento Click, 87 evento Enter, 90 evento FormClosing, 365, 569 evento Idle, 72 evento KeyPress, 87 evento Load, 89, 568 evento MouseClick, 90 evento Paint, 294 evento PreInit, 982 evento PrintPage, 358 evento PropertyChanged, 427 evento Selecting, 838 evento SelectionChange, 363 evento Shown, 89 evento Shutdown, 73 evento Startup, 73 evento StartupNextInstance, 73 evento TextChanged, 87, 426 evento ThreadException, 72 evento ThreadExit, 72 evento UnhandledException, 73 evento UserDeletingRow, 546 evento Validated, 98 evento Validating, 96 evento, suscribir, 30 eventos, 30, 58 eventos del ratón, 334 eventos del teclado, 86 eventos KeyDown y KeyUp, 94 eventos KeyDown y KeyUp y KeyPress, 94 eventos más comunes, 59 eventos, lista, 30 eventos, responder, 86 EVENTVALIDATION, 809 EventWaitHandle, 410, 413 ExecuteNonQuery, 503 ExecuteReader, 503 EXIF, 321 Exit, 51 explorador de bases de datos, 495 expresión de consulta, 628 expresión de consulta, compilación, 635 expresiones de consulta, 632 expresiones de enlace de datos, 753 expresiones lambda, 623

1113

1114


expresiones regulares, 99, 438 Expression, 629, 632 Extension, 622, 636 extremo, 875

F factoría, 526 fecha y hora, 25 fecha y hora, formato, 381 fechas, 211 fichero de configuración, 527, 528, 827, 927 fichero de recursos, 132, 1096 fila añadir, 583 fila nueva, 583 filas, 487 FileDialog, 217 FileName, 219 FileUpload, 897 Fill, 506, 568 Filter, 219 FilterIndex, 219 filtrado, 863 filtro de nombres de fichero, 219 finalizar la ejecución, 22 Finally, 509 Find, 255, 352, 584 FindString, 157, 194 firma digital, 960 FixedDialog, 177 FlatStyle, 185, 189 flow layout, 782 FlowLayoutPanel, 213 Fluent API, 712 foco, 89, 229, 583 Focus, 89, 193, 583 FolderBrowserDialog, 217 font, 1069 Font, 54, 109, 303 FontDialog, 217, 222 For Each, 231 ForeColor, 109 form, 798, 1076 Form, 48, 81 Format, 88 Format de String, 381 Format, evento, 432, 435 FormatException, 88 formatos de fechas y horas, 381 FormBorderStyle, 66, 177

FormClosed, 64 FormClosing, 64, 365, 569 FormClosing, evento, 180 FormsAuthentication, 938 formulario Acerca De, 329 formulario activo, 63, 346 formulario cargar, 568 formulario cerrar, 569 formulario hijo, 350 formulario MDI, 348, 603 formulario modal, 63 formulario no modal, 63 formulario propietario, 182 formulario web, diseño, 735 formulario, BackgroundImage, 324 formulario, cerrar, 365 formulario, posición inicial, 63 formularios, 45, 1076 formularios hijo, 346 formularios hijo abiertos, 345, 362 formularios web, 773, 798 formularios, colección, 63 formularios, comunicación entre, 234 FormView, 765, 858 From, 626, 635 FromArgb, 109 FromFile, 324 FromImage, 312 ftp, 1064, 1066 fuente, establecer, 109 FullPath, 255 Func, 625 funciones, representar, 330 fusionar barras de herramientas, 371

G GDI+, 293 GDI+, servicios, 295 generador de código nativo, 12 generar código JavaScript, 1014 gestión de datos, 723 gestor de recursos, 1099 get, 798 GetAllUsers, 956 GetCurrent, 925 GetCustomAttributes, 70 GetDatabaseValues, 698 getElementsByTagName, 1009 GetExecutingAssembly, 70

ÍNDICE

GetObject, 68, 132 getSelectedColumn, 253 GetString, 68, 132, 1101 GetType, 263, 544 GetView, 843 GIF, 321 Global.asax, 796 globalización, 1093 Gopher, 1064 GotFocus, 229 gráficos, 293 gráficos en un documento HTML, 1074 gráficos vectoriales, 295 Graphics, 298, 341 GraphicsPath, 304, 308 grid layout, 782 GridView, 759, 864, 1025 GridView, AllowSorting, 863 GridView, SelectedValue, 866 Group, 637 Group … By, 627 GroupBox, 81, 188, 191 grupo de aplicaciones, 745, 922 grupos de noticias, 1066 guardar documento, 355 guardar una aplicación, 33 guardar una imagen, 325

H habilitar o inhabilitar los elementos de un menú, 152 Handled, 87 Handles, 46, 61 HashSet, 703, 716 HasMorePages, 359 head, 1069 height, 1075 herramientas, caja, 22 hidden, 807 Hide, 65, 236 hilos, 391 hilos accediendo a controles de los formularios, 399 hilos secundarios, detener de forma controlada, 414 hilos, cancelar, 407 hilos, estados, 398 hilos, mecanismos de sincronización, 408 hipertexto, 1073

hn, 1070 hojas de estilo, 973, 1023, 1084 hr, 1070 href, 1073 HScrollBar, 81, 204 html, 8, 1068, 1069 HTML, controles, 727, 728 HtmlInputHidden, 807 HTTP, 8, 803, 1064 HTTP 403.13, 968 HTTP get, 799 HTTP post, 800 HttpClientCertificate, 963 HttpContext, 802, 925 HttpCookie, 804 http‐equiv, 917 HTTPS, 962, 966 HttpServerUtility, 802 HyperLink, 840, 854

I IBindingList, 431, 433, 440, 447, 469 IBindingListView, 470 Icon, 29, 65 icono de la aplicación, 29 IDatabaseInitializer, 708 Identity, 707, 897, 924 IDictionary, 844 idioma, 1094 IDisposable, 511 Idle, 72 IEditableObject, 548 IEnumerable, 440, 627, 641 iframe, 1075 IgnoreCase, 1101 IIS, 742, 919 IIS 7.0, certificados, 963 IIS, instalar, 1092 IList, 431, 440 Image, 322 Image, propiedad, 133 ImageIndex, 257, 258 ImageList, 257 imagen, 325, 1079 imagen en un botón, 130 imagen, cargar, 324 imágen, FromFile, 260 imagen, guardar, 325 imágenes, 296

1115

1116


imágenes en un documento HTML, 1074 imágenes, lista de, 257 Images, 257 ImageStream, 258 ImageTransparentColor, 133 IMAP, 1064 img, 1074 imprimir documento, 357 incoherencia de accesibilidad, 231 Increment, 209 Inherits, 781 iniciadores de colecciones, 622 iniciadores de objetos, 621 iniciar una lista desplegable, 281 inicio de sesión, 936 Init, 785 InitialDirectory, 219 Initialize, 710 innerHTML, 1010 INotifyPropertyChanged, 427, 448 input, 1077 InputBox, 174 Insert, 197, 823, 843 INSERT, 490 insertar filas, 682 insertar filas, EntityDataSource, 841 insertar filas, modelo de enlace, 855 InsertCommand, 505 Inserting, 845 InsertItemTemplate, 859 InsertMethod, 766 interceptar la tecla pulsada, 91 Interface, 371 interfaces gráficas, 7, 38 interfaz, 45 interfaz de múltiples documentos, 343 interfaz fluida, 712 interfaz IEditableObject, 548 Interlocked, 410 internacionalización, 1093 Internet, 1061 Internet Explorer, 1067 Into, 639 intranet, 1062 introducir datos, 475 Invalidate, 295 InvariantCulture, 1096 Invoke, 400, 402 InvokeRequired, 401, 402 inyección de código SQL, 513

IPrincipal, 924 IQueryable, 627, 641, 680 IRC, 915 IsAlive, 398 ISAPI, 1091 IsBackground, 398, 419 IsCallback, 1016 IsClientScriptBlockRegistered, 1017 IsDispose, 236 IsDisposed, 183 IsInAsyncPostBack, 1021 IsMatch, 102, 438 IsMDIContainer, 344 IsOnline, 957 IsPostBack, 759, 785 IsStartupScriptRegistered, 1017 IsValid, 785 it, 648, 835 Italic, 364 Item, 231, 756 ItemClicked, 481 Items, propiedad, 156, 194 ItemType, 756

J JavaScript, 1001 JavaScript, depurar código, 1058 JavaScript, eventos, 1015 JavaScript, fichero .js, 1015 JavaScript, generar código, 1014 JIT, 11 Join, 398, 627, 638 JPEG, 321 jQuery, 795, 943 JSON, 1007

K Key, 231 KeyChar, 87, 92 KeyDown, 86, 94 KeyPress, 86, 92, 187 KeyPressEventArgs, 87 Keys, 94, 130 KeyUp, 86, 94 KeyValuePair, 231

ÍNDICE

L label, 1081 Label, 53, 81, 82 LabelEdit, 255, 268 Language, 782, 1096 LargeChange, 204 LastActivityDate, 957 LayoutMdi, 347, 362 LayoutMode, 29 Lazy Loading, 649 lector de datos, 504 Left, 65 Let, 640 li, 1072 Like, 584 líneas de ayuda, 29 LINQ, 619 LINQ to Entities, 644 Linux, 1103 List, 442 lista, 24, 193 lista de formularios abiertos, 362 lista de los eventos, 30 lista de tareas, 133 lista desplegable, 24, 198, 1080 lista desplegable, añadir elemento, 202 lista desplegable, borrar elemento, 202 lista desplegable, diseñar, 200 lista desplegable, estilo, 199 lista desplegable, iniciar, 201 lista, acceder a sus elementos, 196 lista, borrar elemento, 198 lista, colección de elementos, 197 lista, columnas, 193 lista, diseño, 194 lista, elemento seleccionado, 194 lista, iniciar, 196 lista, ordenar, 194 lista, selección múltiple, 196 listas desplegables en menús, 155 listas HTML, 1072 ListBox, 54, 81, 193, 445 ListBox, vincular con DataSet, 521, 558 ListChanged, 552 ListControl, 81 ListView, 269, 859 ListView, ejemplo, 273 ListViewItem, 273 Literal, 976

1117

llamada asíncrona, 400 llamada síncrona, 400 Load, 89, 568, 751, 785 LoadFile, 352 LocalDB, 1054 localhost, 800 Localizable, 1096 localización, 1093 Location, 55, 126, 222 LocationChanged, 65, 223 lock, 410 lógica de negocio, 723 Login, control, 938 LoginName, 978, 985 LoginName, control, 951 LoginStatus, 978, 985 LoginStatus, control, 939 LoginView, 977 LoginView, control, 939 logo, 367

M maestro‐detalle, 461, 587 maestro‐detalle, aplicación web, 868 mail, 1065 Main, 49, 51 MainMenuStrip, 126, 344 manifiesto, 11 ManualResetEvent, 410 mapa de bits, 320 MapPath, 802 máquina virtual, 11 marcador de posición de contenido, 971, 977, 987 marcas de tiempo, 896 marco, 24 marco con título, 281 marcos en páginas HTML, 1075 máscaras, 980 MaskedTextBox, 81, 104 MasterPage, 1023 MasterPageFile, 971 Match, 102 Matches, 103 Matrix, 315 Max, 627 MaxDropDownItems, 199 maximizar, 44 Maximum, 203

1118


MDI, 343, 366 MdiChildren, 346 MdiLayout, 347 MdiWindowListItem, 345 MemberExpression, 632 Membership, 951, 956 MembershipUser, 956 mensaje, mostrar, 129 mensajes, 13 menú, 123 menú contextual, 159, 480 Menú de control, 43 menú dinámico, 161 menú Ventana, 345, 347, 362 menú, añadir, 126 menú, controlador de eventos, 128, 147 menú, elementos, 127 menú, señalar elemento, 153 menú, separador, 128 menús, 121 menús en páginas web, 974, 996 menús, combinar, 345 menús, diseño, 124 menús, líneas de separación, 125 MenuStrip, 126, 323 Merge, 351 MergeAction, 345, 351 MergeIndex, 345, 351 MessageBox, 170 MessageBox.Show, 425 meta, 917 Metafile, 322 metarchivo, 296 method, 798, 1077 MethodCallExpression, 632 MethodInvoker, 403 método ‐ evento, 61 método Add, 55, 583 método conducido por un evento, 86 método DataBind, 753 método Delete, 584 método Dispose, 50 método Exit, 51 método Fill, 568 método Find, 584 método Focus, 583 método Insert, 843 método NewRow, 583 método PerformClick, 583 método Print, 358

método Select, 89, 584 método SetToolTip, 57 método Update, 569 métodos de página, 1038 Métodos del generador de consultas, 645 métodos extensores, 622 Microsoft .NET, 4 Microsoft Access, 502 Microsoft.ACE.OLEDB, 503 Microsoft.Jet.OLEDB, 503 MiddleCenter, 54 miembro protegido, 50 Min, 627 minimizar, 44 Minimum, 203 modal o no modal, 170 Model First, 653, 700 ModelMethodContext, 862 modelo de datos, 454, 457 modelo de enlace de ASP.NET, 757, 847 modelo de entidades, 644 ModelState, 767 Model‐View‐Controller, 1059 Model‐View‐ViewModel (MVVM), 1059 módem, 1065 modificadores de tamaño, 27 modificar datos, 675 modificar datos en una tabla, 490 modificar una base de datos, 582 Modified, 354, 365, 499 ModifierKeys, 94 Modifiers, 369 Monitor, 409, 412 Mono, 1103 MonthCalendar, 212 mosaico, 362 mostrar un mensaje, 129 MouseClick, 90 MouseDown, 334 MouseMove, 334 MouseUp, 334 mover el control, 27 MsgBox, 129 MSIL, 9 MSL, 644 MultiLine, 139 multiple, 1081 Mutex, 409 My, 327 My.Computer, 327

ÍNDICE

My.Computer.Audio, 339 My.Computer.Clipboard, 142

N name, 1073, 1077 Name, 50, 126, 398 navegar por los elementos de una lista, 466 nemónico, 85, 129 NetworkService, 746, 771 NewRow, 583 news, 1066 ngen.exe, 12 N‐Layer architecture, 895 Node, 263 Nodes, 255 nodo seleccionado, 265 nodo, añadir, 265 nodo, borrar, 268 nodos, borrar todos, 268 NT AUTHORITY\Servicio de Red, 790 N‐Tier architecture, 895 nuevo documento, 353 NuGet, 701 Nullable(Of Integer), 848

O Object, 80 ObjectCollection, 197 ObjectContext, 653 ObjectDataSource, 904, 905 ObjectQuery, 645 ObjectStateEntry, 676, 695 ObjectStateManager, 676, 695 objeto de negocio, 905 objeto Response, 999 objetos como orígenes de datos, 454 objetos de negocio, 535 objetos de sincronización, 409 OdbcConnection, 501 OdbcDataAdapter, 505 ol, 1072 OleDbConnection, 501 OleDbDataAdapter, 505 OleDbDataReader, 504 onchange, evento, 1008 onreadystatechange, 1005 OpenFile, 219, 220 OpenFileDialog, 217, 220

OpenForms, 63 operadores de consulta, 626 OperationContract, 876 optgroup, 1081 OptimisticConcurrencyException, 689 option, 1080 Option Explicit, 36 Option Strict, 36 OracleConnection, 501 OracleDataAdapter, 505 orden, 505 orden de tabulación, 1080 orden parametrizada, 516 orden SQL, escribir una nueva, 610 orden Tab, 55, 90, 281 ordenación, 863 Order By, 627, 635 organizar iconos, 362 Orientation, 207 origen de datos, 440, 457 orígenes de datos ADO.NET, 440, 575 orígenes de datos, ventana, 457 OriginalValues, 698 ORM, 643, 701 OutputCache, 813 Overrides, 50 OwnedForms, 183 OwnedWindows, 65 Owner, 65, 183, 234

P p, 1070 Padding, 126 padre‐hija, tablas, 587 Page, 784, 924, 1017 Page.DataBind, 752 Page_Error, 841 Page_evento, 751, 785 PageMethods, 1038 PageRequestManager, 1033 PageSetupDialog, 217 página de contenido, 969 página de inicio de sesión, 936 página maestra, 969 página principal, 969 página web, 781, 1068 página web ASP.NET, 739 página web dinámica, 1090 página web, modelo de ejecución, 747

1119

1120


paginación, 863 páginas ASP, 1091 páginas web, publicar, 741 Paint, 294, 298, 299 Panel, 24, 188, 323, 367 panel de dibujo, 340 pantalla de presentación, 76 ParameterExpression, 632 Parameters, 516 parámetro oculto, 807, 1079 parámetros en órdenes SQL, 516 Parse, 114 Parse, evento, 432, 435 Partial, 86 pasos, 239 passport, 927 PasswordChar, 176 PasswordRecovery, control, 950 Paste, 144 patrón de diseño Factory, 526 patrones de diseño, 649 Pen, 300 perfiles, 983 PerformClick, 117, 469, 583 PerformStep, 209 permanente, 312 PictureBox, 81, 323 plantilla, 755, 760 plantilla de formularios, 366 Play, 339 PNG, 321 POCO, 701 Point, 55, 302 pool de conexiones, 926 POP 2 y 3, 1064 portapapeles, 142, 327 posición de un componente, modificar, 222 posición inicial del formulario, 63 Position, 442, 581 post, 798 postback, 1003, 1029 postbacks asíncronos, 1021 PostgreSql, 502 precompilar la aplicación ASP.NET, 797 PreInit, 785, 982 PreRender, 785 presentación, 723 PRIMARY KEY, 489 principal, 919 Print, 358

PrintDialog, 217 PrintPage, 358 Priority, 398 problemas de concurrencia, 556 procedimientos almacenados, 517, 533 producto cartesiano, 638 Profile, 983 ProgressBar, 81, 208 ProgressChanged, 406 ProgressPercentage, 406 PropertyChanged, 427 PropertyManager, 441 propiedad, 656 propiedad autoimplementada, 621 propiedad cambió, notificar, 427 propiedad Cancel, 96 propiedad ClientSize, 50 propiedad Controls, 55 propiedad Count, 581 propiedad Cursor, 329 propiedad DataBindings, 577 propiedad DataMember, 567 propiedad DataSource, 567 propiedad Font, 54 propiedad Icon, 29 propiedad Location, 55 propiedad Modified, 354, 365 propiedad Name, 50 propiedad Position, 581 propiedad ReadOnly, 108 propiedad Size, 50, 55 propiedad TabStop, 55 propiedad TanIndex, 55 propiedad Text, 50, 54 propiedad TextAlign, 54, 108 propiedades, 27 propiedades de navegación, 662 propiedades, añadir a un control, 376, 387 propiedades, atributos, 379 propiedades, clasificación, 379 propiedades, control de usuario, 373, 375, 377, 378, 379, 380, 381, 386, 387, 388 propietario de un diálogo, 234 Protected, 50 protocolo, 1062 protocolo de transferencia de ficheros, 1066 proveedor de datos, 500 proveedor de entidades, 645 proveedores de LINQ, 641 providers, 951

ÍNDICE

proyecto, 16 publicar páginas web, 741 puntero, 22 punto de entrada a la aplicación, 51 punto de inserción, 89 punto final, 875

Q QueryString, atributo proveedor de valor, 848

R RAD, 781 RadioButton, 54, 81, 188 RangeValidator, 793 raster, dispositivos, 294 Read, 504 ReaderWriterLock, 410 ReadOnly, 108 readyState, 1005 recorte, área de, 309 Rectangle, 302 recursos, 130, 1096 recursos de una aplicación, 68 recursos embebidos, 132 recursos vinculados, 132 recursos, acceder, 1099, 1100 Redirect, 803, 999 RedirectFromLoginPage, 938 Redo, 352 reescritura de la URL, 806 refactorización, 375 referencias, 19 referencias culturales, 1094 reflexión, 70 Refresh, 447, 691 Regex, 102, 438 región, 308 región de recorte, 309 región no válida, 295 RegisterClientScriptBlock, 1017 RegisterStartupScript, 1017 registros, 487 rehacer, 352, 360 rejilla, 567 rejilla de ayuda, 29 Reload, 693, 698 reloj, 223 reloj despertador, 164, 238

Remove, 197, 231 RemoveAt, 197 RemoveAt, colección, 164 RemoveHandler, 62 rendimiento del servidor, 812 repintar una ventana, 295 Replace, 103 ReportProgress, 406 representar funciones, 330 Request, 802 RequiredFieldValidator, 793 reset, 1079 Reset, 413 Resize, 223 resolución gráfica, 294 ResourceManager, 68, 132, 1099, 1101 Response, 802, 999 Response.Redirect, 938 responseText, 1005 responseXML, 1005 RestoreBounds, 66 reutilización, 373 RevertMerge, 351 RGB, 109 RichTextBox, 81, 151, 352 Row, 553 RowCount, 254 Rows, 243 RTF, 352 Run, 46 RunWorkerAsync, 404 RunWorkerCompleted, 404, 407 ruta del sitio web, 802

S SaveChanges, 662 SaveFile, 352 script callbacks, 1012 ScriptManager, 1021 ScriptManagerProxy, 1028 ScriptPath, 1021 scripts, 1021, 1091 ScriptService, 1036 Scroll, 206 ScrollBar, 54, 81, 203 ScrollBars, 139 sección crítica, 410 seguimiento de los cambios, 695 seguridad, 958

1121

1122


seleccionar datos de una tabla, 491 seleccionar el contenido de una caja de texto, 90 seleccionar el texto de una caja, 229 seleccionar un objeto, 28 select, 1080 Select, 89, 91, 144, 584, 635, 823, 838 SELECT, 491 SelectAll, 90, 144, 229 SelectCommand, 505 selected, 1081 SelectedCells, 244 SelectedColumns, 243 SelectedImageIndex, 257, 258 SelectedIndex, 157, 194, 199, 752 SelectedIndexChanged, 157, 672, 673 SelectedItem, 157, 194, 199, 201, 752 SelectedItems, 196 SelectedNode, 255, 265 SelectedRows, 243 SelectedRtf, 359 SelectedText, 91, 143, 359 SelectedValue, 558, 752 Selecting, 838 SelectionAlignment, 364 SelectionChange, 363 SelectionFont, 364 SelectionLength, 91, 143 SelectionStart, 91, 143 SelectMethod, 761 Semaphore, 409 sentencia Using, 511 señalar un elemento de un menú, 153 separadores, 125 seriar/deseriar un árbol, 292 Server, 802, 841 ServiceContract, 876 Services, 1021, 1036 servicio, 873 servicio de conexiones, 926 Servicio de red, 746, 771 servicio de suscripciones, 951 servicio WCF, 875 servicio WCF, configuración, 882 servicio web, 8 servicio web, acceso a BD, 990 servicios de IIS, 742 servicios de Internet, 1065 Servicios de objetos, 646 servicios web con AJAX, 1034 servicios web y LINQ, 894

servicios web, ejecución asíncrona, 890 servidor de nombres, 1064 servidor SMTP de IIS, 948 servidor web, 1092 servlets, 1092 Session, 802 Set, 413, 686 SetCacheability, 815 SetClip, 309 SetError, 97 SetInitializer, 710 setLocationRelativeTo, 283 setTimeout, 1011 SetToolTip, 57 ShortcutKeys, 130 Show, 65, 170, 177, 183, 234 ShowColor, 222 ShowDialog, 63, 177, 179, 183, 218 ShowHelp, 221 ShowInTaskbar, 64, 65 Shown, 63, 89 ShowNodeToolTips, 269 ShowPlusMinus, 269 ShowReadOnly, 219 ShowRootLines, 269 Shutdown, 73 simultaneidad, 689, 895 simultaneidad optimista, 563 sincronización, 917 sistema de nombres de dominio, 1063 sitio web, 741 sitio web, reglas de acceso, 954 sitios web, administración, 941 size, 1069 Size, 50, 55, 222, 303 SizeChanged, 223 skins, 980 Sleep, 398 SmallChange, 204 SMTP, 948, 1065 SOAP, 871 SOAP, mensaje, 874 SolidBrush, 301 solución, 16 sonido en una aplicación, 339 Sort, 194, 200 SortedList, 229, 230 SplashScreen, 76 SplitContainer, 273 SQL, 488

ÍNDICE

SQL Server, 502, 509, 790 SQL Server 2012 Express, 1051 SQL Server Management Studio Express, 1054 SqlCacheDependency, 817 SQLCMD, 1052 SqlCommand, 503 SqlCommandBuilder, 563 SqlConnection, 501 SqlDataAdapter, 505 SqlDataReader, 504 SqlDataSource, 820, 1024 src, 1074, 1076 SSDL, 644 SSL, 930, 961, 967 Start, 396, 398 StartPosition, 63 Startup, 73 StartupNextInstance, 73 StartupPosition, 66 State, 698 status, 1005 StatusBar, 81 StatusStrip, 137 statusText, 1005 Step, 209 StoreWins, 693 Strikethru, 364 subdominio, 1063 submenú‐menú contextual, 161 submenús, 127 submit, 1079 Substitution, 814 Sum, 627 suplantación de identidad, 932 SupportsFiltering, 469 SupportsSorting, 469 suscribir evento, 30 SvcUtil.exe, 887 SyncLock, 410, 419 System.ComponentModel, 81 System.Data.Linq, 619 System.Drawing, 50, 54, 82, 296 System.Linq, 619 System.Linq.Expressions, 631 System.Runtime.CompilerServices, 622, 636 System.Threading, 392 system.web, 927 System.Web, 802 System.Windows.Forms, 49, 80 System.Windows.Forms.Design, 81

1123

T Tab, 55 TabControl, 210 tabindex, 1080 TabIndex, 55, 89, 126 tabla, 24, 241, 487, 1083 tabla con cabecera de filas, 281 tabla, construir, 244 tabla, iniciar, 246 table, 1083 table dinámico, 1005 TableAdapterManager, 574 TableLayoutPanel, 213 tablero de dibujo, 340 TabStop, 55 Tag, 484 Take While, 627 tamaño de los controles, 27 tamaño de un componente, modificar, 222 TCP/IP, 1062 td, 1083 tecla de acceso, 56, 85 tecla pulsada, interceptar, 91 teclas, 94 teclas Alt, Control o Shift (Mayús), 94 telnet, 1065 temas, 980 temporizador, 25, 223, 1011 Text, 50, 54, 88, 199 TextAlign, 54, 108 textarea, 1080 TextBox, 53, 81, 82, 141 TextBoxBase, 81, 143 TextChanged, 87, 191, 426 texto seleccionado, 152 th, 1083 theme, 980 Thread, 395 ThreadException, 72 ThreadExit, 72 ThreadStart, 395 ThreadState, 398 ThreeState, 185 Tick, evento, 225 TickFrequency, 207 ticks, 239 TickStyle, 207 TIFF, 321 Timer, 224, 410, 1034

1124


TimeSpam, 226 tip, 57 tipo anónimo, 620 tipo de un objeto, 263 tipo enumerado, 111 tipo implícito, 620 tipografía, 296 tipos de enlace, 432 tipos SQL, 489 title, 1069 ToDouble, 88 ToInt32, 192 ToList, 663 ToolBar, 81 ToolStrip, 121, 134 ToolStripButton, 135 ToolStripComboBox, 155 ToolStripItem, 121 ToolStripItemCollection, 127 ToolStripManager, 351 ToolStripMenuItem, 126, 480 ToolStripSeparator, 128 ToolTip, 57 Top, 65 Topmost, 66 ToString, 193, 230, 262 ToUpper, 193 tr, 1083 TrackBar, 81, 207 transacción, 518, 613 transacciones explícitas, 523 TransactionScope, 519, 613 Transform, 316 transformación, 314, 331 transformación global, 316 transformación local, 316 transformaciones de color, 318 trazado, 308 TreeNode, 255 TreeView, 254 trigger, 1029 Triggers, 1030 TryParse, 114 type, 1077 Type, 263, 460, 544 typeof, 460

U Unchanged, 499

Underline, 364 Undo, 144, 154, 352, 360 UnhandledException, 73 unidad de medida, 299 UNIQUE, 489 Unload, 785 Update, 507, 569, 613, 823 UPDATE, 490 UpdateCommand, 505 UpdateMethod, 762 UpdateMode, 1031 UpdatePanel, 1028 UpdateProgress, 1032 URL, 725, 1072 URL, dirigirse a otra, 938 USENET, 1065, 1066 User, 924 UserControl, 375 UserDeletingRow, 546 UserName, 957 Using, 511, 613 usuario ASPNET, 926

V validación, 767 validación de datos, DataGridView, 478 validación de los datos, 606 validación discreta, 794 validación personalizada, 104 validación, controles, 727 validar datos, 438 validar un campo de texto, 93 Validate, 606 Validated, 96 Validating, 96 ValidationAttribute, 711 ValidationSummary, 793 value, 1079 Value, 203, 209, 231, 237 Value Object, 532, 649 value provider attributes, 848 ValueChanged, 206 ValueMember, 521, 558 var, 620 varbinary, 897 variable fuertemente tipada, 756 variable, declaración implícita, 620 VaryByParam, 813 ventana, 43, 45

ÍNDICE

ventana de aplicación, 344 ventana de documento, 344 ventana, centrar, 283 Ventana, menú, 347, 362 ViewState, 784, 807, 808 ViewState, deshabilitar, 818 ViewState, mecanismo, 818 vista de colección, 471 vista del control, 844 vista, buscar sus elementos, 474 vista, filtrar sus elementos, 474 vista, ordenar sus elementos, 473 Visual Studio .NET, 13, 15 VScrollBar, 81, 204

W WaitAll, 413 WaitAny, 413 WaitHandle, 410, 412 WaitOne, 413 WCF, 873 web, 1066 web, controles, 727 Web.config, 927 WebForm_DoCallback, 1013

webMethod, 1039 WebResource.axd, 1014 Where, 635 WhereParameters, 838 width, 1075 Windows Forms, 7, 38, 79 WindowsFormsApplicationBase, 76 WindowsIdentity, 925 WindowState, 66, 344 WithEvents, 54 WordWrap, 139 WorkerReportsProgress, 406 WorkerSupportsCancellation, 407 world wide web, 1066 WPF, 7, 38, 79 WriteLine, 129 WSDL, 872 WWW, 1065, 1066

X XCOPY, 1052 XHTML, 1001, 1090 XML, 7, 1009, 1089 XMLHTTP, 1004 XMLHttpRequest, 1004

1125

Del mismo autor ● Curso de programación con PASCAL ● Curso de programación GW BASIC/BASICA ● Manual para TURBO BASIC Guía del programador ● Manual para Quick C 2 Guía del programador ● Manual para Quick BASIC 4.5 Guía del programador ● Curso de programación Microsoft COBOL ● Enciclopedia del lenguaje C ● Curso de programación QBASIC y MS-DOS 5 ● Curso de programación RM/COBOL-85 ● El abecé de MS-DOS 6 ● Microsoft Visual C ++ (ver. 1.5x de 16 bits) Aplicaciones para Windows ● Microsoft Visual C ++ Aplicaciones para Win32 (2ª edición) ● Microsoft Visual C ++ Programación avanzada en Win32 ● Visual Basic 6 Curso de programación (2ª edición) ● Enciclopedia de Microsoft Visual Basic 6 ● El lenguaje de programación Java ● El lenguaje de programación C#

ISBN: 978-84-86381-36-3 224 págs. ISBN: 978-84-86381-87-5 320 págs. ISBN: 978-84-86381-43-1 444 págs. ISBN: 978-84-86381-65-3 540 págs. ISBN: 978-84-86381-74-5 496 págs. ISBN: 978-84-7897-001-8 480 págs. ISBN: 978-84-7897-053-7 888 págs. ISBN: 978-84-7897-059-9 384 págs. ISBN: 978-84-7897-070-4 396 págs. ISBN: 978-84-7897-114-5 224 págs. ISBN: 978-84-7897-180-0 846 págs. + 2 disquetes ISBN: 978-84-7897-561-7 792 págs. + disquete ISBN: 978-84-7897-344-6 888 págs. + CD-ROM ISBN: 978-84-7897-357-6 528 págs. + disquete ISBN: 978-84-7897-386-6 1.072 págs. + CD-ROM ISBN: 978-84-7897-485-6 320 págs. + CD-ROM ISBN: 978-84-7897-500-6 320 págs. + CD-ROM

Del mismo autor ● El lenguaje de programación Visual Basic.NET ● Java 2 Lenguaje y aplicaciones ● Programación orientada a objetos con C ++ (4ª edición) ● C/C++ Curso de programación (3ª edición) ● Microsoft C# Lenguaje y aplicaciones (2ª edición) ● Java 2. Interfaces gráficas y aplicaciones para Internet (3ª edición) ● Aplicaciones .Net multiplataforma (Proyecto Mono) ● Enciclopedia del lenguaje C ++ (2ª edición) ● Enciclopedia de Microsoft Visual C# (3ª edición) ● Enciclopedia de Microsoft Visual Basic (2ª edición) ● Microsoft Visual Basic .NET Lenguaje y aplicaciones (3ª edición) ● Java 2 Curso de programación (4ª edición) ● Microsoft C# Curso de programación (2ª edición) ● Visual C#. Interfaces gráficas y aplicaciones para Internet con WPF, WCF y Silverlight ● Visual Basic. Interfaces gráficas y aplicaciones para Internet con WPF, WCF y Silverlight

ISBN: 978-84-7897-525-9 464 págs. + CD-ROM ISBN: 978-84-7897-745-1 392 págs. + CD-ROM ISBN: 978-84-7897-761-1 648 págs. + CD-ROM ISBN: 978-84-7897-762-8 708 págs. + CD-ROM ISBN: 978-84-7897-813-7 520 págs. + CD-ROM ISBN: 978-84-7897-859-5 718 págs. + CD-ROM ISBN: 978-84-7897-880-9 212 págs. + CD-ROM ISBN: 978-84-7897-915-8 902 págs. + CD-ROM ISBN: 978-84-7897-986-8 1.110 págs. + CD-ROM ISBN: 978-84-7897-987-5 1.090 págs. + CD-ROM ISBN: 978-84-9964-020-4 520 págs. + CD-ROM ISBN: 978-84-9964-032-7 820 págs. + CD-ROM ISBN: 978-84-9964-068-6 850 págs. + CD-ROM ISBN: 978-84-9964-203-1 956 págs. + CD-ROM ISBN: 978-84-9964-204-8 938 págs. + CD-ROM

INSTALACIÓN Para instalar el kit de desarrollo de Visual Basic y los ejemplos de este libro descargue la plataforma de desarrollo de la dirección: http://www.microsoft.com/express/.

PLATAFORMA WINDOWS Instalación de .NET Framework SDK Hay que instalar .NET Framework Redistributable Package antes de instalar .NET Framework SDK. El primer paquete incluye todo lo necesario para ejecutar aplicaciones desarrolladas con .NET Framework. El segundo paquete incorpora todo lo necesario para escribir, construir, verificar y desplegar aplicaciones desarrolladas con.NET Framework. Para realizar la instalación, siga las instrucciones mostradas por el asistente de instalación. Esta instalación se realiza en la carpeta Microsoft.NET de Windows y en la carpeta Microsoft.NET de archivos de programas.

Instalación de Microsoft Visual Studio La instalación de Visual Studio (el paquete completo o las versiones Express que necesite) no requiere la instalación previa del SDK porque está incluido en éste. Descargue de Internet el paquete Visual Studio Express 2012, o bien, si tiene acceso a alguna versión profesional de Visual Studio 2012, e instálelo (opcionalmente puede instalar SQL Server Express).

Ejemplos del libro Los ejemplos del libro puede instalarlos en la carpeta Projects de Visual Studio o los puede recuperar directamente desde el material adicional cuando los quiera consultar.

PLATAFORMA LINUX Véase el apéndice D.

LICENCIA Todo el contenido de este material adicional, excepto los ejemplos del libro, es propiedad de las firmas que los representan (Microsoft, etc.). La inclusión en este libro se debe a su gentileza y es totalmente gratuita y con la finalidad de apoyar el aprendizaje del software correspondiente. Para obtener más información y actualizaciones visite las direcciones indicadas en dicho software: http://www.microsoft.com/express/ Al realizar el proceso de instalación, haga el favor de consultar el acuerdo de licencia para cada uno de los productos.

WEB DEL AUTOR: http://www.fjceballos.es En esta Web podrá echar una ojeada a mis publicaciones más recientes y acceder a la descarga del software necesario para el estudio de esta obra así como a otros recursos.

Report "Ceballos: Enciclopedia de Microsoft Visual Basic 3Ed"

Your name

Email

Reason

Description

Copyright © 2024 IDOC.TIPS. All rights reserved.
About Us | Privacy Policy | Terms of Service | Copyright | Contact Us | Cookie Policy

Sign In

Email

Password

Remember me Forgot password?

Our partners will collect data and use cookies for ad personalization and measurement. Learn how we and our ad partner Google, collect and use data. Agree & close

Ceballos: Enciclopedia de Microsoft Visual Basic 3Ed

Recommend Documents

Ejemplo de un documento HTML

El cuerpo del documento puede contener:

Texto, imágenes, sonido y órdenes HTML

Ejemplo de un documento HTML

El cuerpo del documento puede contener:

Texto Imágenes Sonido Órdenes HTML

CONCERTAR UNA TUTORÍA

Ejemplo de un documento HTML

El cuerpo del documento puede contener:

Texto, imágenes, sonido y órdenes HTML

Ejemplo de un documento HTML

El cuerpo del documento puede contener:

Texto, imágenes, sonido y órdenes HTML

Divisiones

Texto
Imágenes
Sonido
Órdenes HTML