Programación Con Visual Basic 2008 (McGraw-Hill)

Construya aplicaciones .NET 3.5 con la herramienta para negocios RAD de Microsoft 

 Programac  Progra mación ión con

 Visual Basic  Visual 2008

Tim Patrick 

Programación con Visual Basic 2008

Programación con Visual Basic 2008

Programación con Visual Visual Basic 2008 Tim Patrick 

Traducción

Eloy Pineda Rojas Traductor profesional

MÉXICO • BOGOTÁ • BUENOS AIRES • CARACAS • GUATEMALA • MADRID • NUEVA YORK  SAN JUAN • SANTIAGO • SÃO PAULO • AUCKLAND • LONDRES • MILÁN • MONTREAL NUEVA DELHI • SAN FRANCISCO • SINGAPUR • ST. LOUIS • SIDNEY • TORONTO

Director editorial: Fernando Castellanos Rodríguez Editor: Miguel Ángel Luna Ponce Supervisor de producción: Zeferino García García  PROGRAMACIÓN CON VISUAL BASIC 2008

Prohibida la reproducción total o parcial de esta obra, por cualquier medio, sin la autorización escrita del editor.

Educación DERECHOS RESERV RESERVADOS © 2010 respecto a la primera edición en español por McGRAW-HILL INTERAMERICANA EDITORES, S.A. DE C.V.  A Subsidiary of Te  McGraw-Hill  Companies,  Companies, Inc.

Corporativo Punta Santa Fe Prolongaciónn Paseo de la Reforma 1015, Torre A  Prolongació Piso 17, Colonia Desarrollo Santa Fe, Delegación Álvaro Obregón C.P.. 013 C.P 01376, 76, Méxic México, o, D. F. Miembro de la Cámara Nacional de la Industria Editorial Mexicana, Reg. Núm. 736 ISBN: 978-607-15-0248-3

 Authorized translation  Authorized translation of the English English edition edition of Programming Visual Basic 2008. ISBN 9780596518431. © Tim Patrick. is translation is published and sold by permission of O’Reilly Media, Inc., the owner of all rights to publish and sell the same. 1234567890 Impreso en México

109876543210 Printed in Mexico

Para Maki, mi amorosa esposa 

Contenido

Prólogo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xv 1. Introducción a .NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1  Antes de .NET De nuevo, la presentación de .NET El objeto en .NET Las partes de .NET Framework Del código fuente a EXE Temas relacion relacionados ados con Visual Studio y Visual Basic Visual Studio 2008 Resumen Proyecto

1 2 3 7 16 17 18 22 23

2. Introducción a Visual Basic . . . . . . . . . . . . . . . . . . . . . . . . . . 30 La historia de la revolución de Visual Basic Visual Basic de adentro hacia fuera Los fundamentos de la lógica y los datos Tipos de datos y variables Intermedio Comentarios Instrucciones Option Operadores básicos Uso de funciones y subrutinas Condiciones Bucles Creación de procedimientos propios Otras características de control de ujo Eventos y manejador de eventos Espacios de nombres

30 32 32 35 44 44 45 47 49 50 54 57 61 64 66 vii

El espacio de nombres My Resumen Proyecto

69 70 70

3. Presentación del proyecto . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 El Proyec Proyecto to Biblioteca Las necesidades de los usuarios La vida de un proyecto Resumen Proyecto

76 79 83 90 90

4. Diseño de la base de datos . . . . . . . . . . . . . . . . . . . . . . . . . . 95 Bases de datos relacionales SQL Server 2005 SQL Uso de bases de datos en Visual Basic Documentación de la base de datos Resumen Proyecto

95 98 100 107 108 109 109

5. Ensamblados de .NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126 ¿Qué es un ensamblado? ¿Qué hay dentro de un ensamblado? Ensamblados y aplicaciones El espacio de nombres My y los ensamblados Directivas y ensamblados Resumen Proyecto

126 128 131 132 134 136 137

6. Datos y tipos de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151 La naturaleza de los datos en computación Datos en .NET Tipos de datos de Visual Basic Literales Constantes Enumeraciones

viii | Contenido

151 153 158 159 160 161

Variables Convenciones de asignación de nombres a variables y constantes Inferencia de tipo local Operadores Variables estáticas Matrices Tipos que pueden ser nulos Funciones comunes de Visual Basic Resumen Proyecto

162 165 166 167 172 172 175 176 182 182

7. Windows Forms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187 Dentro de una aplicación de Windows Ventanas en .NET Cómo hacer formularios útiles Resumen Proyecto

187 191 210 212 212

8. Clases y herencia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219 Conceptos de programación orientada a objetos Programación orientada a objetos en Visual Basic y .NET Problemas relacionados Resumen Proyecto

219 224 241 244 244

9. Programación funcional . . . . . . . . . . . . . . . . . . . . . . . . . . . 253 Expresiones lambda Inicializadores de objetos Manejo de errores en Visual Basic La naturaleza de los errores en Visual Basic Manejo de errores no estructurado Manejo de errores estructurado Errores no manejados  Administración de errores Resumen Proyecto

253 259 260 260 263 265 267 269 273 274

Contenido |

ix

10. ADO.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277 ¿Qué es ADO.NET? Revisión general de ADO.NET Comparación entre usar y no usar conjuntos de datos Conexión a SQL Server con Visual Studio Interacción con SQL Server en código Transacciones de base de datos Marco de trabajo de la entidad ADO.NET Resumen Proyecto

278 279 282 284 289 292 293 294 294

11. Seguridad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303 Características de seguridad en .NET Criptografía y cifrado Cifrado en .NET Otras características de seguridad Resumen Proyecto

304 304 306 311 312 312

12. Sobrecargas y extensiones . . . . . . . . . . . . . . . . . . . . . . . . . . 330 ¿Qué es la sobrecarga de un operador? ¿Qué puede sobrecargar? Otros problemas con la sobrecarga de operadores Métodos de extensión Resumen Proyecto

330 332 338 340 342 342

13. XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361 ¿Qué es XML? La Regla de XML Contenido XML Uso de XML en .NET .NET:: el viejo estilo Uso de XML en .NET .NET:: el nuevo estilo Resumen Proyecto

x

| Contenido

361 364 365 371 375 378 379

14. Configuraciones de la aplicación . . . . . . . . . . . . . . . . . . . . . . . 392 Una breve historia sobre las conguraciones Conguración en Visual Basic 2008 Resumen Proyecto

392 394 400 401

15. Archivos y directorios . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416 La administración tradicional de archivos de Visual Basic Manipulación de archivos mediante ujo  Administración de archivo con el espacio espacio de nombres My Resumen Proyecto

417 418 424 427 428

16. Genéricos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 433 ¿Qué son los genéricos? Variaciones en las declaraciones de los genéricos Resumen Proyecto

433 436 442 442

17. LINQ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ¿Qué es LINQ? Tipos anónimos LINQ to Objects Expresiones básicas de consulta Conversión de resultados a otras formas Consultas agregadas Expresiones de consulta avanzada LINQ to XML LINQ para datos relacionados con ADO.NET Ejecución diferida Resumen Proyecto

448 448 450 451 453 459 459 460 461 463 468 469 470

18. Interfaz de usuario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 486 Revisión general de GDI+ Selección de un lienzo

487 488

Contenido |

xi

Elección de plumas y pinceles Flujo de texto a partir de la fuente Creación de imágenes Exposición de su verdadero artista Rutas: dibujos en macrovisión Regiones e imágenes Modicaciones elaboradas con transformaciones Mejoramiento de controles mediante el dibujo de propietario  Windows Presentation Presentation Foundation Foundation Mejoramiento de clases con atributos Resumen Proyecto

490 493 497 499 501 502 503 505 507 510 511 511

19. Localización y globalización . . . . . . . . . . . . . . . . . . . . . . . . . 526 Denición de globalización y localización  Archivos de recursos El objet objetoo My My.Resour .Resources ces Localización de formularios dentro de Visual Studio  Adición de recursos fuera de Visual Visual Studio Compilación manual de recursos Otras características de localización Resumen Proyecto

526 527 529 531 534 535 537 538 539

20. Impresión . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 552 Impresión en Windows Impresión en .NET Impresión de un documento Vista previa de impresión Conteo y numeración de páginas Impresión en modo simple Resumen Proyecto

553 554 557 559 561 563 564 564

21. Creación de informes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 581 Opciones de informe en .NET Uso de controles de informe en .NET Resumen Proyecto

xii

| Contenido

581 584 597 597

22. Otorgue licencia a su aplicación . . . . . . . . . . . . . . . . . . . . . . . . 611 Opciones de licenciamiento de software  Acuerdos de licencia Ofuscación El sistema de licenciamiento de biblioteca Resumen Proyecto

