aprenda workbook: visual basic 2005 - primeros dos capítulos

WWoorrkkBBooookk

VViissuuaall BBaassiicc 22000055

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, produc-tos, personas, o eventos de la realidad.

El contenido del presente material tiene protegidos los derechos de au-tor 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 cual-quier medio conocido o por conocer, sin importar el propósito. La re-producció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 titu-lares de derechos.

© DERECHOS RESERVADOS POR LOS RESPECTIVOS TITULARES

Aprenda Practicando

http://www.Aprenda.mx

I

Í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

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, traba-

jando 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 es-calonados ............................................................................................................................................... 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

1

OObbjjeettiivvooss:: Aprenderá cómo se compone la plataforma .NET, y cómo funciona

internamente, desde que codificamos el programa fuente, hasta que vemos el re-

sultado 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 progra-

mas.

4. Aprenderá las particularidades de la biblioteca de clases de .NET y su or-

ganización lógica y física.

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

res.

6. Aprenderá la forma en que .NET puede convivir con aplicaciones pasadas,

basadas en tecnología COM.

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 EExxaammiinnaannddoo llaass eennttrraaddaass aaccttuuaalleess ddeell GGlloobbaall AAsssseemmbbllyy CCaacchhee ((GGAACC)) ................................ 3333 EExxaammiinnaannddoo ddiiffeerreenncciiaass eenn pprrooggrraammaass eejjeeccuuttaabblleess,, uussaannddoo eell

ddeesseennssaammbbllaaddoorr ddee ..NNEETT ((iillddaassmm..eexxee)) ............................................................................................................ 3355 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 aplica-

ciones. 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 utili-

zan 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 me-

tido 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.


Problemas que el imina .NET. Algunos de los problemas que se

eliminan con .NET son:

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 comunica-

ción.

Falta de aprovechamiento de la experiencia ganada por el manejo

previo de otros lenguajes.

Incapacidad para el desarrollo de aplicaciones que aprovechen arqui-

tecturas de 64 bits.

Benef icios que proporciona .NET. 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.


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.

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 in-

troducción de esta nueva tecnología.

Una buena práctica es que consulte el glosario de términos de .NET dis-

ponible en el sitio de Internet de Microsoft. Eso ayudaría a reconocer los

términos, simplemente; para entenderlos, lea este manual.


Principales capas de la plataforma .NET

Las capas que componen la plataforma .NET son:

Capa de lenguajes. 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 ele-

mentos que deben cumplir todos los lenguajes que deseen ser consi-

derados 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 lengua-

jes .NET, siempre y cuando respeten los lineamientos de CLS y pro-

porcionen los compiladores para generar el código intermedio reco-

nocido por .NET.

.NET Framework ( Infraestructura y servicios) . .NET Frame-

work es la capa compuesta por el núcleo de servicios y recursos de

.NET, que incluye los compiladores, la biblioteca de clases común pa-

ra todos los lenguajes, y los servicios que convierten lo codificado en

los lenguajes en código máquina para los diversos sistemas operati-

vos, a través del uso de código intermedio. .NET Framework se

compone de los siguientes elementos:

o Capa de servicios (Services) . La capa de servicios se compo-

ne de aquellos servicios que permiten la intercomunicación entre


los programas desarrollados en un lenguaje .NET y el resto de los

elementos de .NET Framework, con el fin de generar comporta-

mientos a través del diálogo con el sistema operativo. Se tienen

dos servicios principales: a) Windows Application Services, que apo-

yan 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 Bibl ioteca de clases base (BCL / Base Class L ibrary) .

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 organiza-

das, que podrán ser utilizadas como funciones nativas de manera

no dedicada por todos los lenguajes de .NET.

o Motor común de ejecución (CLR / Common Language

Runtime) . 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 compila-

dores de línea de comando que permiten la creación de código in-

termedio, libre de ambigüedades, al que se le da el nombre de en-

samblado (assembly); contiene además los compiladores JIT (just in

time compilers), que se encargan de generar código máquina a par-

tir 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 pa-

ra funcionar se le da el calificativo de administrado (managed).

Soporte operativo. La capa de soporte operativo es la capa com-

puesta 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.

NNOOTTAA

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-


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 lengua-

jes 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, que-

dando 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 ver-

