Aprenda Workbook: Visual Basic 2005 - Primeros dos capítulos.

WorkBook Visual Basic 2005 Felipe Ramírez Facultad de Contaduría Púbica y Administración Facultad de Ingeniería Mecánica y Eléctrica Universidad Autónoma de Nuevo León, México.

Francisco Salazar Facultad de Contaduría Púbica y Administración Universidad Autónoma de Nuevo León, México.

 MÉXICO WWW.APRENDA.MX 01-800-APRENDA

El contenido de este documento está sujeto a cambios sin previo aviso.

Las organizaciones, productos, personas, o eventos referidos en los ejemplos son ficticios, por lo cual no debe establecerse relación alguna, inferirse o atribuirse dicha relación, respecto a organizaciones, productos, personas, o eventos de la realidad.

El contenido del presente material tiene protegidos los derechos de autor de la manera más amplia posible, por lo cual queda estrictamente prohibida su reproducción parcial o total.

Queda estrictamente prohibido su almacenamiento o introducción a cualquier sistema de recuperación de datos.

Queda estrictamente prohibida su reproducción o transmisión en cualquier medio conocido o por conocer, sin importar el propósito. La reproducción sólo podrá realizarse previa autorización por escrito del titular de los derechos.

De acuerdo a lo establecido por la Ley Federal del Derecho de Autor, se someterá a proceso a aquél que PRODUZCA, REPRODUZCA, ALMACENE, DISTRIBUYA, TRANSPORTE O COMERCIALICE COPIAS DE LA OBRA SIN LA AUTORIZACIÓN DEL TITULAR DE LOS DERECHOS. Los nombres de organizaciones y productos comerciales que aparecen en el presente material son propiedad de sus respectivos dueños y titulares de derechos. © DERECHOS RESERVADOS POR LOS RESPECTIVOS TITULARES Aprenda Practicando http://www.Aprenda.mx

Índice Generalidades ...................................................................................... VII 1 Plataforma .NET versión 2005 .............................................................. 1 Plataforma .NET ......................................................................................................................................................... 3 Principales capas de la plataforma .NET ......................................................................................................... 6 Capa de lenguajes de .NET ..................................................................................................................................... 8 CLS (Common Language Specification) .......................................................................................... 8 Lenguajes .NET ....................................................................................................................................... 11 Capa de servicios .................................................................................................................................................... 12 Biblioteca de clases base de .NET Framework (BCL) ............................................................................. 13 Independencia de la biblioteca de clases y los lenguajes ...................................................................... 16 CLR (Common Language Runtime) ................................................................................................................ 18 Tiempos de Compilación en .NET .................................................................................................. 19 Compilador para generar código intermedio............................................................................................. 20 Global Assembly Cache (GAC) ........................................................................................................................... 22 .NET PE (.NET Portable Executable) versus PE/COFF ......................................................... 24 Compiladores JIT ................................................................................................................................... 27 Modificaciones de .NET al Sistema Operativo ............................................................................................ 30 Modificación al cargador de ejecutables ..................................................................................... 30 Registro de biblioteca de clases base ........................................................................................... 30 Prerrequisitos del sistema operativo ........................................................................................... 31 Convivencia de .NET y COM ............................................................................................................................... 32 Examinando las entradas actuales del Global Assembly Cache (GAC) ........................................... 33 Examinando diferencias en programas ejecutables, usando el desensamblador de .NET (ildasm.exe) ............................................................................................................................ 35 Preguntas de competencia ................................................................................................................................. 36 Investigación............................................................................................................................................................. 37

2 Técnicas de desarrollo usando Visual Studio 2005 ...............................39 Soluciones y proyectos ......................................................................................................................................... 41 Trabajo Colaborativo recomendado en .NET ............................................................................................. 44 Creando aplicaciones en Visual Studio ......................................................................................................... 45 Elementos de sintaxis en Visual Basic ........................................................................................................... 48 Creando una aplicación de Consola en Visual Basic usando Visual Studio ................................... 50 Creando una solución en blanco ..................................................................................................... 50 Agregando un proyecto a una solución ....................................................................................... 51 Herramientas de Text Editor ........................................................................................................... 54 Colocando números de línea en Text Editor ............................................................................. 55 Intellisense y detección dinámica de errores ........................................................................... 56

I

II Índice

Modificando código usando Text Editor ..................................................................................... 59 Generando (Build) una solución en Visual Studio .................................................................. 59 Depurando una solución .................................................................................................................... 60 Creando una aplicación Windows en Visual Basic usando Visual Studio, trabajando varios proyectos en una solución ...................................................................................... 61 Generando una aplicación Windows ............................................................................................ 61 Fijando una herramienta en el espacio de trabajo ................................................................. 62 Agregando objetos de interfaz en tiempo de diseño ............................................................. 63 Navegando entre documentos de una solución ....................................................................... 65 Guardando documentos en una solución ................................................................................... 66 Estableciendo el proyecto de inicio para una solución ........................................................ 66 Creando una aplicación Web en Visual Basic usando Visual Studio, trabajando varios proyectos en una solución .................................................................................................. 69 Creando un directorio virtual para un sitio Web .................................................................... 69 Creando una aplicación Web ASP.NET ........................................................................................ 71 Preguntas de competencia ................................................................................................................................. 75 Investigación ............................................................................................................................................................ 76

3 Variables, arreglos y tipos de datos .................................................... 77 Variables ..................................................................................................................................................................... 79 Identificadores ....................................................................................................................................... 81 Tipos de datos en .NET ....................................................................................................................... 84 Conversión de datos .............................................................................................................................................. 88 Conversión implícita (Casting) ....................................................................................................... 88 Conversión explícita ............................................................................................................................ 89 Conversión por método ...................................................................................................................... 89 Acceso a datos Value type y Reference type ............................................................................................... 91 Capacidades de los tipos valor y referencia .............................................................................. 91 Naturaleza de tipo de los datos ....................................................................................................... 92 ByVal y ByRef .......................................................................................................................................... 93 Strong Typing ........................................................................................................................................................... 94 Option Explicit [On/Off] ..................................................................................................................... 95 Option Strict [On/Off] ......................................................................................................................... 95 Declaración de variables ..................................................................................................................................... 96 Constantes ................................................................................................................................................................. 98 Literales ...................................................................................................................................................................... 99 Valores por omisión .............................................................................................................................................. 99 Origen de las variables: clases y estructuras............................................................................................100 Alcance de las variables .....................................................................................................................................102 Shadowing ...............................................................................................................................................................103 Accesibilidad de las variables .........................................................................................................................105 Arreglos ....................................................................................................................................................................108 Arreglos unidimensionales .............................................................................................................110 Arreglos multidimensionales ........................................................................................................112 Arreglos escalonados ........................................................................................................................114 Demostrando el uso de variables de valor y referencia ......................................................................117 Demostrando la declaración de variables, constantes, y la realización de conversiones ...119 Construyendo (Build) un solo proyecto ....................................................................................119 Demostrando el alcance de las variables, y la forma en que preservan valores ......................122

Índice III

Comprobación del uso de arreglos unidimensionales, multidimensionales y escalonados ............................................................................................................................................... 126 Preguntas de competencia .............................................................................................................................. 130 Investigación.......................................................................................................................................................... 130

4 Estructuras de decisión y control .......................................................131 Estatuto If Then Else (condicional) ............................................................................................................. 133 Select Case .............................................................................................................................................................. 136 For Next ................................................................................................................................................................... 138 While 140 Do Loop .................................................................................................................................................................... 142 Reglas para el anidado de estructuras ....................................................................................................... 144 Uso de estructuras de decisión ...................................................................................................................... 146 Uso de For Next .................................................................................................................................................... 149 Identificando errores en estructuras anidadas ...................................................................................... 152 Preguntas de competencia .............................................................................................................................. 153 Investigación.......................................................................................................................................................... 153

5 Tipos de datos definidos por el usuario (UDT) 7 Estructuras ..............155 Objetivos .................................................................................................................................................................. 156 Tipos de datos definidos por el usuario .................................................................................................... 157 Comentarios finales respecto a los UDTs .................................................................................................. 161 Lab 05.01: Definir y utilizar estructuras ................................................................................................... 162 Ingresar a Microsoft Visual Studio 2008. ................................................................................ 162 Definir una estructura para representar un artículo ......................................................... 162 Definir una estructura para una dirección IP con el mínimo consumo de memoria posible ................................................................................................................................. 164 Preguntas de competencia .............................................................................................................................. 166 Investigación.......................................................................................................................................................... 166

6 Manejo estructurado de excepciones ................................................167 Errores versus Excepciones ............................................................................................................................ 169 Manejo estructurado de excepciones ......................................................................................................... 171 Try...Catch...Finally .............................................................................................................................................. 172 Bloque Try ............................................................................................................................................. 172 Bloque Catch ......................................................................................................................................... 173 Bloque Finally ...................................................................................................................................... 173 Clase System.Exception ................................................................................................................... 174 Calificadores de excepción .............................................................................................................................. 176 Objeto Err ................................................................................................................................................................ 178 Tipos de filtrado de excepciones .................................................................................................................. 179 Lanzando nuestras propias excepciones .................................................................................................. 180 Uso de Try Catch Finally, y uso de propiedades de la clase System.Exception ........................ 181 Viendo errores en tiempo de diseño usando Error List .................................................... 183 Filtrado de excepciones .................................................................................................................................... 185 Lanzamiento de excepciones definidas por el usuario ....................................................................... 188

IV Índice

7 Ordenamiento, búsqueda e intercalación ......................................... 191 Objetivos ...................................................................................................................................................................192 Ordenamiento, búsqueda e intercalación ..................................................................................................193 Ordenamiento ........................................................................................................................................................194 Método de ordenamiento por intercambio ..............................................................................................195 Recursos de ordenamiento en .net Framework ......................................................................................197 Operaciones de búsqueda .................................................................................................................................199 Método de búsqueda binaria ...........................................................................................................................200 Intercalación de estructuras ............................................................................................................................202 Lab 07.01: Ordenamiento, Búsqueda e Intercalación ..........................................................................204 Ingresar a Microsoft Visual Studio 2008. .................................................................................204 Comprobar las funciones de ordenamiento en .net .............................................................204 Comprobar el algoritmo de búsqueda binaria .......................................................................207 Implementar un código para intercalar dos arreglos .........................................................209 Preguntas de competencia ...............................................................................................................................211 Investigación ..........................................................................................................................................................211

8 Desarrollo de procedimientos y funciones ........................................ 213 Procedimientos .....................................................................................................................................................215 Forma de agregar procedimientos a un programa ..............................................................215 Forma de mandar llamar a ejecución un procedimiento ..................................................217 Argumentos ...........................................................................................................................................218 Valores de retorno ..............................................................................................................................219 Codificación de procedimientos.....................................................................................................................220 Argumentos opcionales y valores por omisión .......................................................................................225 Procedimiento que no utiliza argumentos ................................................................................................227 Procedimiento que declara argumentos pero no retorna valores .................................................230 Procedimiento que declara argumentos y retorna valores ...............................................................233 Preguntas de competencia ...............................................................................................................................235 Investigación ..........................................................................................................................................................236

9 Funciones básicas de .NET Framework.............................................. 237 Funciones intrínsecas .........................................................................................................................................239 Argumentos y expresiones ...............................................................................................................................240 Grupos de funciones ............................................................................................................................................244 Resumen de funciones de fecha y hora .....................................................................................245 Resumen de funciones de manipulación de cadenas (String) ........................................246 Resumen de funciones numéricas ...............................................................................................247 Resumen de funciones de conversión........................................................................................247 Resumen de funciones trigonométricas ...................................................................................248 Resumen de funciones de decisión .............................................................................................248 Resumen de funciones de medio ambiente de Windows ..................................................249 Resumen de funciones de manejo de sistema de archivos (File System) ..................250 Resumen de funciones de manejo de archivos ......................................................................250 Resumen de funciones de formato ..............................................................................................252

Índice V

Resumen de funciones de manejo de errores........................................................................ 252 Resumen de funciones financieras ............................................................................................. 252 Resumen de funciones de manejo de variables y objetos ................................................ 253 Consejos para una mejor consulta de funciones .................................................................. 254 Relación alfabética de funciones de uso más común ........................................................................... 255 Muestra el proceso de depreciación de un bien, utilizando DDB ................................................... 297 Lectura y escritura de llaves en el Registry de Windows .................................................................. 298 Uso de Dir para la manipulación del contenido del File System ..................................................... 300 Lectura secuencial de archivos planos del sistema, en modo texto .............................................. 301 Copia y borrado de archivos a nivel sistema operativo ...................................................................... 302 Lee datos de un archivo del sistema, en formato binario, usando una referencia (Reference) ........................................................................................................................................... 304 Lee datos de un archivo del sistema, en formato binario, utilizando un Objeto ..................... 305 Cálculo del valor futuro producto de una inversión ............................................................................ 306 Interfaz que mezcla elementos gráficos (InputBox, MsgBox) y salida en consola ................. 307 Generador de código HTML, con manejo se archivos planos ........................................................... 309 Preguntas de competencia .............................................................................................................................. 310 Investigación.......................................................................................................................................................... 310

10 Manejo de archivos .........................................................................311 Objetivos .................................................................................................................................................................. 312 El namespace System.IO ................................................................................................................................... 313 Muestra del contenido de System.IO........................................................................................................... 314 El objeto My.Computer.FileSystem .............................................................................................................. 316 Los archivos planos ............................................................................................................................................ 317 ¿Cómo crear un archivo plano? .................................................................................................... 318 ¿Cómo escribir a un archivo plano? ........................................................................................... 318 ¿Cómo leer de un archivo plano? ................................................................................................ 319 Lab 10.01: Aprovechar los recursos para el manejo del sistema de archivos y crear y consumir archivos planos. .............................................................................................. 321 Ingresar a Microsoft Visual Studio 2008. ................................................................................ 321 Preguntas de competencia .............................................................................................................................. 328 Investigación.......................................................................................................................................................... 328