611 615 616 618 621 622

23. Desarrollo Web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 642 Cómo funciona Internet Programación de Internet Característica Caracte rísticass de ASP ASP.NET .NET Prueba de ASP ASP.NET .NET Más acerca de eventos Estado y vista de estado Validació alidaciónn de datos Integración de base de datos Base de comunicación de Windows Resumen Proyecto

642 644 645 646 653 654 655 657 658 663 663

24. Adición de ayuda en línea . . . . . . . . . . . . . . . . . . . . . . . . . . 672 Opciones de Windows Online Help Diseño de HTML Help  Acceso a HTML Help Resumen Proyecto

672 674 680 683 683

25. Implementación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 689 ¿Qué elementos participan en la implementación? Métodos de implementación dentro de Visual Studio Resumen Proyecto

689 690 700 700

26. Proyecto completo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 711 El proyecto Biblioteca Flexibilidad de Visual Basic El marco conceptual de la programación Resumen

711 714 716 717

Contenido | xiii

A. Instalación del software . . . . . . . . . . . . . . . . . . . . . . . . . . . 719 B. Acuerdo de licencia de software . . . . . . . . . . . . . . . . . . . . . . . . 722 Índice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 725

xiv | Contenido

Prólogo

¡Bienvenido a Programación con Visual Basic 2008 ! Sé que va a disfrutarlo. Ya lo he leído cinco veces. Es probable que se encuentre ansioso de llegar al capítulo 1, pero le recomiendo que lea este prólogo para asegurarse de que pagó por el libro correcto.

¿Quién debe leer este libro? Escribir un libro es como escribir una aplicación de Visual Basic. Bueno, excepto por la parte acerca de encontrar un editor y trabajar con un guía editorial. Y luego están esas quisquillosas reglas acerca de una redacción correcta. Si nos ponemos a pensar, en realidad son muy diferentes. Pero en una manera, los libros y los programas son similares: ambos se escriben para cumplir las necesidades del usuario. Cuando se escriben aplicaciones de software, las necesidades del usuario orientan la organización y las características del programa nal. Cuando se escribe un libro, como el que está revisando ahora, las necesidades del usuario (ése es usted, el lector) orientan la organización y las características del texto nal.  Así que es con usted en mente que me puse a escribir este libro. Oh, están la fama y el prestigio, pero en realidad se trata de usted. Usted, la persona que busca comprender Visual Basic y .NET Framework, que es sobre el que está construido. Cuando pensaba en sus necesidades, me surgieron estas ideas: Tal vez conozca el programa, tal vez no.

En el mundo de la programación, hay cuatro tipos de personas: 1) quienes ya programan felizmente; 2) quienes no programan, pero aprenderán y les encantará; 3) quienes no programan, pero aprenderán y lucharán con ello; y 4) quienes deben regresar este libro de inmediato al estante. Si se encuentra en uno de los primeros tres grupos, este libro es denitivamente para usted. Creo que cualquiera que pueda dividir una tarea en sus instrucciones básicas paso a paso puede programar con éxito en Visual Basic. Si está inseguro acerca de su capacidad de cuanticar tareas de esta manera, tal vez quiera empezar con un libro sobre conceptos básicos de programación.

xv

Tal vez sepa cómo programar en Visual Basic o .NET, tal vez no.

 Y está bien, porque este libro le enseñará. En la mayor parte de los capítulos se presentan temas importantes para el desarrollo en Visual Basic y .NET, como los conceptos de programación orientada a objetos. O el uso de diferentes tipos de variables disponibles para usted, o la interacción con una base de datos. Si ya sabe cómo usar Visual Basic 6 o anterior, es estupendo, pero no es un prerrequisito. Quiere escribir programas.

Casi todos los libros de programación le enseñan a codicar en incrementos de 10 líneas. Por lo menos, eso es lo que aparece disperso por todas sus páginas. He puesto algunos de estos “fragmentos de código” en este libro. Pero paso mis días escribiendo programas reales, no programas de ejemplo de 10 líneas. Si quiere escribir programas completos, debe aprender usando programas completos. Por eso es por lo que también puse un programa en mi libro (un programa completo). En los siguientes cientos de páginas, desarrollaré un programa real: una base de datos para una pequeña biblioteca) y usted lo escribirá conmigo. Puse todas estas ideas en 26 capítulos fáciles de leer, e hice que McGraw-Hill los pusiera a su alcance para conveniencia de usted. Cuando llegue al índice, habrá aprendido cómo escribir programas completos en Visual Basic y .NET. Será una aventura de programación, ¡así que empecemos!

¿Qué hay en este libro? Como vamos a pasar mucho tiempo juntos, tal vez quiera saber algo acerca de mí. Bueno, mi nombre es Tim Patrick, y durante muchos años viví en la misma calle en que se encontraba el enorme campus de Microsoft. He escrito programas durante 25 años, y en estos días escribo aplicaciones de Visual Basic orientadas a bases de datos personalizadas. Y no estoy solo. Casi todos los desarrolladores de Visual Basic escriben software de negocios. Si eso es lo que hace, o planea hacer, tiene mucha compañía. Mientras recorre las páginas de este libro, leerá acerca de las principales actividades de .NET y Visual Basic que orientan el desarrollo de aplicaciones del consumidor general y en el nivel de negocios. Si planea hacer otro tipo de programación, como desarrollo de juegos, este libro será útil, pero no hablaré acerca de características avanzadas o especializadas como modelos 3D interactivos o transformaciones geométricas. En cada capítulo se analiza un tema importante de la programación, y luego se sigue con una implementación práctica de ese tema: la creación del programa de base de datos Biblioteca. No mostraré cada línea de código en el libro; si lo hiciera, el libro pesaría 25 kilos y costaría cinco mil pesos, más impuestos. Para obtener cada línea de código, tendrá que descargar el código fuente del sitio Web del libro. El código y el libro de texto están unidos en un propósito: entrenarlo en el hábil uso de Visual Basic en la plataforma .NET, de modo que pueda desarrollar las aplicaciones de la más elevada calidad posible. El texto y el código fuente incluyen valiosos recursos que puede usar todos los días en su vida de programación.

xvi | Prólogo

¿Qué hay en el software descargado? Le va a gustar lo que descargue. Contiene todo el código fuente del proyecto de base de datos Biblioteca. Lo que es estupendo es que cuando instala los ejemplos de código fuente, se vuelven parte de Visual Studio. Una vez que están instalados, puede crear un proyecto especíco de un nuevo capítulo desde el menú Archivo → Nuevo proyecto en Visual Studio. El apéndice A tiene todos los detalles de la descarga y la instalación. Escribí el código del proyecto usando Visual Basic 2008 Professional Edition. Algunas partes tal vez no sean compatibles con versiones anteriores del lenguaje .NET. Ninguno es compatible con Visual Basic 6.0 o anterior, de modo que ni se preocupe en probarlo. El código fuente funcionará con cualquier edición de Visual Basic 2008, incluida Express Edition. El código fuente también utiliza SQL Server 2005 para el almacenamiento de su base de datos. Puede usar cualquier edición de SQL Server 2005, incluida Express Edition. En el capítulo 4 se introducen las bases de datos y SQL Server 2005. Si estará usando la base de datos en un entorno de red controlado por el departamento de tecnología de la información, tal vez necesite hablar con el representante de ese departamento acerca de la instalación de la base de datos de ejemplo. El código SQL que uso es muy simple, de modo que debe trabajar sobre versiones anteriores de SQL Server, y podría ajustar fácilmente para que trabaje con Oracle, DB2, Microsoft Access u otros motores comunes de base de datos. También puede usar la próxima versión SQL Server 2008, si la tiene disponible. Puede usar el código fuente descargable para sus propios proyectos, pero por favor déle crédito a quien crédito se merece. Hay un acuerdo de licencia relacionado con el código (consulte el apéndice B), de modo que por favor no venda el software como si fuera suyo. Sólo para estar seguro, he agregado unos cuantos errores difíciles de encontrar. ¡Sólo bromeaba! (¡No, no lo hice!)

Convenciones usadas en este libro Las siguientes convenciones tipográcas se usan en este libro: Cursivas 

Indica nuevos términos, URL, nombres de archivo y extensiones de archivo. Ancho constante

Indica código de computadora en un sentido amplio. Esto incluye todo el código fuente de Visual Basic, contenido HTML y XML, comandos, opciones, código fuente de otros lenguajes y contenido generado por herramientas de Visual Studio. Ancho constante en negritas

Indica comandos u otro texto que el usuario debe escribir literalmente. También se usa para resaltar una sección particular del código. Ancho constante en cursivas

