Ceballos: Enciclopedia de MS Visual C# 4Ed

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

www.fjceballos.es

Enciclopedia de Microsoft Visual C# Interfaces gráficas y aplicaciones para Internet con Windows Forms y ASP.NET 4.ª 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-264-2 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 C#

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

32 33 35 35 36 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 64 65 66 68 69 70 72 73 74

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 100 100 103 104 106 106 106 107 107 107 109 110 111 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 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 148 148 148 149 149 150 151 152 153 154 154 154 155 159 161 165

CAPÍTULO 6. CONTROLES Y CAJAS DE DIÁLOGO .................................. 169 CAJAS DE DIÁLOGO MODALES Y NO MODALES .................................... CAJAS DE MENSAJE ....................................................................................... 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........................................................................................... Iniciar la lista............................................................................................. Acceder a los elementos seleccionados.....................................................

170 170 173 174 176 177 179 180 181 182 186 191 193 194 194

CONTENIDO

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

195 196 197 198 199 199 200 201 202 205 206 208 209 210 214 215 218 219 221 222 225 236

CAPÍTULO 7. TABLAS Y ÁRBOLES ................................................................ 239 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 ................................................................. Añadir y borrar nodos .................................................................................... Añadir un nodo .........................................................................................

239 241 242 243 244 250 251 252 253 253 254 255 256 258 262 262 263

XII


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.............................................................................

266 266 267 267 268 269 270 271 271 274 290

CAPÍTULO 8. DIBUJAR Y PINTAR .................................................................. 291 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 ........................................... CAMBIAR LA FORMA DEL PUNTERO DEL RATÓN ................................. EJERCICIOS RESUELTOS ...............................................................................

293 294 296 297 298 299 300 300 301 302 302 302 303 304 304 305 306 306 309 311 315 316 318 318 320 326 327 328

CONTENIDO

XIII

EJERCICIOS PROPUESTOS............................................................................. 339 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 385 386 388 391

XIV


CAPÍTULO 11. PROGRAMACIÓN CON HILOS ............................................ 393 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.............................................................................

394 397 400 400 401 401 406 407 409 409 410 410 411 413 414 417 420 423

PARTE 3. ACCESO A DATOS ............................................... 425 CAPÍTULO 12. ENLACE DE DATOS EN WINDOWS FORMS ..................... 427 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 ........................................................................

427 427 431 434 435 436 437 437 437 439 439 444 446 447 452 456 459

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 462 466 470 470 471 474 476 478 478 479 479 480 482 483 485

CAPÍTULO 13. ACCESO A UNA BASE DE DATOS ....................................... 493 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 .................................................................................. Servicio de conexiones................................................................................... ACCESO CONECTADO A UNA BASE DE DATOS ...................................... ATAQUES DE INYECCIÓN DE CÓDIGO SQL .............................................. Órdenes parametrizadas .................................................................................

494 494 494 496 496 497 497 499 499 501 502 503 504 506 507 509 509 510 512 514 515 516 519 523

XVI


Procedimientos almacenados ......................................................................... 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.............................................................................

524 525 526 530 533 539 540 541 542 545 550 551 553 556 557 561 564 566 566 570 572 577 578 579 581 585 587 588 590 593 597 598 608 627

CAPÍTULO 14. LINQ ............................................................................................ 631 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 ....................................................................

631 632 632 632 633

CONTENIDO

Iniciadores de objetos y colecciones .............................................................. Métodos extensores ........................................................................................ Expresiones lambda ....................................................................................... El delegado Func ......................................................................... 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 los controles con sus orígenes 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 .................................................................................

XVII 633 634 635 637 638 640 643 647 649 649 650 650 651 652 653 654 656 659 663 664 664 673 676 678 679 680 681 686 687 688 693 695 699 703 710 715 717 717 718 719 720 722 726

XVIII


Atributos de anotación de datos ................................................................ 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.............................................................................

726 727 729 730 731 732 733 734 737

PARTE 4. APLICACIONES PARA INTERNET .................. 739 CAPÍTULO 15. ASP.NET ..................................................................................... 741 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 .................................................................................

743 744 745 746 747 748 748 750 751 751 751 752 752 753 755 757 759 760 762 764 765 767 771 772 772 775 777 779

CONTENIDO

XIX

Actualizar y eliminar datos .................................................................. Insertar datos (FormView) ................................................................... Estado del modelo y validación ........................................................... Asistente para publicar un proyecto web ASP.NET ......................................

780 783 785 787

CAPÍTULO 16. FORMULARIOS WEB ............................................................. 791 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 ..........................................

792 796 798 799 800 802 805 805 808 810 814 816 816 817 818 819 819 821 821 822 822 824 825 825 828 828 828 829 830 830 831 832 833 834 836

XX


CONTROLES DE SERVIDOR COMO ORIGEN DE DATOS......................... 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.............................................................................

837 839 841 844 846 847 853 855 856 857 859 859 865 870 870 873 873 878 881 887

CAPÍTULO 17. SERVICIOS WEB ...................................................................... 889 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 ........................................................................................

890 891 892 893 894 900 902 906 906 908 912 912 914 915 916 924 927 928 928

CONTENIDO

XXI

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

929 929 930 931 932

CAPÍTULO 18. SEGURIDAD DE APLICACIONES ASP.NET ...................... 939 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 ....................................................................

940 941 942 943 950 952 953 958 971 978 979 979 981 983 988

CAPÍTULO 19. PÁGINAS MAESTRAS ............................................................. 989 ESTRUCTURA DE UNA PÁGINA MAESTRA ............................................... 989 Controles de usuario web ............................................................................... 994 Mejorar el aspecto de la interfaz .................................................................... 999 Temas y máscaras en ASP.NET ..................................................................... 1000 Perfiles ........................................................................................................... 1003 EJERCICIOS RESUELTOS ............................................................................... 1007 Base de datos .................................................................................................. 1008 Cliente web .................................................................................................... 1012 CAPÍTULO 20. AJAX ........................................................................................... 1021 FUNDAMENTOS DE AJAX ............................................................................. 1023 XMLHttpRequest ........................................................................................... 1024 AJAX con ASP.NET...................................................................................... 1032 GENERACIÓN DE CÓDIGO JAVASCRIPT ................................................... 1034

XXII


Fichero JavaScript .......................................................................................... 1035 Vincular un evento con una función JavaScript ............................................. 1035 Inyectar código JavaScript desde el lado del servidor ................................... 1037 ASP.NET AJAX ................................................................................................. 1038 Crear un sitio web ASP.NET AJAX ................................................................... 1039 Clase ScriptManager ...................................................................................... 1040 Clases ScriptManager y ScriptManagerProxy ............................................... 1048 Clase UpdatePanel ......................................................................................... 1048 Clase AsyncPostBackTrigger......................................................................... 1050 Clase UpdateProgress..................................................................................... 1051 Cancelar una llamada asíncrona ..................................................................... 1053 Clase Timer .................................................................................................... 1054 Servicios web ................................................................................................. 1054 Métodos de página ......................................................................................... 1058 EJERCICIOS RESUELTOS ............................................................................... 1060

PARTE 5. ACERCA DEL CD Y DE LOS APÉNDICES .... 1063 HERRAMIENTAS DE DESARROLLO.............................................................. 1065 PÁGINAS WEB ...................................................................................................... 1081 INTERNACIONALIZACIÓN .............................................................................. 1113 .NET PARA LINUX ............................................................................................... 1123 ÍNDICE ................................................................................................................... 1125

PRÓLOGO C#, pronunciado C Sharp, es actualmente, junto con Java, uno de los lenguajes de programación más populares en Internet. Pero, además, apoyándose en la biblioteca .NET, está disponible para el desarrollo de aplicaciones de propósito general, aplicaciones con interfaz gráfica, aplicaciones para Internet y aplicaciones para móviles. La idea fundamental de esta obra es dar a conocer estas facetas del lenguaje C#, profundizando en el alcance que tiene sobre la Web. En los últimos tiempos C y C++ han sido los lenguajes más utilizados en el desarrollo de aplicaciones en general. Ambos lenguajes proporcionan al programador el nivel de abstracción preciso para abordar el desarrollo de cualquier aplicación por compleja que sea, así como mecanismos de bajo nivel para utilizar las características más avanzadas de las plataformas sobre las que se desarrolla; pero, en general, el tiempo necesario para desarrollar una aplicación resulta largo comparado con otros lenguajes como Visual Basic, que ofrecen además de facilidad, una elevada productividad en el desarrollo de aplicaciones, aunque, eso sí, sacrificando la flexibilidad que los desarrolladores de C y C++ requieren. La solución que Microsoft da a este problema es el lenguaje denominado C#. Se trata de un lenguaje moderno orientado a objetos que permite desarrollar una amplia gama de aplicaciones para la plataforma Microsoft .NET. Más que otra cosa, el objetivo de C# es permitir a todos los desarrolladores en general, y a los de C y C++ en particular, abordar el desarrollo de aplicaciones complejas con facilidad y rapidez pero sin sacrificar la potencia y el control que ofrecen C y C++. Es un poco como tomar todas las cosas buenas de Visual Basic y añadirlas a C++, aunque recortando algunas de las tradiciones más ocultas y difíciles de conocer de C y C++. Esto elimina los errores de programación más comunes en C/C++. Por ejemplo:

