Contenido de un vistazo

Acerca del
Autor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xix
Acerca del Revisor
Técnico. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xix
Agradecimientos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . xx
Introducción y bienvenida. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . xxi
PARTE 1 nnn Introducción a Visual Basic 2008 y el
. NET
nCHAPTER 1 La filosofía de. NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
nCHAPTER 2 Edificio de Visual Basic 2008 aplicaciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
PARTE 2 n n n la base de programación VB Construye
nCHAPTER tres construcciones de programación VB 2008, primera parte. . . . . . . . . . . . . . . . . . . . . .
. . . . . . 65
nCHAPTER cuatro construcciones de programación VB 2008, Parte II. . . . . . . . . . . . . . . . . . . . . . . . .
. . 103
nCHAPTER 5 Diseño de encapsulado de clase Tipos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
nCHAPTER 6 Entendimiento Herencia y polimorfismo. . . . . . . . . . . . . . . . . . . . . . 173
nCHAPTER 7 Entendimiento estructurado de excepciones. . . . . . . . . . . . . . . . . . . . . . 207
nCHAPTER 8 Descripción de objetos de por vida. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
PARTE 3 n n n avanzada de programación VB Construye
nCHAPTER 9 Trabajar con tipos de interfaz. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255
nCHAPTER 10 colecciones, genéricos y tipos de datos que aceptan valores NULL. . . . . . . . . . . . . . .
. . . . . . 291
nCHAPTER 11 delegados, eventos y expresiones
lambda. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327
nCHAPTER 12 sobrecarga de operadores y rutinas de conversión personalizados. . . . . . . . . . . . .
359
nCHAPTER 13 VB 2008-Características del lenguaje
específico. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383
nCHAPTER 14 Una introducción a LINQ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409

PARTE 4 Programación con. NET

nCHAPTER 15 Introducción. NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 437
nCHAPTER 16 Tipo de reflexión, el enlace, y la programación basada en atributos. . . . 483
nCHAPTER 17 Procesos, dominios de aplicación, y contextos de objetos. . . . . . . . . . . . . . . . .
. . . . . . 517
nCHAPTER 18 Creación de aplicaciones multiproceso. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 537
nCHAPTER 19. NET Interoperabilidad Asambleas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 571
PARTE 5 nnn presentar el. Bibliotecas de red de clase de base
nCHAPTER 20 y manipulación de archivos de Directorio.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 607
nCHAPTER 21 Presentación de la serialización de objetos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . 633
nCHAPTER [Link] 22 Parte I: La Capa de Conexión. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 653
nCHAPTER 23 [Link] Parte II: La capa de desconectado. . . . . . . . . . . . . . . . . . . . . . . . . . . 705
nCHAPTER 24 Programación con el API de LINQ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 759
nCHAPTER 25 Introducción a Windows Communication Foundation. . . . . . . . . . . . . . . . . . . 795
nCHAPTER 26 Introducción a Windows Workflow Foundation. . . . . . . . . . . . . . . . . . . . . . . . . 843
PARTE 6 nnn de aplicaciones de escritorio con Windows Forms
nCHAPTER 27 Introducción a Windows Forms. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 883
nCHAPTER 28 de representación gráfica de datos con GDI +. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
929
nCHAPTER 29 Programación con formularios Windows Forms. . . . . . . . . . . . . . . . . . . . . . . . 983
PARTE 7 n n n de aplicaciones de escritorio con WPF
nCHAPTER 30 Introducción a Windows Presentation Foundation y XAML. . . . . . . . . . . 1047
nCHAPTER 31 Programar con los controles de WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1103
nCHAPTER 32 WPF representación gráfica 2D, recursos y temas. . . . . . . . . . . . . 1167
PARTE 8 nnn construcción de Aplicaciones Web con [Link]
nCHAPTER construcción de 33 páginas Web [Link]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. 1215
nCHAPTER 34 Web [Link], Temas y páginas maestras. . . . . . . . . . . . . . . . 1261
nCHAPTER 35 de estado de [Link] Técnicas de Gestión. . . . . . . . . . . . . . . . . . . . . . . . . . 1297
ÍNDICE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . 1331

Acerca del
Autor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xix
Acerca del Revisor
Técnico. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xix
Agradecimientos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . xx
Introducción y bienvenida. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . xxi
PARTE 1 n n n Introducción a Visual Basic 2008 y
la Plataforma. NET
nCHAPTER 1 La filosofía de. NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
Entender la situación anterior. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
La solución. NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Introducción a los bloques de construcción de la plataforma. NET
(CLR, CTS, y CLS). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Lo que Visual Basic 2008 trae a la mesa. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Adicional. NET-Aware lenguajes de programación. . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Una visión general de. NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Comprender el sistema de tipos común. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Comprender la especificación Common Language. . . . . . . . . . . . . . . . . . . . . . 19
Comprender el Common Language Runtime. . . . . . . . . . . . . . . . . . . . . . . . . . 21
La Asamblea / Espacio de nombres / Distinción tipo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
Usando [Link]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
Uso de Reflector de Lutz Roeder. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
Implementar el tiempo de ejecución. NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
La naturaleza independiente de la plataforma. NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
nCHAPTER 2 Edificio de Visual Basic 2008 aplicaciones. . . . . . . . . . . . . . . . . . . . . 35
El papel del. NET Framework 3.5 SDK. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
La VB 2008 la línea de comandos del compilador ([Link]). . . . . . . . . . . . . . . . . . . . . . . . . . 36
La construcción de aplicaciones con Visual Basic 2008 [Link]. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
37
Trabajar con archivos de respuesta de [Link]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Edificio. NET Usando SharpDevelop. . . . . . . . . . . . . . . . . . . . . . . . . . . 43
Edificio. NET utilizando Visual Basic 2008 Express. . . . . . . . . . . . . . . . 46
vi

Edificio. NET utilizando Visual Studio 2008. . . . . . . . . . . . . . . . . . . . . . 47

El papel de la Asamblea de Visual Basic Compatibility 6.0. . . . . . . . . . . . . . . . . . . 59
Un catálogo parcial de adicionales. Herramientas de desarrollo NET. . . . . . . . . . . . . . . . . . . . 61
Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
PARTE 2 n n n la base de programación VB Construye
nCHAPTER tres construcciones de programación VB 2008, primera parte. . . . . . . . . . . . . . . . . . . .
65
El papel del tipo de módulo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
El papel del método principal. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
Un interesante Aparte: Algunos miembros adicionales de la
Clase [Link]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
El [Link] clase. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
Tipos de datos del sistema de notación abreviada y VB. . . . . . . . . . . . . . . . . . . . . . . . . . . 77
Comprender el tipo [Link]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
Estrechamiento (explícito) y ampliación (implícita) Conversiones de tipos de datos. . . . . . . . . . 89
Construcción de Visual Basic 2008 declaraciones de código. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
VB 2008 las construcciones de control de flujo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
VB iteración Construye 2008. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
nCHAPTER cuatro construcciones de programación VB 2008, Parte II. . . . . . . . . . . . . . . . . . . 103
Definición de subrutinas y funciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
Entender sobrecarga miembros. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
Manipulación de matriz en Visual Basic 2008. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
Entender VB 2008 enumeraciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
Al presentar el VB 2008 Tipo de estructura. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
nCHAPTER 5 Diseño de encapsulado de clase Tipos. . . . . . . . . . . . . . . . . . . . . . . . 129
Al presentar el VB 2008 tipo de clase. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
Comprensión de Constructores de la Clase. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
El papel de la Palabra de mí. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
Entendiendo la palabra clave compartida. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
Definición de los pilares de la programación orientada a objetos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . 148
Visual Basic 2008 modificadores de acceso. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
El primer pilar: Servicios VB 2008 de encapsulación. . . . . . . . . . . . . . . . . . . . . . . 154
Comprensión de datos constante. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
Básicos de los campos de sólo lectura. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
Cómo entender las definiciones de tipo parcial. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164

La documentación de VB 2008 el código fuente a través de XML. . . . . . . . . . . . . . . . . . . . . . . . . . . .

165
Visualización de los frutos de nuestro trabajo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
nCHAPTER 6 Entendimiento Herencia y polimorfismo. . . . . . . . . . . . . 173
La mecánica básica de la herencia. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
La revisión de Visual Studio 2008 diagramas de clase. . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
El Segundo Pilar: Los detalles de la herencia. . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
Programación para la Contención / Delegación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
El tercer pilar: Apoyo polimórfica VB del 2008. . . . . . . . . . . . . . . . . . . . . . . . . 187
Entender clase base / derivada reglas de conversión de la clase. . . . . . . . . . . . . . . . . . . 198
La clase padre Maestro: [Link]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200
Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
nCHAPTER 7 Entendimiento estructurado de excepciones. . . . . . . . . . . . . 207
Oda a los errores, los errores y excepciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207
El papel de. Control de excepciones NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208
El ejemplo más simple posible. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210
Configuración del estado de una excepción. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214
Sistema de Nivel excepciones ([Link]). . . . . . . . . . . . . . . . . . . . . 218
Las excepciones de nivel de aplicación ([Link]). . . . . . . . . . . . . . . 219
Procesamiento de múltiples excepciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
El último bloque. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226
¿Quién está tirando ¿Qué? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
El resultado de las excepciones no controladas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228
Depuración de las excepciones no controladas utilizando Visual Studio 2008. . . . . . . . . . . . . . . 228
Combinando VB6 Error de procesamiento y control de excepciones estructurado. . . . . . . . . . 230
Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230
nCHAPTER 8 Descripción de objetos de por vida. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
Clases, objetos y referencias. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
Los fundamentos de la vida de objetos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234
El papel de las raíces de la aplicación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237
Entender Generaciones de objetos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239
El tipo de [Link]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240
Edificio finalizables objetos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243
Construcción de objetos desechables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246
Edificio finalizables y desechables Tipos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248
Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251
PARTE 3 n n n avanzada de programación VB
Construye
nCHAPTER 9 Trabajar con tipos de interfaz. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255
Descripción de los tipos de interfaz. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255
Definición de interfaces personalizadas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257
La implementación de una interfaz. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259
Interactuar con los tipos de interfaces de apoyo. . . . . . . . . . . . . . . . . . . . . . . . . . . . 262
Resolución de conflictos de nombres con la palabra clave Implements. . . . . . . . . . . . . . . . . . . 268
Edificio Enumerable tipos (IEnumerable e IEnumerator). . . . . . . . . . . . . . . 273
Construcción de objetos comparables (IComparable). . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280
Uso de interfaces como un mecanismo de devolución de
llamada. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285
Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289
nCHAPTER 10 colecciones, genéricos y tipos de datos que aceptan valores NULL. . . . . . . . . . . .
291
Los tipos no genéricos de [Link]. . . . . . . . . . . . . . . . . . . . . . . . . . . . 291
Espacio de nombres [Link]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 298
Entender Boxing y Unboxing Operaciones. . . . . . . . . . . . . . . . . . . . . . . . . 298
La seguridad de tipos y establecimiento inflexible de tipos de
colecciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302
El espacio de nombres [Link]. . . . . . . . . . . . . . . . . . . . . . . . . . . . 307
Descripción de los tipos de datos que aceptan valores NULL y la [Link] (Of T)
Tipo genérico. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310
Crear métodos genéricos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313
Creación de Estructuras Genéricas (o clases). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316
Creación de una colección genérica de encargo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317
Creación de interfaces genéricas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323
Creación de delegados genéricos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324
Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 326
nCHAPTER 11 delegados, eventos y expresiones lambda. . . . . . . . . . . . . . . . . . . . . . . . . . . . 327
Descripción de los tipos. Delegado NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327
El ejemplo más simple posible Delegado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331
La renovación de los coches tipo con los delegados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334
Entendimiento (y uso) Eventos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339
Definición de una "Prim-y correcta" de eventos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345
Definición de eventos establecimiento inflexible de tipos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . 347
Personalización del proceso de registro de eventos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348
Visual expresiones lambda de base. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352
Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357

nCHAPTER 12 sobrecarga de operadores y rutinas de conversión personalizados. . . 359

Entender sobrecarga de operadores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359
Los detalles de los tipos de valor y tipos de referencia. . . . . . . . . . . . . . . . . . . . . . . . . 365
Creación de rutinas de conversión personalizados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374
Definición de rutinas de conversión implícita. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377
La palabra clave DirectCast VB. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378
Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 381
nCHAPTER 13 VB 2008-Características del lenguaje específico. . . . . . . . . . . . . . . . . . . . . . . 383
Comprensión de tipos de datos implícitas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383
Entender los métodos de extensión. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 391
Comprender la sintaxis de objetos de inicializador. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 399
Descripción de los tipos anónimos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403
Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 408
nCHAPTER 14 Una introducción a LINQ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409
Comprender la función de LINQ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409
Un primer vistazo a las expresiones de consultas LINQ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412
LINQ y colecciones genéricas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417
LINQ y las colecciones no genéricas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 419
La representación interna de los operadores de consulta LINQ. . . . . . . . . . . . . . . . . . . . . 420
La investigación de los operadores de LINQ VB consulta. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 424
LINQ Consultas: Una isla para sí?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 432
Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 433
PARTE 4 n n n Programación con. NET
nCHAPTER 15 Introducción. NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 437
El papel de los ensamblados. NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 437
Entender el formato de una Asamblea. NET. . . . . . . . . . . . . . . . . . . . . . . . . . 439
La construcción de encargo. NET espacios de nombres. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 443
Construcción y consumo de una Asamblea de un solo archivo. . . . . . . . . . . . . . . . . . . . . . . . . 448
Construcción y Utilización de un ensamblado de varios archivos. . . . . . . . . . . . . . . . . . . . . . . . . . .
457
Entender Asambleas privada. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 460
Entender Asambleas compartido. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 466
El consumo de una Asamblea común. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 471
Configuración de Asambleas compartido. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 473
Entender Asambleas Editorial Política. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 477
Descripción de los elementos <codeBase>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 478

El espacio de nombres [Link]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 480

Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 481
nCHAPTER 16 Tipo de reflexión, el enlace, y atributo en función-
Programación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 483
La necesidad de metadatos tipo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 483
Comprender la reflexión. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 487
La construcción de un Visor de metadatos
personalizados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 490
Carga dinámica de Asambleas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 494
Reflexionando sobre Asambleas compartido. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 496
Comprender el enlace. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 498
Entender programación atribuido. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 500
Construcción de atributos personalizados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 505
Asamblea de nivel (y el módulo de nivel) Atributos. . . . . . . . . . . . . . . . . . . . . . . . . . 507
Reflexionando sobre Atributos Utilizar enlace anticipado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 509
Reflexionando sobre Atributos Utilizando el enlace. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 510
Poner la reflexión, el enlace y atributos personalizados en perspectiva. . . . . . 511
Creación de una aplicación extensible. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 511
Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 516
nCHAPTER 17 Procesos, dominios de aplicación, y contextos de objetos. . . . . . . . . . . . . . 517
Revisión de los procesos tradicionales de Win32. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 517
La interacción con los procesos de la Plataforma. NET. . . . . . . . . . . . . . . . . . . . . . 519
Entendimiento. NET dominio de aplicación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 526
Entender límites objeto de contexto. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 531
Resumiendo Procesos, dominios de aplicación, y el contexto. . . . . . . . . . . . . . . . . . . . . . 535
Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 536
nCHAPTER 18 Creación de aplicaciones multiproceso. . . . . . . . . . . . . . . . . . . . . . . . 537
El Proceso / AppDomain / Contexto / Relación con hilo. . . . . . . . . . . . . . . . . . . . 537
Una breve revisión del Delegado. NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 539
La naturaleza asíncrona de delegados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 541
La invocación de un método de forma asincrónica. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 542
El espacio de nombres [Link]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 547
La clase [Link]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 548
Programación Crear subprocesos secundarios. . . . . . . . . . . . . . . . . . . . . . . . . . 551
El tema de la concurrencia. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 556
Programación con temporizador devoluciones de
llamada. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 562
Comprender el ThreadPool CLR. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 564
El papel del componente BackgroundWorker. . . . . . . . . . . . . . . . . . . . . . . . . . 565
Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 569

nCHAPTER 19. NET Interoperabilidad Asambleas. . . . . . . . . . . . . . . . . . . . . . . . . . . . 571

El alcance de. NET Interoperabilidad. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 571
Un ejemplo sencillo de. NET para interoperabilidad COM. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 572
La investigación de la Asamblea. Interoperabilidad NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 575
Comprender el contenedor que se puede llamar tiempo de ejecución. . . . . . . . . . . . . . . . . . . . . . . . . .
. 578
El papel de IDL COM. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 580
El enlace a la coclase CoCalc. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 586
La construcción de una más interesante VB6 servidor COM. . . . . . . . . . . . . . . . . . . . . . . . . . . . 587
Examinando el ensamblado de interoperabilidad. . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . 590
Entender COM. NET Interoperabilidad. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 593
El papel de la Convención. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 595
El papel de la interfaz de clase. NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 596
Creación de una. Tipos de redes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 597
Generación de la biblioteca de tipos y registro de los tipos. NET. . . . . . . . . . . . . . . 600
Examinar la información de tipo exportados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 601
La construcción de un Visual Basic 6.0 cliente de prueba. . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . .
602
Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 603
PARTE 5 n n n Introducción a la clase. NET Base
Bibliotecas
nCHAPTER 20 y manipulación de archivos de Directorio. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 607
Explorando el espacio de nombres [Link]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 607
El Directorio (Info) y Archivo (Información) Tipos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 608
Trabajar con el tipo de DirectoryInfo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 609
Trabajar con el tipo de repertorio. . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . 613
Trabajo con la clase DriveInfo tipo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 614
Trabajo con la clase FileInfo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 615
Trabajar con el tipo de archivo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 618
La clase Stream Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 620
Trabajar con StreamWriters y StreamReaders. . . . . . . . . . . . . . . . . . . . . . . . 623
Trabajar con StringWriters y StringReaders. . . . . . . . . . . . . . . . . . . . . . . . . . 626
Trabajar con BinaryWriters y BinaryReaders. . . . . . . . . . . . . . . . . . . . . . . . . . 627
Programación "Ver" Archivos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 629
Archivo asincrónico Realización de E / S. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 631
Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 632
nCHAPTER 21 Presentación de la serialización de objetos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 633
Comprender la serialización de objetos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 633
Configuración de los objetos de la serialización. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 636

Elegir un formateador de serialización. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 637

Serialización de objetos de uso BinaryFormatter. . . . . . . . . . . . . . . . . . . . . . . . . . . 639
Serialización de objetos con el SoapFormatter. . . . . . . . . . . . . . . . . . . . . . . . . . . . 640
Serialización de objetos con el XmlSerializer. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 641
La persistencia de las colecciones de objetos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 644
Personalización del proceso de serialización. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 645
Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 651
nCHAPTER [Link] 22 Parte I: La Capa de Conexión. . . . . . . . . . . . . . . . . . . . . . . 653
Una definición de alto nivel de [Link]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 653
Comprender los proveedores de datos [Link]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 655
Los espacios de nombres adicionales de [Link]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
658
Los tipos del espacio de nombres [Link]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 658
Proveedores de abstracción de datos mediante interfaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 663
Creación de la base de datos AutoLot. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 665
El proveedor de datos de [Link] fábrica modelo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 671
Entender la capa de Conexión [Link]. . . . . . . . . . . . . . . . . . . . . . . . . 677
Trabajar con los lectores de datos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 682
La construcción de una biblioteca de datos reutilizables de acceso. . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . 684
Creación de una consola de Front End de interfaz de usuario basada en. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . 692
Acceso a datos asincrónico con SqlCommand. . . . . . . . . . . . . . . . . . . . . . . . . 697
Introducción a las transacciones de bases de datos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 698
Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 703
nCHAPTER 23 [Link] Parte II: La capa de desconectado. . . . . . . . . . . . . . . . . . . 705
Entender la capa desconectado de [Link]. . . . . . . . . . . . . . . . . . . . . . 705
Comprender la función del conjunto de datos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 706
Trabajar con DataColumn. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 709
Trabajar con objetos DataRow. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 711
Trabajar con tablas de datos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 715
Enlazar objetos DataTable a las interfaces de usuario. . . . . . . . . . . . . . . . . . . . . . . . . . . . 720
Llenado de DataSet / Objetos DataTable Con los adaptadores de datos. . . . . . . . . . . . . . . . . . . 730
Revisión [Link]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 733
Navegando Multitabled objetos DataSet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 736
Las herramientas de acceso a datos de Visual Studio 2008. . . . . . . . . . . . . . . . . . . . . . . . . . . . 742
La disociación autogenerados Código de la capa de interfaz de usuario. . . .. . . . . . . . . . . . . . . . . .
753
Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 756
nCHAPTER 24 Programación con el API de LINQ. . . . . . . . . . . . . . . . . . . . . . . . . . . . 759
El papel de LINQ to [Link]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 759
De programación con LINQ to DataSet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 760

De programación con LINQ to SQL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 765

Generación de clases de entidad Uso [Link]. . . . . . . . . . . . . . . . . . . . . . . . . . . 770
Construcción de clases de entidad utilizando Visual Studio 2008. . . . . . . . . . . . . . . . . . . . . . . . . 776
De programación con LINQ to XML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 779
El soporte integrado de XML de Visual Basic 2008. . . . . . . . . . . . . . . . . . . . . . . . 781
Creación de elementos de programación XML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 783
Creación de documentos XML mediante programación. . . . . . . . . . . . . . . . . . . . . . . . . . . . 785
Generación de documentos de las consultas LINQ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 787
Carga y análisis de contenido XML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 788
Navegando un documento XML en memoria. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 789
Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 794
nCHAPTER 25 Introducción a Windows Communication Foundation. . . . . . . . . 795
Un popurrí de la API de computación distribuida. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 795
El papel del Fondo de Operaciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
801
La investigación de las Asambleas de WCF Core. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 804
El Proyecto Estudio de WCF Plantillas de Visual. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 805
La composición básica de una aplicación de WCF. . . . . . . . . . . . . . . . . . . . . . . . . . . . 807
El ABC del Fondo de Operaciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
808
La construcción de un servicio WCF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 813
Que aloja el servicio WCF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 816
Aumento de la aplicación de cliente de WCF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 824
Utilizando el servicio WCF Biblioteca de plantillas de proyecto. . . . . . . . . . . . . . . . . . . . . . . . . 826
Que aloja el servicio de WCF como un servicio de Windows. . . . . . . . . . . . . . . . . . . . . . . . . 829
Invocación de un servicio de forma asincrónica. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 833
Diseño de contratos de WCF de datos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 835
Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 841
nCHAPTER 26 Introducción a Windows Workflow Foundation. . . . . . . . . . . . . . . . 843
Definir un proceso de negocio. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 843
Los ladrillos de la WF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 844
WF asambleas, espacios de nombres, y Proyectos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 850
La construcción de un flujo de trabajo simple aplicación compatible. . . . . . . . . . . . . . . . . . . . . . . . .
852
Examinando el motor de WF Hosting Código. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 856
La invocación de servicios Web dentro de flujos de trabajo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
859
La construcción de una Biblioteca WF código reutilizable. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
873
Unas breves palabras respecto a actividades personalizadas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
878
Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 879

PARTE 6 n n n de aplicaciones de escritorio con

Windows Forms
nCHAPTER 27 Introducción a Windows Forms. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 883
Listado de el espacio de nombres [Link]. . . . . . . . . . . . . . . . . . . . . 883
Trabajar con los tipos de formularios Windows Forms. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 885
El papel de la clase de aplicación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 887
La anatomía de un formulario. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 890
La funcionalidad de una clase de control. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 891
La funcionalidad de la clase de formulario. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 896
La construcción de aplicaciones para Windows con Visual Studio 2008. . . . . . . . . . . . . . . . . . . 900
Trabajar con MenuStrips y ContextMenuStrips. . . . . . . . . . . . . . . . . . . . . . . . 905
Trabajar con StatusStrips. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 913
Trabajar con ToolStrips. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 919
Construir una aplicación MDI. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 924
Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 927
nCHAPTER 28 de representación gráfica de datos con GDI +. . . . . . . . . . . . . . . . . . . . . . . . 929
Una encuesta de la GDI + Espacios de nombres. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 929
Una visión general del espacio de nombres [Link]. . . . . . . . . . . . . . . . . . . . . . . . 930
El [Link] Tipos de utilidad. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 931
Entender la clase Graphics. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 933
Entender sesiones de pintura. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 935
La GDI + Sistemas de coordenadas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 939
Definición de un valor de color. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 943
La manipulación de las fuentes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 945
Encuesta del espacio de nombres [Link].Drawing2D. . . . . . . . . . . . . . . . . . . 953
Trabajar con plumas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 953
Trabajar con pinceles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 957
Representación de imágenes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 963
Arrastrar y Hit Prueba del control PictureBox. . . . . . . . . . . . . . . . . . . . . . . . . 965
Entender el formato de Windows Forms de recursos. . . . . . . . . . . . . . . . . . . . . 973
Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 981
nCHAPTER 29 Programación con formularios Windows Forms. . . . . . . . . . . . . . . 983
El mundo de los controles de Windows Forms. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 983
Agregar controles a los formularios a mano. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 984
Agregar controles a formularios mediante Visual Studio 2008. . . . . . . . . . . . . . . . . . . . . . 986
Trabajar con los controles básicos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 987
Configurar el orden de tabulación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1003

Marco botón del formulario de entrada por defecto. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1004