Indica texto que debe reemplazarse con valores proporcionados por el usuario o valores determinados por el contexto. Prólogo | xvii

Este ícono signica un consejo, una sugerencia o una nota general.

Este ícono indica un aviso o precaución.

Uso de los ejemplos de código Este libro está aquí para ayudarle a hacer su trabajo. En general, puede usar el código en este libro en sus programas y documentación. No es necesario que se ponga en contacto con el editor o conmigo para pedir permiso, a menos que esté reproduciendo una parte importante del código. Por ejemplo, escribir un programa que use varios fragmentos de código de este libro no requiere permiso. Vender o distribuir un CD-ROM de ejemplos de libros de McGraw-Hill requiere permiso. Responder una pregunta al citar este libro y poner el código como ejemplo, no requiere permiso. Incorporar una cantidad importante de código de ejemplo de este libro en la documentación de su producto requiere que se apegue a los términos del acuerdo de licencia del software que se encuentra en el apéndice B.  Apreciamos, pero no exigimos atribución. Por lo general, una atribución incluye título, autor, editor e ISBN. Por ejemplo, “Programación con Visual Basic 2008 , por Tim Patrick. Copyright 2010 Tim Patrick, 978-607-15-0248-3”. Si siente que la manera en que usa los ejemplos del código caen fuera del uso limpio del permiso otorgado aquí, siéntase en la libertad de ponerse en contacto con nosotros en [email protected].

¿Cómo ponerse en contacto con nosotros? Por favor, dirija los comentarios y las preguntas relacionadas con este libro al editor: McGraw-Hill Interamericana Editores S.A. de C.V. Prolongación Paseo de la reforma 1015 Torre a pisos 16 y 17. Colonia Desarrollo Santa Fe. 01376 México D.F. 1500 5000 5005 5000 Tenemos una página Web para este libro, donde presentamos una lista de erratas, ejemplos y cualquier información adicional. Puede acceder a esta página en: www.mcgraw-hill-educacion.com  (haga una búsqueda por ISBN, autor o título) Para comentar o plantear preguntas técnicas acerca de este libro, envíe un correo electrónico a:  [email protected]

xviii | Prólogo

Agradecimientos El desarrollo de Programación con Visual Basic 2008  fue una labor que exigió amor de mi parte, y he sido bendecido por contar con quienes compartieron esa labor conmigo. Joan Murray de  Addison-Wesley fue mi editora en la primera edición del libro. John Osborn, de O’Reilly Media se tomó la tarea de guiar la segunda edición. He sido afortunado al trabajar con John en tres diferentes proyectos de libros, y su éxito fue posible gracias a sus atentos esfuerzos. Otros autores y programadores tomaron tiempo de sus trabajos para revisar cada capítulo del libro y señalar sus deciencias, que fueron numerosos antes de su llegada. En especial, deseo dar las gracias a Glenn Berry, Alex Bierhaus, Harry Chen, Ken Getz, Lowell Mauer y Dan Sullivan por sus estupendos comentarios. Cuando llegó el momento de concentrarse en la versión 2008 de Visual Basic, también recibí información fantástica de Chris Williams, Daniel Seara, Ron Petrusha y Sander Gerz. Muchas gracias a Joe Binder, Jay Roxe, Prasadi de Silva y Eric Knox, todos ellos miembros del equipo de Visual Basic en Microsoft. Cada uno de ellos tomó en cuenta una interminable cantidad de preguntas acerca de características esotéricas de Visual Basic y .NET, y proporcionó respuestas llenas de conocimiento, paciencia y gracia. Mi agente, Claudette Moore, siempre merece su propio párrafo en cualquier libro de computación que escriba. En realidad, sería un tema estupendo para una de esas biografías concentradas en agentes literarios que el público siempre está reclamando. No sólo hace un estupendo trabajo en todas las cosas normales de los agentes, sino que también comparte personalmente las alegrías y tristezas de los autores bajo su cargo. Gracias por otro año divertido en los libros. Para Maki, mi esposa, y para Spencer, mi hijo, les doy una ola especial de gracias. Si alguna vez usted pasa tiempo con autores, sabrá lo excéntricos que pueden ser. Pero Maki y Spencer combaten la excentricidad con cuidado y amor, y funciona. La palabra gracias parece tan inadecuada cuando les debo tanto. Gracias a Dios por haberme proporcionado una familia tan tremenda.

Prólogo | xix

CAPÍTULO 1

Introducción a .NET