daderamente nos importa como programadores es que nuestra codifica-

ción produzca la respuesta que esperamos. En .NET, sin embargo, es

importante aquello que sucede desde nuestra codificación hasta la inter-

venció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 mo-

tor 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 condi-

ció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).

NNOOTTAA

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.


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 traba-

jo con el lenguaje, incluyendo el compilador y el analizador (parser) del

lenguaje. El único requisito es que debe cumplir con todas las reglas de-

finidas en el CLS.

Capacidades mult i lenguaje de .NET . Dado que todos los lengua-

jes de .NET cumplen con CLS, su programación es bastante similar.

A continuación ilustramos el típico programa Hola mundo, que general-

mente 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 (HolaMun-

do.cs): 1 2 3 4 5 6 8 9

using System; ccllaassss HHoollaaMMuunnddoo { 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 CCllaassss HHoollaaMMuunnddoo SSuubb MMaaiinn(()) Console.WriteLine(“Hola Mundo”) EEnndd SSuubb EEnndd CCllaassss

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 lengua-

je.

NNOOTTAA

La empresa japonesa Fujitsu enfrentó un problema que será común para

muchas empresas grandes: gran parte de sus desarrollos están implemen-

tados 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


atractiva. Lo ideal para mucha gente sería disponer de poderosos lengua-

jes 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 nue-

vos lenguajes, proporciona interoperabilidad entre los mismos. En vir-

tud 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.


Lenguajes .NET

La definición de un Lenguaje .NET es simple: todo aquel lenguaje de pro-

gramació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 lla-

mamos 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 admi-

nistrados (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 co-

llection), 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.


Capa de servicios

La capa de servicios se encarga de proporcionar los medios de comunica-

ción de datos entre los lenguajes y herramientas de desarrollo, y los ele-

mentos 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 Applica-

tion Services está dirigido hacia los desarrollos en ambiente Web (Inter-

net, Intranet, y Computación móvil), mientras que Windows Application

Services está dirigido a los desarrollos en ambiente Windows (aplicacio-

nes de escritorio y Cliente/Servidor).


Biblioteca de clases base de .NET Framework (BCL)

Para entender la Biblioteca de clases de .NET Framework (BCL / Base Class Li-

brary), 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 (comporta-

miento), y los resultados que proporciona.

Al proceso de derivar un objeto a partir de una clase, se le llama ins-

tanciación.

Los objetos tienen propiedades, métodos y eventos.


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 ins-

tanciar 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 uti-

lizados, 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 estruc-

turas 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 canti-

dad de clases, y cada una de ellas ofrece una determinada funcionalidad

que puede ser integrada a las aplicaciones. Algunas permiten crear obje-

tos que desarrollan cálculos matemáticos o trigonométricos, otras permi-

ten definir objetos que nos ayudan a realizar gráficos, otras permiten cre-

ar 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.

Espacios de nombres / Namespaces. 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).

NNOOTTAA

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


programa en .NET no necesariamente están contenidas en los mismos ar-

chivos de librerías, pero al momento de programar eso es irrelevante para

el desarrollador.

Garantizando la disponibi l idad de las clases: referencia y

declaración de l ibrerías. 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 recur-

so lógico. En otras palabras, hay que decir qué librería se requiere (refe-

rencia física), y qué espacio de nombre la refiere (referencia lógica).

Para la referencia física es necesario que al compilar establezcamos la re-

ferencia a la librería (DLL) que requerimos. Para la referencia lógica, de-

pendiendo del lenguaje en el que esté codificando, se utilizarán instruc-

ciones 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.

Instanciación de objetos. Si ya declaró las librerías, entonces ya

dispone de las clases contenidas en ellas; como ya dispone de clases, pue-

de generar objetos (instanciar), y cuando ya tenga objetos, puede hacer

uso de sus métodos para realizar alguna tarea determinada.

Código type safe. Cuando los métodos de los objetos y los types uti-

lizados 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 li-

brería específica en la cual se ha de buscar la clase, o bien, no se han de-

clarado los espacios de nombres que faciliten la ubicación de la clase bus-

cada, dentro de la jerarquía.

Jerarquías de clases superiores. 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 fun-

cionalidad. 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 compo-

nente físico está asociado con un determinado espacio de nombres. Re-