XXIV   


El recolector de basura libera al programador del peso que conlleva el manejo manual de la memoria. Todos los objetos creados dinámicamente así como las matrices son iniciados a cero, y aunque C# no inicia automáticamente las variables locales, el compilador avisará siempre que se intente utilizar una antes de iniciarla. C# unifica el sistema de tipos permitiendo ver a cada uno de ellos en el lenguaje como un objeto.

Resumiendo, C# 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 C#) 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. 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 esta ofrece. Y “NET” hace referencia al ámbito donde operarán nuestras aplicaciones web (Network - red).

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 (C#, Visual Basic, Java, etc., son lenguajes orientados a objetos). Haber programado en .NET y con C# sería lo ideal, así como tener conocimientos de HTML y XML. Estos requisitos son materia de mis otros libros Microsoft C# -

PRÓLOGO

XXV

Lenguaje y aplicaciones y Microsoft C# - Curso de programación, ambos editados también por las editoriales RA-MA y Alfaomega Grupo Editor. Microsoft C# - 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 C# - 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. Este sí que es un libro de programación con C# 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

XXVI


APÉNDICE C. INTERNACIONALIZACIÓN APÉNDICE D. .NET PARA LINUX

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. En especial, quiero expresar mi agradecimiento por su participación en las ediciones anteriores a mi excolega Manuel Peinado Gallego, por sus buenas recomendaciones y aportaciones, y a Francisco Ceballos Fernández, ingeniero de informática, por la revisión del contenido. 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 CD y de los apéndices  Entornos 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.

1066   


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 C# 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: HERRAMIENTAS DE DESARROLLO

1067

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

1068


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.


1069

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).

1070


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.


1071



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

1072


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


1073

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 (:).

1074


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


1075

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 BASE 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

1076


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.


1077

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.

1078


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. Si la operación anterior no solucionó el problema, pruebe a reparar la instalación actual a partir del CD de instalación 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


1079

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 = 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 fuen-

1080


te. 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 implementar 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-

1082


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

1083

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

1084


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).


1085



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.

1086


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


1087

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.

1088


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.


1089

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:

1090


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.


1091

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

1092


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


1093

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.

1094


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


1095

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>

1096


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 CD.

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


1097

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.

1098


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á


1099

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.

1100


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:


1101

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.

1102


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 CD. Concertar una tutoría
CONCERTAR UNA TUTORÍA

Alumno:

Con el profesor:

Día:

Hora: 10 12 16 18


1103

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:

1104 


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 CD que acompaña al libro.


1105

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:

1106


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





1107


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
.

1108


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).


1109

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

1110


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


1111

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.

1112


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