¡Bienvenido a .NET! También podría decir “Bienvenido al universo”, porque .NET es grande como el universo. Y es complejo. Y está lleno de hoyos negros y otras cosas que no siempre tienen sentido. Pero resulta que es un sistema fantástico (.NET, no el universo) para desarrollar aplicaciones de software. El .NET Framework fue desarrollado en un vacío (a diferencia del universo); Microsoft lo desarrolló, junto con sus lenguajes de desarrollo (sobre todo C# y Visual Basic) para atender varios de los problemas que padecían los desarrolladores y usuarios del software de Windows. Para comprender por completo por qué .NET era necesario, necesitamos hacer un corto viaje por los caminos de la historia de la computadora.

Antes de .NET Las computadoras de propósito general han existido desde mediados del siglo ��. Sin embargo, eran inaccesibles para la mayoría porque: (a) costaban millones de dólares; (b) consumían enormes cantidades de energía eléctrica; (c) el mantenimiento y la programación sólo podían realizarlos especialistas capacitados, y (d) tendían a entrar en conflicto con los muebles de la sala. Treinta años después, IBM desarrolló la idea de la computadora “personal”. Estas computadoras de “escritorio” representaron un gran avance en tecnología, pero sólo una minoría las usó alguna vez. Seguían siendo costosas (miles de dólares) y el mantenimiento y la programación aún requerían una importante inversión en entrenamiento. Las PC de IBM aún se veían abominables  junto a los muebles de la sala. Luego surgió la Macintosh de Apple. Con su brillante diseño y su funcionalidad amigable, llevó la alegría de la computación a las masas. Y aunque la programación no siempre era sencilla, brindó agradables resultados. No maravilla que Microsoft decidiera copiar (perdón, quise decir mejorar) su funcionalidad.

1

Microsoft Windows 1.0 trajo un mayor nivel de capacidad de uso a la plataforma de computación de IBM/Intel. Pero no era un viaje gratis para los programadores. El desarrollo de MSDOS ya era lo suficientemente difícil sin la adición de los “mensajes emergentes” y las cientos de llamadas a la interfaz de programación de aplicaciones (API, Application Programming Interface) que necesitaban los programas de Windows. Visual Basic 1.0, presentado en 1991, simplificó enormemente el proceso de desarrollo, pero con el advenimiento de los sistemas de 32 bits, los componentes ActiveX y COM, además de Web, aun los programadores de VB se sentían abrumados. En todos los años de la década de 1990 la situación sólo pareció empeorar. Microsoft vio aumentada la competencia en la forma del lenguaje Java TM y el sistema operativo Linux. Los hackers estaban explotando los desbordamientos de búfer y otros problemas de seguridad presentes en la plataforma de Windows. Los usuarios experimentaban múltiples problemas que surgían de estándares en conflicto, tecnologías que competían por la integración de datos, un registro que no hacía más que crecer y el “infierno de las DLL”. Frustrados, un grupo de usuarios de Excel prendió fuego a todo el campus de Microsoft en Redmond. No todo iba tan mal. Pero Microsoft vio que necesitaba atender los problemas de desarrollo general del software y del uso de su amada plataforma Windows. Su solución llegó en la forma de .NET Framework.

De nuevo, la presentación de .NET Cuando Microsoft anunció sus planes de crear .NET, sorprendió a muchos desarrolladores, sobre todo a los de Visual Basic, que lo vieron como un gigantesco paso en retroceso al “rápido desarrollo de aplicaciones”. Pero el lanzamiento de .NET Framework versión 1.0 brindó en 2002 muchos beneficios necesarios: .NE introdujo un entorno de programación unificado

Todos los lenguajes compatibles con .NET se compilan en un “lenguaje intermedio de Microsoft” antes de ensamblarse en código máquina específico de la plataforma. Visual Basic, C# y otros lenguajes de .NET son envolturas alrededor de este “lenguaje” .NET común. Como todos los compiladores compatibles con .NET hablan el mismo lenguaje básico, ya no experimentan los innumerables conflictos entre datos y lenguaje inherentes de otros sistemas basados en componentes de lenguaje cruzado como COM. La versión .NET de Visual Studio también unificó la interfaz estándar de usuario que deja que los programadores creen código fuente. .NE comprometió a los desarrolladores con las tecnologías orientadas a objetos

.NET no sólo abarca por completo el paradigma de la programación orientada a objetos, sino que todo en .NET está contenido en un objeto: todos los valores de datos, todos los bloques de código fuente y los detalles internos de todos los eventos iniciados por el usuario. Todo aparece en el contexto de un objeto.

2

| Capítulo 1: Introducción a .NET

.NE simplificó la programación en Windows 

La programación en Visual Basic antes de .NET era muy fácil, hasta que llegaba el momento de interactuar con una de las bibliotecas API, algo que sucedía con mucha frecuencia en la programación profesional. Con .NET casi todas las API de uso regular se reemplazan con una jerarquía de objetos que proporciona acceso a muchas características comunes necesarias en Windows. Debido a que la jerarquía es extensible, otros vendedores pueden agregar nueva funcionalidad sin alterar el marco conceptual existente. .NE mejoró la seguridad

Los usuarios y administradores pueden establecer ahora reglas de seguridad para diferentes características de .NET, para limitar el daño que pueden provocar los programas maliciosos. El entorno “administrado” de .NET también resuelve los problemas de desbordamiento de búfer y fugas de memoria mediante características como asignación sólida de tipos y recolección de basura. .NE mejoró la productividad del desarrollador mediante estándares

.NET Framework está construido sobre muchos estándares nuevos y existentes (y además los usa), como XML y SOAP. Esto mejora el intercambio de datos no sólo en la plataforma de Windows, sino también en interacciones con otras plataformas y sistemas. .NE mejoró el desarrollo de aplicaciones Web

Hasta antes del arribo de .NET, gran cantidad del desarrollo de aplicaciones Web se realizaba mediante lenguajes de creación de secuencias de comandos. .NET trajo el poder del desarrollo compilado, de escritorio, a Internet. .NE simplificó la implementación de aplicaciones

Si .NET está instalado en un sistema, para lanzar un programa basta con copiar su archivo EXE al sistema de destino (aunque un programa de instalación es mucho más amigable con el usuario). Características como implementación lado a lado y de ClickOnce, además de la eliminación de los conflictos de versión de archivos y el “infierno de las DLL” (la presencia de varias versiones de la misma DLL en un sistema, o la incapacidad de eliminar una versión de una DLL), simplificaron en gran medida la implementación de aplicaciones Web y de escritorio. Si no comprendió algunos de los términos empleados en esta sección, no hay problema. Los encontrará de nuevo, con explicaciones, en capítulos posteriores.

El objeto en .NET Para comprender totalmente el desarrollo del software en .NET, debe entender qué es un objeto. (Si está familiarizado con la programación orientada a objetos, puede omitir lo siguiente y pasar a la próxima sección, aunque se perderá un contenido estupendo.) A pesar de que parte de la información de esta sección también aparece en el capítulo 8, es tan importante analizar .NET que una parte de ella también aparecerá aquí.

El objeto en .NET |

3

Objetos y datos Desde el punto de vista de la programación, una computadora realiza cuatro tareas básicas: � Almacena datos  en su área de memoria. � Da soporte al procesamiento de datos   mediante operaciones básicas, incluidas adición y sustracción, álgebra booleana y manipulación de cadenas de texto. � Permite que el usuario interactúe con los datos  almacenados en su memoria. � Proporciona una manera de introducir y extraer datos  de la memoria mediante dispositivos de entrada y salida tales como teclados e impresoras, y con medios de almacenamiento de datos como discos duros. La esencia de estas cuatro actividades son los datos . El objetivo de la existencia de las computadoras es la manipulación de datos. Los sistemas operativos proporcionan la base par a estas actividades, pero son las aplicaciones de software las que hacen que estas características (la capacidad de manipular datos) sean reales y tengan algún significado para el usuario. Los lenguajes de programación de alto nivel son las principales herramientas usadas para desarrollar estas aplicaciones, cada una de las cuales usa algunos métodos generales para que las características de manipulación de datos queden disponibles para el programador. De regreso a los felices días del desarrollo del lenguaje ensamblador, si conocía la dirección en memoria de una pieza de datos, podía acceder a ella y manipularla de manera directa. En las primeras versiones de BASIC y en casi todos los demás lenguajes “procedimentales”, se accedía a los datos mediante variables .  A medida que aumentó la complejidad de los lenguajes, junto con sus objetivos, también lo hizo la concepción de los datos. En el lenguaje LISP (List Processing, procesamiento de listas, o “Lots of Irritating Silly Parentheses”, gran cantidad de paréntesis irritantes y tontos), cualquier valor de datos existía dentro de una lista  o un conjunto de datos más largo. Pero en los lenguajes de .NET, los datos se ven a través del objeto. Los objetos son colecciones de valores de datos y código fuente relacionado. Mientras que en los antiguos dialectos de BASIC, cada elemento de datos era más o menos independiente a través de su variable con nombre, los valores de datos relacionados en los lenguajes de programación orientada a objetos pueden agruparse en objetos. La implementación de objetos a menudo incluye código fuente diseñado para manipular los valores de los datos en ese obj eto. Por lo general, los objetos representan algo que en ocasiones tiene una contraparte en la vida real, sea física o conceptual. Por ejemplo, su código puede incluir un objeto Casa que tiene campos  de datos o propiedades  para la dirección, el color de la pintura exterior y el número de personas que viven en la casa. El código fuente asociado podría manejar esos datos; un método Pintura podría modificar el valor de color empleado para la pintura exterior.  A los datos y elementos de código dentro de un objeto se les denomina miembros . Algunos miembros están ocultos dentro del objeto y sólo puede accederse a ellos mediante el código fuente del objeto. Otros miembros son más públicos; cualquier código de su aplicación puede usarlos, no sólo el subconjunto de código de su aplicación que se encuentra dentro del objeto. Considere que una televisión es un objeto (véase la figura 1-1). 4

| Capítulo 1: Introducción a .NET

Vista exterior

Vista interior

Figura 1-1. Una V es un objeto, no sólo objetable.

Por lo general, es fácil usar los miembros públicos de una TV: la perilla de encendido, el selector de canales, el control de volumen, etc. Son los conductos mediante los cuales el usuario controla los valores de datos de la TV (su salida de video y audio). También hay miembros ocultos dentro de la TV; podría usar estos miembros para mejorar la calidad de imagen y sonido, aunque esto sería una mala idea para la mayoría de los usuarios. No querrá meterse con los elementos internos de su televisor, créame. De la misma manera, un objeto no querrá que código externo al objeto se mezcle con sus miembros internos, excepto si lo hace a través de los miembros públicos . No me preocupa la manera en que la TV funciona internamente, siempre y cuando obtenga las imágenes y el sonido usando los controles (encendido, canales, volumen).

Objetos e interfaces Los miembros públicos de un objeto representan su interfaz . Si el código externo del objeto quiere manipular los datos que pertenecen a ese objeto, utiliza los miembros de la interfaz. No tiene que imaginar los miembros ocultos o la manera en que funcionan, y eso es correcto. Sobre todo, es correcto si esos miembros internos cambian alguna vez por una razón, lo que sucede con más frecuencia de lo que se imagina. Considere la manera en que los elementos internos de la TV han cambiado en los últimos 30 años. He aquí un dibujo de la TV que mi familia tenía cuando era niño. Compárela con las TV de panel plano modernas de hoy en día (véase la figura 1-2). La TV de mi familia era estupenda. Tenía un radio estereofónico de alta fidelidad, una tornamesa que reproducía discos de 33 1/3, 45 y 78 rpm, y una pantalla grande de 19 pulgadas en blanco y negro, con un despliegue claro como un cristal. Dos niños podían ocultarse tras ella y jugar a las escondidas. Y mi amigo que tenía el mismo modelo afirmaba que podía dibujar líneas permanentes realmente asombrosas en la pantalla con un imán. ¿A quién le importaba que los paneles de las bocinas parecieran una alfombra gastada? ¿A quién le importaba que la unidad ocupara hasta 30% del espacio de la sala? ¿A quién le importaba que pudieran cocinarse salchichas sobre ella por el calor que generaban los bulbos? Era más que una TV; se trataba de un centro de entretenimiento . El objeto en .NET |

5

La TV de mi niñez

Una cosa novedosa

Figura 1-2. ¿Son en realidad televisores? 

 Ahora compárela con la sosa pantalla plana de la derecha. Si la ve de cerca, notará que la interfaz de la TV no ha cambiado mucho en tres décadas. Aún tiene controles para encendido y selección de canales (aunque ya han desaparecido los controles para líneas horizontales y verticales). Lo que ha cambiado es la configuración interna. Ya se fueron los bulbos que zumbaban, todos ellos reemplazados con transistores eficientes y componentes de estado sólido. Pero no tiene mucha diferencia para el espectador, porque la interfaz pública sigue siendo la misma. En la programación orientada a objetos, éstos desarrollan su trabajo de la misma manera. Siempre y cuando la interfaz pública siga siendo la misma, pueden cambiar el código actual del objeto y el sistema de almacenamiento de datos interno (a lo que se le conoce también como implementación del objeto), pero no tiene impacto en la aplicación general.

Objetos e instancias La interfaz y la implementación de un objeto en realidad sólo representa su diseño; hay partes que el programador crea mediante el código fuente. Existen incluso antes de que se compile el programa y se instalen en la computadora del usuario. En realidad, en este nivel, los objetos ni siquiera son conocidos como objetos. En la mayoría de los lenguajes (incluido Visual Basic), la palabra clase  indica la implementación de la interfaz de un objeto. Una vez que su aplicación está instalada en una computadora y se inicia, el código crea instancias  de la clase para almacenar datos reales en memoria. Estas instancias son los objetos reales del desarrollo de la programación orientada a objetos. Dependiendo de la manera en que se escribe su código, podría usarse la implementación de una sola clase para crear uno o cientos de objetos en memoria al mismo tiempo. 6

| Capítulo 1: Introducción a .NET

En .NET, todo su código y sus valores de datos aparecen dentro de objetos. Casi todo lo que ve en un programa en ejecución es un objeto: un formulario de Windows es un objeto; un control de cuadro de lista en ese formulario es un objeto, y un solo elemento en ese cuadro de lista es un objeto.

Las partes de .NET Framework Por tanto, ahora sabe todo acerca de los objetos, y tal vez esté pensando que es momento de poner este libro en la pila y empezar a programar. Pero aún falta analizar algunas partes de .NET Framework. Esas partes se muestran hasta el hartazgo en la documentación de .NET, y todos tienen un acrónimo de tres letras.

El motor común de tiempo de ejecución del lenguaje En el centro de .NET Framework está el motor común de tiempo de ejecución del lenguaje  (CLR, Common Language Runtime), llamado así no porque sea común u ordinario, sino porque todos los lenguajes habilitados por .NET lo comparten en común. Todo lo que hace en un programa de .NET está administrado por un CLR. Cuando cree una variable, dé las gracias a CLR y su sistema de administración de datos. Cuando diga adiós a una pieza de datos, dé las gracias a CLR y la manera en que administra  la liberación de datos mediante su sistema de recolección de basura. ¿Observó la manera en que la palabra administra  sigue apareciendo en estas frases? De seguro mi editor sí lo observó. Pero “administra” es la palabra exacta, porque es lo que hace CLR. En realidad, al software escrito por .NET Framework se le llama código administrado. Cualquier código que cae fuera del control de CLR, incluidos los componentes COM (ActiveX) usados por su aplicación .NET, es conocido como código no administrado. CLR se parece al Aeropuerto Internacional de Los Ángeles. Si alguna vez ha estado en LAX, sabe que hay gran cantidad de actividades. Los aviones llegan y salen cada minuto. Los automóviles llegan y salen por miles de la carretera de dos niveles y las estructuras del estacionamiento central. Las personas y los carteristas se desplazan constantemente entre las ocho terminales principales y la enorme terminal internacional. Pasan muchas cosas, pero gran parte de ello es administrado. Los aviones no pueden despegar sin aprobación de la torre de control. Los puntos de acceso y las compuertas administran las carreteras de acceso y los lugares de estacionamiento.  Agentes amigables y corteses administran el flujo de pasajeros y carteristas en las áreas seguras de la terminal. Las estructuras de control y administración ubicadas en LAX aseguran un flujo ordenado y seguro de personas entre sus aviones y la ciudad de Los Ángeles. Las estructuras de control y administración del CLR aseguran un flujo ordenado y seguro de datos entre el código .NET y el resto de la computadora o la red conectada. Tal vez le gustaría saber el secreto de la manera en que el CLR puede procesar programas escritos en cualquier lenguaje .NET, incluidos Visual Basic, C# y FORTRAN. Igual pasa con los competidores de Microsoft. En realidad lo saben, porque no es un secreto. Todos los lenguajes compatibles Las partes de .NET Framework |

7

con .NET convierten su código fuente (lo compilan) en lenguaje intermedio de Microsoft  (MSIL, MicroSoft Intermediate Language, que suele pronunciarse “misil” y que se abrevia con frecuencia sólo como IL). Para quienes estén familiarizados con el lenguaje ensamblador, se parece mucho a éste. Para quienes no estén familiarizados con él, parece un conjunto de galimatías. Por ejemplo, he aquí algún código fuente de Visual Basic para una aplicación de consola   (un programa que funciona con texto y que no es de Windows, como los viejos programas de MS-DOS) que simplemente da salida a las palabras “Hola, mundo” de un procedimiento llamado Main: Module Module1 Sub Main( ) Console.WriteLine("Hola, mundo.") End Sub End Module

Ése es todo el programa de .NET. Cuando el compilador de Visual Basic lo convierte en MSIL, el procedimiento Main tiene este aspecto (ligeramente modificado, para que se acomode a la página): .method public static void Main( ) cil managed {   .entrypoint .custom instance void [mscorlib]System. STAThreadAttribute::.ctor() = ( 01 00 00 00 ) // Code size 11 (0xb) .maxstack 8 IL_0000: ldstr "Hola, mundo." IL_0005: call void [mscorlib]System.Console::WriteLine(string) IL_000a: ret } // end of method Module1::Main

Sí, todo un galimatías. Pero es correcto, porque satisface los requisitos de la Asociación Internacional de Libros de Cómputo de que todos los capítulos 1 incluyan el ejemplo de código “Hola, mundo”. Además, el CLR lo comprende, y eso es lo que realmente cuenta en .NET. Siempre y cuando tenga su código en IL, .NET lo procesará. El compilador de Visual Basic sólo genera el IL automáticamente. Otros compiladores de lenguaje .NET, incluido C#, también producen IL. Incluso puede escribir su propio código IL, pero es probable que esté leyendo el libro equivocado para eso. Sólo ponga a descansar su mente, éste será el último fragmento de IL que verá en este libro.

La especificación de lenguaje común Los lenguajes que aseguran que son compatibles con .NET no pueden afirmarlo por ninguna de las viejas razones. En realidad tienen que ser compatibles con .NET y su funcionamiento. Esto lo hace mediante la especificación de lenguaje común  (CLS, Common Language Specification). La CLS define un conjunto mínimo de características que un lenguaje debe implementar antes de que se considere compatible con .NET o, más exactamente, con CLS. Un lenguaje puede rebasar ese mínimo, si lo desea, y .NET incluye muchas opciones adicionales sobre las que pueden construirse características específicas del lenguaje. Un lenguaje que 8

| Capítulo 1: Introducción a .NET

sólo implementa las funciones mínimas especificadas de CLS tal vez no pueda interactuar por completo con componentes que exceden la especificación mínima. Por supuesto, Visual Basic es compatible con CLS, y en realidad supera ese mínimo.

El sistema común de tipos Debido a que CLR está controlando de todas maneras su código fuente, Microsoft pensó que sería bueno hacer que controle también los datos del código fuente. Para esto, .NET Framework utiliza su sistema común de tipos  (CTS, Common Type System), que define todos los tipos y los mecanismos de datos esenciales usados en los programas de .NET. Esto incluye todos los tipos numéricos, de cadena y booleanos. También define el objeto, la unidad esencial de administración de datos en .NET. El CTS divide todos los objetos en compartimientos. El primero de éstos, llamado tipos de valor , almacena datos reales en el compartimiento. Si tiene un valor entero de 32 bits, se coloca en ese compartimiento de tipo de valor, listo para su uso inmediato. El otro compartimiento contiene tipos de referencia . Cuando observa en este compartimiento, se distingue un mapa que le indica dónde encontrar los datos reales en algún otro lugar de la memoria de la computadora.  Al parecer, los tipos de valor son más fáciles de usar, y en realidad lo son, pero tienen algunas restricciones no impuestas a los tipos de referencia. Los programas y componentes escritos con el estándar CTS pueden intercambiar datos entre sí, sin obstáculos ni limitaciones. (Algunos tipos de datos de .NET caen fuera de los tipos “esenciales” de CTS, pero necesita evitarlos cuando quiera interactuar específicamente con componentes que sólo pueden usar los tipos esenciales de CTS.) Cuando escriba sus aplicaciones en Visual Basic, casi todo su código aparecerá en clases . Las clases son tipos de referencia que incluyen valores de datos y código asociado. Los valores de datos incluidos en una clase son, con más frecuencia, los tipos de datos esenciales de CTS, pero también pueden contener objetos que usted designe en cualquier otro lugar de su aplicación. Visual Basic también incluye estructuras , el hermano más débil pero rápido de las clases. Las estructuras implementan tipos de valor, y también incluyen datos y código. Las clases y estructuras sólo son dos tipos de datos/código disponibles en Visual Basic. Las inter faces  son esqueletos de clases y estructuras; incluyen detalles de diseño de lo que debe aparecer en una clase o estructura relacionada, pero no incluyen ninguna implementación real o código que funcione. Los delegados   definen una “firma” de procedimiento sin implementación, y se usan para dar soporte a eventos , que son las acciones (iniciadas por el usuario, por el sistema operativo o por su código) que le dicen a su código “¡Ponte a trabajar ahora!” Las nutrias marinas  son mamíferos acuáticos que están curiosamente relacionados con las comadrejas y que prefieren comer erizos de mar. Los módulos  son bloques de código y datos, pero, a diferencia de las clases y estructuras, no pueden crear objetos independientes a partir de ellos. Las enumeraciones   agrupan un conjunto de valores de enteros relacionados, generalmente para usarlo como listas de opciones. En la terminología de .NET, todos estos términos (clase, estructura, interfaz, delegado, módulo y enumeración, pero no nutria marina) son conocidos de manera colectiva como tipos . Tal vez ya sepa Las partes de .NET Framework |

9

que .NET tenía algunos elementos confusos; no compraría un libro sobre él si fuera fácil. Pero a pesar de toda la tecnología compleja, es ésta simple palabra, tipo, la que causa la mayor confusión. Tal vez experimentará angustia en todo este libro cada vez que la lea. El problema es que resulta demasiado general. No sólo alude a estos elementos centrales del CTS, sino que también se usa cuando se habla sólo de tipos de valores específicos de Visual Basic (con más frecuencia llamados “tipos de datos” de Visual Basic). El apodo de las estructuras es “tipos definidos por el usuario”, otro uso confuso de “tipo”. Los programadores que usaron Visual Basic antes de su encarnación de .NET también recuerdan a “Tipo” como la instrucción de lenguaje usado para crear tipos definidos por el usuario. ¡Nooo! Microsoft debió usar alguna palabra diferente de tipo para el mundo de clases, interfaces, enumeraciones, etc. “Plátano” hubiera sido una mejor opción porque sólo en ocasiones se usa para analizar el software. Pero “tipo” es  la palabra, de modo que mejor vaya acostumbrándose a verla. Trataré de incluir la mayor cantidad de contexto posible cuando use la palabra en este volumen. Por lo general, los miembros de un tipo suelen ser simples campos de datos y procedimientos de código. Es decir, una clase puede incluir una clase anidada , si la necesita. Sólo ciertos tipos dan soporte a anidamiento (consulte el capítulo 8 para conocer más detalles; en ese capítulo también se expondrán los niveles de acceso). Cada miembro tiene un nivel de acceso que indica cuál código puede usar. Hay cinco niveles de acceso, que van de públicos  (cualquier persona y sus hermanos pueden usar el miembro) a privados  (tiene que estar dentro del tipo para saber que está allí). En el capítulo 6 se analiza el sistema de tipos de .NET con mayor detalle, así como la información que obtiene de clases, estructuras y otras frutas.

Bibliotecas de clases de .NET Las computadoras son en realidad muy estúpidas. Mientras que yo puedo contar hasta 17, una computadora llega hasta 1; sólo conoce los dígitos 0 y 1. La CPU incluye un conjunto de operadores simples empleados para manipular los dígitos 0 y 1, y unos cuantos operadores más que comparan los 1 y 0 de maneras complejas. El último gran truco de la computadora es su capacidad de introducir 0 y 1 en la memoria, y de extraerlos de ella, pero lo logra de manera espectacular. Seguramente hace estas cosas casi a la velocidad de la luz, aunque ¿puede calcular π a 3 millones de posiciones decimales? Bueno, en realidad puede hacerlo. Las computadoras no saben nada acerca de las letras del alfabeto, y en realidad sólo pueden manejar los dígitos 0 y 1, pero aquí estoy usando una computadora para escribir un libro que ganará premios. Es la capacidad de combinar los valores de datos y operadores de 1 bit en bibliotecas  de funcionalidad cada vez más compleja lo que hace que las computadoras resulten útiles.* .NET Framework está basado en décadas de funcionalidad cada vez más compleja. Cuando instala .NET Framework, el CLR y su sistema de tipos asociado representa el núcleo del marco * Si quiere leer un libro realmente fascinante acerca de cómo se forman las operaciones complejas de software y hardware a partir de los usos más básicos de 0 y 1, lea Code: Te Hidden Language of Computer Hardware y Software , de Charles Petzold (Microsoft Press).

10

| Capítulo 1: Introducción a .NET

conceptual. En sí mismo, éste incluye toda la funcionalidad básica necesaria para dejar que sume 2 y 2 y obtenga correctamente 4. Y como desarrollador de aplicaciones de negocios, usted dedica mucho tiempo a hacer eso. Pero ¿qué pasa si quiere hacer algo más complejo, algo que sabe que algún otro programador ya ha hecho, como ordenar una lista de nombres o dibujar un círculo de colores en un formulario? Para obtener esa respuesta, vaya a las bibliotecas de clases , las .NET Class Libraries. Estas bibliotecas, instaladas con el marco conceptual, incluyen gran cantidad de funcionalidad escrita de antemano (y cada vez más compleja) que no tiene que crear desde cero. Hay dos bibliotecas de clases en .NET: la biblioteca básica de clases  (BCL, Base Class Library) y la biblioteca de clases de Framework  (FCL, Framework Class Library). La BCL es más pequeña y contiene las características más esenciales que no pueden faltar en un programa. Incluye sólo las clases que son obligatorias para dar soporte a aplicaciones en el marco conceptual, si Microsoft fuera a llevar, por decir algo, el marco conceptual a Linux. La FCL es más grande e incluye todo lo demás que Microsoft considera que le gustaría tener en sus programas, pero que no era absolutamente esencial tener en la BCL. Ni siquiera pregunte cuántas clases hay en la FCL; no querrá saberlo. Apuesto a que ni siquiera Microsoft conoce realmente el número completo. Estoy convencido de que esos malvados bromistas de Microsoft han incluido clases de broma en la FCL, pero están enterradas de manera tan profunda que pocos programadores las han encontrado. Con miles (sí, ¡miles!) de clases, enumeraciones, interfaces y otros tipos incluidos en las BCL y FCL, pensaría que sería difícil encontrar sólo la clase que necesite. Pero no es tan difícil, al menos no tan abrumadoramente difícil. .NET Framework incluye una característica llamada espacios de nombres . Todos los tipos en .NET aparecen en una jerarquía (estructura en forma de árbol), que incluye sólo unas cuantas entradas en la raíz. Cada nodo de la jerarquía es un espacio de nombres. Usted identifica de manera única cualquier clase u otro tipo en las bibliotecas al asignar un nombre a todos los espacios de nombre, de la raíz hacia el espacio de nombres local que contiene la clase, separando cada nodo con un punto ( .).  A diferencia de la mayor parte de las jerarquías, cuyas ramas empiezan en un solo nodo raíz, la  jerarquía de espacios de nombres de .NET tiene varios nodos raíz. El espacio de nombres raíz más largo recibe el nombre System. Incluye muchas clases, pero también varios nodos de jerarquía de la siguiente capa (espacios de nombres). Debido a que el marco conceptual incluye características para el desarrollo de aplicaciones de Windows y Web, hay espacios de nombres que contienen las características de desarrollo específicos de Windows y Web. Éstos aparecen dentro del espacio de nombres System, y se les denomina Windows y Web. Todo el código relacionado con formularios en pantalla en el espacio de nombres Windows aparece en el espacio de nombres Forms, y dentro de éste se encuentra la clase real que implementa un formulario, denominado Form. En la figura 1-3 se presenta una imagen de este subconjunto de espacios de nombres. En Visual Basic se identifica una clase al calificarla con todos sus espacios de nombres, a partir de la raíz. La clase Form tiene el siguiente nombre plenamente calificado:   System.Windows.Forms.Form

Las partes de .NET Framework |

11

= Espacio de nombres

System

= Clase

Web Windows Forms Form

Figura 1-3. Una jerarquía de espacios de nombres y clases.

Todas las clases y los tipos existen en algún lugar de la jerarquía, aunque no todas las clases descienden de System. Muchas de las características de soporte específicas de Visual Basic aparecen en el espacio de nombres Microsoft.VisualBasic, que tiene “Microsoft” como nodo raíz en lugar de “System”. Cuando crea proyectos nuevos en Visual Basic, el nombre del proyecto es, como opción predeterminada, un nuevo nodo de nivel superior en la jerarquía. Si crea una nueva aplicación de Windows llamada WindowsApplication1, el formulario “Form1” predeterminado tiene el siguiente nombre plenamente calificado:   WindowsApplication1.Form1

Este nuevo espacio de nombres de la aplicación no sólo es un apéndice de segunda clase que cuelga del espacio de nombres System. Está plenamente integrado en la jerarquía completa de espacio de nombres de .NET; el espacio de nombres WindowsApplication1 es un nodo raíz, al igual que los nodos raíz System y Microsoft. Visual Basic incluye características que le permiten modificar el espacio de nombres predeterminado para su aplicación, o coloca una de las clases de la aplicación en un espacio de nombres específico. Incluso puede colocar las clases de su aplicación en la rama del espacio de nombres System. Al cambiar WindowsApplication1 a System.MiSuperApl se mueve Form1 a:   System.MiSuperApl.Form1

Si su aplicación es, en realidad, una biblioteca o un componente destinado para usar en programas, las clases de su aplicación aparecerán en el espacio de nombres que especifique cuando el otro programa cargue su componente en el área de su aplicación. Su código parecerá parte de los espacios de nombres proporcionados por Microsoft. ¿No es estupendo?  Aunque puede agregar sus clases al espacio de nombres System, terminará con la misma molestia que otros programadores de .NET. Se supone que el espacio de nombres System es para las características del “sistema” (léase: proporcionadas por Microsoft), y eso es todo. Además, es posible que dos vendedores usen la misma ruta del espacio de nombres. Así que, para evitar posibles conflictos de espacio de nombres  y   miradas indiscretas de otros programadores, debe asignar a las clases de su aplicación el siguiente nombre:   NombreEmpresa.NombreAplicación.NombreClase

12

| Capítulo 1: Introducción a .NET

Una sola clase u otro tipo no puede dividirse entre varios espacios de nombres, aun dentro de la misma rama de una jerarquía. Sin embargo, dos clases o tipos pueden compartir un nombre común en diferentes espacios de nombres, aun dentro de la misma rama. Todas las clases de la BCL y la FCL aparecen entremezcladas en toda la jerarquía de espacios de nombres. Esto significa que no necesariamente sabe si una clase determinada es de la BCL o la FCL. Para ser franco, en realidad no importa; a su código no le interesa de qué biblioteca proviene una clase, siempre y cuando esté disponible para usarla en la estación de trabajo del usuario.  Justo antes del lanzamiento de Visual Studio 2008, Microsoft anunció que pondría a disposición de todos el código fuente de gran parte de la biblioteca de clases de Framework, versión 3.5, para que los desarrolladores lo revisen. Esto significa que los programadores que quieren saber cómo ordena Microsoft una lista de nombres en memoria o dibuja un círculo de colores en un formulario obtendrán por lo menos un vistazo parcial de la manera en que se hace.

Ensamblados y manifiestos Un ensamblado es una “unidad de implementación” de las partes de la aplicación o biblioteca .NET. En 99.9% de los casos, un ensamblado es simplemente un archivo ejecutable de .NET (un archivo .exe ) o una biblioteca de clases de .NET y de otros tipos (un archivo .dll ). Es posible dividir un ensamblado entre varios archivos, pero por lo general se dedica un archivo a un ensamblado. Lo que convierte a un archivo .exe  o .dll   ordinario en un ensamblado es la presencia de un manifiesto. En el caso de ensamblados de un solo archivo, el manifiesto aparece en el archivo; también puede aparecer en un archivo independiente. El manifiesto es un fragmento de datos que presenta una lista de detalles importantes acerca del ensamblado, incluido su nombre, información de versión, datos culturales predeterminados, información sobre ensamblados y tipos externos de referencia, y una lista de todos los archivos contenidos en el ensamblado. El CLR no reconocerá un ensamblado sin su manifiesto, de modo que no lo pierda. Los ensamblados pueden incluir un nombre fuerte  opcional. Esto ayuda a asegurar la integridad y autenticidad de un ensamblado mediante una firma digital adjunta al manifiesto. El nombre fuerte utiliza criptografía de clave pública para garantizar que el ensamblado es único y no se ha modificado. Visual Studio y .NET Framework incluyen herramientas que permiten agregar un nombre fuerte a un ensamblado. Cuando implemente su aplicación, por lo general colocará todos los archivos del ensamblado, de configuración y relacionados y específicos de su aplicación en el directorio de instalación de la aplicación, al igual que en los días del Jurásico antes de .NET. Los ensamblados compartidos que están diseñados para que los use más de una aplicación en una sola máquina puede almacenarse en la caché global de ensamblados  (GAC, Global Assembly Cache ). Todos los ensamblados colocados en la GAC deben tener nombres fuertes. Algunos sistemas permiten que sólo los administradores del sistema agreguen ensamblados a la GAC.

Metadatos y atributos Los ensamblados están determinados por la letra m. Además de manifiestos y miembros de tipos, también pueden contener metadatos . El código de la aplicación y los elementos de datos Las partes de .NET Framework |

13

almacenados en un ensamblado son paralelos al código y los elementos de datos encontrados en el código fuente relacionado de Visual Basic; para cada tipo y miembro de su código fuente, hay código ejecutable asociado en el ensamblado implementado. Esto tiene sentido y no cambia mucho de las implementaciones previas a .NET. La diferencia es que ahora el compilador de Visual Basic adjunta información adicional (metadatos) a cada tipo y miembro del ensamblado. Estos metadatos documentan el nombre del contenido asociado, información acerca de los tipos de datos requeridos, información sobre la herencia de clase del elemento, y permisos de seguridad antes de que el usuario u otro software usen el elemento. Su código fuente de Visual Basic puede mejorar los metadatos de cualquier elemento de su ensamblado mediante atributos . Los metadatos generados por un atributo son más que sólo algún número de ID. Los atributos implementan clases .NET completas, con sus propios valores de datos y su lógica asociada. Cualquier código .NET que sabe cómo procesar atributos puede examinar los atributos en busca de un tipo o miembro y tomar las acciones necesarias. Esto incluye Visual Studio, el compilador de Visual Basic y sus propias aplicaciones personalizadas. He aquí un ejemplo mundano: .NET Framework incluye un atributo denominado ObsoleteAttribute. Este atributo le permite marcar tipos de miembros de su ensamblado como obsoleto o ya no soportado. (Visual Studio usa este atributo para desplegar una advertencia cada vez que intenta usar una característica caduca de BCL o FCL.) Para usar el atributo, se agrega a un miembro de su aplicación empleando picoparéntesis: Class MiClaseConMiembrosObsoletos Sub HaceAlgo( ) End Sub End Class

Este código define una sola clase (MiClaseConMiembrosObsoletos) con un solo procedimiento de miembro (HaceAlgo), un procedimiento que evidentemente realiza alguna tarea. El procedimiento se marca con el atributo ObsoleteAttribute. Por costumbre, todos los nombres de atributos terminan con la palabra Attribute . Puede quitar esta parte de la palabra, si lo desea, siempre y cuando la palabra resultante no entre en conflicto con ninguna palabra clave del lenguaje Visual Basic: Class MiClaseConMiembrosObsoletos Sub HaceAlgo( ) End Sub End Class

Cuando compila la clase y la almacena en un ensamblado, el atributo se almacena como parte de la definición de HaceAlgo. Ahora puede escribir una aplicación de Visual Basic separada que rastree un ensamblado y dé salida al nombre y el estado de cada tipo de miembro que encuentre. Cuando ese programa de análisis encuentre el miembro obsoleto, detectará ObsoleteAttribute en los metadatos y dará salida al estado: HaceAlgo Procedure: Obsolete, don't use it!

Casi todos los atributos están diseñados con un propósito específico en mente. Algunos atributos instruyen a Visual Studio para que despliegue los miembros de una clase de maneras específicas. 14

| Capítulo 1: Introducción a .NET

Estoy hablando de esta área Propiedades.

Figura 1-4. El panel Propiedades en Visual Studio.

Tal vez ya haya jugado con las características de edición de formularios de Visual Studio para diseñar una aplicación simple de escritorio de Windows. Cuando agrega un control (como un botón o un cuadro de lista) a un formulario y selecciona ese control, Visual Studio le permite editar detalles de ese control mediante el área del panel Propiedades (véase la figura 1-4). El control Button está implementado como una clase, y muchos de sus miembros de clase aparecen en el panel Propiedades, pero no todos ellos. Cuando se diseñó la clase Button, se agregaron atributos a sus miembros para indicarle a Visual Studio cuáles miembros deben aparecer en el panel Propiedades y cuáles no. De manera obediente, Visual Studio examina estos atributos y sólo despliega las propiedades solicitadas.

Definición de la versión Como las suyas, mis aplicaciones son perfectas desde su lanzamiento inicial, y nunca tengo una razón para modificarlas o agregar características. Pero hay organizaciones de desarrollo de software (incluida una empresa grande a la que haré referencia por su letra inicial  M , para evitarle la pena) que sienten la necesidad de estar por encima de sus competidores con versiones “mejoradas” de sus ofrecimientos de software. Digamos que “M” tiene un procesador de palabras popular que incluye la versión 1.0 de un componente de revisión ortográfica. “M” también vende una herramienta de correo electrónico que depende específicamente de la versión 1.0 de ese mismo componente compartido. Si, en una muestra de machismo competitivo, “M” lanza una actualización del procesador de palabras y del componente de revisión ortográfica (ahora la versión 2.0), ¿qué sucede a la capacidad de revisión ortográfica de la herramienta de correo electrónico? Las partes de .NET Framework |

15

No afirmo que esto pase en la vida real. Pero si así fuera, el reemplazo de un componente vital compartido con una versión más reciente pero de alguna manera incompatible podría causar problemas reales. Un problema relacionado es la implementación de varias versiones de un solo componente en la misma estación de trabajo, todas en diferentes directorios. ¿Pueden borrarse de manera segura algunas de ellas? .NET resuelve estos problemas mediante la definición de la versión . Todos los ensamblados que usan componentes compartidos identifican de manera exacta cuáles versiones de los componentes compartidos se necesitan. Aunque puede reconfigurarse una aplicación para que use la versión más reciente, sólo usará, como opción predeterminada, la versión de un componente especificada originalmente. Varias versiones de un solo componente compartido pueden agregarse a la GAC, una característica llamada implementación lado a lado. El CLR asegura que la aplicación correcta se vincula con el componente correcto. Incluso puede ejecutar aplicaciones de manera simultánea que usan diferentes versiones del mismo componente.

Del código fuente a EXE  Ahora ya sabe gran parte de lo que hay que saber acerca de .NET, excepto por esa cosa molesta de la programación. Antes de profundizar en algún código real, tomemos un breve descanso y examinemos el tiempo de vida de una aplicación, de principio a fin (véase la figura 1-5). Por tanto, he aquí lo que sucede, paso a paso: 1. Usted, como programador, es responsable de preparar los ingredientes básicos (a) de la aplicación. En el caso de los programas de Visual Basic, esto significa crear uno o más archivos de código fuente con una extensión .vb. Sus ingredientes también pueden incluir otros archivos de apoyo, como archivos de recursos (de texto e imagen, a menudo utilizados para soporte de varios idiomas). (a)

(b)

(c)

(d) Figura 1-5. El proceso de desarrollo real de Visual Basic.

16

| Capítulo 1: Introducción a .NET

(e)

2. El compilador de Visual Basic cocina su aplicación (b). El resultado es un ensamblado, junto con un manifiesto y metadatos. La salida en realidad es un MSIL semicompilado e incluye versiones listas para ejecutarse de los tipos y miembros del código fuente, incluidos todos los nombres de miembros y tipos. Todo este contenido puede “descompilarse” (regresarlo a MSIL completo, aunque no a Visual Basic completo) usando una herramienta llamada ildasm.exe  (el desensamblador de lenguaje intermedio de Microsoft), que se incluye con .NET Framework. Debido a que tal vez no quiera que nadie desensamble su aplicación y revise el código, Microsoft (y otros) también proporcionan un obfuscador , que revuelve el contenido de su código de tal manera que resulte lo suficientemente difícil como para desalentar a los ojos indiscretos. 3. El ensamblado (c) se implementa en la estación de trabajo del usuario. Se utilizan unos cuantos métodos diferentes para implementar la aplicación, incluidos 1) generar un paquete de instalación para el Windows Installer; 2) generar una implementación de ClickOnce, o 3) realizar una instalación de xcopy, que sólo requiere copiar el propio ensamblado EXE en la máquina de destino. No importa el método de implementación que elija, el motor de tiempo de ejecución de .NET (d) debe estar instalado en la estación de trabajo del usuario. 4. El usuario come (quiero decir, ejecuta) el programa (e). El CLR hace una compilación justo a tiempo (JIT, just-in-time) del ensamblado MSIL para prepararlo para usarse en la plataforma local. Luego presenta la aplicación al usuario y administra todos los aspectos de la aplicación mientras la ejecuta. El usuario experimenta un nivel de alegría y satisfacción que rara vez se encuentra cuando se usan otras aplicaciones de software.  Al igual que con la preparación de una comida para un día festivo, el proceso de desarrollo real está de alguna manera relacionado con la lectura de un párrafo (o un libro de recetas) sobre él. Pero no es tan difícil como para que no pueda incluirse en un libro como éste.

