visual basic 2008

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

PARTE 4 Programación con. NETnCHAPTER 15 Introducción. NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 437nCHAPTER 16 Tipo de reflexión, el enlace, y la programación basada en atributos. . . . 483nCHAPTER 17 Procesos, dominios de aplicación, y contextos de objetos. . . . . . . . . . . . . . . . . . . . . . . 517nCHAPTER 18 Creación de aplicaciones multiproceso. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 537nCHAPTER 19. NET Interoperabilidad Asambleas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 571PARTE 5 nnn presentar el. Bibliotecas de red de clase de basenCHAPTER 20 y manipulación de archivos de Directorio. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 607nCHAPTER 21 Presentación de la serialización de objetos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . 633nCHAPTER ADO.NET 22 Parte I: La Capa de Conexión. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 653nCHAPTER 23 ADO.NET Parte II: La capa de desconectado. . . . . . . . . . . . . . . . . . . . . . . . . . . 705nCHAPTER 24 Programación con el API de LINQ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 759nCHAPTER 25 Introducción a Windows Communication Foundation. . . . . . . . . . . . . . . . . . . 795nCHAPTER 26 Introducción a Windows Workflow Foundation. . . . . . . . . . . . . . . . . . . . . . . . . 843PARTE 6 nnn de aplicaciones de escritorio con Windows FormsnCHAPTER 27 Introducción a Windows Forms. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 883nCHAPTER 28 de representación gráfica de datos con GDI +. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 929nCHAPTER 29 Programación con formularios Windows Forms. . . . . . . . . . . . . . . . . . . . . . . . 983PARTE 7 n n n de aplicaciones de escritorio con WPFnCHAPTER 30 Introducción a Windows Presentation Foundation y XAML. . . . . . . . . . . 1047nCHAPTER 31 Programar con los controles de WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1103nCHAPTER 32 WPF representación gráfica 2D, recursos y temas. . . . . . . . . . . . . 1167PARTE 8 nnn construcción de Aplicaciones Web con ASP.NETnCHAPTER construcción de 33 páginas Web ASP.NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1215nCHAPTER 34 Web ASP.NET, Temas y páginas maestras. . . . . . . . . . . . . . . . 1261nCHAPTER 35 de estado de ASP.NET Técnicas de Gestión. . . . . . . . . . . . . . . . . . . . . . . . . . 1297ÍNDICE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1331

Acerca del Autor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xixAcerca del Revisor Técnico. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xixAgradecimientos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xxIntroducción y bienvenida. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xxiPARTE 1 n n n Introducción a Visual Basic 2008 yla Plataforma. NETnCHAPTER 1 La filosofía de. NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3Entender la situación anterior. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3La solución. NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6Introducción a los bloques de construcción de la plataforma. NET(CLR, CTS, y CLS). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6Lo que Visual Basic 2008 trae a la mesa. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7Adicional. NET-Aware lenguajes de programación. . . . . . . . . . . . . . . . . . . . . . . . . . . 9Una visión general de. NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10Comprender el sistema de tipos común. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16Comprender la especificación Common Language. . . . . . . . . . . . . . . . . . . . . . 19

Comprender el Common Language Runtime. . . . . . . . . . . . . . . . . . . . . . . . . . 21La Asamblea / Espacio de nombres / Distinción tipo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22Usando Ildasm.exe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27Uso de Reflector de Lutz Roeder. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30Implementar el tiempo de ejecución. NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30La naturaleza independiente de la plataforma. NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32nCHAPTER 2 Edificio de Visual Basic 2008 aplicaciones. . . . . . . . . . . . . . . . . . . . . 35El papel del. NET Framework 3.5 SDK. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35La VB 2008 la línea de comandos del compilador (vbc.exe). . . . . . . . . . . . . . . . . . . . . . . . . . 36La construcción de aplicaciones con Visual Basic 2008 vbc.exe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37Trabajar con archivos de respuesta de vbc.exe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40Edificio. NET Usando SharpDevelop. . . . . . . . . . . . . . . . . . . . . . . . . . . 43Edificio. NET utilizando Visual Basic 2008 Express. . . . . . . . . . . . . . . . 46vi

Edificio. NET utilizando Visual Studio 2008. . . . . . . . . . . . . . . . . . . . . . 47El papel de la Asamblea de Visual Basic Compatibility 6.0. . . . . . . . . . . . . . . . . . . 59Un catálogo parcial de adicionales. Herramientas de desarrollo NET. . . . . . . . . . . . . . . . . . . . 61Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61PARTE 2 n n n la base de programación VB ConstruyenCHAPTER tres construcciones de programación VB 2008, primera parte. . . . . . . . . . . . . . . . . . . . 65El papel del tipo de módulo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65El papel del método principal. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69Un interesante Aparte: Algunos miembros adicionales de laClase System.Environment. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72El System.Console clase. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73Tipos de datos del sistema de notación abreviada y VB. . . . . . . . . . . . . . . . . . . . . . . . . . . 77Comprender el tipo System.String. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83Estrechamiento (explícito) y ampliación (implícita) Conversiones de tipos de datos. . . . . . . . . . 89Construcción de Visual Basic 2008 declaraciones de código. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94VB 2008 las construcciones de control de flujo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96VB iteración Construye 2008. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102nCHAPTER cuatro construcciones de programación VB 2008, Parte II. . . . . . . . . . . . . . . . . . . 103Definición de subrutinas y funciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103Entender sobrecarga miembros. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111Manipulación de matriz en Visual Basic 2008. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113Entender VB 2008 enumeraciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120Al presentar el VB 2008 Tipo de estructura. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128nCHAPTER 5 Diseño de encapsulado de clase Tipos. . . . . . . . . . . . . . . . . . . . . . . . 129Al presentar el VB 2008 tipo de clase. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129

Comprensión de Constructores de la Clase. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133El papel de la Palabra de mí. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137Entendiendo la palabra clave compartida. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142Definición de los pilares de la programación orientada a objetos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148Visual Basic 2008 modificadores de acceso. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151El primer pilar: Servicios VB 2008 de encapsulación. . . . . . . . . . . . . . . . . . . . . . . 154Comprensión de datos constante. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161Básicos de los campos de sólo lectura. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163Cómo entender las definiciones de tipo parcial. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164

La documentación de VB 2008 el código fuente a través de XML. . . . . . . . . . . . . . . . . . . . . . . . . . . . 165Visualización de los frutos de nuestro trabajo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171nCHAPTER 6 Entendimiento Herencia y polimorfismo. . . . . . . . . . . . . 173La mecánica básica de la herencia. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173La revisión de Visual Studio 2008 diagramas de clase. . . . . . . . . . . . . . . . . . . . . . . . . . . . 177El Segundo Pilar: Los detalles de la herencia. . . . . . . . . . . . . . . . . . . . . . . . . . . . 178Programación para la Contención / Delegación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184El tercer pilar: Apoyo polimórfica VB del 2008. . . . . . . . . . . . . . . . . . . . . . . . . 187Entender clase base / derivada reglas de conversión de la clase. . . . . . . . . . . . . . . . . . . 198La clase padre Maestro: System.Object. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206nCHAPTER 7 Entendimiento estructurado de excepciones. . . . . . . . . . . . . 207Oda a los errores, los errores y excepciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207El papel de. Control de excepciones NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208El ejemplo más simple posible. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210Configuración del estado de una excepción. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214Sistema de Nivel excepciones (System.SystemException). . . . . . . . . . . . . . . . . . . . . 218Las excepciones de nivel de aplicación (System.ApplicationException). . . . . . . . . . . . . . . 219Procesamiento de múltiples excepciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222El último bloque. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226¿Quién está tirando ¿Qué? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227El resultado de las excepciones no controladas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228Depuración de las excepciones no controladas utilizando Visual Studio 2008. . . . . . . . . . . . . . . 228Combinando VB6 Error de procesamiento y control de excepciones estructurado. . . . . . . . . . 230Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230nCHAPTER 8 Descripción de objetos de por vida. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233Clases, objetos y referencias. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233Los fundamentos de la vida de objetos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234El papel de las raíces de la aplicación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237Entender Generaciones de objetos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239El tipo de System.GC. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240Edificio finalizables objetos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243

Construcción de objetos desechables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246Edificio finalizables y desechables Tipos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251

PARTE 3 n n n avanzada de programación VBConstruyenCHAPTER 9 Trabajar con tipos de interfaz. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255Descripción de los tipos de interfaz. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255Definición de interfaces personalizadas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257La implementación de una interfaz. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259Interactuar con los tipos de interfaces de apoyo. . . . . . . . . . . . . . . . . . . . . . . . . . . . 262Resolución de conflictos de nombres con la palabra clave Implements. . . . . . . . . . . . . . . . . . . 268Edificio Enumerable tipos (IEnumerable e IEnumerator). . . . . . . . . . . . . . . 273Construcción de objetos comparables (IComparable). . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280Uso de interfaces como un mecanismo de devolución de llamada. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289nCHAPTER 10 colecciones, genéricos y tipos de datos que aceptan valores NULL. . . . . . . . . . . . 291Los tipos no genéricos de System.Collections. . . . . . . . . . . . . . . . . . . . . . . . . . . . 291Espacio de nombres System.Collections.Specialized. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 298Entender Boxing y Unboxing Operaciones. . . . . . . . . . . . . . . . . . . . . . . . . 298La seguridad de tipos y establecimiento inflexible de tipos de colecciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302El espacio de nombres System.Collections.Generic. . . . . . . . . . . . . . . . . . . . . . . . . . . . 307Descripción de los tipos de datos que aceptan valores NULL y la System.Nullable (Of T)Tipo genérico. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310Crear métodos genéricos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313Creación de Estructuras Genéricas (o clases). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316Creación de una colección genérica de encargo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317Creación de interfaces genéricas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323Creación de delegados genéricos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 326nCHAPTER 11 delegados, eventos y expresiones lambda. . . . . . . . . . . . . . . . . . . . . . . . . . . . 327Descripción de los tipos. Delegado NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327El ejemplo más simple posible Delegado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331La renovación de los coches tipo con los delegados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334Entendimiento (y uso) Eventos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339Definición de una "Prim-y correcta" de eventos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345Definición de eventos establecimiento inflexible de tipos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347Personalización del proceso de registro de eventos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348Visual expresiones lambda de base. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357

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

El espacio de nombres System.Configuration. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 480Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 481nCHAPTER 16 Tipo de reflexión, el enlace, y atributo en función-Programación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 483La necesidad de metadatos tipo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 483Comprender la reflexión. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 487

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

nCHAPTER 19. NET Interoperabilidad Asambleas. . . . . . . . . . . . . . . . . . . . . . . . . . . . 571El alcance de. NET Interoperabilidad. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 571Un ejemplo sencillo de. NET para interoperabilidad COM. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 572La investigación de la Asamblea. Interoperabilidad NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 575Comprender el contenedor que se puede llamar tiempo de ejecución. . . . . . . . . . . . . . . . . . . . . . . . . . . 578El papel de IDL COM. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 580El enlace a la coclase CoCalc. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 586La construcción de una más interesante VB6 servidor COM. . . . . . . . . . . . . . . . . . . . . . . . . . . . 587Examinando el ensamblado de interoperabilidad. . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . 590

Entender COM. NET Interoperabilidad. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 593El papel de la Convención. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 595El papel de la interfaz de clase. NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 596Creación de una. Tipos de redes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 597Generación de la biblioteca de tipos y registro de los tipos. NET. . . . . . . . . . . . . . . 600Examinar la información de tipo exportados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 601La construcción de un Visual Basic 6.0 cliente de prueba. . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . 602Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 603PARTE 5 n n n Introducción a la clase. NET BaseBibliotecasnCHAPTER 20 y manipulación de archivos de Directorio. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 607Explorando el espacio de nombres System.IO. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 607El Directorio (Info) y Archivo (Información) Tipos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 608Trabajar con el tipo de DirectoryInfo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 609Trabajar con el tipo de repertorio. . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . 613Trabajo con la clase DriveInfo tipo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 614Trabajo con la clase FileInfo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 615Trabajar con el tipo de archivo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 618La clase Stream Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 620Trabajar con StreamWriters y StreamReaders. . . . . . . . . . . . . . . . . . . . . . . . 623Trabajar con StringWriters y StringReaders. . . . . . . . . . . . . . . . . . . . . . . . . . 626Trabajar con BinaryWriters y BinaryReaders. . . . . . . . . . . . . . . . . . . . . . . . . . 627Programación "Ver" Archivos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 629Archivo asincrónico Realización de E / S. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 631Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 632nCHAPTER 21 Presentación de la serialización de objetos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 633Comprender la serialización de objetos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 633Configuración de los objetos de la serialización. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 636

Elegir un formateador de serialización. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 637Serialización de objetos de uso BinaryFormatter. . . . . . . . . . . . . . . . . . . . . . . . . . . 639Serialización de objetos con el SoapFormatter. . . . . . . . . . . . . . . . . . . . . . . . . . . . 640Serialización de objetos con el XmlSerializer. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 641La persistencia de las colecciones de objetos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 644Personalización del proceso de serialización. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 645Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 651nCHAPTER ADO.NET 22 Parte I: La Capa de Conexión. . . . . . . . . . . . . . . . . . . . . . . 653Una definición de alto nivel de ADO.NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 653Comprender los proveedores de datos ADO.NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 655Los espacios de nombres adicionales de ADO.NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 658Los tipos del espacio de nombres System.Data. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 658Proveedores de abstracción de datos mediante interfaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 663Creación de la base de datos AutoLot. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 665

El proveedor de datos de ADO.NET fábrica modelo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 671Entender la capa de Conexión ADO.NET. . . . . . . . . . . . . . . . . . . . . . . . . 677Trabajar con los lectores de datos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 682La construcción de una biblioteca de datos reutilizables de acceso. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 684Creación de una consola de Front End de interfaz de usuario basada en. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 692Acceso a datos asincrónico con SqlCommand. . . . . . . . . . . . . . . . . . . . . . . . . 697Introducción a las transacciones de bases de datos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 698Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 703nCHAPTER 23 ADO.NET Parte II: La capa de desconectado. . . . . . . . . . . . . . . . . . . 705Entender la capa desconectado de ADO.NET. . . . . . . . . . . . . . . . . . . . . . 705Comprender la función del conjunto de datos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 706Trabajar con DataColumn. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 709Trabajar con objetos DataRow. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 711Trabajar con tablas de datos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 715Enlazar objetos DataTable a las interfaces de usuario. . . . . . . . . . . . . . . . . . . . . . . . . . . . 720Llenado de DataSet / Objetos DataTable Con los adaptadores de datos. . . . . . . . . . . . . . . . . . . 730Revisión AutoLotDAL.dll. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 733Navegando Multitabled objetos DataSet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 736Las herramientas de acceso a datos de Visual Studio 2008. . . . . . . . . . . . . . . . . . . . . . . . . . . . 742La disociación autogenerados Código de la capa de interfaz de usuario. . . .. . . . . . . . . . . . . . . . . . 753Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 756nCHAPTER 24 Programación con el API de LINQ. . . . . . . . . . . . . . . . . . . . . . . . . . . . 759El papel de LINQ to ADO.NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 759De programación con LINQ to DataSet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 760

De programación con LINQ to SQL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 765Generación de clases de entidad Uso SqlMetal.exe. . . . . . . . . . . . . . . . . . . . . . . . . . . 770Construcción de clases de entidad utilizando Visual Studio 2008. . . . . . . . . . . . . . . . . . . . . . . . . 776De programación con LINQ to XML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 779El soporte integrado de XML de Visual Basic 2008. . . . . . . . . . . . . . . . . . . . . . . . 781Creación de elementos de programación XML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 783Creación de documentos XML mediante programación. . . . . . . . . . . . . . . . . . . . . . . . . . . . 785Generación de documentos de las consultas LINQ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 787Carga y análisis de contenido XML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 788Navegando un documento XML en memoria. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 789Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 794nCHAPTER 25 Introducción a Windows Communication Foundation. . . . . . . . . 795Un popurrí de la API de computación distribuida. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 795El papel del Fondo de Operaciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 801La investigación de las Asambleas de WCF Core. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 804El Proyecto Estudio de WCF Plantillas de Visual. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 805

