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: editorial@ra-ma.com
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 ................................

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








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

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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<T, TResu> .........................................................................
Operadores de consulta ..................................................................................
Árboles de expresiones lambda ......................................................................
EXPRESIONES DE CONSULTA......................................................................
Compilación de una expresión de consulta ....................................................
Sintaxis de las expresiones de consulta ..........................................................
Cláusula group ..........................................................................................
Productos cartesianos ................................................................................
Cláusula join .............................................................................................
Cláusula into .............................................................................................
Cláusula let................................................................................................
PROVEEDORES DE LINQ ...............................................................................
ENTITY FRAMEWORK ...................................................................................
MARCO DE ENTIDADES DE ADO.NET ........................................................
Consultar un modelo de objetos .....................................................................
ACCESO A UNA BASE DE DATOS ................................................................
Conectarse a la base de datos .........................................................................
Generar el modelo de entidades .....................................................................
Las clases de entidad y el contexto de objetos ...............................................
Propiedades de navegación ............................................................................
Mostrar datos en una interfaz gráfica .............................................................
Una aplicación con interfaz gráfica................................................................
Vincular 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

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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


ENCICLOPEDIA DE MICROSOFT VISUAL C#

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

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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


ENCICLOPEDIA DE MICROSOFT VISUAL C#

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

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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.

APÉNDICE A: HERRAMIENTAS DE DESARROLLO

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

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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.

APÉNDICE A: HERRAMIENTAS DE DESARROLLO

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

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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

APÉNDICE A: HERRAMIENTAS DE DESARROLLO

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

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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

APÉNDICE A: HERRAMIENTAS DE DESARROLLO

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

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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.

APÉNDICE A: HERRAMIENTAS DE DESARROLLO

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

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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

APÉNDICE A: HERRAMIENTAS DE DESARROLLO

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

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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

APÉNDICE B: PÁGINAS 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

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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

APÉNDICE B: PÁGINAS WEB

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

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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.

APÉNDICE B: PÁGINAS WEB

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 (<texto etiqueta>) y otra de fin (</texto etiqueta>) 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.
<font size="10">Usuario:</font>

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:
<html>
<head>
<title>Título del documento</title>
</head>
<body>
Cuerpo del documento: texto, imágenes, sonido y órdenes HTML
</body>
</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

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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):
<html>
<head>
<title>Título del documento</title>
</head>
<body>
<h1>Ejemplo de un documento HTML</h1>
<hr>
<h3>El cuerpo del documento puede contener:</h3>
<h4>Texto, imágenes, sonido y órdenes HTML</h4>
<p>
HTML es un lenguaje utilizado para desarrollar páginas y
documentos web.
<p>
A diferencia de los lenguajes convencionales, HTML utiliza
una serie de etiquetas especiales intercaladas en un
documento de texto sin formato.

APÉNDICE B: PÁGINAS WEB

1091

<br>
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.
</p><hr>
</body>
</html>

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:
<font size=2 face="Arial">
Tipo de fuente Arial, tamaño 2; <b>negrita</b> y <i>cursiva</i>
</font>

1092

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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.
<li>Texto <li>Imágenes <li>Sonido <li>Órdenes HTML

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

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

APÉNDICE B: PÁGINAS WEB

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):
<html>
<head>
<title>
Título del documento
</title>
</head>
<body>
<h1>Ejemplo de un documento HTML</h1>
<hr>
<h3>El cuerpo del documento puede contener:</h3>
<h4>
<ol><li>Texto <li>Imágenes <li>Sonido <li>Órdenes HTML</ol>
</h4>
<p>
<a name="Definición">HTML</a> es un lenguaje utilizado para
desarrollar páginas y documentos web.
<p>
A diferencia de los lenguajes convencionales, HTML utiliza
una serie de etiquetas ASCII especiales intercaladas en un
documento escrito en ASCII.
<br>
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.
<p>

1094

ENCICLOPEDIA DE MICROSOFT VISUAL C#

Para editar una página <a href="#Definición">HTML</a> y
posteriormente visualizarla, todo lo que necesita es un
editor de texto ASCII y un explorador web.
<hr>
Haga clic <a href="http://www.sitio_web/ini/inicio.html">
aquí</a> para ir a la página de inicio
</body>
</html>

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:
<html>
...
<hr>
<center>
El profesor Ceballos resolviendo dudas a sus alumnos.
<img src="ceballos.jpeg" align=bottom
alt=" [Foto del profesor Ceballos]">
</center>
<hr>
Haga clic <a href="http://www.sitio_web/ini/inicio.html">

APÉNDICE B: PÁGINAS WEB

1095