Temas relacionados con Visual Studio y Visual Basic Espere un minuto: ¿qué pasa con Visual Studio? En la última sección ni siquiera se mencionó.  Y no era necesario, porque no requiere usarlo para desarrollar, compilar, implementar o ejecutar aplicaciones de Visual Basic . Todo .NET Framework (incluido el compilador de Visual Basic) está disponible, de manera gratuita, en el sitio Web de Microsoft; descárguelo y úselo para desarrollar e implementar aplicaciones que son tan poderosas y complejas como las de Visual Studio. La edición de julio de 1983 de la revista Datamation incluye un artículo de un valeroso lector, Ed Post, titulado “Real Programmers Don’t Use Pascal” (Los programadores reales no usan Pascal).* Recomiendo que lea este artículo, porque le ayudará a separar rápidamente a los programadores reales de los “comedores de pays”. Y cuando lo haga, aléjese lo más rápido que pueda de los * Datamation 29 (7): julio de 1983, pp. 263-265. También encontré el texto del artículo en Internet al hacer una búsqueda con el título. Una versión similar del texto, con unos cuantos cambios editoriales, también se encuentra bajo el título “Real Programmers Don’t Write Pascal” (Los programadores reales no escriben en Pascal).

Temas relacionados con Visual Studio y Visual Basic |

