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.
4 Plataforma .NET Versión 2005
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.
Plataforma .NET Versión 2005 5
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.
6 Plataforma .NET Versión 2005
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
Plataforma .NET Versión 2005 7
los programas desarrollados en un lenguaje .NET y el resto de los
elementos de .NET Framework, con el fin de generar 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-
8 Plataforma .NET Versión 2005
ductos nuevos, existía la necesidad de diferenciarlos de las propuestas
anteriores. Incluso, internamente en la compañía se penalizaba a quien
osara referirse a Visual Basic.NET como Visual Basic 7. Con la versión 1.1
de .NET Framework, los lenguajes pasaron a ser Visual Basic.NET, Visual
C# y Managed C++, trabajándose con Visual Studio.NET 2003. Ahora en
la versión 2.0 de .NET Framework ya las versiones anteriores de los 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.
Plataforma .NET Versión 2005 9
Cualquier desarrollador experimentado puede aventurarse a desarrollar
su propio lenguaje de programación basado en .NET y proponerlo al
mercado. Basta con desarrollar las herramientas necesarias para el 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
10 Plataforma .NET Versión 2005
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.
Plataforma .NET Versión 2005 11
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.
12 Plataforma .NET Versión 2005
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).
Plataforma .NET Versión 2005 13
Biblioteca de clases base de .NET Framework (BCL)
Para entender la Biblioteca de clases de .NET Framework (BCL / Base Class 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.
14 Plataforma .NET Versión 2005
Los métodos son las acciones predefinidas que es posible realizar a
través de un objeto. Para poder utilizar un método es necesario 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
Plataforma .NET Versión 2005 15
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-
16 Plataforma .NET Versión 2005
ferencia a la librería a través del espacio de nombres que a través de una
ruta de archivo físico.
Con lo ya expuesto podemos finalmente definir a la biblioteca de clases
de .NET Framework, como una colección de clases incluidas en el 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-
Plataforma .NET Versión 2005 17
teada (dotted), que diferencia espacios de nombres, clases y types (estos
últimos, opcionales en algunos casos):
Namespace.Class[.Type]
Además, todos los lenguajes de desarrollo son soportados por un mismo
entorno integrado de desarrollo, llamado Visual Studio, con el cual 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.
18 Plataforma .NET Versión 2005
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.
Plataforma .NET Versión 2005 19
Tiempos de Compilación en .NET
CLR trabaja en dos tiempos:
1. Tiempo de compilación, que inicia cuando usted utiliza cualquier 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
20 Plataforma .NET Versión 2005
la compilación y ejecución de los programas en .NET, con el fin de que
puedan aprovechar la biblioteca de clases y los servicios de .NET 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-
Plataforma .NET Versión 2005 21
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:
22 Plataforma .NET Versión 2005
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
Plataforma .NET Versión 2005 23
dos componentes compartidos del mismo nombre físico, pero nuestro
programa sabrá siempre cuál es el que debe utilizar.
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.
24 Plataforma .NET Versión 2005
.NET PE (.NET Portable Executable) versus
PE/COFF
Si tanto usted como la empresa en la que trabaja se está iniciando en la
experiencia llamada .NET, es probable que se quiera saber por qué los
ejecutables generados en versiones anteriores de Visual Basic 6.0 y los
generados en .NET son distintos; es muy probable que al tratar de 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).
Plataforma .NET Versión 2005 25
A los programas ejecutables, por cumplir con la especificación PE, se les
ha dado a llamar también Archivos PE.
Tanto PE como COFF están claramente especificados y disponibles pú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
26 Plataforma .NET Versión 2005
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.
Plataforma .NET Versión 2005 27
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.
28 Plataforma .NET Versión 2005
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-
Plataforma .NET Versión 2005 29
cutable, además de no ser posible transformar el IL en código nativo, por
la ausencia de CLR; en ese contexto y dicho de otra forma, su programa
nunca podría producir a partir del ensamblado la secuencia de números
binarios que provoquen una respuesta en su computadora.
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.
30 Plataforma .NET Versión 2005
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.
Plataforma .NET Versión 2005 31
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.
32 Plataforma .NET Versión 2005
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.
Plataforma .NET Versión 2005 33
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?
34 Plataforma .NET Versión 2005
5. Existe una columna llamada Public Key Token, que se trata de una clave GUID
(Global Un ique Identifier) ¿Para qué cree que sirva dicha clave?
6. Cierre el programa de configuración de .NET Framework 2.0.
FIN DEL EJERCICIO
Plataforma .NET Versión 2005 35
EEjjeerrcciicciioo 0011..0022
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
36 Plataforma .NET Versión 2005
Preguntas de competencia
1. ¿Qué lenguaje de programación actual recomendaría para desarrollar aplicaciones que maximicen el retorno de inversión dedicado a ellas?
2. Le han solicitado que proporcione el código necesario para ejecutar la aplicación que anteriormente le habían solicitado por lo que le indican que requieren la inmediata entrega de los ensamblados 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.
Plataforma .NET Versión 2005 37
Investigación
1. ¿Es posible identificar un ensamblado de la GAC con respecto al código fuente que le dio origen?
2. Dado que un ensamblado puede ser “desensamblado” ¿Existe alguna 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
42 Técnicas de desarrollo usando Visual Studio 2005
de .NET Framework o a bibliotecas creadas por el usuario, archivos XML,
HTML, y en fin, todo lo necesario para generar un ensamblado.
Visual Studio posee más de 90 diferentes tipos de proyectos. La ventaja
de utilizarlos es que seleccionando el tipo de proyecto adecuado, Visual
Studio se encarga de crear los archivos mínimos para el tipo de aplicación
seleccionada, y además establece de forma automática las referencias a
clases de .NET Framework usualmente requeridas.
Es importante mencionar que algunos proyectos muy especiales no 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
Técnicas de desarrollo usando Visual Studio 2005 43
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.
44 Técnicas de desarrollo usando Visual Studio 2005
Trabajo Colaborativo recomendado en .NET
Se conoce como desarrollos colaborativos a las iniciativas de desarrollo que
son tan grandes que el trabajo debe distribuirse en varios equipos de 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
Técnicas de desarrollo usando Visual Studio 2005 45
archivos del módulo; la compilación y depuración sólo se realizará
sobre lo que estamos trabajando, y no sobre lo que están trabajando
otros.
2. Se recomienda que el trabajo de desarrollo de módulos y 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.
46 Técnicas de desarrollo usando Visual Studio 2005
Figura
02.01
Start Page
En Start Page se selecciona la opción de menú File – New – Project (o
presionar CTRL-MAYÚS-N). Aparecerá la ventana New Project, que
nos permite seleccionar el lenguaje que deseamos utilizar, así como el tipo
de proyecto que deseamos construir.
Figura
02.02
New Project
Al proporcionar los datos del proyecto que se desea agregar, automá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-
Técnicas de desarrollo usando Visual Studio 2005 47
tiende que la solución se compone de un solo proyecto, a lo que se llama
proyecto autónomo (stand-alone project); en este tipo de proyecto no se da
mucha relevancia al concepto de solución dentro del entorno integrado de
desarrollo.
Es indispensable saber qué lenguaje .NET es el que desea utilizar (Project
Type), y decidido esto, es necesario saber qué tipo de aplicación se desea
(Templates). Las plantillas o templates permiten predeterminar los 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.
48 Técnicas de desarrollo usando Visual Studio 2005
Elementos de sintaxis en Visual Basic
Visual Basic es el heredero de la tradicional sintaxis del lenguaje Visual
Basic 6.0. Para no comenzar a desarrollar programas sin un 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.
Técnicas de desarrollo usando Visual Studio 2005 49
7. Las bibliotecas a utilizarse en un programa se declaran al inicio
del mismo, utilizando la palabra reservada Imports.
8. Se utilizan paréntesis para delimitar expresiones que deban 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
50 Técnicas de desarrollo usando Visual Studio 2005
EEjjeerrcciicciioo 0022..0011
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-
Técnicas de desarrollo usando Visual Studio 2005 51
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-
52 Técnicas de desarrollo usando Visual Studio 2005
dos los elementos típicos de una aplicación de consola, incluyendo archivos de
código fuente, datos y configuraciones que apliquen.
14. En Name coloque el nombre del proyecto, que debe ser HolaMundoCon; en 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.
Técnicas de desarrollo usando Visual Studio 2005 53
18. En este momento Solution Explorer debe mostrar todos los elementos físicos
que componen la solución, y en Document Window se tendrá a Text Editor mo-
dificando el código de Module1.vb.
54 Técnicas de desarrollo usando Visual Studio 2005
Herramientas de Text Editor
19. Text Editor tiene los siguientes elementos.
Figura
02.03
Elementos de
Text Editor
20. Text Editor es una herramienta fascinante de edición de código, dadas las 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
Técnicas de desarrollo usando Visual Studio 2005 55
codificación, mostrando sólo aquellas partes del código que realmente
nos interesa observar.
f. 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-
56 Técnicas de desarrollo usando Visual Studio 2005
tions. Seleccione el nodo Text Editor –Basic – General; habilite el cuadro de
verificación Line Numbers, de la sección Display. Haga clic en Ok.
Intellisense y detección dinámica de errores
23. Dentro del procedimiento Main() introduzca la siguiente línea.
Console.WriteLine(“Presione INTRO”)
Esto se deberá escribir en varios tiempos. Primero escriba «Console.» Al
llegar al punto, aparecerá un menú dinámico que propone los elementos del
lenguaje que concuerdan con el código que comenzamos a escribir, de tal forma
que nosotros iniciamos la escritura, pero puede ser que Visual Studio sea el que
la termine, simplificando el proceso de codificación, además de evitar errores de
sintaxis. A esta funcionalidad se le llama intellisense.
Intellisense tiene en la parte baja dos pestañas: Common y All. Dado que los
elementos de un objeto pueden ser muchos, Visual Studio nos permite ver los
más comunes, o bien todos. Por omisión mostrará los más comunes, lo cual es
muy práctico. Del menú de elementos que aparecen, es posible seleccionar
utilizando el puntero del ratón, utilizando las flechas de dirección, o bien por
concordancia con lo escrito. Sólo en caso de que lo que busque no se encuentre
en Common, recurra a All.
Técnicas de desarrollo usando Visual Studio 2005 57
Siga escribiendo, hasta que haya escrito «Console.WriteL» . La información
que hemos escrito permite una concordancia exacta con un elemento del menú,
mismo que se selecciona.
Para ahorrarnos la escritura, y dado que ya está seleccionado el código que 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.
58 Técnicas de desarrollo usando Visual Studio 2005
Se recomienda ampliamente el uso de Intellisense, dado que se ha demostrado
que reduce en gran medida los errores de sintaxis.
Siga escribiendo la línea de código, y vea cómo aparece una ayuda interactiva
de llenado de los elementos. En este caso, la ayuda nos indica que si escribimos
«WriteLine()», lo que obtendríamos sería un terminador de línea. La ayuda
interactiva nos dice que hay 18 formas de utilizar WriteLine, dado el 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á.
Técnicas de desarrollo usando Visual Studio 2005 59
25. Corrija la línea para que ya no genere errores.
Modificando código usando Text Editor
26. Como todo programa Hola Mundo, se espera que el usuario interactúe con el
programa, y que éste envíe el mensaje «Hola Mundo». Para hacer esto, 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.
60 Técnicas de desarrollo usando Visual Studio 2005
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
Técnicas de desarrollo usando Visual Studio 2005 61
EEjjeerrcciicciioo 0022..0022
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.
62 Técnicas de desarrollo usando Visual Studio 2005
6. Selecciona la opción de menú View – Toolbox (CTRL-ALT-X). Aparecerá la
herramienta Toolbox, que muestra de forma clasificada los controles gráficos
disponibles para una aplicación Windows.
7. Los controles son enlaces gráficos que permiten acceder las clases de .NET 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.
Técnicas de desarrollo usando Visual Studio 2005 63
Agregando objetos de interfaz en tiempo de diseño
12. En Form Designer se pueden agregar objetos de interfaz de tres maneras: Modo
inserción, haciendo doble clic sobre alguno de los controles; Modo arrastre, 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.
64 Técnicas de desarrollo usando Visual Studio 2005
18. Seleccione el objeto Label1 que se agregó a la interfaz. Para ello, haga un solo
clic sobre él.
19. Cada elemento en la interfaz es un objeto, y como todo objeto, posee 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
Técnicas de desarrollo usando Visual Studio 2005 65
el usuario. Para ello debemos codificar procedimientos de evento, que son bloques
de código que se ejecutarán cuando el usuario o el programa interactúen de
cierta manera con la aplicación.
23. Deseamos que al hacer clic en el botón, se coloque el texto Hola Mundo en el
objeto lblResultado. Para ello debemos codificar el procedimiento que 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.
66 Técnicas de desarrollo usando Visual Studio 2005
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.
Técnicas de desarrollo usando Visual Studio 2005 67
34. Para hacer que nuestro nuevo proyecto de aplicación Windows sea el proyecto
de inicio, seleccione el nodo HolaMundoWin en el Solution Explorer. Invoque
el menú de contexto y seleccione Set as StartUp Project. De esa forma el 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.
68 Técnicas de desarrollo usando Visual Studio 2005
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
Técnicas de desarrollo usando Visual Studio 2005 69
EEjjeerrcciicciioo 0022..0033
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....
70 Técnicas de desarrollo usando Visual Studio 2005
7. Aparecerá el Asistente para crear un directorio virtual. Haga clic en Siguiente
en la pantalla de bienvenida. Cuando el asistente pregunte por el alias de su
sitio, escriba APVBNETVS, y haga clic en Siguiente.
8. Como directorio de contenido del sitio Web, seleccione o escriba la ruta del 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.
Técnicas de desarrollo usando Visual Studio 2005 71
Creando una aplicación Web ASP.NET
12. En el Solution Explorer seleccione el nodo de la solución Ejercicios, y desde
el menú de contexto seleccione Add – New Web Site. Con lo que aparecerá la
ventana Add New Web Site.
13. En Templates seleccione ASP.NET Web Site. En Location haga clic en el botón
Browse. Con ello aparecerá la ventana Choose Location, que permite 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.
72 Técnicas de desarrollo usando Visual Studio 2005
15. Se generará el sitio Web ASP.NET. La página principal sobre la que se estará
trabajando es la página Default.aspx; las páginas pueden trabajarse en modo
de diseño (Design) y en modo codificación (Source). La forma de alternar entre uno
y otro modo es seleccionando las pestañas que aparecen en la parte inferior de
Document Window. Al estar en Design, se puede utilizar Toolbox para inte-
grar objetos en la interfaz. En modo Source es necesario que se agreguen las
etiquetas en el lugar indicado.
Técnicas de desarrollo usando Visual Studio 2005 73
16. Vaya a modo de diseño (Design) y utilizando Toolbox (CTRL-ALT-X), agregue
un Button y un Label.
17. Seleccione el objeto Label1, y asigne en la propiedad Name, el mismo nombre
que asignó en Windows: lblResultado.
18. Haga doble clic en el botón que agregó a la interfaz. Aparecerá el 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.
74 Técnicas de desarrollo usando Visual Studio 2005
20. Vuelva a generar la solución (CTRL-MAYUS-B), y si no hay problemas en la
generación, depure la aplicación (F5). Debe funcionar igual que la aplicación
Windows: al hacer clic en el botón, el mensaje de la etiqueta debe cambiar.
21. En este ejercicio comprobamos que el desarrollo Windows y Web, realizado
desde Visual Studio es prácticamente idéntico.
22. Finalmente nuestro proyecto quedaría como sigue.
23. En cualquier momento puede llamar a edición cualquier elemento de la 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
Técnicas de desarrollo usando Visual Studio 2005 75
Preguntas de competencia
1. Al hacer las pruebas del código escrito, este se ejecuta sin aparente 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
76 Técnicas de desarrollo usando Visual Studio 2005
Investigación
1. Existen recursos que pueden ayudar en tiempo de codificación y pruebas como los llamados Assertions ¿Qué propósito tienen y como se utilizan?
2. Investigue acerca de los diferentes snippets que incluye Visual Studio y demuestre en una presentación el uso de algunos de ellos y explique cómo estos pueden ayudarle a reducir los errores de escritura de código y el tiempo invertido en tal actividad.
3. ¿Cuál es el procedimiento para crear un proyecto que genere un 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.