La composición básica de una aplicación de WCF. . . . . . . . . . . . . . . . . . . . . . . . . . . . 807El ABC del Fondo de Operaciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 808La construcción de un servicio WCF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 813Que aloja el servicio WCF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 816Aumento de la aplicación de cliente de WCF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 824Utilizando el servicio WCF Biblioteca de plantillas de proyecto. . . . . . . . . . . . . . . . . . . . . . . . . 826Que aloja el servicio de WCF como un servicio de Windows. . . . . . . . . . . . . . . . . . . . . . . . . 829Invocación de un servicio de forma asincrónica. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 833Diseño de contratos de WCF de datos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 835Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 841nCHAPTER 26 Introducción a Windows Workflow Foundation. . . . . . . . . . . . . . . . 843Definir un proceso de negocio. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 843Los ladrillos de la WF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 844WF asambleas, espacios de nombres, y Proyectos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 850La construcción de un flujo de trabajo simple aplicación compatible. . . . . . . . . . . . . . . . . . . . . . . . . 852Examinando el motor de WF Hosting Código. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 856La invocación de servicios Web dentro de flujos de trabajo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 859La construcción de una Biblioteca WF código reutilizable. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 873Unas breves palabras respecto a actividades personalizadas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 878Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 879

PARTE 6 n n n de aplicaciones de escritorio conWindows FormsnCHAPTER 27 Introducción a Windows Forms. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 883Listado de el espacio de nombres System.Windows.Forms. . . . . . . . . . . . . . . . . . . . . 883Trabajar con los tipos de formularios Windows Forms. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 885El papel de la clase de aplicación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 887La anatomía de un formulario. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 890La funcionalidad de una clase de control. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 891La funcionalidad de la clase de formulario. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 896La construcción de aplicaciones para Windows con Visual Studio 2008. . . . . . . . . . . . . . . . . . . 900Trabajar con MenuStrips y ContextMenuStrips. . . . . . . . . . . . . . . . . . . . . . . . 905Trabajar con StatusStrips. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 913Trabajar con ToolStrips. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 919Construir una aplicación MDI. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 924Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 927nCHAPTER 28 de representación gráfica de datos con GDI +. . . . . . . . . . . . . . . . . . . . . . . . 929Una encuesta de la GDI + Espacios de nombres. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 929Una visión general del espacio de nombres System.Drawing. . . . . . . . . . . . . . . . . . . . . . . . 930El System.Drawing Tipos de utilidad. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 931

Entender la clase Graphics. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 933Entender sesiones de pintura. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 935La GDI + Sistemas de coordenadas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 939Definición de un valor de color. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 943La manipulación de las fuentes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 945Encuesta del espacio de nombres System.Drawing.Drawing2D. . . . . . . . . . . . . . . . . . . 953Trabajar con plumas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 953Trabajar con pinceles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 957Representación de imágenes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 963Arrastrar y Hit Prueba del control PictureBox. . . . . . . . . . . . . . . . . . . . . . . . . 965Entender el formato de Windows Forms de recursos. . . . . . . . . . . . . . . . . . . . . 973Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 981nCHAPTER 29 Programación con formularios Windows Forms. . . . . . . . . . . . . . . 983El mundo de los controles de Windows Forms. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 983Agregar controles a los formularios a mano. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 984Agregar controles a formularios mediante Visual Studio 2008. . . . . . . . . . . . . . . . . . . . . . 986Trabajar con los controles básicos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 987Configurar el orden de tabulación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1003

Marco botón del formulario de entrada por defecto. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1004Trabajo con controles más exóticos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1004Creación de formularios personalizados de controles de Windows. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1022Prueba del tipo CarControl. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1028La construcción de un host CarControl formulario personalizado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1029El papel del espacio de nombres System.ComponentModel. . . . . . . . . . . . . . . . . . . 1030Construcción de cuadros de diálogo Personalizar. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1034Dinámica de formularios Windows Forms Controles de posicionamiento. . . . . . . . . . . . . . . . . . . . . . . 1039Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1043PARTE 7 n n n de aplicaciones de escritorio con WPFnCHAPTER 30 Introducción a Windows Presentation Foundationy XAML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1047La motivación detrás de WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1047Las diferentes versiones de aplicaciones de WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1050La investigación de las Asambleas de WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1053La construcción de una aplicación de WPF (XAML gratuita). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1060Detalles adicionales del tipo de aplicación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1063Detalles adicionales del tipo de ventana. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1065La construcción de una aplicación de WPF (XAML centrada). . . . . . . . . . . . . . . . . . . . . . . . . . . . 1070La transformación de marcado en una Asamblea. NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . 1074Separación de preocupaciones Usando archivos de código subyacente. . . . . . . . . . . . . . . . . . . . . . .

1078La sintaxis de XAML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1080Creación de aplicaciones WPF con Visual Studio 2008. . . . . . . . . . . . . . . . . . . . . 1091Procesamiento de XAML en tiempo de ejecución: SimpleXamlPad.exe. . . . . . . . . . . . . . . . . . . . . . 1095El papel de Microsoft Expression Blend. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1099Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1101nCHAPTER 31 Programar con los controles de WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . 1103Una encuesta de la Biblioteca de controles de WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1103La declaración de los controles en XAML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1106Comprender la función de las propiedades de dependencia. . . . . . . . . . . . . . . . . . . . . . 1108Descripción de los eventos enrutados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1112Trabajar con tipos de botón. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1116Trabajar con casillas de verificación y RadioButton. . . . . . . . . . . . . . . . . . . . . . . . . . . 1120Trabajar con el control ListBox y tipos de ComboBox. . . . . . . . . . . . . . . . . . . . . . . . 1123Trabajar con las áreas de texto. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1129Diseño de Control de Contenido Utilización de los paneles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1131Edificio del marco de una ventana usando paneles anidados. . . . . . . . . . . . . . . . . . . . . . . 1141Entender los comandos de control de WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1147xvi nCONTENTS

Descripción del modelo de enlace de datos de WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . 1150Conversión de datos mediante IValueConverter. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1153Establecer enlaces con objetos personalizados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1156Vinculante Elementos de interfaz de usuario a los documentos XML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1161Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1165nCHAPTER 32 WPF representación gráfica 2D, Recursos,y temas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1167La filosofía de WPF Servicios de representación gráfica. . . . . . . . . . . . . . . . . . . . 1167Exploración de los tipos derivados de forma. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1175Trabajar con pinceles de WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1177Trabajar con plumas de WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1180Exploración de los tipos derivados de dibujo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1181El papel de las transformaciones de interfaz de usuario. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1185Descripción de los servicios de WPF Animación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1187Descripción de los recursos del sistema de WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1195Definición y Aplicación de estilos para los controles de WPF. . . . . . . . . . . . . . . . . . . . . . . . . . 1198La alteración de la interfaz de usuario de un control mediante plantillas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1207Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1211PARTE 8 n n n Construcción de Aplicaciones Web con

ASP.NETnCHAPTER construcción de 33 páginas Web ASP.NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1215El papel de las HTTP. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1215Básicos de las aplicaciones Web y servidores Web. . . . . . . . . . . . . . . . . . . . . . 1216El papel de HTML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1219El papel de las secuencias de comandos del lado del cliente. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1224Presentar el Formulario de datos (GET y POST). . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1226La construcción de una página ASP clásico. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1227Problemas con ASP clásico. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1229Los espacios de nombres de ASP.NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1230La página Web ASP.NET Modelo de código. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1231Detalles de una estructura del sitio Web de ASP.NET. . . . . . . . . . . . . . . . . . . . . . 1242El ciclo de compilación de ASP.NET página. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1243La cadena de herencia de tipo de página. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1246Interactuar con la solicitud HTTP entrante. . . . . . . . . . . . . . . . . . . . . . . . . . . 1247Interactuar con la respuesta de salida HTTP. . . . . . . . . . . . . . . . . . . . . . . . . . 1250El ciclo de vida de una página Web ASP.NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1252El papel del archivo web.config. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1256Resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1259

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

La filosofía de. NETCada pocos años o menos, el programador de hoy en día deben estar dispuestos a realizar una auto-infligidastrasplante 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), yAPI (incluyendo. NET Windows Forms y bibliotecas GDI +) que fueron desplazadas por las balas de platadesarrollo de software con el tiempo convertido en sombra de algo mejor o por lo menosalgo nuevo. A pesar de la frustración que puede sentir cuando se actualiza el conocimiento internobase, es francamente inevitable. Para ello, este libro examina los detalles del curso de Microsoftofreciendo dentro del paisaje de la ingeniería de software. NET platformand la última versión deel lenguaje de Visual Basic de programación.El punto de este capítulo es sentar las bases conceptuales para el resto del libro. Escomienza con una discusión de alto nivel de una serie de. NET temas relacionados, tales como asambleas, el comúnIntermediate Language (CIL), y justo a tiempo (JIT). Además de la vista previaalgunas de las características clave del lenguaje de programación Visual Basic 2008, también llegará a entenderla relación entre varios aspectos de. NET Framework, como el comúnLanguage 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. NETbibliotecas de clase base, a veces abreviado como el BCL o, alternativamente, como el FCL (siendo elMarco de las bibliotecas de clases). Por último, este capítulo se investiga el lenguaje-agnóstico y platformindependentla naturaleza de la plataforma. NET (sí, es verdad!. NET no se limita a la familia de Windowsde los sistemas operativos). Como era de esperar, la mayoría de estos temas se analizan en mucho másdetalle en el resto de este texto.Comprender el estado anterior de AsuntosAntes de examinar los detalles del universo. NET, es útil considerar algunas de las cuestiones quemotivado la génesis de la actual plataforma de Microsoft. Para entrar en la mente correcta-set, vamos a comenzar estecapítulo con una breve lección de historia y sin dolor para recordar nuestras raíces y entender las limitacionesde la situación anterior. Después de completar este rápido recorrido por la vida como la conocía, que a su veznuestra atención a los numerosos beneficios que proporciona Visual Basic 2008 y la plataforma. NET.La vida como un programador de la API C/Win32Tradicionalmente, el desarrollo de software para la familia de sistemas operativos Windows que

participanutilizando el lenguaje de programación C en relación con la programación de aplicaciones Windowsde interfaz (API) y el Windows Software Development Kit (SDK). Si bien es cierto que numerososaplicaciones se han creado con éxito utilizando este enfoque de larga tradición, pocos de nosotros estaría de acuerdoque 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 enfrentarsecon 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 objetosenfoque. Cuando se combinan los miles de funciones globales y tipos de datos definidos por ella API de Windows a una lengua ya formidable, no es de extrañar que no son tan numerosos buggyaplicaciones flotando en la actualidad.La vida como un C + + / MFC ProgramadorUna 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 queC + + 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 manualgestió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 FoundationClases (MFC) proporciona al programador un conjunto de clases C + + que simplifica la construcciónde las aplicaciones de Windows. La principal función de MFC es envolver un "subconjunto sana" de la materia prima de la API de Windowsdetrás de un número de clases y numerosas herramientas de generación de código (también conocido como magos). Independientemente de laayuda ayuda que ofrece el marco de trabajo MFC (así como muchos otros C + + basado en herramientas), elhecho del asunto es que C + + sigue siendo una experiencia difícil y propenso a errores, debido a suraíces históricas en C.La vida como una aplicación de Visual Basic 6.0 del programadorDebido 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ásde MFC, VB6 oculta la complejidad de la materia prima de la API de Windows de la vista utilizando una serie de servicios integradosasistentes 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) esque no es un lenguaje totalmente orientado a objetos, sino que es ". objeto de conocimiento" Por ejemplo, VB6 nopermiten 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 proporcionala capacidad de crear aplicaciones multiproceso a menos que esté dispuesto a bajar a bajo nivelLlamadas API de Windows (que es el mejor de los complejos y peligrosos en el peor).Vida Como un Programador Java/J2EEIntroduzca Java. Java es un lenguaje de programación orientado a objetos que tiene sus raíces sintácticos en C + +. Comomuchos 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) proporcionaprogramadores con un gran número predefinido de "paquetes" que contienen varios tiposdefiniciones. El uso de estos tipos, los programadores de Java pueden construir "100% puro de Java" aplicacionescompleta con la conectividad de base de datos, soporte de mensajería, web-enabled interfaces, y un escritorio ricosinterfaz de usuario (UI).Aunque Java es un lenguaje muy elegante, un problema potencial es que el uso de Java normalmentesignifica que usted debe usar Java front-to-back "durante el ciclo de desarrollo. En efecto, Java ofrece pocoesperanza de la integración del lenguaje, ya que esto va en contra del objetivo principal de Java (un único de programaciónidioma para todas las necesidades). En realidad, sin embargo, hay millones de líneas de código existente a cabohay en el mundo que lo ideal sería que se mezclan con los nuevos código Java. Lamentablemente, Java hace que estatarea 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 mejorenfoque 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 apoyopara una verdadera integración entre lenguajes.Vida Como programador COMEl 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 lareglas 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 + +. Delphilos 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 nuevoCOM 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ónidentificadores (AppID), talones, proxies, y el entorno de ejecución de COM, los programadores puedenevitar la necesidad de trabajar con sockets, manual de llamadas a procedimiento remoto, y otros de bajo niveldetalles. 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 MyComClassEstablecer myObj = Nueva MyComClass 'Localización resuelven utilizando AppID.myObj.DoSomeWorkA pesar de COM puede ser considerado como un modelo de objetos de gran éxito, es muy complejobajo el capó. Para ayudar a simplificar el desarrollo de los binarios COM, numerosos COM-conscientemarcos han venido a la existencia (sobre todo VB6). Sin embargo, el marco de apoyo solono es suficiente para ocultar la complejidad del COM. Incluso cuando se elige una manera relativamente simple COMawarelenguaje como Visual Basic 6, que todavía se ven obligados a lidiar con las entradas de registro y frágilesnumerosas cuestiones relacionadas con la implementación (en adelante denominado el infierno DLL).Vida Como un Programador de ADN de WindowsPara 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 ylos productos. Lamentablemente, la creación de una aplicación web mediante COM distribuido