almente, 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-


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 am-

biente 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 sa-

ber 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 de la biblioteca de clases y los

lenguajes

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 Vi-

sual Basic por utilizar una herramienta “tan limitada”; si un programador

de Visual Basic 6.0 deseaba desarrollar programas con la misma funcio-

nalidad que C++, era necesario que aprendiera el manejo del API (Applica-

tion Programming Interface) de Windows, y dicha opción podía ser bastan-

te 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 programa-

dor 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 es-

pacio 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-


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 po-

dremos estar codificando al mismo tiempo múltiples proyectos en múlti-

ples lenguajes.

Realizar esto antes de .NET era impensable. El desarrollador debía

aprender las palabras reservadas de cada uno de los lenguajes que apren-

diera. Cada lenguaje poseía su propia biblioteca de clases (Class Founda-

tion), 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 pro-

pia herramienta de desarrollo, llegaríamos a la conclusión de que el pro-

gramador consumía todo su tiempo en aprender las herramientas de de-

sarrollo 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 pro-

gramas y en capacitación.


CLR (Common Language Runtime)

Motor común de ejecución. Uno de los puntos más interesantes que

aporta .NET es que cambia la forma en que se compilan y ejecutan los

programas.

Compi lación en dos fases en .NET. La plataforma .NET compila

los programas a dos tiempos, separando la fase de análisis de la compila-

ció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, admi-nistración del ciclo de vida de los objetos, administración de memoria, re-cuperación de recursos (garbage collector), pistas de depuración, etcétera.


Tiempos de Compilación en .NET

CLR trabaja en dos tiempos:

1. Tiempo de compilación, que inicia cuando usted utiliza cualquier com-

pilador 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 compilado-

res justo a tiempo que producen código nativo, para luego producir

los efectos esperados del programa.

NNOOTTAA

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 com-

pilación y ejecución que abstrae y coloca en un plano subyacente las dife-

rencias 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


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 Frame-

work.

NNOOTTAA

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 Micro-

soft, y que dicha compañía tardó años en diseñarlo.

Compilador para generar código intermedio

CLR en tiempo de compilación. El trabajo de CLR comienza cuan-

do 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.

Ensamblado | assembly. Al compilar un programa en .NET, se ge-

nerará un ejecutable reconocido solamente por la plataforma .NET, al cual

se le da el nombre de ensamblado (assembly); un ensamblado es un conjun-

to 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 en-

samblado. Usted puede determinar qué tipo de ejecutable desea obte-

ner 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.

Metadatos. A lo largo de su vida, usted tal vez ha utilizado muchos

programas ejecutables, e incluso es posible que los haya creado. Que-

remos 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-


chivo (EXE), no son iguales. El ejecutable creado por alguno de los com-

piladores de .NET estará compuesto por dos elementos: código y metada-

tos (este último no existe en los ejecutables comunes).

El código es el conjunto de instrucciones que forman el programa, y el me-

tadatos es la información que describe cada elemento que ha de ser admi-

nistrado 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, ver-

sió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 pla-

taforma .NET, y por tanto posee metadatos, se dice que es un programa

con código administrado (managed code).

Código administrado / managed code. Un dato que es importan-

te mencionar es que si su computadora no tiene instalado el .NET Fra-

mework 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 Frame-

work poseen el CLR, y el CLR es necesario para poder tener acceso a me-

tadatos; podemos decir que existe un contrato de cooperación entre el eje-

cutable 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.

Diversos nombres de los ensamblados. Los ejecutables que se ob-

tienen después de compilar el código fuente son conocidos de varias for-

mas; ya los referimos como código administrado. El código administra-

do también es conocido como ensamblado (assembly), como MSIL (Microsoft

Intermediate Language), como IL (Intermediate Language), o como código in-

termedio. 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 compila-

ció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 defini-

ción, un ensamblado es una colección de funcionalidad, control de ver-

siones e implementación, que actúa como la unidad básica de ejecución

para el .NET Framework.

Manif iesto. 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:


Identidad del ensamblado (public key token).

Referencia de los archivos que el ensamblado requiere para ser im-

plementado.

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 in-

formación en el registro de Windows, pues todo lo que necesitamos saber

se encuentra en el manifiesto del ensamblado.