1114


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: using System; using System.Globalization; class CInfoCultura { static void Main(string[] args) { foreach (CultureInfo info in CultureInfo.GetCultures( CultureTypes.AllCultures)) // Mostrar todas las referencias culturales Console.WriteLine("{0,-12} {1}", info, info.DisplayName); } }

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 static void Cultura(string sInfo) { CultureInfo info = 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(); }

APÉNDICE C: INTERNACIONALIZACIÓN

1115

Para invocar al método anterior, añada al método Main sentencias análogas a las siguientes: 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 static void CulturaActual() { CultureInfo info = null; info = CultureInfo.CurrentUICulture; Console.Write("Cultura actual: "); Console.WriteLine("{0, -12} {1}", info, info.DisplayName); }

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

1116


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 referencia 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.


1117

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.cs[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.

1118


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 void ArchivoSalir_Click(object sender, EventArgs e) { Close(); } private void AyudaAcercaDe_Click(object sender, EventArgs e) { AcercaDe dlg = new AcercaDe(); dlg.Show(); }


1119

Mostrar recursos específicos Para mostrar los recursos de la aplicación bajo una referencia cultural determinada utilizaremos el siguiente código: using System.Globalization; using 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 void OpcionesIdiomaEspañol_Click(object sender, EventArgs e) { Thread.CurrentThread.CurrentCulture = new CultureInfo("es-ES"); Thread.CurrentThread.CurrentUICulture = new CultureInfo("es-ES"); this.Controls.Clear(); this.InitializeComponent(); } private void OpcionesIdiomaInglés_Click(object sender, EventArgs e) { Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US"); Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-US"); this.Controls.Clear(); this.InitializeComponent(); }

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.

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ú

1120


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: using System.Resources; // ... private void btAceptar_Click(object sender, EventArgs e) { ResourceManager rm = new ResourceManager("InfoCulturaWin.Form1", typeof(Form1).Assembly); TextBox1.Text = rm.GetString("cad01"); }

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 cultu-


1121

ral 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í: using System.Resources; // ... private void btAceptar_Click(object sender, EventArgs e) { System.Resources.ResourceManager rm = new System.Resources.ResourceManager( "InfoCulturaWin.Properties.Resources", typeof(Form1).Assembly); if (CultureInfo.CurrentUICulture.Name == "es-ES") TextBox1.Text = rm.GetString("cad01_es"); else TextBox1.Text = rm.GetString("cad01_en"); }

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, multiplataforma, 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 C#, entre otros lenguajes, 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 no es más que una extensión a esta enciclopedia para que vea cómo puede aplicar lo aprendido en la misma, sobre una máquina Linux con Mono.

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

? ?, 866

@ @, 726 @ Page, 799, 991 @ Register, 997

A a, etiqueta HTML, 1093 abort, 1024 Abort, 400 abrir documento, 354 acceder a un nodo, 258 AcceptButton, 83, 85, 175, 368 AcceptsReturn, 140 AcceptsTab, 140 acceso a datos desde un formulario web, 837 acceso a datos utilizando componentes, 571 acceso anónimo, 944 acceso anónimo, deshabilitar, 946 acceso conectado a bases de datos, 516

acceso desconectado a bases de datos, 570 acceso desconectado a datos, 566 accesos directos, 1093 Access, 508 aceleradores, 129 Acerca de, 179, 326 acoplar control, 140 acoplar un control a su contenedor, 221 action, 1097, 1099 Activate, 63, 64 Activated, 62, 63 ActiveForm, 63 ActiveMdiChild, 346 actualizar las filas, 693 actualizar y eliminar filas, EntityDataSource, 857 actualizar y eliminar filas, modelo de enlace, 870 adaptador, 510 Add, 55, 126, 229, 595 Add, colección, 162 Added, 505 AddNew, 488 AddRange, 127 address, 900 administración de sitios web, 961 ADO.NET, 9, 502 AfterSelect, 261 agregar datos, 929 AJAX, 1021, 1048 Ajax Control Toolkit, 999

1126


AJAX, envío de datos utilizando el método POST, 1031 AJAX, llamadas fuera de dominio, 1030 AJAX, llamadas que producen errores o que no retornan, 1030 align, 1094 alineación del texto, 54, 364 alisado, 300 AllowFullOpen, 219 AllowMerge, 345 AllowsTransparency, 65 alt, 1094 ámbito de aplicación, 828 ámbito de sesión, 829 Anchor, 221, 367 animación, 334 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, 594 añadir un usuario que tenga una función, 974 añadir una nueva fila a una rejilla, 488 aplicación ASP.NET cliente de un servicio web, 1012 aplicación web, 1112 aplicación web de IIS, 762 aplicación, ciclo de vida, 70 aplicación, crear, 16 aplicación, depurar, 33 aplicación, desarrollo, 82 aplicación, instanciar sólo una vez, 72, 78 aplicaciones de consola, 1066 aplicaciones web, 792 App.config, 67 App_Browsers, 796 App_Code, 767, 796 App_Data, 796 App_GlobalResource, 796 App_LocalResources, 796 App_Themes, 796, 1000 App_WebReferences, 796 Appearance, 183, 187 AppendText, 144 applets, 1112 Application, 51, 62, 71, 821 Application_Error, 859 ApplicationExit, 71 árbol, 252 árbol, acceder a un nodo, 258

árbol, añadir imágenes para los nodos, 255 árbol, añadir nodos, 254 árbol, añadir y borrar un nodo, 262 árbol, arquitectura, 253 árbol, iniciar, 256 árbol, nodos, 253 árbol, personalizar, 267 árbol, recorrer, 262 árboles de expresiones, 640 archivo de aplicación de ASP.NET, 814 área cliente, 64 área de texto, 1100 argumentos en la línea de órdenes, 73, 1071 arrastrar y soltar, 366 ArrayList, 447 asincrónico, modelo, 912 asociación, 669 ASP, 1111 ASP.NET, 743, 1112 ASP.NET AJAX, 1038 ASP.NET, acceso a los recursos, 808 ASP.NET, arquitectura, 940 ASP.NET, carpetas, 796 ASP.NET, instalación, 1077 aspnet_compiler, 815 aspnet_regiis, 1077 assembly, 11 Assembly, 70 AsyncPostBackErrorMessage, 1041 AsyncPostBackTimeout, 1041 AsyncPostBackTrigger, 1050 ataques de inyección SQL, 519 atributos de anotación de datos, 720, 726 atributos globales de una aplicación, 69 atributos proveedores de valores, 866 Attach, 696, 922 AttachDBFilename, 1072 autenticación ASP.NET, 947 autenticación básica con conexión SSL, 982 autenticación de IIS, 947 autenticación mediante formularios, 954 autenticación Windows, 946 authentication, 947 authorization, 947, 950, 976 AutoEventWireup, 769, 803 AutoPostBack, 804, 805, 1044 AutoResetEvent, 412, 416 autoridad de certificación, 982 autorización, 950 AutoValidate, 96

ÍNDICE

ayuda dinámica, 18

B BackColor, 110 BackgroundWorker, 406 barra de desplazamiento, 25, 44, 202 barra de desplazamiento, eventos, 204 barra de direcciones, 1088 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, 206 barra de título, 44 barras de desplazamiento, 321 barras de herramientas, fusionar, 351, 371 barras, añadir, 320 base de datos, 493 base de datos accedida desde un servicio web, 1011 base de datos basada en servicio, 608 base de datos local, 609 base de datos SQL Server, crear, 599 base de datos, añadir las tablas, 600, 610 base de datos, crear, 608, 1072 base de datos, diagrama visual, 612 base de datos, navegar, 590 bases de datos, mover, 1072 Beep, 338 BeginEdit, 557 BeginInvoke, 402 BeginUpdate, 157, 192 biblioteca de clases, 9 Bin, 796 binary, 916 BinaryExpression, 643 Bind, 774 binding, 900 Binding, 435 BindingComplete, 442 BindingContext, 445 BindingList, 444 BindingList, propiedades, 562 BindingListView, 476, 686 BindingManagerBase, 446 BindingNavigator, 597 BindingSource, 437, 439, 445, 456, 459, 465, 468, 552, 589, 592, 623

1127

BindItem, 774 Bitmap, 294, 320 bloquear los controles, 29 BMP, 319 body, 1089 Bold, 364 border, 1103 borrar datos, 930 borrar registros en una tabla, 497 borrar tabla de la base de datos, 497 borrar un control, 27 borrar un registro, 595 botón borrar, 1099 botón de opción, 24, 186, 1098 botón de pulsación, 23, 56, 82 botón enviar, 1099 botón predeterminado, 83, 85, 175 br, 1090 Brush, 299 bucle de mensajes, 47 buscar en una lista, 192 buscar un registro, 595 Button, 53, 81, 82 ButtonBase, 81

C CA, 982 Cache, 834 caché, 830 caché con SQL Server, 834 cadena de conexión, 720 cadena de consulta, 824 caja de clave de acceso, 1098 caja de diálogo Abrir, 215 caja de diálogo Color, 218 caja de diálogo Fuente, 219 caja de diálogo Guardar, 217 caja de diálogo modal o no modal, 170 caja de diálogo modal, cerrar, 178 caja de diálogo no modal, cerrar, 234 caja de diálogo para mostrar un mensaje, 170 caja de diálogo, crear, 174 caja de diálogo, mostrar, 176 caja de diálogo, recuperar datos, 177 caja de herramientas, 22 caja de imagen, 24, 318 caja de imagen, Image, 323 caja de texto, 24, 82, 1097 caja de texto multilínea, 139

1128


caja de texto, seleccionar el contenido, 90 cajas de diálogo estándar, 214 cajas de diálogo personalizadas, 173 calculadora, 106 calendario, 25 callback, 1024 cambios en los datos, 688 cambios en los datos, notificar, 437 cambios, seguimiento, 710 campos, 493 Cancel, 96 cancelar una llamada asíncrona, 1053 CancelAsync, 410 CancelButton, 175, 368 CancelEdit, 557 CancelEventArgs, 96 CancellationPending, 410 CanRedo, 361 CanUndo, 144, 154, 361 capa de acceso a datos, 545 capa de lógica de negocio, 550 capa de presentación, 540 capa de presentación, desacoplar, 556 capa de presentación, lógica, 553 capas de servicios de la red, 1082 cargar imagen, 322 carpeta virtual, 759 carpetas ASP.NET, 796 cascada, 362 cascada, operaciones en, 701 casilla de verificación, 24, 182, 1098 Category, 379 CellBeginEdit, 556 CellClick, 251 CellDoubleClick, 488 CellEnter, 472 CellFormatting, 245 Cells, 242 CellValidated, 483 CellValidating, 483 center, 1095 CenterParent, 175 centrar ventana, 281 cerrar, 44 cerrar formulario, 129 certificado de cliente, 983, 986 certificado de cliente es rechazado, 988 certificado del servidor, 981, 984 certificados, generar o solicitar, 983 CGI, 1110

ChangePassword, control, 971 ChangeTracker, 690, 711 chat, 935 CheckBox, 53, 81, 182 Checked, 153, 183, 187, 192 CheckedChanged, 185, 191 CheckedListBox, 196 CheckOnClick, 153 CheckState, 183 CheckStateChanged, 186 ciclo de vida de un formulario, 62 ciclo de vida de una aplicación, 70 ciclo de vida de una página web, 802 clase, 57 clase Application, 51 clase Binding, 435 clase Bitmap, 294, 320 clase Button, 53 clase Cache, 834 clase CheckBox, 53, 182 clase CheckedListBox, 196 clase Clipboard, 142 clase Color, 110 clase ColorDialog, 218 clase ColorMatrix, 316 clase ComboBox, 54, 197 clase ConfigurationManager, 845 clase Control, 82 clase Convert, 190 clase ConvertEventArgs, 441 clase CultureInfo, 1114 clase Cursor, 327 clase Cursors, 327 clase DataGridView, 240 clase DataGridViewColumn, 241 clase DataGridViewRow, 241 clase DataRow, 505 clase DataTable, 505 clase DbContext, 675 clase de entidad, 673, 715 clase Debug, 129 clase EventWaitHandle, 416 clase FontDialog, 220 clase Form, 48 clase Graphics, 294 clase GroupBox, 186 clase Image, 320 clase Label, 53 clase ListBox, 54, 191 clase ListView, 267

ÍNDICE

clase Membership, 973 clase MembershipUser, 973 clase MenuStrip, 126 clase Metafile, 320 clase OpenFileDialog, 215 clase Page, 802 clase Panel, 186 clase Point, 55 clase ProgressBar, 206 clase RadioButton, 54, 186 clase Regex, 103, 442 clase ResourceManager, 132 clase ScrollBar, 54, 202 clase seriable, 228 clase Size, 50, 55 clase TextBox, 53, 141 clase TextBoxBase, 143 clase Thread, 398 clase Timer, 223 clase TimeSpam, 224 clase ToolStrip, 121 clase ToolStripButton, 135 clase ToolStripItem, 121 clase ToolStripItemCollection, 127 clase ToolStripMenuItem, 126 clase ToolStripSeparator, 128 clase TrackBar, 205 clase TreeNode, 253 clase TreeView, 252 clase Type, 261 clase UserControl, 375, 996 clase WaitHandle, 415 clases, 9 clases POCO, 716 clave de un nodo, 253 clave pública, 979 Clear, 144, 195 ClearError, 859 clearTimeout, 1031 clic en un botón, 474 clic en un botón, simular, 118, 595 Click, 46, 87 Client certificate revoked, 988 cliente servidor, 741 cliente WCF, 902 ClientScript, 1037 ClientSize, 50 ClientWins, 708 clipboard, 326 Clipboard, 142

1129

Close, 64, 129, 178, 181, 510 CLR, 9 CLS, 6 code, 1091 Code First, 715 ingeniería inversa, 729 Code First, convenciones, 719 CodeFile, 799 código administrado, 11 código intermedio, 9 código no administrado, 11 colección, 162 colección como origen de datos, 444 colección ConstraintCollection, 505 colección ControlBindingsCollection, 590 colección DataColumnCollection, 505 colección DataRelationCollection, 505 colección DataRowCollection, 505, 594 colección DataTableCollection, 505 colección de elementos, 24 colección jerárquica, 25 colección, añadir, 195 colección, borrar, 195 colección, borrar todo, 195 colección, insertar, 195 colocar el control, 29 Color, 110, 218, 297 color, establecer, 110 Color, propiedad, 219, 220 ColorDialog, 214, 218 ColorMatrix, 316 columnas, 493 ColumnCount, 252 Columns, 241 Columns de ListView, 270 COM, 12 COM+, 13 combinar menús, 345 ComboBox, 54, 81, 197 Command, 506, 509 CommandBuilder, 537 CommandField, 884 CommandName, 783 CommonDialog, 214 compilador JIT, 11 Complete, 624 Component, 80 componente, 80 componentes de acceso a datos, 539 concurrencia, 566, 703, 914

1130


ConcurrencyCheck, 705 ConcurrencyMode, 703 conexión abierta/cerrada, 675 conexión, probar, 514 configuración de la aplicación, 67 configuración, fichero, 536, 947 configurar el almacenamiento en caché, 831 configurar IIS, 948 Configuration, 712, 947 ConfigurationManager, 536, 845 confirmar, 172 conjunto de datos, 504 conjunto de datos, crear, 577 Connection, 506 ConnectionStrings, 536, 845 ConstantExpression, 643 Constraint, 505 ConstraintCollection, 505 construir controles, 373 consultas parametrizadas, 856 contenedor, 24 contenedor UpdatePanel, 1048 contenedor UpdateProgress, 1052 Content, 937, 992, 1044 ContentAlignment, 54 ContentPlaceHolder, 991, 1044 ContextMenuStrip, 159, 485 contexto de objetos, 673, 674 contextos de corta duración, 687 contract, 900 contrato, 893 contrato de datos, 898 contrato de servicio, 894 Control, 80, 81, 181 control Button, 750 control Calendar, 751 control ChangePassword, 971 control CheckBox, 748 control CheckBoxList, 748 control CreateUserWizard, 967 control DataGridView, 578, 584 control de usuario, 379 control DetailsView, 1046 control DropDownList, 750 control GridView, 973, 1045 control HyperLink, 751 control ImageButton, 750 control Label, 748 control LinkButton, 750 control ListBox, 749

control Literal, 996 control Login, 958 control LoginName, 971 control LoginStatus, 959 control LoginView, 959 control Panel, 751 control PasswordRecovery, 970 control RadioButton, 749 control RadioButtonList, 749 control RichTextBox, 352 control ScriptManagerProxy, 1048 control SqlDataSource, 1044 control Substitution, 832 control Table, 751 control TextBox, 748 control web para acceso a datos, 838 Control, atributo proveedor de valor, 866 control, borrar, 27 control, mover, 27 Control.DataBind, 771 controlador de eventos, 30, 60 controladores de espera, 415 controladores de eventos, asignar, 61 ControlBox, 175 controles, 45, 1097 controles con enlaces a datos, 752 controles de rango definido, 201 controles de servidor HTML, 745 controles de servidor web, 745 controles de usuario, 746 controles de usuario web, 994 controles de validación, 745, 752, 811 controles HTML, 746 controles para inicio de sesión, 958 controles Strip, 321 controles web, 747 controles, construir, 373 controles, enlazar o vincular con BD, 588 Controls, 55 ControlUpdateMode, propiedad, 435 conversión de datos, 115 conversiones en enlaces, 439 Convert, 88, 190 ConvertEventArgs, 441 ConvertEventHandler, 440 convertir un DateTime en un String y viceversa, 387 convertir un entero en base 10, 8 o 16, en una cadena de caracteres, 191

ÍNDICE

convertir una cadena de caracteres a un entero en base 10, 8 o 16, 190 cookies, 822 coordenadas, 311 coordenadas universales, 331 coordenadas, tipos, 315 coordinador de transacciones distribuidas, 625 Copy, 144 correo electrónico, 1085 cortar, copiar y pegar, 359 Count, 446, 592, 638 crear un adaptador, 572 crear un enlace, 437, 447 crear una aplicación, 16 crear una aplicación MDI, 344 crear una base de datos, 494, 499, 501 crear una caja de diálogo, 174 crear una conexión, 577 crear una imagen a partir de un fichero, 258 crear una tabla, 494 CREATE DATABASE, 494 CREATE TABLE, 494 CreateDatabaseIfNotExists, 723 CreateGraphics, 296 CreateUser, 973 CreateUserWizard, control, 967 credentials, 955 criptografía asimétrica, 979 criptografía simétrica, 979 CRL, 988 CRUD, 719 CSDL, 656 CSS, 993, 1021, 1043, 1104 CSS, atributos, 1104 CSS, class, 1106 CSS, div, 1108 CSS, id, 1107 CSS, link, 1105 CSS, pseudoclases, 1107 CSS, span, 1108 CSS, style, 1104 cuadro combinado, 197 cultura, 1114 CultureInfo, 1114 CurrencyManager, 446, 459 Current, 446, 595 CurrentCell, 251 CurrentCellAddress, 251 CurrentCulture, 1115 CurrentItem, 470, 478

1131

CurrentUICulture, 1115 CurrentValues, 713 Cursor, 328 cursor del ratón, cambiar, 328 Cursors, 327 curvas cardinales y de Bézier, 305 Cut, 144

D Data Mapper, 661 Data Transfer Object, 540 DataAdapter, 506, 580 DataAdapter, métodos, 567 Database, 720 Database First, 664, 715 DataBind, 770, 772 DataBinder, 773 DataBindings, 436, 588 DataColumn, 505, 586 DataColumnCollection, 505 DataContract, 898 DataError, 482 DataGridView, 81, 240, 461, 465, 540, 552, 553, 578, 584 DataGridView, arquitectura, 241 DataGridView, construir, 242 DataGridView, control de errores, 481 DataGridView, iniciar, 244 DataGridView, n.º de filas y columnas, 252 DataGridView, origen de datos, 247 DataGridView, tamaño de las celdas, 250 DataGridView, validar, 566 DataGridView, valor de la celda, 251 DataGridViewColumn, 241 DataGridViewRow, 241 DataMember, 468, 578, 769, 898 DataReader, 506, 510 DataRelationCollection, 505 DataRow, 505 DataRowCollection, 505, 594 DataRowView, 435, 595 DataSet, 435, 566, 586 DataSet, métodos, 567 DataSource, 446, 449, 466, 529, 568, 578, 769 DataSource de DataGridView, 248 DataSourceID, 769 DataSourceObject, 769 DataSourceUpdateMode, propiedad, 435 DataTable, 435, 505, 586

1132


DataTableCollection, 505 DataTextField, 769 DataTextFormatString, 770 DataValueField, 770 DataView, 435, 476 DataViewManager, 435, 586 DateTime, 381, 387 DateTimeFormatInfo, 387 DateTimePicker, 210 DbCommand, 533 DbCommandBuilder, 537 DBConcurrencyException, 575 DbConnection, 533 DbContext, 662, 671, 715 DbDataAdapter, 533 DbEntityEntry, 690, 696, 712, 783, 871 DbProviderFactories, 533 DbProviderFactory, 507, 533 DbQuery, 662 DbSet, 662, 671 DbSet< >, 675 DbSet, 663 DbUpdateConcurrencyException, 703 DCOM, 13 Deactivate, 63 Debug, 129 debugger, 1078 defaultRedirect, 859 definición parcial, 86 delegado, 60, 383 delegado Func, 637 delegados, 401, 635 Delete, 595, 841 DELETE, 497 DeleteCommand, 511 Deleted, 505 DeleteMethod, 780 depuración, 129 depurar, 1069 depurar una aplicación, 33 descripción abreviada, 56, 57 Description, 379 deshacer, 144, 154, 352, 360 deslizador, 205 Detach, 915 DetailsView, 854, 869, 887, 1046 DHTML, 1022 diálogo Acerca de, 179 diálogo modal, cerrar, 178 diálogo no modal, 232

diálogo no modal, cerrar, 234 diálogo, ¿está visible?, 236 diálogo, acceso a la ventana padre, 233 diálogo, ocultar, 234 DialogResult, propiedad de un botón, 177 DialogResult, propiedad de un formulario, 177 DialogResult, valor retornado..., 172 dibujar formas, 341 dirección, 893 dirección de Internet, 1084 dirección IP, 1084 directorio virtual, 759 dirigirse a otra URL, 958 diseño de tipo maestro‐detalle, 466, 598 DisplayMember, 449, 529, 568 Dispose, 50, 178, 181, 518 dispositivos matriciales y vectoriales, 292 DNS, 1083 doble búfer, 337 Dock, 140, 221 documento XML, 1029 DoEvents, 417 DOM, 1022 dominio, 1083 DoubleBuffered, 337 DoWork, 407 DrawArc, 304 DrawBezier, 305 DrawCurve, 305 DrawEllipse, 303 DrawLine, 302 DrawPie, 304 DrawPolygon, 304 DrawRectangle, 302 DROP TABLE, 497 DropCreateDatabase..., 723 DropDown, 161 DropDownItems, 162 DropDownList, 769 DropDownOpening, evento, 152 DropDownStyle, 197 DTC, 625

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, 908

ÍNDICE

ejecutar, 22 Elapsed, 224 Elapsed, evento, 223 elemento actual, 470, 478 elemento de un menú, marcar, 154 eliminar filas, 699 eliminar un recurso, 131 EM_FORMATRANGE, 391 e‐mail, 1085 Email, 977 EnableAutoDragDrop, 366 Enabled, 153 EnablePageMethods, 1059 EnablePartialRendering, 1041 EndEdit, 558 EndInvoke, 402 endpoint, 900 EndUpdate, 157, 192 enfocar un componente, 89 enlace a colecciones, 446 enlace con otros controles, 439 enlace de datos .NET, 427, 434, 585 enlaces, 893, 901, 1093 enlaces de datos en ASP.NET, 771 Enter, 90 entidad, 668 Entity Client, 658 Entity Framework, 656 Entity SQL, 658 EntityCollection, 676 EntityDataSource, 847 EntityDataSourceView, 861 EntityKey, 710 EntitySet, 710 entorno de desarrollo integrado, 1065 entorno de ejecución, 9 entrada de datos, 1097 Entries, 708 Entry, 690, 712, 783, 871 enumeración ContentAlignment, 54 enumeración Keys, 130 error, notificar, 97 errores en una página ASP.NET, controlar, 859, 873 errores, control en DataGridView, 481 ErrorProvider, 97 ErrorText, 484 escribir datos en una tabla, 496 espacios de nombres, 32 especificación de lenguaje común, 6

eSQL, 658 esquinas redondeadas, 999 estado de aplicación, 828 estado de sesión, 828 estado de un hilo, 399 estado de una página, 821 estado de vista, 825 estado del modelo, 785 estilo del texto, 364 estructura de una aplicación gráfica, 48 etiqueta, 23, 54 etiquetas, 82 etiquetas HTML, 1089 Eval, 773 EventArgs, 384 EventHandler, 60, 405 evento, 46, 62 evento ApplicationExit, 71 evento CellBeginEdit, 556 evento CellFormatting, 245 evento Click, 87 evento Enter, 90 evento FormClosing, 365, 580 evento Idle, 71 evento KeyPress, 87 evento Load, 89, 579 evento MouseClick, 91 evento Paint, 292 evento PreInit, 1002 evento PrintPage, 358 evento PropertyChanged, 431 evento Selecting, 856 evento SelectionChange, 363 evento Shown, 89 evento TextChanged, 87, 430 evento ThreadException, 71 evento ThreadExit, 71 evento UserDeletingRow, 555 evento Validated, 98 evento Validating, 97 evento, suscribir, 30 eventos, 30, 59, 383 eventos del ratón, 332 eventos del teclado, 86 eventos KeyDown, KeyUp y KeyPress, 94 eventos más comunes, 60 eventos, implementar, 383 eventos, lista, 30 eventos, responder, 86 EVENTVALIDATION, 827

1133

1134


EventWaitHandle, 412, 416 ExecuteNonQuery, 509 ExecuteReader, 509 EXIF, 319 Exit, 51 explorador de bases de datos, 501 expresión de consulta, 640, 644 expresión de consulta, compilación, 647 expresiones de enlace de datos, 772 expresiones lambda, 635 expresiones regulares, 100, 442 Expression, 641, 643 extremo, 893

F factoría, 533 fecha y hora, 25 fecha y hora, formato, 381 fechas, 209 fichero de configuración, 535, 536, 845, 947 fichero de recursos, 133, 1116 fila añadir, 595 fila nueva, 594 filas, 493 FileDialog, 214 FileName, 217 FileUpload, 916 Fill, 512, 567, 579 Filter, 217 FilterIndex, 217 filtrado, 881 filtro de nombres de fichero, 217 finalizar la ejecución, 22 finally, 515 Find, 253, 352, 595 FindString, 157, 192 firma digital, 980 FixedDialog, 175 FlatStyle, 183, 187 flow layout, 800 FlowLayoutPanel, 210, 211 Fluent API, 727 foco, 89, 227, 595 Focus, 89, 191, 595 FolderBrowserDialog, 215 font, 1089 Font, 54, 109, 301 FontDialog, 215, 220 foreach, 229

ForeColor, 110 FOREIGN KEY, 585 form, 816, 1096 Form, 48, 81 Format, 88 Format de String, 381 Format, evento, 436, 439 FormatException, 88 formatos de fechas y horas, 381 FormBorderStyle, 66, 175 FormClosed, 63 FormClosing, 63, 365, 580 FormClosing, evento, 178 FormsAuthentication, 958 formulario Acerca De, 327 formulario activo, 62, 346 formulario cargar, 579 formulario cerrar, 580 formulario hijo, 350 formulario MDI, 348, 615 formulario modal, 62 formulario no modal, 62 formulario propietario, 180 formulario web, diseño, 753 formulario, BackgroundImage, 323 formulario, cerrar, 365 formulario, posición inicial, 63 formularios, 45, 1096 formularios hijo, 346 formularios hijo abiertos, 345, 362 formularios web, 791, 816 formularios, colección, 62 formularios, comunicación entre, 232 FormView, 783, 876 from, 638, 646 FromArgb, 110 FromFile, 323 FromImage, 310 ftp, 1084, 1086 fuente, establecer, 109 FullPath, 253 Func, 637 funciones, representar, 328 fusionar barras de herramientas, 371

G GDI+, 291 GDI+, servicios, 293 generador de código nativo, 12

ÍNDICE

generar código JavaScript, 1034 gestión de datos, 741 gestor de recursos, 1119 get, 816 GetAllUsers, 976 GetCurrent, 945 GetCustomAttributes, 70 GetDatabaseValues, 713 getElementsByTagName, 1029 GetExecutingAssembly, 70 GetObject, 68, 132 GetString, 68, 132, 1121 GetType, 261 GetView, 862 GIF, 319 Global.asax, 814 globalización, 1113 Gopher, 1084 GotFocus, 227 gráficos, 291 gráficos en un documento HTML, 1094 gráficos vectoriales, 293 Graphics, 296, 340 GraphicsPath, 302, 306 grid layout, 800 GridView, 777, 882, 1045 GridView, AllowSorting, 881 GridView, SelectedValue, 884 group, 649 group … by, 638 GroupBox, 81, 186, 189 grupo de aplicaciones, 763, 942 grupos de noticias, 1086 guardar documento, 355 guardar una aplicación, 32 guardar una imagen, 324

H habilitar o inhabilitar los elementos de un menú, 152 Handled, 87 HashSet, 718, 733 HasMorePages, 359 head, 1089 height, 1095 herramientas, caja, 22 hidden, 825 Hide, 64, 234 hilo en segundo plano, 400

1135

hilos, 393 hilos accediendo a controles de los formularios, 401 hilos secundarios, detener de forma controlada, 417 hilos, cancelar, 410 hilos, estados, 400 hilos, mecanismos de sincronización, 411 hipertexto, 1093 hn, 1090 hoja de estilo, 993, 1043, 1104 hr, 1090 href, 1093 HScrollBar, 81, 202 html, 8, 1088, 1089 HTML, controles, 745, 746 HtmlInputHidden, 825 HTTP, 8, 821, 1085 HTTP 403.13, 988 HTTP get, 817 HTTP post, 818 HttpClientCertificate, 983 HttpContext, 820, 945 HttpCookie, 822 http‐equiv, 937 HTTPS, 982, 986 HttpServerUtility, 820 HyperLink, 858, 872

I IBindingList, 435, 437, 444, 452, 474 IBindingListView, 475 Icon, 29, 65 icono de la aplicación, 29 IDatabaseInitializer, 723 Identity, 723, 916, 944 IDictionary, 862 idioma, 1114 IDisposable, 518 Idle, 71 IEditableObject, 557 IEnumerable, 445, 639, 653 iframe, 1095 IgnoreCase, 1121 IIS, 760, 939 IIS 7.0, certificados, 983 IIS, instalar, 1112 IList, 435, 444 Image, 320

1136


Image, propiedad, 133 ImageIndex, 255, 256 ImageList, 255 imagen, 324, 1099 imagen en un botón, 130 imagen, cargar, 322 imágen, FromFile, 258 imagen, guardar, 324 imágenes, 294 imágenes en un documento HTML, 1094 imágenes, lista de, 255 Images, 255 ImageStream, 256 ImageTransparentColor, 133 IMAP, 1084 img, 1094 imprimir documento, 357 incoherencia de accesibilidad, 230 Increment, 207 Inherits, 799 iniciadores de colecciones, 634 iniciadores de objetos, 633 iniciar una lista desplegable, 279 inicio de sesión, 956 Init, 803 InitialDirectory, 217 Initialize, 725 innerHTML, 1030 INotifyPropertyChanged, 431, 453 input, 1097 Insert, 195, 841, 861 INSERT, 496 insertar filas, 695 insertar filas, EntityDataSource, 859 insertar filas, modelo de enlace, 873 InsertCommand, 511 Inserting, 864 InsertItemTemplate, 877 InsertMethod, 784 interceptar la tecla pulsada, 92 interface, 371 interfaces gráficas, 7, 38 interfaz, 45 interfaz de múltiples documentos, 343 interfaz fluida, 727 interfaz IEditableObject, 557 Interlocked, 412 internacionalización, 1113 internal, 259 Internet, 1081

Internet Explorer, 1087 into, 651 intranet, 1082 introducir datos, 480 Invalidate, 293 InvariantCulture, 1116 Invoke, 402, 404 InvokeRequired, 403 inyección de código SQL, 519 IPrincipal, 944 IQueryable, 639, 653, 693 IRC, 935 IsAlive, 400 ISAPI, 1111 IsBackground, 400 IsCallback, 1036 IsClientScriptBlockRegistered, 1037 IsDispose, 234 IsDisposed, 181 IsInAsyncPostBack, 1041 IsMatch, 103, 442 IsMDIContainer, 344 IsOnline, 977 IsPostBack, 777, 803 IsStartupScriptRegistered, 1037 IsValid, 803 it, 661, 853 Italic, 364 Item, 229, 774 ItemClicked, 486 Items, propiedad, 157, 192 ItemType, 774

J JavaScript, 1021 JavaScript, depurar código, 1078 JavaScript, eventos, 1035 JavaScript, fichero .js, 1035 JavaScript, generar código, 1034 JIT, 11 join, 638, 650 Join, 400 JPEG, 319 jQuery, 813, 963 JSON, 1027

K Key, 229

ÍNDICE

KeyChar, 87 KeyDown, 86, 94 KeyPress, 86, 92, 185 KeyPressEventArgs, 87 Keys, 94, 130 KeyUp, 86, 94 KeyValuePair, 229

L label, 1101 Label, 53, 81, 82 LabelEdit, 253, 266 Language, 800, 1116 LargeChange, 202 LastActivityDate, 977 LayoutMdi, 347, 362 LayoutMode, 29 Lazy Loading, 662 lector de datos, 510 Left, 65 let, 652 li, 1092 Like, 595 líneas de ayuda, 29 LINQ, 631 LINQ to Entities, 657 Linux, 1123 List, 447 lista, 24, 191 lista de formularios abiertos, 362 lista de los eventos, 30 lista de tareas, 134 lista desplegable, 24, 197, 1100 lista desplegable, añadir elemento, 200 lista desplegable, borrar elemento, 200 lista desplegable, diseñar, 198 lista desplegable, estilo, 197 lista desplegable, iniciar, 199 lista, acceder a sus elementos, 194 lista, borrar elemento, 196 lista, colección de elementos, 195 lista, columnas, 191 lista, diseño, 193 lista, elemento seleccionado, 192 lista, iniciar, 194 lista, ordenar, 193 lista, selección múltiple, 195 listas desplegables en menús, 155 listas HTML, 1092

1137

ListBox, 54, 81, 191, 449 ListBox, vincular con DataSet, 528, 568 ListChanged, 562 ListControl, 81 ListView, 267, 877 ListView, ejemplo, 271 ListViewItem, 270 Literal, 996 llamada asíncrona, 402 llamada síncrona, 402 Load, 89, 579, 769, 803 LoadFile, 352 LocalDB, 1074 localhost, 817 Localizable, 1116 localización, 1113 Location, 55, 126, 221 LocationChanged, 65, 221 lock, 413 lógica de negocio, 741 Login, control, 958 LoginName, 998, 1005 LoginName, control, 971 LoginStatus, 998, 1005 LoginStatus, control, 959 LoginView, 997 LoginView, control, 959 logo, 367

M maestro‐detalle, 466, 598, 599 maestro‐detalle, aplicación web, 886 mail, 1085 Main, 49 MainMenuStrip, 126, 344 manifiesto, 11 ManualResetEvent, 412 mapa de bits, 318 MapPath, 820 máquina virtual, 11 marcador de posición de contenido, 991, 997, 1007 marcas de tiempo, 915 marco, 24 marco con título, 279 marcos en páginas HTML, 1095 máscaras, 1000 MaskedTextBox, 81, 104, 380 MasterPage, 1043

1138


MasterPageFile, 991 Match, 103 Matches, 103 Matrix, 313 Max, 638 MaxDropDownItems, 197 maximizar, 44 Maximum, 201 MDI, 343, 366 MdiChildren, 346 MdiLayout, 347 MdiWindowListItem, 345 Media, 338 MemberExpression, 643 Membership, 971, 976 MembershipUser, 976 mensaje, mostrar, 129 mensajes, 13 menú, 123 menú contextual, 159, 485 menú de control, 44 menú dinámico, 161 menú Ventana, 345, 347, 362 menú, añadir, 126 menú, controlador de eventos, 128, 148 menú, elementos, 127 menú, señalar elemento, 153 menú, separador, 128 menús, 121 menús en páginas web, 994, 1016 menús, combinar, 345 menús, diseño, 124 menús, líneas de separación, 125 MenuStrip, 126, 321 Merge, 351 MergeAction, 345, 351 MergeIndex, 345, 351 MessageBox, 129, 170 MessageBox.Show, 429 meta, 937 Metafile, 320 metarchivo, 294 method, 816, 1097 MethodCallExpression, 643 MethodInvoker, 405 método Add, 55, 595 método conducido por un evento, 86 método DataBind, 772 método Delete, 595 método Dispose, 50

método Exit, 51 método Fill, 579 método Find, 595 método Focus, 595 método Insert, 861 método NewRow, 594 método PerformClick, 595 método Print, 358 método Select, 89, 595 método SetToolTip, 57 método Update, 580 métodos de página, 1058 Métodos del generador de consultas, 658 métodos extensores, 634 Microsoft .NET, 4 Microsoft Access, 508 Microsoft.ACE.OLEDB, 509 Microsoft.Jet.OLEDB, 509 MiddleCenter, 54 miembro protegido, 50 Min, 638 minimizar, 44 Minimum, 201 modal o no modal, 170 Model First, 665, 715 ModelMethodContext, 880 modelo de datos, 459, 462 modelo de enlace de ASP.NET, 775, 865 modelo de entidades, 656 ModelState, 785 Model‐View‐Controller, 1079 Model‐View‐ViewModel (MVVM), 1079 módem, 1085 modificadores de tamaño, 27 modificar datos, 688 modificar datos en una tabla, 496 modificar una base de datos, 593 Modified, 354, 365, 505 ModifierKeys, 94 Modifiers, 369 Monitor, 411 Mono, 1123 MonthCalendar, 209 mosaico, 362 mostrar un mensaje, 129 MouseClick, 91 MouseDown, 332 MouseMove, 332 MouseUp, 332 mover el control, 27

ÍNDICE

MSIL, 9 MSL, 657 MultiLine, 139 multiple, 1101 Mutex, 72, 412

N name, 1093, 1097 Name, 50, 126, 400 navegar por los elementos de una lista, 471 nemónico, 85, 129 NetworkService, 764, 789 NewRow, 594 news, 1086 ngen.exe, 12 N‐Layer architecture, 914 Node, 261 Nodes, 253 nodo seleccionado, 263 nodo, añadir, 263 nodo, borrar, 266 nodos, borrar todos, 266 NT AUTHORITY\Servicio de Red, 808 N‐Tier architecture, 914 nuevo documento, 353 NuGet, 716

O Object, 80 ObjectCollection, 195 ObjectContext, 665 ObjectDataSource, 924, 925 ObjectQuery, 658 ObjectStateEntry, 689, 710 ObjectStateManager, 689, 710 objeto de negocio, 925 objeto Response, 1019 objetos como orígenes de datos, 459 objetos de negocio, 542 objetos de sincronización, 411 OdbcConnection, 507 OdbcDataAdapter, 511 ol, 1092 OleDbConnection, 507 OleDbDataAdapter, 511 OleDbDataReader, 510 onchange, evento, 1028 onreadystatechange, 1025

OpenFile, 217, 218 OpenFileDialog, 215, 218 OpenForms, 62 operadores de consulta, 638 OperationContract, 894 optgroup, 1101 OptimisticConcurrencyException, 703 option, 1100 OracleConnection, 507 OracleDataAdapter, 511 orden, 511 orden de tabulación, 1100 orden parametrizada, 523 orden SQL, escribir una nueva, 621 orden Tab, 55, 90, 279 ordenación, 881 orderby, 638, 646 organizar iconos, 362 Orientation, 205 origen de datos, 444, 462, 601 orígenes de datos ADO.NET, 445, 586 orígenes de datos, ventana, 462 OriginalValues, 713 ORM, 655, 716 out, 73 OutputCache, 831 override, 50 OwnedForms, 181 OwnedWindows, 64 Owner, 65, 181, 232, 233

P p, 1090 padre‐hija, tablas, 599 Page, 802, 944, 1037 Page.DataBind, 771 Page_Error, 859 Page_evento, 769, 803 PageMethods, 1058 PageRequestManager, 1053 PageSetupDialog, 215, 392 página de contenido, 989 página de inicio de sesión, 956 página maestra, 989 página principal, 989 página web, 799, 1088 página web ASP.NET, 757 página web dinámica, 1110 página web, modelo de ejecución, 765

1139

1140


paginación, 881 páginas ASP, 1111 páginas web, publicar, 759 Paint, 292, 296, 297 Panel, 24, 186, 321, 367 panel de dibujo, 339 pantalla de presentación, 74 ParameterExpression, 643 Parameters, 523 parámetro oculto, 825, 1099 parámetros en órdenes SQL, 523 parcial definición, 86 Parse, 115 Parse, evento, 436, 439 partial, 86 pasos, 237 passport, 947 PasswordChar, 174 PasswordRecovery, control, 970 Paste, 144 patrón de diseño Factory, 533 patrones de diseño, 661 Pen, 298 perfiles, 1003 PerformClick, 118, 474, 595 PerformStep, 207 PictureBox, 81, 321 plantilla, 773, 778 plantilla de formularios, 366 Play, 338 PlaySync, 338 PNG, 319 POCO, 716 Point, 55, 300 pool de conexiones, 516, 946 POP 3, 1084 portapapeles, 142, 326 posición de un componente, modificar, 221 posición inicial del formulario, 63 posición, conservar, 221 Position, 446, 592 post, 816 postback, 1023, 1049 postbacks asíncronos, 1041 PostgreSql, 508 precompilar la aplicación ASP.NET, 815 PreInit, 803, 1002 PreRender, 803 presentación, 741 PRIMARY KEY, 495

principal, 939 Print, 358 PrintDialog, 215, 392 PrintDocument, 357, 392 PrintPage, 358 PrintPreviewDialog, 392 Priority, 400 problemas de concurrencia, 566 procedimiento almacenado, 524, 541 producto cartesiano, 650 Profile, 1003 ProgressBar, 81, 206 ProgressChanged, 409 ProgressPercentage, 409 PropertyChanged, 431 PropertyManager, 446 propiedad, 668 propiedad autoimplementada, 633 propiedad cambió, notificar, 431 propiedad Cancel, 96 propiedad ClientSize, 50 propiedad Controls, 55 propiedad Count, 592 propiedad Cursor, 328 propiedad DataBindings, 588 propiedad DataMember, 578 propiedad DataSource, 578 propiedad Font, 54 propiedad Icon, 29 propiedad Location, 55 propiedad Modified, 354, 365 propiedad Name, 50 propiedad Position, 592 propiedad ReadOnly, 109 propiedad Size, 50, 55 propiedad TabStop, 55 propiedad TanIndex, 55 propiedad Text, 50, 54 propiedad TextAlign, 54, 109 propiedades, 27 propiedades de navegación, 674 propiedades, añadir a un control, 376, 390 propiedades, atributos, 379 propiedades, clasificación, 379 propiedades, control de usuario, 376 propietario de un diálogo, 232 protected, 50 protocolo, 1082 protocolo de transferencia de ficheros, 1086 proveedor de datos, 506

ÍNDICE

proveedor de entidades, 658 proveedores de LINQ, 653 providers, 971 proyecto, 16 publicar páginas web, 759 puntero, 22 punto de inserción, 89 punto final, 893

Q QueryString, atributo proveedor de valor, 866

R RAD, 799 RadioButton, 54, 81, 186 RangeValidator, 811 raster, dispositivos, 292 Read, 510 ReaderWriterLock, 412 ReadOnly, 109 readyState, 1025 recorte, área de, 307 Rectangle, 300 recursos, 130, 1116 recursos de una aplicación, 68 recursos embebidos, 132 recursos vinculados, 132 recursos, acceder, 1119, 1120 Redirect, 821, 1019 RedirectFromLoginPage, 958 Redo, 352 reescritura de la URL, 824 refactorización, 375 referencias, 19 referencias culturales, 1114 reflexión, 70 Refresh, 451, 706 Regex, 103, 442 región, 306 región de recorte, 307 región no válida, 293 RegisterClientScriptBlock, 1037 RegisterStartupScript, 1037 registros, 493 rehacer, 352, 360 rejilla, 578 rejilla de ayuda, 29 Reload, 707, 713

reloj, 222 reloj despertador, 165, 236 Remove, 195, 229 RemoveAt, 195 RemoveAt, colección, 165 rendimiento del servidor, 830 repintar una ventana, 293 Replace, 103 ReportProgress, 409 representar funciones, 328 Request, 820 RequiredFieldValidator, 811 reset, 1099 Reset, 416 Resize, 221 resolución gráfica, 292 ResourceManager, 68, 132, 1119, 1120 Response, 820, 1019 Response.Redirect, 958 responseText, 1025 responseXML, 1025 RestoreBounds, 65 RestoreDirectory, 217 reutilización, 373 RevertMerge, 351 RGB, 110 RichTextBox, 81, 151, 352, 391 Row, 563 RowCount, 252 Rows, 241 RTF, 352 Run, 47 RunWorkerAsync, 407 RunWorkerCompleted, 407, 409 ruta del sitio web, 820

S SaveChanges, 675 SaveFile, 352 script callbacks, 1032 ScriptManager, 1041 ScriptManagerProxy, 1048 ScriptPath, 1041 scripts, 1041, 1111 ScriptService, 1056 Scroll, 204 ScrollBar, 54, 81, 202 ScrollBars, 139 sección crítica, 413

1141

1142


seguimiento de los cambios, 710 seguridad, 978 seleccionar datos de una tabla, 497 seleccionar el contenido de una caja de texto, 90 seleccionar el texto de una caja, 227 seleccionar un objeto, 28 select, 638, 646, 1100 Select, 89, 91, 144, 595, 841, 856 SELECT, 497 SelectAll, 91, 144, 227 SelectCommand, 511 selected, 1101 SelectedCells, 242 SelectedColumns, 241 SelectedImageIndex, 255, 256 SelectedIndex, 157, 192, 193, 198, 770 SelectedIndexChanged, 157, 684, 685 SelectedItem, 157, 192, 198, 199, 770 SelectedItems, 195 SelectedNode, 253, 263 SelectedRows, 241 SelectedRtf, 359 SelectedText, 91, 143, 359 SelectedValue, 569, 770 Selecting, 856 SelectionAlignment, 364 SelectionChange, 363 SelectionFont, 364 SelectionLength, 91, 144 SelectionStart, 91, 143 SelectMethod, 779 Semaphore, 412 sentencia using, 518 señalar un elemento de un menú, 153 separadores, 125 seriar/deseriar un árbol, 290 Server, 820, 859 Services, 1041, 1056 servicio, 891 servicio de conexiones, 516, 946 Servicio de red, 764, 789, 946 servicio de suscripciones, 971 servicio WCF, 893 servicio WCF, configuración, 900 servicio web, 8 servicio web, acceso a BD, 1010 servicios de IIS, 760 servicios de Internet, 1085 Servicios de objetos, 658

servicios web con AJAX, 1054 servicios web y LINQ, 912 servicios web, ejecución asíncrona, 908 servidor de nombres, 1084 servidor SMTP de IIS, 968 servidor web, 1112 servlets, 1112 Session, 820 Set, 416, 699 SetCacheability, 833 SetClip, 307 SetError, 98 SetInitializer, 725, 731 setTimeout, 1031 SetToolTip, 57 ShortcutKeys, 130 Show, 64, 170, 173, 181, 232 ShowColor, 220 ShowDialog, 62, 173, 177, 181, 215 ShowHelp, 219 ShowInTaskbar, 63, 65 Shown, 63, 89 ShowNodeToolTips, 267 ShowPlusMinus, 267 ShowReadOnly, 217 ShowRootLines, 267 simultaneidad, 703, 914 simultaneidad optimista, 574 sincronización, 937 sistema de nombres de dominio, 1083 sitio web, 759 sitio web, reglas de acceso, 974 sitios web, administración, 961 size, 1089 Size, 50, 55, 221, 301 SizeChanged, 221 skins, 1000 Sleep, 400 SmallChange, 202 SMTP, 968, 1085 SOAP, 889 SOAP, mensaje, 892 SolidBrush, 299 solución, 16 sonido, 338 Sort, 193, 198 SortedList, 227, 229 SoundPlayer, 338 SplashScreen, 74 SplitContainer, 271

ÍNDICE

SQL, 494 Sql Server, 508, 516 SQL Server, 809 SQL Server 2012 Express, 1071 SQL Server Management Studio Express, 1074 SqlCacheDependency, 835 SQLCMD, 1072 SqlCommand, 509 SqlCommandBuilder, 574 SqlConnection, 507 SqlDataAdapter, 511, 567 SqlDataReader, 510 SqlDataSource, 838, 1044 src, 1094, 1096 SSDL, 656 SSL, 950, 981, 987 Start, 398, 400 StartPosition, 63 StartupPosition, 65 State, 713 status, 1025 StatusBar, 81 StatusStrip, 137 statusText, 1025 Step, 207 StoreWins, 707 Strikethru, 364 subdominio, 1083 submenú‐menú contextual, 161 submenús, 127 submit, 1099 Substitution, 832 Sum, 639 superficie de dibujo permanente, 310 suplantación de identidad, 952 SupportsFiltering, 474 SupportsSorting, 474 suscribir evento, 30 SvcUtil.exe, 905 System.ComponentModel, 81 System.Data.Linq, 631 System.Drawing, 50, 54, 82, 294 System.Linq, 631 System.Linq.Expressions, 642 System.Media, 338 System.Threading, 394 system.web, 947 System.Web, 820 System.Windows.Forms, 49, 80 System.Windows.Forms.Design, 81

1143

SystemSound, 338 SystemSounds, 338

T Tab, 55 TabControl, 208 tabindex, 1100 TabIndex, 55, 89, 126 tabla, 24, 239, 493, 1103 tabla con cabecera de filas, 279 tabla, construir, 242 tabla, iniciar, 244 table, 1103 table dinámico, 1025 TableAdapterManager, 585 TableLayoutPanel, 211 tablero de dibujo, 339 TabStop, 55 Tag, 489 TakeWhile, 639 tamaño de los controles, 27 tamaño de un componente, modificar, 221 TCP/IP, 1082 td, 1103 tecla de acceso, 56, 85 tecla pulsada, interceptar, 92 teclas, 94 teclas Alt, Control o Shift (Mayús), 94 telnet, 1085 temas, 1000 temporizador, 25, 222, 1031 Text, 50, 54, 88, 198 TextAlign, 54, 109 textarea, 1100 TextBox, 53, 81, 82, 141 TextBoxBase, 81, 143 TextBoxEx, 374 TextChanged, 87, 189, 430 texto seleccionado, 152 th, 1103 theme, 1000 Thread, 398 ThreadException, 71 ThreadExit, 71 ThreadStart, 398 ThreadState, 400 ThreeState, 183 Tick, evento, 223 TickFrequency, 205

1144


ticks, 237 TickStyle, 205 TIFF, 320 Timer, 223, 412, 1054 TimeSpam, 224 tip, 57 tipo anónimo, 632 tipo de un objeto, 261 tipo enumerado, 112 tipo implícito, 632 tipografía, 294 tipos de enlace, 436 tipos SQL, 495 title, 1089 ToDouble, 88 ToInt32, 190 ToList, 676 ToolBar, 81 ToolStrip, 121, 134 ToolStripButton, 135 ToolStripComboBox, 155 ToolStripItem, 121 ToolStripItemCollection, 127 ToolStripManager, 351 ToolStripMenuItem, 126, 486 ToolStripSeparator, 128 ToolTip, 57 Top, 65 Topmost, 65 ToString, 191, 228, 260 ToString de DateTime, 381 ToUpper, 191 tr, 1103 TrackBar, 81, 205 transacción, 525, 624 transacciones explícitas, 530 TransactionScope, 526, 624 Transform, 315 transformación, 312, 329 transformación global, 314 transformación local, 315 transformaciones de color, 316 trazado, 306 TreeNode, 253 TreeView, 252 trigger, 1049 Triggers, 1050 TryParse, 115 type, 1097 Type, 261, 465, 552

typeof, 465, 552

U Unchanged, 505 Underline, 364 Undo, 144, 154, 352, 361 unidad de medida, 297 UNIQUE, 495 Unload, 803 Update, 513, 580, 624, 841 UPDATE, 496 UpdateCommand, 511 UpdateMethod, 780 UpdateMode, 1051 UpdatePanel, 1048 UpdateProgress, 1052 URL, 743, 1092 URL, dirigirse a otra, 958 USENET, 1085, 1086 User, 944 UserControl, 375 UserDeletingRow, 555 UserName, 977 using, 518, 624 usuario ASPNET, 946 usuario Servicio de red, 946

V validación, 785, 811 validación de datos, DataGridView, 483 validación de los datos, 617 validación discreta, 813 validación personalizada, 104 validación, controles, 745 validar datos, 442 validar un campo de texto, 93 Validate, 617 Validated, 96 Validating, 96 ValidationAttribute, 726 ValidationSummary, 811 value, 1099 Value, 201, 207, 229, 236 Value Object, 540, 661 value provider attributes, 866 ValueChanged, 204 ValueMember, 529, 569 var, 632

ÍNDICE

varbinary, 916 variable fuertemente tipada, 774 variable, declaración implícita, 632 VaryByParam, 831 ventana, 43, 45 ventana de aplicación, 344 ventana de documento, 344 ventana, centrar, 281 Ventana, menú, 347, 362 ViewState, 802, 826 ViewState, deshabilitar, 836 ViewState, mecanismo, 836 vista de colección, 476 vista del control, 862 vista, buscar sus elementos, 479 vista, filtrar sus elementos, 479 vista, ordenar sus elementos, 478 Visual Studio, 15 Visual Studio .NET, 13 VScrollBar, 81, 202

W WaitAll, 415 WaitAny, 415 WaitHandle, 413, 415 WaitOne, 415 WCF, 891 web, 1086 web, controles, 745 Web.config, 947

WebForm_DoCallback, 1033 webMethod, 1059 WebResource.axd, 1034 where, 638, 646 WhereParameters, 856 width, 1095 Windows Forms, 7, 38, 79 WindowsFormsApplicationBase, 74 WindowsIdentity, 945 WindowState, 66, 344 WordWrap, 139 WorkerReportsProgress, 409 WorkerSupportsCancellation, 410 world wide web, 1086 WPF, 7, 38, 79 WriteLine, 129 WSDL, 890 www, 1086

X XCOPY, 1072 XHTML, 1021, 1110 XML, 7, 1029, 1109 XMLHTTP, 1024 XMLHttpRequest, 1024

Y yield return, 648

1145

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 C# 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 MS Visual C# 4Ed"

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 MS Visual C# 4Ed

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