1 Plataforma .NET Versión 2005

Objetivos: Aprenderá cómo se compone la plataforma .NET, y cómo funciona internamente, desde que codificamos el programa fuente, hasta que vemos el resultado de nuestro programa.

1. Aprenderá cuáles son las capas más importantes de .NET Framework.

2. Aprenderá cuáles son los requisitos que deben cumplir los lenguajes para ser reconocidos como lenguajes .NET. 3. Aprenderá la forma en que .NET interpreta, compila y ejecuta los programas.

4. Aprenderá las particularidades de la biblioteca de clases de .NET y su organización lógica y física.

5. Aprenderá las ventajas que brinda la plataforma .NET a los desarrolladores.

6. Aprenderá la forma en que .NET puede convivir con aplicaciones pasadas, basadas en tecnología COM.

1

2 Plataforma .NET Versiรณn 2005

Contenido Plataforma .NET ........................................................................................................ 3 Principales capas de la plataforma .NET ................................................................ 6 Capa de lenguajes de .NET ...................................................................................... 8 CLS (Common Language Specification) .................................................... 8 Lenguajes .NET ......................................................................................... 11 Capa de servicios ................................................................................................... 12 Biblioteca de clases base de .NET Framework (BCL) ........................................... 13 Independencia de la biblioteca de clases y los lenguajes ................................... 16 CLR (Common Language Runtime) ....................................................................... 18 Tiempos de Compilaciรณn en .NET ............................................................ 19 Compilador para generar cรณdigo intermedio ........................................................ 20 Global Assembly Cache (GAC) ................................................................................ 22 .NET PE (.NET Portable Executable) versus PE/COFF ............................ 24 Compiladores JIT ...................................................................................... 27 Modificaciones de .NET al Sistema Operativo ...................................................... 30 Modificaciรณn al cargador de ejecutables ................................................ 30 Registro de biblioteca de clases base .................................................... 30 Prerrequisitos del sistema operativo ...................................................... 31 Convivencia de .NET y COM ................................................................................... 32 Examinando las entradas actuales del Global Assembly Cache (GAC) ................ 33 Examinando diferencias en programas ejecutables, usando el desensamblador de .NET (ildasm.exe) ...................................................... 35 Preguntas de competencia .................................................................................... 36 Investigaciรณn ........................................................................................................... 37

Plataforma .NET Versión 2005

3

Plataforma .NET

La plataforma .NET es un componente de los sistemas operativos basados en Windows, que permite el desarrollo, liberación y ejecución de aplicaciones. La plataforma posee un conjunto de herramientas de desarrollo y lenguajes de programación de propósito general, orientados a objetos, de tercera generación, de alto nivel, de compilación a código intermedio, que nos permiten utilizar todos los recursos disponibles en la computadora a través de una librería de clases común, con la cual se pueden desarrollar aplicaciones de Consola, basadas en Windows, y para la Web, que utilizan protocolos abiertos para la interacción entre los elementos que las componen. .NET no es sólo un conjunto de lenguajes o un producto de Microsoft metido en una caja: .NET es toda una plataforma de desarrollo orientada a objetos que resuelve muchos de los problemas que se presentan hoy en día al desarrollar aplicaciones empresariales.

4 Plataforma .NET Versión 2005

Pr o bl e ma s qu e el i min a .N ET . eliminan con .NET son:

Algunos de los problemas que se



El infierno de los DLL.



Falta de interoperabilidad con otras plataformas.



Incapacidad para el manejo de esquema orientado a objetos.



Pobre manejo de errores.



Incapacidad para utilizar Internet como medio eficiente de comunicación.



Falta de aprovechamiento de la experiencia ganada por el manejo previo de otros lenguajes.



Incapacidad para el desarrollo de aplicaciones que aprovechen arquitecturas de 64 bits.

B en ef i ci o s qu e pr op or ci on a .N ET . Los beneficios que se obtienen al trabajar bajo la plataforma .NET pueden resumirse en los siguientes: 

Integración de aplicaciones multilenguaje.



Homologación de capacidades de los lenguajes.



Existencia de una biblioteca de clases común para los lenguajes.



Arquitectura abierta a nuevos lenguajes.



Desarrollo simplificado.

Plataforma .NET Versión 2005 

Implementación simple.



Mejor soporte a componentes.



Interoperación con Internet.



Interoperación con dispositivos móviles.



Rentabilidad.



Seguridad.



Fácil implementación (Copy Deployment).



Permite el desarrollo para aplicaciones de 64 bits.

5

Uno de los mayores retos que usted tendrá que superar para dominar cualquier lenguaje .NET será el entender la forma en que esta plataforma trabaja, además de los muchos tecnicismos que deberá aprender con la introducción de esta nueva tecnología.

Una buena práctica es que consulte el glosario de términos de .NET disponible en el sitio de Internet de Microsoft. Eso ayudaría a reconocer los términos, simplemente; para entenderlos, lea este manual.

6 Plataforma .NET Versión 2005

Principales capas de la plataforma .NET

Las capas que componen la plataforma .NET son: 

Cap a d e len gu a je s . La capa de lenguajes es la capa compuesta por el CLS y todos los lenguajes de programación compatibles con CLS. CLS (Common Language Specification) es un convencionalismo de elementos que deben cumplir todos los lenguajes que deseen ser considerados lenguajes .NET. Actualmente, Microsoft ha liberado cinco lenguajes y sus compiladores: Visual Basic, C#, C++, Visual J#, y JScript. Otros fabricantes pueden implementar sus propios lenguajes .NET, siempre y cuando respeten los lineamientos de CLS y proporcionen los compiladores para generar el código intermedio reconocido por .NET.



.N ET Fr a m ew or k ( In f r a e st ru c tur a y s er v i ci o s ) . .NET Framework es la capa compuesta por el núcleo de servicios y recursos de .NET, que incluye los compiladores, la biblioteca de clases común para todos los lenguajes, y los servicios que convierten lo codificado en los lenguajes en código máquina para los diversos sistemas operativos, a través del uso de código intermedio. .NET Framework se compone de los siguientes elementos: o

Cap a d e s er v i ci o s (S er vi c e s ) . La capa de servicios se compone de aquellos servicios que permiten la intercomunicación entre

Plataforma .NET Versión 2005

7

los programas desarrollados en un lenguaje .NET y el resto de los elementos de .NET Framework, con el fin de generar comportamientos a través del diálogo con el sistema operativo. Se tienen dos servicios principales: a) Windows Application Services, que apoyan a las aplicaciones de interfaz gráfica estilo Windows y a las aplicaciones de consola, en su diálogo con .NET Framework y el sistema operativo; b) ASP.NET Application Services, que apoya a las aplicaciones de interfaz gráfica basados en la Web, servicios Web XML y aplicaciones de cómputo móvil, en su diálogo con .NET Framework y el sistema operativo, a través de la intermediación del motor de servicios Web. En plataforma Microsoft este motor de servicios Web se llama Internet Information Server (IIS).



o

Bi bl i ot e c a d e cl a s e s b as e ( BC L / B as e Cl a s s L ib rar y) .

La biblioteca de clases base (BCL/Base Class Library) se trata de un conjunto de bibliotecas de clase que ponen a disposición de los programas un conjunto de funciones jerárquicamente organizadas, que podrán ser utilizadas como funciones nativas de manera no dedicada por todos los lenguajes de .NET.

o

M o to r c o mún d e e j e c uc i ón (CL R / C o m m on Lan g uag e R un t i m e) . El motor común de ejecución (CLR/ Common Language Runtime) es la plataforma común de ejecución de los programas desarrollados en cualquier lenguaje .NET. CLR agrupa compiladores de línea de comando que permiten la creación de código intermedio, libre de ambigüedades, al que se le da el nombre de ensamblado (assembly); contiene además los compiladores JIT (just in time compilers), que se encargan de generar código máquina a partir de los ensamblados. CLR se encarga de la gestión de errores, uso de recursos y diálogo con el sistema operativo en tiempo de ejecución.

A todo lo que requiere de la intervención de CLR para funcionar se le da el calificativo de administrado (managed).

S op or t e o p era ti v o . La capa de soporte operativo es la capa compuesta por las herramientas que se integran al sistema operativo al momento de instalar .NET Framework en un equipo, con lo cual el sistema operativo se ve modificado para ser capaz de interpretar y ejecutar aplicaciones .NET de forma nativa. Esta capa permite que el sistema operativo responda a indicaciones de acción emitidas por CLR en tiempo de ejecución.

NOTA Microsoft ha nombrado de diferentes formas a los productos y lenguajes que componen la tecnología .NET; en la versión 1.0 de .NET Framework los lenguajes eran Visual Basic.NET, Visual C#.NET y Managed C++; el entorno integrado de desarrollo era llamado Visual Studio.NET 2002. Por ser pro-

8 Plataforma .NET Versión 2005 ductos nuevos, existía la necesidad de diferenciarlos de las propuestas anteriores. Incluso, internamente en la compañía se penalizaba a quien osara referirse a Visual Basic.NET como Visual Basic 7. Con la versión 1.1 de .NET Framework, los lenguajes pasaron a ser Visual Basic.NET, Visual C# y Managed C++, trabajándose con Visual Studio.NET 2003. Ahora en la versión 2.0 de .NET Framework ya las versiones anteriores de los lenguajes se dan por muertas, por lo que podemos referir a los lenguajes como Visual Basic, C# y C++. Se elimina también el “.NET” a Visual Studio, quedando el nombre de la última versión como Visual Studio 2005.

Capa de lenguajes de .NET CLS (Common Language Specification) La verdad es que no siempre prestamos mucha atención a lo que hace una herramienta de desarrollo tras bambalinas; seamos sinceros: lo que verdaderamente nos importa como programadores es que nuestra codificación produzca la respuesta que esperamos.

En .NET, sin embargo, es importante aquello que sucede desde nuestra codificación hasta la intervención del sistema operativo en la atención de nuestras peticiones.

Para saber cómo funciona .NET partimos de un concepto denominado CLS (Common Language Specification | Especificación Común del Lenguaje).

El CLS es el sub-conjunto de capacidades mínimas soportadas por el motor de ejecución de .NET (CLR). Todas las herramientas y componentes de .NET, por ejemplo, conviven y utilizan las clases de BCL, además de ser orientadas a objetos; esto es así porque CLS lo determina como condición para ser considerado CLS Compliant, y por tanto, parte de tecnología .NET. El cumplimiento de estas reglas garantiza un comportamiento homogéneo de todos los componentes y herramientas de desarrollo .NET. Todos los lenguajes .NET liberados por Microsoft obviamente cumplen con todas las especificaciones de CLS, haciendo de Microsoft .NET un ambiente multilenguaje, en donde todos los lenguajes permiten hacer prácticamente lo mismo, dado que cumplen con un mismo marco original de trabajo y funcionamiento (CLS).

NOTA C# se pronuncia "C Sharp", ya que la “#” se coloca en lugar del Sharp, símbolo de representación utilizado en las partituras musicales, que no se encuentra disponible en el teclado.

Plataforma .NET Versión 2005

9

Cualquier desarrollador experimentado puede aventurarse a desarrollar su propio lenguaje de programación basado en .NET y proponerlo al mercado. Basta con desarrollar las herramientas necesarias para el trabajo con el lenguaje, incluyendo el compilador y el analizador (parser) del lenguaje. El único requisito es que debe cumplir con todas las reglas definidas en el CLS. Cap a ci dad e s mu lt il en g ua j e d e .N ET . Dado que todos los lenguajes de .NET cumplen con CLS, su programación es bastante similar.

A continuación ilustramos el típico programa Hola mundo, que generalmente se utiliza para mostrar la estructura básica de un programa en un lenguaje determinado, mostrando un mensaje cualquiera.

El programa Hola Mundo en C# sería de la siguiente manera (HolaMundo.cs): 1 2 3 4 5 6 8 9

using System; class HolaMundo { static void Main() { Console.WriteLine(“Hola Mundo”); } }

Así sería el mismo programa en Visual Basic (HolaMundo.vb): 1 2 3 4 5 6

Imports System Class HolaMundo Sub Main() Console.WriteLine(“Hola Mundo”) End Sub End Class

Vea cómo el código es sorprendentemente parecido. Todos los lenguajes en .NET comparten el mismo origen (CLS), y difieren solamente en la forma estructural de la codificación, determinada por el estilo del lenguaje.

NOTA La empresa japonesa Fujitsu enfrentó un problema que será común para muchas empresas grandes: gran parte de sus desarrollos están implementados en COBOL. ¿Cómo cambiar a la plataforma .NET sin sacrificar la inversión en desarrollo que ya se tiene? La solución que adoptaron fue generar el lenguaje COBOL, cumpliendo la especificación dictada por CLS. Podríamos hablar de una especie de COBOL.NET. Tomando el antecedente, descubrimos que las posibilidades son inmensas, y la oportunidad de implementar nuevos lenguajes nunca había sido tan

10 Plataforma .NET Versión 2005 atractiva. Lo ideal para mucha gente sería disponer de poderosos lenguajes de programación en su lengua nativa, por ejemplo en español; ¿alguien se anima?

CLS además de proponer una arquitectura que facilita la creación de nuevos lenguajes, proporciona interoperabilidad entre los mismos.

En virtud de que todos los lenguajes .NET comparten una misma especificación, en una solución o aplicación pueden convivir programas desarrollados en diferentes lenguajes, sin crear problemas de compatibilidad entre ellos.

Plataforma .NET Versión 2005

11

Lenguajes .NET

La definición de un Lenguaje .NET es simple: todo aquel lenguaje de programación y sus herramientas de análisis y compilación, que cumplen con la especificación CLS. Los lenguajes .NET requieren someterse a un proceso de compilación, y el resultado de la compilación debe ser un programa intermedio, que llamamos ensamblado (assembly); los ensamblados sólo pueden ejecutarse en colaboración con el motor de ejecución de .NET (CLR).