Copy deployment. Todo lo que necesita un ejecutable para trabajar se

encuentra declarado en el ensamblado; es por ello que un programa eje-

cutable en .NET trabajará con solo ser copiado a un equipo: no hay que

instalar componentes, o instalaciones complejas, sólo se copia el ensam-

blado; 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 desarrolla-

dores en la misma organización que desarrollen sus propias librerías.

Aunque remota, existe la probabilidad de que dos desarrolladores distin-

tos generen, para utilizar en una misma aplicación, una librería comparti-

da 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 de-

ben registrarse en un recurso llamado Global Assembly Cache (GAC); este

recurso almacena las entradas de los componentes y librerías .NET, regis-

trando para cada uno diferentes especificaciones, de entre las cuales des-

taca PublicKeyToken, que constituye un identificador único del compo-

nente.

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


dos componentes compartidos del mismo nombre físico, pero nuestro

programa sabrá siempre cuál es el que debe utilizar.

Administrador de GAC. Existe una herramienta de .NET Frame-

work, 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 com-

partido, o remover un componente compartido, previamente registrado.


.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 im-

plementar proyectos en .NET surjan cuestiones del por qué hay que insta-

lar .NET Framework en las máquinas para poder ejecutar los programas

.NET. Esto genera suspicacias y dudas: ¿seguirán trabajando mis aplica-

ciones 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 indepen-

diente de la instalación actual que tiene, por lo que no modifica sus apli-

caciones 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.

Archivo PE. Un ejecutable de Windows (Windows executable), sea EXE o

DLL, debe poseer un formato llamado PE Format (Portable Executable For-

mat), que es un derivado del Microsoft Common Object File Format (COFF).


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úbli-

camente, 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 recono-

cidos 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 bas-

tante conocidas para los que han desarrollado compiladores, como lo son

.data, .rdata, .rsrc, y .text.

Archivo .NET PE. Un archivo PE de .NET es más complejo, pues con-

tiene 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 meta-

datos y el código intermedio, lo que determina la forma en como el pro-

grama 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 recono-

cer las nuevas secciones del ejecutable, que ordenarán la compilación JIT

de la información contenida en datos CLR.

Desensamblador de ensamblados. .NET Framework posee una

herramienta de línea de comando para desensamblar los archivos ejecu-

tables, llamado ildasm.exe; con dicha herramienta podemos compro-

bar si un programa es o no .NET, al aplicar el siguiente comando:

ildasm /TEXT NombreEjecutable /HEADER


Donde NombreEjecutable es el nombre del ejecutable que queremos anali-

zar. 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.


Compiladores JIT

CLR en tiempo de ejecución. El ejecutable generado por los compi-

ladores 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 car-

gador 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 tratamien-

to 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 pre-

viamente en dicho equipo. En caso de que sea la primera vez que se eje-

cuta 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 ensambla-

dos, 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.


Los compiladores JIT son los que realizan la fase de síntesis de la compi-

lació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, conside-

rando la plataforma de la misma, así como la disponibilidad de recursos

que posee.

NNOOTTAA

El hecho de que se realice la compilación JIT la primera vez que se ejecu-

ta 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 compila-

ció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 porta-

bles. Quien determina la diferencia del código nativo que ha de ejecutar-

se 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 pro-

cesador, 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 fun-

cionalidad disponible para cada una de las plataformas mencionadas.

Poco importa también en qué lenguaje estaba desarrollado el código fuen-te que dio origen al ejecutable: después de compilarlo, todo es IL.

NNOOTTAA

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-


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.

NNOOTTAA

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 sub-

conjunto funcional del CLR, denominado CLI (Common Language Infraes-

tructure), 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 cual-

quier 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 ver-

siones OEM lo incluirán como parte de los mismos.

Ensamblador de .NET. Existen también herramientas de .NET Fra-

mework 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 com-

pilador 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 desarrolla-

da 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.


Modificaciones de .NET al Sistema Operativo

Los sistemas operativos son, a fin de cuentas, los que reciben las instruc-

ciones 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 ejecu-

tables 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 re-

gistran, a fin de que pueda disponer de todas las clases de .NET.


No se confunda, el hecho de que usted no requiera registrar sus compo-

nentes 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 loca-

les, a través de componentes, mientras que las aplicaciones que usted