basado en Windows Aplicaciones de InternetArquitectura (DNA) es también muy compleja.Parte de esta complejidad se debe al simple hecho de que Windows DNA requiere el uso de numerosastecnologías y lenguajes (ASP, HTML, XML, JavaScript, VBScript, COM (+), así como los datos de unacceso a la API como ADO). Un problema es que muchas de estas tecnologías no tienen ninguna relacióndesde el punto de vista sintáctico. Por ejemplo, JavaScript tiene una sintaxis muy similar a C, mientras que VBScript es unsubconjunto de Visual Basic 6. Los servidores COM que se crean para ejecutar en el marco del COM + en tiempo de ejecución tienen un completodiferentes apariencia de las páginas ASP que los invoca. El resultado es una muy confusa mezcolanzade las tecnologías.Además, y quizás más importante, cada lengua y / o tecnología tiene su propio tiposistema (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 consu 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 unaChar * en C.

La solución. NETHasta aquí la breve lección de historia. La conclusión es que la vida como programador de Windows ha sidomenos que perfecto. . NET Framework es un enfoque más radical y de fuerza bruta a la racionalizaciónel 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 Windowssistemas operativos, así como en numerosos sistemas operativos que no sean de Microsoft, tales como Mac OS X yvarios Unix / Linux. Para establecer el escenario, aquí es un rápido resumen de algunas de las características fundamentalescortesía de NET.:• interoperabilidad completa con código existente: Esto es (por supuesto) una buena cosa. ActiveXcomponentes 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 (incluyendoel 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 untipo 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 primasLlamadas 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), COMbibliotecas 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 binariaen el registro del sistema. Por otra parte,. NET permite que múltiples versiones de la misma *. dll paraconviven 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 quever con COM (más allá del hecho de que tanto los marcos de origen de Microsoft). De hecho, el únicomanera. 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. NETPlataforma (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,. NETpuede ser entendida como un entorno de ejecución y una nueva biblioteca de clases base amplia. El tiempo de ejecucióncapa se refiere correctamente como el Common Language Runtime o CLR. La función principal de laCLR es localizar, cargar y administrar. Tipos de redes en su nombre. El CLR también se ocupa de un númerode los detalles de bajo nivel como la gestión de la memoria, la carga de bibliotecas externas, y la seguridad de realizarcheques.Otro bloque de construcción de la red. Platformis el sistema de tipos común, o CTS. El CTSespecificació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 representanen 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óndefinido por el CTS. El Common Language Specification (CLS) es una especificación relacionados quedefine un subconjunto de tipos comunes y construcciones de programación que todos. NET lenguajes de programaciónpuede estar de acuerdo. Por lo tanto, si usted construye. Tipos NET que sólo exponen las características compatibles con CLS, quepuede estar seguro de todo eso. NET-consciente puede consumir. Por el contrario, si usted hace uso de untipo de datos o construcción de programación que está fuera de los límites de la ETI, no se puede garantizarque todos los idiomas de programación. NET puede interactuar con el. colección NET.El papel de las bibliotecas de clases baseAdemás del CLR y CTS y especificaciones CLS, la plataforma. NET proporciona una biblioteca de clases baseque está disponible para todos los lenguajes de programación. NET. No sólo la biblioteca de clases base de encapsularprimitivas diversos, tales como las discusiones, el archivo de entrada / salida (E / S), la representación gráfica, y la interaccióncon varios dispositivos de hardware externo, sino que también proporciona soporte para una serie de serviciosrequerido 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 XMLla manipulación, la seguridad programática, y la construcción de la web habilitada (así comotradicionales de escritorio y la consola basada en) frente a los extremos. Desde un alto nivel, se puede visualizar la relaciónentre 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ónLo que Visual Basic 2008 trae a la mesaDebido a que. NET es un cambio radical de anteriores tecnologías de Microsoft, debe quedar claroque 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 similarapariencia de VB6, introdujo un gran número de nuevas palabras clave y las construcciones quemuchos programadores (incluyéndome a mí) con el tiempo considerado VB. NET como un nuevo miembro de la BASEde 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 objetosque 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 (encontraste 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 permitetipos de anotar y sus miembros para calificar aún más su comportamiento (más detalles enCapítulo 16).Con el lanzamiento de. NET 2.0, la VB. NET lenguaje de programación se conoce como VisualBasic 2005 (VB 2005). Mientras VB 2005 es totalmente compatible con Visual Basic. NET, agregó numerosasnuevas 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 serinterpretada por las clases personalizadas o estructuras. Formalmente, esta característica se denominala sobrecarga de operadores.• La introducción del espacio de nombres My. Este espacio de nombres proporciona acceso instantáneo a machineandinformación específica del proyecto (que reduce en gran medida la cantidad de código que necesita paraautor 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 construircódigo muy eficiente y con seguridad de tipos que define numerosos "marcadores" que se especifican en el momentoque interactúan con el tema genérico.• La capacidad de personalizar el proceso de registrar, anular el registro o envío de eventos utilizando elPersonalizada 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 Basicidioma (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), quepuede 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 biende 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 NETtipos• Una sintaxis de inicialización de objetos nuevos, que le permite establecer valores de propiedad en el momento decreación de objetosTal vez el punto más importante para entender acerca de Visual Basic 2008 es que sólo puedeproducir código que puede ejecutar en el tiempo de ejecución. NET (por lo tanto, nunca podría usar VB 2008 paraconstruir 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 denominaconjunto (más detalles en las asambleas en tan sólo un poco). Por el contrario, el código que no puede ser alojado directamenteel tiempo de ejecución. NET que se denomina código no administrado.Adicional. NET-Aware lenguajes de programaciónEntender 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 MicrosoftConferencia 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 siguientesitio web (por favor, tenga en cuenta que esta dirección URL está sujeto a cambios):http://www.dotnetlanguages.net

Una vez que haya navegado a esta página, haga clic en el enlace situado en Recursos superior de la páginamenú del sistema. Aquí encontrará una lista de numerosas. lenguajes de programación NET y enlaces de interésdonde 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 deVB 2008, le animo a visitar este sitio, usted está seguro de encontrar. NET vale la pena investigaren su tiempo libre (LISP. NET, cualquier persona?).La vida en un mundo multilingüeComo desarrolladores primero en llegar a comprender la naturaleza independiente del idioma de. NET, numerosas preguntassurgir. El más frecuente de estas preguntas tendría que ser: "Si todos. NET compilar abajocon "el código administrado," ¿por qué necesitamos más de un compilador? "Hay un número de maneras deresponder a esta pregunta. En primer lugar, los programadores son mucho muy particular cuando se trata de nuestra eleccióndel lenguaje de programación (me incluyo). Algunos prefieren idiomas llena de puntos y comas y rizadocorchetes, con la mayor número posible de palabras clave (como C #, C + + y J #). Otros disfrutan de un lenguaje queofrece más "legible" la sintaxis (como Visual Basic 2008). Y otros lo desea, puede aprovecharsus 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 derivade la familia de los lenguajes C, se puede decir que realmente todos los programadores estaría feliz con esteelección? O, si la única "oficial". NET se basa en la sintaxis de Fortran, imagina toda la gentepor ahí que pasaría por alto. NET por completo. Debido a que el tiempo de ejecución. NET no podría importarme menos queel 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 unificadosolución es el simple hecho de que todos los lenguajes de programación tienen su propio conjunto de fortalezasy debilidades. Por ejemplo, algunos lenguajes de programación ofrecen un excelente soporte intrínseco paratratamiento matemático avanzado. Otros ofrecen un rendimiento superior para cálculos financieros, lógicacálculos, la interacción con los ordenadores centrales, y así sucesivamente. Cuando usted toma los

puntos fuertes de unlenguaje 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ónsoftware 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 deel mundo. Si el idioma de su elección pasa a ser Visual Basic 2008, pero se colocan en un clientesitio 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 ymolesta. No digo más.Una visión general de. NETA pesar de que. Binarios NET tomar la misma extensión de archivo como servidores COM y no administradoLos binarios de Windows (*. dll o *. exe), no tienen absolutamente ninguna similitud interna. Por ejemplo,. NETasambleas 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, peroen lugar de lenguaje intermedio independiente de la plataforma (IL), así como tipo de metadatos. Figura 1-3 muestra elpanorama 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 funcionarioplazo para la IL fue el lenguaje intermedio de Microsoft (MSIL). Sin embargo, con la versión final de. NET 1.0, el término secambió 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 abreviaturaCIL lo largo de este texto.Cuando un *. dll o *. exe ha sido creado con un compilador. NET-aware, el módulo resultante esincluido 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 entenderalgunas 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 Javaen 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 detallelas características de cada "tipo" que viven en el binario. Por ejemplo, si usted tiene una clase denominadaSportscar, el tipo de metadatos describe detalles como clase base Sportscar, que las interfaces sonimplementado por Sportscar (si procede), así como una descripción completa de cada miembro con el apoyo de latipo 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 unaversión binaria de la interfaz de lenguaje de definición de código [IDL]). Los problemas con la información de tipo COMes que no se garantiza la presencia y el hecho de que el código IDL no tiene forma de documentolos servidores de referencia externa que se requieren para el correcto funcionamiento de la actual OCMservidor. Por el contrario,. Metadatos NET está siempre presente y es generado automáticamente por un hecho. NetAwarecompilador.Por último, además de CIL y tipo de metadatos, conjuntos de ellos también se describen conmetadatos, que es oficialmente llamado un manifiesto. El manifiesto contiene información acerca de la actualversió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 manifiestaninformación sobre el curso de los próximos capítulos.

Un solo archivo y las Asambleas de varios archivosEn un gran número de casos, no es simple-a-uno entre un. NETy el archivo binario (*. dll o *. exe). Por lo tanto, si usted está construyendo una red. *. Dll, que es seguro tener en cuenta queel binario y la asamblea son una misma cosa. Del mismo modo, si usted está construyendo un escritorio ejecutableaplicació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 deque se denomina un módulo. Cuando se construye un ensamblado de múltiples archivos, uno de estos módulos (denominadomódulo de primaria) debe contener el manifiesto del ensamblado (y posiblemente las instrucciones del CIL y los metadatospara 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 secundariaen el manifiesto del ensamblado.Así que, ¿por qué optar por crear un ensamblado de múltiples? Al particionar el conjunto enmódulos discretos, usted termina con una opción de implementación más flexibles. Por ejemplo, si un usuario se hace referenciaun montaje remoto que necesita ser descargado en su máquina, el tiempo de ejecuciónsólo descargar los módulos necesarios. Por lo tanto, usted es libre de construir su conjunto de talmanera que los tipos con menos frecuencia requerida (por ejemplo, un tipo con nombre HardDriveReformatter) se mantienen en unseparados módulo independiente.Por el contrario, si todos los tipos se colocaron en un ensamblado de un solo archivo, el usuario final puede terminarla 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 queestán destinados a ser inicialmente desplegadas y versionados como una sola unidad.El papel de la Lengua Común IntermedioAhora que usted tiene una mejor idea. NET, vamos a examinar el papel del intermedio comúnidioma (CIL) en un poco más de detalle. CIL es un lenguaje que se sitúa por encima de cualquier particular, platformspecificconjunto de instrucciones. Sin importar qué. NET consciente de que usted elija, los asociadoscompilador emite instrucciones de la CIL. Por ejemplo, el siguiente de Visual Basic 2008 modelos de código trivialcalculadora. No se preocupe por la sintaxis exacta, por ahora, pero se dan cuenta el formato de laAgregar () en la clase Calc:

' Calc.vbImports SystemNamespace CalculatorExample' Defines the program's entry point.Module ProgramSub Main()Dim ans As IntegerDim c As New Calc()ans = c.Add(10, 84)Console.WriteLine("10 + 84 is {0}.", ans)Console.ReadLine()End SubEnd Module' The VB 2008 calculator.Class CalcPublic Function Add(ByVal x As Integer, ByVal y As Integer) As Integer

Return x + yEnd FunctionEnd ClassEnd Namespace

Una vez que el compilador de VB 2008 (vbc.exe) compila este archivo de código fuente, se termina con una sola filaensamblado ejecutable que contiene un manifiesto, las instrucciones de la CIL, y los metadatos que describen cadaaspecto 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 Ildasm.exe (examinado un poco más adelante en estecapí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: nopIL_0001: ldarg.1IL_0002: ldarg.2IL_0003: add.ovfIL_0004: stloc.0IL_0005: br.s IL_0007IL_0007: ldloc.0IL_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 CILidioma. Basta con entender que el Visual Basic 2008 compilador traduce el códigoestados 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 estemisma aplicación usando C #, en lugar de VB 2008 (de nuevo, no sudan la sintaxis, pero tenga en cuenta las similitudesen las bases de código):

// Calc.csusing System;namespace CalculatorExample{// Defines the program's entry point.public class Program{static void Main(){Calc c = new Calc();int ans = c.Add(10, 84);Console.WriteLine("10 + 84 is {0}.", ans);Console.ReadLine();}}CHAPTER 1 n 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 porel 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.1IL_0001: ldarg.2IL_0002: addIL_0003: stloc.0IL_0004: br.s IL_0006IL_0006: ldloc.0IL_0007: ret} // end of method Calc::Add

archivos nSource El Código Calc.vb y Calc.cs código se incluyen en el Capítulo 1 subdirectorio.Beneficios del CILEn este punto, puede que se pregunte exactamente lo que se gana por el código fuente de la compilación en CILen lugar de directamente a un conjunto de instrucciones específicas. Una de las ventajas es la integración del lenguaje. Como usted haya hemos visto, cada compilador. NET-consciente produce instrucciones CIL casi idénticos. Por lo tanto, todos losidiomas se resuelven en un campo binario bien definido que hace uso del mismo tipo mismadel 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ódigola base se ejecuta en sistemas operativos múltiples). De hecho,. distribuciones NET ya existen para

muchosno los sistemas operativos Windows (más detalles en la conclusión de este capítulo). En contraste con laPlataforma J2EE, sin embargo,. NET permite crear aplicaciones que utilizan el idioma de su elección.CIL Compilación de las Instrucciones sobre plataformas específicasDebido 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 sentidoInstrucciones de la CPU que se denomina un "justo a tiempo (JIT), que a veces va por el ambientenombre de la inquietud. . NET aprovecha entorno de ejecución de un compilador JIT para cada CPU orientación de latiempo 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 ejecutardentro 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 parafuncionar en un entorno de alta memoria. De esta forma, los desarrolladores pueden escribir un solo cuerpo de códigoque 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 unllamada se realiza a un método denominado PrintDocument (), las instrucciones del CIL se compilan en platformspecificinstrucciones que aparecen en la primera invocación y retenido en la memoria para su uso posterior. Por lo tanto, ella próxima vez PrintDocument () se llama, no es necesario volver a compilar el CIL.El papel de. Metadatos Tipo NETAdemá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 elbinarios, 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ónentidades-tanto es así, de hecho, que. NET binarios no necesitan ser registrados en el sistemaRegistro.

Para ilustrar el formato de. metadatos NET, echemos un vistazo a los metadatos que se hagenerado para el método Add () de la clase VB Calc analizadas (los metadatos generadosde la versión de C # del método Add () es similar):

TypeDef #2 (02000003)-------------------------------------------------------TypDefName: CalculatorExample.Calc (02000003)Flags : [Public] [AutoLayout] [Class][AnsiClass] [BeforeFieldInit] (00100001)Extends : 01000001 [TypeRef] System.ObjectMethod #1 (06000003)-------------------------------------------------------MethodName: Add (06000003)Flags : [Public] [HideBySig] [ReuseSlot] (00000086)RVA : 0x00002090ImplFlags : [IL] [Managed] (00000000)CallCnvntn: [DEFAULT]hasThisReturnType: I42 ArgumentsArgument #1: I4Argument #2: I42 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émicodetalle) consumida por los numerosos aspectos del entorno de ejecución. NET, así como por diversosherramientas de desarrollo. Por ejemplo, la característica IntelliSense que proporciona Visual Studio 2008, seposible mediante la lectura de los metadatos de un ensamblado en tiempo de diseño. Los metadatos también es utilizado por varios objectbrowsingutilidades, herramientas de depuración, y el Visual Basic 2008 se compilador. Para estar seguros, los metadatos sela 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 objetoserialización proceso. Capítulo 16 formalizará el papel de. NET metadatos.

El papel de los ensamblados de manifiestosPor último pero no menos importante, recuerde que un montaje. NET también contiene metadatos que describen elmontaje en sí (técnicamente se denomina un manifiesto). Entre otros detalles, los documentos de manifiesto todos losensamblados externos requeridos por la Asamblea actual para que funcione correctamente, la versión de la asambleanúmero, la información de copyright, etc. Al igual que tipo de metadatos, es siempre el trabajo del compiladorpara generar el manifiesto del ensamblado. Éstos son algunos de los detalles relevantes del manifiesto generadoal compilar el archivo de código Calc.vb visto anteriormente en este capítulo (suponemos que indica

el compiladora nombre de nuestra asamblea Calc.exe):

.assembly extern mscorlib{.publickeytoken = (B7 7A 5C 56 19 34 E0 89 ).ver 2:0:0:0}....assembly Calc{....ver 0:0:0:0}.module Calc.exe.imagebase 0x00400000.subsystem 0x00000003.file alignment 512.corflags 0x00000001

En pocas palabras, este documento manifiesta la lista de ensamblados externos requeridos por Calc.exe (a través dela asamblea. directivas externa), así como diversas características de la propia Asamblea (versiónnúmero, nombre del módulo, etc.) Capítulo 15 examinará la utilidad de los datos del manifiesto en la mayor partemás detalles.Comprender el sistema de tipos comúnUn montaje de la propuesta puede contener cualquier número de distintos "tipos". En el mundo de. NET, "tipo " es simplementeun 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 concada uno de estos tipos. Por ejemplo, el ensamblado puede definir una sola clase que implementa algunosnúmero de interfaces. Tal vez uno de los métodos de interfaz tiene una enumeración como una entradapará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 tiposdeben ser definidos con el fin de ser acogida por el CLR. Normalmente, los únicos individuos que están profundamenterelacionados con el funcionamiento interno de la CTS son las herramientas para la construcción y / o compiladores que se dirigen ael. NET. Es importante, sin embargo, para todos. NET a aprender acerca de cómo trabajarcon los cinco tipos definidos por el CTS en el idioma de su elección. He aquí una breve descripción.CTS tipos de claseTodos los idiomas. NET-consciente apoya, por lo menos, la noción de un tipo de clase, que es la piedra angularde 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 conocidocomo variables miembro). En Visual Basic 2008, las clases se declaran mediante la palabra clave de clase:

' A class type.Public Class CalcPublic Function Add(ByVal x As Integer, ByVal y As Integer) As IntegerReturn x + yEnd FunctionEnd Class

Si usted tiene experiencia en el desarrollo de clases VB6, tenga en cuenta que los tipos de clase ya no sondefinido dentro de un archivo *. cls, dado el hecho de que ahora tenemos una palabra clave específica para la definición de clasetipos (recordemos que todo el código VB se encuentra ahora dentro de los archivos *. vb). Los capítulos 5 y 6 se examinará ladetalles de la construcción de tipos de clases con Visual Basic 2008.CTS tipos de interfazUna 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únde base, tales como la interfaz IUnknown. En VB 2008, los tipos de interfaz se definen mediante la interfazpalabra clave, por ejemplo:

' Classes or structures that implement this interface' know how to render themselves.Public Interface IDrawSub Draw()End Interface

Por su cuenta, las interfaces son de poca utilidad. Sin embargo, cuando una clase o estructura implementa una propuestainterfaz en su forma única, usted puede solicitar el acceso a la funcionalidad proporcionada mediante unreferencia de la interfaz de "manera polimorfa". interfaz de programación basada Se explora laen el capítulo 9.CTS tipos de estructuraEl concepto de una estructura también se formalizó en el marco del CTS. En pocas palabras, una estructura puede serpensado como una alternativa ligera a los tipos de clase, que tienen una semántica basada en valores (véaseCapí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 PointPublic xPos As IntegerPublic yPos As IntegerPublic Sub New(ByVal x As Integer, ByVal y As Integer)xPos = xyPos = yEnd SubPublic Sub Display()Console.WriteLine("({0}, {1}", xPos, yPos)End SubEnd Structure

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

' An enumeration type.Public Enum CharacterTypeWizard = 100Fighter = 200Thief = 300End Enum

Las demandas de CTS que los tipos enumerados derivan de una clase base común, System.Enum. Comoverá en el capítulo 4, esta clase base define un número de miembros interesantes que le permitenextraer, manipular y transformar el nombre de base / valor mediante programación.CTS tipos de delegadoLos delegados son quizás los más complejos de tipo NET;. Sin embargo, son muy importantes, ya que sonpara formthe fundación de la arquitectura de eventos. NET. Para estar seguro, en cualquier momento que desee para manejarel clic de un botón, la actividad del ratón interceptar, o proceso de devoluciones de datos en un servidor web, los delegadosser utilizado en el fondo. En pocas palabras, un delegado se utiliza para almacenar las direcciones de método que se puedeinvocada 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 asociadosdetalles 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 potentesoluciones.CTS miembros de tipoAhora que ha visto previamente cada uno de los tipos formalizado por la CTS, se dan cuenta que la mayoría de tipospuede 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órficoscomportamiento 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 varioscapí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 datosEl aspecto final de la CTS a tener en cuenta por el momento es que establece un conjunto bien definidode tipos de datos fundamentales. A pesar de una lengua dada normalmente tiene una palabra clave única paradeclarar una CTS intrínseca tipo de datos, todas las palabras clave del lenguaje en última instancia resolver al mismo tipodefinido en un ensamblado denominado mscorlib.dll. Considere la tabla 1-1, que documenta cómo las principales CTStipos de datos se expresan en diversos. NET.

Table 1-1. The Intrinsic CTS Data TypesCTS Data Type VB 2008 Keyword C# Keyword C++/CLI KeywordSystem.Byte Byte byte unsigned charSystem.SByte SByte sbyte signed charSystem.Int16 Short short shortSystem.Int32 Integer int int or longSystem.Int64 Long long __int64System.UInt16 UShort ushort unsigned shortSystem.UInt32 UInteger uint unsigned int or unsigned longSystem.UInt64 ULong ulong unsigned __int64System.Single Single float floatSystem.Double Double double doubleSystem.Object Object object Object^

System.Char Char char wchar_tSystem.String String string String^System.Decimal Decimal decimal DecimalSystem.Boolean 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únEspecificaciónComo 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 doslenguas distintas expresa el mismo lenguaje de programación (por ejemplo, un método sin valor de retorno), eles 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 deel tiempo de ejecución. NET, ya que los compiladores respectiva (vbc.exe o csc.exe, en este caso) emiten una similarconjunto de instrucciones de la CIL. Sin embargo, el lenguaje también puede variar con respecto a su nivel general defuncionalidad. Por ejemplo, un lenguaje. NET puede o no tener una palabra clave para representar sin firmardatos, y puede o no puede apoyar los tipos de puntero. Teniendo en cuenta estas posibles variaciones, lo ideal seríatener 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 laconjunto mínimo y completa de las características de un hecho. NET-consciente debe apoyar para producir códigoque puede ser organizado por el CLR, mientras que al mismo tiempo tener acceso en un uniformmanner por todos los idiomasque 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 suproductos 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 losque (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ónasamblea.Teniendo en cuenta esta regla, se puede (correctamente) inferir que los artículos restantes de la ETI no se aplican a lalógica utilizada para construir el funcionamiento interno de un tipo. NET. Los únicos aspectos de un tipo que debe cumplirel CLS son las definiciones miembros ellos mismos (es decir, convenciones de nombres, parámetros ytipos 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 volverlos 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 ULongReturn x + yEnd FunctionEnd Class

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

Public Class CalcPublic 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 + yEnd FunctionEnd Class

usted tendría que aún se ajustaban a las normas de la ETI, y puede estar seguro de que todos los. NETson 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 CLSdescribe cómo una lengua determinada internamente debe representar cadenas de texto, ¿cómo

debe ser enumeracionesrepresentan 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 paraherramienta / constructores compilador.Velar por el cumplimiento CLSComo se verá a lo largo de este libro, VB 2008 se define una programación de algunas construcciones queno son compatibles con CLS. La buena noticia, sin embargo, es que puede indicar al compilador para VB 2008verifique el código de compatibilidad con CLS mediante un único atributo. NET:"Dile que el compilador para comprobar la compatibilidad con CLS.<Assembly: System.CLSCompliant(True)>El capítulo 16 se sumerge en los detalles de la programación basada en atributos. Hasta entonces, sólo tiene que entenderque el atributo <CLSCompliant()> dará instrucciones al compilador de VB 2008 para revisar todas ycada línea de código en contra de las reglas del CLS. Si cualquier violaciónes CLS se descubren, recibirá uncompilador de error y una descripción del código de ofender.Comprender el Common Language RuntimeAdemás de las especificaciones de CTS y CLS, el próximo TLA (abreviatura de tres letras) que sostienencon en este momento es el CLR. Programación hablando, el tiempo de ejecución término puede ser entendidocomo un conjunto de servicios externos que se requieren para ejecutar una determinada unidad de código compilado. Porejemplo, cuando los desarrolladores hacer uso de la Microsoft Foundation Classes (MFC) para crear una nuevaaplicación, que son conscientes de que su programa requiere la biblioteca MFC en tiempo de ejecución (por ejemplo, mfc42.dll).Otros lenguajes populares también tienen un tiempo de ejecución correspondiente. programadores VB6 también atado a untiempo de ejecución del módulo o dos (por ejemplo, msvbvm60.dll). 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. NETtiempo 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 proporcionaun 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 mscoree.dll colección con nombre

(también conocido como el ComúnObjeto motor de tiempo de ejecución de ejecución). Cuando se hace referencia a una asamblea para el uso, es mscoree.dllcargado automáticamente, lo que a su vez carga el ensamblado necesario en la memoria. El motor de tiempo de ejecuciónes responsable de una serie de tareas. En primer lugar, es la entidad encargada de resolver elubicación de una asamblea y la constatación del tipo solicitado en el binario al leer el contenidometadatos. El CLR a continuación, establece el tipo en la memoria, compila el CIL asociados en platformspecificinstrucciones, realiza todas las comprobaciones de seguridad necesarias, y luego ejecuta el código enque se trate.Además de cargar los ensamblados personalizados y la creación de tipos personalizados, el CLRtambién interactúan con los tipos contenidos en las bibliotecas. NET clase base cuando sea necesario. Aunquela biblioteca de base de toda la clase se ha dividido en una serie de asambleas discreto, el conjunto de claveses mscorlib.dll. mscorlib.dll 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 seconstruir. 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á haciendouso de tipos de base de biblioteca de clases), un hecho. NET, y el motor de ejecución de. NET.Figura 1-4. mscoree.dll en acciónLa Asamblea / Espacio de nombres / Distinción TipoCada 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 labibliotecas 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 System.IO contiene el archivo I / O-tipos relacionados, el espacio de nombres System.Data define el centro detipos de base de datos de acceso, el espacio de nombres System.Windows.Forms define elementos de la GUI, y así sucesivamente. Esmuy importante señalar que un solo conjunto (como mscorlib.dll) 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 (ustedaprender más acerca de esta herramienta en el capítulo 2). Esta herramienta le permite examinar los ensamblados de referenciapor la solución actual, los espacios de nombres dentro de un conjunto particular, los tipos dentro de un determinadoespacio de nombres, y los miembros de un tipo específico. Tenga en cuenta que mscorlib.dll contiene diversasespacios 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 Javaes 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 2008Imports SystemPublic Module MyAppSub Main()Console.WriteLine("Hi from VB 2008")End SubEnd Module// Hello world in C#using System;public class MyApp{static void Main(){CHAPTER 1 n THE PHILOSOPHY OF .NET 23

Console.WriteLine("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 nombresnombre del sistema. Más allá de las variaciones sintácticas menores, estas tres aplicaciones de apariencia muymuy parecidos, tanto física como lógica.Claramente, su objetivo principal como desarrollador de. NET es llegar a conocer la riqueza de tipos

definidos enlos (numerosos). NET espacios de nombres. El espacio de nombres más fundamentales para conseguir sus manos en torno a esnombre del sistema. Este espacio de nombres proporciona un cuerpo de la base de los tipos que tendrá que aprovechar el tiempoy otra vez como un desarrollador de. NET. De hecho, no se puede construir cualquier tipo de funcional. NETsin 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 LifeSystem Within System you find numerous useful types dealing withintrinsic data, mathematical computations, randomnumber generation, environment variables, and garbagecollection, as well as a number of commonly usedexceptions and attributes.System.Collections These namespaces define a number of stock containerSystem.Collections.Generic types, as well as base types and interfaces that allow you tobuild customized collections.System.Data These namespaces are used for interacting with relationalSystem.Data.Odbc databases using ADO.NET.System.Data.OracleClientSystem.Data.OleDbSystem.Data.SqlClientSystem.IO These namespaces define numerous types used to workSystem.IO.Compression with file I/O, compression of data, and port manipulation.System.IO.PortsSystem.Reflection These namespaces define types that support runtimeSystem.Reflection.Emit type discovery as well as dynamic creation of types.System.Runtime.InteropServices This namespace provides facilities to allow .NET types tointeract with “unmanaged code” (e.g., C-based DLLs andCOM servers) and vice versa.System.Drawing These namespaces define types used to build desktopSystem.Windows.Forms applications using .NET’s original UI toolkit (WindowsForms).24 CHAPTER 1 n THE PHILOSOPHY OF .NET

.NET Namespace Meaning in LifeSystem.Windows The System.Windows namespace is the root for several newSystem.Windows.Controls namespaces (introduced with .NET 3.0) that represent theSystem.Windows.Shapes Windows Presentation Foundation UI toolkit.System.Linq These namespaces define types used when programmingSystem.Xml.Linq against the LINQ API.System.Data.LinqSystem.Web This is one of many namespaces that allow you to buildASP.NET web applications and XML web services.System.ServiceModel This is one of many namespaces used to build distributedapplications using the (.NET 3.0–centric) WindowsCommunication Foundation API.System.Workflow.Runtime These are two of many namespaces that define types usedSystem.Workflow.Activities to build “workflow-enabled” applications using the .NET 3.0Windows Workflow Foundation API.System.Threading This namespace defines numerous types to buildmultithreaded applications.System.Security Security is an integrated aspect of the .NET universe. In thesecurity-centric namespaces, you find numerous typesdealing with permissions, cryptography, and so on.System.Xml 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 detallescon 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ónVale la pena reiterar que el espacio de nombres no es más que una manera conveniente para nosotros los simples humanospara comprender y organizar lógicamente los tipos relacionados. Consideremos de nuevo el espacio de nombres System. Desdesu perspectiva, se puede asumir que System.Console representa una clase denominada consola que secontenida dentro de un espacio de nombres denominado System. Sin embargo, a los ojos del tiempo de ejecución. NET, esto no esasí. El motor de tiempo de ejecución sólo se ve una sola entidad llamada System.Console.En Visual Basic 2008, la palabra clave importaciones simplifica el proceso de los tipos de referencia se define en elun espacio de nombres en particular. Así es como funciona. Digamos que usted está interesado en la construcción de una tradicionalaplicación de escritorio. La ventana principal hace un gráfico de barras basado en alguna información obtenidaa 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 nombresse contiene el estudio y experimentación, he aquí algunos posibles candidatos a la referencia ensu programa:

' Here are all the namespaces used to build this application.Imports System ' General base class library types.Imports System.Drawing ' Graphical rendering types.Imports System.Windows.Forms ' GUI widget types.Imports System.Data ' General data-centric types.Imports System.Data.SqlClient ' MS SQL Server data access types

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

' Explicitly list the namespaces used by this file.Imports SystemImports System.DrawingPublic Class ProgramPublic Sub DisplayLogo()' Create a 20 x 20 pixel bitmap.Dim companyLogo As New Bitmap(20, 20)...End SubEnd Class

Debido a que su aplicación es la importación de System.Drawing, el compilador es capaz de resolver elMapa de bits de clase como miembro de este espacio de nombres. Si no ha especificado el espacio de nombres System.Drawing,que se publicará un error del compilador. Sin embargo, usted es libre de declarar variables con un completonombre, así:

' Not listing System.Drawing namespace!Imports SystemPublic Class ProgramPublic Sub DisplayLogo()' Create a 20 x 20 pixel bitmap.Dim companyLogo As New System.Drawing.Bitmap(20, 20)...End SubEnd Class

Si bien la definición de un tipo utilizando el nombre completo proporciona una mayor facilidad de lectura, creo que habíade 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 plenanombres completos (a menos que exista una ambigüedad definida por resolver) y optar por el procedimiento simplificadoenfoque de la palabra clave Imports.Sin embargo, recuerde siempre que esta técnica es simplemente una notación abreviada para especificar untipo es totalmente nombre completo, y teniendo en cuenta los resultados de cada enfoque en el exacto mismo CIL subyacente (elhecho de que el código CIL siempre hace uso de los nombres completos) y no tiene ningún efecto sobre el rendimiento oel tamaño del ensamblado generado.Hacer referencia a ensamblados externosAdemá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 laVB 2008 compilador el nombre del ensamblado que contiene la definición real de la CIL referenciatipo. Como se ha mencionado, de múltiples núcleos. NET vivir dentro de espacios de nombres mscorlib.dll. Sin embargo, el Sistema.Tipo Drawing.Bitmap está contenida en un ensamblado independiente nombrado System.Drawing.dll. Un granmayoría de las asambleas. NET Framework se encuentra en un directorio específico denominado el mundialmemoria caché de ensamblados (GAC). En una máquina Windows, esto puede ser localizado en C: \ Windows \ assembly, comomuestra 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 letienen varias maneras de informar al compilador que las asambleas que desea incluir en la compilaciónciclo. Usted estudiar la manera de hacerlo en el siguiente capítulo, así que voy a mantener a raya a los detalles por ahora.Usando Ildasm.exeSi usted está comenzando a sentirse un poco abrumado ante la idea de obtener el dominio sobre cada espacio de nombresen la plataforma. NET, sólo recuerda que lo que hace un único espacio de nombres es que contienetipos que de alguna manera están relacionados semánticamente. Por lo tanto, si usted no tiene necesidad de una interfaz de usuariomás allá de una simple aplicación de consola, puede olvidarse de todo sobre el System.Windows y System.Webespacios de nombres (entre otros). Si está creando una aplicación de pintura, los espacios de nombres de base de datostienen 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 (Ildasm.exe) le permite cargar cualquier. NETmontaje e investigar su contenido, incluyendo el manifiesto de asociados, el código CIL, y tipo de metadatos.De forma predeterminada, Ildasm.exe se debe instalar en C: \ Archivos de programa \ Microsoft SDKs \ Windows \V6.0A \ bin (si usted no puede encontrar Ildasm.exe en esta ubicación, sólo tiene que buscar en su máquina para una aplicaciónllamado "Ildasm.exe").nNota Si ha instalado Visual Studio 2008, también puede cargar Ildasm.exe al abrir una aplicación de Visual Studio 2008Sí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 unconjunto que desea explorar. A modo de ejemplo, la Figura 1.7 muestra el conjunto integrado Calc.execompilando el archivo de código Calc.vb visto anteriormente en este capítulo. Como puede ver, Ildasm.exe presentala estructura de un conjunto con un formato familiar de vista de árbol.

Figura 1-7. Ildasm.exe le permite ver la composición interna de cualquier conjunto. NET.Viendo el código CILAdemás de mostrar los espacios de nombres, tipos, y los miembros que figuran en una asamblea dado,

Ildasm.exe también le permite ver las instrucciones del CIL de un miembro determinado. Por ejemplo, sifueron a doble clic en el método Main () del tipo de programa, una ventana independiente que muestra lasubyacentes del CIL (ver Figura 1-8).Figura 1-8.Viewing el CIL subyacentes a través de Ildasm.exeVer los metadatos de tipoSi desea ver los metadatos de tipos para el ensamblado cargado, pulse Ctrl + M. Figura 1-9muestra los metadatos de la Calc.Add () método

Figura de tipo 1-9.Viewing metadatos a través de Ildasm.exeVer 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 enel icono MANIFIESTO en la ventana Ildasm.exe principal (ver Figura 1-10).Figura 1-10.Viewing datos del manifiesto a través de Ildasm.exePara estar seguro, Ildasm.exe tiene más opciones que se muestra aquí, y voy a ilustrar las características adicionalesde la herramienta en su caso en el texto. Al leer este libro, recomendamosabrir los ensamblados con Ildasm.exe para ver cómo su código de Visual Basic 2008 se representa en términosde código CIL independiente de la plataforma. Aunque no es necesario convertirse en un experto en el código CIL a ser undominio del VB 2008 programador, la comprensión de algunos conceptos básicos de la CIL sólo fortalecerá su programaciónmuscular.CAPÍTULO 1 n LA FILOSOFÍA DE. NET 29

Uso de Lutz Roeder reflectorSi bien la utilización Ildasm.exe 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 unaaplicación ensamblado utilizando su lenguaje de gestión de elección. Afortunadamente, muchos años. NETde los navegadores están disponibles para su descarga, incluyendo el reflector.exe muy popular. Esta herramienta gratuita se puededescargar de http://www.aisto.com/roeder/dotnet. 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 Calc.exe una vez más.Figura 1-11. Reflector es una herramienta de exploración de objetos muy popular.Tenga en cuenta que reflector.exe 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. Noser conscientes de que a lo largo del resto del libro, voy a hacer uso de ambos Ildasm.exe asícomo reflector.exe para ilustrar diversos conceptos.Implementar el tiempo de ejecución. NETNo 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 unproblema, como el equipo de desarrollo debe estar correctamente configurado en el momento de instalar la libredisponible. NET Framework 3.5 SDK (así como comerciales. entornos de desarrollo NET, tales comoVisual Studio 2008).Sin embargo, si implementa un ensamblado a un equipo que no tiene. NET instalado, se producirá un errorpara ejecutar. Por esta razón, Microsoft proporciona un paquete de instalación dotNetFx35setup.exe con nombre que puede ser

libremente enviado e instalado junto con su. NET de software. Este programa de instalación se puede descargarde Microsoft de su. NET área de descarga (http://msdn.microsoft.com/netframework).Una vez dotNetFx35setup.exe está instalado, el equipo de destino contendrá ahora la clase. NET basebibliotecas,. NET (mscoree.dll), 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á quevelar por el equipo de destino tiene el medio ambiente. NET instalado y configurado.La naturaleza independiente de la plataforma. NETPara cerrar este capítulo, me permito hacer un breve comentario sobre la naturaleza independiente de la plataforma. NETplataforma. Para la sorpresa de la mayoría de los desarrolladores. NET puede ser desarrollado y ejecutado enlos sistemas no operativos de Microsoft (Mac OS X, numerosas distribuciones de Linux y Solaris, por nombrarpocos). Para entender cómo es esto posible, es necesario llegar a un acuerdo con otra siglaNET en el universo. CLI (Common Language Infrastructure).WhenMicrosoft lanzado la plataforma. NET, también a mano un conjunto de documentos formales quese 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 virtualSistema de Ejecución, o VES). Mejor aún, estos documentos han sido sometidos a ECMA Internationalcomo oficial de las normas internacionales (http://www.ecma-international.org). Las especificacionesde 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 permitenterceros para construir distribuciones de las platformfor. NET cualquier número de sistemas operativosy / o transformadores. ECMA-335 es quizás el más "carne" de las dos especificaciones, hasta el punto deque se ha dividido en seis divisiones, como se muestra en la Tabla 1-3.

Table 1-3. Partitions of the CLIPartitions of ECMA-335 Meaning in LifePartition I: Concepts and Architecture Describes the overall architecture of the CLI, includingthe rules of the CTS and CLS, and the mechanics of the.NET runtime enginePartition II: Definitions and Semantics Describes the details of .NET metadataPartition III: Instruction Set Describes the syntax and semantics of CIL codePartition IV: Profiles and Libraries Gives a high-level overview of the minimal and completeclass libraries that must be supported by a .NETdistribution

Partitions of ECMA-335 Meaning in LifePartition V: Debug Exchange Format Defines details of .NET debugging symbolsPartition VI: Annexes Provides a collection of “odds and ends” details such asclass library design guidelines and the implementationdetails 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 nombresque 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). LaCLI no define los espacios de nombres que faciliten el desarrollo web (ASP.NET), acceso a bases de datos(ADO.NET), o el desarrollo de aplicaciones de escritorio interfaz gráfica de usuario (a través de Windows Forms o Windows PresentationFundación).La buena noticia, sin embargo, es que la corriente principal. distribuciones NET ampliar las bibliotecas de la CLIcon sus equivalentes de Microsoft compatibles con ASP.NET, ADO.NET y Windows Forms (entre otrosAPI) con el fin de ofrecer todas las funciones, las plataformas de desarrollo a nivel de producción. Hasta la fecha, haydos implementaciones más importantes de la CLI (más allá de ofrecer específicas de Windows de Microsoft). Aunqueeste texto se centra en la creación de aplicaciones. NET utilizando. NET de Microsoft, la

distribución, la tabla 1-4proporciona información sobre el Mono y proyectos Portable.NET.

Distribution Meaning in Lifehttp://www.mono-project.com The Mono project is an open source distribution of the CLI thattargets various Linux distributions (e.g., SuSE, Fedora, and soon) as well as Windows and Mac OS X.http://www.dotgnu.org Portable.NET is another open source distribution of the CLIthat runs on numerous operating systems. Portable.NET aimsto target as many operating systems as possible (Win32, AIX,BeOS, Mac OS X, Solaris, all major Linux distributions, andso on).

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

NET básicamente se reduce a un motor de ejecución en tiempo de ejecución (mscoree.dll) y la biblioteca de clases base(mscorlib.dll y asociados). El Common Language Runtime (CLR) es capaz de albergar cualquier. NETbinaria (también conocido como conjunto) que no cumplen con las normas del código administrado. Como se ha visto, las asambleas contienenCIL instrucciones (además de los metadatos de tipo y el manifiesto del ensamblado) que se compilan eninstrucciones específicas de la plataforma mediante un "justo a tiempo (JIT). Además, se exploró el papelde la Common Language Specification (CLS) y el Sistema de tipos común (CTS).Esto fue seguido por un examen de la Ildasm.exe y navegar por objeto reflector.exeservicios públicos, así como la cobertura de cómo configurar un equipo para organizar las aplicaciones. NET utilizandodotNetFx35setup.exe. 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 Portable.NET

Construcción de Visual Basic 2008AplicacionesComo 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 IDEenfrentarse a: Microsoft Visual Basic 6.0. Dicho esto, el punto de este capítulo es proporcionar unagira por varios. opciones de desarrollo NET, incluyendo, por supuesto, Visual Studio 2008. El capítulose abre, sin embargo, con un examen de trabajar con el VB 2008 compilador de línea de comandos,vbc.exe, y el más simple de todos los editores de texto, el Bloc de notas (notepad.exe).Mientras que usted podría trabajar a través de este texto completo mediante otra cosa que vbc.exe y un simpleeditor 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 esgratis!). Después de un breve examen de Visual Basic 2008 Express IDE, a su vez su atención aVisual Studio 2008. En este capítulo se cierra con una breve discusión sobre el papel de laMicrosoft.VisualBasic.dll montaje y un estudio de adicionales. Herramientas de desarrollo NETtal 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 formalmenteexaminados. Si no está familiarizado con la sintaxis, no se preocupe. Capítulo 3 comenzará formalmente el examen deel lenguaje Visual Basic.El papel de. NET Framework 3.5 SDKUn error común en relación con. NET es la creencia de que los programadores debencomprar una copia de Visual Studio para construir sus aplicaciones Visual Basic. La verdad del asunto esque son capaces de construir cualquier tipo de. NET utilizando el programa de descarga gratuita. NET Framework3.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 undocumentación del sistema.nNota. NET Framework 3.5 SDK (dotNetFx35setup.exe) pueden obtenerse en el sitio web. NET descarga(Http://msdn.microsoft.com/netframework).35C H A R T E P 2

si usted es de hecho va a estar utilizando Visual Studio 2008 o Visual Basic 2008 Express, no tienennecesidad 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 elSDK antes de continuar.El Visual Studio 2008 del símbolo del sistemaCuando 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 sidesea utilizar estos servicios desde cualquier ventana de comandos de Windows, tendrá que registrar estoscaminos con el sistema operativo.Mientras que usted puede actualizar la variable PATH de forma manual para hacerlo (que no se molestará en haceraquí), puede ahorrar un poco de tiempo, simplemente haciendo uso de los comandos de Visual Studio 2008Del sistema que es accesible desde el inicio äPrograms äMicrosoft Visual Studio 2008 äVisual Estudiocarpeta de herramientas (ver Figura 2-1).Figura 2-1. El Visual Studio 2008 del símbolo del sistemaLa ventaja de utilizar este comando en particular del sistema es que se ha preconfigurado para ofrecerel acceso a cada una de las herramientas de desarrollo. NET sin necesidad de modificar la variable PATHajustes. Suponiendo que ha instalado un entorno. NET, escriba el siguiente comandoy 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 (vbc.exe)Hay una serie de técnicas que puede utilizar para compilar el código fuente de VB 2008. Además deVisual Studio 2008 (así como varios de terceros. NET IDE), que son capaces de crear. NETcon el VB 2008 compilador de línea de comandos, vbc.exe. Si bien es cierto que usted nunca podrá decidirconstruir una aplicación a gran escala utilizando el compilador de línea de comandos, es importante comprender laconceptos básicos de cómo compilar los archivos *. vb a mano. No puedo pensar en algunas de las razones que usted debe obtener un controlsobre el proceso:• La razón más obvia es el simple hecho de que puede que no tenga una copia de VisualStudio 2008.• Usted puede estar en un ambiente universitario donde está prohibido el uso de la generación de

códigoherramientas 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áficoaplicaciones, que son en última instancia, instruir vbc.exe cómo manipular la entrada de VB 2008archivos. En este sentido, es edificante para ver lo que ocurre detrás de las escenas.Otro buen producto derivado de trabajar con vbc.exe en la materia prima es que usted se convierte en muchomás cómoda la manipulación de otras herramientas de línea de comandos se incluye con el. NET Framework 3.5SDK. Como se verá a lo largo de este libro, una serie de utilidades importantes son accesibles sólo desdela línea de comandos.La construcción de aplicaciones con Visual Basic 2008 vbc.exePara ilustrar cómo construir una. NET IDE libre, vamos a construir un simple montaje de un solo archivollamado TestApp.exe con el VB 2008 compilador de línea de comandos y el Bloc de notas. En primer lugar, usted necesita una ciertade código fuente. Abra el Bloc de notas y escriba lo siguiente:

' A simple VB 2008 application.Imports SystemModule TestAppSub Main()Console.WriteLine("Testing! 1, 2, 3")End SubEnd Module

Una vez que haya terminado, guarde el archivo en una ubicación conveniente (por ejemplo, C: \ VbcExample) comoTestApp.vb. Ahora, vamos a conocer las opciones fundamentales de la VB 2008 compilador. El primer punto de interéses entender cómo especificar el nombre y tipo de reunión para crear (por ejemplo, una consolaaplicación denominada MyShell.exe, una biblioteca de código llamado MathLib.dll, aWindows FormsMyWinApp.exe nombre, etc.) Cada posibilidad es representado por una bandera específica se introdujo vbc.exe comoparámetro de línea de comandos (ver Tabla 2-1).

Table 2-1. Output-centric Options of the VB 2008 CompilerOption Meaning in Life/out This option is used to specify the name of the assembly to be created. Bydefault, 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 module.Modules 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 thebackground.

Para compilar TestApp.vb en una aplicación de consola denominada TestApp.exe, abrir un Visual Studio2008 del símbolo del sistema y cambie al directorio que contiene la fuente *. vb código mediante elcomando 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 lanombre de los archivos de entrada, no después):

vbc /target:exe TestApp.vb

Aquí no se especifica explícitamente un pabellón de entrada / salida, por lo tanto el ejecutable se llamaráTestApp.exe, le dio el nombre del archivo de entrada inicial. Sin embargo, si desea especificar un úniconombre para su montaje, puede introducir el siguiente comando:

vbc /target:exe /out:MyFirstApp.exe TestApp.vb

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

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

vbc TestApp.vb

TestApp.exe ahora se puede ejecutar desde la línea de comandos, escriba el nombre del ejecutable ypulsando la tecla Intro. Si todo va bien, debería ver el mensaje "Prueba! 1, 2, 3 "imprimir a laventana de comandos (ver Figura 2-2).

Figura 2-2. TestApp.exe en acciónHacer referencia externa Asambleas Uso vbc.exeEl 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 entiendesu referencia al tipo System.Console, recuerdo del capítulo 1 que mscorlib.dll (elensamblado que contiene el tipo System.Console) se hace referencia automáticamente durante la compilaciónproceso.Para ilustrar el proceso de la referencia externa ensamblados adicionales, vamos a actualizar laAplicación TestApp.exe para mostrar un cuadro de mensaje de Windows Forms. Abra el archivo TestApp.vby modificarlo de la siguiente manera

' A simple VB 2008 application.Imports System' Add this!Imports System.Windows.FormsModule TestAppSub Main()Console.WriteLine("Testing! 1, 2, 3")

' Add this!MessageBox.Show("Hello!")End SubEnd Module

Observe la referencia al espacio de nombres System.Windows.Forms 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 vbc.exe que contiene el conjunto de espacios de nombres importados.Dado que usted ha hecho uso de la clase de mensajes, debe especificar elSystem.Windows.Forms.dll ensamblado utilizando la bandera de referencia / (que puede ser abreviado a / r):

vbc /r:System.Windows.Forms.dll TestApp.vb

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

Figura 2-3. Su primera aplicación de Windows FormsCompilación de varios archivos de código fuente utilizando vbc.exeLa encarnación actual de la aplicación TestApp.exe fue creado usando un solo *. vb código fuentearchivo. Si bien es perfectamente lícito tener en todos sus. tipos de redes se definen en un archivo *. vb sola, la mayoría deproyectos se componen de varios archivos *. vb para mantener su base de código un poco más flexible. Supongamos quehan escrito una clase adicional (de nuevo, utilizando el Bloc de notas) contenida en un nuevo

archivo llamadoHelloMsg.vb:

' The HelloMessage classImports SystemImports System.Windows.FormsClass HelloMessageSub Speak()MessageBox.Show("Hello Again")End SubEnd 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 comentarla 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 System.Windows.FormsModule TestAppSub Main()Console.WriteLine("Testing! 1, 2, 3")' Don't need this anymore either.' MessageBox.Show("Hello!")' Exercise the HelloMessage class!Dim hello As New HelloMessage()hello.Speak()End SubEnd Module

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

vbc /r:System.Windows.Forms.dll TestApp.vb HelloMsg.vb

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

vbc /r:System.Windows.Forms.dll *.vb

Cuando se ejecuta el programa de nuevo, la salida es idéntica. La única diferencia entre los dossolicitudes es el hecho de que la lógica actual se ha dividido en varios archivos.Hacer referencia a varios ensamblados externos Uso de vbc.exeEn una nota relacionada, lo que si necesita hacer referencia a varios ensamblados externos utilizando vbc.exe?Simplemente una lista de cada conjunto mediante una lista delimitada por comas. No es necesario

especificar múltiples externosasambleas para el ejemplo actual, sino que sigue algunos ejemplos de uso:

vbc /r:System.Windows.Forms.dll,System.Drawing.dll *.vb

Trabajar con archivos de respuesta vbc.exeComo 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 referenciay *. vb código. Para ayudar a disminuir su carga de escribir, el compilador de VB 2008 honra la utilización dearchivos de respuestas.VB archivos de respuestas 2008 contienen todas las instrucciones que se utilizarán durante la elaboración de sugeneración actual. Por convención, estos archivos en un final *. RSP (respuesta) de extensión. Supongamos queHa creado un archivo de respuesta denominado TestApp.rsp que contiene los siguientes argumentos (como se puedever, los comentarios se denotan con el carácter #):

# This is the response file# for the TestApp.exe app# of Chapter 2.# External assembly references./r:System.Windows.Forms.dll

# Output and files to compile (using wildcard syntax)./t:exe /out:TestApp.exe *.vb

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

vbc @TestApp.rsp

Si la necesidad se presente, que también son capaces de especificar varios archivos *. rsp como entrada (por ejemplo, vbc@ @ FirstFile.rsp SecondFile.rsp @ ThirdFile.rsp). Si toma este enfoque, se tenga en cuenta que elcompilador procesa las opciones del comando, ya que se encuentran! Por lo tanto, los argumentos de línea de comandosen 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 reemplazapor el archivo *. rsp especificado. Por lo tanto, si usted fuera a entrar en

vbc /out:MyCoolApp.exe @TestApp.rsp

el nombre de la asamblea todavía se TestApp.exe (en lugar de MyCoolApp.exe), dada la/ out: bandera TestApp.exe listados en el archivo de respuesta TestApp.rsp. Sin embargo, si después de una lista de las banderasarchivo de respuestas, la bandera tienen prioridad en el archivo de respuesta. Así, en el siguiente comandoconjunto, su montaje es de hecho el nombre MyCoolApp.exe

vbc @TestApp.rsp /out:MyCoolApp.exe

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 (vbc.rsp)El punto final que se hará con respecto a los archivos de respuestas es que el compilador de VB 2008 tiene asociado unpor defecto del archivo de respuestas (vbc.rsp), que se encuentra en el mismo directorio que vbc.exe sí mismo (por ejemplo,C: \ Windows \ Microsoft.NET \ Framework \ v3.5). Si se va a abrir este archivo con el Bloc de notas, quese encontraba con que numerosos NET ya se han especificado utilizando el R /:. bandera. A medida queera de esperar, se llega a comprender el papel de muchos de estos. NET bibliotecas a lo largodel texto. Sin embargo, para sentar las bases, aquí es una mirada dentro de vbc.rsp:

# 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:Accessibility.dll/r:Microsoft.Vsa.dll/r:System.Configuration.dll/r:System.Configuration.Install.dll/r:System.Data.dll/r:System.Data.OracleClient.dll/r:System.Deployment.dll/r:System.Design.dll/r:System.DirectoryServices.dll/r:System.dll/r:System.Drawing.Design.dll/r:System.Drawing.dll

/r:System.EnterpriseServices.dll/r:System.Management.dll/r:System.Messaging.dll/r:System.Runtime.Remoting.dll/r:System.Runtime.Serialization.Formatters.Soap.dll/r:System.Security.dll/r:System.ServiceProcess.dll/r:System.Transactions.dll/r:System.Web.dll/r:System.Web.Mobile.dll/r:System.Web.RegularExpressions.dll/r:System.Web.Services.dll

/r:System.Windows.Forms.Dll/r:System.XML.dll/r:System.Workflow.Activities.dll/r:System.Workflow.ComponentModel.dll/r:System.Workflow.Runtime.dll/r:System.Runtime.Serialization.dll/r:System.ServiceModel.dll

/r:System.Core.dll/r:System.Xml.Linq.dll/r:System.Data.Linq.dll/r:System.Data.DataSetExtensions.dll/r:System.Web.Extensions.dll/r:System.Web.Extensions.Design.dll/r:System.ServiceModel.Web.dll# Import System and Microsoft.VisualBasic/imports:System/imports:Microsoft.VisualBasic/imports:System.Linq/imports:System.Xml.Linq/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 estoscolecciones.Cuando usted está construyendo su VB 2008 con programas de vbc.exe, 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 TestApp.exe podría ser compilado correctamente con el siguiente comandoconjunto (como se hace referencia en System.Windows.Forms.dll vbc.rsp):

vbc /out:TestApp.exe *.vb

En el caso de que desea desactivar la lectura automática de vbc.rsp, puede especificar el/ noconfig opción

vbc @TestApp.rsp /noconfig

Obviamente, el VB 2008 compilador de línea de comandos tiene muchas otras opciones que se pueden utilizar paracontrolar el modo en el archivo. NET se va a generar. En este punto, sin embargo, usted debe tenera manejar los conceptos básicos. Si desea conocer más detalles sobre la funcionalidad de vbc.exe,de búsqueda de. NET Framework 3.5 documentación para el término "vbc.exe".nSource Código VbcExample El proyecto se incluye en el Capítulo 2 subdirectorio.Edificio. NET Usando SharpDevelopMientras que el Bloc de notas está muy bien para la creación de simple. Programas NET, no ofrece nada en el camino de desarrolladorproductividad. Lo ideal sería al autor *. vb archivos con un editor que soporta (como mínimo) la palabra clavecoloració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áficosinterfaces de usuario, plantillas de proyecto y herramientas de base de datos de la manipulación. La suerte quiso que numerosasherramientas existen, muchos de los cuales son completamente gratis.Para hacer frente a esas necesidades, permítame presentarle la siguiente opción de desarrollo. NET: SharpDesarrollar (también conocido como # develop). SharpDevelop es un IDE de código abierto y rico en funciones quepuede utilizar para construir. NET utilizando Visual Basic o C #, así como el uso de CIL y una inspirada en Python. NETlenguaje llamado Boo. Más allá del hecho de que este IDE es completamente gratuito, es interesante señalar quefue 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 instalarSharpDevelop en su equipo de desarrollo. Ambas distribuciones se pueden obtener dehttp://www.sharpdevelop.com (a la hora de escribir este artículo, la versión actual es de 2,2, sin embargo, seAsegúrese de descargar la última y mejor).SharpDevelop proporciona numerosas mejoras de la productividad y en muchos casos es la funciónricos 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 ensambladosimplementar 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 SDKImpresionante para un país libre IDE, ¿no? Aunque este capítulo no se aplica a cada uno de estos puntos endetalle, vamos a caminar a través de algunos artículos de interés.:

La construcción de un proyecto de prueba simpleUna vez que haya instalado SharpDevelop, la opción de menú Archivo ANew asolution permite que usted escojaqué tipo de proyecto que desea generar (y en el que. NET). Por ejemplo, usted asumehan 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 eldiseñador), y una ventana Propiedades para configurar la apariencia de cada elemento de la interfaz de usuario. Figura 2-5 ilustrala configuración de un tipo de botón utilizando el IDE (por defecto, el IDE se mostrará el código fuente de la corrienteforma, seleccione la ficha Diseño en la parte inferior de la ventana principal para activar el diseñador

Cancelartraducción del inglés al español

Figura 2-5. Gráficamente el diseño de una aplicación de Windows Forms con SharpDevelopSi tuviera que hacer clic en el botón Fuente montado en la parte inferior del diseñador del formulario, ustedencontrar 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 estede 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 VisualStudio 2008.Edificio. NET utilizando Visual Basic2008 ExpressDurante el verano de 2004, Microsoft introdujo una línea completamente nueva de IDEs que caen bajo la denominaciónde "Express" productos (http://msdn.microsoft.com/express). Hasta la fecha, hay variosmiembros de la familia Express (todos los cuales son completamente gratis y apoyado y mantenido porMicrosoft Corporation), incluyendo las siguientes:• Visual Web Developer 2008 Express: Una herramienta ligera para la construcción de sitios web dinámicos yServicios web XML con ASP.NET• Visual Basic 2008 Express: Un ideal herramienta de programación optimizada para los programadores novatosque 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 aficionadosque 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 desarrolladoresAlgunas características únicas de Visual Basic 2008 ExpressVersiones En general, los productos Express están reducida de sus homólogos de Visual Studio 2008y afectan principalmente a los. NET aficionados y estudiantes. Al igual que SharpDevelop, Visual Basic2008 Express ofrece varias herramientas de navegación de objetos, un diseñador de formularios Windows Forms, el Agregar referenciascuadro 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 enSharpDevelop, 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 MicrosoftXNA Game StudioConsidere la figura 7.2, que muestra el uso de Visual Basic Express al autor el marcado XAMLpara 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ísticasque necesita para trabajar durante el resto de este texto.

Figura 2-7.Visual 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 deVisual Studio 2008.Edificio. NET utilizando VisualStudio 2008Si usted es un profesional. ingeniero de software NET, las posibilidades son muy buenas que suempleador ha comprado IDE principal de Microsoft, Visual Studio 2008, por sus esfuerzos de desarrollo(http://msdn.microsoft.com/vstudio). Esta herramienta es de lejos la más rica en características ylista para la empresa IDE examinados en este capítulo. Por supuesto, este poder tiene un precio, que sevarí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 duranteel 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 queser 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 queexaminar una opción que no es proporcionada por el IDE. Sin embargo, estar seguro de que todos los de este librocó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 Apresssitio web (http://www.apress.com), puede cargar el ejemplo actual en Visual Studio 2008 (o Visual Basic2008 Express) haciendo doble clic en el ejemplo de archivo *. sln. Si no está utilizando Visual Studio 2008/VisualBasic 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 2008Visual 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 datosherramientas, objetos y las utilidades del proyecto de navegación, y un sistema de ayuda integrado. A diferencia de muchos de losIDE que ya hemos examinado, Visual Studio 2008 ofrece numerosas adiciones. Aquí hay una parciallista:• 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 miembrosdirectamente en el IDEPara ser completamente honesto, Visual Studio 2008 ofrece tantas características que sería necesario untodo el libro (un libro bastante grande por cierto) para describir completamente todos los aspectos del IDE. Esto no eslibro. Sin embargo, quiero señalar algunas de las características principales de las páginas que siguen. A medida queel 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álogoPara 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 Frameworkdesea construir en contra (2.0, 3.0 o 3.5) utilizando el cuadro de lista desplegable en la parte superior derecha de laNuevo 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 2-8.Visual Studio 2008 ahora le permite orientar una determinada versión de. NET Framework.Uso de la utilidad Explorador de solucionesLa utilidad Explorador de soluciones (accesible desde el menú Ver) que permite ver el conjunto de todo el contenidoarchivos y ensamblados de referencia que conforman el proyecto actual. De forma predeterminada, el Explorador de solucionesNo le mostrará el conjunto de ensamblados de referencia utilizado por el proyecto o los directorios de salidautilizado por Visual Studio 2008 (como \ bin \ Debug). Para ver todos los aspectos de su proyecto, debe hacer clic enel 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úblicosCAPÍTULO 2 EDIFICIO n Visual Basic 2008 APLICACIONES 49

Observe que la carpeta Referencias del Explorador de soluciones muestra una lista de cada conjunto tieneActualmente se hace referencia, que será diferente en función del tipo de proyecto seleccionado y la versión delMarco está compilando en contra.Hacer referencia a ensamblados externosCuando usted necesita a las asambleas de referencia adicional, usted puede hacer clic en la carpeta Referenciasen el Explorador de soluciones y seleccione la opción Agregar referencia del menú o simplemente haga un proyecto deAgregar referencia opción de menú de Visual Studio 2008. En cualquier caso, usted puede seleccionar el conjunto deel 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, elficha muy recientes útil un recuento actualizado de las asambleas con frecuencia se hace referencia se han utilizado enotros proyectos.Figura 2-10. El cuadro de diálogo Agregar referenciaVer las propiedades del proyectoPor ú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 diferentesconfiguración, con fuerza el nombre de su conjunto, implementar la aplicación, los recursos de inserción de aplicaciones yconfigurar los eventos pre y generación posterior.

Figura 2-11. El proyecto Mi ventanaLa utilidad de la Vista de clasesLa siguiente herramienta para examinar es la utilidad de la Vista de clases, que se puede abrir desde el menú Ver. El propósitode esta utilidad es para mostrar todos los tipos en el proyecto actual desde una perspectiva más orientada a objetosla perspectiva (en lugar de una visión basada en archivos del Explorador de soluciones). El panel superior muestra el conjunto deespacios 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 utilidadCAPÍTULO 2 EDIFICIO n Visual Basic 2008 APLICACIONES 51

La utilidad de Examinador de objetosVisual Studio 2008 también proporciona una utilidad para investigar el conjunto de ensamblados de referencia dentro de suproyecto actual. Activar el Examinador de objetos utilizando el menú Ver y, a continuación, seleccionar el conjunto dedesea investigar (véase la Figura 2-13).Figura 2-13. El Examinador de objetos de utilidadnNota Si hace doble clic en un icono de ensamblado de la carpeta Referencias del Explorador de soluciones, Examinador de objetos seabre automáticamente con el montaje seleccionado resaltado.Visual Studio 2008 Tecnología de fragmentos de códigoVisual Studio 2008 (así como Visual Basic 2008 Express) también tiene la capacidad de insertar complejosbloques de código VB 2008 con selecciones de menú, los clics del ratón sensible al contexto, y / o el

tecladoatajos usando fragmentos de código. En pocas palabras, un fragmento de código es un bloque predefinidos de Visual Basic 2008código que se expandirá en el archivo de código activo. Como era de suponer, fragmentos de código puede ser de granayudar a aumentar la productividad, dado que la herramienta va a generar los estados código necesario (en lugarque nosotros!).Para ver esta funcionalidad de primera mano, haga clic en una línea en blanco dentro de su método Main () y activarel menú Insertar fragmento de código. Desde aquí, podrás ver que los fragmentos de código relacionados se agrupan enuna categoría específica (patrones de código, datos, Aplicación de Windows Forms, etc.) Para este ejemplo, seleccionelos fundamentos Amath categoría y luego activar el calcular un pago mensual de un préstamofragmento (ver Figura 2-14).Una vez que seleccione un fragmento determinado, se encuentra el código relacionado se expande de forma automática (prensala 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 unFragmento 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 snippetsFigure 2-15. The inserted snippetAs

Como puede ver, Visual Studio 2008 define un buen número de fragmentos de código. Sin duda, el mejormanera de aprender acerca de cada posibilidad es simplemente a través de la experimentación. Bajo el capó, cada códigofragmento de código se define dentro de un documento XML (teniendo una extensión *. fragmento de forma predeterminada), ubicado enel directorio C: \ Archivos de programa \ Microsoft Visual Studio 9.0 \ VB \ Snippets \ 1033 de la guía. De hecho, dado quecada fragmento es simplemente una descripción XML del código que se inserta dentro del IDE, es muy sencillola 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 http://msdn.microsoft.com. 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 VisualVisual Studio 2008 nos da la capacidad de diseñar clases visuales (pero esta capacidad no está incluido enVisual Basic 2008 Express). La utilidad Diseñador de clases le permite ver y modificar las relacionesde 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 sumodificaciones 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 enLado derecho el Explorador de soluciones (ver Figura 2.16).Figura 2-16. Inserción de un archivo de diagrama de clasenNota Si ha seleccionado el icono de su proyecto en el Explorador de soluciones antes de insertar un diagrama de clase (como se muestraen 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 seleccionael 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. Sihaga clic en la imagen de flecha, puede mostrar u ocultar los miembros del tipo (ver Figura 2.17). Ten en cuenta queVisual Studio 2008 le mostrará todos los miembros en el proyecto actual de forma predeterminada. Si desea eliminarun elemento determinado en el diagrama, simplemente haga clic derecho y seleccione Eliminar en el menú contextual (estoNo 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 claseventana (activa mediante el menú Ver "Otras Windows) y el Diseñador de clases Caja de herramientas (activautilizando el elemento de menú Ver äToolbox). La ventana Detalles de clase no sólo le muestra ladetalles del elemento seleccionado en el diagrama, sino también le permite modificar los actuales miembrosy los miembros de insertar nuevos sobre la marcha (véase la Figura 2-18).

Figura 2-18. La ventana Detalles de claseEl 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 clasecomo la ventana activa para ver esta caja de herramientas.) Al hacerlo, el IDE crea automáticamente nuevasVB 2008 definiciones de tipos en el fondo.Figura 2-19. La caja de herramientas Diseñador de clasesA 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úblicoString Petname campo denominado (véase la Figura 2-20).

Figura 2-20. Agregar un campo con la ventana Detalles de claseSi ahora mirar el VB 2008 la definición de la clase de coches (en el recién generado Car.vbarchivo), 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 StringEnd Class

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

Public Class SportsCarInherits CarPublic Function PrintPetName() As StringpetName = "Fred"Return String.Format("Name of this car is: {0}", petName)End SubEnd Class

El banco de prueba de objetosOtra buena herramienta visual que proporciona Visual Studio 2008 es objeto de prueba de banco

(OTB). Este aspecto de lael IDE le permite crear rápidamente una instancia de una clase e invocar sus miembros sin la necesidad depara compilar y ejecutar toda la aplicación. Esto puede ser extremadamente útil cuando se desea probar unmétodo específico, pero no desean pasar por docenas de líneas de código para hacerlo. Esto también esmuy útil cuando usted está construyendo una biblioteca. NET (*. dll) y desea probar rápidamente sumiembros 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. Porejemplo, haga clic en el tipo Sportscar, y desde el menú contextual resultante seleccione CrearInstanceäSportsCar (). Se abrirá un cuadro de diálogo que le permite nombrar el temporalvariable 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 elPrintPetName () método (véase la Figura 2-22).Figura 2-22. El Visual Studio 2008 objetos de Banco de PruebasUna vez que lo hace, la OTB le mostrará el valor devuelto por una función, que es una cadena establecida en elvalor "Nombre de este coche es: Fred". Observe en la figura 2.23, puede optar por guardar este nuevo objeto Stringen la OTB, así, después de lo cual puede invocar a varios miembros del tipo String.Figura 2-23.Viewing nuestro valor devuelto por una función

El sistema de ayuda integradoEl aspecto final de Visual Studio 2008 debe ser cómodo con desde el principio es la plenasistema de ayuda integrado. . NET Framework 3.5 SDK (también conocido como el MSDN Library) esmuy 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 yprofundizar en la documentación presentada. Si te resistes, que están condenados a una frustración de largo, yexistencia dolorosa como desarrollador de. NET.Visual Studio 2008 proporciona la ventana Ayuda dinámica (se accede a través de la Ayuda adinámicoselecció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 consolaclase, la ventana Ayuda dinámica muestra un conjunto de enlaces sobre el tipo System.Console.nNota Otro atajo útil es la tecla F1 de Visual Studio 2008. Basta con ubicar el cursor del ratón dentro de unpalabra 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 SDKdocumentació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 a.net a.net marco a.net FrameworkNodo de referencia de la documentación, se encuentra la documentación completa de todas y cadaespacio 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 laparámetros de un miembro determinado. Por otra parte, al ver la página de ayuda para un mismo tipo, se lese dijo el nombre de la asamblea y espacio de nombres que contiene el tipo en cuestión (que se encuentra en elparte superior de dicha página). Al leer el resto de este libro, supongo que va a sumergirse enesta 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 mangasy cavar en los detalles. Ningún libro, independientemente de su tamaño, puede cubrir todos los detalles de la creación de aplicaciones con VisualBasic 2008 o la plataforma. NET. Por lo tanto, si se encuentra con un tipo o miembro que desee obtener más informaciónsobre 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.0AsambleaComo lo más seguro dado cuenta a lo largo de este libro, Visual Basic 2008 es unrevisión a fondo de VB6 que a menudo es mejor considerar simplemente VB 2008 como un lenguaje nuevo en elfamiliar 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. NETbibliotecas 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. NETllamado Microsoft.VisualBasic.dll, que define los tipos que proporcionan la misma funcionalidad de lalegado VB6 construcciones. Al igual que cualquier montaje, Microsoft.VisualBasic.dll se compone de numerosasespacios de nombres que agrupan ideas afines tipos (ver Figura 2.25).Figura 2-25. El conjunto de compatibilidad Microsoft.VisualBasic.dll VB6Además, cada uno de estos espacios de nombres están automáticamente disponibles para cada

archivo *. vb en sudel proyecto. Teniendo en cuenta este punto, no es necesario añadir explícitamente un conjunto de instrucciones Imports para accederde sus tipos. Por lo tanto, si desea hacerlo, usted todavía puede hacer uso de diversos VB6-ismos, como elMsgBox () para mostrar un cuadro de mensaje simple:

' The Microsoft.VisualBasic namespaces' are automatically referenced by a' Visual Studio 2008 VB project.Module Module1Sub Main()

MsgBox("Hello, old friend...")End SubEnd Module

Note como parece que está llamando a un método global llamada MsgBox () directamente dentro deMain (). En realidad, el MsgBox () es un miembro de un módulo de VB 2008 Interacción con nombre que sedefinido en el espacio de nombres Microsoft.VisualBasic (véase la Figura 2-26).Figura 2-26. El espacio de nombres Microsoft.VisualBasic 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 miembrosdefinido en un módulo puede ser llamado directamente, sin necesidad de prefijo el nombre de la definiciónmódulo. Sin embargo, si usted fuera a prefijo del módulo de interacción con el MsgBox () función, el programaque funcionan de forma idéntica:

Module Module1Sub Main()Interaction.MsgBox("Everything old is new again!")End SubEnd Module

Ahora bien, aunque se puede sentir un poco tranquilizador saber que la funcionalidad de VB6 todavía puede ser simuladodentro de los nuevos proyectos de Visual Basic 2008, le recomiendo que evite el uso de este tipo enposible. En primer lugar, la escritura parece estar en la pared sobre la vida de VB6, en el queLa propia Microsoft tiene previsto eliminar gradualmente el apoyo a VB6 con el tiempo, y teniendo en cuenta esto, no se puede garantizarque 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ásque el (pronto-a-ser) el legado lenguaje de programación Visual Basic 6. Teniendo en cuenta estos puntos, este textono hacer uso de la capa de compatibilidad de VB6. Por el contrario, que se centrará en el aprendizaje. NET basebibliotecas y la forma de interactuar con este tipo utilizando la sintaxis de Visual Basic 2008.

Un catálogo parcial de adicionales. NETHerramientas de desarrolloPara concluir este capítulo, me gustaría señalar una serie de. NET herramientas de desarrollo que se complementanla funcionalidad proporcionada por el IDE de elección. Muchas de las herramientas mencionadas aquí sonde código abierto, y todos ellos son gratuitos. Aunque no tengo el espacio para cubrir los detalles deestas utilidades, la tabla 2-2 enumera una serie de herramientas que he encontrado para ser extremadamente útil, así comoURL que puede visitar para obtener más información acerca de ellos.

Table 2-2. Select .NET Development ToolsTool Meaning in Life URLFxCop This is a must-have for any .NET developer http://blogs.msdn.com/fxcop/interested in .NET best practices. FxCopwill test any .NET assembly against theofficial Microsoft .NET best-practicecoding guidelines.Lutz Roeder’s This advanced .NET decompiler/object http://www.aisto.com/roeder/Reflector browser allows you to view the .NET dotnetimplementation of any .NET type usinga variety of languages.NAnt NAnt is the .NET equivalent of Ant, the http://sourceforge.net/popular Java automated build tool. NAnt projects/nantallows you to define and execute detailedbuild scripts using an XML-based syntax.NDoc NDoc is a tool that will generate code http://sourceforge.net/documentation files for commented VB projects/ndoccode (or a compiled .NET assembly) in avariety of popular formats (MSDN’s *.chm,XML, HTML, Javadoc, and LaTeX).NUnit NUnit is the .NET equivalent of the http://www.nunit.orgJava-centric JUnit unit testing tool. UsingNUnit, you are able to facilitate thetesting of your managed code.

SummarySo as you can see, you have many new toys at your disposal! The point of this chapter was to provideyou with a tour of the major programming tools a VB 2008 programmer may leverage during thedevelopment process. You began the journey by learning how to generate .NET assemblies usingnothing other than the free VB 2008 compiler and Notepad.You also examined three feature-rich IDEs, starting with the open source SharpDevelop, followedby Microsoft’s Visual Basic 2008 Express and Visual Studio 2008. While this chapter onlyscratched the surface of each tool’s functionality, you should be in a good position to exploreyour chosen IDE at your leisure. The chapter wrapped up by describing the role of Microsoft.VisualBasic.dll and mentioned a number of open source .NET development tools that extendthe functionality of your IDE of choice.

Core VB ProgrammingConstructs

Programación VB 2008 Construcciones,Parte IEste capítulo comienza su investigación formal del lenguaje de programación Visual Basic 2008. Noser conscientes de este capítulo y el siguiente se presentan una serie de temas independiente del tamaño de un bocado debesentirse 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ásicasde VB 2008.Dicho esto, la primera tarea es comprender el papel de la palabra clave del módulo comoasí como el formato de punto de partida de un programa: el método Main (). A continuación, se investigará laintrínseca VB 2008 los tipos de datos (y sus tipos equivalente en el espacio de nombres System), así como diversasdatos 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óduloVisual Basic 2008 admite una programación específica la construcción de un módulo llamado, que se declaracon la palabra clave del módulo. Por ejemplo, al crear un proyecto Aplicación de consola con VisualStudio 2008, recibirá automáticamente un archivo *. vb que contiene el siguiente código:

Module Module1Sub Main()End SubEnd Module

Bajo el capó, la palabra clave del módulo define un tipo de clase, con algunas excepciones notables. En primer lugary 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ónque es más o menos análoga a la funcionalidad proporcionada por un archivo *. bas VB6 (los detalles sobre compartidamiembros se pueden encontrar en el capítulo 5).Dado que los miembros de un módulo son directamente accesibles, no es necesario anteponer elnombre del módulo cuando se accede a su contenido. Para ilustrar el trabajo con módulos, crear una nueva consolaProyecto de aplicación (llamada FunWithModules) y actualizar el archivo de código inicial de la siguiente manera:

Module Module1Sub Main()' Show banner.DisplayBanner()

' Get user's name and say howdy.GreetUser()End SubSub DisplayBanner()' Get the current color of the console text.Dim currColor As ConsoleColor = Console.ForegroundColor' Set text color to yellow.Console.ForegroundColor = ConsoleColor.YellowConsole.WriteLine("******* Welcome to FunWithModules *******")Console.WriteLine("This simple program illustrates the role")Console.WriteLine("of the Module type.")Console.WriteLine("*****************************************")' Reset to previous color of your console text.Console.ForegroundColor = currColorConsole.WriteLine()End SubSub GreetUser()Dim userName As StringConsole.Write("Please enter your name: ")userName = Console.ReadLine()Console.WriteLine("Hello there {0}. Nice to meet ya.", userName)End SubEnd ModuleFigure 3-1 shows one possible output.

Proyectos con múltiples módulosEn 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, sidesea hacerlo, puede adaptar Main () de la siguiente manera:

Sub Main()' Show banner.Module1.DisplayBanner()' Get user's name and say howdy.Module1.GreetUser()End Sub

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

Module MyModulePublic Sub GreetUser()Console.WriteLine("Hello user...")End SubEnd Module

Si usted quiere hablar MyModule.GreetUser () desde dentro del método Main (), ahora tendría queel 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 Module1.GreetUser () método, como lo es en el ámbito mismo módulo comoMain ():

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

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

Module MyMathModuleFunction Add(ByVal x As Integer, ByVal y As Integer) As IntegerReturn x + yEnd FunctionFunction Subtract(ByVal x As Integer, ByVal y As Integer) As IntegerReturn x - yEnd FunctionEnd 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.Console.WriteLine("10 + 10 is {0}.", Add(10, 10))' Subtract some numbers' (module prefix optional).Console.WriteLine("10 - 10 is {0}.", MyMathModule.Subtract(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 delas funciones del edificio y subrutinas.

Los módulos no son InstanciableOtro 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 puedeutilizado 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 puedenimplementar interfaces.Cambiar el nombre de su módulo inicialDe forma predeterminada, Visual Studio 2008 los nombres de los de tipo inicial del módulo de una aplicación de consola utilizando elmá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 comolo 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ódulonNota 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 laVentana Explorador de soluciones de Visual Studio. Esto automáticamente "reiniciar" el objeto de inicio

Miembros de los módulosPara terminar nuestra investigación de los tipos de módulos, sé que los módulos pueden tener miembros adicionalesmás allá de las subrutinas y funciones. Si desea definir los datos de campo (así como otros miembros, comocomo propiedades o eventos), usted es libre de hacerlo. Por ejemplo, suponga que desea actualizar a MyModulecontienen 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 MyModulePublic UserName As StringSub GreetUser()Console.WriteLine("Hello, {0}.", UserName)End SubEnd 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"MyModule.GreetUser()...End Sub

nSource Código FunWithModules El proyecto se encuentra en el Capítulo 3 subdirectorio.El papel del método principalCada VB 2008 ejecutables de aplicaciones (como un programa de consola, el servicio de Windows o el escritorio de unGUI de la aplicación) debe contener un tipo de definición de un método Main (), que representa el punto de entrada dela 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 estructuratipo así. Si se define el método Main () dentro de cualquiera de estos tipos, debeexpresamente hacer uso de la palabra clave compartida. Para ilustrar, crear una nueva aplicación de consola denominadaFunWithMain. 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 SubEnd Class

Si intenta compilar el programa, usted recibirá otra vez un error del compilador que le informaque 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 argumentosSystem.EnvironmentUna 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, vbc.exe (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. Lacompilador de vbc.exe procesados estos indicadores de entrada con el fin de compilar el ensamblado de salida. Cuando sedeseo de construir un método Main () que puede procesar los argumentos de entrada de línea de comandos para su medidaaplicaciones, usted tiene varias formas posibles de hacerlo.Su primer enfoque consiste en hacer uso de la GetCommandLineArgs compartido () método definido por elTipo System.Environment. Este método devuelve un array de objetos String. El primer elemento de lamatriz es simplemente el nombre del programa ejecutable, mientras que cualquier resto de elementos de la matriz representanlos argumentos de línea de comandos propios. Para ilustrar, actualizar su actual método Main () comosiguiente:

Class ProgramShared Sub Main()Console.WriteLine("***** Fun with Main() *****")' Get command-line args.Dim args As String() = Environment.GetCommandLineArgs()Dim s As StringFor Each s In argsConsole.WriteLine("Arg: {0}", s)NextEnd SubEnd Class

Suponiendo que usted ha construido su aplicación, si usted fuera a ejecutar ahora la aplicación en el símbolo deldel sistema, se puede alimentar en sus argumentos de la misma manera como lo hizo cuando se trabajacon vbc.exe (ver Figura 3-3).Figura 3-3. Procesamiento de la línea de comandos argumentosPor supuesto, depende de usted para determinar que los argumentos de línea de comandos de su programaresponder y la forma en que debe tener el formato (por ejemplo, con un - o un prefijo /). Aquí simplemente se pasa enuna serie de opciones que se imprime en el símbolo del sistema. Supongamos, sin embargo, fueron la creación deun nuevo juego de video y programar la aplicación para procesar una opción llamada-godmode. Si

elusuario inicia la aplicación con la bandera, ya sabes que el usuario es en realidad un tramposo, y usted puede tener unacurso de acción apropiado.

Procesamiento de la línea de comandos con argumentos Main ()Si prefiere no hacer uso del tipo System.Environment 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ónsu base de código de la siguiente manera:

Shared Sub Main(ByVal args As String())Console.WriteLine("***** Fun with Main() *****")' Get command-line args.Dim s As StringFor Each s In argsConsole.WriteLine("Arg: {0}", s)NextEnd Sub

Al adoptar este enfoque, el primer elemento de la matriz de entrada es de hecho la primera línea de comandosargumento (en lugar del nombre del ejecutable). Si se va a ejecutar la aplicación una vezde 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 enLenguajes basados en C, en devolver el valor 0 indica normalmente que el programa ha terminadosin 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 IntegerConsole.WriteLine("***** Fun with Main() *****")Dim s As StringFor Each s In argsConsole.WriteLine("Arg: {0}", s)Next' Return a value to the OS.Return 0End Function

Independientemente de cómo se defina el método Main (), el objetivo sigue siendo el mismo: interactuar conlos tipos que llevan a cabo la funcionalidad de su aplicación. Una vez que la declaración final en elMétodo main () se ha ejecutado, Main () las salidas y su aplicación termina.Especificar argumentos de línea de comandos con Visual Studio 2008Por último, permítanme señalar que Visual Studio 2008 le permite especificar de entrada de línea de

comandosargumentos, que puede ser muy útil cuando las pruebas y la depuración de la aplicación. En lugar detener que ejecutar la aplicación en una línea de comandos para alimentar argumentos en forma manual, puede hacerlaespecificar los argumentos utilizando la ficha Depurar del cuadro de diálogo Mi proyecto, que se muestra en la Figura 3.4 (véase laLa línea de comandos área de texto argumentos).

Figura 3-4. Simulación de argumentos de la línea de comandosAl compilar y ejecutar la aplicación en modo de depuración, los argumentos especificados sonse pasa al método Main () de forma automática. Sé que al compilar y ejecutar un lanzamientoconstrucción de su solicitud (que se puede establecer mediante la ficha de compilación del cuadro de diálogo Mi proyectocaja), esto ya no es el caso.Un interesante Aparte: Algunos miembros adicionales dela clase System.EnvironmentEl 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 actualidadalojamiento de su. NET utilizando diversos miembros compartidos. Para ilustrar la utilidad deSystem.Environment, actualizar el método Main () con la siguiente lógica:

Shared Function Main(ByVal args As String()) As Integer...' OS running this app?Console.WriteLine("Current OS: {0}", Environment.OSVersion)' List the drives on this machine.Dim drives As String() = Environment.GetLogicalDrives()Dim d As StringFor Each d In drivesConsole.WriteLine("You have a drive named {0}.", d)Next' Which version of the .NET platform is running this app?Console.WriteLine("Executing version of .NET: {0}", _Environment.Version)Return 0End 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 System.EnvironmentProperty Meaning in LifeCurrentDirectory Gets the full path to the current applicationMachineName Gets the name of the current machineNewLine Gets the newline symbol for the current environmentProcessorCount Returns the number of processors on the current machine

SystemDirectory Returns the full path to the system directoryUserName Returns the name of the user who started this application

El System.Console claseCasi todos los ejemplos de aplicaciones creadas en el transcurso de los capítulos iniciales de este textohacen un uso extensivo de la clase System.Console. Si bien es cierto que una consola de interfaz de usuario (a vecesllama 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 deVisual Basic y los aspectos centrales de la plataforma. NET, en lugar de tratar con las complejidades de laGUIs edificio.Como su nombre lo indica, la clase Console encapsula la entrada, salida y error de secuencia de manipulacionespara aplicaciones basadas en la consola. Tabla 3-2 se enumeran algunas (pero definitivamente no todos) de los miembros delde interés.

Table 3-2. Select Members of System.ConsoleMember Meaning in LifeBeep() This method forces the console to emit a beep of a specified frequency andduration.BackgroundColor These properties set the background/foreground colors for the currentForegroundColor output. They may be assigned any member of the ConsoleColor enumeration.BufferHeight These properties control the height/width of the console’s buffer area.BufferWidthTitle This property sets the title of the current console.WindowHeight These properties control the dimensions of the console in relation to theWindowWidth established buffer.WindowTopWindowLeftClear() This method clears the established buffer and console display area.

Básico de entrada y salida con la clase de consolaAdemás de los miembros en la Tabla 2.3, el tipo de consola define un conjunto de métodos para capturar la entraday 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 cocheida y vuelta) a la secuencia de salida. El método write () texto bombas de la secuencia de salida sinretorno de carro. ReadLine () le permite recibir información de la secuencia de entrada hasta elretorno 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 denominadaBasicConsoleIO y actualizar el método Main () con la lógica que pide al usuario para algunos bitsde información y se hace eco de cada elemento en la secuencia de salida estándar.

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

El formato de salida de la consolaDurante 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 deformato de cadenas, lo que puede ser utilizado por cualquier lenguaje de programación. NET. En pocas palabras, cuando sela 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, elvalor (s) pasó a Console.WriteLine () se sustituyen por cada marcador de posición. Para ilustrar, la actualizaciónsu actual método Main () de la siguiente manera:

Sub Main()...' Specify string placeholders and values to use at' runtime.Dim theInt As Integer = 90Dim theDouble As Double = 9.99Dim theBool As Boolean = TrueConsole.WriteLine("Value of theInt: {0}", theInt)Console.WriteLine("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 opcionaldesignada por {0}, {1}, {2}, y así sucesivamente. Ser muy consciente de que el primer número ordinal de un curlybracketmarcador de posición siempre comienza con 0. El resto de parámetros a WriteLine () son simplemente elvalores que se inserta en los marcadores de posición respectiva (en este caso, un número entero, un doble, y unBoolean).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 serecibir 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, sison un fan de los Beatles y queremos construir la cadena "9, Número 9, Número 9", escribiría:

' John says...Console.WriteLine("{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.Console.WriteLine("{1}, {0}, {2}", 10, 20, 30)

NET cadena de formato BanderasSi desea más detalles de formato, cada marcador de posición opcionalmente puede contener varios formatoscaracteres. Cada carácter de formato se puede escribir en mayúsculas o minúsculas con poca o ningunaconsecuencia. Tabla 3-3 muestra las opciones de formato básico.

Table 3-3. .NET String Format CharactersString Format Character Meaning in LifeC or c Used to format currency. By default, the flag will prefix the local culturalsymbol (a dollar sign [$] for U.S. English).D or d Used to format decimal numbers. This flag may also specify theminimum 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 tofixed or exponential format.

String Format Character Meaning in LifeN or n Used for basic numerical formatting (with commas).X or x Used for hexadecimal formatting. If you use an uppercase “X”, your hexformat 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()...Console.WriteLine("C format: {0:C}", 99989.987)Console.WriteLine("D9 format: {0:D9}", 99999)Console.WriteLine("E format: {0:E}", 99999.76543)Console.WriteLine("F3 format: {0:F3}", 99999.9999)Console.WriteLine("N format: {0:N}", 99999)Console.WriteLine("X format: {0:X}", 99999)Console.WriteLine("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 imprimirla cadena completa en el formato deseado.Uso de cadenas de formato String.Format ()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 String.Format compartido () método. Esto puede ser útilcuando se necesita para construir una cadena que contiene valores numéricos en la memoria para su uso en cualquier aplicacióntipo (formularios Windows Forms, ASP.NET, servicios web, XML, etc). Para ilustrar, la actualización principal () con elsiguiente código final:

' Now make use of some format tags.Sub Main()...' Use the shared String.Format() method to build a new string.Dim formatStr As StringformatStr = _String.Format("Don't you wish you had {0:C} in your account?", 99989.987)Console.WriteLine(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 representarvariables locales, variables de miembros, los valores devueltos y los parámetros de entrada. Aunque muchos de losVB tipos de datos se denominan de forma idéntica a los tipos de datos encontrados en VB6, tenga en cuenta que no es unasignació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 sobreCompatibilidad 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 sonen realidad notaciones cortas para los tipos en toda regla en el espacio de nombres System. Tabla 3-4 documentoslos tipos de datos de VB 2008 (con el tamaño de la asignación de almacenamiento), los equivalentes de datos el tipo de sistema, yel rango de cada tipo.

Table 3-4. The Intrinsic Data Types of VB 2008VB Keyword CLS Compliant? System Type Range Meaning in LifeBoolean Yes System.Boolean True or False Represents truth orfalsitySByte No System.SByte –128 to 127 Signed 8-bit numberByte Yes System.Byte 0 to 255 Unsigned 8-bitnumberShort Yes System.Int16 –32,768 to 32,767 Signed 16-bit numberUShort No System.UInt16 0 to 65,535 Unsigned 16-bitnumberInteger Yes System.Int32 –2,147,483,648 to Signed 32-bit number2,147,483,647UInteger No System.UInt32 0 to 4,294,967,295 Unsigned 32-bitnumberLong Yes System.Int64 –9,223,372,036,854,775,808 to Signed 64-bit number9,223,372,036,854,775,807

VB Keyword CLS Compliant? System Type Range Meaning in LifeULong No System.UInt64 0 to 18,446,744,073,709,551,615 Unsigned 64-bitnumberChar Yes System.Char U+0000 to U+ffff A single 16-bitUnicode characterSingle Yes System.Single ±1.5 5 1045 to ±3.4 5 1038 32-bit floating-pointnumberDouble Yes System.Double ±5.0 5 10324 to ±1.7 5 10308 64-bit floating-pointnumberDecimal Yes System.Decimal ±1.0 5 10e28 to ±7.9 5 10e28 A 96-bit signednumberString Yes System.String Limited by system memory Represents a set ofUnicode charactersDate Yes System.DateTime January 1, 0001 to Represents aDecember 31, 9999 time/date valueObject Yes System.Object Any type can be stored in an The base class of allobject variable types in the .NETuniverse78 CHAPTER 3 n VB 2008 PROGRAMMING CONSTRUCTS, PART I

Cada uno de los tipos numéricos (Short, Integer, etc), así como el tipo de mapa a una Fechaestructura correspondiente en el espacio de nombres System. En pocas palabras, las estructuras son "tipos de valor" asignadoen la pila. Por otra parte, String y Object son "tipos de referencia", es decir, elvariable se le asigna en el montón administrado. Usted examinará todos los detalles de valor y referenciatipos en el capítulo 12, sin embargo, por el momento, sólo tiene que entender que los tipos de valor se puede asignaren la memoria rápidamente y tienen una vida muy fijo y predecible.Declaración de variables e inicializaciónCuando se declara un tipo de datos como una variable local (por ejemplo, una variable dentro de un ámbito miembro), quehacerlo 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 dataTypeDim age As IntegerDim firstName As StringDim isUserOnline As BooleanEnd Sub

Uno de los cambios sintácticos útil que se ha producido con el lanzamiento de la RED. platformis laposibilidad de declarar una sucesión de variables en una sola línea de código. VB6 también apoyó esta capacidad, perola semántica fuera un poco intuitivas y una fuente de errores sutiles. Por ejemplo, en VB6, sino establece explícitamente los tipos de datos de cada variable, las variables no cualificados se establece en el VB6Variante 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últipleslas 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 IntegerDim varTwo As Integer

Si bien estos métodos siguen siendo válidos utilizando Visual Basic 2008, al declarar múltiples variablesen una sola línea, todos ellos se definen en función del tipo de datos especificado. Así, en los siguientesVB 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 IntegerEnd Sub

En una nota final, VB 2008 ahora admite la posibilidad de asignar un valor a una variable directamente en elpunto de la declaración. Para entender el significado de esta nueva pieza de la sintaxis, tenga en cuenta el hecho de queen VB6, que se vieron obligados a escribir lo siguiente:

' VB6 code.Dim i As Integeri = 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 = initialValueDim age As Integer = 36Dim firstName As String = "Sid"Dim isUserOnline As Boolean = TrueEnd Sub

Valores por defecto de los tipos de datosTodos VB 2008 los tipos de datos tienen un valor predeterminado que automáticamente se le asignará a la variable. Lavalores 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 12:00:00 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 amiembros 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 ProgramPublic 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 definidasdentro de un ámbito determinado. Teniendo en cuenta esto, el siguiente método devolverá el valor 0, ya que cada localEntero ha sido asignado automáticamente el valor 0:

Function Add() As IntegerDim a, b As IntegerReturn a + b ' Returns zero.End Function

El tipo de datos jerarquía de clasesEs 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 elentonces, simplemente entender que los tipos en la parte superior de una jerarquía de clases proporcionan algunos comportamientos predeterminados quese otorgan a los tipos derivados. La relación entre estos tipos de sistemas de base puede ser representadocomo se muestra en la Figura 3-7.

Tenga en cuenta que cada uno de estos tipos en última instancia se deriva de System.Object, que define un conjunto demétodos (ToString (), igual a (), GetHashCode (), y así sucesivamente), común a todos los tipos en la base. NETbibliotecas 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 System.ValueType. Descendientesde ValueType se asignan automáticamente en la pila y por lo tanto tienen una vida muy predecibley son muy eficientes. Por otro lado, los tipos que no tienen System.ValueType en su herenciacadena (como System.Type, System.String, System.Array, System.Exception, 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 System.Object y System.ValueType por el momentoser (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), elsiguiente es la sintaxis perfectamente legal, dado que System.Int32 (el VB 2008 entero) con el tiempo derivade System.Object, 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 System.Object.Console.WriteLine(12.GetHashCode()) ' Prints the type's hash code value.Console.WriteLine(12.Equals(23)) ' Prints FalseConsole.WriteLine(12.ToString()) ' Returns the string value "12"Console.WriteLine(12.GetType()) ' Prints System.Int32End Sub

Intrínseca de tipos de datos y la nueva palabra claveTodos 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 variablea su valor predeterminado. Aunque es más engorroso de usar la palabra clave New cuando se crea unavariable 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 completonombre a través de cualquiera de estos métodos:

' These statements are also functionally identical.Dim b2 As System.Boolean = New System.Boolean()Dim b3 As System.Boolean

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

Sub Main()Console.WriteLine("***** Fun with Data Types *****")Console.WriteLine("Max of Integer: {0}", Integer.MaxValue)

Console.WriteLine("Min of Integer: {0}", Integer.MinValue)Console.WriteLine("Max of Double: {0}", Double.MaxValue)Console.WriteLine("Min of Double: {0}", Double.MinValue)End Sub

Además de los MinValue / propiedades MaxValue, un tipo determinado sistema numérico puede definirmiembros adicionales de utilidad. Por ejemplo, el tipo System.Double 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):

Console.WriteLine("Double.Epsilon: {0}", Double.Epsilon)Console.WriteLine("Double.PositiveInfinity: {0}", _Double.PositiveInfinity)Console.WriteLine("Double.NegativeInfinity: {0}", _Double.NegativeInfinity)

Los miembros de System.BooleanA continuación, considere el tipo de datos System.Boolean. La cesión sólo será válida una VB 2008 booleano puede tomares del conjunto {true | false}. Teniendo en cuenta este punto, debe quedar claro que no System.Booleanapoyar una MinValue / conjunto de propiedades MaxValue, sino más bien TrueString / FalseString (que produce lacadena "True " o "Falso", respectivamente):

Console.WriteLine("Boolean.FalseString: {0}", Boolean.FalseString)Console.WriteLine("Boolean.TrueString: {0}", Boolean.TrueString)

Los miembros de System.CharVB 2008 datos de texto se representa por el valor intrínseco de cadena y las palabras clave Char, que son simples

notaciones cortas por System.String y System.Char, los cuales son Unicode en el marco delcampana. 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 asumeestá definiendo un tipo de cadena en toda regla. Sin embargo, para generar una cadena de caracteres de un solo literal quedebe escribirse como un lugar de Char, el carácter entre comillas dobles y virar en una sola "c"después dela cotización de cierre. Si lo hace, asegura que el texto entre comillas dobles literal es representado como un hechoSystem.Char, en lugar de una System.String:

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 estecapítulo) para su proyecto, el compilador de VB 2008 exige que la tachuela en la c sufijo a un tipo de datos Char cuandoasignación de un valor.El tipo System.Char le proporciona una gran cantidad de funcionalidad más allá de la capacidad de mantenerun solo punto de datos de caracteres. Utilizando los métodos comunes de System.Char, que son capaces de determinarsi un carácter dado es numérica, alfabética, un punto de puntuacion, o lo que sea. Parailustran, actualizar Main () con las siguientes afirmaciones:

' Fun with System.Char.Dim myChar As Char = "a"cConsole.WriteLine("Char.IsDigit('a'): {0}", Char.IsDigit(myChar))Console.WriteLine("Char.IsLetter('a'): {0}", Char.IsLetter(myChar))

Console.WriteLine("Char.IsWhiteSpace('Hello There', 5): {0}", _Char.IsWhiteSpace("Hello There", 5))Console.WriteLine("Char.IsWhiteSpace('Hello There', 6): {0}", _Char.IsWhiteSpace("Hello There", 6))Console.WriteLine("Char.IsPunctuation('?'): {0}", _Char.IsPunctuation("?"c))

Como se ilustra en el fragmento de código anterior, los miembros de System.Char tienen dos convenciones de llamada:un solo carácter o una cadena con un índice numérico que especifica la posición de lacarácter a prueba.De análisis de valores de datos de cadenaLos tipos de datos de. NET proporciona la capacidad para generar una variable de su tipo subyacente dado un textoequivalente (por ejemplo, el análisis). Esta técnica puede ser muy útil cuando se desea convertir unbits 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éricovalor. Tenga en cuenta la lógica de análisis siguientes:

' Fun with parsing.Dim b As Boolean = Boolean.Parse("True")Console.WriteLine("Value of myBool: {0}", b)Dim d As Double = Double.Parse("99.884")Console.WriteLine("Value of myDbl: {0}", d)Dim i As Integer = Integer.Parse("8")Console.WriteLine("Value of myInt: {0}", i)Dim c As Char = Char.Parse("w")Console.WriteLine("Value of myChar: {0}", c)

Comprender el tipo System.String

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 Stringpalabras clave en realidad es una notación abreviada para un tipo de verdad en la biblioteca. NET de la clase base, que en estecaso es System.String. Por lo tanto, usted puede declarar una variable de cadena utilizando cualquiera de estosnotaciones:

' These two string declarations are functionally equivalent.Dim firstName As StringDim lastName As System.String

System.String 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 lacadena actual, convertir hacia y desde mayúsculas y minúsculas, y así sucesivamente. Tabla 3-5 se enumeran algunas (perono todos) de los miembros de interés.

Member of String Class Meaning in LifeChars 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 characterdata.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 modificationsReplace() (characters removed or replaced).Split() This method returns a String array containing the substrings in thisinstance that are delimited by elements of a specified Char or Stringarray.Trim() This method removes all occurrences of a set of specified charactersfrom the beginning and end of the current string.ToUpper() These methods create a copy of the current string in uppercase orToLower() lowercase format.

Básicas de manipulación de cadenasTrabajar con los miembros de System.String es como era de esperar. Sólo tienes que crear una variable de cadenay hacer uso de la funcionalidad proporcionada por el operador punto. No ser consciente de que algunos de los miembrosde System.String se comparten los miembros y, por tanto llamó a la clase (en lugar delobjeto) nivel. Suponga que ha creado una nueva aplicación de consola denominada FunWithStrings yactualización Main () de la siguiente manera:

Module ProgramSub Main()Console.WriteLine("***** Fun with Strings *****")Dim firstName As String = "June"Console.WriteLine("Value of firstName: {0}", firstName)Console.WriteLine("firstName has {0} characters.", firstName.Length)Console.WriteLine("firstName in uppercase: {0}", firstName.ToUpper())Console.WriteLine("firstName in lowercase: {0}", firstName.ToLower())Dim myValue As Integer = 3456787Console.WriteLine("Hex vaule of myValue is: {0:X}", myValue)Console.WriteLine("Currency value of myValue is: {0:C}", myValue)End SubEnd Module

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

Pag 117 sigue.

visual basic 2008

Documents