Todo programa que se ejecuta en colaboración con el motor común de ejecución (CLR) se le da el calificativo de administrado (managed), por lo cual, a los lenguajes de .NET también se les conoce como lenguajes administrados (managed languages).

En esencia, son administrados aquellos elementos que son ejecutados por el motor común de ejecución, en lugar de ser ejecutados directamente por el sistema operativo.

Al ser administrados, los elementos disponen de servicios propios del motor común de ejecución, como lo son la recolección de basura (garbage collection), verificación de tipos en tiempo de ejecución (runtime type checking), administración de la memoria (memory management), y soporte de seguridad (security support), entre otros servicios.

12 Plataforma .NET Versión 2005

Capa de servicios

La capa de servicios se encarga de proporcionar los medios de comunicación de datos entre los lenguajes y herramientas de desarrollo, y los elementos internos de .NET que se encargan de transformar los desarrollos en aprovechamiento de recursos a través de lenguaje máquina, es decir, el .NET Framework.

La capa de servicios se integra por dos diferentes tipos de servicios: ASP.NET Application Services y Windows Application Services.

Estos servicios son en realidad modelos de programación que permiten la intercomunicación entre la interfaz y el núcleo de la plataforma .NET. Cualquier lenguaje puede ser útil para programar y darse a entender para cualquiera de los servicios; la diferencia estriba en que ASP.NET Application Services está dirigido hacia los desarrollos en ambiente Web (Internet, Intranet, y Computación móvil), mientras que Windows Application Services está dirigido a los desarrollos en ambiente Windows (aplicaciones de escritorio y Cliente/Servidor).

Plataforma .NET Versión 2005

13

Biblioteca de clases base de .NET Framework (BCL)

Para entender la Biblioteca de clases de .NET Framework (BCL / Base Class Library), debemos considerar primero que todo en .NET es un objeto, pues los lenguajes .NET son completamente orientados a objetos.

Aunque se tratará a fondo el tema de programación orientada a objetos, nos anticipamos para precisar muy brevemente algunas definiciones que ocupamos en este momento, a efecto de poder explicar en qué consiste la BCL: 

Un objeto es un conjunto de datos y procedimientos que proporcionan una funcionalidad determinada.



Otra definición clásica nos dice que un objeto es una instancia de una clase.



Una clase es la definición formal de un objeto; es como una "plantilla de un objeto" que especifica los datos que un objeto puede manejar para identificarse, definirse y producir resultados; la clase también especifica los procesos que es capaz de realizar un objeto (comportamiento), y los resultados que proporciona.



Al proceso de derivar un objeto a partir de una clase, se le llama instanciación.



Los objetos tienen propiedades, métodos y eventos.

14 Plataforma .NET Versión 2005 

Los métodos son las acciones predefinidas que es posible realizar a través de un objeto. Para poder utilizar un método es necesario instanciar un objeto, generarlo a partir de una clase; un método siempre se refiere a través de un objeto.



Existen clases, interfaces y tipos de valor que son CLS Compliant y que permiten el acceso a la funcionalidad de BCL, sin la necesidad de instanciar un objeto previamente. Para diferenciar estos elementos de los elementos que sí requieren ser instanciados para poder ser utilizados, se les da el nombre de types.

Hechas estas precisiones, podemos decir que los programas desarrollados en .NET tienen como finalidad poner a trabajar, por medio de las estructuras del lenguaje, a los types y a los objetos generados a partir de clases.

La biblioteca de clases base de .NET Framework integra una gran cantidad de clases, y cada una de ellas ofrece una determinada funcionalidad que puede ser integrada a las aplicaciones. Algunas permiten crear objetos que desarrollan cálculos matemáticos o trigonométricos, otras permiten definir objetos que nos ayudan a realizar gráficos, otras permiten crear objetos a través de los cuales podemos manipular bases de datos, y así.

Una cantidad así de clases es muy difícil de manejar y clasificar.

Las clases se almacenan generalmente en librerías de vínculos dinámicos (DLL), que agrupan aquellas clases que son afines. La BCL se compone de más de 150 archivos DLL, en los cuales se encuentran diseminadas las clases que componen la biblioteca de clases base.

E spa c i os d e n o m br e s / Nam e sp a c es . Tratar de ubicar las librerías por su nombre de archivo físico sería bastante problemático. Las clases, como son muchas, se han categorizado y agrupado de manera lógica y jerárquica, de acuerdo a su funcionalidad. A dichos grupos de clases se les conoce como Espacios de nombres (Namespaces).

NOTA La forma más fácil de explorar la jerarquía de clases de .NET Framework es la ayuda electrónica que viene con el producto; también está disponible la versión impresa, a través de Microsoft Press, a un precio no muy accesible para todos.

Recomendamos el uso de los medios electrónicos, ya que salva árboles, es más rápido, y es gratis.

Un programa puede contener objetos y puede hacer uso de types; tanto los objetos como los types derivan de clases que indistintamente están contenidas en librerías (DLL) de .NET, o bien en clases desarrolladas por el usuario; las clases que dan origen a los objetos y types utilizadas en un

Plataforma .NET Versión 2005

15

programa en .NET no necesariamente están contenidas en los mismos archivos de librerías, pero al momento de programar eso es irrelevante para el desarrollador.

Ga ran tiz an d o la di sp o n ib il ida d d e la s c la s e s: r ef er en ci a y de c lar a ci ón d e l i br erí a s . Para poder hacer uso de una clase, antes debemos especificar en qué librería debe buscarse la clase que deseamos; para ello es necesario dos cosas: referir el recurso físico, y referir el recurso lógico. En otras palabras, hay que decir qué librería se requiere (referencia física), y qué espacio de nombre la refiere (referencia lógica).

Para la referencia física es necesario que al compilar establezcamos la referencia a la librería (DLL) que requerimos. Para la referencia lógica, dependiendo del lenguaje en el que esté codificando, se utilizarán instrucciones declarativas de espacios de nombre, tales como import, using, include, etcétera, para que nuestro programa pueda navegar en la jerarquía de clases contenidas en la librería, sin problemas.

La instrucción a utilizar varía en función al lenguaje que se esté utilizando.

In s tan c ia c i ón d e ob j et o s. Si ya declaró las librerías, entonces ya dispone de las clases contenidas en ellas; como ya dispone de clases, puede generar objetos (instanciar), y cuando ya tenga objetos, puede hacer uso de sus métodos para realizar alguna tarea determinada.

C ódi g o t yp e saf e . Cuando los métodos de los objetos y los types utilizados por el programa son reconocidos por la plataforma .NET, debido a que todas las referencias a librerías están correctamente realizadas, se dice que el programa es type safe.

Un programa no es type safe cuando en él se utilizan clases contenidas en la biblioteca de clases de .NET Framework, pero no se ha referido la librería específica en la cual se ha de buscar la clase, o bien, no se han declarado los espacios de nombres que faciliten la ubicación de la clase buscada, dentro de la jerarquía.

J er ar qu ía s d e cl as e s s up eri o re s . Existen dos grandes espacios de nombres: System y Microsoft; éstos a su vez tienen subdivisiones, de tal forma que las clases se organizan de manera jerárquica con base a su funcionalidad.

En virtud de que casi todas las clases de .NET Framework pertenecen de una u otra forma a cualquiera de estas dos jerarquías, se les llama jerarquías de clases superior.

La organización de clases a través de espacios de nombres es lógica; .NET Framework se encarga de saber en todo momento qué librería o componente físico está asociado con un determinado espacio de nombres. Realmente, especificar el espacio de nombres System significa tener acceso a una librería que físicamente se llama Mscorlib.dll, y que se encuentra en algún lugar de su equipo. Como puede ver, es más sencillo hacer re-

16 Plataforma .NET Versión 2005 ferencia a la librería a través del espacio de nombres que a través de una ruta de archivo físico.

Con lo ya expuesto podemos finalmente definir a la biblioteca de clases de .NET Framework, como una colección de clases incluidas en el ambiente de desarrollo .NET, disponibles para todos los lenguajes .NET por igual, organizadas en espacios de nombres, que permiten realizar tareas diversas a través del uso de objetos y types. .NET Framework nos proporciona un sinfín de recursos para desarrollar aplicaciones; ahora nuestro problema consiste en encontrar dónde están los recursos que ocupamos. Al desarrollar en .NET es indispensable saber qué métodos y types queremos utilizar, en qué clase se encuentran y qué espacios de nombres nos permiten disponer de dichas clases. Si la funcionalidad que necesitamos no está en ninguna de las clases de BCL, entonces tendremos que desarrollar nuestras propias clases.

Independencia lenguajes

de

la

biblioteca

de

clases

y

los

Ninguno de los lenguajes tiene uso exclusivo de la librería de objetos de .NET: está disponible para todos.

Este hecho es bastante significativo ya que todos los lenguajes pueden hacer uso de las mismas clases, y por tanto, podrán servir para lo mismo.

Anteriormente, los programadores de C++ podían presumir de conocer un lenguaje que les permitía manejar los recursos de la computadora de una manera más profunda, y subestimaban a los programadores de Visual Basic por utilizar una herramienta “tan limitada”; si un programador de Visual Basic 6.0 deseaba desarrollar programas con la misma funcionalidad que C++, era necesario que aprendiera el manejo del API (Application Programming Interface) de Windows, y dicha opción podía ser bastante compleja. Ahora eso ha cambiado, ya que con todos los lenguajes en .NET se podrán hacer las mismas cosas.