desarrolle en .NET ya no serán basadas en componentes, y se comuni-

carán a través de protocolos abiertos; en cierta forma, se aprovecha lo me-

jor 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 Explo-

rer, que tiene una amplia integración con los sistemas operativos Win-

dows.

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.


Convivencia de .NET y COM

Seguramente las organizaciones tienen desarrollos basados en componen-

tes 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 en-

samblado, una librería con la cual los componentes COM puedan interac-

tuar.

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.


EEjjeerrcciicciioo 0011..0011

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 mis-

mo valor en dicha columna ¿Qué cree que signifique eso?


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



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 Hola-

MundoA.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. ¿Qué as-

semblies externos se mandan llamar desde este programa?

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

FIN DEL EJERCICIO


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 correspondien-tes. ¿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 res-pecto? 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.


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 for-ma de evitar esto y prevenir la inspección de nuestro programa?

3. Procure investigar cuantos lenguajes que cumplen con la CLI existen ac-tualmente 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 res-pecto y explíquelas.

39

Técnicas de

desarrollo usando

Visual Studio 2005

2

OObbjjeettiivvooss:: 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, basa-

do 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.

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 CCrreeaannddoo uunnaa aapplliiccaacciióónn ddee CCoonnssoollaa eenn VViissuuaall BBaassiicc uussaannddoo VViissuuaall SSttuuddiioo.................... 5500

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

CCrreeaannddoo uunnaa aapplliiccaacciióónn WWiinnddoowwss eenn VViissuuaall BBaassiicc uussaannddoo VViissuuaall SSttuuddiioo,,

ttrraabbaajjaannddoo vvaarriiooss pprrooyyeeccttooss eenn uunnaa ssoolluucciióónn ........................................................................................ 6611 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

CCrreeaannddoo uunnaa aapplliiccaacciióónn WWeebb eenn VViissuuaall BBaassiicc uussaannddoo VViissuuaall SSttuuddiioo,,

ttrraabbaajjaannddoo vvaarriiooss pprrooyyeeccttooss eenn uunnaa ssoolluucciióónn ........................................................................................ 6699 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 dife-

rencias.

Si se utiliza Visual Studio, todo nuestro trabajo se organizará en solucio-

nes y proyectos.

Una solución es el nivel más alto o global de organización en Visual Stu-

dio, y consiste en una colección de proyectos, administrados en una sola

estructura.

Las soluciones almacenan información respecto a los proyectos que agru-

pan, 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 compila-

dos 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


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 gene-

rarán ensamblados, por ejemplo proyectos de setup, pero son los menos.

Un proyecto puede formar parte de varias soluciones, por lo que es posi-

ble organizar por módulos una aplicación, y al mismo tiempo se puede

tener una solución maestra que englobe a todos los proyectos. Subdivi-

dir es una buena práctica, ya que al momento de estar desarrollando y so-

licitar 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 gran-

des: 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 aho-

ra 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 perso-

na 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 proyec-

tos que utilizan diferentes lenguajes .NET, pero un proyecto sólo puede

tener código fuente de un solo lenguaje.

>> LLoo nnuueevvoo

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 posi-

ble crear proyectos autónomos (stand-alone projects); cuando una solu-

ción sólo se compone de un proyecto, no es necesario hacer la gestión


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íge-

nes de clases, y no sólo archivos DLL.


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 de-

sarrollo.

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 des-

arrolladores 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. Traba-

jar 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 siguien-

tes 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


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 sub-

módulos se haga en un equipo local, y nunca en un ambiente de pro-

ducció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 res-

ponsable, 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 progra-

mas que componen la aplicación, pero no se trabaja sobre ella. En es-

ta 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á fi-

nalmente para generar el entregable.

Creando aplicaciones en Visual Studio

El procedimiento más sencillo para la creación de una solución es ingre-

sando 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.

>> LLoo nnuueevvoo

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

Ahora las 4 secciones (Open an existing project, Getting Started, Head-

lines, and News) aparecen en una sola página.


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ática-

mente se tendrá una solución del mismo nombre. La desventaja de esta

modalidad es que en aplicaciones grandes, nunca un proyecto y una solu-

ció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 moti-

va la creación automática de una solución homónima, Visual Studio en-


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 re-