Trabajo con controles más exóticos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1004
Creación de formularios personalizados de controles de
Windows. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1022
Prueba del tipo CarControl. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1028
La construcción de un host CarControl formulario
personalizado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1029
El papel del espacio de nombres [Link]. . . . . . . . . . . . . . . . . . . 1030
Construcción de cuadros de diálogo Personalizar. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1034
Dinámica de formularios Windows Forms Controles de posicionamiento. . . . . . . . . . . . . . . . . . . . . . .
1039
Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1043
PARTE 7 n n n de aplicaciones de escritorio con WPF
nCHAPTER 30 Introducción a Windows Presentation Foundation
y XAML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1047
La motivación detrás de WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1047
Las diferentes versiones de aplicaciones de WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1050
La investigación de las Asambleas de WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1053
La construcción de una aplicación de WPF (XAML gratuita). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1060
Detalles adicionales del tipo de aplicación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1063
Detalles adicionales del tipo de ventana. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1065
La construcción de una aplicación de WPF (XAML centrada). . . . . . . . . . . . . . . . . . . . . . . . . . . . 1070
La transformación de marcado en una Asamblea. NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . 1074
Separación de preocupaciones Usando archivos de código subyacente. . . . . . . . . . . . . . . . . . . . . . .
1078
La sintaxis de XAML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1080
Creación de aplicaciones WPF con Visual Studio 2008. . . . . . . . . . . . . . . . . . . . . 1091
Procesamiento de XAML en tiempo de ejecución: [Link]. . . . . . . . . . . . . . . . . . . . . .
1095
El papel de Microsoft Expression Blend. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1099
Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1101
nCHAPTER 31 Programar con los controles de WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . 1103
Una encuesta de la Biblioteca de controles de WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1103
La declaración de los controles en XAML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1106
Comprender la función de las propiedades de dependencia. . . . . . . . . . . . . . . . . . . . . . 1108
Descripción de los eventos enrutados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1112
Trabajar con tipos de botón. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1116
Trabajar con casillas de verificación y RadioButton. . . . . . . . . . . . . . . . . . . . . . . . . . . 1120
Trabajar con el control ListBox y tipos de ComboBox. . . . . . . . . . . . . . . . . . . . . . . . 1123
Trabajar con las áreas de texto. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1129
Diseño de Control de Contenido Utilización de los paneles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1131
Edificio del marco de una ventana usando paneles anidados. . . . . . . . . . . . . . . . . . . . . . . 1141
Entender los comandos de control de WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1147
xvi nCONTENTS

Descripción del modelo de enlace de datos de WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . 1150

Conversión de datos mediante IValueConverter. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1153
Establecer enlaces con objetos personalizados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1156
Vinculante Elementos de interfaz de usuario a los documentos
XML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1161
Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1165
nCHAPTER 32 WPF representación gráfica 2D, Recursos,
y temas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1167
La filosofía de WPF Servicios de representación gráfica. . . . . . . . . . . . . . . . . . . . 1167
Exploración de los tipos derivados de forma. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1175
Trabajar con pinceles de WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1177
Trabajar con plumas de WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1180
Exploración de los tipos derivados de dibujo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1181
El papel de las transformaciones de interfaz de
usuario. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1185
Descripción de los servicios de WPF Animación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1187
Descripción de los recursos del sistema de WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1195
Definición y Aplicación de estilos para los controles de WPF. . . . . . . . . . . . . . . . . . . . . . . . . . 1198
La alteración de la interfaz de usuario de un control mediante
plantillas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1207
Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1211
PARTE 8 n n n Construcción de Aplicaciones Web con
[Link]
nCHAPTER construcción de 33 páginas Web [Link]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1215
El papel de las HTTP. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1215
Básicos de las aplicaciones Web y servidores Web. . . . . . . . . . . . . . . . . . . . . . 1216
El papel de HTML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1219
El papel de las secuencias de comandos del lado del
cliente. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1224
Presentar el Formulario de datos (GET y POST). . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1226
La construcción de una página ASP clásico. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1227
Problemas con ASP clásico. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1229
Los espacios de nombres de [Link]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1230
La página Web [Link] Modelo de código. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1231
Detalles de una estructura del sitio Web de [Link]. . . . . . . . . . . . . . . . . . . . . . 1242
El ciclo de compilación de [Link] página. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1243
La cadena de herencia de tipo de página. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1246
Interactuar con la solicitud HTTP entrante. . . . . . . . . . . . . . . . . . . . . . . . . . . 1247
Interactuar con la respuesta de salida HTTP. . . . . . . . . . . . . . . . . . . . . . . . . . 1250
El ciclo de vida de una página Web [Link]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1252
El papel del archivo [Link]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1256
Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1259

nCHAPTER 34 Web [Link], Temas y páginas maestras. . . . . . . 1261

Comprender la naturaleza de los controles Web. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1261
El tipo de [Link]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1263
Los miembros clave del tipo [Link]. . . . . . . . 1267
Categorías de los controles web de [Link]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1267
La construcción de un sitio web [Link]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1269
El papel de los controles de validación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1285
Trabajar con los temas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1289
Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1295
nCHAPTER 35 de estado de [Link] Técnicas de Gestión. . . . . . . . . . . . . . . . . . . 1297
El tema de Estado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1297
Técnicas de administración de estados de [Link]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1299
Comprender la función de estado de vista de [Link]. . . . . . . . . . . . . . . . . . . . . . . . . 1300
El papel del archivo [Link]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1303
Comprenda la distinción entre período de sesiones. . . . . . . . . . . . . . . . . . . . . . 1305
Trabajar con el caché de la aplicación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1310
Mantener datos de sesión. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1315
Comprender las cookies. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1318
El papel del Elemento <sessionState>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1321
Comprender la API perfil de [Link]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1324
Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1330
nIndex. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1331

La filosofía de. NET

Cada pocos años o menos, el programador de hoy en día deben estar dispuestos a realizar una
auto-infligidas
trasplante de conocimientos para mantenerse al día con las nuevas tecnologías de la jornada. Los
lenguajes (C + +,
Visual Basic 6.0, Java), marcos (OWL, MFC, ATL, STL), arquitecturas (COM, CORBA, EJB), y
API (incluyendo. NET Windows Forms y bibliotecas GDI +) que fueron desplazadas por las balas de
plata
desarrollo de software con el tiempo convertido en sombra de algo mejor o por lo menos
algo nuevo. A pesar de la frustración que puede sentir cuando se actualiza el conocimiento interno
base, es francamente inevitable. Para ello, este libro examina los detalles del curso de Microsoft
ofreciendo dentro del paisaje de la ingeniería de software. NET platformand la última versión de
el lenguaje de Visual Basic de programación.
El punto de este capítulo es sentar las bases conceptuales para el resto del libro. Es
comienza con una discusión de alto nivel de una serie de. NET temas relacionados, tales como
asambleas, el común
Intermediate Language (CIL), y justo a tiempo (JIT). Además de la vista previa
algunas de las características clave del lenguaje de programación Visual Basic 2008, también
llegará a entender
la relación entre varios aspectos de. NET Framework, como el común
Language Runtime (CLR), el sistema de tipos común (CTS), y el Common Language Specification
(CLS).
Este capítulo también le proporciona una visión general de la funcionalidad proporcionada por el.
NET
bibliotecas de clase base, a veces abreviado como el BCL o, alternativamente, como el FCL (siendo
el
Marco de las bibliotecas de clases). Por último, este capítulo se investiga el lenguaje-agnóstico y
platformindependent
la naturaleza de la plataforma. NET (sí, es verdad!. NET no se limita a la familia de Windows
de los sistemas operativos). Como era de esperar, la mayoría de estos temas se analizan en mucho
más
detalle en el resto de este texto.
Comprender el estado anterior de Asuntos
Antes de examinar los detalles del universo. NET, es útil considerar algunas de las cuestiones que
motivado la génesis de la actual plataforma de Microsoft. Para entrar en la mente correcta-set,
vamos a comenzar este
capítulo con una breve lección de historia y sin dolor para recordar nuestras raíces y entender las
limitaciones
de la situación anterior. Después de completar este rápido recorrido por la vida como la conocía,
que a su vez
nuestra atención a los numerosos beneficios que proporciona Visual Basic 2008 y la plataforma.
NET.
La vida como un programador de la API C/Win32
Tradicionalmente, el desarrollo de software para la familia de sistemas operativos Windows que
participan
utilizando el lenguaje de programación C en relación con la programación de aplicaciones Windows
de interfaz (API) y el Windows Software Development Kit (SDK). Si bien es cierto que numerosos
aplicaciones se han creado con éxito utilizando este enfoque de larga tradición, pocos de nosotros
estaría de acuerdo
que la creación de aplicaciones utilizando la materia prima de la API / SDK es una tarea compleja.

El problema obvio primera es que C es un lenguaje muy conciso. los desarrolladores de C se ven
obligados a enfrentarse
con la administración manual de memoria, aritmética de punteros complejo, y lo feo construcciones
sintácticas.
Además, dado que C es un lenguaje de procedimiento, carece de los beneficios proporcionados por
el orientado a objetos
enfoque. Cuando se combinan los miles de funciones globales y tipos de datos definidos por el
la API de Windows a una lengua ya formidable, no es de extrañar que no son tan numerosos buggy
aplicaciones flotando en la actualidad.
La vida como un C + + / MFC Programador
Una gran mejora con respecto primas C / API de desarrollo es el uso de C + + lenguaje de
programación.
En muchos sentidos, C + + puede ser considerado como una capa orientada a objetos en la parte
superior de C. Por lo tanto, a pesar de que
C + + beneficio de los programadores de la famosa "pilares de la programación orientada a objetos"
(encapsulación, herencia y polimorfismo),
todavía están a merced de los aspectos dolorosos de la lengua C (por ejemplo, la memoria manual
gestión, la aritmética de punteros complejo, y las construcciones sintácticas fea).
A pesar de su complejidad, C + + muchos marcos existen en la actualidad. Por ejemplo, el Microsoft
Foundation
Clases (MFC) proporciona al programador un conjunto de clases C + + que simplifica la
construcción
de las aplicaciones de Windows. La principal función de MFC es envolver un "subconjunto sana" de
la materia prima de la API de Windows
detrás de un número de clases y numerosas herramientas de generación de código (también
conocido como magos). Independientemente de la
ayuda ayuda que ofrece el marco de trabajo MFC (así como muchos otros C + + basado en
herramientas), el
hecho del asunto es que C + + sigue siendo una experiencia difícil y propenso a errores, debido a su
raíces históricas en C.
La vida como una aplicación de Visual Basic 6.0 del programador
Debido a un sincero deseo de disfrutar de un estilo de vida más simples, muchos programadores
evitarse el mundo de C (++)-
marcos basada por completo en favor de la más amable, más suave lenguajes como Visual Basic
6.0 (VB6).
VB6 es muy popular debido a su capacidad de crear sofisticadas interfaces gráficas de usuario
(GUI), código
bibliotecas (por ejemplo, servidores de ActiveX), y la lógica de acceso a datos con un mínimo de
alboroto y molestias. Mucho más
de MFC, VB6 oculta la complejidad de la materia prima de la API de Windows de la vista utilizando
una serie de servicios integrados
asistentes de programación, tipos de datos intrínsecos, clases y funciones específicas de VB6.
La principal limitación de VB6 (que ha sido rectificada, dada la aparición de la plataforma. NET) es
que no es un lenguaje totalmente orientado a objetos, sino que es ". objeto de conocimiento" Por
ejemplo, VB6 no
permiten al programador establecer "es-un" relaciones entre los tipos (es decir, sin la herencia
clásica)
y no tiene apoyo intrínseco a la construcción de clase con parámetros. Por otra parte, VB6 no
proporciona
la capacidad de crear aplicaciones multiproceso a menos que esté dispuesto a bajar a bajo nivel
Llamadas API de Windows (que es el mejor de los complejos y peligrosos en el peor).
Vida Como un Programador Java/J2EE
Introduzca Java. Java es un lenguaje de programación orientado a objetos que tiene sus raíces
sintácticos en C + +. Como
muchos de ustedes saben, los puntos fuertes de Java son mucho mayores que su apoyo a la
independencia de la plataforma.
Java (como lengua) se limpia muchos aspectos desagradables sintácticas de C + +. Java (como
plataforma) proporciona
programadores con un gran número predefinido de "paquetes" que contienen varios tipos
definiciones. El uso de estos tipos, los programadores de Java pueden construir "100% puro de
Java" aplicaciones
completa con la conectividad de base de datos, soporte de mensajería, web-enabled interfaces, y un
escritorio ricos
interfaz de usuario (UI).
Aunque Java es un lenguaje muy elegante, un problema potencial es que el uso de Java
normalmente
significa que usted debe usar Java front-to-back "durante el ciclo de desarrollo. En efecto, Java
ofrece poco
esperanza de la integración del lenguaje, ya que esto va en contra del objetivo principal de Java (un
único de programación
idioma para todas las necesidades). En realidad, sin embargo, hay millones de líneas de código
existente a cabo
hay en el mundo que lo ideal sería que se mezclan con los nuevos código Java. Lamentablemente,
Java hace que esta
tarea problemática.

Pura de Java a menudo no es apropiado para muchas aplicaciones de forma gráfica o numérica
intensiva
(En estos casos, es posible que la velocidad de ejecución de Java deja mucho que desear). Una
mejor
enfoque de este tipo de programas sería utilizar un lenguaje de bajo nivel (como C + +) en su caso.
Una vez más, mientras que Java proporciona una capacidad limitada a un acceso no-Java API, hay
poco apoyo
para una verdadera integración entre lenguajes.
Vida Como programador COM
El Modelo de objetos componentes (COM) fue el primer intento de Microsoft en un marco unificado
de componentes.
COM es una arquitectura que dice en efecto: "Si usted construye sus clases de acuerdo con la
reglas del COM, se termina con un bloque de código binario reutilizables ".
La belleza de una versión binaria del servidor COM es que se puede acceder de forma
independiente del lenguaje.
Así, los programadores de VB6 puede construir clases COM que puede ser utilizada por C + +.
Delphi
los programadores pueden utilizar las clases COM construido usando C, y así sucesivamente. Sin
embargo, como es de su conocimiento,
COM independencia del lenguaje es algo limitado. Por ejemplo, no hay manera de obtener un nuevo
COM clase mediante una clase COM existentes (como COM no tiene soporte para la herencia
clásica).
Otro de los beneficios del COM es su naturaleza ubicación transparente. Uso de construcciones
tales como la aplicación
identificadores (AppID), talones, proxies, y el entorno de ejecución de COM, los programadores
pueden
evitar la necesidad de trabajar con sockets, manual de llamadas a procedimiento remoto, y otros de
bajo nivel
detalles. Por ejemplo, considere lo siguiente VB6 código de cliente COM:
"El tipo MyComClass se puede escribir en
"Cualquier idioma COM-consciente, y puede ser ubicado en cualquier lugar
'En la red (incluyendo el equipo local).
Dim myObj Como MyComClass
Establecer myObj = Nueva MyComClass 'Localización resuelven utilizando AppID.
[Link]
A pesar de COM puede ser considerado como un modelo de objetos de gran éxito, es muy complejo
bajo el capó. Para ayudar a simplificar el desarrollo de los binarios COM, numerosos COM-
consciente
marcos han venido a la existencia (sobre todo VB6). Sin embargo, el marco de apoyo solo
no es suficiente para ocultar la complejidad del COM. Incluso cuando se elige una manera
relativamente simple COMaware
lenguaje como Visual Basic 6, que todavía se ven obligados a lidiar con las entradas de registro y
frágiles
numerosas cuestiones relacionadas con la implementación (en adelante denominado el infierno
DLL).
Vida Como un Programador de ADN de Windows
Para complicar más las cosas, hay una pequeña cosa llamada Internet. En los últimos años,
Microsoft ha estado agregando más características tanto de Internet-en su familia de sistemas
operativos y
los productos. Lamentablemente, la creación de una aplicación web mediante COM distribuido
basado en Windows Aplicaciones de Internet
Arquitectura (DNA) es también muy compleja.
Parte de esta complejidad se debe al simple hecho de que Windows DNA requiere el uso de
numerosas
tecnologías y lenguajes (ASP, HTML, XML, JavaScript, VBScript, COM (+), así como los datos de
un
acceso a la API como ADO). Un problema es que muchas de estas tecnologías no tienen ninguna
relación
desde el punto de vista sintáctico. Por ejemplo, JavaScript tiene una sintaxis muy similar a C,
mientras que VBScript es un
subconjunto de Visual Basic 6. Los servidores COM que se crean para ejecutar en el marco del
COM + en tiempo de ejecución tienen un completo
diferentes apariencia de las páginas ASP que los invoca. El resultado es una muy confusa
mezcolanza
de las tecnologías.
Además, y quizás más importante, cada lengua y / o tecnología tiene su propio tipo
sistema (que puede parecer nada que ver con el tipo de sistema de otra persona). Más allá del
hecho de que cada API de buques con
su propia colección de código prefabricadas, tipos de datos más básicos no siempre se puede tratar
de forma idéntica.
Un BSTR en C + + no es lo mismo que una cadena en Visual Basic 6, los cuales tienen muy poco
que ver con una
Char * en C.

La solución. NET
Hasta aquí la breve lección de historia. La conclusión es que la vida como programador de Windows
ha sido
menos que perfecto. . NET Framework es un enfoque más radical y de fuerza bruta a la
racionalización
el proceso de desarrollo de aplicaciones. La solución propuesta por. NET es "Cambiar todo" (lo
siento,
no se puede culpar al mensajero por el mensaje). Como se puede ver durante el resto de este libro,
. NET Framework es un modelo completamente nuevo para la construcción de sistemas de la
familia de Windows
sistemas operativos, así como en numerosos sistemas operativos que no sean de Microsoft, tales
como Mac OS X y
varios Unix / Linux. Para establecer el escenario, aquí es un rápido resumen de algunas de las
características fundamentales
cortesía de NET.:
• interoperabilidad completa con código existente: Esto es (por supuesto) una buena cosa. ActiveX
componentes pueden mezclar (es decir, de interoperabilidad) con las nuevas aplicaciones. NET y
viceversa.
Además, los servicios de invocación de plataforma (PInvoke) le permite llamar a bibliotecas de C-
base (incluyendo
el API subyacente del sistema operativo) de código. NET.
• Integración entre lenguajes de programación NET.. NET soporta la herencia entre lenguajes,
error entre lenguajes, manipulación y depuración entre lenguajes de código.
• Un motor de ejecución común compartida por todos NET-consciente. Uno de los aspectos de este
motor es un
tipo bien definido sistema de que cada lengua. NET-consciente "entiende".
• Una biblioteca de clases base amplia: Esta biblioteca proporciona refugio de la complejidad de las
materias primas
Llamadas a la API de Windows y ofrece un modelo de objetos compatible utilizado por todos los
idiomas. NET-consciente.
• No más de plomería COM: Legacy interfaces COM (como IUnknown e IDispatch), COM
bibliotecas de tipos, y el tipo de variante COM centrada en los datos no tienen cabida en un nativo.
NET binario.
• Un modelo de implementación verdaderamente simplificado. Bajo NET, no hay necesidad de
registrar una unidad binaria
en el registro del sistema. Por otra parte,. NET permite que múltiples versiones de la misma *. dll
para
conviven en armonía en una sola máquina.
Como se puede más probable es que se reúnen a partir de las viñetas anteriores, la plataforma.
NET no tiene nada que
ver con COM (más allá del hecho de que tanto los marcos de origen de Microsoft). De hecho, el
único
manera. NET y COM tipos pueden interactuar unos con otros está utilizando la capa de
interoperabilidad.
nNota cobertura de la capa de interoperabilidad. NET se puede encontrar en el capítulo 19.
Introducción a los bloques de construcción del. NET
Plataforma (CLR, CTS, y CLS)
Ahora que usted sabe algunos de los beneficios proporcionados por. NET, vamos a ver tres
principales (y sí)
entidades que lo hacen posible: el CLR, CTS, y CLS. Desde el punto de vista del programador,.
NET
puede ser entendida como un entorno de ejecución y una nueva biblioteca de clases base amplia. El
tiempo de ejecución
capa se refiere correctamente como el Common Language Runtime o CLR. La función principal de
la
CLR es localizar, cargar y administrar. Tipos de redes en su nombre. El CLR también se ocupa de
un número
de los detalles de bajo nivel como la gestión de la memoria, la carga de bibliotecas externas, y la
seguridad de realizar
cheques.
Otro bloque de construcción de la red. Platformis el sistema de tipos común, o CTS. El CTS
especificación describe completamente el sistema de tipos de base y construcciones de
programación con el apoyo de el tiempo de ejecución, especifica cómo estas entidades pueden
interactuar entre sí, y los detalles de cómo se representan
en el formato de metadatos. NET (más información sobre metadatos más adelante en este capítulo).
Entender que un hecho. NET consciente de no ser compatible con todos y cada función
definido por el CTS. El Common Language Specification (CLS) es una especificación relacionados
que
define un subconjunto de tipos comunes y construcciones de programación que todos. NET
lenguajes de programación
puede estar de acuerdo. Por lo tanto, si usted construye. Tipos NET que sólo exponen las
características compatibles con CLS, que
puede estar seguro de todo eso. NET-consciente puede consumir. Por el contrario, si usted hace
uso de un
tipo de datos o construcción de programación que está fuera de los límites de la ETI, no se puede
garantizar
que todos los idiomas de programación. NET puede interactuar con el. colección NET.
El papel de las bibliotecas de clases base
Además del CLR y CTS y especificaciones CLS, la plataforma. NET proporciona una biblioteca de
clases base
que está disponible para todos los lenguajes de programación. NET. No sólo la biblioteca de clases
base de encapsular
primitivas diversos, tales como las discusiones, el archivo de entrada / salida (E / S), la
representación gráfica, y la interacción
con varios dispositivos de hardware externo, sino que también proporciona soporte para una serie
de servicios
requerido por la mayoría de aplicaciones del mundo real.
Por ejemplo, las bibliotecas de clases base que definen tipos de facilitar el acceso de base de datos,
documento XML
la manipulación, la seguridad programática, y la construcción de la web habilitada (así como
tradicionales de escritorio y la consola basada en) frente a los extremos. Desde un alto nivel, se
puede visualizar la relación
entre el CLR, CTS, CLS, y la biblioteca de clases base, como se muestra en la Figura 1.1.
Figura 1-1. La clase CLR, CTS, CLS, y la base de la colección de la relación
Lo que Visual Basic 2008 trae a la mesa
Debido a que. NET es un cambio radical de anteriores tecnologías de Microsoft, debe quedar claro
que las lenguas legado basado en COM, como Visual Basic 6 no puede integrar directamente con la
plataforma. NET.
Teniendo en cuenta este hecho, Microsoft introdujo un lenguaje de programación nuevo, Visual
Basic. NET
(VB. NET), con el lanzamiento de. NET 1.0. Como desarrolladores aprendieron rápidamente, a
pesar de VB. NET tenía una similar
apariencia de VB6, introdujo un gran número de nuevas palabras clave y las construcciones que
muchos programadores (incluyéndome a mí) con el tiempo considerado VB. NET como un nuevo
miembro de la BASE
de la familia en lugar de "Visual Basic 7.0."

Por ejemplo, a diferencia de VB6, VB. NET proporciona a los desarrolladores un idioma en toda
regla orientada a objetos
que es tan poderoso como lenguajes como C + +, Java o C #. Por ejemplo, utilizando Visual Basic.
NET,
los desarrolladores pueden crear aplicaciones multiproceso de escritorio, páginas web y servicios
web XML;
definir personalizado subrutinas de construcción de clase, los miembros de la sobrecarga, y definir
las funciones de devolución de llamada
(A través de delegados). En pocas palabras, aquí están algunas de las principales características
proporcionadas por cortesía de VB. NET:
• Soporte completo de la herencia clásica y el polimorfismo clásica.
• establecimiento inflexible de tipos palabras clave para definir clases, estructuras, enumeraciones,
delegados e interfaces.
Teniendo en cuenta estas nuevas palabras clave, código de Visual Basic. NET es siempre
contenida dentro de un archivo *. vb (en
contraste con el VB6 centrada *. cls, *. bas y *. frm).
• Soporte completo para las técnicas de programación basadas en la interfaz.
• Soporte completo para la programación basada en atributos. Esta marca de desarrollo que permite
tipos de anotar y sus miembros para calificar aún más su comportamiento (más detalles en
Capítulo 16).
Con el lanzamiento de. NET 2.0, la VB. NET lenguaje de programación se conoce como Visual
Basic 2005 (VB 2005). Mientras VB 2005 es totalmente compatible con Visual Basic. NET, agregó
numerosas
nuevas campanas y silbatos adicionales, la mayoría de notabilidad lo siguiente:
• La capacidad de redefinir cómo los operadores intrínsecos de la lengua (como el símbolo +) puede
ser
interpretada por las clases personalizadas o estructuras. Formalmente, esta característica se
denomina
la sobrecarga de operadores.
• La introducción del espacio de nombres My. Este espacio de nombres proporciona acceso
instantáneo a machineand
información específica del proyecto (que reduce en gran medida la cantidad de código que necesita
para
autor de forma manual).
• La capacidad de construir los tipos genéricos y los miembros de genéricos. Uso de medicamentos
genéricos, que son capaces de construir
código muy eficiente y con seguridad de tipos que define numerosos "marcadores" que se
especifican en el momento
que interactúan con el tema genérico.
• La capacidad de personalizar el proceso de registrar, anular el registro o envío de eventos
utilizando el
Personalizada de palabras clave.
• Apoyo a la firma tipos de datos (SByte, ULong, etc.)
• La capacidad de definir un tipo único a través de múltiples archivos de código utilizando la palabra
clave Partial.
Como puede imaginar,. NET 3.5 añade aún más funcionalidad a la programación de Visual Basic
idioma (ahora oficialmente llamado Visual Basic 2008), incluyendo las características básicas
siguientes:
• Apoyo a la inflexible instrucciones de consulta (a la LINQ Language Integrated Query), que
puede interactuar con una variedad de almacenes de datos (bases de datos, documentos XML,
objetos de colección)
• Soporte para los tipos anónimos, que permiten rápidamente modelo de la "forma" de un tipo más
bien
de su comportamiento
• La capacidad de extender la funcionalidad de un tipo compilado utilizando métodos de extensión
• Apoyo a las expresiones lambda, que simplifican en gran medida la forma en que puede trabajar.
Delegar NET
tipos
• Una sintaxis de inicialización de objetos nuevos, que le permite establecer valores de propiedad en
el momento de
creación de objetos
Tal vez el punto más importante para entender acerca de Visual Basic 2008 es que sólo puede
producir código que puede ejecutar en el tiempo de ejecución. NET (por lo tanto, nunca podría usar
VB 2008 para
construir un nativo de ActiveX del servidor COM). Oficialmente, el término utilizado para describir el
código de selección