aquí</a> para ir a la página de inicio
</body>
</html>

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 <a href="ceballos.html">
aquí</a> 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:
<center>
<a href="enlaces.html">
<img src="ceballos.jpg" align=bottom
alt="Foto del profesor Ceballos">
</a>
</center>

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:
<center>
El autor:<br>
<iframe src="ceballos.html" width=650 height=300></iframe>
</center>

1096

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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></iframe>

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:
<form method={get|post} action="fichero para procesar los datos">
Controles que forman el formulario
</form>

APÉNDICE B: PÁGINAS WEB

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:
<input
type = {text|password|checkbox|radio|hidden|image|submit|reset}
name = "Variable que toma el valor"
>

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: <input type="text" name="nombre" size="35">

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

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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: <input type="password" name="clave"
size="25" maxlength="20">

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:
<input type="checkbox" name="cv1" value="1" checked> Opción 1 <br>
<input type="checkbox" name="cv2" value="2"> Opción 2 <br>
<input type="checkbox" name="cv3" value="3"> Opción 3 <br>

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:
<input type="radio" name="opcion" value="1"> Opción 1 <br>
<input type="radio" name="opcion" value="2" checked> Opción 2 <br>
<input type="radio" name="opcion" value="3"> Opción 3 <br>

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á

APÉNDICE B: PÁGINAS WEB

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.
<input type="hidden" name="variable" value="valor">

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.
<input type="submit" value="Enviar datos">

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.
<input type="submit" name="enviar" value="Enviar">
<input type="submit" name="buscar" value="Buscar">

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.
<input type="reset" value="Borrar datos">

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.
<input type="image" src="fichero.jpg">

1100

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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:
<input type="text" name="nombre" size="30" tabindex="1">

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: <br><textarea name="mensaje"
rows="5" cols="20" wrap>
</textarea>

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:
<select name="opcion">
<option value="1"> Opción 1
<option selected value="2"> Opción 2
<option value="3"> Opción 3
</select>

APÉNDICE B: PÁGINAS WEB

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:
<select name="opcion" multiple>
<option value="1"> Opción 1
<option selected value="2"> Opción 2
<option value="3"> Opción 3
</select>

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:
<select name="opcion">
<optgroup label="grupo 1">
<option value="1"> Opción
<option value="2"> Opción
<option value="3"> Opción
</optgroup>
<optgroup label="grupo 2">
<option value="4"> Opción
<option value="5"> Opción
</optgroup>
</select>

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

ENCICLOPEDIA DE MICROSOFT VISUAL C#

El código HTML que da lugar a este formulario puede ser el siguiente (la expresión &nbsp indica un espacio en blanco). El código puede obtenerlo del fichero Cap15\HTML\tutorias.html del CD.
<html>
<head>
<title>Concertar una tutoría</title>
</head>
<body>
<h1 align="center">CONCERTAR UNA TUTORÍA</h1>
<form action="http://localhost:8080/miap/tutorias"
method=post>
Alumno:<br><input type="text" name="alumno" size="60">
<br><br>Con el profesor:
<br><input type="text" name="profesor" size="60">
<br><br>Día:<br>
<select name="día">
<option>lunes <option>miércoles <option>jueves
</select>
<br><br>Hora:
&nbsp;&nbsp;&nbsp;10<input type="radio" name="hora" value="10"
checked>
&nbsp;&nbsp;&nbsp;12<input type="radio" name="hora" value="12">
&nbsp;&nbsp;&nbsp;16<input type="radio" name="hora" value="16">
&nbsp;&nbsp;&nbsp;18<input type="radio" name="hora" value="18">

APÉNDICE B: PÁGINAS WEB

1103

<br><br>Asunto:<br><textarea name="asunto"
rows="5" cols="40" wrap></textarea>
<br><br><input type="submit" value="Enviar datos">
&nbsp;&nbsp;<input type="reset">
</form>
</body>
</html>

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:
<table border="1">
<tr>
<th>Nombre</th>
<th>Nota</th>
</tr>
<tr>
<td width=200>Javier Ceballos Fernández</td>
<td width=30 align=right>10.00</td>
</tr>
<tr>
<td width=200>Elena Ortiz Fuentes</td>
<td width=30 align=right>7.50</td>
</tr>
</table>

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:
<th colspan=2> cabecera 1</th>

Extender una celda en múltiples filas:
<th rowspan=2> cabecera 1</th>

Modificar el ancho y el alto de la tabla en valor absoluto o respecto al tamaño
de la ventana del navegador:
<table width=60% height=80%>

1104

ENCICLOPEDIA DE MICROSOFT VISUAL C#

Modificar el tamaño de una celda:
<td width=200 height=50>

Alinear el contenido de una celda:
<td valign=top align=left>

Modificar el color de fondo de una celda:
<td bgcolor="green">