cursos iniciales de la aplicación.

Visual Studio preguntará dónde se desea guardar la aplicación (Loca-

tion), y con qué nombre (Name). Los archivos fuente que usted genere

se encontrarán en el directorio que usted especifique. Se generará un ar-

chivo 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 nom-

bre específico a la solución (Solution Name).

>> LLoo nnuueevvoo

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.


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 conocimien-

to 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 Mo-

dule, 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 ce-

rrarse.


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 resol-

verse, o para delimitar argumentos.

9. Las variables que se utilicen en un programa deben estar defini-

das 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 pala-

bras 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



Creando una aplicación de Consola en Visual Basic usando

Visual Studio

Desarrollará una aplicación de consola, que al presionar INTRO muestre un mensa-

je «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, por-

que queremos trabajar con soluciones de Visual Studio.

4. En Templates seleccionamos Blank Solution. Al seleccionar el tipo de proyec-

to, 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 Loca-

tion 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-


ntro del medio de almacenamiento. Haga clic en Ok para que se genere una

solución llamada Ejercicios.

7. Al aceptar los cambios, se generará un directorio llamado Ejercicios en el direc-

torio de trabajo. En dicho directorio existirá un archivo denominado Ejerci-

cios.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 tie-

nen en una solución. Para disponer de forma visual de Solution Explorer po-

demos 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-


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 Lo-

cation 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 so-

lución un directorio llamado HolaMundoCon. En dicho directorio se encon-

trará 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 invo-

lucrados 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 especi-

ficaciones útiles para la compilación del proyecto, y en \obj se colocarán archi-

vos 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 aplica-

ció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.


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 mo-

dificando el código de Module1.vb.


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 mu-

chas herramientas que ofrece, dentro de las cuales se encuentran las siguientes.

a. Barra de selección de documentos . En la parte superior de Text

Editor aparecerá una barra que mostrará las pestañas (Tabs) que permi-

tirán seleccionar el documento con el que deseamos estar trabajando.

b. Tabs . 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. Selector de documentos act ivos . 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 selec-

ción, hacer clic en el Selector de documentos activos (flecha ) permite

ver los documentos activos en forma de menú, y seleccionarlos.

d. Cerrado de documentos . 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. Delimitadores de branchin 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 procedi-

miento, módulo o clase, en las líneas delimitadoras de branching apare-

cen símbolos (-) y (+); estos pequeños iconos permiten visualizar y ocul-

tar el código delimitado, con lo que podemos hacer más clara nuestra


codificación, mostrando sólo aquellas partes del código que realmente

nos interesa observar.

f. Complementación automática de c ódigo . 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 codifi-

cación, además que evita errores por omisión de código.

g. Color ing . Es la capacidad de Text Editor de diferenciar por colores

los elementos del código. Generalmente las palabras reservadas es-

tarán en azul, identificadores y operadores en negro, y comentarios en

verde. Esto es útil sobre todo cuando no estamos seguros de estar es-

cribiendo correctamente las palabras reservadas. Si no se ponen de co-

lor azul, es que no están siendo bien escritas.

h. Divisores de procedimientos . Son las delimitaciones horizontales

que separan los procedimientos incluidas en el código.

i. Divisor de paneles de edició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 pro-

gramas muy extensos, en donde desea estar comparando porciones de

código que es imposible mantener juntas en una misma pantalla.

j. Selector de elementos . Se trata de un combo que muestra los di-

ferentes 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. Selector de miembros . 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. Intel l isense . 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ódi-

go. Muy probablemente si se presentan problemas al momento de compila-

ción o ejecución, Visual Studio referirá el número de línea que presenta proble-

mas. 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-


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.


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 pre-

tendemos 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énte-

sis derecho, y vea cómo Intellisense complementa el código de forma automáti-

ca, desapareciendo.


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 polimor-

fismo con que el objeto fue programado. Utilizando los iconos de la ayu-

da 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 sin-

taxis, 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á.


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, nues-

tro programa enviará un mensaje, esperará el uso del teclado, y enviará final-

mente 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, respectiva-

mente.

Generando (Build) una solución en Visual Studio

28. Generar una solución consiste en tratar de compilar todos los programas y ele-

mentos de todos los proyectos asociados a una solución. Al realizase la compi-