el tiempo de ejecución. NET es código administrado. La unidad binario que contiene el código
administrado se denomina
conjunto (más detalles en las asambleas en tan sólo un poco). Por el contrario, el código que no
puede ser alojado directamente
el tiempo de ejecución. NET que se denomina código no administrado.
Adicional. NET-Aware lenguajes de programación
Entender que Visual Basic 2008 no es el único lenguaje que puede ser usado para construir
aplicaciones. NET.
Cuando la plataforma. NET fue revelado por primera vez al público en general durante el 2000
Microsoft
Conferencia de Desarrolladores Profesionales (PDC), varios proveedores anunciaron que estaban
ocupados construyendo
. versiones de NET-conscientes de sus compiladores respectivos.
En el momento de escribir estas líneas, decenas de lenguas diferentes se han sometido. NET
iluminación.
Además de los cinco idiomas que se incluyen con Visual Studio 2008 (Visual Basic 2008, C #, J #, C
+ + / CLI,
y JScript. NET), los hay. NET compiladores para Smalltalk, COBOL y Pascal (por nombrar algunos).
Aunque este libro se centra (casi) exclusivamente en Visual Basic 2008, tenga en cuenta lo
siguiente
sitio web (por favor, tenga en cuenta que esta dirección URL está sujeto a cambios):
[Link]
Una vez que haya navegado a esta página, haga clic en el enlace situado en Recursos superior de
la página
menú del sistema. Aquí encontrará una lista de numerosas. lenguajes de programación NET y
enlaces de interés
donde se pueden descargar diversos compiladores (ver Figura 1-2).
Figura 1-2. . NET es uno de los muchos sitios que documentan conocidos. lenguajes de
programación NET

Aunque supongo que son los principales interesados en la construcción. Programas NET utilizando
la sintaxis de
VB 2008, le animo a visitar este sitio, usted está seguro de encontrar. NET vale la pena investigar
en su tiempo libre (LISP. NET, cualquier persona?).
La vida en un mundo multilingüe
Como desarrolladores primero en llegar a comprender la naturaleza independiente del idioma de.
NET, numerosas preguntas
surgir. El más frecuente de estas preguntas tendría que ser: "Si todos. NET compilar abajo
con "el código administrado," ¿por qué necesitamos más de un compilador? "Hay un número de
maneras de
responder a esta pregunta. En primer lugar, los programadores son mucho muy particular cuando se
trata de nuestra elección
del lenguaje de programación (me incluyo). Algunos prefieren idiomas llena de puntos y comas y
rizado
corchetes, con la mayor número posible de palabras clave (como C #, C + + y J #). Otros disfrutan
de un lenguaje que
ofrece más "legible" la sintaxis (como Visual Basic 2008). Y otros lo desea, puede aprovechar
sus habilidades mainframe mientras se mueve a la plataforma. NET (a través de COBOL. NET).
Ahora, sea honesto. Si Microsoft fuera a construir un sencillo "oficial". NET que se deriva
de la familia de los lenguajes C, se puede decir que realmente todos los programadores estaría feliz
con este
elección? O, si la única "oficial". NET se basa en la sintaxis de Fortran, imagina toda la gente
por ahí que pasaría por alto. NET por completo. Debido a que el tiempo de ejecución. NET no
podría importarme menos que
el lenguaje se utiliza para construir una asamblea. programadores NET puede permanecer fiel a sus
preferencias sintácticas,
y compartir el código compilado entre los compañeros de equipo, departamentos y organizaciones
externas
(Independientemente de que. Otras NET optar por el uso).
Otro subproducto de la excelente integración de varios. NET en un software unificado
solución es el simple hecho de que todos los lenguajes de programación tienen su propio conjunto
de fortalezas
y debilidades. Por ejemplo, algunos lenguajes de programación ofrecen un excelente soporte
intrínseco para
tratamiento matemático avanzado. Otros ofrecen un rendimiento superior para cálculos financieros,
lógica
cálculos, la interacción con los ordenadores centrales, y así sucesivamente. Cuando usted toma los
puntos fuertes de un
lenguaje de programación en particular y luego incorporar los beneficios proporcionados por la
plataforma. NET,
todo el mundo gana.
Por supuesto, en realidad las posibilidades son bastante buenas que usted pasará la mayor parte de
su tiempo de construcción
software usando el archivo. NET de su elección. Sin embargo, una vez que aprender la sintaxis de
uno. NET,
es muy fácil de dominar a otro. Esto también es muy beneficioso, sobre todo a los consultores de
el mundo. Si el idioma de su elección pasa a ser Visual Basic 2008, pero se colocan en un cliente
sitio que se ha comprometido a C #, que todavía son capaces de aprovechar la funcionalidad de.
NET Framework,
y usted debería ser capaz de entender la estructura general de la base de código con un mínimo
esfuerzo y
molesta. No digo más.
Una visión general de. NET
A pesar de que. Binarios NET tomar la misma extensión de archivo como servidores COM y no
administrado
Los binarios de Windows (*. dll o *. exe), no tienen absolutamente ninguna similitud interna. Por
ejemplo,. NET
asambleas no se describen el uso de bibliotecas COM tipo y no están registrados en el registro del
sistema.
Quizás lo más importante. NET binarios no contienen instrucciones específicas de la plataforma,
pero
en lugar de lenguaje intermedio independiente de la plataforma (IL), así como tipo de metadatos.
Figura 1-3 muestra el
panorama de la historia hasta el momento
nNota Hay un punto que se hizo en relación con la abreviatura "IL." Durante el desarrollo de. NET, el
funcionario
plazo para la IL fue el lenguaje intermedio de Microsoft (MSIL). Sin embargo, con la versión final de.
NET 1.0, el término se
cambió el lenguaje común intermedio (CIL). Por lo tanto, al leer la literatura. NET, entender que la
IL, MSIL,
y del CIL están describiendo la entidad exactamente la misma. De acuerdo con la terminología
actual, voy a utilizar la abreviatura
CIL lo largo de este texto.
Cuando un *. dll o *. exe ha sido creado con un compilador. NET-aware, el módulo resultante es
incluido en un ensamblado. Usted examinará numerosos detalles de. NET en el capítulo 15.
Sin embargo, para facilitar el debate sobre el entorno de ejecución. NET, es necesario entender
algunas propiedades básicas de este nuevo formato de archivo.
Como se mencionó, un ensamblado contiene código CIL, que es conceptualmente similar al
bytecode de Java
en que no se compila con las instrucciones específicas de la plataforma hasta que sea
absolutamente necesario. Por lo general,
"Absolutamente necesario" es el punto en el que un bloque de instrucciones del CIL (tales como una
implementación de método)
se hace referencia para su uso por el tiempo de ejecución. NET.
Además de las instrucciones del CIL, las asambleas también contienen metadatos que describen
con gran detalle
las características de cada "tipo" que viven en el binario. Por ejemplo, si usted tiene una clase
denominada
Sportscar, el tipo de metadatos describe detalles como clase base Sportscar, que las interfaces son
implementado por Sportscar (si procede), así como una descripción completa de cada miembro con
el apoyo de la
tipo Sportscar.
. Metadatos NET es una mejora dramática en los metadatos de tipos COM. Como usted ya sabe,
binarios COM suelen ser descritos mediante una biblioteca de tipos asociados (que es poco más
que una
versión binaria de la interfaz de lenguaje de definición de código [IDL]). Los problemas con la
información de tipo COM
es que no se garantiza la presencia y el hecho de que el código IDL no tiene forma de documento
los servidores de referencia externa que se requieren para el correcto funcionamiento de la actual
OCM
servidor. Por el contrario,. Metadatos NET está siempre presente y es generado automáticamente
por un hecho. NetAware
compilador.
Por último, además de CIL y tipo de metadatos, conjuntos de ellos también se describen con
metadatos, que es oficialmente llamado un manifiesto. El manifiesto contiene información acerca de
la actual
versión de la asamblea, información de referencia cultural (utilizado para la localización de cadenas
y recursos de imagen),
y una lista de todos los conjuntos de referencias externas que son necesarios para la correcta
ejecución. Usted examinará
diversas herramientas que pueden utilizarse para investigar los tipos de un ensamblado, metadatos,
y se manifiestan
información sobre el curso de los próximos capítulos.

Un solo archivo y las Asambleas de varios archivos

En un gran número de casos, no es simple-a-uno entre un. NET
y el archivo binario (*. dll o *. exe). Por lo tanto, si usted está construyendo una red. *. Dll, que es
seguro tener en cuenta que
el binario y la asamblea son una misma cosa. Del mismo modo, si usted está construyendo un
escritorio ejecutable
aplicación, el archivo *. exe, simplemente se puede denominar como la propia asamblea. Como se
verá en el capítulo 15,
Sin embargo, esto no es completamente exacto. Técnicamente hablando, si un conjunto se
compone de un
*. dll único o un módulo *. exe, tiene un montaje de un solo archivo. conjuntos de un solo archivo
contendrá todos los
CIL es necesario, metadatos, y se manifiestan asociados de manera autónoma, solo paquete, bien
definidos.
conjuntos de varios archivos, por otra parte, se componen de numerosas. NET binarios, cada uno
de
que se denomina un módulo. Cuando se construye un ensamblado de múltiples archivos, uno de
estos módulos (denominado
módulo de primaria) debe contener el manifiesto del ensamblado (y posiblemente las instrucciones
del CIL y los metadatos
para varios tipos). Los módulos de los demás contienen un manifiesto de nivel de módulo, CIL, y
tipo de metadatos.
Como se puede sospechar, los documentos primarios módulo de la serie de módulos requeridos
secundaria
en el manifiesto del ensamblado.
Así que, ¿por qué optar por crear un ensamblado de múltiples? Al particionar el conjunto en
módulos discretos, usted termina con una opción de implementación más flexibles. Por ejemplo, si
un usuario se hace referencia
un montaje remoto que necesita ser descargado en su máquina, el tiempo de ejecución
sólo descargar los módulos necesarios. Por lo tanto, usted es libre de construir su conjunto de tal
manera que los tipos con menos frecuencia requerida (por ejemplo, un tipo con nombre
HardDriveReformatter) se mantienen en un
separados módulo independiente.
Por el contrario, si todos los tipos se colocaron en un ensamblado de un solo archivo, el usuario final
puede terminar
la descarga de una gran parte de los datos que no es realmente necesario (que es, obviamente, una
pérdida de tiempo).
Por lo tanto, como se puede ver, una asamblea es en realidad una agrupación lógica de uno o
varios módulos relacionados que
están destinados a ser inicialmente desplegadas y versionados como una sola unidad.
El papel de la Lengua Común Intermedio
Ahora que usted tiene una mejor idea. NET, vamos a examinar el papel del intermedio común
idioma (CIL) en un poco más de detalle. CIL es un lenguaje que se sitúa por encima de cualquier
particular, platformspecific
conjunto de instrucciones. Sin importar qué. NET consciente de que usted elija, los asociados
compilador emite instrucciones de la CIL. Por ejemplo, el siguiente de Visual Basic 2008 modelos de
código trivial
calculadora. No se preocupe por la sintaxis exacta, por ahora, pero se dan cuenta el formato de la
Agregar () en la clase Calc:

' [Link]
Imports System
Namespace CalculatorExample
' Defines the program's entry point.
Module Program
Sub Main()
Dim ans As Integer
Dim c As New Calc()
ans = [Link](10, 84)
[Link]("10 + 84 is {0}.", ans)
[Link]()
End Sub
End Module
' The VB 2008 calculator.
Class Calc
Public Function Add(ByVal x As Integer, ByVal y As Integer) As Integer

Return x + y
End Function
End Class
End Namespace

Una vez que el compilador de VB 2008 ([Link]) compila este archivo de código fuente, se termina
con una sola fila
ensamblado ejecutable que contiene un manifiesto, las instrucciones de la CIL, y los metadatos que
describen cada
aspecto de los tipos de Calc y Programa.
Capítulo nNota 2 examina los detalles de la compilación de código mediante el compilador de VB.
Si se va a abrir este conjunto con la utilidad [Link] (examinado un poco más adelante en este
capítulo), se verá que el método Add () se representa mediante la CIL como las siguientes:

.method public instance int32 Add(int32 x, int32 y) cil managed

{
// Code size 9 (0x9)
.maxstack 2
.locals init ([0] int32 Add)
IL_0000: nop
IL_0001: ldarg.1
IL_0002: ldarg.2
IL_0003: [Link]
IL_0004: stloc.0
IL_0005: br.s IL_0007
IL_0007: ldloc.0
IL_0008: ret
} // end of method Calc::Add

No se preocupe si usted no puede hacer cara o cruz del código CIL que resulta de este método.
En realidad, la gran mayoría de los desarrolladores. NET importa un bledo los detalles de la
programación del CIL
idioma. Basta con entender que el Visual Basic 2008 compilador traduce el código
estados en términos de la CIL.
Ahora bien, recordemos que esto es cierto de todos los compiladores. NET-consciente. Para ilustrar,
supongamos que ha creado este
misma aplicación usando C #, en lugar de VB 2008 (de nuevo, no sudan la sintaxis, pero tenga en
cuenta las similitudes
en las bases de código):

// [Link]
using System;
namespace CalculatorExample
{
// Defines the program's entry point.
public class Program
{
static void Main()
{
Calc c = new Calc();
int ans = [Link](10, 84);
[Link]("10 + 84 is {0}.", ans);
[Link]();
}
}
CHAPTER 1 ■ THE PHILOSOPHY OF .NET 13
// The C# calculator.
public class Calc
{
public int Add(int x, int y)
{ return x + y; }
}
}

