C#与.NET 3.0 高级程序设计（英文版）
Parte 1 nnn Introducción a C# y la plataforma .NET
nCAPITULO 1 La Filosofía de .NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
Comprender el estado anterior de las cosas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
La solución .NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Presentamos los componentes básicos de la plataforma .NET (CLR, CTS,
y CLS). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Lenguajes de programación compatibles con .NET adicionales. . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Una descripción general de los ensamblados .NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
Comprensión del sistema de tipos común. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
Comprensión de la especificación del lenguaje común. . . . . . . . . . . . . . . . . . . . . . 20
Comprender el tiempo de ejecución de lenguaje común. . . . . . . . . . . . . . . . . . . . . . . . . . 22
La distinción ensamblado/espacio de nombres/tipo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Explorando un ensamblado usando ildasm.exe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
Explorando un ensamblaje usando el reflector de Lutz Roeder. . . . . . . . . . . . . . . . . . . . . . 31
Implementación del tiempo de ejecución .NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
La naturaleza independiente de la plataforma de .NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
nCAPÍTULO 2 Creación de aplicaciones C#. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
La función del SDK de .NET Framework 3.5. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Creación de aplicaciones C# mediante csc.exe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Creación de aplicaciones .NET mediante TextPad. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Creación de aplicaciones .NET con Notepad++. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
Creación de aplicaciones .NET con SharpDevelop. . . . . . . . . . . . . . . . . . . . . . . . . . . 48
Creación de aplicaciones .NET con Visual C# 2008 Express. . . . . . . . . . . . . . . . . . 50
Creación de aplicaciones .NET con Visual Studio 2008. . . . . . . . . . . . . . . . . . . . . . 52
Un catálogo parcial de herramientas de desarrollo .NET adicionales. . . . . . . . . . . . . . . . . . . . 64
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
IV
Parte 2 nnn Construcciones de programación principales de C#
nCAPÍTULO 3 Construcciones básicas de programación en C#, Parte I. . . . . . . . . . . . . . . . . . . . . . . . . 69
La anatomía de un programa C# simple. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
Un comentario interesante: algunos miembros adicionales del
Clase de entorno del sistema. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
La clase System.Console. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
Tipos de datos del sistema y notación taquigráfica C#. . . . . . . . . . . . . . . . . . . . . . . . . . . 80
Comprender el tipo System.String. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
Reducción y ampliación de las conversiones de tipos de datos. . . . . . . . . . . . . . . . . . . . . . . . . . 95
Construcciones de iteración de C#. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
Constructos de decisión y operadores relacionales/de igualdad. . . . . . . . . . . . . . . . . 102
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
nCAPÍTULO 4 Construcciones básicas de programación en C#, Parte II. . . . . . . . . . . . . . . . . . . . . . . . 107
Métodos y modificadores de parámetros. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
Comprender la sobrecarga de miembros. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
Manipulación de matrices en C#. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
Comprender el tipo de enumeración. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
Comprender el tipo de estructura. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
Comprender los tipos de valor y los tipos de referencia. . . . . . . . . . . . . . . . . . . . . . . . 129
Tipos de valor y referencia: detalles finales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
Comprensión de los tipos que admiten valores NULL en C#. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
nCAPÍTULO 5 Definición de tipos de clases encapsuladas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
Presentamos el tipo de clase C#. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
Comprensión de los constructores de clases. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
El papel de esta palabra clave. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
Comprender la palabra clave estática. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
Definiendo los pilares de la programación orientada a objetos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
Modificadores de acceso a C#. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
El primer pilar: los servicios de encapsulación de C#. . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
Comprensión de los datos constantes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
Comprensión de los campos de sólo lectura. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
Comprensión de los tipos parciales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
Documentar el código fuente de C# mediante XML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176
Visualizando los frutos de nuestro trabajo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
nCAPÍTULO 6 Comprensión de la herencia y el polimorfismo. . . . . . . . . . . . . . . . . . 185
La mecánica básica de la herencia. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
Revisión de diagramas de clases de Visual Studio. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
El segundo pilar: los detalles de la herencia. . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
Programación para Contención/Delegación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
nCONTENIDO v
vi nCONTENIDO
El tercer pilar: el soporte polimórfico de C#. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
Comprensión de las reglas de conversión de clases base/clases derivadas. . . . . . . . . . . . . . . . . . . 210
La clase principal principal: System.Object. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
nCAPÍTULO 7 Comprensión del manejo estructurado de excepciones. . . . . . . . . . . . . . . . . . . 219
Oda a los errores, fallos y excepciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
El papel del manejo de excepciones de .NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220
El ejemplo más simple posible. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
Configurar el estado de una excepción. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226
Excepciones a nivel del sistema (System.SystemException). . . . . . . . . . . . . . . . . . . . . 230
Excepciones a nivel de aplicación (System.ApplicationException). . . . . . . . . . . . . . . 231
Procesamiento de múltiples excepciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236
El bloque finalmente. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239
¿Quién tira qué? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240
El resultado de excepciones no controladas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241
Depuración de excepciones no controladas mediante Visual Studio. . . . . . . . . . . . . . . . . . . . 242
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243
nCAPÍTULO 8 Comprensión de la vida útil de los objetos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245
Clases, objetos y referencias. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245
Los conceptos básicos de la vida útil de los objetos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246
El papel de las raíces de las aplicaciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249
Comprensión de las generaciones de objetos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251
El tipo System.GC. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252
Construyendo objetos finalizables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256
Construcción de objetos desechables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259
Creación de tipos finalizables y desechables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265
Parte 3 nnn Construcciones de programación avanzada en C#
nCAPÍTULO 9 Trabajar con interfaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269
Comprensión de los tipos de interfaz. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269
Definición de interfaces personalizadas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272
Implementación de una interfaz. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274
Invocar miembros de la interfaz a nivel de objeto. . . . . . . . . . . . . . . . . . . . . . . . . 276
Interfaces como parámetros. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278
Interfaces como valores de retorno. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280
Matrices de tipos de interfaz. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281
Implementación de interfaces con Visual Studio 2008. . . . . . . . . . . . . . . . . . . . . . . 282
Resolución de conflictos de nombres mediante implementación de interfaz explícita. . . . . . . . . . . . . 283
Diseño de jerarquías de interfaz. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286
Creación de tipos enumerables (IEnumerable e IEnumerator). . . . . . . . . . . . . . . 289
Construyendo objetos clonables (ICloneable). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
Construyendo objetos comparables (IComparable). . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299
Comprensión de las interfaces de devolución de llamadas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 308
nCAPÍTULO 10 Colecciones y Genéricos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309
Las interfaces del espacio de nombres System.Collections. . . . . . . . . . . . . . . . . . . . . 309
Los tipos de clase de System.Collections. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312
System.Collections.Espacio de nombres especializado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316
La relación Boxing, Unboxing y System.Object. . . . . . . . . . . . . . . . . . . 316
La cuestión de la seguridad de tipos y las colecciones fuertemente tipadas. . . . . . . . . . . . . . . . . . 319
El espacio de nombres System.Collections.Generic. . . . . . . . . . . . . . . . . . . . . . . . . . . . 324
Creación de métodos genéricos personalizados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327
Creación de estructuras y clases genéricas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330
Crear una colección genérica personalizada. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 332
Creación de clases base genéricas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337
Creación de interfaces genéricas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 338
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339
nCAPÍTULO 11 Delegados, eventos y Lambdas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341
Comprensión del tipo de delegado .NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341
Definición de un delegado en C#. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342
Las clases base System.MulticastDelegate y System.Delegate. . . . . . . . . 344
El ejemplo de delegado más simple posible. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345
Modernización del tipo de coche con delegados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348
"Un ejemplo de delegado más elaborado". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353
Comprender la covarianza de los delegados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 358
Creación de delegados genéricos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360
Comprensión de los eventos de C#. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362
El delegado genérico EventHandler. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 369
Comprensión de los métodos anónimos de C#. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 370
Comprender las conversiones de grupos de métodos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372
El operador Lambda de C# 2008. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 381
nCAPÍTULO 12 Indexadores, operadores y punteros. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383
Comprensión de los métodos de indexación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383
Comprender la sobrecarga del operador. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388
Comprensión de las conversiones de tipos personalizados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 397
Trabajar con tipos de puntero. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 404
Directivas de preprocesador de C#. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 414
nCAPÍTULO 13 Características del lenguaje C# 2008. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415
Comprensión de las variables locales escritas implícitamente. . . . . . . . . . . . . . . . . . . . . . . . . . 415
Comprender las propiedades automáticas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 420
Comprensión de los métodos de extensión. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 424
nCONTENIDO vii
Comprensión de los métodos parciales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 433
Comprensión de la sintaxis del inicializador de objetos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 436
Comprensión de los tipos anónimos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 440
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 445
nCAPÍTULO 14 Introducción a LINQ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 447
Comprender el papel de LINQ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 447
Un primer vistazo a las expresiones de consulta LINQ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 450
LINQ y colecciones genéricas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 456
LINQ y colecciones no genéricas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 457
La representación interna de los operadores de consultas LINQ. . . . . . . . . . . . . . . . . . . . . 459
Investigación de los operadores de consulta LINQ de C#. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 463
Consultas LINQ: ¿Una isla en sí mismas? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 469
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 472
PARTE 4 nnn Programación con ensamblados .NET
nCAPÍTULO 15 Introducción a los ensamblados .NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 475
Definición de espacios de nombres personalizados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 475
El papel de los ensamblados .NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 480
Comprensión del formato de un ensamblado .NET. . . . . . . . . . . . . . . . . . . . . . . . . . 482
Creación y consumo de un ensamblaje de archivo único. . . . . . . . . . . . . . . . . . . . . . . . . 486
Creación y consumo de un ensamblaje de varios archivos. . . . . . . . . . . . . . . . . . . . . . . . . . . 496
Comprensión de las asambleas privadas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 499
Comprender las asambleas compartidas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 504
Consumir una asamblea compartida. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 510
Configuración de ensamblajes compartidos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 512
Investigando la composición interna del GAC. . . . . . . . . . . . . . . . . . . . . . . . 516
Comprensión de los ensamblajes de políticas del editor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 518
Comprender el elemento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 519
El espacio de nombres System.Configuration. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 521
El archivo de configuración de la máquina. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 522
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 522
nCAPÍTULO 16 Reflexión de tipos, enlace tardío y basado en atributos
Programación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 523
La necesidad de metadatos de tipo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 523
Comprender la reflexión. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 527
Creación de un visor de metadatos personalizado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 530
Cargando ensamblajes dinámicamente. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 536
Reflexionando sobre las asambleas compartidas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 538
Comprender el enlace tardío. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 539
viii nCONTENIDO
Comprensión de la programación atribuida. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 542
Creación de atributos personalizados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 546
Atributos a nivel de ensamblaje (y a nivel de módulo). . . . . . . . . . . . . . . . . . . . . . . . . . 549
Reflexionando sobre los atributos mediante el enlace anticipado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 550
Reflexionando sobre los atributos mediante el enlace tardío. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 551
Poner la reflexión, el enlace tardío y los atributos personalizados en perspectiva. . . . . . 553
Creación de una aplicación extensible. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 553
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 559
nCAPÍTULO 17 Procesos, dominios de aplicación y contextos de objetos. . . . . . . . . . . . . . . . . . . 561
Revisión de procesos tradicionales de Win32. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 561
Interactuando con Procesos Bajo la Plataforma .NET. . . . . . . . . . . . . . . . . . . . . . 563
Comprensión de los dominios de aplicaciones .NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 571
Comprensión de los límites del contexto de los objetos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 577
Resumiendo procesos, dominios de aplicación y contexto. . . . . . . . . . . . . . . . . . . . . . 581
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 582
nCAPÍTULO 18 Creación de aplicaciones multiproceso. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 583
La relación proceso/dominio de aplicación/contexto/hilo. . . . . . . . . . . . . . . . . . . . 583
"Una breve revisión del delegado de .NET". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 585
La naturaleza asincrónica de los delegados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 587
Invocar un método de forma asincrónica. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 588
El espacio de nombres System.Threading. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 593
La clase System.Threading.Thread. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 594
Creación programática de subprocesos secundarios. . . . . . . . . . . . . . . . . . . . . . . . . . 597
La cuestión de la concurrencia. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 602
Programación con devoluciones de llamada del temporizador. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 609
Comprender CLR ThreadPool. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 610
El papel del componente BackgroundWorker. . . . . . . . . . . . . . . . . . . . . . . . . . 612
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 616
nCAPÍTULO 19 Comprensión de CIL y el papel de los ensamblajes dinámicos. . . . . . . . 617
Reflexionando sobre la naturaleza de la programación CIL. . . . . . . . . . . . . . . . . . . . . . . . . . . 617
"Examen de directivas, atributos y códigos de operación de CIL". . . . . . . . . . . . . . . . . . . . . . . 618
Empujar y hacer estallar: la naturaleza basada en pilas de CIL. . . . . . . . . . . . . . . . . . . . 620
Comprensión de la ingeniería de ida y vuelta. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 621
Comprensión de las directivas y atributos de CIL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 629
Asignaciones de tipos de datos de biblioteca de clases base .NET, C# y CIL. . . . . . . . . . . . . . . . 635
Definición de miembros tipo en CIL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 636
Examinando códigos de operación CIL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 638
Construyendo un ensamblado .NET con CIL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 643
Comprensión de los ensamblajes dinámicos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 648
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 657
nCONTENIDO ix
Parte 5 nnn Presentación de las bibliotecas de clases base .NET
nCAPÍTULO 20 E/S de archivos y almacenamiento aislado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 661
Explorando el espacio de nombres System.IO. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 661
Los tipos Directorio(Info) y Archivo(Info). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 662
Trabajar con el tipo DirectoryInfo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 663
Trabajar con el tipo de directorio. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 667
Trabajar con el tipo de clase DriveInfo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 668
Trabajando con la clase FileInfo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 669
Trabajar con el tipo de archivo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 673
La clase de corriente abstracta. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 675
Trabajar con StreamWriters y StreamReaders. . . . . . . . . . . . . . . . . . . . . . . . 677
Trabajar con StringWriters y StringReaders. . . . . . . . . . . . . . . . . . . . . . . . . . 680
Trabajar con BinaryWriters y BinaryReaders. . . . . . . . . . . . . . . . . . . . . . . . . . 682
"Observando" archivos mediante programación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 683
Realizar E/S de archivos asincrónicos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 685
Comprensión del papel del almacenamiento aislado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 687
Introducción a la seguridad del acceso al código. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 688
Una descripción general del almacenamiento aislado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 698
Obtención de una tienda mediante InsulatedStorageFile. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 702
Almacenamiento aislado en acción: implementación ClickOnce. . . . . . . . . . . . . . . . . . . . . . . . 707
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 710
nCAPÍTULO 21 Introducción a la serialización de objetos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 711
Comprender la serialización de objetos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 711
Configuración de objetos para serialización. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 713
Elegir un formateador de serialización. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 715
Serializar objetos utilizando BinaryFormatter. . . . . . . . . . . . . . . . . . . . . . . . . . . 717
Serializar objetos utilizando SoapFormatter. . . . . . . . . . . . . . . . . . . . . . . . . . . . 719
Serialización de objetos mediante XmlSerializer. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 720
Serialización de colecciones de objetos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 723
Personalización del proceso de serialización. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 724
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 729
nCAPÍTULO 22 ADO.NET Parte I: La capa conectada. . . . . . . . . . . . . . . . . . . . . . . . . . . . 731
Una definición de alto nivel de ADO.NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 731
Comprender los proveedores de datos ADO.NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 733
Espacios de nombres ADO.NET adicionales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 736
Los tipos del espacio de nombres System.Data. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 737
Resumen de proveedores de datos mediante interfaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 741
Creando la base de datos de AutoLot. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 744
El modelo de fábrica de proveedores de datos ADO.NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 749
Comprensión de la capa conectada de ADO.NET. . . . . . . . . . . . . . . . . . . . . . . . . 755
Trabajar con lectores de datos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 760
Creación de una biblioteca de acceso a datos reutilizable. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 763
x nCONTENIDO
Creación de una interfaz de usuario basada en la consola. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 770
Acceso asincrónico a datos mediante SqlCommand. . . . . . . . . . . . . . . . . . . . . . . . . 775
Comprensión de las transacciones de bases de datos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 777
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 781
nCAPÍTULO 23 ADO.NET Parte II: La capa desconectada. . . . . . . . . . . . . . . . . . . . . . . . 783
Comprender la capa desconectada de ADO.NET. . . . . . . . . . . . . . . . . . . . . . 783
Comprensión del papel del conjunto de datos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 784
Trabajando con columnas de datos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 787
Trabajando con filas de datos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 789
Trabajar con tablas de datos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 793
Vinculación de objetos DataTable a interfaces de usuario. . . . . . . . . . . . . . . . . . . . . . . . . . . . 798
Llenado de objetos DataSet/DataTable mediante adaptadores de datos. . . . . . . . . . . . . . . . . . . 808
Revisando AutoLotDAL.dll. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 811
Navegando por objetos DataSet de varias tablas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 814
Las herramientas de acceso a datos de Visual Studio 2008. . . . . . . . . . . . . . . . . . . . . . . . . . . 820
Desacoplar el código generado automáticamente de la capa UI. . . . . . . . . . . . . . . . . . . . . . . 831
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 835
nCAPÍTULO 24 Programación con las API de LINQ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 837
El papel de LINQ para ADO.NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 837
Programación con LINQ to DataSet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 838
Programación con LINQ a SQL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 843
Generando clases de entidad usando SqlMetal.exe. . . . . . . . . . . . . . . . . . . . . . . . . . . 848
Creación de clases de entidad con Visual Studio 2008. . . . . . . . . . . . . . . . . . . . . . . . 854
Manipulación de documentos XML utilizando LINQ to XML. . . . . . . . . . . . . . . . . . . . . . . . 857
Navegando por un documento en memoria. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 862
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 865
nCAPÍTULO 25 Presentación de Windows Communication Foundation. . . . . . . . . . . . . . . 867
"Un popurrí de API de informática distribuida". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 867
El papel de WCF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 873
Investigación de las asambleas principales de WCF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 876
Las plantillas de proyecto WCF de Visual Studio. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 877
La composición básica de una aplicación WCF. . . . . . . . . . . . . . . . . . . . . . . . . . . . 879
El ABC de WCF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 880
Construyendo un servicio WCF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 885
Alojamiento del servicio WCF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 888
Creación de la aplicación cliente WCF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 896
Uso de la plantilla de proyecto de biblioteca de servicios WCF. . . . . . . . . . . . . . . . . . . . . . . . . 900
Alojamiento del servicio WCF como servicio de Windows. . . . . . . . . . . . . . . . . . . . . . . . . 903
Invocar un servicio de forma asincrónica. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 908
Diseño de contratos de datos WCF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 910
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 915
nCONTENIDO xi
nCAPÍTULO 26 Presentación de Windows Workflow Foundation. . . . . . . . . . . . . . . . . . . . . 917
Definición de un proceso de negocio. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 917
Los componentes básicos de WF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 918
Ensamblados, espacios de nombres y proyectos de WF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 924
Creación de una aplicación sencilla habilitada para flujos de trabajo. . . . . . . . . . . . . . . . . . . . . . . . . 926
Examinando el código de alojamiento del motor WF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 930
Invocar servicios web dentro de flujos de trabajo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 934
Creación de una biblioteca de códigos WF reutilizables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 945
Unas breves palabras sobre las actividades personalizadas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 951
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 952
Parte 6 nnn Interfaces de usuario de escritorio
nCAPÍTULO 27 Programación con Windows Forms. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 955
Los espacios de nombres de Windows Forms. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 955
Creación de una aplicación sencilla de Windows Forms (sin IDE). . . . . . . . . . . . . . . . . . 956
La plantilla de proyecto de Visual Studio Windows Forms. . . . . . . . . . . . . . . . . . . . . . 961
La anatomía de una forma. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 968
Responder a la actividad del mouse. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 975
Responder a la actividad del teclado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 977
Diseño de cuadros de diálogo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 978
Representación de datos gráficos utilizando GDI+. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 985
Creación de una aplicación completa de Windows Forms. . . . . . . . . . . . . . . . . . . . . . . . 990
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 997
nCAPÍTULO 28 Presentación de Windows Presentation Foundation y XAML. . . . . . . 999
La motivación detrás de WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 999
Los distintos tipos de aplicaciones WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1002
Investigando las Asambleas de WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1004
Creación de una aplicación WPF (sin XAML). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1011
Detalles adicionales del tipo de aplicación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1015
Detalles adicionales del tipo de ventana. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1017
Creación de una aplicación WPF (centrada en XAML). . . . . . . . . . . . . . . . . . . . . . . . . . . . 1021
Transformando el marcado en un ensamblado .NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . 1025
Separación de preocupaciones mediante archivos de código subyacente. . . . . . . . . . . . . . . . . . . . . . . 1029
La sintaxis de XAML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1031
Creación de aplicaciones WPF con Visual Studio 2008. . . . . . . . . . . . . . . . . . . . 1044
Procesamiento de XAML en tiempo de ejecución: SimpleXamlPad.exe. . . . . . . . . . . . . . . . . . . . . . 1048
El papel de Microsoft Expression Blend. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1052
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1053
xii nCONTENIDO
nCAPÍTULO 29 Programación con controles WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1055
"Un estudio de la biblioteca de control de WPF". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1055
Declaración de controles en XAML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1058
Comprensión del papel de las propiedades de dependencia. . . . . . . . . . . . . . . . . . . . . . 1060
Comprensión de los eventos enrutados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1064
Trabajar con tipos de botones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1068
Trabajar con CheckBoxes y RadioButtons. . . . . . . . . . . . . . . . . . . . . . . . . . . 1072
Trabajar con los tipos ListBox y ComboBox. . . . . . . . . . . . . . . . . . . . . . . . 1075
Trabajar con áreas de texto. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1081
Controlar el diseño del contenido mediante paneles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1083
Construyendo el marco de una ventana usando paneles anidados. . . . . . . . . . . . . . . . . . . . . . . 1093
Comprensión de los comandos de control de WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1099
Comprensión del modelo de enlace de datos de WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . 1102
Conversión de datos mediante IValueConverter. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1106
Vinculación a objetos personalizados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1108
Vinculación de elementos de la interfaz de usuario a documentos XML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1112
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1116
nCAPÍTULO 30 Representación gráfica, recursos y temas 2D de WPF. . . . . . . . . 1117
La filosofía de los servicios de representación gráfica de WPF. . . . . . . . . . . . . . . . . . . . 1117
Explorando los tipos derivados de formas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1124
Trabajando con pinceles WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1127
Trabajar con bolígrafos WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1130
Explorando los tipos derivados de dibujos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1130
El papel de las transformaciones de la interfaz de usuario. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1135
Comprensión de los servicios de animación de WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1136
Comprender el sistema de recursos de WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1145
Definición y aplicación de estilos para controles WPF. . . . . . . . . . . . . . . . . . . . . . . . . 1147
Modificación de la interfaz de usuario de un control mediante plantillas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1156
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1160
Parte 7 nnn Creación de aplicaciones web con ASP.NET
nCAPÍTULO 31 Creación de páginas web ASP.NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1163
El papel de HTTP. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1163
Comprensión de las aplicaciones web y los servidores web. . . . . . . . . . . . . . . . . . . . . . 1164
El papel del HTML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1167
El papel de las secuencias de comandos del lado del cliente. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1172
Envío de los datos del formulario (GET y POST). . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1174
Creación de una página ASP clásica. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1175
Problemas con ASP clásico. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1177
Los espacios de nombres de ASP.NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1178
El modelo de código de página web ASP.NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1179
Detalles de una estructura de directorio de sitio web ASP.NET. . . . . . . . . . . . . . . . . . . . . . 1190
El ciclo de compilación de páginas ASP.NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1192
nCONTENIDO xiii
La cadena de herencia del tipo de página. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1194
Interactuar con la solicitud HTTP entrante. . . . . . . . . . . . . . . . . . . . . . . . . . . 1195
Interactuar con la respuesta HTTP saliente. . . . . . . . . . . . . . . . . . . . . . . . . . 1198
El ciclo de vida de una página web ASP.NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1200
La función del archivo Web.config. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1203
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1206
nCAPÍTULO 32 Controles web, temas y páginas maestras de ASP.NET. . . . . . . . . . . . 1207
Comprender la naturaleza de los controles web. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1207
El tipo System.Web.UI.Control. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1209
El tipo System.Web.UI.WebControls.WebControl. . . . . . . . . . . . . . . . . . . . . . 1213
Categorías principales de controles web ASP.NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . 1213
Creación de un sitio web ASP.NET rico en funciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1215
El papel de los controles de validación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1231
Trabajar con temas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1237
Controles de posicionamiento mediante tablas HTML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1243
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1244
nCAPÍTULO 33 Técnicas de gestión del estado de ASP.NET. . . . . . . . . . . . . . . . . . . . . . . 1245
La cuestión del Estado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1245
Técnicas de gestión de estado de ASP.NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1247
Comprender la función del estado de vista de ASP.NET. . . . . . . . . . . . . . . . . . . . . . . . . 1248
"La función del archivo Global.asax". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1251
Comprensión de la distinción entre aplicación y sesión. . . . . . . . . . . . . . . . . . . . . . 1254
Trabajar con la caché de aplicaciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1259
Mantenimiento de datos de sesión. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1263
Comprender las cookies. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1267
La función del elemento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1269
Comprensión de la API de perfil ASP.NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1272
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1279
Parte 8 nnn Apéndices
APÉNDICE A Interoperabilidad COM y .NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1283
El alcance de la interoperabilidad de .NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1283
Un ejemplo simple de interoperabilidad de .NET a COM. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1284
Investigación de un ensamblado de interoperabilidad .NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1287
Comprender el contenedor invocable en tiempo de ejecución. . . . . . . . . . . . . . . . . . . . . . . . . . 1289
El papel de COM IDL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1292
Uso de una biblioteca de tipos para crear un ensamblaje de interoperabilidad. . . . . . . . . . . . . . . . . . . . . . 1296
Construyendo un servidor COM más elaborado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1299
Examinando la Asamblea de Interop. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1301
Comprensión de la interoperabilidad de COM a .NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . 1305
El papel de la CCW. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1306
El papel de la interfaz de clase .NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1307
xiv nCONTENIDO
Construyendo sus tipos .NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1308
Generación de la biblioteca de tipos y registro de los tipos .NET. . . . . . . . . . . . . . 1310
Examinar la información de tipo exportada. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1311
Creación de un cliente de prueba de Visual Basic 6.0. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1312
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1313
nAPÉNDICE B Desarrollo .NET independiente de la plataforma con Mono. . . . . . . . . . . 1315
La naturaleza independiente de la plataforma de .NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1315
Obtención e instalación de Mono. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1318
Las herramientas de desarrollo Mono. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1321
Creación de aplicaciones .NET con Mono. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1323
Sugerencias para estudios adicionales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1330
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1331
nÍNDICE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1333
Expandir