Uno de los mayores beneficios que se obtiene al disponer de una misma biblioteca de clases para su uso en varios lenguajes, es que el programador aprende un solo lenguaje, y al mismo tiempo aprenderá todos los demás, en términos generales. Compare el código HolaMundo.cs (C#) y HolaMundo.vb (Visual Basic), que se encuentran en este mismo módulo; estando codificados en diferentes lenguajes, ambos utilizan un mismo espacio de nombres System, una misma clase Console, y un mismo type WriteLine().

La forma de invocar a las clases y los types en todos los lenguajes .NET es uniforme, obedeciendo una sintaxis de separación pun-

Plataforma .NET Versión 2005

17

teada (dotted), que diferencia espacios de nombres, clases y types (estos últimos, opcionales en algunos casos): Namespace.Class[.Type] Además, todos los lenguajes de desarrollo son soportados por un mismo entorno integrado de desarrollo, llamado Visual Studio, con el cual podremos estar codificando al mismo tiempo múltiples proyectos en múltiples lenguajes.

Realizar esto antes de .NET era impensable.

El desarrollador debía aprender las palabras reservadas de cada uno de los lenguajes que aprendiera. Cada lenguaje poseía su propia biblioteca de clases (Class Foundation), tenía sus propias jerarquías y su propia sintaxis de invocación. La experiencia que ganaba con un lenguaje no le servía de mucho al intentar desarrollar en otro. Si a eso le sumamos que cada lenguaje tenía su propia herramienta de desarrollo, llegaríamos a la conclusión de que el programador consumía todo su tiempo en aprender las herramientas de desarrollo y las diferencias en los lenguajes, quedándole muy poco tiempo para ocuparse de los problemas reales de programación, como sería la lógica de negocios.

La plataforma .NET reduce la curva de aprendizaje y favorece los equipos de desarrollo, ya que la especialización se dará ahora sobre las ramas del conocimiento involucrados en los problemas que se pretenden resolver, y no en las herramientas de desarrollo para resolverlos; con ello se aumenta la rentabilidad de los programadores y el retorno de la inversión en programas y en capacitación.

18 Plataforma .NET Versión 2005

CLR (Common Language Runtime)

M o to r c o mú n d e e j e cu ci ón . Uno de los puntos más interesantes que aporta .NET es que cambia la forma en que se compilan y ejecutan los programas.

C o mpi la c i ón en d o s f a s es en .N ET . La plataforma .NET compila los programas a dos tiempos, separando la fase de análisis de la compilación, de la de síntesis. Para ello, juega un papel muy importante el CLR. El CLR (Common Language Runtime / Motor común de ejecución), es el motor de ejecución de código administrado, que se encarga de proporcionar al programa en ejecución servicios de alto nivel, tales como la integración de módulos multilenguaje, seguridad y acceso a módulos de código, administración del ciclo de vida de los objetos, administración de memoria, recuperación de recursos (garbage collector), pistas de depuración, etcétera.

Plataforma .NET Versión 2005

19

Tiempos de Compilación en .NET

CLR trabaja en dos tiempos: 1.

Tiempo de compilación, que inicia cuando usted utiliza cualquier compilador de lenguaje .NET para compilar un código fuente, y termina cuando usted ya posee un código intermedio del código fuente que compiló.

2.

Tiempo de ejecución, que inicia cuando se llama a ejecución un código intermedio y CLR se encarga de someterlo a la acción de compiladores justo a tiempo que producen código nativo, para luego producir los efectos esperados del programa.

NOTA Los tiempos en los que se compilan y ejecutan los programas en .NET es el rasgo más característico de la nueva plataforma. Son una diferencia enorme con respecto a las versiones anteriores del producto, por lo cual se analizan a mayor detalle más adelante.

Como definición, podemos decir que CLR es el motor de ejecución de código administrado, que provee una infraestructura en tiempo de compilación y ejecución que abstrae y coloca en un plano subyacente las diferencias de plataformas de hardware en donde un programa es ejecutado.

La definición anterior es compleja, y el concepto mismo del CLR lo es.

De manera sencilla podemos decir que el CLR se encarga de administrar

20 Plataforma .NET Versión 2005 la compilación y ejecución de los programas en .NET, con el fin de que puedan aprovechar la biblioteca de clases y los servicios de .NET Framework.

NOTA No se sienta mal si tarda un poco en entender cómo trabaja el CLR. Piense que es el núcleo de la nueva plataforma de desarrollo de Microsoft, y que dicha compañía tardó años en diseñarlo.

Compilador para generar código intermedio CLR en ti e mp o d e c o m pil a ci ón . El trabajo de CLR comienza cuando usted tiene un programa codificado en algún lenguaje .NET; dicho programa es un archivo de texto plano, que bien pudo haber editado en el Bloc de Notas (Notepad.exe); a dicho programa le llamamos código fuente (source code).

El código fuente no es ejecutable. Para poder ejecutar un programa es necesario que pase por un proceso de compilación, que consiste en revisar la sintaxis y la estructura del programa, y en caso de que esté correcto, que se genere un archivo equivalente que permita ser llamado a ejecución (ejecutable).

El programa que se encarga de convertir un programa fuente a ejecutable recibe el nombre de compilador; en el caso de Visual Basic, el compilador es un programa llamado vb.exe.

En sa m bl ad o | as s e m bl y. Al compilar un programa en .NET, se generará un ejecutable reconocido solamente por la plataforma .NET, al cual se le da el nombre de ensamblado (assembly); un ensamblado es un conjunto de uno o más archivos que son implementados como una sola unidad de ejecución, sobre la cual se determina la accesibilidad y los permisos.

Los ensamblados son la unidad básica, mínima, de ejecución en .NET. La compilación en .NET puede generar archivos de diversos tipos: exe, win exe, library o module, con diferentes extensiones de archivo, como EXE o DLL; sin importar qué se genere, estaremos hablando siempre de un ensamblado.

Usted puede determinar qué tipo de ejecutable desea obtener del proceso de compilación; si al compilar no se especifica el tipo de ejecutable que se desea generar, por omisión se creará un archivo EXE. M e tad at o s . A lo largo de su vida, usted tal vez ha utilizado muchos programas ejecutables, e incluso es posible que los haya creado.

Queremos decirle que un ejecutable común y corriente, y uno generado por un compilador de .NET, no obstante de tener la misma extensión de ar-

Plataforma .NET Versión 2005

21

chivo (EXE), no son iguales. El ejecutable creado por alguno de los compiladores de .NET estará compuesto por dos elementos: código y metadatos (este último no existe en los ejecutables comunes).

El código es el conjunto de instrucciones que forman el programa, y el metadatos es la información que describe cada elemento que ha de ser administrado en tiempo de ejecución por el CLR; es información relativa al programa y su entorno, como pueden ser tipos de datos que utiliza, versión del programa, referencias externas a librerías, etcétera.

La diferencia entre un ejecutable .NET y uno que no lo es radica en la existencia del metadatos. Cuando un ejecutable fue compilado para plataforma .NET, y por tanto posee metadatos, se dice que es un programa con código administrado (managed code).

C ódi g o ad m in i s tra d o / man ag ed c od e . Un dato que es importante mencionar es que si su computadora no tiene instalado el .NET Framework no podrá llamar a ejecución a los ejecutables de .NET. Esto se debe a que sólo las computadoras que tienen instalado el .NET Framework poseen el CLR, y el CLR es necesario para poder tener acceso a metadatos; podemos decir que existe un contrato de cooperación entre el ejecutable y el CLR. El calificativo “administrado” (managed) aplica para todo lo que ejecuta bajo un contrato de cooperación con el CLR, y que sin éste, no funciona.

Di v er s os n o m br e s d e l o s en s a mb la d os . Los ejecutables que se obtienen después de compilar el código fuente son conocidos de varias formas; ya los referimos como código administrado. El código administrado también es conocido como ensamblado (assembly), como MSIL (Microsoft Intermediate Language), como IL (Intermediate Language), o como código intermedio.

El código intermedio es aquél que no es código nativo aún, ya que sólo ha sido sometido a la fase de análisis del proceso de compilación. El código intermedio es independiente de la plataforma en la que se ejecuta, e independiente del lenguaje en el cual fue escrito el código fuente que le dio origen; eso garantiza la portabilidad de las aplicaciones, haciéndolas universales y multiplataforma.

El término que más se está utilizando es el de ensamblado. Por definición, un ensamblado es una colección de funcionalidad, control de versiones e implementación, que actúa como la unidad básica de ejecución para el .NET Framework.

Ma n if i e s t o. Por poseer metadatos, los ensamblados siempre son auto descriptivos. Cada ensamblado posee un manifiesto (assembly manifest), que es donde se almacena el metadatos.

El manifiesto es parte integral del ensamblado mismo, y en él se almacena la siguiente información:

22 Plataforma .NET Versión 2005 

Identidad del ensamblado (public key token).



Referencia de los archivos que el ensamblado requiere para ser implementado.



Types utilizados, y otros recursos utilizados por el ensamblado.



Dependencias con otros ensamblados, y



Permisos requeridos para poder ejecutar el ensamblado.

Gracias a la existencia de los manifiestos, ya no es necesario guardar información en el registro de Windows, pues todo lo que necesitamos saber se encuentra en el manifiesto del ensamblado.

C opy d ep lo y m en t. Todo lo que necesita un ejecutable para trabajar se encuentra declarado en el ensamblado; es por ello que un programa ejecutable en .NET trabajará con solo ser copiado a un equipo: no hay que instalar componentes, o instalaciones complejas, sólo se copia el ensamblado; a esto se le ha dado el nombre de implementación por copia (Copy Deployment).

Esto, por supuesto, si el equipo donde se copia posee la plataforma .NET, y en consecuencia, el CLR.

Global Assembly Cache (GAC) Los ensamblados pueden ser, entre otras cosas, librerías. En el caso de que sean librerías, existe la posibilidad que nosotros queramos utilizarlas en diferentes escenarios y en diferentes aplicaciones, teniendo un carácter de compartidas (shared); también es posible que existan otros desarrolladores en la misma organización que desarrollen sus propias librerías.

Aunque remota, existe la probabilidad de que dos desarrolladores distintos generen, para utilizar en una misma aplicación, una librería compartida con el mismo nombre.

De permitirlo .NET, caeríamos en la misma situación de infierno de los DLL que tanto quisimos evitar en Windows DNA. Afortunadamente, en el caso de las librerías .NET compartidas, éstas deben registrarse en un recurso llamado Global Assembly Cache (GAC); este recurso almacena las entradas de los componentes y librerías .NET, registrando para cada uno diferentes especificaciones, de entre las cuales destaca PublicKeyToken, que constituye un identificador único del componente.

En el GAC se encuentran las referencias lógicas de los componentes, que junto con la referencia física que especificamos al momento de compilar, evita que utilicemos un recurso que no queremos utilizar. Puede haber

Plataforma .NET Versión 2005

23

dos componentes compartidos del mismo nombre físico, pero nuestro programa sabrá siempre cuál es el que debe utilizar.

Ad m in i s tra d or d e G A C .

Existe una herramienta de .NET Framework, llamada gacutil.exe, que permite administrar el registro de componentes compartidos en el GAC. Dependiendo lo que se quiera hacer, gacutil.exe permite listar los componentes registrados en GAC, registrar un nuevo componente compartido, o remover un componente compartido, previamente registrado.

24 Plataforma .NET Versión 2005

.NET PE (.NET Portable Executable) versus PE/COFF

Si tanto usted como la empresa en la que trabaja se está iniciando en la experiencia llamada .NET, es probable que se quiera saber por qué los ejecutables generados en versiones anteriores de Visual Basic 6.0 y los generados en .NET son distintos; es muy probable que al tratar de implementar proyectos en .NET surjan cuestiones del por qué hay que instalar .NET Framework en las máquinas para poder ejecutar los programas .NET. Esto genera suspicacias y dudas: ¿seguirán trabajando mis aplicaciones existentes? ¿comenzará a fallar mi equipo? ¿tengo que pagar algo para poder ejecutar aplicaciones .NET? Primeramente podemos decir que para ejecutar aplicaciones .NET deberá instalar .NET Framework en los equipos, pero no la versión de desarrollo, sino el núcleo del producto, que es gratuito, además de que es independiente de la instalación actual que tiene, por lo que no modifica sus aplicaciones existentes.

Lo que sí se modifica es el cargador de programas (program loader); es decir, la parte del sistema operativo que se encarga de reconocer a un programa ejecutable, y de ejecutar las acciones.

Ar c hi v o P E . Un ejecutable de Windows (Windows executable), sea EXE o DLL, debe poseer un formato llamado PE Format (Portable Executable Format), que es un derivado del Microsoft Common Object File Format (COFF).

Plataforma .NET Versión 2005

25

A los programas ejecutables, por cumplir con la especificación PE, se les ha dado a llamar también Archivos PE. Tanto PE como COFF están claramente especificados y disponibles públicamente, de tal forma que todos los desarrolladores cuyas aplicaciones generan ejecutables puedan utilizarlos, incluyendo en dichos ejecutables los elementos que permitirán que los programas generados sean reconocidos como ejecutables.

Cualquier compilador o aplicación que desee generar ejecutables de Windows debe cumplir con la especificación PE/COFF. Un programa ejecutable contiene dos secciones en su interior: la sección de encabezados PE/COFF (PE/COFF Headers) , y la sección de imagen nativa del programa (Native Image Section).

La sección de encabezados PE/COFF le dirá al sistema operativo cómo está compuesto el programa, y cómo debe ser ejecutado; la sección de imagen nativa del programa se encarga de contener al programa en sí, así como los recursos que lo componen, usando para ello sub-secciones bastante conocidas para los que han desarrollado compiladores, como lo son .data, .rdata, .rsrc, y .text.

Ar c hi v o . NE T P E. Un archivo PE de .NET es más complejo, pues contiene dos secciones más: la sección de encabezados CLR (CLR Header Section), y la sección de datos CLR (CLR Data Section).

El encabezado CLR almacena información que indica que el programa es un ejecutable de .NET, y que deberá ser tratado como tal por el cargador de programas. Por otro lado, la sección de datos CLR contiene el metadatos y el código intermedio, lo que determina la forma en como el programa será ejecutado.

Como puede ver, las secciones del archivo PE permanecen. Si usted no tiene instalado .NET Framework, el cargador de programas de Windows encontrará secciones no reconocidas (encabezado CLR y datos CLR), y no sabrá qué hacer con ellas. Como no fueron reconocidas dichas secciones y el código ejecutable de .NET no es código nativo, el programa generará un error. Sólo teniendo .NET Framework instalado será posible reconocer las nuevas secciones del ejecutable, que ordenarán la compilación JIT de la información contenida en datos CLR. De s en sa m bl ad or d e en sa m bl ad o s . .NET Framework posee una herramienta de línea de comando para desensamblar los archivos ejecutables, llamado ildasm.exe; con dicha herramienta podemos comprobar si un programa es o no .NET, al aplicar el siguiente comando: ildasm /TEXT NombreEjecutable /HEADER

26 Plataforma .NET Versi贸n 2005

Donde NombreEjecutable es el nombre del ejecutable que queremos analizar.

La especificaci贸n /TEXT provoca que la salida sea a consola, y /HEADER provoca que aparezcan en el resultado todos los encabezados del ejecutable.

S贸lo si las definiciones muestran que el programa posee encabezados CLR, el programa es .NET.

Plataforma .NET Versión 2005

27

Compiladores JIT

CLR en ti e m p o d e e j e c uc i ón . El ejecutable generado por los compiladores de .NET no está en código nativo, y por tanto, su ejecución no implica que el equipo en el que es ejecutado realice alguna acción.

Al correr un ejecutable en un equipo que posee .NET Framework, el cargador de programas del sistema operativo revisa el programa buscando el encabezado CLR y los datos CLR; si estas secciones existen quiere decir que se trata de un ensamblado (.NET PE), y procede a darle un tratamiento considerando que es un ejecutable .NET. De no ser así, procede a ejecutar el programa considerándolo como archivo PE de Windows.

Si se trata de un .NET PE, el CLR identifica si ya ha sido ejecutado previamente en dicho equipo. En caso de que sea la primera vez que se ejecuta en el equipo, el CLR detecta que el ensamblado no es código nativo, y procede a generar código nativo a través de compiladores que actúan en tiempo de ejecución, a los cuales se les llama compiladores justo a tiempo (compilador JIT / Just In Time Compiler).

Sólo para aclarar el punto: los compiladores JIT trabajan sobre ensamblados, no sobre código fuente.

El compilador JIT evaluará el ensamblado, la disponibilidad de los types utilizados por el ensamblado, y los recursos disponibles del sistema en que se está ejecutando el ensamblado. A partir de ese análisis, genera el código nativo aplicable al equipo, y procede a ejecutarlo.

28 Plataforma .NET Versión 2005 Los compiladores JIT son los que realizan la fase de síntesis de la compilación, transformando el código intermedio que se encuentra en la sección de datos CLR, en su equivalente a código nativo de la máquina, considerando la plataforma de la misma, así como la disponibilidad de recursos que posee.

NOTA El hecho de que se realice la compilación JIT la primera vez que se ejecuta un programa ejecutable en .NET, hace que el proceso sea más lento.

Algunos programadores se decepcionan con .NET, pues argumentan que es más lento que las plataformas de desarrollo anteriores; quizá sea más lento la primera vez, pero la segunda vez que lo ejecute, el CLR detecta que ya existe código nativo creado, por lo que no procede a la compilación JIT, y por tanto se puede ver la velocidad real a la que el programa ejecutará.

Gracias al CLR los programas ejecutables de .NET son altamente portables. Quien determina la diferencia del código nativo que ha de ejecutarse en una determinada plataforma es el CLR, y no el ejecutable. Si un mismo ensamblado es ejecutado en dos equipos distintos, uno con mucha memoria y varios procesadores, y otro con poca memoria y un solo procesador, el CLR a través del compilador JIT generará el código nativo apropiado para tomar ventaja de todos los recursos disponibles.

Vea las posibilidades: se puede tener una versión de .NET Framework en un equipo basado en UNIX, otro en Linux, y una versión compacta de .NET Framework en un teléfono celular o en un PDA como la Palm Pilot.

El mismo ensamblado puede ser ejecutado en todas las plataformas, y es el CLR a través del compilador JIT quien genera el código nativo y la funcionalidad disponible para cada una de las plataformas mencionadas.

Poco importa también en qué lenguaje estaba desarrollado el código fuente que dio origen al ejecutable: después de compilarlo, todo es IL. NOTA Resulta adecuado el nombre que se le da al ejecutable que generan los compiladores de .NET, "código intermedio" (IL), ya que lo generado es un código entre el código fuente y el código nativo. Los programadores de Java encontrarán la semejanza rápidamente: el IL sería como el Bytecode, mientras que el CLR sería como el Java Virtual Machine.

Sólo un lenguaje de .NET permite (por el momento) la compilación directa a “casi” código nativo: C++.

No tener instalado el .NET Framework en una máquina también afecta al momento de ejecución, ya que el equipo no sabrá cómo interpretar el eje-

Plataforma .NET Versión 2005

29

cutable, además de no ser posible transformar el IL en código nativo, por la ausencia de CLR; en ese contexto y dicho de otra forma, su programa nunca podría producir a partir del ensamblado la secuencia de números binarios que provoquen una respuesta en su computadora.

NOTA Microsoft, en octubre de 2000, propuso a la ECMA (European Computer Manufacturers Association), asociación internacional que se encarga de la estandarización de sistemas de información y comunicación, un subconjunto funcional del CLR, denominado CLI (Common Language Infraestructure), para que fuera aprobado como estándar de desarrollo, junto con el lenguaje C#.

En diciembre de 2001 se ratificó por ECMA (ECMA-335), por lo cual cualquier plataforma de sistema operativo que así lo desee podrá disponer de su propio subconjunto de CLR, haciendo posible que las aplicaciones desarrolladas en .NET puedan ser ejecutadas en dichas plataformas sin modificar el código.

Microsoft ha puesto a disposición de todos un producto base denominado .NET Framework Redistributable Package en su sitio Web corporativo. Al instalarlo en su equipo ya será posible ejecutar aplicaciones desarrolladas en plataforma .NET. También lo está incluyendo en los Service Pack de sus sistemas operativos, y seguramente todos los sistemas operativos versiones OEM lo incluirán como parte de los mismos.

En sa m bl ad or d e .N ET . Existen también herramientas de .NET Framework que permiten realizar la fase de síntesis de la compilación, además del compilador JIT. El programa ilasm.exe es el ensamblador de .NET Framework; su función consiste en transformar un programa en código intermedio (MSIL), en archivo .NET PE. Para aquellos que deseen desarrollar un lenguaje .NET, esta herramienta es muy importante. Sólo se tendrán que preocupar por generar un compilador que traduzca el código fuente a MSIL, es decir, que se encargue de realizar la fase de análisis.

La fase de síntesis podrá ser desarrollada por el ensamblador de .NET. También es posible desensamblar un archivo .NET PE, a través de la herramienta de .NET Framework llamada ildasm.exe.

Tanto ilasm.exe como ildasm.exe están disponibles desde la línea de comandos del sistema operativo.

30 Plataforma .NET Versión 2005

Modificaciones de .NET al Sistema Operativo

Los sistemas operativos son, a fin de cuentas, los que reciben las instrucciones de bajo nivel para producir los efectos buscados en los programas, por lo cual, no pueden sustraerse a los cambios que .NET requiere para funcionar.

Modificación al cargador de ejecutables Ya discutimos que los ejecutables de .NET no son iguales a los ejecutables PE/COFF; el sistema operativo se ve modificado en este aspecto, ya que debe ser capaz de reconocer los nuevos encabezados de las secciones que poseen los .NET PE. Después de instalar .NET Framework en su equipo, el cargador de ejecutables será capaz de reconocer tanto a los ejecutables de .NET como a los ejecutables PE/COFF.

Registro de biblioteca de clases base Se instalan en su equipo todas las librerías de .NET Framework, y se registran, a fin de que pueda disponer de todas las clases de .NET.

Plataforma .NET Versión 2005

31

No se confunda, el hecho de que usted no requiera registrar sus componentes en .NET en el Registro de Windows, no quiere decir que las librerías de .NET no se registran de alguna forma. .NET sigue teniendo entradas en el Registro de Windows, ya que es el mecanismo optimizado que los sistemas operativos Windows entienden mejor; sin embargo, los desarrollos en .NET que usted realice no estarán basados en componentes, sino en ensamblados. De esa forma, el núcleo de .NET puede mantener manejo binario y registrado en los equipos locales, a través de componentes, mientras que las aplicaciones que usted desarrolle en .NET ya no serán basadas en componentes, y se comunicarán a través de protocolos abiertos; en cierta forma, se aprovecha lo mejor de la tecnología disponible.

A medida que los sistemas operativos comiencen a reconocer elementos .NET, la tecnología basada en componentes desaparecerá, aunque eso puede llevar tiempo.

Prerrequisitos del sistema operativo El sistema operativo debe disponer de un mínimo de actualización; por ejemplo, se asume que cuenta con una versión mínima de Internet Explorer, que tiene una amplia integración con los sistemas operativos Windows.

También se requiere tener una versión actualizada de MDAC (Microsoft Data Access Components), que permita desarrollar algunas asignaciones de base de datos internas del modelo .NET.

32 Plataforma .NET Versión 2005

Convivencia de .NET y COM

Seguramente las organizaciones tienen desarrollos basados en componentes COM; cambiar de inmediato a .NET puede no ser posible, e incluso, puede no ser deseable.

En ese sentido, .NET puede convivir con componentes COM, y para ello utiliza dos herramientas de .NET Framework: el exportador de librerías y el importador de librerías.

El exportador de librerías (type library exporter) está representados por el programa tlbexp.exe, que se encarga de generar, a partir de un ensamblado, una librería con la cual los componentes COM puedan interactuar.

El importador de librerías (type library importer) es la contraparte, ya que a partir de un componente COM, se genera un componente con el cual .NET pueda interactuar.

Está representado por el programa tlbimp.exe.

Plataforma .NET Versión 2005



33

Ejercicio 01.01 Examinando las entradas actuales del Global Assembly Cache (GAC)

Se utilizará el administrador de GAC para conocer cuáles son los componentes .NET disponibles. Esta práctica asume que se tiene instalado .NET Framework 2.0 SDK, English version.

1.

Vaya a Panel de control – Herramientas administrativas – .NET Framework 2.0 Configuration. Aparecerá la herramienta de configuración de .NET Framework 2.0.

2.

En el panel de la izquierda haga clic en el nodo My Computer; en el panel de la derecha aparecerá el vínculo Manage the Assembly Cache (Global Assembly Cache).

3.

Haga clic en el vínculo View List of Assemblies in the Assembly Cache.

4.

Existe una columna llamada Locale, y no todos los ensamblados tienen el mismo valor en dicha columna ¿Qué cree que signifique eso?

34 Plataforma .NET Versión 2005

5.

Existe una columna llamada Public Key Token, que se trata de una clave GUID (Global Un ique Identifier) ¿Para qué cree que sirva dicha clave?

6.

Cierre el programa de configuración de .NET Framework 2.0.

FIN DEL EJERCICIO 

Plataforma .NET Versión 2005



35

Ejercicio 01.02 Examinando diferencias en programas ejecutables, usando el desensamblador de .NET (ildasm.exe)

Desensamblará dos ejecutables, y determinará cuál de los dos es un ejecutable .NET. 1.

Ubique el directorio APVBNETVS\Cap01. Ese será su directorio de trabajo.

2.

En ese directorio se encontrarán dos programas. Se trata de los archivos HolaMundoA.exe y HolaMundoB.exe. Los dos hacen lo mismo, pero sólo uno de ellos es un .NET PE.

3.

Para este ejercicio nos apoyaremos en desensamblador de .NET Framework (ILDASM.EXE), que se encuentra en el directorio base de .NET (C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727).

4.

Inicio – Todos los programas – Microsoft .NET Framework SDK v2.0 – SDK Command Prompt.

5.

Vaya al directorio de trabajo.

En la línea de comandos, intente lo siguiente:

cd c:\APVBNETVS\Cap01 ildasm /TEXT HolaMundoA.exe /HEADER >a.txt ildasm /TEXT HolaMundoB.exe /HEADER >b.txt

6.

Es muy evidente cuál de los dos ejecutables no es un ejecutable .NET, dado que no puede ser desensamblado.

7.

Edite el archivo b.txt y busque la sección Metadata Version. semblies externos se mandan llamar desde este programa?

8.

Cierre la sesión de línea de comandos.

FIN DEL EJERCICIO 

¿Qué as-

36 Plataforma .NET Versión 2005

Preguntas de competencia

1. ¿Qué lenguaje de programación actual recomendaría para desarrollar aplicaciones que maximicen el retorno de inversión dedicado a ellas?

2. Le han solicitado que proporcione el código necesario para ejecutar la aplicación que anteriormente le habían solicitado por lo que le indican que requieren la inmediata entrega de los ensamblados correspondientes. ¿Qué archivos procedería a entregar?

3. Al estar conversando con un experimentado programador que desconoce la arquitectura de la plataforma .net, este le comenta que hay que ser muy cuidadoso con la gestión de la memoria. ¿Qué le comentaría usted al respecto? Elabore una respuesta que explique tal comentario.

4. Un colega programador le pregunta acerca de la llamada compilación JIT ¿Qué ejemplo utilizaría usted para ilustrar el concepto?

5. Al escuchar una conversación respecto a la plataforma .net, escucha que uno de los participantes refiere que el elemento activo de la plataforma es la BCL y otro se opone refiriendo que es el CLR y ambos acuden a usted para aclarar la duda. Explique la respuesta que proporcionaría.

Plataforma .NET Versión 2005

37

Investigación

1. ¿Es posible identificar un ensamblado de la GAC con respecto al código fuente que le dio origen?

2. Dado que un ensamblado puede ser “desensamblado” ¿Existe alguna forma de evitar esto y prevenir la inspección de nuestro programa?

3. Procure investigar cuantos lenguajes que cumplen con la CLI existen actualmente en el mercado y cuál es el objetivo principal de cada uno de ellos.

4. ¿Existe alguna opción de compilación que permita mejorar el desempeño de un ensamblado? De ser así y si es más de una, elabore una tabla al respecto y explíquelas.

Técnicas de desarrollo usando Visual Studio 2005

2

Objetivos: Aprenderá las generalidades del trabajo con Visual Studio para el desarrollo de aplicaciones de Consola, Windows y Web. 1. Aprenderá el concepto de organización de trabajo de Visual Studio, basado en soluciones y proyectos.

2. Aprenderá la mecánica para la creación de aplicaciones usando Visual Studio.

3. Aprenderá el uso de las herramientas Solution Explorer, Toolbox, Text Editor.

4. Aprenderá a distribuir el espacio de trabajo en Visual Studio.

5. Aprenderá a construir y depurar aplicaciones en Visual Studio.

6. Aprenderá a realizar configuraciones generales básicas de Visual Studio.

39

40 Técnicas de desarrollo usando Visual Studio 2005

Contenido Soluciones y proyectos ............................................................................................ 41 Trabajo Colaborativo recomendado en .NET ......................................................... 44 Creando aplicaciones en Visual Studio .................................................................. 45 Elementos de sintaxis en Visual Basic ................................................................... 48 Creando una aplicación de Consola en Visual Basic usando Visual Studio.......... 50 Creando una solución en blanco .............................................................................. 50 Agregando un proyecto a una solución .................................................................... 51 Herramientas de Text Editor .................................................................................... 54 Colocando números de línea en Text Editor ............................................................ 55 Intellisense y detección dinámica de errores ............................................................ 56 Modificando código usando Text Editor .................................................................. 59 Generando (Build) una solución en Visual Studio ................................................... 59 Depurando una solución .......................................................................................... 60

Creando una aplicación Windows en Visual Basic usando Visual Studio, trabajando varios proyectos en una solución ............................................ 61 Generando una aplicación Windows ........................................................................ 61 Fijando una herramienta en el espacio de trabajo .................................................... 62 Agregando objetos de interfaz en tiempo de diseño ................................................. 63 Navegando entre documentos de una solución ........................................................ 65 Guardando documentos en una solución .................................................................. 66 Estableciendo el proyecto de inicio para una solución ............................................. 66

Creando una aplicación Web en Visual Basic usando Visual Studio, trabajando varios proyectos en una solución ............................................ 69 Creando un directorio virtual para un sitio Web ...................................................... 69 Creando una aplicación Web ASP.NET .................................................................. 71

Preguntas de competencia ..................................................................................... 75 Investigación ............................................................................................................ 76

Técnicas de desarrollo usando Visual Studio 2005

41

Soluciones y proyectos

Desarrollar en .NET es igual en SDK que en Visual Studio, sin embargo, la forma en que organizamos el trabajo de desarrollo tiene importantes diferencias.

Si se utiliza Visual Studio, todo nuestro trabajo se organizará en soluciones y proyectos.

Una solución es el nivel más alto o global de organización en Visual Studio, y consiste en una colección de proyectos, administrados en una sola estructura.

Las soluciones almacenan información respecto a los proyectos que agrupan, las dependencias entre estos, así como el orden de construcción (compilación y generación de ensamblados) que deben tener entre sí.

Las soluciones tienen la extensión sln, y tienen algunas limitantes: la primera es que sólo se puede tener una solución abierta en una instancia de Visual Studio; la segunda es que una solución no puede contener a otra solución.

Los proyectos son colecciones de archivos fuente, que juntos son compilados como un archivo de salida .NET (ensamblado).

Cada proyecto puede componerse por interfaces de usuario (Windows Forms, Web Forms, Mobile), archivos de código (vb), referencias a clases

42 Técnicas de desarrollo usando Visual Studio 2005 de .NET Framework o a bibliotecas creadas por el usuario, archivos XML, HTML, y en fin, todo lo necesario para generar un ensamblado.

Visual Studio posee más de 90 diferentes tipos de proyectos. La ventaja de utilizarlos es que seleccionando el tipo de proyecto adecuado, Visual Studio se encarga de crear los archivos mínimos para el tipo de aplicación seleccionada, y además establece de forma automática las referencias a clases de .NET Framework usualmente requeridas.

Es importante mencionar que algunos proyectos muy especiales no generarán ensamblados, por ejemplo proyectos de setup, pero son los menos.

Un proyecto puede formar parte de varias soluciones, por lo que es posible organizar por módulos una aplicación, y al mismo tiempo se puede tener una solución maestra que englobe a todos los proyectos. Subdividir es una buena práctica, ya que al momento de estar desarrollando y solicitar la compilación de los programas (Volver a generar la solución), se compilarán todos los proyectos de la solución.

Esto puede convertirse en un problema en el caso de aplicaciones grandes: en primera instancia, porque pueden ser muchos los proyectos a compilar, lo que tomará mucho tiempo; en segunda instancia, porque en los proyectos grandes intervienen varios programadores, y es posible que tenga que estar lidiando con proyectos que ya funcionaban pero que ahora están presentando errores, mismos que se tendrán que corregir antes de que usted pueda ver su programa compilado.

Las soluciones deben planearse cuidadosamente con todo el equipo de desarrolladores.

Que una solución integre a todos los proyectos de otra solución, no quiere decir que una solución está dentro de otra. Eso permite que cada persona pueda crear las soluciones que requiera, sin impactar el trabajo de otros y sin perjudicar la integración de software, que se da por la unión de proyectos.

Es importante notar que en una misma solución pueden convivir proyectos que utilizan diferentes lenguajes .NET, pero un proyecto sólo puede tener código fuente de un solo lenguaje.

> Lo nuevo En Visual Studio 2005 se tienen las siguientes prestaciones relativas a los proyectos y las soluciones. Es posible crear proyectos temporales (temporary projects) que no requieren guardarse; así podemos probar cosas sin necesidad de crear proyectos y soluciones. También es posible crear proyectos autónomos (stand-alone projects); cuando una solución sólo se compone de un proyecto, no es necesario hacer la gestión

Técnicas de desarrollo usando Visual Studio 2005

de la solución, aunque de todas formas se genere. Para la organización del trabajo ya es posible crear directorios o folders de solución, con los cuales podemos clasificar los archivos involucrados en la solución.

También podemos administrar todos los recursos de un proyecto a través de Project Designer, y es posible referir archivos EXE como orígenes de clases, y no sólo archivos DLL.

43

44 Técnicas de desarrollo usando Visual Studio 2005

Trabajo Colaborativo recomendado en .NET

Se conoce como desarrollos colaborativos a las iniciativas de desarrollo que son tan grandes que el trabajo debe distribuirse en varios equipos de desarrollo.

Piense en proyectos de desarrollo de la magnitud de Microsoft Excel. Es impensable que un solo equipo de desarrolladores esté a cargo de todas y cada una de las funciones del paquete. Seguramente un equipo de desarrolladores se ocupa de la interfaz gráfica, otro se ocupa de Solver, otro de las capacidades de graficación, etcétera.

Imagine que alguien quiere compilar la parte que está desarrollando, y que ello implicará compilar todos los programas de todos los equipos de trabajo. Eso sería inadmisible en términos de tiempo y procesamiento.

Partimos del supuesto que mantener las cosas simples es lo mejor. Trabajar con el mínimo de elementos, suficientes y necesarios para obtener los resultados que buscamos nos mantendrá más enfocados en el trabajo.

Cuando se trabaja en ambientes colaborativos se recomiendan las siguientes prácticas relacionadas con los proyectos y las soluciones.

1.

Se debe dividir la aplicación en módulos, e incluso sub-módulos.

Cada módulo y sub-módulo es una unidad de labores de desarrollo, que contará con un responsable. De esa forma sólo se trabaja con los

Técnicas de desarrollo usando Visual Studio 2005

45

archivos del módulo; la compilación y depuración sólo se realizará sobre lo que estamos trabajando, y no sobre lo que están trabajando otros.

2.

Se recomienda que el trabajo de desarrollo de módulos y submódulos se haga en un equipo local, y nunca en un ambiente de producción.

3.

Se debe tener una solución por cada módulo, y una solución por cada sub-módulo, si aplica.

4.

Cada solución tiene un responsable.

5.

Los desarrollos de los sub-módulos sólo se agregan al módulo en caso de estar probados.

6.

Todas las librerías de uso común deben ser administradas por un responsable, aún y cuando no sea quien las desarrolla. Debe haber una solución para el manejo de las librerías de uso común.

7.

Sólo el responsable de la solución que contiene las librerías de uso común puede autorizar las modificaciones a las librerías; al autorizar una modificación deberá comunicar de la actualización a todos los equipos de trabajo.

8.

Se debe tener una solución que integre todos los recursos y programas que componen la aplicación, pero no se trabaja sobre ella. En esta solución sólo se integran los recursos que ya han sido probados a nivel módulo.

9.

La solución que integra toda la aplicación es la que se compilará finalmente para generar el entregable.

Creando aplicaciones en Visual Studio El procedimiento más sencillo para la creación de una solución es ingresando a Visual Studio. Aparecerá la página principal de la herramienta, denominada Start Page (página de inicio), desde la cual se pueden abrir proyectos nuevos o existentes, así como consultar información de Visual Studio y la plataforma .NET.

> Lo nuevo En Visual Studio 2005 la página de inicio fue rediseñada totalmente.

Ahora las 4 secciones (Open an existing project, Getting Started, Headlines, and News) aparecen en una sola página.

46 Técnicas de desarrollo usando Visual Studio 2005

Figura 02.01 Start Page

En Start Page se selecciona la opción de menú File – New – Project (o presionar CTRL-MAYÚS-N). Aparecerá la ventana New Project, que nos permite seleccionar el lenguaje que deseamos utilizar, así como el tipo de proyecto que deseamos construir.

Figura 02.02 New Project

Al proporcionar los datos del proyecto que se desea agregar, automáticamente se tendrá una solución del mismo nombre. La desventaja de esta modalidad es que en aplicaciones grandes, nunca un proyecto y una solución se llaman igual, ya que la solución es un concepto global, mientras que un proyecto es específico. Cuando la creación de un proyecto motiva la creación automática de una solución homónima, Visual Studio en-

Técnicas de desarrollo usando Visual Studio 2005

47

tiende que la solución se compone de un solo proyecto, a lo que se llama proyecto autónomo (stand-alone project); en este tipo de proyecto no se da mucha relevancia al concepto de solución dentro del entorno integrado de desarrollo.

Es indispensable saber qué lenguaje .NET es el que desea utilizar (Project Type), y decidido esto, es necesario saber qué tipo de aplicación se desea (Templates). Las plantillas o templates permiten predeterminar los recursos iniciales de la aplicación.

Visual Studio preguntará dónde se desea guardar la aplicación (Location), y con qué nombre (Name). Los archivos fuente que usted genere se encontrarán en el directorio que usted especifique. Se generará un archivo que mantendrá la referencia de todos los archivos involucrados en la solución, y tendrá la extensión sln. Es posible que la solución tenga un nombre distinto al del proyecto, por lo que se podrá colocar un nombre específico a la solución (Solution Name). > Lo nuevo En Visual Studio 2005 la organización es más eficiente, dado que todos los recursos de una solución están en un mismo lugar.

La versión 2003 almacenaba los archivos del proyecto en el directorio que nosotros especificábamos, pero colocaba el archivo de solución (SLN) en Mis documentos/Proyectos de Visual Studio, lo que creaba problemas en equipos en donde trabajaban diversos usuarios. Ahora la solución y los proyectos se almacenan en el mismo directorio.

48 Técnicas de desarrollo usando Visual Studio 2005

Elementos de sintaxis en Visual Basic

Visual Basic es el heredero de la tradicional sintaxis del lenguaje Visual Basic 6.0. Para no comenzar a desarrollar programas sin un conocimiento básico de la sintaxis del lenguaje, enumeramos algunas características esenciales.

1.

Visual Basic es no sensitivo a mayúsculas y minúsculas (non case sensitive).

2.

Las líneas de código terminan al encontrarse un salto de línea (CR/LF).

3.

El continuador de línea es un guión bajo ( _ ); el continuador de línea no debe interrumpir expresiones, antes de él debe haber un espacio en blanco, y después de él no debe escribirse nada.

4.

Un bloque de código es el conjunto de líneas que deben ser tratadas como unidad de ejecución. Los bloques de código generalmente se delimitan por estructuras con inicio y fin (Module – End Module, Sub – End Sub, etc.).

5.

Todo bloque de código que se inicie debe cerrarse.

6.

El último bloque de código en abrirse debe ser el primero en cerrarse.

Técnicas de desarrollo usando Visual Studio 2005

49

7.

Las bibliotecas a utilizarse en un programa se declaran al inicio del mismo, utilizando la palabra reservada Imports.

8.

Se utilizan paréntesis para delimitar expresiones que deban resolverse, o para delimitar argumentos.

9.

Las variables que se utilicen en un programa deben estar definidas de manera explícita.

10. Aunque no es relevante para el compilador, evite la codificación de todo mayúsculas o todo minúsculas. Procure iniciar las palabras reservadas con mayúsculas.

Este es un ejemplo típico de un programa en Visual Basic.

1 2 3 4 5 6 7 8 9 10

Imports System Imports System.Console Module MiPrograma Sub Main() Write("Pulse INTRO") ReadLine() WriteLine("Hola mundo") End Sub End Module

50 Técnicas de desarrollo usando Visual Studio 2005



Ejercicio 02.01 Creando una aplicación de Consola en Visual Basic usando Visual Studio

Desarrollará una aplicación de consola, que al presionar INTRO muestre un mensaje «Hola Mundo».

 Creando una solución en blanco 1. Ingrese a Visual Studio.

2. Seleccione la opción File – New (CTRL-MAYÚS-N). Con ello aparecerá la ventana de New Project.

3.

En Project Type seleccione Other Project Types – Visual Studio Solutions, porque queremos trabajar con soluciones de Visual Studio.

4.

En Templates seleccionamos Blank Solution. Al seleccionar el tipo de proyecto, Visual Studio se encargará de generar un contenedor de proyectos que podrá ser compilado para producir una aplicación.

5.

En Name coloque el nombre de la solución, que debe ser Ejercicios; en Location se especifica la ruta en la que se han de almacenar los archivos físicos que componen la solución. Escriba la ruta del directorio de trabajo del manual, que es C:\APVBNETVS.

6.

Vea cómo el cuadro de verificación Create directory for solution está marcado por omisión. Esto es recomendable para que la solución se organice mejor de-

Técnicas de desarrollo usando Visual Studio 2005

ntro del medio de almacenamiento. solución llamada Ejercicios.

7.

51

Haga clic en Ok para que se genere una

Al aceptar los cambios, se generará un directorio llamado Ejercicios en el directorio de trabajo. En dicho directorio existirá un archivo denominado Ejercicios.sln, que almacenará las referencias a los proyectos que componen la aplicación.

 Agregando un proyecto a una solución 8.

La herramienta Solution Explorer nos permite ver todos los elementos que componen una solución; mediante una interfaz de árbol de nodos, es posible ver todos los proyectos y componentes almacenados en archivos físicos que se tienen en una solución. Para disponer de forma visual de Solution Explorer podemos utilizar la opción View – Solution Explorer (CTRL-ALT-L).

9.

Actualmente sólo aparece un nodo, correspondiente a la solución Ejercicios.

En el nodo se hace referencia a que actualmente la solución tiene cero proyectos asociados.

10. Seleccione en Solution Explorer el nodo Solution ‘Ejercicios’, e invoque el menú de contexto (haga clic en el botón alterno del ratón). Seleccione la opción Add – New Project.

11. Aparecerá la ventana New Project.

12. En Project Type seleccione Visual Basic - Windows, porque desarrollaremos una aplicación de consola utilizando Visual Basic; recuerde que los proyectos de consola ejecutan utilizando el servicio Windows Application Services, aunque no sean interfaces gráficas; de ahí que se traten de aplicaciones Windows.

13. En Templates seleccionamos Console Application. Al seleccionar el tipo de proyecto, Visual Studio se encargará de proporcionar de forma automática to-

52 Técnicas de desarrollo usando Visual Studio 2005 dos los elementos típicos de una aplicación de consola, incluyendo archivos de código fuente, datos y configuraciones que apliquen.

14. En Name coloque el nombre del proyecto, que debe ser HolaMundoCon; en Location se especifica la ruta en la que se han de almacenar los archivos físicos que se están desarrollando. Escriba la ruta del directorio de trabajo de la solución, que es C:\APVBNETVS\Ejercicios.

15. Haga clic en Ok, con lo cual se generará dentro del directorio de trabajo de la solución un directorio llamado HolaMundoCon. En dicho directorio se encontrará el archivo de código fuente del programa de consola (.VB) y el archivo del proyecto (.VBPROJ) que concentrará las referencias de los archivos físicos involucrados en el proyecto. Se generan también directorios de trabajo: en \Bin se colocarán los ensamblados que se generen cuando se realice la compilación del proyecto, en \My Project se almacenarán archivos de configuración y especificaciones útiles para la compilación del proyecto, y en \obj se colocarán archivos temporales involucrados en el proceso de compilación y depuración.

16. Al haber especificado como Template una Console Application, Visual Studio genera de forma automática los archivos y referencias comunes para una aplicación de consola. El componente principal será un programa de código fuente llamado Module1.vb, que es módulo en Visual Basic.

17. Document Window es el espacio principal de trabajo en Visual Studio, en donde la mayoría de las herramientas se ubicarán en tiempo de diseño. En Document Window aparecerá Text Editor, que es el editor de texto plano en donde se podrá modificar el código de Module1.vb.

Técnicas de desarrollo usando Visual Studio 2005

53

18. En este momento Solution Explorer debe mostrar todos los elementos físicos que componen la solución, y en Document Window se tendrá a Text Editor modificando el código de Module1.vb.

54 Técnicas de desarrollo usando Visual Studio 2005

 Herramientas de Text Editor 19. Text Editor tiene los siguientes elementos.

Figura 02.03 Elementos de Text Editor

20. Text Editor es una herramienta fascinante de edición de código, dadas las muchas herramientas que ofrece, dentro de las cuales se encuentran las siguientes. a.

Bar ra d e s el e c ci ón d e do c u m en t o s . En la parte superior de Text Editor aparecerá una barra que mostrará las pestañas (Tabs) que permitirán seleccionar el documento con el que deseamos estar trabajando.

b.

T ab s. Llamadas también pestañas de selección, identifican y permiten seleccionar los documentos abiertos con los que se puede trabajar.

A los documentos que se encuentran abiertos y en la barra de selección de documentos, se les llama documentos activos.

c.

S el e c to r d e d o cu m en t o s a ct i vo s . Dado que se pueden tener una cantidad de documentos activos que hagan insuficiente el espacio en la barra de selección de documentos para mostrar las pestañas de selección, hacer clic en el Selector de documentos activos (flecha ) permite ver los documentos activos en forma de menú, y seleccionarlos.

d. C err ad o d e d o cu m en t o s . Si se desea quitar un documento de los documentos activos, simplemente se debe seleccionar el documento a cerrar, y hacer clic en el icono de cerrado de documentos. e.

De li m it ad or e s d e b ran c hin g. Es la capacidad de Text Editor de mostrar de forma visible los alcances de los bloques principales de código (Branching). Como se puede observar, al inicio de un procedimiento, módulo o clase, en las líneas delimitadoras de branching aparecen símbolos (-) y (+); estos pequeños iconos permiten visualizar y ocultar el código delimitado, con lo que podemos hacer más clara nuestra

Técnicas de desarrollo usando Visual Studio 2005

55

codificación, mostrando sólo aquellas partes del código que realmente nos interesa observar. f.

C o mpl e m en ta c i ón au t o má ti c a d e c ód ig o. Es la capacidad de Text Editor de agregar de forma automática líneas de código que por regla de lenguaje debe escribirse. Esto simplifica el proceso de codificación, además que evita errores por omisión de código.

g.

C ol or in g . Es la capacidad de Text Editor de diferenciar por colores los elementos del código. Generalmente las palabras reservadas estarán en azul, identificadores y operadores en negro, y comentarios en verde. Esto es útil sobre todo cuando no estamos seguros de estar escribiendo correctamente las palabras reservadas. Si no se ponen de color azul, es que no están siendo bien escritas.

h. Di vi s or e s d e p r o c edi m i en t os . Son las delimitaciones horizontales que separan los procedimientos incluidas en el código. i.

Di vi s or d e pan e le s de ed i ci ón . Si se arrastra el icono Divisor de paneles de edición, podrá dividirse el espacio de edición de Text Editor en dos mitades. En cada una de las mitades podrá desplazarse, ver y editar diferentes partes del código. Esto es especialmente útil en programas muy extensos, en donde desea estar comparando porciones de código que es imposible mantener juntas en una misma pantalla.

j.

S el e c to r de el e m en t o s . Se trata de un combo que muestra los diferentes módulos y elementos globales de una aplicación. En caso de que el programa posea muchos elementos globales, este combo permite ir directamente a la parte de código que nos interesa, sin tener que estar navegando entre las líneas de código para buscar.

k.

S el e c to r de m ie m br o s . Trabaja de la misma forma que Selector de elementos, sólo que a un nivel más bajo.

Permite seleccionar un miembro de un elemento global.

l.

In t el li s en s e . Capacidad a través de la cual Text Editor propone los objetos y miembros más comunes, conforme se escribe el código.

 Colocando números de línea en Text Editor 21. Los números de línea son muy útiles al momento de identificar partes del código. Muy probablemente si se presentan problemas al momento de compilación o ejecución, Visual Studio referirá el número de línea que presenta problemas. Lo ideal es saber el número de línea que corresponde a cada parte del código.

22. Si los números de línea no aparecen en su editor de textos, puede mostrarlos de la siguiente manera. Vaya al menú Tool – Options. Aparecerá la ventana Op-

56 Técnicas de desarrollo usando Visual Studio 2005 tions. Seleccione el nodo Text Editor –Basic – General; habilite el cuadro de verificación Line Numbers, de la sección Display. Haga clic en Ok.

 Intellisense y detección dinámica de errores 23. Dentro del procedimiento Main() introduzca la siguiente línea.

Console.WriteLine(“Presione INTRO”)

Esto se deberá escribir en varios tiempos. Primero escriba «Console.» Al llegar al punto, aparecerá un menú dinámico que propone los elementos del lenguaje que concuerdan con el código que comenzamos a escribir, de tal forma que nosotros iniciamos la escritura, pero puede ser que Visual Studio sea el que la termine, simplificando el proceso de codificación, además de evitar errores de sintaxis. A esta funcionalidad se le llama intellisense.

Intellisense tiene en la parte baja dos pestañas: Common y All. Dado que los elementos de un objeto pueden ser muchos, Visual Studio nos permite ver los más comunes, o bien todos. Por omisión mostrará los más comunes, lo cual es muy práctico.

Del menú de elementos que aparecen, es posible seleccionar utilizando el puntero del ratón, utilizando las flechas de dirección, o bien por concordancia con lo escrito. Sólo en caso de que lo que busque no se encuentre en Common, recurra a All.

Técnicas de desarrollo usando Visual Studio 2005

57

Siga escribiendo, hasta que haya escrito «Console.WriteL» . La información que hemos escrito permite una concordancia exacta con un elemento del menú, mismo que se selecciona.

Para ahorrarnos la escritura, y dado que ya está seleccionado el código que pretendemos escribir, basta con escribir el caracter que seguiría, en caso de escribir nosotros el código. En este caso sería un paréntesis “(“ . Escriba un paréntesis derecho, y vea cómo Intellisense complementa el código de forma automática, desapareciendo.

58 Técnicas de desarrollo usando Visual Studio 2005

Se recomienda ampliamente el uso de Intellisense, dado que se ha demostrado que reduce en gran medida los errores de sintaxis.

Siga escribiendo la línea de código, y vea cómo aparece una ayuda interactiva de llenado de los elementos. En este caso, la ayuda nos indica que si escribimos «WriteLine()», lo que obtendríamos sería un terminador de línea. La ayuda interactiva nos dice que hay 18 formas de utilizar WriteLine, dado el polimorfismo con que el objeto fue programado. Utilizando los iconos  de la ayuda interactiva, busque la alternativa 14 de 18, para que vea la forma en que se utiliza WriteLine con un String.

A este momento ya debió de haber escrito la línea de ejemplo por completo.

24. Modifique la línea, de tal forma que escriba «Console» con doble “s”, a fin de causar un error. Vea cómo al introducir una línea que presenta errores de sintaxis, Visual Studio le señala la falta muy al estilo de Word, subrayando el error en color azul.

Si se coloca sobre la parte del código que presenta el error, podrá darse cuenta que Visual Studio le informa el mensaje del error que se está provocando.

Esto ayuda a reducir el tiempo de desarrollo, dado que no hace falta compilar y probar para saber que algo fallará.

Técnicas de desarrollo usando Visual Studio 2005

59

25. Corrija la línea para que ya no genere errores.

 Modificando código usando Text Editor 26. Como todo programa Hola Mundo, se espera que el usuario interactúe con el programa, y que éste envíe el mensaje «Hola Mundo». Para hacer esto, nuestro programa enviará un mensaje, esperará el uso del teclado, y enviará finalmente el mensaje «Hola Mundo». Modifique el procedimiento Main(). El código deberá quedar de la siguiente forma.

Codificación de HolaMundoCon 1 2 3 4 5 6 7 8 9

Module Module1 Sub Main() Console.Write("Presione INTRO") Console.ReadLine() Console.WriteLine("Hola mundo.")

End Sub End Module

27. Realmente usted sólo tuvo que agregar las líneas 4, 5, y 6, que muestran un mensaje, esperan que presione una tecla, y muestran otro mensaje, respectivamente.

 Generando (Build) una solución en Visual Studio 28. Generar una solución consiste en tratar de compilar todos los programas y elementos de todos los proyectos asociados a una solución. Al realizase la compilación se generan los ensamblados correspondientes a cada uno de los proyectos, quedando listos para su ejecución.

60 Técnicas de desarrollo usando Visual Studio 2005 29. Vaya al menú Build – Build Solution (CTRL-MAYÚS-B), para generar la solución.

30. En la parte inferior de Visual Studio se abrirá la ventana Output, que es la encargada de mostrar el resultado de los procesos que Visual Studio realiza en el plano subyacente, al ponerse en contacto con las herramientas de línea de comandos de .NET Framework, así como con otros elementos de la plataforma.

Si al final de la generación aparece el siguiente mensaje, su programa es correcto, dado que se tuvo éxito en la construcción de un proyecto, encontrándose cero fallas.

 Depurando una solución 31. Vaya al menú Debug – Start Debugging (F5) para depurar la aplicación. Al depurar la aplicación se comprueba que el programa esté correcto sintácticamente, y al mismo tiempo se ejecuta la aplicación para verificar que no cause problemas en tiempo de ejecución.

Para efectos prácticos, depurar es ejecutar, en ambiente de desarrollo.

32. Con ello aparecerá la aplicación de consola ejecutando. trará muy rápidamente el mensaje «Hola Mundo».

FIN DEL EJERCICIO 

Al hacer clic se mos-

Técnicas de desarrollo usando Visual Studio 2005



61

Ejercicio 02.02 Creando una aplicación Windows en Visual Basic usando Visual Studio, trabajando varios proyectos en una solución

Desarrollará una aplicación Windows, que al hacer clic en un botón, muestre un mensaje «Hola Mundo».

1.

En este ejercicio trabajará con la solución creada en el ejercicio anterior.

 Generando una aplicación Windows 2.

En el Solution Explorer seleccione el nodo Ejercicios (Solution ‘Ejercicios’).

3.

Invoque el menú de contexto y seleccione Add – New Project.

4.

Seleccione en Project Types el nodo Visual Basic - Windows. Dentro de Templates, seleccione Windows Applications. En Name especifique el nombre del proyecto, que será HolaMundoWin, y se almacenará en el directorio de trabajo de la solución. Haga clic en Ok.

5.

Aparecerá en Document Window una herramienta llamada Form Designer, que permite el diseño de interfaces de forma gráfica y dinámica.

62 Técnicas de desarrollo usando Visual Studio 2005 6.

Selecciona la opción de menú View – Toolbox (CTRL-ALT-X). Aparecerá la herramienta Toolbox, que muestra de forma clasificada los controles gráficos disponibles para una aplicación Windows.

7.

Los controles son enlaces gráficos que permiten acceder las clases de .NET Framework para la elaboración de interfaces gráficas; a través de los controles es posible agregar objetos de interacción en una interfaz. Visual Studio se encarga de agregar el código necesario para la integración en los programas.

8.

Observe cómo Toolbox no permanece en su lugar por mucho tiempo.

 Fijando una herramienta en el espacio de trabajo 9.

Cuando una herramienta de Visual Studio se encuentra en modo de ocultación automática, al no hacer uso de dicha herramienta, ésta se contrae, liberando espacio de trabajo en Document Window. Se dice que una herramienta está en modo fijo cuando permanece en el espacio de trabajo de Document Window, independientemente si se está haciendo uso de la herramienta o no. Hay ocasiones en que nosotros preferimos que la ocultación automática no esté disponible, por lo que procedemos a colocar la herramienta en modo fijo.

10. Teniendo visible el Toolbox, haga clic en el Icono de ocultación automática que se encuentra en la esquina superior derecha de la herramienta (barra de título del Toolbox). Después de haber hecho clic en el icono, debe lucir de la siguiente forma.

Modo fijo

Modo ocultación automática

Si el Icono de ocultación automática aparece en modo fijo, hacer clic sobre el icono pondrá a la herramienta en modo ocultación automática. Si el Icono de ocultación automática aparece en modo ocultación automática, hacer clic sobre el icono pondrá a la herramienta en modo fijo.

11. En caso de que Toolbox esté en modo de ocultación automática, cambie su estado a modo fijo. La interfaz deberá quedar de la siguiente manera.

Técnicas de desarrollo usando Visual Studio 2005

63

 Agregando objetos de interfaz en tiempo de diseño 12. En Form Designer se pueden agregar objetos de interfaz de tres maneras: Modo inserción, haciendo doble clic sobre alguno de los controles; Modo arrastre, arrastrando un control desde el Toolbox hacia el Form Designer; y Modo trazo, haciendo un solo clic sobre un control, y trazando en Form Designer el espacio que se desea que el control aparezca.

13. En Toolbox aparecen categorías de controles que pueden ser incluidos en una interfaz.

Expanda en Toolbox la categoría Common Control, haciendo clic en (+).

14. Haga doble clic sobre el control Button, que se encuentra en el Toolbox – Common Control.

15. Arrastre el control Label, que se encuentra en el Toolbox, y colóquelo debajo del botón que acaba de agregar en el punto anterior.

16. En los puntos anteriores se agregó un objeto en modo inserción y uno en modo arrastre.

17. Acomódelos de tal forma que queden distribuidos de la siguiente manera. Sólo arrástrelos. No haga doble clic sobre ellos.

64 Técnicas de desarrollo usando Visual Studio 2005

18. Seleccione el objeto Label1 que se agregó a la interfaz. Para ello, haga un solo clic sobre él.

19. Cada elemento en la interfaz es un objeto, y como todo objeto, posee propiedades que determinan su apariencia y sus capacidades de comportamiento. La herramienta Properties permite modificar los valores de las propiedades de los objetos. Seleccione la opción View - Properties Windows (F4) para ver la herramienta Properties.

20. Como teníamos seleccionado el objeto Label1, Visual Studio nos permite la modificación de las propiedades de dicho objeto.

21. En la ventana Propiedades, en el combo superior aparecerá el nombre del objeto que se modificará, así como la clase en la que está basada.

Busque la propiedad (Name), y cambie el nombre Label1 por lblResultado. Presione INTRO. El nombre habrá cambiado en el combo superior de la ventana Properties, lo que indica que el cambio ha sido aceptado.

22. Para agregar funcionalidad al programa es necesario que le especifiquemos el comportamiento que deseamos que tenga, como respuesta a la interacción con

Técnicas de desarrollo usando Visual Studio 2005

65

el usuario. Para ello debemos codificar procedimientos de evento, que son bloques de código que se ejecutarán cuando el usuario o el programa interactúen de cierta manera con la aplicación.

23. Deseamos que al hacer clic en el botón, se coloque el texto Hola Mundo en el objeto lblResultado. Para ello debemos codificar el procedimiento que responda al evento Click del botón.

24. Haga doble clic en el botón que agregó a la interfaz. Automáticamente aparece pre-codificado el procedimiento que se ha de ejecutar al momento de hacer clic (Click) en el botón (Button1), de ahí que el procedimiento se llame Button1_Click. Vea cómo el editor nos deja listos para codificar lo que debe suceder cuando hagamos clic en el botón, en tiempo de ejecución.

25. Dentro del procedimiento deberá agregar una línea que especifique que al hacer clic en el botón, se cambiará la propiedad Text del objeto lblRespuesta a Hola Mundo. El código debe lucir como sigue.

Codificación de HolaMundoWin

 Navegando entre documentos de una solución 26. En la parte superior de Document Window aparece la Barra de selección de documentos, en la cual aparecen todos los elementos de la solución que se encuentran abiertos en este momento. Cada elemento posee su propia pestaña de selección, también llamadas Tabs.

27. En este ejemplo aparecen 4 documentos o herramientas que pueden ser seleccionadas en la Barra de selección de documentos. Cada documento se activa al hacer clic sobre su Tab, activándose en Document Window la herramienta utilizada por el documento para su edición.

Form1.vb y Module1.vb, por ser código fuente, aparecerán utilizando Text Editor, mientras que Form1.vb [Design] se mostrará usando Form Designer. Por otro lado, Start Page aparecerá como un navegador de páginas Web intrínseco de Visual Studio, dado que es una página Web.

66 Técnicas de desarrollo usando Visual Studio 2005 28. Seleccione alternativamente los diferentes Tabs que se tienen, y vea el comportamiento de Visual Studio. Si alguno de los documentos abiertos desea cerrarse, basta hacer clic en el Tab y posteriormente hacer clic en la cruz que aparece en el extremo izquierdo de la Barra de selección de documentos.

 Guardando documentos en una solución 29. Si el Tab de un documento muestra un asterisco (*), eso indica que el documento posee modificaciones que no han sido guardadas.

30. Guarde todos los cambios. Para ello invoque el menú File – Save All, o presione CTRL-MAYÚS-S.

 Estableciendo el proyecto de inicio para una solución 31. Cada proyecto tiene un objeto de inicio (startup object) que puede ser una página Web o un programa que permita su ejecución. Al ejecutar el ensamblado generado a partir de un proyecto, el objeto inicial será el objeto a mostrar primero.

32. De la misma forma, cada solución en Visual Studio puede tener uno o más proyectos, sin embargo, toda solución debe tener un proyecto de inicio (startup project). Cuando mandemos a ejecución una solución desde Visual Studio, lo que veremos como resultado será la ejecución del objeto inicial del proyecto seleccionado como proyecto de inicio.

33. Vea la ventana del Solution Explorer. Actualmente en la solución Ejercicios tiene dos proyectos registrados: el programa de consola del ejercicio anterior (HolaMundoCon), y el proyecto Windows que estamos trabajando (HolaMundoWin). Si observa bien, el proyecto HolaMundoCon aparece en negritas, lo que indica que es el proyecto de inicio de la solución. Si depura (F5) en este momento se ejecutará la aplicación de consola, y no la de Windows que estamos trabajando.

Técnicas de desarrollo usando Visual Studio 2005

67

34. Para hacer que nuestro nuevo proyecto de aplicación Windows sea el proyecto de inicio, seleccione el nodo HolaMundoWin en el Solution Explorer. Invoque el menú de contexto y seleccione Set as StartUp Project. De esa forma el proyecto de Windows será nuestro proyecto de inicio.

35. En nuestro caso, como la aplicación Windows sólo contiene un formulario Windows, establecer nuestro proyecto como proyecto de inicio provoca que el único formulario sea el objeto de inicio. Si nuestra aplicación tuviera más de un formulario Windows sería necesario especificar cuál de los formularios es el objeto de inicio.

36. Un objeto de inicio es el elemento de un proyecto que será el primero en mostrarse en la interfaz.

37. Generar una solución permite que los elementos de todos los proyectos de una solución sean compilados, generando los ensamblados correspondientes. En este caso, generar la solución implicaría la compilación de los dos proyectos que hemos desarrollado.

38. Guarde la solución y genérela, para ver si no hay problemas con el trabajo que ha realizado. Si aparece el siguiente resultado, es que todo fue bien. Vea cómo se han construido 2 ensamblados (EXE); uno por cada proyecto de la solución.

68 Técnicas de desarrollo usando Visual Studio 2005

39. Si no hubo problemas, depure la aplicación (F5). de inicio, es decir, nuestra aplicación Windows.

Se depurará nuestro proyecto

40. Al aparecer nuestra interfaz en tiempo de ejecución, haga clic en el botón, y vea cómo el texto de la etiqueta cambia. En ese caso, la aplicación funcionó adecuadamente.

41. Guarde su aplicación y ciérrela.

FIN DEL EJERCICIO 

Técnicas de desarrollo usando Visual Studio 2005



69

Ejercicio 02.03 Creando una aplicación Web en Visual Basic usando Visual Studio, trabajando varios proyectos en una solución

Desarrollará una aplicación Web, que al hacer clic en un botón, muestre un mensaje «Hola Mundo».

 Creando un directorio virtual para un sitio Web 1.

Una aplicación ASP.NET funciona basada en la colaboración de .NET Framework e Internet Information Server. Si creamos una aplicación ASP.NET, Visual Studio intentará almacenarla como un sitio dependiente del sitio Web predeterminado, es decir http://localhost/, que equivale a crear un directorio en la ruta C:\inetpub\wwwroot, y darle permisos de ejecución Web.

2.

No siempre deseamos que nuestro sitio se almacene físicamente en C:\inetpub\wwwroot, por lo que es necesario que especifiquemos que un directorio cualquiera actúe como sitio Web, a lo que se le llama directorio virtual.

Aunque el directorio no se encuentre en C:\inetpub\wwwroot, virtualmente si lo estará.

3.

Genere en nuestro directorio trabajo (C:\APVBNETVS) un directorio que se llame HolaMundoWeb. Ese directorio será el directorio de trabajo de la aplicación Web que vamos a crear.

4.

Vaya a Inicio – Panel de control – Herramientas administrativas – Servicios de Internet Information Server.

5.

Expanda el árbol Servicios de Internet Information Server, hasta que ubique el nodo Sitio Web Predeterminado.

6.

Estando en ese nodo, invoque el menú de contexto, y seleccione la opción de menú Nuevo – Directorio virtual....

70 Técnicas de desarrollo usando Visual Studio 2005

7.

Aparecerá el Asistente para crear un directorio virtual. Haga clic en Siguiente en la pantalla de bienvenida. Cuando el asistente pregunte por el alias de su sitio, escriba APVBNETVS, y haga clic en Siguiente.

8.

Como directorio de contenido del sitio Web, seleccione o escriba la ruta del directorio que acaba de crear en el punto anterior (C:\APVBNETVS\HolaMundoWeb), y haga clic en Siguiente.

9.

Deje los permisos tal como están. Haga clic en Siguiente, y luego haga clic en Finalizar.

10. Se habrá creado un sitio llamado APVBNETVS. 11. Ubique el nodo APVBNETVS en el árbol de servicios de Servicios de Internet Information Server y selecciónelo. En el panel de la derecha se podrá observar que no hay elementos disponibles en dicho sitio. Cierre el programa Servicios de Internet Information Server.

Técnicas de desarrollo usando Visual Studio 2005

71

 Creando una aplicación Web ASP.NET 12. En el Solution Explorer seleccione el nodo de la solución Ejercicios, y desde el menú de contexto seleccione Add – New Web Site. Con lo que aparecerá la ventana Add New Web Site.

13. En Templates seleccione ASP.NET Web Site. En Location haga clic en el botón Browse.

Con ello aparecerá la ventana Choose Location, que permite seleccionar una ruta física del sistema operativo (si está codificando en \InetPub\wwwroot) o un directorio virtual.

14. Seleccione en el panel derecho el origen Local IIS, para indicar que el desarrollo se trabajará en un directorio virtual dentro de nuestra máquina. Al seleccionar Local IIS, aparecerán en organización de árbol de nodos todos los sitios registrados. Seleccione su sitio APVBNETVS. Haga clic en Open para aceptar.

72 Técnicas de desarrollo usando Visual Studio 2005

15. Se generará el sitio Web ASP.NET. La página principal sobre la que se estará trabajando es la página Default.aspx; las páginas pueden trabajarse en modo de diseño (Design) y en modo codificación (Source). La forma de alternar entre uno y otro modo es seleccionando las pestañas que aparecen en la parte inferior de Document Window. Al estar en Design, se puede utilizar Toolbox para integrar objetos en la interfaz. En modo Source es necesario que se agreguen las etiquetas en el lugar indicado.

Técnicas de desarrollo usando Visual Studio 2005

73

16. Vaya a modo de diseño (Design) y utilizando Toolbox (CTRL-ALT-X), agregue un Button y un Label.

17. Seleccione el objeto Label1, y asigne en la propiedad Name, el mismo nombre que asignó en Windows: lblResultado.

18. Haga doble clic en el botón que agregó a la interfaz. Aparecerá el procedimiento de evento que se ejecutará al momento de hacer clic en el botón. Codifique lo siguiente en el procedimiento Button1_Click.

Codificación de HolaMundoWeb

19. Seleccione el nodo http://localhost/APVBNETVS en el Solution Explorer, y establézcalo como proyecto de inicio.

74 Técnicas de desarrollo usando Visual Studio 2005 20. Vuelva a generar la solución (CTRL-MAYUS-B), y si no hay problemas en la generación, depure la aplicación (F5). Debe funcionar igual que la aplicación Windows: al hacer clic en el botón, el mensaje de la etiqueta debe cambiar.

21. En este ejercicio comprobamos que el desarrollo Windows y Web, realizado desde Visual Studio es prácticamente idéntico.

22. Finalmente nuestro proyecto quedaría como sigue.

23. En cualquier momento puede llamar a edición cualquier elemento de la solución.

Dependiendo del tipo de archivo que se trate, Visual Studio invocará Text Editor, Form Designer, o Web Form Designer, o lo que aplique.

24. En Solution Explorer haga doble clic en el nodo HolaMundoCon – Module1.vb, luego haga doble clic en HolaMundoWin – Form1.vb, luego haga clic en http://localhost/APVBNETVS/ - Default.aspx, y finalmente haga clic en http://localhost/APVBNETVS/ - Default.aspx – Default.aspx.vb. Vea cómo se comporta Visual Studio.

25. Guarde su aplicación y ciérrela.

FIN DEL EJERCICIO 

Técnicas de desarrollo usando Visual Studio 2005

75

Preguntas de competencia

1. Al hacer las pruebas del código escrito, este se ejecuta sin aparente problema. Sin embargo, los resultados que arroja son incorrectos. ¿Qué recurso de Visual Studio aprovecharía para identificar el o los errores de lógica que aparentemente afectan al mismo?

2. Se le solicita que genere los ensamblados resultantes de su proyecto pero que no los ejecute. De ser esto posible, explique el procedimiento que seguiría 3. Elabore una guía gráfica de cómo se pueden ver en pantalla dos bloques de código que pertenecen al mismo documento pero que están separados por múltiples líneas entre sí.

4. Al leer la documentación de algún entorno de desarrollo, se encuentra con que ofrece soporte para intellisense ¿Qué clase de ventaja es esa?

5. ¿Cuántos tipos de proyectos de .net puede contener una solución de Visual Studio?

6. Hasta el día de hoy, han estado trabajando con Visual Studio para producir aplicaciones cliente-servidor Windows Forms. Su gerente le indica que empezarán a producir aplicaciones Web y le pregunta si deberán adquirir un software que remplace al actual IDE ¿Cuál sería su respuesta? Justifíquela

76 Técnicas de desarrollo usando Visual Studio 2005

Investigación

1. Existen recursos que pueden ayudar en tiempo de codificación y pruebas como los llamados Assertions ¿Qué propósito tienen y como se utilizan?

2. Investigue acerca de los diferentes snippets que incluye Visual Studio y demuestre en una presentación el uso de algunos de ellos y explique cómo estos pueden ayudarle a reducir los errores de escritura de código y el tiempo invertido en tal actividad.

3. ¿Cuál es el procedimiento para crear un proyecto que genere un instalador de nuestro proyecto? Ilústrelo y explíquelo.

4. Elabore una tabla con los atajos de teclado que ofrece Visual Studio, esta deberá contener el atajo y una explicación de su efecto.