Si examina el CIL para el método Add (), usted encontrará las instrucciones similares (ligeramente
modificado por
el compilador de C #):

.method public hidebysig instance int32 Add(int32 x, int32 y) cil managed

{
// Code size 8 (0x8)
.maxstack 2
.locals init ([0] int32 CS$1$0000)
IL_0000: ldarg.1
IL_0001: ldarg.2
IL_0002: add
IL_0003: stloc.0
IL_0004: br.s IL_0006
IL_0006: ldloc.0
IL_0007: ret
} // end of method Calc::Add
archivos nSource El Código [Link] y [Link] código se incluyen en el Capítulo 1 subdirectorio.
Beneficios del CIL
En este punto, puede que se pregunte exactamente lo que se gana por el código fuente de la
compilación en CIL
en lugar de directamente a un conjunto de instrucciones específicas. Una de las ventajas es la
integración del lenguaje. Como usted ha
ya hemos visto, cada compilador. NET-consciente produce instrucciones CIL casi idénticos. Por lo
tanto, todos los
idiomas se resuelven en un campo binario bien definido que hace uso del mismo tipo misma
del sistema.
Además, dado que la CIL es independiente de la plataforma, el. NET Framework en sí es
platformagnostic,
proporcionar los mismos beneficios que los desarrolladores de Java se han acostumbrado a (es
decir, un solo código
la base se ejecuta en sistemas operativos múltiples). De hecho,. distribuciones NET ya existen para
muchos
no los sistemas operativos Windows (más detalles en la conclusión de este capítulo). En contraste
con la
Plataforma J2EE, sin embargo,. NET permite crear aplicaciones que utilizan el idioma de su
elección.
CIL Compilación de las Instrucciones sobre plataformas específicas
Debido al hecho de que las asambleas contienen instrucciones CIL, en lugar de las instrucciones
específicas de la plataforma,
Código CIL debe ser compilado en la marcha antes de su uso. La entidad que compila el código CIL
en sentido
Instrucciones de la CPU que se denomina un "justo a tiempo (JIT), que a veces va por el ambiente
nombre de la inquietud. . NET aprovecha entorno de ejecución de un compilador JIT para cada CPU
orientación de la
tiempo de ejecución, cada uno optimizado para la plataforma subyacente.
Por ejemplo, si usted está creando una aplicación. NET que se va a implementar en un dispositivo
portátil
(como un Pocket PC o. NET teléfono celular habilitado), la correspondiente fluctuación está bien
equipado para ejecutar
dentro de un ambiente de poca memoria. Por otro lado, si va a implementar el ensamblado a una

máquina de back-end del servidor (donde la memoria es rara vez un problema), el jitter será
optimizado para
funcionar en un entorno de alta memoria. De esta forma, los desarrolladores pueden escribir un solo
cuerpo de código
que puede ser eficiente JIT compila y ejecuta en máquinas con arquitecturas diferentes.
Por otra parte, como un hecho la inquietud compila las instrucciones de CIL en código máquina
correspondiente,
en caché los resultados en la memoria de una manera adecuada para el sistema operativo de
destino. De esta manera, si un
llamada se realiza a un método denominado PrintDocument (), las instrucciones del CIL se compilan
en platformspecific
instrucciones que aparecen en la primera invocación y retenido en la memoria para su uso posterior.
Por lo tanto, el
la próxima vez PrintDocument () se llama, no es necesario volver a compilar el CIL.
El papel de. Metadatos Tipo NET
Además de las instrucciones del CIL, un montaje. NET contiene metadatos plena, completa y
precisa,
que describe cada uno y todo tipo (clase, estructura, enumeración, etc) se define en el
binarios, así como los miembros de cada tipo (propiedades, funciones, eventos, etc). Por suerte,
siempre es el trabajo del compilador (no el programador) para definir el tipo de metadatos últimos y
más grandes.
Porque. metadatos NET es tan perversamente meticuloso, las asambleas son totalmente auto-
descripción
entidades-tanto es así, de hecho, que. NET binarios no necesitan ser registrados en el sistema
Registro.
Para ilustrar el formato de. metadatos NET, echemos un vistazo a los metadatos que se ha
generado para el método Add () de la clase VB Calc analizadas (los metadatos generados
de la versión de C # del método Add () es similar):

TypeDef #2 (02000003)
-------------------------------------------------------
TypDefName: [Link] (02000003)
Flags : [Public] [AutoLayout] [Class]
[AnsiClass] [BeforeFieldInit] (00100001)
Extends : 01000001 [TypeRef] [Link]
Method #1 (06000003)
-------------------------------------------------------
MethodName: Add (06000003)
Flags : [Public] [HideBySig] [ReuseSlot] (00000086)
RVA : 0x00002090
ImplFlags : [IL] [Managed] (00000000)
CallCnvntn: [DEFAULT]
hasThis
ReturnType: I4
2 Arguments
Argument #1: I4
Argument #2: I4
2 Parameters
(1) ParamToken : (08000001) Name : x flags: [none] (00000000)
(2) ParamToken : (08000002) Name : y flags: [none] (00000000)

A pesar de lo que puede pensar, los metadatos es una entidad muy útil (en lugar de un académico
detalle) consumida por los numerosos aspectos del entorno de ejecución. NET, así como por
diversos
herramientas de desarrollo. Por ejemplo, la característica IntelliSense que proporciona Visual Studio
2008, se
posible mediante la lectura de los metadatos de un ensamblado en tiempo de diseño. Los
metadatos también es utilizado por varios objectbrowsing
utilidades, herramientas de depuración, y el Visual Basic 2008 se compilador. Para estar seguros,
los metadatos se
la columna vertebral de numerosas. NET incluyendo Windows Communication Foundation,
servicios de la reflexión, a finales instalaciones vinculante, los servicios web XML / la. capa NET
Remoting, y el objeto
serialización proceso. Capítulo 16 formalizará el papel de. NET metadatos.

El papel de los ensamblados de manifiestos

Por último pero no menos importante, recuerde que un montaje. NET también contiene metadatos
que describen el
montaje en sí (técnicamente se denomina un manifiesto). Entre otros detalles, los documentos de
manifiesto todos los
ensamblados externos requeridos por la Asamblea actual para que funcione correctamente, la
versión de la asamblea
número, la información de copyright, etc. Al igual que tipo de metadatos, es siempre el trabajo del
compilador
para generar el manifiesto del ensamblado. Éstos son algunos de los detalles relevantes del
manifiesto generado
al compilar el archivo de código [Link] visto anteriormente en este capítulo (suponemos que indica
el compilador
a nombre de nuestra asamblea [Link]):

.assembly extern mscorlib

{
.publickeytoken = (B7 7A 5C 56 19 34 E0 89 )
.ver [Link]
}
...
.assembly Calc
{
...
.ver [Link]
}
.module [Link]
.imagebase 0x00400000
.subsystem 0x00000003
.file alignment 512
.corflags 0x00000001

En pocas palabras, este documento manifiesta la lista de ensamblados externos requeridos por
[Link] (a través de
la asamblea. directivas externa), así como diversas características de la propia Asamblea (versión
número, nombre del módulo, etc.) Capítulo 15 examinará la utilidad de los datos del manifiesto en la
mayor parte
más detalles.
Comprender el sistema de tipos común
Un montaje de la propuesta puede contener cualquier número de distintos "tipos". En el mundo de.
NET, "tipo " es simplemente
un general termused para referirse a un miembro del conjunto {clase, interfaz, estructura,
enumeración, delegado}.
Al crear soluciones usando un lenguaje. NET-consciente, lo más probable es interactuar con
cada uno de estos tipos. Por ejemplo, el ensamblado puede definir una sola clase que implementa
algunos
número de interfaces. Tal vez uno de los métodos de interfaz tiene una enumeración como una
entrada
parámetro y devuelve una estructura a la persona que llama.
Recordemos que el sistema de tipos común (CTS) es una especificación formal de que el número
de documentos tipos
deben ser definidos con el fin de ser acogida por el CLR. Normalmente, los únicos individuos que
están profundamente
relacionados con el funcionamiento interno de la CTS son las herramientas para la construcción y /
o compiladores que se dirigen a
el. NET. Es importante, sin embargo, para todos. NET a aprender acerca de cómo trabajar
con los cinco tipos definidos por el CTS en el idioma de su elección. He aquí una breve descripción.
CTS tipos de clase
Todos los idiomas. NET-consciente apoya, por lo menos, la noción de un tipo de clase, que es la
piedra angular
de la programación orientada a objetos (POO). Una clase puede estar compuesto de cualquier
número de
miembros (por ejemplo, propiedades, métodos y eventos) y los puntos de datos (datos de campo,
también conocido
como variables miembro). En Visual Basic 2008, las clases se declaran mediante la palabra clave de
clase:

' A class type.

Public Class Calc
Public Function Add(ByVal x As Integer, ByVal y As Integer) As Integer
Return x + y
End Function
End Class

Si usted tiene experiencia en el desarrollo de clases VB6, tenga en cuenta que los tipos de clase ya
no son
definido dentro de un archivo *. cls, dado el hecho de que ahora tenemos una palabra clave
específica para la definición de clase
tipos (recordemos que todo el código VB se encuentra ahora dentro de los archivos *. vb). Los
capítulos 5 y 6 se examinará la
detalles de la construcción de tipos de clases con Visual Basic 2008.
CTS tipos de interfaz
Una interfaz no es más que una colección con nombre de definiciones de miembros que pueden
contar con el apoyo
(es decir, ejecutado) por una determinada clase o estructura. A diferencia de COM, interfaces. NET
no obtengan un común
de base, tales como la interfaz IUnknown. En VB 2008, los tipos de interfaz se definen mediante la
interfaz
palabra clave, por ejemplo:

' Classes or structures that implement this interface

' know how to render themselves.
Public Interface IDraw
Sub Draw()
End Interface

Por su cuenta, las interfaces son de poca utilidad. Sin embargo, cuando una clase o estructura
implementa una propuesta
interfaz en su forma única, usted puede solicitar el acceso a la funcionalidad proporcionada
mediante un
referencia de la interfaz de "manera polimorfa". interfaz de programación basada Se explora la
en el capítulo 9.
CTS tipos de estructura
El concepto de una estructura también se formalizó en el marco del CTS. En pocas palabras, una
estructura puede ser
pensado como una alternativa ligera a los tipos de clase, que tienen una semántica basada en
valores (véase
Capítulo 12 para más detalles). Por lo general, las estructuras son más adecuadas para la
modelización numérica, geométrica,
o tipos de datos matemáticos y se crean en Visual Basic 2008 utilizando la palabra clave de la
estructura:

' A structure type.

Public Structure Point
Public xPos As Integer
Public yPos As Integer
Public Sub New(ByVal x As Integer, ByVal y As Integer)
xPos = x
yPos = y
End Sub
Public Sub Display()
[Link]("({0}, {1}", xPos, yPos)
End Sub
End Structure

CTS Enumeration Types

Enumerations are a handy programming construct that allows you to group name/value pairs. For
example, assume you are creating a video game application that allows the player to select one of
three character categories (Wizard, Fighter, or Thief). Rather than keeping track of arbitrary numerical
values to represent each possibility, you could build a custom enumeration using the VB 2008
Enum keyword:

' An enumeration type.

Public Enum CharacterType
Wizard = 100
Fighter = 200
Thief = 300
End Enum

Las demandas de CTS que los tipos enumerados derivan de una clase base común, [Link].
Como
verá en el capítulo 4, esta clase base define un número de miembros interesantes que le permiten
extraer, manipular y transformar el nombre de base / valor mediante programación.
CTS tipos de delegado
Los delegados son quizás los más complejos de tipo NET;. Sin embargo, son muy importantes, ya
que son
para formthe fundación de la arquitectura de eventos. NET. Para estar seguro, en cualquier
momento que desee para manejar
el clic de un botón, la actividad del ratón interceptar, o proceso de devoluciones de datos en un
servidor web, los delegados
ser utilizado en el fondo. En pocas palabras, un delegado se utiliza para almacenar las direcciones
de método que se puede
invocada en un momento posterior. En Visual Basic 2008, los delegados se declaran usando la
palabra clave Delegado:

' This delegate type can "point to" any method

' returning an integer and taking two integers as input.
Public Delegate Function BinaryOp(ByVal x As Integer, _
ByVal y As Integer) As Integer

Capítulos 11 y 18 se examinarán los detalles de. NET delegado, incluyendo numerosos asociados
detalles tales como la multidifusión (es decir, el reenvío de una solicitud a varios destinatarios) y
asincrónica
(es decir, sin bloqueo) invocaciones de método.
nNota 2008 VB proporciona numerosas palabras clave (véase el capítulo 11) que eliminan la
necesidad de definir manualmente delegado
tipos. Sin embargo, son capaces de definir los delegados directamente cuando se desea construir
más compleja y potente
soluciones.
CTS miembros de tipo
Ahora que ha visto previamente cada uno de los tipos formalizado por la CTS, se dan cuenta que la
mayoría de tipos
puede contener cualquier número de miembros. Formalmente hablando, un miembro de tipo se ve
limitada por el conjunto
{constructor, finalizador, constructor de la residencia, tipo anidado, operador, método, propiedad,
paso a paso, el campo,
campo de sólo lectura, un evento constante,}.
El CTS define varios "adornos" que pueden estar asociados con un miembro determinado. Por
ejemplo,
cada miembro tiene un nivel de visibilidad dada marcados con un determinado VB 2008 la palabra
clave (por ejemplo, pública,
Privado, protegido, etc.) Algunos miembros pueden ser declarados como "abstracto" para hacer
cumplir una polimórficos
comportamiento de los tipos derivados, así como "virtual" para definir una lata (pero reemplazables)
la aplicación.
Además, la mayoría de los miembros puede ser configurado como compartido (consolidados en el
nivel de clase) o instancia (consolidados a el nivel de objeto). La construcción de los miembros de
tipo se examina en el transcurso de los próximos varios
capítulos.
nNota Como se describe en el capítulo 10, Visual Basic 2008 admite la construcción de los tipos
genéricos y los miembros de genéricos.
Intrínseca CTS tipos de datos
El aspecto final de la CTS a tener en cuenta por el momento es que establece un conjunto bien
definido
de tipos de datos fundamentales. A pesar de una lengua dada normalmente tiene una palabra clave
única para
declarar una CTS intrínseca tipo de datos, todas las palabras clave del lenguaje en última instancia
resolver al mismo tipo
definido en un ensamblado denominado [Link]. Considere la tabla 1-1, que documenta cómo
las principales CTS
tipos de datos se expresan en diversos. NET.

Table 1-1. The Intrinsic CTS Data Types

CTS Data Type VB 2008 Keyword C# Keyword C++/CLI Keyword
[Link] Byte byte unsigned char
[Link] SByte sbyte signed char
System.Int16 Short short short
System.Int32 Integer int int or long
System.Int64 Long long __int64
System.UInt16 UShort ushort unsigned short
System.UInt32 UInteger uint unsigned int or unsigned long
System.UInt64 ULong ulong unsigned __int64
[Link] Single float float
[Link] Double double double
[Link] Object object Object^
[Link] Char char wchar_t
[Link] String string String^
[Link] Decimal decimal Decimal
[Link] Boolean bool bool

nNota palabras clave VB para firmar los tipos de datos (SByte, UShort, UInteger y ULong) sólo se
admiten en
. NET 2.0 o superior.
Comprender el lenguaje común
Especificación
Como ustedes saben, las diferencias lingüísticas expresar la misma programación en
construcciones únicas,
términos específicos del lenguaje. Por ejemplo, en VB 2008 se suele denotar la concatenación de
cadenas con

el creador "y" comercial (&), mientras que en C # siempre hacer uso del signo más (+). Incluso
cuando dos
lenguas distintas expresa el mismo lenguaje de programación (por ejemplo, un método sin valor de
retorno), el
es muy probable que la sintaxis se parece bastante diferente en la superficie:

' A VB 2008 subroutine.

Public Sub MyMethod()
' Some interesting code...
End Sub
// A C# method with no return value.
public void MyMethod()
{
// Some interesting code...
}

Como ya hemos visto, estas variaciones sintácticas menores son insignificantes a los ojos de
el tiempo de ejecución. NET, ya que los compiladores respectiva ([Link] o [Link], en este caso)
emiten una similar
conjunto de instrucciones de la CIL. Sin embargo, el lenguaje también puede variar con respecto a
su nivel general de
funcionalidad. Por ejemplo, un lenguaje. NET puede o no tener una palabra clave para representar
sin firmar
datos, y puede o no puede apoyar los tipos de puntero. Teniendo en cuenta estas posibles
variaciones, lo ideal sería
tener una línea de base a la cual todos los idiomas. NET-consciente se espera que los conforman.
El Common Language Specification (CLS) es un conjunto de reglas que describen con gran detalle
la
conjunto mínimo y completa de las características de un hecho. NET-consciente debe apoyar para
producir código
que puede ser organizado por el CLR, mientras que al mismo tiempo tener acceso en un
uniformmanner por todos los idiomas
que se dirigen a la plataforma. NET. En muchos sentidos, el CLS puede ser visto como un
subconjunto del total
funcionalidad definida por el CTS.
El CLS es en última instancia, un conjunto de reglas que los constructores compilador debe
conformto, si pretenden que su
productos para funcionar a la perfección en el universo. NET. Cada regla se le asigna un nombre
sencillo (por ejemplo,
"CLS artículo 6") y describe cómo esta norma afecta a los que construyen los compiladores, así
como los
que (de alguna manera) interactuar con ellos. La crème de la crème de la ETI es la regla de un
poderoso:
• Artículo 1: reglas de CLS se aplican sólo a las partes de un tipo que se exponen fuera de la
definición
asamblea.
Teniendo en cuenta esta regla, se puede (correctamente) inferir que los artículos restantes de la ETI
no se aplican a la
lógica utilizada para construir el funcionamiento interno de un tipo. NET. Los únicos aspectos de un
tipo que debe cumplir
el CLS son las definiciones miembros ellos mismos (es decir, convenciones de nombres,
parámetros y
tipos de cambio). La lógica de ejecución de un miembro puede utilizar cualquier número de técnicas
no-CLS,
como el mundo exterior no notará la diferencia.
Para ilustrar esto, el siguiente método Add () no es compatible con CLS, como los parámetros y
volver
los valores de hacer uso de los datos sin signo (que no es un requisito de la cls):

Public Class Calc

' Exposed unsigned data is not CLS compliant!
Public Function Add(ByVal x As ULong, ByVal y As ULong) As ULong
Return x + y
End Function
End Class

Sin embargo, si usted fuera a hacer simplemente uso de los datos internos sin firmar de la siguiente
manera:

Public Class Calc

Public Function Add(ByVal x As Integer, ByVal y As Integer) As Integer
' As this ULong variable is only used internally,
' we are still CLS compliant.
Dim temp As ULong = 0

Return x + y
End Function
End Class

usted tendría que aún se ajustaban a las normas de la ETI, y puede estar seguro de que todos los.
NET
son capaces de invocar el método Add ().
Por supuesto, además de con el artículo 1, el CLS define muchas otras reglas. Por ejemplo, el CLS
describe cómo una lengua determinada internamente debe representar cadenas de texto, ¿cómo
debe ser enumeraciones
representan internamente (el tipo de base utilizada para el almacenamiento), la forma de definir los
miembros de la residencia, y así sucesivamente.
Afortunadamente, usted no tiene que cometer estas normas a la memoria para ser un experto.
Desarrollador NET. Una vez más,
por lo general, una comprensión íntima de la CTS y las especificaciones de CLS es sólo de interés
para
herramienta / constructores compilador.
Velar por el cumplimiento CLS
Como se verá a lo largo de este libro, VB 2008 se define una programación de algunas
construcciones que
no son compatibles con CLS. La buena noticia, sin embargo, es que puede indicar al compilador
para VB 2008
verifique el código de compatibilidad con CLS mediante un único atributo. NET:
"Dile que el compilador para comprobar la compatibilidad con CLS.
<Assembly: [Link](True)>
El capítulo 16 se sumerge en los detalles de la programación basada en atributos. Hasta entonces,
sólo tiene que entender
que el atributo <CLSCompliant()> dará instrucciones al compilador de VB 2008 para revisar todas y
cada línea de código en contra de las reglas del CLS. Si cualquier violaciónes CLS se descubren,
recibirá un
compilador de error y una descripción del código de ofender.
Comprender el Common Language Runtime
Además de las especificaciones de CTS y CLS, el próximo TLA (abreviatura de tres letras) que
sostienen
con en este momento es el CLR. Programación hablando, el tiempo de ejecución término puede ser
entendido
como un conjunto de servicios externos que se requieren para ejecutar una determinada unidad de
código compilado. Por
ejemplo, cuando los desarrolladores hacer uso de la Microsoft Foundation Classes (MFC) para crear
una nueva
aplicación, que son conscientes de que su programa requiere la biblioteca MFC en tiempo de
ejecución (por ejemplo, [Link]).
Otros lenguajes populares también tienen un tiempo de ejecución correspondiente. programadores
VB6 también atado a un
tiempo de ejecución del módulo o dos (por ejemplo, [Link]). los desarrolladores de Java
están vinculados a la Máquina Virtual de Java
(JVM) y así sucesivamente.
La plataforma. NET ofrece un nuevo sistema de ejecución. La diferencia clave entre el. NET
tiempo de ejecución y los tiempos de ejecución de los demás que acabo de mencionar es el hecho
de que el tiempo de ejecución. NET proporciona
un solo tiempo de ejecución bien definidos capa que es compartida por todos los idiomas y
plataformas que están. NetAware.
El quid de la CLR está físicamente representada por una [Link] colección con nombre
(también conocido como el Común
Objeto motor de tiempo de ejecución de ejecución). Cuando se hace referencia a una asamblea
para el uso, es [Link]
cargado automáticamente, lo que a su vez carga el ensamblado necesario en la memoria. El motor
de tiempo de ejecución
es responsable de una serie de tareas. En primer lugar, es la entidad encargada de resolver el
ubicación de una asamblea y la constatación del tipo solicitado en el binario al leer el contenido
metadatos. El CLR a continuación, establece el tipo en la memoria, compila el CIL asociados en
platformspecific
instrucciones, realiza todas las comprobaciones de seguridad necesarias, y luego ejecuta el código
en
que se trate.
Además de cargar los ensamblados personalizados y la creación de tipos personalizados, el CLR
también interactúan con los tipos contenidos en las bibliotecas. NET clase base cuando sea
necesario. Aunque
la biblioteca de base de toda la clase se ha dividido en una serie de asambleas discreto, el conjunto
de claves
es [Link]. [Link] contiene un gran número de tipos básicos que encierran una gran
variedad

de tareas de programación comunes, así como los tipos de datos básicos utilizados por todos los
idiomas. NET. Cuando se
construir. soluciones NET, automáticamente tendrá acceso a esta asamblea en particular.
Figura 1-4 ilustra el flujo de trabajo que se lleva a cabo entre el código fuente (que está haciendo
uso de tipos de base de biblioteca de clases), un hecho. NET, y el motor de ejecución de. NET.
Figura 1-4. [Link] en acción
La Asamblea / Espacio de nombres / Distinción Tipo
Cada uno de nosotros entiende la importancia de las bibliotecas de código. El punto de las
bibliotecas que se encuentran dentro de Visual Basic 6,
J2EE, o MFC es dar a los desarrolladores un conjunto bien definido de código existente para
aprovechar en sus aplicaciones.
Sin embargo, el lenguaje Visual Basic 2008 no viene con una biblioteca de código específico del
lenguaje. Por el contrario,
VB 2008 los desarrolladores aprovechar el idioma. bibliotecas NET. Para mantener todos los tipos
dentro de la
bibliotecas de clases base bien organizada, la plataforma. NET hace un uso extensivo del concepto
de espacio de nombres
En pocas palabras, un espacio de nombres es un conjunto de tipos correspondientes que figuran en
una asamblea. Por ejemplo,
el espacio de nombres [Link] contiene el archivo I / O-tipos relacionados, el espacio de
nombres [Link] define el centro de
tipos de base de datos de acceso, el espacio de nombres [Link] define elementos
de la GUI, y así sucesivamente. Es
muy importante señalar que un solo conjunto (como [Link]) puede contener cualquier número
de espacios de nombres, cada uno de los cuales puede contener cualquier número de tipos (clases,
interfaces, estructuras, enumeraciones,
o delegados).
Para aclarar, la Figura 1-5 muestra una captura de pantalla de la utilidad de Visual Studio 2008
objetos de Brower (usted
aprender más acerca de esta herramienta en el capítulo 2). Esta herramienta le permite examinar
los ensamblados de referencia
por la solución actual, los espacios de nombres dentro de un conjunto particular, los tipos dentro de
un determinado
espacio de nombres, y los miembros de un tipo específico. Tenga en cuenta que [Link]
contiene diversas
espacios de nombres, cada uno con sus propios tipos semánticamente relacionados.
Figura 1-5. Un montaje único puede tener cualquier número de espacios de nombres.
La diferencia fundamental entre este enfoque y una biblioteca específica del lenguaje, tales como la
API de Java
es que cualquier orientación por idioma el tiempo de ejecución. NET hace uso de los mismos
espacios de nombres y los mismos tipos.
Por ejemplo, los siguientes tres programas de todos los ilustrar el omnipresente "Hello World ",
escrito en Visual Basic 2008, C # y C + + / CLI:

' Hello world in VB 2008

Imports System
Public Module MyApp
Sub Main()
[Link]("Hi from VB 2008")
End Sub
End Module
// Hello world in C#
using System;
public class MyApp
{
static void Main()
{
CHAPTER 1 ■ THE PHILOSOPHY OF .NET 23

[Link]("Hi from C#");

}
}
// Hello world in C++/CLI
#include "stdafx.h"
using namespace System;
int main(array<System::String ^> ^args)
{
Console::WriteLine(L"Hi from C++/CLI");
return 0;
}
Tenga en cuenta que cada lengua está haciendo uso de la clase Console, que se define dentro de
un espacio de nombres
nombre del sistema. Más allá de las variaciones sintácticas menores, estas tres aplicaciones de
apariencia muy
muy parecidos, tanto física como lógica.
Claramente, su objetivo principal como desarrollador de. NET es llegar a conocer la riqueza de tipos
definidos en
los (numerosos). NET espacios de nombres. El espacio de nombres más fundamentales para
conseguir sus manos en torno a es
nombre del sistema. Este espacio de nombres proporciona un cuerpo de la base de los tipos que
tendrá que aprovechar el tiempo
y otra vez como un desarrollador de. NET. De hecho, no se puede construir cualquier tipo de
funcional. NET
sin al menos hacer una referencia al espacio de nombres System. Cuadro 1.2 ofrece un resumen de
algunos
(pero ciertamente no todos) de los espacios de nombres. NET.

Table 1-2. A Sampling of .NET Namespaces

.NET Namespace Meaning in Life
System Within System you find numerous useful types dealing with
intrinsic data, mathematical computations, random
number generation, environment variables, and garbage
collection, as well as a number of commonly used
exceptions and attributes.
[Link] These namespaces define a number of stock container
[Link] types, as well as base types and interfaces that allow you to
build customized collections.
[Link] These namespaces are used for interacting with relational
[Link] databases using [Link].
[Link]
[Link]
[Link]
[Link] These namespaces define numerous types used to work
[Link] with file I/O, compression of data, and port manipulation.
[Link]
[Link] These namespaces define types that support runtime
[Link] type discovery as well as dynamic creation of types.
[Link] This namespace provides facilities to allow .NET types to
interact with “unmanaged code” (e.g., C-based DLLs and
COM servers) and vice versa.
[Link] These namespaces define types used to build desktop
[Link] applications using .NET’s original UI toolkit (Windows
Forms).
24 CHAPTER 1 ■ THE PHILOSOPHY OF .NET

.NET Namespace Meaning in Life

[Link] The [Link] namespace is the root for several new
[Link] namespaces (introduced with .NET 3.0) that represent the
[Link] Windows Presentation Foundation UI toolkit.
[Link] These namespaces define types used when programming
[Link] against the LINQ API.
[Link]
[Link] This is one of many namespaces that allow you to build
[Link] web applications and XML web services.
[Link] This is one of many namespaces used to build distributed
applications using the (.NET 3.0–centric) Windows
Communication Foundation API.
[Link] These are two of many namespaces that define types used
[Link] to build “workflow-enabled” applications using the .NET 3.0
Windows Workflow Foundation API.
[Link] This namespace defines numerous types to build
multithreaded applications.
[Link] Security is an integrated aspect of the .NET universe. In the
security-centric namespaces, you find numerous types
dealing with permissions, cryptography, and so on.
[Link] The XML-centric namespaces contain numerous types used
to interact with XML data.

nNota el capítulo 2 se ilustra el uso del. NET Framework 3.5 SDK, que proporciona detalles
con respecto a cada espacio de nombres y el tipo que se encuentran en las bibliotecas de clases
base.
Acceso a un espacio de nombres mediante programación
Vale la pena reiterar que el espacio de nombres no es más que una manera conveniente para
nosotros los simples humanos
para comprender y organizar lógicamente los tipos relacionados. Consideremos de nuevo el espacio
de nombres System. Desde
su perspectiva, se puede asumir que [Link] representa una clase denominada consola
que se
contenida dentro de un espacio de nombres denominado System. Sin embargo, a los ojos del
tiempo de ejecución. NET, esto no es
así. El motor de tiempo de ejecución sólo se ve una sola entidad llamada [Link].
En Visual Basic 2008, la palabra clave importaciones simplifica el proceso de los tipos de referencia
se define en el
un espacio de nombres en particular. Así es como funciona. Digamos que usted está interesado en
la construcción de una tradicional
aplicación de escritorio. La ventana principal hace un gráfico de barras basado en alguna
información obtenida
a partir de una base de datos de back-end y muestra el logotipo de su empresa. Si bien el
aprendizaje de los tipos cada espacio de nombres
se contiene el estudio y experimentación, he aquí algunos posibles candidatos a la referencia en
su programa:

' Here are all the namespaces used to build this application.
Imports System ' General base class library types.
Imports [Link] ' Graphical rendering types.
Imports [Link] ' GUI widget types.
Imports [Link] ' General data-centric types.
Imports [Link] ' MS SQL Server data access types

Una vez especificado un número de espacios de nombres (y establecer una referencia a las
asambleas
que los definen, que se explica en el capítulo 2), usted es libre de crear instancias de los tipos que
contienen. Por ejemplo, si usted está interesado en la creación de una instancia de la clase Bitmap
(definido en el
Espacio de nombres [Link]), puede escribir lo siguiente:

' Explicitly list the namespaces used by this file.

Imports System
Imports [Link]
Public Class Program
Public Sub DisplayLogo()
' Create a 20 x 20 pixel bitmap.
Dim companyLogo As New Bitmap(20, 20)
...
End Sub
End Class

Debido a que su aplicación es la importación de [Link], el compilador es capaz de

resolver el
Mapa de bits de clase como miembro de este espacio de nombres. Si no ha especificado el espacio
de nombres [Link],
que se publicará un error del compilador. Sin embargo, usted es libre de declarar variables con un
completo
nombre, así:

' Not listing [Link] namespace!

Imports System
Public Class Program
Public Sub DisplayLogo()
' Create a 20 x 20 pixel bitmap.
Dim companyLogo As New [Link](20, 20)
...
End Sub
End Class

Si bien la definición de un tipo utilizando el nombre completo proporciona una mayor facilidad de
lectura, creo que había
de acuerdo en que la palabra clave de Visual Basic 2008 las importaciones reduce las pulsaciones
de teclado. En este texto, voy a evitar el uso de la plena
nombres completos (a menos que exista una ambigüedad definida por resolver) y optar por el
procedimiento simplificado
enfoque de la palabra clave Imports.
Sin embargo, recuerde siempre que esta técnica es simplemente una notación abreviada para
especificar un
tipo es totalmente nombre completo, y teniendo en cuenta los resultados de cada enfoque en el
exacto mismo CIL subyacente (el
hecho de que el código CIL siempre hace uso de los nombres completos) y no tiene ningún efecto
sobre el rendimiento o
el tamaño del ensamblado generado.
Hacer referencia a ensamblados externos
Además de especificar un espacio de nombres a través de la palabra clave de Visual Basic 2008 las
importaciones, también hay que decir la
VB 2008 compilador el nombre del ensamblado que contiene la definición real de la CIL referencia
tipo. Como se ha mencionado, de múltiples núcleos. NET vivir dentro de espacios de nombres
[Link]. Sin embargo, el Sistema.
Tipo [Link] está contenida en un ensamblado independiente nombrado
[Link]. Un gran
mayoría de las asambleas. NET Framework se encuentra en un directorio específico denominado el
mundial
memoria caché de ensamblados (GAC). En una máquina Windows, esto puede ser localizado en C:
\ Windows \ assembly, como
muestra en la Figura 6.1.

Figura 1-6. Las bibliotecas de clases base de residir en la GAC.

Dependiendo de la herramienta de desarrollo que está utilizando para construir sus aplicaciones.
NET, se le
tienen varias maneras de informar al compilador que las asambleas que desea incluir en la
compilación
ciclo. Usted estudiar la manera de hacerlo en el siguiente capítulo, así que voy a mantener a raya a
los detalles por ahora.
Usando [Link]
Si usted está comenzando a sentirse un poco abrumado ante la idea de obtener el dominio sobre
cada espacio de nombres
en la plataforma. NET, sólo recuerda que lo que hace un único espacio de nombres es que contiene
tipos que de alguna manera están relacionados semánticamente. Por lo tanto, si usted no tiene
necesidad de una interfaz de usuario
más allá de una simple aplicación de consola, puede olvidarse de todo sobre el [Link] y
[Link]
espacios de nombres (entre otros). Si está creando una aplicación de pintura, los espacios de
nombres de base de datos
tienen más probabilidades de poco interés. Al igual que cualquier nuevo sistema de código de
prefabricados, se aprende sobre la marcha. (Lo siento,
no hay acceso directo al "arte de magia" conocer todas las asambleas, espacios de nombres y
estilos a su disposición;
a continuación, de nuevo, es por eso que usted está leyendo este libro!)
El lenguaje intermedio de utilidad Desensamblador ([Link]) le permite cargar cualquier. NET
montaje e investigar su contenido, incluyendo el manifiesto de asociados, el código CIL, y tipo de
metadatos.
De forma predeterminada, [Link] se debe instalar en C: \ Archivos de programa \ Microsoft
SDKs \ Windows \
V6.0A \ bin (si usted no puede encontrar [Link] en esta ubicación, sólo tiene que buscar en su
máquina para una aplicación
llamado "[Link]").
nNota Si ha instalado Visual Studio 2008, también puede cargar [Link] al abrir una aplicación
de Visual Studio 2008
Símbolo del sistema (véase el capítulo 2 para más detalles) y escribiendo el nombre de la
herramienta (ildasm) y pulsando la tecla de retorno.
Una vez que ha cargado esta herramienta, vaya al comando de menú Archivo AOpen y vaya a un
conjunto que desea explorar. A modo de ejemplo, la Figura 1.7 muestra el conjunto integrado
[Link]
compilando el archivo de código [Link] visto anteriormente en este capítulo. Como puede ver,
[Link] presenta
la estructura de un conjunto con un formato familiar de vista de árbol.

Figura 1-7. [Link] le permite ver la composición interna de cualquier conjunto. NET.
Viendo el código CIL
Además de mostrar los espacios de nombres, tipos, y los miembros que figuran en una asamblea
dado,
[Link] también le permite ver las instrucciones del CIL de un miembro determinado. Por
ejemplo, si
fueron a doble clic en el método Main () del tipo de programa, una ventana independiente que
muestra la
subyacentes del CIL (ver Figura 1-8).
Figura [Link] el CIL subyacentes a través de [Link]
Ver los metadatos de tipo
Si desea ver los metadatos de tipos para el ensamblado cargado, pulse Ctrl + M. Figura 1-9
muestra los metadatos de la [Link] () método

Figura de tipo [Link] metadatos a través de [Link]

Ver los metadatos de la Asamblea (también conocido como el Manifiesto)
Por último, si usted está interesado en ver el contenido del manifiesto de la asamblea, simplemente
haga doble clic en
el icono MANIFIESTO en la ventana [Link] principal (ver Figura 1-10).
Figura [Link] datos del manifiesto a través de [Link]
Para estar seguro, [Link] tiene más opciones que se muestra aquí, y voy a ilustrar las
características adicionales
de la herramienta en su caso en el texto. Al leer este libro, recomendamos
abrir los ensamblados con [Link] para ver cómo su código de Visual Basic 2008 se representa
en términos
de código CIL independiente de la plataforma. Aunque no es necesario convertirse en un experto en
el código CIL a ser un
dominio del VB 2008 programador, la comprensión de algunos conceptos básicos de la CIL sólo
fortalecerá su programación
muscular.
CAPÍTULO 1 n LA FILOSOFÍA DE. NET 29

Uso de Lutz Roeder reflector

Si bien la utilización [Link] es una tarea muy común cuando se desea ahondar en las entrañas
de una. NET binario,
el gotcha una es que sólo son capaces de ver el código CIL subyacente, en vez de buscar una
aplicación ensamblado utilizando su lenguaje de gestión de elección. Afortunadamente, muchos
años. NET
de los navegadores están disponibles para su descarga, incluyendo el [Link] muy popular.
Esta herramienta gratuita se puede
descargar de [Link] Una vez que haya instalado esta aplicación,
usted es capaz de ejecutar la herramienta y el enchufe en cualquier conjunto que desee utilizando la
opción de menú Archivo AOpen.
Figura 1-11 muestra nuestra aplicación [Link] una vez más.
Figura 1-11. Reflector es una herramienta de exploración de objetos muy popular.
Tenga en cuenta que [Link] apoya una ventana Desensamblador (abre pulsando la barra
espaciadora)
así como un cuadro de lista desplegable que le permite ver la base de código subyacente en el
idioma de su
elección (incluyendo, por supuesto, el código CIL).
Lo dejo hasta que veas el número de características interesantes que se encuentran dentro de esta
herramienta. No
ser conscientes de que a lo largo del resto del libro, voy a hacer uso de ambos [Link] así
como [Link] para ilustrar diversos conceptos.
Implementar el tiempo de ejecución. NET
No debería ser ninguna sorpresa que. NET sólo se puede ejecutar en una máquina que tiene la
. NET Framework instalado. Para una persona que construye. NET, esto nunca debe ser un
problema, como el equipo de desarrollo debe estar correctamente configurado en el momento de
instalar la libre
disponible. NET Framework 3.5 SDK (así como comerciales. entornos de desarrollo NET, tales
como
Visual Studio 2008).
Sin embargo, si implementa un ensamblado a un equipo que no tiene. NET instalado, se producirá
un error
para ejecutar. Por esta razón, Microsoft proporciona un paquete de instalación [Link]
con nombre que puede ser

libremente enviado e instalado junto con su. NET de software. Este programa de instalación se
puede descargar
de Microsoft de su. NET área de descarga ([Link]
Una vez [Link] está instalado, el equipo de destino contendrá ahora la clase. NET
base
bibliotecas,. NET ([Link]), y adicionales. infraestructura de red (por ejemplo, el GAC).
nNota El sistema operativo Windows Vista está preconfigurado con todas las necesarias.
infraestructura NET. Sin embargo,
si va a implementar su aplicación a otras versiones del sistema operativo Windows, tendrá que
velar por el equipo de destino tiene el medio ambiente. NET instalado y configurado.
La naturaleza independiente de la plataforma. NET
Para cerrar este capítulo, me permito hacer un breve comentario sobre la naturaleza independiente
de la plataforma. NET
plataforma. Para la sorpresa de la mayoría de los desarrolladores. NET puede ser desarrollado y
ejecutado en
los sistemas no operativos de Microsoft (Mac OS X, numerosas distribuciones de Linux y Solaris,
por nombrar
pocos). Para entender cómo es esto posible, es necesario llegar a un acuerdo con otra sigla
NET en el universo. CLI (Common Language Infrastructure).
WhenMicrosoft lanzado la plataforma. NET, también a mano un conjunto de documentos formales
que
se describe la sintaxis y la semántica de los lenguajes C # y lenguajes de CIL, el formato. NET, base
. NET espacios de nombres, y la mecánica de un hipotético. Motor NET (conocido como el virtual
Sistema de Ejecución, o VES). Mejor aún, estos documentos han sido sometidos a ECMA
International
como oficial de las normas internacionales ([Link] Las especificaciones
de interés son
• ECMA-334: El C # Especificación del lenguaje
• ECMA-335: La Infraestructura de Lenguaje Común (CLI)
nNota Microsoft no ha definido una especificación formal con respecto a la de Visual Basic 2008
lenguaje de programación.
La buena noticia, sin embargo, es que el código abierto más importantes. NET distribuciones vienen
con un compilador BASIC compatible.
La importancia de estos documentos se hace evidente cuando se comprende que permiten
terceros para construir distribuciones de las platformfor. NET cualquier número de sistemas
operativos
y / o transformadores. ECMA-335 es quizás el más "carne" de las dos especificaciones, hasta el
punto de
que se ha dividido en seis divisiones, como se muestra en la Tabla 1-3.

Table 1-3. Partitions of the CLI

Partitions of ECMA-335 Meaning in Life
Partition I: Concepts and Architecture Describes the overall architecture of the CLI, including
the rules of the CTS and CLS, and the mechanics of the
.NET runtime engine
Partition II: Definitions and Semantics Describes the details of .NET metadata
Partition III: Instruction Set Describes the syntax and semantics of CIL code
Partition IV: Profiles and Libraries Gives a high-level overview of the minimal and complete
class libraries that must be supported by a .NET
distribution

Partitions of ECMA-335 Meaning in Life

Partition V: Debug Exchange Format Defines details of .NET debugging symbols
Partition VI: Annexes Provides a collection of “odds and ends” details such as
class library design guidelines and the implementation
details of a CIL compiler

Tenga en cuenta que la partición IV (Perfiles y Bibliotecas) sólo define un conjunto mínimo de
espacios de nombres
que representan los servicios fundamentales que se exigen por una distribución de la CLI
(colecciones, consola de E / S / S de archivos,
roscado, la reflexión, acceso a la red, las necesidades básicas de seguridad, la manipulación de
XML, etc). La
CLI no define los espacios de nombres que faciliten el desarrollo web ([Link]), acceso a bases
de datos
([Link]), o el desarrollo de aplicaciones de escritorio interfaz gráfica de usuario (a través de
Windows Forms o Windows Presentation
Fundación).
La buena noticia, sin embargo, es que la corriente principal. distribuciones NET ampliar las
bibliotecas de la CLI
con sus equivalentes de Microsoft compatibles con [Link], [Link] y Windows Forms (entre
otros
API) con el fin de ofrecer todas las funciones, las plataformas de desarrollo a nivel de producción.
Hasta la fecha, hay
dos implementaciones más importantes de la CLI (más allá de ofrecer específicas de Windows de
Microsoft). Aunque
este texto se centra en la creación de aplicaciones. NET utilizando. NET de Microsoft, la
distribución, la tabla 1-4
proporciona información sobre el Mono y proyectos [Link].

Distribution Meaning in Life

[Link] The Mono project is an open source distribution of the CLI that
targets various Linux distributions (e.g., SuSE, Fedora, and so
on) as well as Windows and Mac OS X.
[Link] [Link] is another open source distribution of the CLI
that runs on numerous operating systems. [Link] aims
to target as many operating systems as possible (Win32, AIX,
BeOS, Mac OS X, Solaris, all major Linux distributions, and
so on).

Ambos Mono y [Link] proporcionar una ECMA C # compilador compatible,. motor NET,
ejemplos de código y documentación, así como numerosas herramientas de desarrollo que son
funcionalmente
equivalentes a las herramientas que se incluyen con. NET Framework de Microsoft 3.5 SDK. Por
otra parte, Mono y
[Link] colectivamente buque con un compilador de Visual Basic, Java y C.
nNota Si desea conocer más acerca de Mono o [Link], visita de la Cruz-plataforma de
desarrollo NET:. Uso
Mono, [Link], y Microsoft. NET Easton MJ y King Jason (Apress, 2004).
Resumen
El objetivo de este capítulo fue establecer el marco conceptual necesario para el resto de
este libro. Empecé por el examen de una serie de limitaciones y complejidades que se encuentran
dentro de las tecnologías
antes de. NET, y siguió con una visión general de cómo hacerlo. NET y Visual Basic 2008 intento
para racionalizar el actual estado de cosas.

NET básicamente se reduce a un motor de ejecución en tiempo de ejecución ([Link]) y la

biblioteca de clases base
([Link] y asociados). El Common Language Runtime (CLR) es capaz de albergar cualquier.
NET
binaria (también conocido como conjunto) que no cumplen con las normas del código administrado.
Como se ha visto, las asambleas contienen
CIL instrucciones (además de los metadatos de tipo y el manifiesto del ensamblado) que se
compilan en
instrucciones específicas de la plataforma mediante un "justo a tiempo (JIT). Además, se exploró el
papel
de la Common Language Specification (CLS) y el Sistema de tipos común (CTS).
Esto fue seguido por un examen de la [Link] y navegar por objeto [Link]
servicios públicos, así como la cobertura de cómo configurar un equipo para organizar las
aplicaciones. NET utilizando
[Link]. Me envolvió con una breve frente a la naturaleza independiente de la
plataforma de la
. NET utilizando una fuente alternativa de código abierto. distribuciones NET, tales como Mono o
[Link]
Construcción de Visual Basic 2008
Aplicaciones
Como programador de VB 2008, puede elegir entre numerosas herramientas para construir sus
aplicaciones. NET.
Este enfoque es muy diferente del mundo de VB6, en el que sólo tenía un único IDE
enfrentarse a: Microsoft Visual Basic 6.0. Dicho esto, el punto de este capítulo es proporcionar una
gira por varios. opciones de desarrollo NET, incluyendo, por supuesto, Visual Studio 2008. El
capítulo
se abre, sin embargo, con un examen de trabajar con el VB 2008 compilador de línea de comandos,
[Link], y el más simple de todos los editores de texto, el Bloc de notas ([Link]).
Mientras que usted podría trabajar a través de este texto completo mediante otra cosa que [Link]
y un simple
editor de texto, yo apuesto a que también están interesados en trabajar con entornos de desarrollo
de múltiples funciones integradas
(IDE). Con este fin, se le presentó a un IDE de código abierto llamado SharpDevelop.
Este rivales IDE la funcionalidad de muchos comerciales. Entornos NET (y es
gratis!). Después de un breve examen de Visual Basic 2008 Express IDE, a su vez su atención a
Visual Studio 2008. En este capítulo se cierra con una breve discusión sobre el papel de la
[Link] montaje y un estudio de adicionales. Herramientas de desarrollo NET
tal vez desee investigar en su tiempo libre.
nNota A lo largo de este capítulo, verá una serie de construcciones de programación VB no hemos
formalmente
examinados. Si no está familiarizado con la sintaxis, no se preocupe. Capítulo 3 comenzará
formalmente el examen de
el lenguaje Visual Basic.
El papel de. NET Framework 3.5 SDK
Un error común en relación con. NET es la creencia de que los programadores deben
comprar una copia de Visual Studio para construir sus aplicaciones Visual Basic. La verdad del
asunto es
que son capaces de construir cualquier tipo de. NET utilizando el programa de descarga gratuita.
NET Framework
3.5 Software Development Kit (SDK). Este SDK le proporciona numerosos compiladores
administrados,
de línea de comandos de servicios públicos, documentos técnicos, código de ejemplo, el. NET
bibliotecas de clases base, y completar un
documentación del sistema.
nNota. NET Framework 3.5 SDK ([Link]) pueden obtenerse en el sitio web. NET
descarga
(Http://[Link]/netframework).
35
CHARTEP2

si usted es de hecho va a estar utilizando Visual Studio 2008 o Visual Basic 2008 Express, no tienen
necesidad de instalar manualmente el. NET Framework 3.5 SDK. Al instalar cualquiera de estos
productos,
el SDK se instala automáticamente, con lo que te da todo lo que necesite de la caja. Sin embargo,
si no se va a usar un IDE de Microsoft como usted trabaja a través de este texto, asegúrese de
instalar el
SDK antes de continuar.
El Visual Studio 2008 del símbolo del sistema
Cuando se instala el. NET Framework 3.5 SDK, Visual Studio 2008 o Visual Basic 2008 Express,
terminará con una serie de nuevos directorios en el disco duro local, cada uno de los cuales
contiene varios
. NET herramientas de desarrollo. Muchas de estas herramientas son expulsados del símbolo del
sistema, por lo que si
desea utilizar estos servicios desde cualquier ventana de comandos de Windows, tendrá que
registrar estos
caminos con el sistema operativo.
Mientras que usted puede actualizar la variable PATH de forma manual para hacerlo (que no se
molestará en hacer
aquí), puede ahorrar un poco de tiempo, simplemente haciendo uso de los comandos de Visual
Studio 2008
Del sistema que es accesible desde el inicio äPrograms äMicrosoft Visual Studio 2008 äVisual
Estudio
carpeta de herramientas (ver Figura 2-1).
Figura 2-1. El Visual Studio 2008 del símbolo del sistema
La ventaja de utilizar este comando en particular del sistema es que se ha preconfigurado para
ofrecer
el acceso a cada una de las herramientas de desarrollo. NET sin necesidad de modificar la variable
PATH
ajustes. Suponiendo que ha instalado un entorno. NET, escriba el siguiente comando
y pulse la tecla Intro:
vbc -?
Si todo va bien, debería ver una lista de argumentos de línea de comandos del compilador de línea
de comandos de VB
(Donde vbc representa el compilador de Visual Basic).
La VB 2008 la línea de comandos del compilador ([Link])
Hay una serie de técnicas que puede utilizar para compilar el código fuente de VB 2008. Además de
Visual Studio 2008 (así como varios de terceros. NET IDE), que son capaces de crear. NET
con el VB 2008 compilador de línea de comandos, [Link]. Si bien es cierto que usted nunca podrá
decidir
construir una aplicación a gran escala utilizando el compilador de línea de comandos, es importante
comprender la
conceptos básicos de cómo compilar los archivos *. vb a mano. No puedo pensar en algunas de las
razones que usted debe obtener un control
sobre el proceso:
• La razón más obvia es el simple hecho de que puede que no tenga una copia de Visual
Studio 2008.
• Usted puede estar en un ambiente universitario donde está prohibido el uso de la generación de
código
herramientas y entornos de desarrollo en el aula.
• Tiene intención de hacer uso de sistemas automatizados. NET herramientas de construcción como
de MSBuild o de NAnt.
• Desea profundizar el conocimiento de VB 2008. Cuando se utiliza para construir entornos de
desarrollo gráfico
aplicaciones, que son en última instancia, instruir [Link] cómo manipular la entrada de VB 2008
archivos. En este sentido, es edificante para ver lo que ocurre detrás de las escenas.
Otro buen producto derivado de trabajar con [Link] en la materia prima es que usted se convierte
en mucho
más cómoda la manipulación de otras herramientas de línea de comandos se incluye con el. NET
Framework 3.5
SDK. Como se verá a lo largo de este libro, una serie de utilidades importantes son accesibles sólo
desde
la línea de comandos.
La construcción de aplicaciones con Visual Basic 2008 [Link]
Para ilustrar cómo construir una. NET IDE libre, vamos a construir un simple montaje de un solo
archivo
llamado [Link] con el VB 2008 compilador de línea de comandos y el Bloc de notas. En
primer lugar, usted necesita una cierta
de código fuente. Abra el Bloc de notas y escriba lo siguiente:

' A simple VB 2008 application.

Imports System
Module TestApp
Sub Main()
[Link]("Testing! 1, 2, 3")
End Sub
End Module

Una vez que haya terminado, guarde el archivo en una ubicación conveniente (por ejemplo, C: \
VbcExample) como
[Link]. Ahora, vamos a conocer las opciones fundamentales de la VB 2008 compilador. El
primer punto de interés
es entender cómo especificar el nombre y tipo de reunión para crear (por ejemplo, una consola
aplicación denominada [Link], una biblioteca de código llamado [Link], aWindows Forms
[Link] nombre, etc.) Cada posibilidad es representado por una bandera específica se
introdujo [Link] como
parámetro de línea de comandos (ver Tabla 2-1).

Table 2-1. Output-centric Options of the VB 2008 Compiler

Option Meaning in Life
/out This option is used to specify the name of the assembly to be created. By
default, the assembly name is the same as the name of the initial input *.vb file.
/target:exe This option builds an executable console application. This is the default target,
and thus may be omitted when building console applications.
/target:library This option builds a single-file *.dll assembly.
/target:module This option builds a [Link] are elements of multifile assemblies
(fully described in Chapter 15).
/target:winexe This option builds an executable Windows application. Although you are free
to build Windows-based applications using the /target:exe flag, the
/target:winexe flag prevents a console window from appearing in the
background.
Para compilar [Link] en una aplicación de consola denominada [Link], abrir un Visual
Studio
2008 del símbolo del sistema y cambie al directorio que contiene la fuente *. vb código mediante el
comando cd:

cd c:\VbcExample

A continuación, escriba el siguiente comando conjunto (tenga en cuenta que las banderas de línea
de comandos debe venir antes de la
nombre de los archivos de entrada, no después):

vbc /target:exe [Link]

Aquí no se especifica explícitamente un pabellón de entrada / salida, por lo tanto el ejecutable se

llamará
[Link], le dio el nombre del archivo de entrada inicial. Sin embargo, si desea especificar un
único
nombre para su montaje, puede introducir el siguiente comando:

vbc /target:exe /out:[Link] [Link]

También tenga en cuenta que la mayoría de las opciones del compilador Visual Basic 2008 admiten
una versión abreviada, como
/ t en lugar de / target (puedes leer todas las abreviaturas introduciendo vbc /? en el símbolo del
sistema).
Por ejemplo, usted puede ahorrarse algunos golpes de teclado mediante la especificación de los
siguientes:

vbc /t:exe [Link]

Además, dado que el modificador / t: exe bandera es la salida por defecto utilizado por el compilador
de VB 2008, que
También podría elaborar [Link] simplemente escribiendo lo siguiente:

vbc [Link]

[Link] ahora se puede ejecutar desde la línea de comandos, escriba el nombre del ejecutable
y
pulsando la tecla Intro. Si todo va bien, debería ver el mensaje "Prueba! 1, 2, 3 "imprimir a la
ventana de comandos (ver Figura 2-2).

Figura 2-2. [Link] en acción

Hacer referencia externa Asambleas Uso [Link]
El siguiente, vamos a examinar cómo compilar una aplicación que hace uso de tipos definidos en un
archivo externo
. NET. Hablando de eso, sólo en caso de que usted se está preguntando cómo el VB 2008
compilador entiende
su referencia al tipo [Link], recuerdo del capítulo 1 que [Link] (el
ensamblado que contiene el tipo [Link]) se hace referencia automáticamente durante la
compilación
proceso.
Para ilustrar el proceso de la referencia externa ensamblados adicionales, vamos a actualizar la
Aplicación [Link] para mostrar un cuadro de mensaje de Windows Forms. Abra el archivo
[Link]
y modificarlo de la siguiente manera

' A simple VB 2008 application.

Imports System
' Add this!
Imports [Link]
Module TestApp
Sub Main()
[Link]("Testing! 1, 2, 3")

' Add this!

[Link]("Hello!")
End Sub
End Module

Observe la referencia al espacio de nombres [Link] a través de la VB 2008 las

importaciones de palabras clave
(introducido en el capítulo 1). Recuerde que cuando usted explícitamente una lista de los espacios
de nombres utilizados en un determinado
*. vb, se evita la necesidad de hacer uso de los nombres completos (que pueden dar lugar a
calambres mano).
En la línea de comandos, debe informar a [Link] que contiene el conjunto de espacios de nombres
importados.
Dado que usted ha hecho uso de la clase de mensajes, debe especificar el
[Link] ensamblado utilizando la bandera de referencia / (que puede ser
abreviado a / r):

vbc /r:[Link] [Link]

Si ahora vuelve a ejecutar la aplicación, usted debe ver lo que aparece en la figura 2.3, además de
la
salida de la consola.

Figura 2-3. Su primera aplicación de Windows Forms

Compilación de varios archivos de código fuente utilizando [Link]
La encarnación actual de la aplicación [Link] fue creado usando un solo *. vb código fuente
archivo. Si bien es perfectamente lícito tener en todos sus. tipos de redes se definen en un archivo *.
vb sola, la mayoría de
proyectos se componen de varios archivos *. vb para mantener su base de código un poco más
flexible. Supongamos que
han escrito una clase adicional (de nuevo, utilizando el Bloc de notas) contenida en un nuevo
archivo llamado
[Link]:

' The HelloMessage class

Imports System
Imports [Link]
Class HelloMessage
Sub Speak()
[Link]("Hello Again")
End Sub
End Class

Suponiendo que usted ha guardado este archivo nuevo en la misma ubicación que el primer archivo
(por ejemplo,
C: \ VbcExample), actualizar su clase TestApp hacer uso de este nuevo tipo, y comentar
la lógica anterior de Windows Forms. Aquí está la completa actualización:

' A simple VB 2008 application.

Imports System

' Don't need this anymore.

' Imports [Link]
Module TestApp
Sub Main()
[Link]("Testing! 1, 2, 3")
' Don't need this anymore either.
' [Link]("Hello!")
' Exercise the HelloMessage class!
Dim hello As New HelloMessage()
[Link]()
End Sub
End Module

Usted puede compilar el VB 2008 archivos haciendo una lista de cada archivo de entrada
explícitamente:

vbc /r:[Link] [Link] [Link]

Como alternativa, el compilador de VB 2008 le permite hacer uso del carácter comodín (*)
para informar a [Link] para incluir todos los archivos *. vb que figuran en el directorio del proyecto
como parte de la corriente
construcción:
vbc /r:[Link] *.vb

Cuando se ejecuta el programa de nuevo, la salida es idéntica. La única diferencia entre los dos
solicitudes es el hecho de que la lógica actual se ha dividido en varios archivos.
Hacer referencia a varios ensamblados externos Uso de [Link]
En una nota relacionada, lo que si necesita hacer referencia a varios ensamblados externos
utilizando [Link]?
Simplemente una lista de cada conjunto mediante una lista delimitada por comas. No es necesario
especificar múltiples externos
asambleas para el ejemplo actual, sino que sigue algunos ejemplos de uso:

vbc /r:[Link],[Link] *.vb

Trabajar con archivos de respuesta [Link]
Como puede imaginar, si usted fuera a construir un complejo de VB 2008 la aplicación en el símbolo
del sistema,
su vida se llena de dolor a medida que escribe en las banderas que especifican numerosos
ensamblados de referencia
y *. vb código. Para ayudar a disminuir su carga de escribir, el compilador de VB 2008 honra la
utilización de
archivos de respuestas.
VB archivos de respuestas 2008 contienen todas las instrucciones que se utilizarán durante la
elaboración de su
generación actual. Por convención, estos archivos en un final *. RSP (respuesta) de extensión.
Supongamos que
Ha creado un archivo de respuesta denominado [Link] que contiene los siguientes
argumentos (como se puede
ver, los comentarios se denotan con el carácter #):

# This is the response file

# for the [Link] app
# of Chapter 2.
# External assembly references.
/r:[Link]

# Output and files to compile (using wildcard syntax).

/t:exe /out:[Link] *.vb

Ahora, suponiendo que este archivo se guarda en el mismo directorio que el VB 2008 archivos de
código fuente que se
compilado, que son capaces de generar la aplicación completa de la siguiente manera (nótese el
uso del símbolo @):

vbc @[Link]

Si la necesidad se presente, que también son capaces de especificar varios archivos *. rsp como
entrada (por ejemplo, vbc
@ @ [Link] [Link] @ [Link]). Si toma este enfoque, se tenga en cuenta que el
compilador procesa las opciones del comando, ya que se encuentran! Por lo tanto, los argumentos
de línea de comandos
en un archivo *. rsp tarde puede anular las opciones en un archivo de respuesta anterior.
También tenga en cuenta que las banderas que figuran explícitamente en la línea de comandos
antes de que un archivo de respuesta se reemplaza
por el archivo *. rsp especificado. Por lo tanto, si usted fuera a entrar en

vbc /out:[Link] @[Link]

el nombre de la asamblea todavía se [Link] (en lugar de [Link]), dada la

/ out: bandera [Link] listados en el archivo de respuesta [Link]. Sin embargo, si
después de una lista de las banderas
archivo de respuestas, la bandera tienen prioridad en el archivo de respuesta. Así, en el siguiente
comando
conjunto, su montaje es de hecho el nombre [Link]
vbc @[Link] /out:[Link]

nNota La bandera de referencia / es acumulativo. Independientemente de donde se especifica

ensamblados externos (antes, después,
o dentro de un archivo de respuestas), el resultado final es un resumen de cada conjunto de
referencia.
El predeterminado de archivo de respuestas ([Link])
El punto final que se hará con respecto a los archivos de respuestas es que el compilador de VB
2008 tiene asociado un
por defecto del archivo de respuestas ([Link]), que se encuentra en el mismo directorio que
[Link] sí mismo (por ejemplo,
C: \ Windows \ [Link] \ Framework \ v3.5). Si se va a abrir este archivo con el Bloc de notas,
que
se encontraba con que numerosos NET ya se han especificado utilizando el R /:. bandera. A medida
que
era de esperar, se llega a comprender el papel de muchos de estos. NET bibliotecas a lo largo
del texto. Sin embargo, para sentar las bases, aquí es una mirada dentro de [Link]:

# This file contains command-line options that the VB

# command-line compiler (VBC) will process as part
# of every compilation, unless the "/noconfig" option
# is specified.
# Reference the common Framework libraries
/r:[Link]
/r:[Link]
/r:[Link]
/r:[Link]
/r:[Link]
/r:[Link]
/r:[Link]
/r:[Link]
/r:[Link]
/r:[Link]
/r:[Link]
/r:[Link]

/r:[Link]
/r:[Link]
/r:[Link]
/r:[Link]
/r:[Link]
/r:[Link]
/r:[Link]
/r:[Link]
/r:[Link]
/r:[Link]
/r:[Link]
/r:[Link]
/r:[Link]
/r:[Link]
/r:[Link]
/r:[Link]
/r:[Link]
/r:[Link]
/r:[Link]

/r:[Link]
/r:[Link]
/r:[Link]
/r:[Link]
/r:[Link]
/r:[Link]
/r:[Link]
# Import System and [Link]
/imports:System
/imports:[Link]
/imports:[Link]
/imports:[Link]
/optioninfer+

Entender nNota que el archivo de respuesta predeterminada sólo se hace referencia cuando se
trabaja con el compilador de línea de comandos.
El Visual Basic 2008 Express y Visual Studio 2008 IDE no se ajusta automáticamente las
referencias a estos
colecciones.
Cuando usted está construyendo su VB 2008 con programas de [Link], este archivo
automáticamente se hace referencia,
aun cuando la oferta de un archivo *. RSP. Habida cuenta de la presencia del archivo de respuesta
predeterminada,
la actual aplicación [Link] podría ser compilado correctamente con el siguiente comando
conjunto (como se hace referencia en [Link] [Link]):

vbc /out:[Link] *.vb

En el caso de que desea desactivar la lectura automática de [Link], puede especificar el

/ noconfig opción

vbc @[Link] /noconfig

Obviamente, el VB 2008 compilador de línea de comandos tiene muchas otras opciones que se
pueden utilizar para
controlar el modo en el archivo. NET se va a generar. En este punto, sin embargo, usted debe tener
a manejar los conceptos básicos. Si desea conocer más detalles sobre la funcionalidad de [Link],
de búsqueda de. NET Framework 3.5 documentación para el término "[Link]".
nSource Código VbcExample El proyecto se incluye en el Capítulo 2 subdirectorio.
Edificio. NET Usando SharpDevelop
Mientras que el Bloc de notas está muy bien para la creación de simple. Programas NET, no ofrece
nada en el camino de desarrollador
productividad. Lo ideal sería al autor *. vb archivos con un editor que soporta (como mínimo) la
palabra clave
coloración y la integración con el compilador de VB. Además, esperamos para construir nuestra VB
programas que utilizan una herramienta que apoya las capacidades ricas de IntelliSense, los
diseñadores para la creación de gráficos
interfaces de usuario, plantillas de proyecto y herramientas de base de datos de la manipulación. La
suerte quiso que numerosas
herramientas existen, muchos de los cuales son completamente gratis.
Para hacer frente a esas necesidades, permítame presentarle la siguiente opción de desarrollo.
NET: Sharp
Desarrollar (también conocido como # develop). SharpDevelop es un IDE de código abierto y rico en
funciones que
puede utilizar para construir. NET utilizando Visual Basic o C #, así como el uso de CIL y una
inspirada en Python. NET
lenguaje llamado Boo. Más allá del hecho de que este IDE es completamente gratuito, es
interesante señalar que
fue escrito enteramente en C # (y podría tener la misma facilidad se ha escrito en Visual Basic). De
hecho,
tiene la opción de descargar y compilar los archivos *. cs manualmente o ejecutar un programa de
instalación para instalar
SharpDevelop en su equipo de desarrollo. Ambas distribuciones se pueden obtener de
[Link] (a la hora de escribir este artículo, la versión actual es de 2,2, sin
embargo, se
Asegúrese de descargar la última y mejor).
SharpDevelop proporciona numerosas mejoras de la productividad y en muchos casos es la función
ricos como Visual Studio 2008 Standard Edition. Aquí está una lista de resultados parciales de
algunas de las ventajas principales:
• IntelliSense, la finalización de código, y la capacidad de fragmento de código
• Un cuadro de diálogo Agregar referencia a los conjuntos de referencia externa, incluidos los
ensamblados
implementar en la caché de ensamblados global (GAC)
• Un visuales de Windows Forms Designer
• Integrado examen de objetos y servicios públicos código de la definición
• Visual utilidades de base de datos de diseño
• Un VB a C # (y viceversa) utilidad de conversión de código
• Integración con el NUnit (un archivo. NET unidad de servicios públicos de prueba) y Nant (un
archivo. NET Utilidad de construcción)
• Integración con el. NET Framework 3.5 SDK
Impresionante para un país libre IDE, ¿no? Aunque este capítulo no se aplica a cada uno de estos
puntos en
detalle, vamos a caminar a través de algunos artículos de interés.:

La construcción de un proyecto de prueba simple

Una vez que haya instalado SharpDevelop, la opción de menú Archivo ANew asolution permite que
usted escoja
qué tipo de proyecto que desea generar (y en el que. NET). Por ejemplo, usted asume
han creado una aplicación para Windows llamado VB MySDWinApp (ver Figura 2-4).
Figura 2-4. El SharpDevelop Nuevo proyecto de cuadro de diálogo
Como Visual Studio, dispone de un diseñador de interfaz gráfica de usuario, caja de herramientas
(para arrastrar y colocar los controles en el
diseñador), y una ventana Propiedades para configurar la apariencia de cada elemento de la interfaz
de usuario. Figura 2-5 ilustra
la configuración de un tipo de botón utilizando el IDE (por defecto, el IDE se mostrará el código
fuente de la corriente
forma, seleccione la ficha Diseño en la parte inferior de la ventana principal para activar el diseñador
Principio del formulario
Quizás quisiste decir: You can compile a VB 2008 files by listing each input file explicitly:

Escribe texto o la dirección de un sitio web o traduce un documento.

Cancelar
Escuchar
Leer fonéticamente
Final del formulario
traducción del inglés al español

Figura 2-5. Gráficamente el diseño de una aplicación de Windows Forms con SharpDevelop
Si tuviera que hacer clic en el botón Fuente montado en la parte inferior del diseñador del
formulario, usted
encontrar la espera de IntelliSense, la finalización de código, y características integradas de
ayuda (ver Figura 2-6).

SharpDevelop fue diseñado para imitar la mayor parte de la misma funcionalidad que se encuentran
dentro de Microsoft
. NET IDE (que examinaremos a continuación). Teniendo en cuenta este punto, no voy a profundizar
en todas las características de este
de código abierto. NET. Si desea más información, basta con utilizar el menú Ayuda siempre.
nNota Usted es libre de utilizar SharpDevelop medida que se trabaja a través de esta edición del
texto. No se sabe, sin embargo,
que algunos de los capítulos pueden especificar las opciones de menú, herramientas o métodos
abreviados de teclado que son específicos a Visual
Studio 2008.
Edificio. NET utilizando Visual Basic
2008 Express
Durante el verano de 2004, Microsoft introdujo una línea completamente nueva de IDEs que caen
bajo la denominación
de "Express" productos ([Link] Hasta la fecha, hay varios
miembros de la familia Express (todos los cuales son completamente gratis y apoyado y mantenido
por
Microsoft Corporation), incluyendo las siguientes:
• Visual Web Developer 2008 Express: Una herramienta ligera para la construcción de sitios web
dinámicos y
Servicios web XML con [Link]
• Visual Basic 2008 Express: Un ideal herramienta de programación optimizada para los
programadores novatos
que quieren aprender a crear aplicaciones utilizando la sintaxis de uso fácil de Visual Basic
• Visual C # 2008 Express y Visual C + + 2008 Express: Dirigida IDEs para estudiantes y aficionados
que deseen aprender los fundamentos de la informática en su sintaxis de elección
• SQL Server 2005 Express: Una base de datos de nivel de entrada del sistema de gestión orientado
a los aficionados,
aficionados, estudiantes y desarrolladores
Algunas características únicas de Visual Basic 2008 Express
Versiones En general, los productos Express están reducida de sus homólogos de Visual Studio
2008
y afectan principalmente a los. NET aficionados y estudiantes. Al igual que SharpDevelop, Visual
Basic
2008 Express ofrece varias herramientas de navegación de objetos, un diseñador de formularios
Windows Forms, el Agregar referencias
cuadro de diálogo, capacidad de IntelliSense, y la expansión de las plantillas del código.
Sin embargo, Visual Basic 2008 Express ofrece unos pocos (importante) las características no
disponibles actualmente en
SharpDevelop, incluyendo las siguientes:
• Rico soporte para Windows Presentation Foundation (WPF) XAML
• IntelliSense para nuevas construcciones sintácticas VB 2008 que incluyen declaraciones de
consulta LINQ
• La capacidad de programar para Xbox 360 y juegos de video en PC usando el libre acceso
Microsoft
XNA Game Studio
Considere la figura 7.2, que muestra el uso de Visual Basic Express al autor el marcado XAML
para un proyecto de WPF.
Debido a la apariencia de Visual Basic 2008 Express es tan similar a la de Visual Studio 2008
(Y, hasta cierto punto, SharpDevelop), que no ofrecen un paseo a través de este IDE en particular
aquí.
Sin embargo, recuerde que esta herramienta es de uso completamente gratuito y le ofrecerá todas
las características
que necesita para trabajar durante el resto de este texto.

Figura [Link] Basic 2008 Express cuenta con soporte integrado para. NET 3.0 y 3.5 de. NET
API.
nNota Usted es libre de utilizar Visual Basic Express como usted trabaja a través de esta edición del
texto. Una vez más, se tenga en cuenta,
sin embargo, que algunos de los capítulos pueden llamar a las opciones de menú, herramientas o
métodos abreviados de teclado que son específicos de
Visual Studio 2008.
Edificio. NET utilizando Visual
Studio 2008
Si usted es un profesional. ingeniero de software NET, las posibilidades son muy buenas que su
empleador ha comprado IDE principal de Microsoft, Visual Studio 2008, por sus esfuerzos de
desarrollo
([Link] Esta herramienta es de lejos la más rica en características y
lista para la empresa IDE examinados en este capítulo. Por supuesto, este poder tiene un precio,
que se
varían en función de la versión de Visual Studio 2008 que usted compra. Como se puede
sospechar, cada versión
proporciona un conjunto único de características.
nNota Hay un asombroso número de miembros dentro de Visual Studio 2008 de la familia. Mi
hipótesis durante
el resto de este texto es que usted ha elegido para hacer uso de Visual Studio 2008 Professional
como el IDE

A pesar de que se suponga que tiene una copia de Visual Studio 2008 Professional, entiendo que
ser propietario de una copia de este IDE no es necesario para utilizar esta edición del texto. En el
peor de los casos, es posible que
examinar una opción que no es proporcionada por el IDE. Sin embargo, estar seguro de que todos
los de este libro
código de ejemplo se compila bien cuando son procesadas por la herramienta de elección.
nNota Una vez descargado el código fuente de este libro desde el código fuente / zona de
Descargas de la Apress
sitio web ([Link] puede cargar el ejemplo actual en Visual Studio 2008 (o Visual
Basic
2008 Express) haciendo doble clic en el ejemplo de archivo *. sln. Si no está utilizando Visual Studio
2008/Visual
Basic 2008 Express, tendrá que insertar manualmente el siempre *. vb en el área de trabajo del
proyecto del IDE.
Algunas características únicas de Visual Studio 2008
Visual Studio 2008 se suministra con la espera diseñadores de interfaz gráfica de usuario, soporte
de fragmentos de código, la manipulación de bases de datos
herramientas, objetos y las utilidades del proyecto de navegación, y un sistema de ayuda integrado.
A diferencia de muchos de los
IDE que ya hemos examinado, Visual Studio 2008 ofrece numerosas adiciones. Aquí hay una
parcial
lista:
• Visual XML editores / diseñadores
• Soporte para el desarrollo de dispositivos móviles (como teléfonos inteligentes y dispositivos
Pocket PC)
• Soporte para desarrollo de Microsoft Office
• Apoyo Designer para Windows Workflow Foundation (WF) proyectos
• Soporte integrado para la refactorización de código
• Visual utilidades clase de diseño
• El objeto de banco de prueba de ventana, que le permite crear objetos e invocar a sus miembros
directamente en el IDE
Para ser completamente honesto, Visual Studio 2008 ofrece tantas características que sería
necesario un
todo el libro (un libro bastante grande por cierto) para describir completamente todos los aspectos
del IDE. Esto no es
libro. Sin embargo, quiero señalar algunas de las características principales de las páginas que
siguen. A medida que
el progreso a través del texto, usted aprenderá más acerca de Visual Studio 2008 IDE en su caso.
Orientación. NET Framework Uso del nuevo proyecto
Cuadro de diálogo
Para examinar algunas de las características básicas de Visual Studio 2008, cree una nueva
aplicación de consola de Visual Basic
(Nombre Vs2008Example) utilizando el elemento de menú Archivo ANew äProject. Como se puede
ver en la Figura 2-8,
Visual Studio 2008 ahora (por fin) admite la posibilidad de seleccionar qué versión de. NET
Framework
desea construir en contra (2.0, 3.0 o 3.5) utilizando el cuadro de lista desplegable en la parte
superior derecha de la
Nuevo proyecto de cuadro de diálogo. Para cada proyecto en este texto, sólo tiene que dejar la
selección por defecto de
. NET Framework 3.5.

Figura [Link] Studio 2008 ahora le permite orientar una determinada versión de. NET
Framework.
Uso de la utilidad Explorador de soluciones
La utilidad Explorador de soluciones (accesible desde el menú Ver) que permite ver el conjunto de
todo el contenido
archivos y ensamblados de referencia que conforman el proyecto actual. De forma predeterminada,
el Explorador de soluciones
No le mostrará el conjunto de ensamblados de referencia utilizado por el proyecto o los directorios
de salida
utilizado por Visual Studio 2008 (como \ bin \ Debug). Para ver todos los aspectos de su proyecto,
debe hacer clic en
el botón Mostrar todos los archivos de la barra de herramientas del Explorador de soluciones (ver
Figura 2-9).
Figura 2-9. El Explorador de soluciones de servicios públicos
CAPÍTULO 2 EDIFICIO n Visual Basic 2008 APLICACIONES 49

Observe que la carpeta Referencias del Explorador de soluciones muestra una lista de cada
conjunto tiene
Actualmente se hace referencia, que será diferente en función del tipo de proyecto seleccionado y la
versión del
Marco está compilando en contra.
Hacer referencia a ensamblados externos
Cuando usted necesita a las asambleas de referencia adicional, usted puede hacer clic en la
carpeta Referencias
en el Explorador de soluciones y seleccione la opción Agregar referencia del menú o simplemente
haga un proyecto de
Agregar referencia opción de menú de Visual Studio 2008. En cualquier caso, usted puede
seleccionar el conjunto de
el cuadro de diálogo resultante (esto es esencialmente la forma de Visual Studio le permite
especificar la referencia /
opción del compilador de línea de comandos).
. El NET (vea la Figura 2-10) muestra una serie de uso general NET;. sin embargo,
Ver la ficha le permite desplazarse a cualquier conjunto. NET en su disco duro. Además, el
ficha muy recientes útil un recuento actualizado de las asambleas con frecuencia se hace referencia
se han utilizado en
otros proyectos.
Figura 2-10. El cuadro de diálogo Agregar referencia
Ver las propiedades del proyecto
Por último, observe un icono llamado Mi proyecto en el Explorador de soluciones. Al hacer doble clic
en este elemento,
que se presentan con un editor de configuración de proyectos complejos (véase la Figura 2-11).
Podrás ver distintos aspectos de la ventana de mi proyecto a medida que avanza a través de este
libro. Sin embargo,
si toma algún tiempo para echar un vistazo, podrás ver que se puede establecer la seguridad
diferentes
configuración, con fuerza el nombre de su conjunto, implementar la aplicación, los recursos de
inserción de aplicaciones y
configurar los eventos pre y generación posterior.

Figura 2-11. El proyecto Mi ventana

La utilidad de la Vista de clases
La siguiente herramienta para examinar es la utilidad de la Vista de clases, que se puede abrir
desde el menú Ver. El propósito
de esta utilidad es para mostrar todos los tipos en el proyecto actual desde una perspectiva más
orientada a objetos
la perspectiva (en lugar de una visión basada en archivos del Explorador de soluciones). El panel
superior muestra el conjunto de
espacios de nombres y sus tipos, mientras que el panel inferior muestra a los miembros con el tipo
seleccionado
(vea la Figura 2-12).
Figura 2-12. La Vista de clases de utilidad
CAPÍTULO 2 EDIFICIO n Visual Basic 2008 APLICACIONES 51

La utilidad de Examinador de objetos

Visual Studio 2008 también proporciona una utilidad para investigar el conjunto de ensamblados de
referencia dentro de su
proyecto actual. Activar el Examinador de objetos utilizando el menú Ver y, a continuación,
seleccionar el conjunto de
desea investigar (véase la Figura 2-13).
Figura 2-13. El Examinador de objetos de utilidad
nNota Si hace doble clic en un icono de ensamblado de la carpeta Referencias del Explorador de
soluciones, Examinador de objetos se
abre automáticamente con el montaje seleccionado resaltado.
Visual Studio 2008 Tecnología de fragmentos de código
Visual Studio 2008 (así como Visual Basic 2008 Express) también tiene la capacidad de insertar
complejos
bloques de código VB 2008 con selecciones de menú, los clics del ratón sensible al contexto, y / o el
teclado
atajos usando fragmentos de código. En pocas palabras, un fragmento de código es un bloque
predefinidos de Visual Basic 2008
código que se expandirá en el archivo de código activo. Como era de suponer, fragmentos de
código puede ser de gran
ayudar a aumentar la productividad, dado que la herramienta va a generar los estados código
necesario (en lugar
que nosotros!).
Para ver esta funcionalidad de primera mano, haga clic en una línea en blanco dentro de su método
Main () y activar
el menú Insertar fragmento de código. Desde aquí, podrás ver que los fragmentos de código
relacionados se agrupan en
una categoría específica (patrones de código, datos, Aplicación de Windows Forms, etc.) Para este
ejemplo, seleccione
los fundamentos Amath categoría y luego activar el calcular un pago mensual de un préstamo
fragmento (ver Figura 2-14).
Una vez que seleccione un fragmento determinado, se encuentra el código relacionado se expande
de forma automática (prensa
la tecla Esc para cerrar el menú pop-up). Muchos fragmentos de código predefinidos identificar
específicos "marcadores"
para el contenido personalizado. Por ejemplo, una vez que se activa el calcular un pago mensual en
un
Fragmento de Préstamo, se encuentran tres regiones se destacan dentro de la ventana de código.
Con la tecla Tab,
que son capaces de recorrer cada selección para modificar el código según sus necesidades (véase
la Figura 2.15

Figure 2-14. Inserting VB 2008 code snippets

Figure 2-15. The inserted snippet
As

Como puede ver, Visual Studio 2008 define un buen número de fragmentos de código. Sin duda, el
mejor
manera de aprender acerca de cada posibilidad es simplemente a través de la experimentación.
Bajo el capó, cada código
fragmento de código se define dentro de un documento XML (teniendo una extensión *. fragmento
de forma predeterminada), ubicado en
el directorio C: \ Archivos de programa \ Microsoft Visual Studio 9.0 \ VB \ Snippets \ 1033 de la guía.
De hecho, dado que
cada fragmento es simplemente una descripción XML del código que se inserta dentro del IDE, es
muy sencillo
la construcción de fragmentos de código personalizados.
Detalles nNota de cómo construir fragmentos de encargo se pueden encontrar en mi artículo "La
investigación de fragmentos de código Tecnología"
en [Link] Si bien el artículo se muestra la construcción de fragmentos de código
C #, se puede muy fácilmente
construir VB 2008 por fragmentos de edición de código VB 2008 (en lugar de código C #) dentro de
la sección del fragmento de CDATA.
El Diseñador de clases Visual
Visual Studio 2008 nos da la capacidad de diseñar clases visuales (pero esta capacidad no está
incluido en
Visual Basic 2008 Express). La utilidad Diseñador de clases le permite ver y modificar las relaciones
de los tipos (clases, interfaces, estructuras, enumeraciones y delegados) en el proyecto.
Con esta herramienta, usted puede agregar visual (o eliminar) los miembros (o desde) un tipo y que
su
modificaciones que se recogen en el archivo correspondiente *. vb. Además, al modificar un
determinado archivo de VB 2008,
cambios se reflejan en el diagrama de clase.

Para trabajar con este aspecto de Visual Studio 2008, el primer paso es insertar un nuevo archivo
de diagrama de clase.
Hay muchas maneras de hacerlo, una de ellas es hacer clic en el botón Ver diagrama de clase se
encuentra en
Lado derecho el Explorador de soluciones (ver Figura 2.16).
Figura 2-16. Inserción de un archivo de diagrama de clase
nNota Si ha seleccionado el icono de su proyecto en el Explorador de soluciones antes de insertar
un diagrama de clase (como se muestra
en la Figura 2-16), el IDE automáticamente agregar un diseñador visual para cada tipo en los
archivos de código. Si no se selecciona
el icono del proyecto antes de insertar un archivo de diagrama de clase, se le presentará con un
diseñador de vacío. En este punto,
puede arrastrar los archivos *. vb desde el Explorador de soluciones y soltarlos en el diseñador para
ver cada tipo.
Una vez que usted lo hace, usted encontrará los iconos de clase que representan a las clases del
proyecto actual. Si
haga clic en la imagen de flecha, puede mostrar u ocultar los miembros del tipo (ver Figura 2.17).
Ten en cuenta que
Visual Studio 2008 le mostrará todos los miembros en el proyecto actual de forma predeterminada.
Si desea eliminar
un elemento determinado en el diagrama, simplemente haga clic derecho y seleccione Eliminar en
el menú contextual (esto
No elimine el archivo de código relacionado).
Figura 2-17. El diagrama de clase espectador

Esta utilidad trabaja en conjunto con otros dos aspectos de Visual Studio 2008: Detalles de la clase
ventana (activa mediante el menú Ver "Otras Windows) y el Diseñador de clases Caja de
herramientas (activa
utilizando el elemento de menú Ver äToolbox). La ventana Detalles de clase no sólo le muestra la
detalles del elemento seleccionado en el diagrama, sino también le permite modificar los actuales
miembros
y los miembros de insertar nuevos sobre la marcha (véase la Figura 2-18).
Figura 2-18. La ventana Detalles de clase
El Diseñador de clases Caja de herramientas (vea la Figura 2-19) le permite insertar nuevos tipos en
el proyecto
(y crear relaciones entre estos tipos) visualmente. (Tenga en cuenta que debe tener un diagrama de
clase
como la ventana activa para ver esta caja de herramientas.) Al hacerlo, el IDE crea
automáticamente nuevas
VB 2008 definiciones de tipos en el fondo.
Figura 2-19. La caja de herramientas Diseñador de clases
A modo de ejemplo, arrastre una nueva clase del Diseñador de clases Cuadro de herramientas al
Diseñador de clases.
El nombre de esta clase de coches en el cuadro de diálogo resultante. Ahora, utilizando la ventana
Detalles de clase, agregue un público
String Petname campo denominado (véase la Figura 2-20).

Figura 2-20. Agregar un campo con la ventana Detalles de clase

Si ahora mirar el VB 2008 la definición de la clase de coches (en el recién generado [Link]
archivo), verá que se ha actualizado en consecuencia (que no encontrará en los comentarios de
código siguiente,
por supuesto):

Public Class Car

' Public data is typically a bad idea,
' however it will simplify this example.
Public petName As String
End Class

Ahora, agregue otra nueva clase para el diseñador llamado Sportscar. A continuación, seleccione el
icono de la herencia
de la Clase Designer Toolbox y haga clic en el icono de Sportscar. A continuación, mueva el cursor
del ratón en la parte superior
del icono de la clase de coche y haga clic en el ratón. Si realiza estos pasos correctamente, que
acaba de
derivados de la clase Sportscar de coches (ver Figura 2-21).
Figura [Link] que se derivan de una clase existente
Para completar este ejemplo, actualizar la clase Sportscar generado con un método público llamado
PrintPetName () de la siguiente manera (no preocuparse por la sintaxis en este punto, usted cavar
en el
detalles de diseño de clases a partir del próximo capítulo):

Public Class SportsCar

Inherits Car
Public Function PrintPetName() As String
petName = "Fred"
Return [Link]("Name of this car is: {0}", petName)
End Sub
End Class

El banco de prueba de objetos

Otra buena herramienta visual que proporciona Visual Studio 2008 es objeto de prueba de banco
(OTB). Este aspecto de la
el IDE le permite crear rápidamente una instancia de una clase e invocar sus miembros sin la
necesidad de
para compilar y ejecutar toda la aplicación. Esto puede ser extremadamente útil cuando se desea
probar un
método específico, pero no desean pasar por docenas de líneas de código para hacerlo. Esto
también es
muy útil cuando usted está construyendo una biblioteca. NET (*. dll) y desea probar rápidamente su
miembros sin necesidad de crear una aplicación de las pruebas por separado.
Para trabajar con la OTB, haga clic en el tipo que desea crear con el Diseñador de clases. Por
ejemplo, haga clic en el tipo Sportscar, y desde el menú contextual resultante seleccione Crear
InstanceäSportsCar (). Se abrirá un cuadro de diálogo que le permite nombrar el temporal
variable de objeto (y el suministro de los argumentos de constructor, si es necesario). Una vez
finalizado el proceso,
se encuentra el objeto alojado en el IDE. Haga clic en el icono del objeto e invocar el
PrintPetName () método (véase la Figura 2-22).
Figura 2-22. El Visual Studio 2008 objetos de Banco de Pruebas
Una vez que lo hace, la OTB le mostrará el valor devuelto por una función, que es una cadena
establecida en el
valor "Nombre de este coche es: Fred". Observe en la figura 2.23, puede optar por guardar este
nuevo objeto String
en la OTB, así, después de lo cual puede invocar a varios miembros del tipo String.
Figura [Link] nuestro valor devuelto por una función

El sistema de ayuda integrado

El aspecto final de Visual Studio 2008 debe ser cómodo con desde el principio es la plena
sistema de ayuda integrado. . NET Framework 3.5 SDK (también conocido como el MSDN Library)
es
muy buena, muy legible, y lleno de información útil. Dado el gran número de predefinidos
. tipos de redes (que suman así a los miles), usted debe estar dispuesto a subirse las mangas y
profundizar en la documentación presentada. Si te resistes, que están condenados a una frustración
de largo, y
existencia dolorosa como desarrollador de. NET.
Visual Studio 2008 proporciona la ventana Ayuda dinámica (se accede a través de la Ayuda
adinámico
selección de menú), que cambia su contenido (dynamically!) sobre la base de lo que el tema
(ventana, menú,
palabra clave de código fuente, etc) es seleccionado. Por ejemplo, si coloca el cursor en la consola
clase, la ventana Ayuda dinámica muestra un conjunto de enlaces sobre el tipo [Link].
nNota Otro atajo útil es la tecla F1 de Visual Studio 2008. Basta con ubicar el cursor del ratón dentro
de un
palabra clave, tipo o método y pulse la tecla F1. El IDE automáticamente te llevará a la página de
ayuda correcta.
También debe ser consciente de un subdirectorio muy importante de. NET Framework 3.5 SDK
documentación. En primer lugar, activar la opción Ayuda äContents menú de la documentación. En
el marco del
. NET Framework SDK para el Desarrollo [Link] [Link] marco [Link] Framework
Nodo de referencia de la documentación, se encuentra la documentación completa de todas y cada
espacio de nombres en las bibliotecas. NET base (véase la Figura 2-24).
Figura 2-24. El. NET base de la colección de referencia

Cada nodo define el conjunto de tipos en un espacio dado, los miembros de un determinado tipo, y
la
parámetros de un miembro determinado. Por otra parte, al ver la página de ayuda para un mismo
tipo, se le
se dijo el nombre de la asamblea y espacio de nombres que contiene el tipo en cuestión (que se
encuentra en el
parte superior de dicha página). Al leer el resto de este libro, supongo que va a sumergirse en
esta muy, muy nodo fundamental para leer sobre los detalles adicionales de la entidad objeto de
examen.
nNota Me gustaría subrayar una vez más la importancia de trabajar con la suministrada. NET
Framework 3.5 documentación.
Cuando usted está aprendiendo un marco nuevo y lenguaje de programación, tendrá que subirse
las mangas
y cavar en los detalles. Ningún libro, independientemente de su tamaño, puede cubrir todos los
detalles de la creación de aplicaciones con Visual
Basic 2008 o la plataforma. NET. Por lo tanto, si se encuentra con un tipo o miembro que desee
obtener más información
sobre como se trabaja a través de este texto, asegúrese de aprovechar el sistema de ayuda!
El papel de la compatibilidad de Visual Basic 6.0
Asamblea
Como lo más seguro dado cuenta a lo largo de este libro, Visual Basic 2008 es un
revisión a fondo de VB6 que a menudo es mejor considerar simplemente VB 2008 como un lenguaje
nuevo en el
familiar básica, en lugar de "Visual Basic 7.0." Con este fin, muchos familiares VB6 funciones,
enumeraciones,
tipos definidos por el usuario y los objetos intrínsecos están en ninguna parte se encuentra
directamente en el. NET
bibliotecas de clases base.
Aunque esto es técnicamente cierto, todos los de Visual Basic 2008 proyecto creado con Visual
Studio 2008
(Así como Visual Basic 2008 Express Edition) de forma automática hace referencia a un particular.
NET
llamado [Link], que define los tipos que proporcionan la misma funcionalidad de
la
legado VB6 construcciones. Al igual que cualquier montaje, [Link] se compone de
numerosas
espacios de nombres que agrupan ideas afines tipos (ver Figura 2.25).
Figura 2-25. El conjunto de compatibilidad [Link] VB6
Además, cada uno de estos espacios de nombres están automáticamente disponibles para cada
archivo *. vb en su
del proyecto. Teniendo en cuenta este punto, no es necesario añadir explícitamente un conjunto de
instrucciones Imports para acceder
de sus tipos. Por lo tanto, si desea hacerlo, usted todavía puede hacer uso de diversos VB6-ismos,
como el
MsgBox () para mostrar un cuadro de mensaje simple:

' The [Link] namespaces

' are automatically referenced by a
' Visual Studio 2008 VB project.
Module Module1
Sub Main()

MsgBox("Hello, old friend...")

End Sub
End Module

Note como parece que está llamando a un método global llamada MsgBox () directamente dentro de
Main (). En realidad, el MsgBox () es un miembro de un módulo de VB 2008 Interacción con nombre
que se
definido en el espacio de nombres [Link] (véase la Figura 2-26).
Figura 2-26. El espacio de nombres [Link] contiene el tipo de interacción.
Como se verá en el capítulo 3, un módulo de Visual Basic 2008 es similar a un archivo *. bas VB6,
en el que los miembros
definido en un módulo puede ser llamado directamente, sin necesidad de prefijo el nombre de la
definición
módulo. Sin embargo, si usted fuera a prefijo del módulo de interacción con el MsgBox () función, el
programa
que funcionan de forma idéntica:

Module Module1
Sub Main()
[Link]("Everything old is new again!")
End Sub
End Module

Ahora bien, aunque se puede sentir un poco tranquilizador saber que la funcionalidad de VB6
todavía puede ser simulado
dentro de los nuevos proyectos de Visual Basic 2008, le recomiendo que evite el uso de este tipo en
posible. En primer lugar, la escritura parece estar en la pared sobre la vida de VB6, en el que
La propia Microsoft tiene previsto eliminar gradualmente el apoyo a VB6 con el tiempo, y teniendo
en cuenta esto, no se puede garantizar
que esta asamblea de compatibilidad se apoyará en el futuro.
Además, las bibliotecas de clases base de ofrecer numerosos tipos administrados que ofrecen una
funcionalidad mucho más
que el (pronto-a-ser) el legado lenguaje de programación Visual Basic 6. Teniendo en cuenta estos
puntos, este texto
no hacer uso de la capa de compatibilidad de VB6. Por el contrario, que se centrará en el
aprendizaje. NET base
bibliotecas y la forma de interactuar con este tipo utilizando la sintaxis de Visual Basic 2008.

Un catálogo parcial de adicionales. NET

Herramientas de desarrollo
Para concluir este capítulo, me gustaría señalar una serie de. NET herramientas de desarrollo que
se complementan
la funcionalidad proporcionada por el IDE de elección. Muchas de las herramientas mencionadas
aquí son
de código abierto, y todos ellos son gratuitos. Aunque no tengo el espacio para cubrir los detalles de
estas utilidades, la tabla 2-2 enumera una serie de herramientas que he encontrado para ser
extremadamente útil, así como
URL que puede visitar para obtener más información acerca de ellos.
Table 2-2. Select .NET Development Tools
Tool Meaning in Life URL
FxCop This is a must-have for any .NET developer [Link]
interested in .NET best practices. FxCop
will test any .NET assembly against the
official Microsoft .NET best-practice
coding guidelines.
Lutz Roeder’s This advanced .NET decompiler/object [Link]
Reflector browser allows you to view the .NET dotnet
implementation of any .NET type using
a variety of languages.
NAnt NAnt is the .NET equivalent of Ant, the [Link]
popular Java automated build tool. NAnt projects/nant
allows you to define and execute detailed
build scripts using an XML-based syntax.
NDoc NDoc is a tool that will generate code [Link]
documentation files for commented VB projects/ndoc
code (or a compiled .NET assembly) in a
variety of popular formats (MSDN’s *.chm,
XML, HTML, Javadoc, and LaTeX).
NUnit NUnit is the .NET equivalent of the [Link]
Java-centric JUnit unit testing tool. Using
NUnit, you are able to facilitate the
testing of your managed code.

Summary
So as you can see, you have many new toys at your disposal! The point of this chapter was to provide
you with a tour of the major programming tools a VB 2008 programmer may leverage during the
development process. You began the journey by learning how to generate .NET assemblies using
nothing other than the free VB 2008 compiler and Notepad.
You also examined three feature-rich IDEs, starting with the open source SharpDevelop, followed
by Microsoft’s Visual Basic 2008 Express and Visual Studio 2008. While this chapter only
scratched the surface of each tool’s functionality, you should be in a good position to explore
your chosen IDE at your leisure. The chapter wrapped up by describing the role of Microsoft.
[Link] and mentioned a number of open source .NET development tools that extend
the functionality of your IDE of choice.

Core VB Programming
Constructs
Programación VB 2008 Construcciones,
Parte I
Este capítulo comienza su investigación formal del lenguaje de programación Visual Basic 2008. No
ser conscientes de este capítulo y el siguiente se presentan una serie de temas independiente del
tamaño de un bocado debe
sentirse cómodos con lo que exploras. NET Framework. A diferencia de los capítulos restantes de
este texto,
no hay ningún tema predominante en los próximos dos capítulos más allá de examinar las
características sintácticas básicas
de VB 2008.
Dicho esto, la primera tarea es comprender el papel de la palabra clave del módulo como
así como el formato de punto de partida de un programa: el método Main (). A continuación, se
investigará la
intrínseca VB 2008 los tipos de datos (y sus tipos equivalente en el espacio de nombres System),
así como diversas
datos de las rutinas de conversión de tipo. Nos terminar examinando el conjunto de los operadores,
la iteración construcciones,
y construcciones de decisión para construir declaraciones código válido.
El papel del tipo de módulo
Visual Basic 2008 admite una programación específica la construcción de un módulo llamado, que
se declara
con la palabra clave del módulo. Por ejemplo, al crear un proyecto Aplicación de consola con Visual
Studio 2008, recibirá automáticamente un archivo *. vb que contiene el siguiente código:

Module Module1
Sub Main()
End Sub
End Module

Bajo el capó, la palabra clave del módulo define un tipo de clase, con algunas excepciones notables.
En primer lugar
y ante todo, una función pública, el subprograma, propiedad o variable miembro define en el
ámbito de aplicación de un módulo se expone como un "miembro compartido" que se puede
acceder directamente a través de una aplicación.
En pocas palabras, los miembros compartidos permiten simular un alcance global dentro de la
aplicación
que es más o menos análoga a la funcionalidad proporcionada por un archivo *. bas VB6 (los
detalles sobre compartida
miembros se pueden encontrar en el capítulo 5).
Dado que los miembros de un módulo son directamente accesibles, no es necesario anteponer el
nombre del módulo cuando se accede a su contenido. Para ilustrar el trabajo con módulos, crear
una nueva consola
Proyecto de aplicación (llamada FunWithModules) y actualizar el archivo de código inicial de la
siguiente manera:

Module Module1
Sub Main()
' Show banner.
DisplayBanner()
' Get user's name and say howdy.
GreetUser()
End Sub
Sub DisplayBanner()
' Get the current color of the console text.
Dim currColor As ConsoleColor = [Link]
' Set text color to yellow.
[Link] = [Link]
[Link]("******* Welcome to FunWithModules *******")
[Link]("This simple program illustrates the role")
[Link]("of the Module type.")
[Link]("*****************************************")
' Reset to previous color of your console text.
[Link] = currColor
[Link]()
End Sub
Sub GreetUser()
Dim userName As String
[Link]("Please enter your name: ")
userName = [Link]()
[Link]("Hello there {0}. Nice to meet ya.", userName)
End Sub
End Module
Figure 3-1 shows one possible output.

Proyectos con múltiples módulos

En nuestro ejemplo, observe que el método Main () es capaz de llamar directamente al
DisplayBanner ()
y GreetUser () métodos. Debido a que estos métodos se definen en el mismo módulo como Main (),
no estamos obligados como prefijo el nombre de nuestro módulo (Module1) al nombre del miembro.
Sin embargo, si
desea hacerlo, puede adaptar Main () de la siguiente manera:

Sub Main()
' Show banner.
[Link]()
' Get user's name and say howdy.
[Link]()
End Sub

En el ejemplo actual, esto es un poco completamente opcional de la sintaxis (no hay diferencia en
términos de rendimiento o el tamaño de la asamblea compilado). Sin embargo, se supone que iban
a definir un
nuevo módulo (MyModule) en el proyecto (dentro de la misma *. vb, por ejemplo), que define un
idéntica GreetUser formado () método:

Module MyModule
Public Sub GreetUser()
[Link]("Hello user...")
End Sub
End Module

Si usted quiere hablar [Link] () desde dentro del método Main (), ahora tendría que
el prefijo explícitamente el nombre del módulo. Si no se especifica el nombre del módulo, el Main ()
método llama automáticamente al [Link] () método, como lo es en el ámbito mismo
módulo como
Main ():

Sub Main()
' Show banner.
DisplayBanner()
' Call the GreetUser() method in MyModule.
[Link]()
End Sub

Una vez más, entienden que cuando un proyecto está definido por varios módulos, no se
necesarios para el prefijo del nombre del módulo a menos que los métodos son ambiguos. Por lo
tanto, si su actual
proyecto fueron: definir un nuevo módulo denominado MyMathModule:

Module MyMathModule
Function Add(ByVal x As Integer, ByVal y As Integer) As Integer
Return x + y
End Function
Function Subtract(ByVal x As Integer, ByVal y As Integer) As Integer
Return x - y
End Function
End Module

se puede invocar directamente el complemento () y resta () funciona en cualquier lugar dentro de la

aplicación
(u opcionalmente prefijo el nombre del módulo):

Sub Main()
...
' Add some numbers.
[Link]("10 + 10 is {0}.", Add(10, 10))
' Subtract some numbers
' (module prefix optional).
[Link]("10 - 10 is {0}.", [Link](10, 10))
End Sub

nNota Si usted es nuevo en la sintaxis de los lenguajes BASIC, estar seguro de que el capítulo 4 se
cubren los detalles de
las funciones del edificio y subrutinas.

Los módulos no son Instanciable

Otro rasgo del tipo de módulo es que no pueden ser creados directamente con la palabra clave New
VB 2008
(cualquier intento de hacerlo resultará en un error del compilador). Por lo tanto, el siguiente código
es ilegal:

' Nope! Error, can't allocated modules!

Dim m as New Module1()

Por el contrario, un módulo simplemente expone miembros compartidos.

nNota Si usted ya tiene experiencia en programación orientada a objetos, tenga en cuenta que los
tipos de módulo no se puede
utilizado para construir jerarquías de clases, ya que implícitamente están cerrados. Además, a
diferencia de "normales" las clases, los módulos no pueden
implementar interfaces.
Cambiar el nombre de su módulo inicial
De forma predeterminada, Visual Studio 2008 los nombres de los de tipo inicial del módulo de una
aplicación de consola utilizando el
más bien anodino Module1. Si tuviera que cambiar el nombre del módulo que defina el Main ()
método a un nombre más adecuado (Programa, por ejemplo), el compilador generará un error como
lo siguiente:

'Sub Main' was not found in 'FunWithModules.Module1'.

Con el fin de informVisual Studio 2008 con el nombre nuevo módulo, se le requiere para restablecer
el
"objeto de inicio"por medio de la ficha Aplicación del cuadro de diálogo Mi proyecto, como se ve en
la Figura 3-2.
Una vez que lo hace, usted será capaz de compilar la aplicación sin errores.
Figura 3-2. Restablecer el nombre del módulo
nNota como un acceso directo, también puede cambiar el nombre de su módulo inicial, cambiando
el nombre del archivo utilizando la definición de la
Ventana Explorador de soluciones de Visual Studio. Esto automáticamente "reiniciar" el objeto de
inicio

Miembros de los módulos

Para terminar nuestra investigación de los tipos de módulos, sé que los módulos pueden tener
miembros adicionales
más allá de las subrutinas y funciones. Si desea definir los datos de campo (así como otros
miembros, como
como propiedades o eventos), usted es libre de hacerlo. Por ejemplo, suponga que desea actualizar
a MyModule
contienen una sola pieza de datos de la cadena pública. Tenga en cuenta que la GreetUser ()
método que ahora se imprimirá
este valor cuando se invoca:

Module MyModule
Public UserName As String
Sub GreetUser()
[Link]("Hello, {0}.", UserName)
End Sub
End Module

Al igual que cualquier miembro de módulo, el nombre de usuario puede acceder directamente por
cualquier parte de su solicitud.
Por ejemplo:

Sub Main()
...
' Set user's name and call second form of GreetUser().
UserName = "Fred"
[Link]()
...
End Sub

nSource Código FunWithModules El proyecto se encuentra en el Capítulo 3 subdirectorio.

El papel del método principal
Cada VB 2008 ejecutables de aplicaciones (como un programa de consola, el servicio de Windows o
el escritorio de un
GUI de la aplicación) debe contener un tipo de definición de un método Main (), que representa el
punto de entrada de
la aplicación. Como acabamos de ver, el método Main () generalmente se coloca dentro de un tipo
de módulo,
que como ustedes recuerdan define implícitamente Main () como un método compartido.
En sentido estricto, sin embargo, Main () también se puede definir en el ámbito de aplicación de un
tipo de clase o estructura
tipo así. Si se define el método Main () dentro de cualquiera de estos tipos, debe
expresamente hacer uso de la palabra clave compartida. Para ilustrar, crear una nueva aplicación
de consola denominada
FunWithMain. Elimine el código en el archivo *. vb inicial y sustituirlo por el siguiente:

Class Program
' Unlike Modules, members in a class are not
' automatically shared. Thus, we must declare Main()
' with the Shared keyword.
Shared Sub Main()
End Sub
End Class

Si intenta compilar el programa, usted recibirá otra vez un error del compilador que le informa
que el método Main () no puede ser localizado. Uso de la ficha Aplicación del cuadro de diálogo Mi
proyecto,
Ahora puede especificar que el programa objeto de inicio del programa (como ya se muestra en la
Figura 3-2).

Procesamiento de la línea de comandos Uso de argumentos

[Link]
Una de las tareas comunes Main () se llevará a cabo para procesar los argumentos de entrada de
línea de comandos.
Por ejemplo, considere el compilador de línea de comandos VB, [Link] (véase el capítulo 2). Como
ustedes recordarán,
especifica las distintas opciones (por ejemplo, / target, entrada / salida, etc) al compilar nuestros
archivos de código. La
compilador de [Link] procesados estos indicadores de entrada con el fin de compilar el
ensamblado de salida. Cuando se
deseo de construir un método Main () que puede procesar los argumentos de entrada de línea de
comandos para su medida
aplicaciones, usted tiene varias formas posibles de hacerlo.
Su primer enfoque consiste en hacer uso de la GetCommandLineArgs compartido () método
definido por el
Tipo [Link]. Este método devuelve un array de objetos String. El primer elemento de
la
matriz es simplemente el nombre del programa ejecutable, mientras que cualquier resto de
elementos de la matriz representan
los argumentos de línea de comandos propios. Para ilustrar, actualizar su actual método Main ()
como
siguiente:

Class Program
Shared Sub Main()
[Link]("***** Fun with Main() *****")
' Get command-line args.
Dim args As String() = [Link]()
Dim s As String
For Each s In args
[Link]("Arg: {0}", s)
Next
End Sub
End Class

Suponiendo que usted ha construido su aplicación, si usted fuera a ejecutar ahora la aplicación en el
símbolo del
del sistema, se puede alimentar en sus argumentos de la misma manera como lo hizo cuando se
trabaja
con [Link] (ver Figura 3-3).
Figura 3-3. Procesamiento de la línea de comandos argumentos
Por supuesto, depende de usted para determinar que los argumentos de línea de comandos de su
programa
responder y la forma en que debe tener el formato (por ejemplo, con un - o un prefijo /). Aquí
simplemente se pasa en
una serie de opciones que se imprime en el símbolo del sistema. Supongamos, sin embargo, fueron
la creación de
un nuevo juego de video y programar la aplicación para procesar una opción llamada-godmode. Si
el
usuario inicia la aplicación con la bandera, ya sabes que el usuario es en realidad un tramposo, y
usted puede tener una
curso de acción apropiado.

Procesamiento de la línea de comandos con argumentos Main ()

Si prefiere no hacer uso del tipo [Link] para procesar los argumentos de línea de
comandos,
puede definir su método Main () para tener una matriz de entrada de cadenas. Para ilustrar, la
actualización
su base de código de la siguiente manera:

Shared Sub Main(ByVal args As String())

[Link]("***** Fun with Main() *****")
' Get command-line args.
Dim s As String
For Each s In args
[Link]("Arg: {0}", s)
Next
End Sub
Al adoptar este enfoque, el primer elemento de la matriz de entrada es de hecho la primera línea de
comandos
argumento (en lugar del nombre del ejecutable). Si se va a ejecutar la aplicación una vez
de nuevo, usted encontrará cada opción de línea de comandos se imprime en la consola.
Main () como una función (no una subrutina)
También es posible definir Main () como una función que devuelve un entero, en lugar de una
subrutina
(que nunca tiene un valor de retorno). Este enfoque a la creación de un método Main () tiene sus
raíces en
Lenguajes basados en C, en devolver el valor 0 indica normalmente que el programa ha terminado
sin errores. Rara vez (o nunca) necesitan para construir su método Main () de esta manera, sin
embargo,
en aras de la realización, aquí está un ejemplo:

Shared Function Main(ByVal args As String()) As Integer

[Link]("***** Fun with Main() *****")
Dim s As String
For Each s In args
[Link]("Arg: {0}", s)
Next
' Return a value to the OS.
Return 0
End Function

Independientemente de cómo se defina el método Main (), el objetivo sigue siendo el mismo:
interactuar con
los tipos que llevan a cabo la funcionalidad de su aplicación. Una vez que la declaración final en el
Método main () se ha ejecutado, Main () las salidas y su aplicación termina.
Especificar argumentos de línea de comandos con Visual Studio 2008
Por último, permítanme señalar que Visual Studio 2008 le permite especificar de entrada de línea de
comandos
argumentos, que puede ser muy útil cuando las pruebas y la depuración de la aplicación. En lugar
de
tener que ejecutar la aplicación en una línea de comandos para alimentar argumentos en forma
manual, puede hacerla
especificar los argumentos utilizando la ficha Depurar del cuadro de diálogo Mi proyecto, que se
muestra en la Figura 3.4 (véase la
La línea de comandos área de texto argumentos).

Figura 3-4. Simulación de argumentos de la línea de comandos

Al compilar y ejecutar la aplicación en modo de depuración, los argumentos especificados son
se pasa al método Main () de forma automática. Sé que al compilar y ejecutar un lanzamiento
construcción de su solicitud (que se puede establecer mediante la ficha de compilación del cuadro
de diálogo Mi proyecto
caja), esto ya no es el caso.
Un interesante Aparte: Algunos miembros adicionales de
la clase [Link]
El tipo de Medio Ambiente expone una serie de métodos muy útiles más allá de
GetCommandLineArgs ().
En concreto, esta clase le permite obtener una serie de detalles sobre el sistema operativo en la
actualidad
alojamiento de su. NET utilizando diversos miembros compartidos. Para ilustrar la utilidad de
[Link], actualizar el método Main () con la siguiente lógica:

Shared Function Main(ByVal args As String()) As Integer

...
' OS running this app?
[Link]("Current OS: {0}", [Link])
' List the drives on this machine.
Dim drives As String() = [Link]()
Dim d As String
For Each d In drives
[Link]("You have a drive named {0}.", d)
Next
' Which version of the .NET platform is running this app?
[Link]("Executing version of .NET: {0}", _
[Link])
Return 0
End Function

El tipo para el Medio Ambiente define a los miembros que no sean los que se ven en el ejemplo
anterior.
Tabla 3-1 documentos algunas propiedades adicionales de interés, sin embargo, asegúrese de
revisar la
. NET Framework 3.5 SDK para más detalles

Table 3-1. Select Properties of [Link]

Property Meaning in Life
CurrentDirectory Gets the full path to the current application
MachineName Gets the name of the current machine
NewLine Gets the newline symbol for the current environment
ProcessorCount Returns the number of processors on the current machine
SystemDirectory Returns the full path to the system directory
UserName Returns the name of the user who started this application

El [Link] clase
Casi todos los ejemplos de aplicaciones creadas en el transcurso de los capítulos iniciales de este
texto
hacen un uso extensivo de la clase [Link]. Si bien es cierto que una consola de interfaz
de usuario (a veces
llama CUI) no es tan atractivo como una interfaz gráfica de usuario (GUI) o front-end basado en
web,
restricción de los primeros ejemplos de programas de la consola nos permitirá mantener el foco en
la sintaxis de
Visual Basic y los aspectos centrales de la plataforma. NET, en lugar de tratar con las
complejidades de la
GUIs edificio.
Como su nombre lo indica, la clase Console encapsula la entrada, salida y error de secuencia de
manipulaciones
para aplicaciones basadas en la consola. Tabla 3-2 se enumeran algunas (pero definitivamente no
todos) de los miembros del
de interés.
Table 3-2. Select Members of [Link]
Member Meaning in Life
Beep() This method forces the console to emit a beep of a specified frequency and
duration.
BackgroundColor These properties set the background/foreground colors for the current
ForegroundColor output. They may be assigned any member of the ConsoleColor enumeration.
BufferHeight These properties control the height/width of the console’s buffer area.
BufferWidth
Title This property sets the title of the current console.
WindowHeight These properties control the dimensions of the console in relation to the
WindowWidth established buffer.
WindowTop
WindowLeft
Clear() This method clears the established buffer and console display area.

Básico de entrada y salida con la clase de consola

Además de los miembros en la Tabla 2.3, el tipo de consola define un conjunto de métodos para
capturar la entrada
y la salida, todos los cuales son compartidos y por lo tanto llama anteponiendo el nombre de la clase
(consola) para el nombre del método. Como se ha visto, WriteLine () bombas una cadena de texto
(incluyendo un coche
ida y vuelta) a la secuencia de salida. El método write () texto bombas de la secuencia de salida sin
retorno de carro. ReadLine () le permite recibir información de la secuencia de entrada hasta el
retorno de carro, mientras que Lee () se utiliza para la captura de un solo carácter del flujo de
entrada.
Para ilustrar básicas de E / S usando la clase Console, cree una nueva aplicación de consola
denominada
BasicConsoleIO y actualizar el método Main () con la lógica que pide al usuario para algunos bits
de información y se hace eco de cada elemento en la secuencia de salida estándar.

Sub Main()
[Link]("***** Fun with Console IO *****")
' Echo some information to the console.
[Link]("Enter your name: ")
Dim s As String = [Link]()
[Link]("Hello, {0}", s)
[Link]("Enter your age: ")
s = [Link]()
[Link]("You are {0} years old", s)
End Sub

El formato de salida de la consola

Durante estos primeros capítulos, que sin duda han notado numerosos casos de los símbolos {0},
{1}, y como incrustado dentro de una cadena literal. La plataforma. NET introduce un nuevo estilo de
formato de cadenas, lo que puede ser utilizado por cualquier lenguaje de programación. NET. En
pocas palabras, cuando se
la definición de un literal de cadena que contiene los segmentos de datos cuyo valor no se conoce
hasta tiempo de ejecución,
son capaces de especificar un marcador de posición en el literal utilizando esta sintaxis rizado
soporte. En tiempo de ejecución, el
valor (s) pasó a [Link] () se sustituyen por cada marcador de posición. Para ilustrar, la
actualización
su actual método Main () de la siguiente manera:

Sub Main()
...
' Specify string placeholders and values to use at
' runtime.
Dim theInt As Integer = 90
Dim theDouble As Double = 9.99
Dim theBool As Boolean = True
[Link]("Value of theInt: {0}", theInt)
[Link]("theDouble is {0} and theBool is {1}.", _
theDouble, theBool)
End Sub

El primer parámetro a WriteLine () representa una cadena literal que contiene marcadores de
posición opcional
designada por {0}, {1}, {2}, y así sucesivamente. Ser muy consciente de que el primer número
ordinal de un curlybracket
marcador de posición siempre comienza con 0. El resto de parámetros a WriteLine () son
simplemente el
valores que se inserta en los marcadores de posición respectiva (en este caso, un número entero,
un doble, y un
Boolean).
nNota Si usted tiene un menor número de marcadores de posición de número único rizado el
soporte de los argumentos de relleno, que se
recibir una excepción FormatException en tiempo de ejecución.
También es permisible para un marcador de posición dada a repetir dentro de una cadena
determinada. Por ejemplo, si
son un fan de los Beatles y queremos construir la cadena "9, Número 9, Número 9", escribiría:

' John says...

[Link]("{0}, Number {0}, Number {0}", 9)

También sabemos que es posible la posición de cada marcador de posición en cualquier lugar
dentro de una cadena literal,
y no es necesario seguir una secuencia en aumento. Por ejemplo, consideremos el siguiente
fragmento de código:

' Prints: 20, 10, 30.

[Link]("{1}, {0}, {2}", 10, 20, 30)

NET cadena de formato Banderas

Si desea más detalles de formato, cada marcador de posición opcionalmente puede contener varios
formatos
caracteres. Cada carácter de formato se puede escribir en mayúsculas o minúsculas con poca o
ninguna
consecuencia. Tabla 3-3 muestra las opciones de formato básico.

Table 3-3. .NET String Format Characters

String Format Character Meaning in Life
C or c Used to format currency. By default, the flag will prefix the local cultural
symbol (a dollar sign [$] for U.S. English).
D or d Used to format decimal numbers. This flag may also specify the
minimum number of digits used to pad the value.
E or e Used for exponential notation.
F or f Used for fixed-point formatting.
G or g Stands for general. This character can be used to format a number to
fixed or exponential format.

String Format Character Meaning in Life

N or n Used for basic numerical formatting (with commas).
X or x Used for hexadecimal formatting. If you use an uppercase “X”, your hex
format will also contain uppercase characters.

Estos caracteres de formato son el sufijo marcador de posición para un valor determinado, utilizando
los dos puntos testigo (por ejemplo,
{0: C}, {1: d}, {2: X}, y así sucesivamente). Ahora, actualizar el método Main () con la siguiente
lógica:

Now make use of some format tags.

Sub Main()
...
[Link]("C format: {0:C}", 99989.987)
[Link]("D9 format: {0:D9}", 99999)
[Link]("E format: {0:E}", 99999.76543)
[Link]("F3 format: {0:F3}", 99999.9999)
[Link]("N format: {0:N}", 99999)
[Link]("X format: {0:X}", 99999)
[Link]("x format: {0:x}", 99999)
End Sub

Aquí estamos definiendo numerosos literales de cadena, cada uno de ellos tiene un segmento no se
conoce hasta
tiempo de ejecución. En tiempo de ejecución, el carácter de formato se utiliza internamente por el
tipo de consola para imprimir
la cadena completa en el formato deseado.
Uso de cadenas de formato [Link] ()
Tenga en cuenta que el uso de los personajes. NET de formato de cadena no se limita a programas
de la consola!
Estos indicadores puede utilizar el mismo al llamar a la [Link] compartido () método. Esto
puede ser útil
cuando se necesita para construir una cadena que contiene valores numéricos en la memoria para
su uso en cualquier aplicación
tipo (formularios Windows Forms, [Link], servicios web, XML, etc). Para ilustrar, la actualización
principal () con el
siguiente código final:

' Now make use of some format tags.

Sub Main()
...
' Use the shared [Link]() method to build a new string.
Dim formatStr As String
formatStr = _
[Link]("Don't you wish you had {0:C} in your account?", 99989.987)
[Link](formatStr)
End Sub

Sistema de Datos Tipos y notación abreviada VB

Como cualquier otro lenguaje de programación, Visual Basic define un conjunto de tipos de datos
intrínsecos, que se utilizan para representar
variables locales, variables de miembros, los valores devueltos y los parámetros de entrada. Aunque
muchos de los
VB tipos de datos se denominan de forma idéntica a los tipos de datos encontrados en VB6, tenga
en cuenta que no es un
asignación directa (especialmente en términos de un máximo de un tipo de datos y el rango
mínimo).
nNota El UInteger ULong, SByte y los tipos de datos no son compatible con CLS (véanse los
capítulos 1 y 16 para obtener detalles sobre
Compatibilidad con CLS). Por lo tanto, si se expone estos tipos de datos de un ensamblado, no se
puede garantizar que cada
. lenguaje de programación NET será capaz de procesar estos datos.
El cambio más significativo desde VB6 es que las palabras clave tipo de datos de Visual Basic 2008
son
en realidad notaciones cortas para los tipos en toda regla en el espacio de nombres System. Tabla
3-4 documentos
los tipos de datos de VB 2008 (con el tamaño de la asignación de almacenamiento), los
equivalentes de datos el tipo de sistema, y
el rango de cada tipo.

Table 3-4. The Intrinsic Data Types of VB 2008

VB Keyword CLS Compliant? System Type Range Meaning in Life
Boolean Yes [Link] True or False Represents truth or
falsity
SByte No [Link] –128 to 127 Signed 8-bit number
Byte Yes [Link] 0 to 255 Unsigned 8-bit
number
Short Yes System.Int16 –32,768 to 32,767 Signed 16-bit number
UShort No System.UInt16 0 to 65,535 Unsigned 16-bit
number
Integer Yes System.Int32 –2,147,483,648 to Signed 32-bit number
2,147,483,647
UInteger No System.UInt32 0 to 4,294,967,295 Unsigned 32-bit
number
Long Yes System.Int64 –9,223,372,036,854,775,808 to Signed 64-bit number
9,223,372,036,854,775,807

VB Keyword CLS Compliant? System Type Range Meaning in Life

ULong No System.UInt64 0 to 18,446,744,073,709,551,615 Unsigned 64-bit
number
Char Yes [Link] U+0000 to U+ffff A single 16-bit
Unicode character
Single Yes [Link] ±1.5 ✕ 1045 to ±3.4 ✕ 1038 32-bit floating-point
number
Double Yes [Link] ±5.0 ✕ 10324 to ±1.7 ✕ 10308 64-bit floating-point
number
Decimal Yes [Link] ±1.0 ✕ 10e28 to ±7.9 ✕ 10e28 A 96-bit signed
number
String Yes [Link] Limited by system memory Represents a set of
Unicode characters
Date Yes [Link] January 1, 0001 to Represents a
December 31, 9999 time/date value
Object Yes [Link] Any type can be stored in an The base class of all
object variable types in the .NET
universe
78 CHAPTER 3 ■ VB 2008 PROGRAMMING CONSTRUCTS, PART I

Cada uno de los tipos numéricos (Short, Integer, etc), así como el tipo de mapa a una Fecha
estructura correspondiente en el espacio de nombres System. En pocas palabras, las estructuras
son "tipos de valor" asignado
en la pila. Por otra parte, String y Object son "tipos de referencia", es decir, el
variable se le asigna en el montón administrado. Usted examinará todos los detalles de valor y
referencia
tipos en el capítulo 12, sin embargo, por el momento, sólo tiene que entender que los tipos de valor
se puede asignar
en la memoria rápidamente y tienen una vida muy fijo y predecible.
Declaración de variables e inicialización
Cuando se declara un tipo de datos como una variable local (por ejemplo, una variable dentro de un
ámbito miembro), que
hacerlo a través de la Dim y As palabras clave. A modo de algunos ejemplos:

Sub MyMethod()
' Local variables are declared as follows:
' Dim variableName As dataType
Dim age As Integer
Dim firstName As String
Dim isUserOnline As Boolean
End Sub

Uno de los cambios sintácticos útil que se ha producido con el lanzamiento de la RED. platformis la
posibilidad de declarar una sucesión de variables en una sola línea de código. VB6 también apoyó
esta capacidad, pero
la semántica fuera un poco intuitivas y una fuente de errores sutiles. Por ejemplo, en VB6, si
no establece explícitamente los tipos de datos de cada variable, las variables no cualificados se
establece en el VB6
Variante tipo de datos:

' In this line of VB6 code, varOne

' is implicitly defined as a Variant!
Dim varOne, varTwo As Integer

Este comportamiento es más que un poco molesto, ya que la única forma en que son capaces de
definir múltiples
las variables del mismo tipo en VB6 es escribir el siguiente código poco redundante:

Dim varOne As Integer, varTwo As Integer

o peor aún, en varias líneas de código:

Dim varOne As Integer

Dim varTwo As Integer
Si bien estos métodos siguen siendo válidos utilizando Visual Basic 2008, al declarar múltiples
variables
en una sola línea, todos ellos se definen en función del tipo de datos especificado. Así, en los
siguientes
VB código 2008, que ha creado dos variables de tipo Integer:

Sub MyOtherMethod()
' In this line of VB 2008 code, varOne
' and varTwo are both of type Integer!
Dim varOne, varTwo As Integer
End Sub

En una nota final, VB 2008 ahora admite la posibilidad de asignar un valor a una variable
directamente en el
punto de la declaración. Para entender el significado de esta nueva pieza de la sintaxis, tenga en
cuenta el hecho de que
en VB6, que se vieron obligados a escribir lo siguiente:
' VB6 code.
Dim i As Integer
i = 99

VB 2008 le permite racionalizar la asignación de variables usando la siguiente notación:

Sub MyMethod()
' Local data can be initialized at the time of declaration:
' Dim variableName As dataType = initialValue
Dim age As Integer = 36
Dim firstName As String = "Sid"
Dim isUserOnline As Boolean = True
End Sub

Valores por defecto de los tipos de datos

Todos VB 2008 los tipos de datos tienen un valor predeterminado que automáticamente se le
asignará a la variable. La
valores por defecto son muy predecibles, y pueden resumirse de la siguiente manera:
• Las variables Boolean se establece en False.
• Los datos numéricos se establece en 0 (o 0.0 en el caso de los tipos de datos de punto flotante).
• Las variables de Char se establece en un carácter vacío único.
• Fecha en que se fijan los tipos de 1/1/0001 [Link] AM.
• referencias a objetos sin inicializar (incluidos los tipos de cadena) se establece en Nothing.
Teniendo en cuenta estas reglas, reflexionar sobre el siguiente código, que ilustra los valores por
defecto asignados a
miembros en un módulo (los valores predeterminados mismo se aplicaría a los miembros de una
clase también):

' Fields of a class or module receive automatic default assignments.

Module Program
Public myInt As Integer ' Set to 0.
Public myString As String ' Set to Nothing.
Public myBool As Boolean ' Set to False.
Public myObj As Object ' Set to Nothing.
End Module}
En Visual Basic 2008, las mismas reglas de los valores por defecto son válidas para las variables
locales definidas
dentro de un ámbito determinado. Teniendo en cuenta esto, el siguiente método devolverá el valor
0, ya que cada local
Entero ha sido asignado automáticamente el valor 0:

Function Add() As Integer

Dim a, b As Integer
Return a + b ' Returns zero.
End Function

El tipo de datos jerarquía de clases

Es muy interesante notar que incluso los primitivos. NET tipos de datos están organizados en una
"jerarquía de clases."
Si eres nuevo en el mundo de la herencia, descubrirá todos los detalles en el capítulo 6. Hasta el
entonces, simplemente entender que los tipos en la parte superior de una jerarquía de clases
proporcionan algunos comportamientos predeterminados que
se otorgan a los tipos derivados. La relación entre estos tipos de sistemas de base puede ser
representado
como se muestra en la Figura 3-7.

Tenga en cuenta que cada uno de estos tipos en última instancia se deriva de [Link], que
define un conjunto de
métodos (ToString (), igual a (), GetHashCode (), y así sucesivamente), común a todos los tipos en
la base. NET
bibliotecas de clases (estos métodos están detallados en el capítulo 6).
También tenga en cuenta que los tipos de datos numéricos se derivan de una clase denominada
[Link]. Descendientes
de ValueType se asignan automáticamente en la pila y por lo tanto tienen una vida muy predecible
y son muy eficientes. Por otro lado, los tipos que no tienen [Link] en su herencia
cadena (como [Link], [Link], [Link], [Link], y el sistema.
Delegado) no se asignan en la pila, pero en el montón de basura recogidas.
Sin entrar demasiado colgado en los detalles de [Link] y [Link] por el
momento
ser (de nuevo, más detalles en el capítulo 12), sólo tiene que saber que debido a que VB 2008 la
palabra clave (por ejemplo,
Entero) es la notación abreviada para el tipo de sistema correspondiente (en este caso,
System.Int32), el
siguiente es la sintaxis perfectamente legal, dado que System.Int32 (el VB 2008 entero) con el
tiempo deriva
de [Link], y por lo tanto puede invocar cualquiera de sus miembros del sector público:

Sub Main()
' A VB 2008 Integer is really a shorthand for System.Int32,
' which inherits the following members from [Link].
[Link]([Link]()) ' Prints the type's hash code value.
[Link]([Link](23)) ' Prints False
[Link]([Link]()) ' Returns the string value "12"
[Link]([Link]()) ' Prints System.Int32
End Sub
Intrínseca de tipos de datos y la nueva palabra clave
Todos los tipos de datos intrínsecos apoyar lo que se conoce como un constructor predeterminado
(véase el capítulo 5). En pocas palabras,
esta característica le permite crear una variable usando la palabra clave New, que se ajusta
automáticamente a la variable
a su valor predeterminado. Aunque es más engorroso de usar la palabra clave New cuando se crea
una
variable básica tipo de datos, el siguiente es sintácticamente bien formada VB 2008 Código:

' When you create a basic data type with New,

' it is automatically set to its default value.
Dim b1 As New Boolean() ' b1 automatically set to False.

En una nota relacionada, también se puede declarar una variable de tipo de datos intrínsecos con el
tipo completo
nombre a través de cualquiera de estos métodos:

' These statements are also functionally identical.

Dim b2 As [Link] = New [Link]()
Dim b3 As [Link]

Por supuesto, las posibilidades de que va a definir un simple booleano con el nombre de tipo
completo o Nuevo
palabra clave en el código es prácticamente nula. Es importante, sin embargo, recordar siempre que
el VB 2008
palabras claves para los tipos de datos simples son poco más que una notación abreviada para los
tipos reales en el sistema
espacio de nombres.
Experimentar con Tipos de datos numéricos
Para experimentar con las propiedades intrínsecas de VB tipos de datos de 2008, crear una nueva
aplicación de consola denominada
BasicDataTypes. En primer lugar, entender que los tipos numéricos de. NET de apoyo y MaxValue
MinValue propiedades que proporcionan información sobre la gama de un determinado tipo puede
almacenar. Por
ejemplo:

Sub Main()
[Link]("***** Fun with Data Types *****")
[Link]("Max of Integer: {0}", [Link])

[Link]("Min of Integer: {0}", [Link])

[Link]("Max of Double: {0}", [Link])
[Link]("Min of Double: {0}", [Link])
End Sub

Además de los MinValue / propiedades MaxValue, un tipo determinado sistema numérico puede
definir
miembros adicionales de utilidad. Por ejemplo, el tipo [Link] le permite obtener los valores
de
épsilon y el infinito (que pueden ser de interés para aquellos de ustedes con un toque matemático):

[Link]("[Link]: {0}", [Link])

[Link]("[Link]: {0}", _
[Link])
[Link]("[Link]: {0}", _
[Link])

Los miembros de [Link]

A continuación, considere el tipo de datos [Link]. La cesión sólo será válida una VB 2008
booleano puede tomar
es del conjunto {true | false}. Teniendo en cuenta este punto, debe quedar claro que no
[Link]
apoyar una MinValue / conjunto de propiedades MaxValue, sino más bien TrueString / FalseString
(que produce la
cadena "True " o "Falso", respectivamente):

[Link]("[Link]: {0}", [Link])

[Link]("[Link]: {0}", [Link])

Los miembros de [Link]

VB 2008 datos de texto se representa por el valor intrínseco de cadena y las palabras clave Char,
que son simples
notaciones cortas por [Link] y [Link], los cuales son Unicode en el marco del
campana. Como usted seguramente ya sabe, una cadena es un conjunto contiguo de caracteres
(por ejemplo, "Hola").
El tipo de datos Char puede representar una sola ranura en un tipo de cadena (por ejemplo, "H").
De forma predeterminada, al definir los datos textuales entre comillas dobles, el compilador de VB
2008 asume
está definiendo un tipo de cadena en toda regla. Sin embargo, para generar una cadena de
caracteres de un solo literal que
debe escribirse como un lugar de Char, el carácter entre comillas dobles y virar en una sola
"c"después de
la cotización de cierre. Si lo hace, asegura que el texto entre comillas dobles literal es representado
como un hecho
[Link], en lugar de una [Link]:

Dim myChar As Char = "a"c

nNota Cuando se habilita Option Strict (que se describe en la sección "La comprensión de Option
Strict" más adelante en este
capítulo) para su proyecto, el compilador de VB 2008 exige que la tachuela en la c sufijo a un tipo de
datos Char cuando
asignación de un valor.
El tipo [Link] le proporciona una gran cantidad de funcionalidad más allá de la capacidad de
mantener
un solo punto de datos de caracteres. Utilizando los métodos comunes de [Link], que son
capaces de determinar
si un carácter dado es numérica, alfabética, un punto de puntuacion, o lo que sea. Para
ilustran, actualizar Main () con las siguientes afirmaciones:

' Fun with [Link].

Dim myChar As Char = "a"c
[Link]("[Link]('a'): {0}", [Link](myChar))
[Link]("[Link]('a'): {0}", [Link](myChar))

[Link]("[Link]('Hello There', 5): {0}", _

[Link]("Hello There", 5))
[Link]("[Link]('Hello There', 6): {0}", _
[Link]("Hello There", 6))
[Link]("[Link]('?'): {0}", _
[Link]("?"c))

Como se ilustra en el fragmento de código anterior, los miembros de [Link] tienen dos
convenciones de llamada:
un solo carácter o una cadena con un índice numérico que especifica la posición de la
carácter a prueba.
De análisis de valores de datos de cadena
Los tipos de datos de. NET proporciona la capacidad para generar una variable de su tipo
subyacente dado un texto
equivalente (por ejemplo, el análisis). Esta técnica puede ser muy útil cuando se desea convertir un
bits de los datos introducidos por el usuario (por ejemplo, una selección de un cuadro de lista
basado en GUI desplegable) en un valor numérico
valor. Tenga en cuenta la lógica de análisis siguientes:

' Fun with parsing.

Dim b As Boolean = [Link]("True")
[Link]("Value of myBool: {0}", b)
Dim d As Double = [Link]("99.884")
[Link]("Value of myDbl: {0}", d)
Dim i As Integer = [Link]("8")
[Link]("Value of myInt: {0}", i)
Dim c As Char = [Link]("w")
[Link]("Value of myChar: {0}", c)

Comprender el tipo [Link]

Como se ha mencionado, String es un tipo de datos nativa en VB 2008. Al igual que todos los tipos
intrínsecos, el VB 2008 String
palabras clave en realidad es una notación abreviada para un tipo de verdad en la biblioteca. NET
de la clase base, que en este
caso es [Link]. Por lo tanto, usted puede declarar una variable de cadena utilizando
cualquiera de estos
notaciones:

' These two string declarations are functionally equivalent.

Dim firstName As String
Dim lastName As [Link]

[Link] proporciona una serie de métodos que se puede esperar de tal clase de utilidad,
incluidos los métodos que devuelven el número de caracteres de la cadena, buscar subcadenas
dentro de la
cadena actual, convertir hacia y desde mayúsculas y minúsculas, y así sucesivamente. Tabla 3-5 se
enumeran algunas (pero
no todos) de los miembros de interés.

Member of String Class Meaning in Life

Chars This property returns a specific character within the current string.
Length This property returns the length of a string.
Compare() This method compares two strings.
Contains() This method determines whether a string contains a specific substring.
Equals() This method tests whether two string objects contain identical character
data.
Format() This method formats a string using other primitives (i.e., numerical data,
other strings) and the {0} notation examined earlier in this chapter.
Insert() This method inserts a string within a given string.
PadLeft() These methods are used to pad a string with some character.
PadRight()
Remove() These methods are used to receive a copy of a string, with modifications
Replace() (characters removed or replaced).
Split() This method returns a String array containing the substrings in this
instance that are delimited by elements of a specified Char or String
array.
Trim() This method removes all occurrences of a set of specified characters
from the beginning and end of the current string.
ToUpper() These methods create a copy of the current string in uppercase or
ToLower() lowercase format.

Básicas de manipulación de cadenas

Trabajar con los miembros de [Link] es como era de esperar. Sólo tienes que crear una
variable de cadena
y hacer uso de la funcionalidad proporcionada por el operador punto. No ser consciente de que
algunos de los miembros
de [Link] se comparten los miembros y, por tanto llamó a la clase (en lugar del
objeto) nivel. Suponga que ha creado una nueva aplicación de consola denominada FunWithStrings
y
actualización Main () de la siguiente manera:

Module Program
Sub Main()
[Link]("***** Fun with Strings *****")
Dim firstName As String = "June"
[Link]("Value of firstName: {0}", firstName)
[Link]("firstName has {0} characters.", [Link])
[Link]("firstName in uppercase: {0}", [Link]())
[Link]("firstName in lowercase: {0}", [Link]())
Dim myValue As Integer = 3456787
[Link]("Hex vaule of myValue is: {0:X}", myValue)
[Link]("Currency value of myValue is: {0:C}", myValue)
End Sub
End Module

Observe cómo los métodos de la ToUpper () y ToLower () (así como la propiedad Length) no han
llevado a cabo como miembros para compartir, y por lo tanto llamar directamente desde un objeto
String.

Pag 117 sigue.