lación se generan los ensamblados correspondientes a cada uno de los proyec-

tos, quedando listos para su ejecución.


29. Vaya al menú Build – Build Solution (CTRL-MAYÚS-B), para generar la solu-

ción.

30. En la parte inferior de Visual Studio se abrirá la ventana Output, que es la en-

cargada 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 co-

mandos 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 correc-

to, dado que se tuvo éxito en la construcción de un proyecto, encontrándose ce-

ro fallas.

Depurando una solución

31. Vaya al menú Debug – Start Debugging (F5) para depurar la aplicación. Al de-

purar 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 proble-

mas 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. Al hacer clic se mos-

trará muy rápidamente el mensaje «Hola Mundo».

FIN DEL EJERCICIO



Creando una aplicación Windows en Visual Basic usando

Visual Studio, trabajando varios proyectos en una solu-

ció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 Tem-

plates, 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.


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 Fra-

mework 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 encar-

ga 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 au-

tomá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 fi-

jo cuando permanece en el espacio de trabajo de Document Window, indepen-

dientemente 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 siguien-

te 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 esta-

do a modo fijo. La interfaz deberá quedar de la siguiente manera.


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, arras-

trando 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 – Com-

mon 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.


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 propieda-

des 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 propie-

dad (Name), y cambie el nombre Label1 por lblResultado. Presione IN-

TRO. El nombre habrá cambiado en el combo superior de la ventana Proper-

ties, 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


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 res-

ponda 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 But-

ton1_Click. Vea cómo el editor nos deja listos para codificar lo que debe su-

ceder 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 docu-

mentos, 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 selec-

cionadas 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 utili-

zada 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 apa-

recerá como un navegador de páginas Web intrínseco de Visual Studio, dado

que es una página Web.


28. Seleccione alternativamente los diferentes Tabs que se tienen, y vea el compor-

tamiento de Visual Studio. Si alguno de los documentos abiertos desea cerrar-

se, 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 documen-

to posee modificaciones que no han sido guardadas.

30. Guarde todos los cambios. Para ello invoque el menú File – Save All, o presio-

ne 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 gene-

rado 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 pro-

yectos, sin embargo, toda solución debe tener un proyecto de inicio (startup pro-

ject). 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 selec-

cionado como proyecto de inicio.

33. Vea la ventana del Solution Explorer. Actualmente en la solución Ejerci-

cios tiene dos proyectos registrados: el programa de consola del ejercicio ante-

rior (HolaMundoCon), y el proyecto Windows que estamos trabajando (Hola-

MundoWin). 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.


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 pro-

yecto de Windows será nuestro proyecto de inicio.

35. En nuestro caso, como la aplicación Windows sólo contiene un formulario Win-

dows, 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 for-

mulario 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 mostrar-

se 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.


39. Si no hubo problemas, depure la aplicación (F5). Se depurará nuestro proyecto

de inicio, es decir, nuestra aplicación Windows.

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ó ade-

cuadamente.

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

FIN DEL EJERCICIO



Creando una aplicación Web en Visual Basic usando Vi-

sual 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 Frame-

work e Internet Information Server. Si creamos una aplicación ASP.NET, Vi-

sual Studio intentará almacenarla como un sitio dependiente del sitio Web pre-

determinado, 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 di-

rectorio 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 lla-

me HolaMundoWeb. Ese directorio será el directorio de trabajo de la aplica-

ció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....

http://localhost/


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 di-

rectorio 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.


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 selec-

cionar 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 regis-

trados. Seleccione su sitio APVBNETVS. Haga clic en Open para aceptar.


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 inte-

grar objetos en la interfaz. En modo Source es necesario que se agreguen las

etiquetas en el lugar indicado.


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 procedimien-

to 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.


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 solu-

ció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

http://localhost/APVBNETVS/

http://localhost/APVBNETVS/


Preguntas de competencia

1. Al hacer las pruebas del código escrito, este se ejecuta sin aparente pro-blema. Sin embargo, los resultados que arroja son incorrectos. ¿Qué re-curso 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 se-guirí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 Vi-sual Studio?

6. Hasta el día de hoy, han estado trabajando con Visual Studio para produ-cir 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


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 instala-dor 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.

aprenda workbook: visual basic 2005 - primeros dos capítulos

Documents