Modificar el espacio y el margen de las celdas:
<table border cellspacing="8" cellpadding="8">

Controlar los saltos de línea en una celda:
<td nowrap>

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 <p>. 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:
<style type="text/css">
p {color: blue; margin-left: 20; border: solid; border-width: 2}
</style>

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.

APÉNDICE B: PÁGINAS WEB

1105

El siguiente ejemplo muestra una página HTML con estilo:
<html>
<head>
<title>Título del documento</title>
<style type="text/css">
p {color: blue; margin-left: 20; border: solid; border-width: 2}
</style>
</head>
<body>
<h1>Ejemplo de un documento HTML</h1>
<hr>
<h3>El cuerpo del documento puede contener:</h3>
<h4>Texto, imágenes, sonido y órdenes HTML</h4>
<p>
HTML es un lenguaje utilizado para desarrollar páginas y
documentos web.
<p>
A diferencia de los lenguajes convencionales, HTML utiliza
una serie de etiquetas especiales intercaladas en un
documento de texto sin formato.
<br>
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.
<hr>
</body>
</html>

Cuando se muestre la página anterior, los dos párrafos, <p>, 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:
<link rel="stylesheet" href="estilo.css" type="text/css">

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:
<html>
<head>

1106

ENCICLOPEDIA DE MICROSOFT VISUAL C#

<title>Título del documento</title>
<link rel="stylesheet" href="estilo.css" type="text/css">
</head>
<body>
...
</body>
</html>

Clases
Cuando se muestre la página anterior, todos sus párrafos, <p>, 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 <p class="azul"> serán azules y los definidos como <p class="verde">
serán verdes. Por ejemplo:
<html>
<head>
<title>Título del documento</title>
<link rel="stylesheet" href="estilo.css" type="text/css">
</head>
<body>
<h1>Ejemplo de un documento HTML</h1>
<hr>
<h3>El cuerpo del documento puede contener:</h3>
<h4>Texto, imágenes, sonido y órdenes HTML</h4>
<p class="verde">
HTML es un lenguaje utilizado para desarrollar páginas y
documentos web.
<p class="azul">
A diferencia de los lenguajes convencionales, HTML utiliza
una serie de etiquetas especiales intercaladas en un
documento de texto sin formato.
<br>

APÉNDICE B: PÁGINAS WEB

1107

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.
<hr>
</body>
</html>

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 <p> serán azules y los definidos como <p id="verde"> 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 <a> 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 <span> y <div>
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 <span> y <div>.

1108

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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:
<p>
A diferencia de los lenguajes convencionales,
<span style="color:blue; font-style:italic">
HTML utiliza una serie de etiquetas especiales intercaladas
en un documento de texto sin formato.
</span>
</p>

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:
<div class=notas>
<h1>Divisiones</h1>
<p>El elemento div permite utilizar los atributos align, class,
style, id y otros muchos.</p>
<p>Definir un bloque, es útil para construir diferentes secciones
en un documento.</p>
<p>Es necesario especificar la etiqueta de cierre</p>
</div>

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

APÉNDICE B: PÁGINAS WEB

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:
<html>
<head>
<title>Capas</title>
<link rel="stylesheet" href="estilos.css" type="text/css">
</head>
<body>
<div class="sombra">
TÍTULO DE LA PÁGINA
</div>
<div class="titulo">
TÍTULO DE LA PÁGINA
</div>
</body>
</html>

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í:
<p>01/01/2004</p>

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:
<FechaNacimiento>01/01/2004</FechaNacimiento>

1110

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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:
<foto origen="ceballos.jpg">Profesor Ceballos</foto>

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

APÉNDICE B: PÁGINAS WEB

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

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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

 F.J.Ceballos/RA-MA

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

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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.

APÉNDICE C: INTERNACIONALIZACIÓN

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

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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();
}

APÉNDICE C: INTERNACIONALIZACIÓN

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

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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-

APÉNDICE C: INTERNACIONALIZACIÓN

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

 F.J.Ceballos/RA-MA

.NET PARA LINUX
Los desarrolladores sobre GNU/Linux pueden ahora también desarrollar aplicaciones multiplataforma basadas en .NET gracias al proyecto Mono.
¿Qué es Mono? Es un proyecto para construir una plataforma de desarrollo libre, 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, 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

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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 


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 


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

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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 


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

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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


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

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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 


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 


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 


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 


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

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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 


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 


Key, 229 

ÍNDICE

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


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 


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

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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 


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 


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

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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 


QueryString, atributo proveedor de valor, 866 


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 


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

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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 


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

ENCICLOPEDIA DE MICROSOFT VISUAL C#

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 


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 


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 


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 


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


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.

Sign up to vote on this title
UsefulNot useful