17

programadores reales. Por supuesto, pueden reconstruir su código fuente del ensamblado .NET obfuscado, pero serán inútiles en un proyecto de equipo en que se usa Visual Studio. Un “programador real” podría codificar cualquier aplicación de .NET empleando el Bloc de notas, y ejecutarlo. En realidad, los programadores reales usarían Emacs o vi en lugar del Bloc de notas (porque Windows no incluye una interfaz para teclear), pero los resultados serían los mismos. Gruñirían mientras usted escribe con toda alegría en la interfaz de usuario elegante, bien diseñada y plenamente personalizable de Visual Studio. Ellos se quejarían mientras usted utiliza las características IntelliSense y autocompletar integradas en el editor de código de Visual Studio. Consumirían otra rebanada de pizza mientras usted arrastra y coloca interfaces de usuario de Windows y Web. Sí, el programador real podría generar aplicaciones completas con sólo un editor de texto (o hex) y un compilador de .NET, pero usted alcanzaría la gloria, porque lo haría en una fracción del tiempo que le tomaría al enamorado de FORTRAN terminar su código.

Visual Studio 2008 Debido a que éste es un libro sobre desarrollo de Visual Basic y no de uso de Visual Studio, no me adentraré mucho en las características de Visual Studio ni en los elementos de su interfaz. Es una aplicación estupenda y su fuerte integración con .NET Framework hace que sea la mejor herramienta para desarrollar aplicaciones con .NET. Pero como el programador real le diría, sólo es un editor de texto ensalzado. Visual Studio oculta gran parte de la complejidad del código .NET, y su generación automática del código necesario para construir la interfaz de usuario de su aplicación es casi obligatoria. La mayoría de sus características están allí para simplificar el proceso de agregar código a su aplicación.  Aunque no estaré incluyendo una revisión de 20 páginas de Visual Studio aquí, encontrará imágenes de Visual Studio en todo el libro, colocadas para ayudarle a comprender mejor los temas que se analizan en cada capítulo. Cuando inicia Visual Studio por primera vez, despliega la Página de inicio. (Véase la figura 1-6. Las capturas de pantalla de este libro se tomaron de la Professional Edition de Visual Studio 2008.) Visual Studio 2008 es la cuarta versión del producto desde la introducción de .NET en 2002. Cada versión (en 2002, 2003, 2005 y 2008) corresponde a una versión relacionada de .NET Framework (1.0, 1.1, 2.0 y 3.5, respectivamente) y de la implementación de .NET de Visual Basic. La versión 2008 de Visual Studio es importante. Está empaquetada con nuevas características de uso y viene en cuatro deliciosos sabores:

18

| Capítulo 1: Introducción a .NET