Guia_practica_del_desarrollo_aplicaciones_windows_en_net_free

Vista previa del material en texto

Guía práctica del 
desarrollo de 
aplicaciones 
Windows en .NET
Alberto Población, Luis Alfonso Rey, 
Jorge Cangas & José Vicente Sánchez 
© Danysoft 
Libro para José Mora 
DERECHOS RESERVADOS 
El contenido de esta publicación tiene todos los derechos reservados, por lo que no 
se puede reproducir, transcribir, transmitir, almacenar en un sistema de 
recuperación o traducir a otro idioma de ninguna forma o por ningún medio 
mecánico, manual, electrónico, magnético, químico, óptico, o de otro modo. La 
persecución de una reproducción no autorizada tiene como consecuencia la cárcel 
y/o multas. 
LIMITACIÓN DE LA RESPONSABILIDAD 
Tanto el autor como en Danysoft hemos revisado el texto para evitar cualquier tipo 
de error, pero no podemos prometerle que el libro esté siempre libre de errores. Por 
ello le rogamos nos remita por e-mail sus comentarios sobre el libro en 
attcliente@danysoft.com 
DESCUENTOS ESPECIALES 
Recuerde que Danysoft ofrece descuentos especiales a centros de formación y en 
adquisiciones por volumen. Para más detalles, consulte con Danysoft. 
MARCAS REGISTRADAS 
Todos los productos y marcas se mencionan únicamente con fines de identificación y 
están registrados por sus respectivas compañías. 
Autores: Alberto Población, José Vicente Sánchez, Jorge Cangas, y Luis Alfonso Rey 
Publicado por Danysoft 
Avda. de la Industria, 4 Edif. 1 3º 
28108 Alcobendas, Madrid. España. 
902 123146 | www.danysoft.com 
ISBN: 978-84-939910-3-6 
Depósito Legal: M-15718-2012 
Libro para José Mora 
Si no es ese usuario rogamos nos lo comente a attcliente @ danysoft.com 
IMPRESO EN ESPAÑA 
© Danysoft | Madrid, 2012 
 
 
 Tabla De 
Contenidos 
TABLA DE CONTENIDOS ................................................................................................ 3 
APARTADO I: PLATAFORMA .NET Y LENGUAJE C# POR ALBERTO 
POBLACIÓN .......................................................................................................... 11 
PRÓLOGO.................................................................................................................... 13 
INTRODUCCIÓN ........................................................................................................... 15 
A CONTINUACIÓN ............................................................................................................... 16 
EL FRAMEWORK .......................................................................................................... 17 
SERVICIOS DEL CLR ............................................................................................................. 18 
LIBRERÍAS DEL FRAMEWORK ................................................................................................. 19 
Espacios de nombres ................................................................................................. 21 
ALGUNAS CLASES DE USO FRECUENTE...................................................................................... 23 
Interfaces de usuario ................................................................................................. 23 
Aplicaciones de escritorio .......................................................................................... 23 
Aplicaciones para Internet ........................................................................................ 24 
Aplicaciones de consola ............................................................................................ 25 
Servicios Windows..................................................................................................... 25 
Colecciones ................................................................................................................ 26 
Entradas/Salidas ....................................................................................................... 26 
Acceso a datos .......................................................................................................... 27 
Globalización ............................................................................................................. 28 
Manipulación de texto .............................................................................................. 28 
Multihilo .................................................................................................................... 29 
4 | Windows Forms 
Libro para José Mora 
Reflexión ................................................................................................................... 30 
A CONTINUACIÓN ............................................................................................................... 30 
EL LENGUAJE C# .......................................................................................................... 33 
NUESTRO PRIMER PROGRAMA ............................................................................................... 34 
EXAMINANDO EL PROGRAMA EJEMPLO .................................................................................... 38 
La directiva using ...................................................................................................... 38 
La declaración del namespace .................................................................................. 39 
La clase ...................................................................................................................... 39 
El método Main ......................................................................................................... 40 
La sentencia de salida ............................................................................................... 40 
A CONTINUACIÓN ............................................................................................................... 41 
ELEMENTOS SINTÁCTICOS BÁSICOS ............................................................................. 42 
COMENTARIOS ................................................................................................................... 43 
Comentarios XML ...................................................................................................... 43 
SENTENCIAS ....................................................................................................................... 45 
Bloques de sentencias ............................................................................................... 46 
SENTENCIAS DE CONTROL DE FLUJO ........................................................................................ 47 
If ................................................................................................................................ 47 
Switch ........................................................................................................................ 48 
While ......................................................................................................................... 50 
Do .............................................................................................................................. 50 
For ............................................................................................................................. 51 
Foreach ..................................................................................................................... 52 
Goto .......................................................................................................................... 52 
Break ......................................................................................................................... 53 
Continue .................................................................................................................... 53 
EXCEPCIONES ..................................................................................................................... 53 
La instrucción throw .................................................................................................. 54 
Las instrucciones try...catch...finally......................................................................... 55 
Desbordamientos aritméticos ................................................................................... 56 
OPERADORES ..................................................................................................................... 57 
Prioridad de los operadores ...................................................................................... 59 
Los operadores is y as ............................................................................................... 59 
A CONTINUACIÓN ............................................................................................................... 60 
SISTEMA DE TIPOS Y DECLARACIONES DE VARIABLES .................................................. 62 
EL SISTEMA COMÚN DE TIPOS ................................................................................................ 63 
Tipos Valor ................................................................................................................ 64 
Tipos Referencia ........................................................................................................ 64 
TIPOS SIMPLES ................................................................................................................... 64 
NOMBRES DE VARIABLES ...................................................................................................... 66 
Reglas ........................................................................................................................ 66 
Sugerencias de buen estilo ........................................................................................ 66 
Windows Forms | 5 
 
Guía práctica de desarrollo de aplicaciones Windows en .NET 
VARIABLES LOCALES ............................................................................................................ 67 
VARIABLES MIEMBRO DE CLASS O STRUCT ................................................................................ 67 
CONSTANTES Y VARIABLES DE SÓLO‐LECTURA ........................................................................... 68 
Constantes de tipo carácter y cadena ....................................................................... 68 
Constantes de tipo numérico .................................................................................... 69 
MODIFICADORES DE ALCANCE ............................................................................................... 69 
ENUMERACIONES ............................................................................................................... 70 
CASTING ........................................................................................................................... 71 
STRUCTS ........................................................................................................................... 72 
ARREGLOS ......................................................................................................................... 73 
Declaración ............................................................................................................... 73 
Acceso a los elementos ............................................................................................. 74 
Propiedades y métodos de los arreglos .................................................................... 74 
Algunas consideraciones sobre los arreglos .............................................................. 75 
LOS TIPOS VAR ................................................................................................................... 76 
LOS TIPOS DYNAMIC ............................................................................................................ 78 
LOS TIPOS NULLABLE ........................................................................................................... 80 
A CONTINUACIÓN ............................................................................................................... 80 
MÉTODOS ................................................................................................................... 82 
DECLARACIÓN .................................................................................................................... 82 
LLAMADA A LOS MÉTODOS ................................................................................................... 83 
SOBRECARGAS.................................................................................................................... 84 
PARÁMETROS OPCIONALES ................................................................................................... 85 
PARÁMETROS CON NOMBRE ................................................................................................. 86 
PARÁMETROS DE ENTRADA Y SALIDA ....................................................................................... 86 
NÚMERO VARIABLE DE ARGUMENTOS ..................................................................................... 88 
A CONTINUACIÓN ............................................................................................................... 89 
PROPIEDADES ............................................................................................................. 91 
DECLARACIÓN .................................................................................................................... 92 
INVOCACIÓN ...................................................................................................................... 93 
COMPARATIVA ................................................................................................................... 93 
PROPIEDADES AUTOMÁTICAS ................................................................................................ 93 
INDEXADORES .................................................................................................................... 94 
A CONTINUACIÓN ............................................................................................................... 95 
DELEGADOS Y EVENTOS .............................................................................................. 96 
DELEGADOS ....................................................................................................................... 97 
Declaración de un tipo de delegado .......................................................................... 97 
Declaración de una instancia  de un delegado ......................................................... 98 
Llamada a un método  a través de un delegado ....................................................... 99 
Delegados anónimos ............................................................................................... 100 
EVENTOS ......................................................................................................................... 101 
Declaración ............................................................................................................. 102 
6 | Windows Forms 
Libro para José Mora 
Suscripción .............................................................................................................. 102 
Disparo .................................................................................................................... 103 
Patrón convencional ............................................................................................... 104 
Accesores para los eventos ..................................................................................... 105 
A CONTINUACIÓN ............................................................................................................. 106 
ORIENTACIÓN A OBJETOS .......................................................................................... 107 
DATOS ESTÁTICOS ............................................................................................................. 108 
CREACIÓN DE INSTANCIAS ...................................................................................................109 
Constructores .......................................................................................................... 110 
Constructores estáticos ........................................................................................... 112 
Destructores ............................................................................................................ 113 
La sentencia using ................................................................................................... 114 
HERENCIA DE CLASES ......................................................................................................... 116 
Clases selladas ........................................................................................................ 117 
SOBRESCRITURA ............................................................................................................... 118 
POLIMORFISMO ................................................................................................................ 120 
CLASES ABSTRACTAS .......................................................................................................... 121 
INTERFACES ..................................................................................................................... 122 
A CONTINUACIÓN ............................................................................................................. 124 
SOBRECARGA DE OPERADORES ................................................................................. 125 
FORMA DE REALIZAR LA SOBRECARGA ................................................................................... 126 
Operadores restringidos.......................................................................................... 127 
OPERADORES DE CONVERSIÓN ............................................................................................. 128 
A CONTINUACIÓN ............................................................................................................. 131 
GENÉRICOS ............................................................................................................... 133 
EL PROBLEMA .................................................................................................................. 133 
Boxing y Unboxing .................................................................................................. 134 
LA SOLUCIÓN ................................................................................................................... 135 
DECLARACIÓN DE RESTRICCIONES ......................................................................................... 137 
A CONTINUACIÓN ............................................................................................................. 139 
EXTENSORES, LAMBDAS Y LINQ ................................................................................. 141 
MÉTODOS DE EXTENSIÓN ................................................................................................... 141 
EXPRESIONES LAMBDA ....................................................................................................... 145 
Árboles de expresiones ............................................................................................ 146 
LINQ ............................................................................................................................. 147 
A CONTINUACIÓN ............................................................................................................. 151 
OTRAS CARACTERÍSTICAS .......................................................................................... 153 
ATRIBUTOS ...................................................................................................................... 153 
CLASES PARCIALES ............................................................................................................ 155 
Métodos parciales ................................................................................................... 156 
Windows Forms | 7 
 
Guía práctica de desarrollo de aplicaciones Windows en .NET 
INICIALIZADORES DE COLECCIONES ........................................................................................ 158 
ENUMERADORES .............................................................................................................. 159 
COVARIANCIA Y CONTRAVARIANCIA ...................................................................................... 160 
CONCLUSIÓN ................................................................................................................... 163 
APARTADO II: ADO Y LINQ POR JORGE L.CANGAS .......................... 165 
¡CONECTADO! ........................................................................................................... 167 
SQLCONNECTION .............................................................................................................. 171 
DBPROVIDERFACTORY ....................................................................................................... 173 
RECORDATORIO ................................................................................................................ 176 
EL MODO CONECTADO .............................................................................................. 177 
DBCONNECTION ............................................................................................................... 179 
DBCOMMAND ................................................................................................................. 180 
IDATAREADER .................................................................................................................. 182 
IDBDATAPARAMETER ........................................................................................................ 185 
DBCOMMAND “RELOADED” ............................................................................................... 186 
DBTRANSACTION .............................................................................................................. 190 
RECORDATORIO ................................................................................................................ 192 
EL MODO DESCONECTADO ........................................................................................ 195 
DATATABLE ..................................................................................................................... 195 
DATASET ........................................................................................................................ 197 
DATAVIEW ...................................................................................................................... 201 
DATABINDING.................................................................................................................. 202 
TYPEDDATASET ................................................................................................................ 204 
CONCLUSIÓN ................................................................................................................... 209 
LINQ ......................................................................................................................... 211 
CONSULTAS CON LINQ ....................................................................................................... 211 
EXPRESIONES LAMBDA ....................................................................................................... 213 
EVALUACIÓN PEREZOSA...................................................................................................... 214 
OPERADORES DE CONSULTA ................................................................................................ 215 
LINQ PARA DATASET ......................................................................................................... 218 
LINQ PARA XML ...............................................................................................................219 
APARTADO III: WINDOWS FORMS POR JOSÉ VICENTE SÁNCHEZ
 ................................................................................................................................. 221 
INTRODUCCIÓN ......................................................................................................... 223 
VISUAL STUDIO ................................................................................................................ 224 
¿POR QUÉ C#? ................................................................................................................ 225 
PRIMEROS PASOS CON WINDOWS FORMS ................................................................ 227 
UN REPASO A LOS CONTROLES BÁSICOS DE WINDOWS FORMS ................................................... 235 
8 | Windows Forms 
Libro para José Mora 
UN EJEMPLO MÁS COMPLETO: WORDPAD ................................................................ 241 
AGREGANDO ALGO DE CÓDIGO ............................................................................................ 249 
GUARDANDO LOS CAMBIOS DEL ARCHIVO .............................................................................. 255 
AGREGANDO UN MENÚ Y UNA BARRA DE ESTADO .................................................................... 258 
FUENTES DE TEXTO ................................................................................................... 267 
LAS FUENTES .................................................................................................................... 267 
CONCLUSIÓN ................................................................................................................... 277 
USANDO ELEMENTOS DE TERCEROS .......................................................................... 279 
USANDO COM ................................................................................................................ 281 
CONCLUSIÓN ................................................................................................................... 289 
APARTADO IV: WINDOWS PRESENTATION FOUNDATION POR 
LUIS ALFONSO REY ......................................................................................... 291 
PRÓLOGO APARTADO IV ........................................................................................... 293 
EL MODELO DE APLICACIÓN ...................................................................................... 295 
APLICACIONES DE WINDOWS .............................................................................................. 295 
APLICACIONES DE NAVEGACIÓN ........................................................................................... 296 
CONCLUSIÓN ................................................................................................................... 298 
A CONTINUACIÓN ............................................................................................................. 299 
XAML ........................................................................................................................ 301 
XML .............................................................................................................................. 302 
Representación ....................................................................................................... 302 
Sistema de propiedades y eventos .......................................................................... 304 
Controles y sus propiedades más comunes ............................................................. 308 
CONCLUSIÓN ................................................................................................................... 314 
A CONTINUACIÓN ............................................................................................................. 314 
PANELES Y LAYOUT ................................................................................................... 315 
PANELES ......................................................................................................................... 316 
CONCLUSIÓN ................................................................................................................... 319 
A CONTINUACIÓN ............................................................................................................. 319 
DATABINDING Y RECURSOS ....................................................................................... 321 
LOS INTERFACES ............................................................................................................... 321 
LAS EXPRESIONES DE BINDING ............................................................................................. 324 
DATACONTEXT ................................................................................................................. 326 
EL BINDING MÚLTIPLE ........................................................................................................ 327 
CONVERSORES ................................................................................................................. 330 
VALIDACIÓN .................................................................................................................... 333 
INTEGRACIÓN CON VISUAL STUDIO ....................................................................................... 337 
DATAPROVIDERS Y COLLECCIONVIEWSOURCE ........................................................................ 339 
Windows Forms | 9 
 
Guía práctica de desarrollo de aplicaciones Windows en .NET 
RECURSOS ....................................................................................................................... 343 
CONCLUSIÓN ................................................................................................................... 344 
A CONTINUACIÓN ............................................................................................................. 344 
COMANDOS .............................................................................................................. 345 
REDEFINIR UN COMANDO ................................................................................................... 345 
CREAR UN COMANDO NUEVO .............................................................................................. 347 
COMANDOS EN LOS NUEVOS CONTROLES ............................................................................... 349 
COMANDOS EN 4.0 ........................................................................................................... 351 
A CONTINUACIÓN ............................................................................................................. 352 
A CONTINUACIÓN ............................................................................................................. 352 
ESTILOS Y PLANTILLAS ............................................................................................... 353 
ESTILOS .......................................................................................................................... 354 
PLANTILLAS DE DATOS ........................................................................................................ 357 
PLANTILLAS DE CONTROLES ................................................................................................. 359 
TRIGGERS ........................................................................................................................ 361 
RECURSOS COMPARTIDOS Y TEMAS ...................................................................................... 362 
CONCLUSIÓN ................................................................................................................... 364 
A CONTINUACIÓN ............................................................................................................. 364 
GRÁFICOS Y ANIMACIONES ....................................................................................... 365 
GRAFICOS Y RENDERIZADO.................................................................................................. 365 
RENDERIZADO 3‐D ........................................................................................................... 372 
ANIMACIÓN ..................................................................................................................... 375 
VISUAL STATE MANAGER ................................................................................................... 376 
TRATAMIENTO DE MEDIOS .................................................................................................. 378 
CONCLUSIÓN ................................................................................................................... 379 
A CONTINUACIÓN ............................................................................................................. 379 
DOCUMENTOS .......................................................................................................... 381 
DOCUMENTOS EN WPF ..................................................................................................... 381 
DOCUMENTOS DE FLUJO .................................................................................................... 382 
SERIALIZACIÓN Y ALMACENAJE DE DOCUMENTOS ..................................................................... 384 
ANOTACIONES.................................................................................................................. 386 
CONCLUSIÓN ................................................................................................................... 387 
A CONTINUACIÓN ............................................................................................................. 387 
CONTROLES ............................................................................................................... 389 
CONTROLES DE USUARIO .................................................................................................... 389 
LA JERARQUÍA DE OBJETOS EN WPF ..................................................................................... 390 
PASOS PARA DESARROLLAR UN NUEVO CONTROL ..................................................................... 391 
CONCLUSIÓN ................................................................................................................... 395 
A CONTINUACIÓN ............................................................................................................. 395 
LOCALIZACIÓN E INTER‐OPERABILIDAD ..................................................................... 397 
10 | Windows Forms 
Libro para José Mora 
LOCALIZACIÓN Y GLOBALIZACIÓN ......................................................................................... 398 
LOCALIZANDO UNA APLICACIÓN ........................................................................................... 398 
INTEROPERABILIDAD .......................................................................................................... 402 
CONCLUSIÓN ................................................................................................................... 403 
ÍNDICE .................................................................................................................. 405 
SITIOS WEB RELACIONADOS ..................................................................... 412 
 
 
 
 
 
Apartado I: 
Plataforma .NET 
y Lenguaje C# 
por Alberto Población 
 
 
 
 
 
 
 
 
 
 
Plataforma .NET y Lenguaje C# | 13 
 
Guía práctica de desarrollo de aplicaciones Windows en .NET 
Prólogo 
Este libro trata sobre la plataforma .NET en su versión 4.0, así como el lenguaje C# 
también en su versión 4.0 y Visual Studio 2010. Donde sea oportuno, 
mencionaremos aquellas características que son exclusivas de estas últimas 
versiones, con el fin de que el lector sea consciente de que no se pueden usar con 
otras versiones más antiguas. 
No se trata de un manual básico de programación, sino que presume que el lector ya 
sabe programar en algún otro lenguaje y entorno tradicional, mencionando 
únicamente las peculiaridades de la sintaxis del lenguaje C#, sin detenerse a 
explicar conceptos tales como qué es o para qué sirve un bucle o una variable. 
Igualmente, en lo que se refiere al Framework de .NET, no pretende ser una 
referencia de todas las librerías e infraestructura provistas por dicha plataforma, 
sino una introducción general del tipo “qué es y para qué sirve”. 
 
Espero que el libro te resulte útil, y que obtengas buenos resultados desarrollando 
aplicaciones con Visual Studio bajo la plataforma .NET. 
 
14 | Plataforma .NET y Lenguaje C# 
Libro para José Mora 
Plataforma .NET y Lenguaje C# | 15 
 
Guía práctica de desarrollo de aplicaciones Windows en .NET 
Introducción 
Cuando hablamos de la plataforma “punto net”, nos referimos a una serie de 
elementos de infraestructura que se usan para desarrollar aplicaciones informáticas 
que funcionan principalmente sobre Microsoft Windows. 
Desde nuestro punto de vista como desarrolladores de software, se trata 
básicamente de un conjunto de librerías que nos facilitan el desarrollo de 
aplicaciones porque aportan una gran cantidad de funcionalidad que en otros 
entornos de programación sería necesario construir a mano o adquirir de terceras 
partes. Por ejemplo, podemos construir una aplicación de escritorio para Windows 
sin preocuparnos por la bomba de mensajes o por la declaración de las interfaces de 
programación (APIs) previstas por el sistema, porque .NET nos proporciona ya una 
serie de clases que encapsulan y abstraen esos detalles. Lo mismo ocurre con las 
aplicaciones para Web o con los servicios para Windows, cuyo desarrollo se ve en 
todos los casos simplificado gracias a las librerías incluidas en el Framework de 
.NET. 
El conjunto de librerías de clases se conoce como Framework Class Libraries 
(FCL). Entre otras cosas, soporta múltiples tipos de interfaces de usuario, acceso a 
datos, criptografía, algoritmos numéricos, protocolos de comunicación, codificación 
y análisis de texto, manejo del sistema de archivos, etc., etc. Además, se soportan 
diversos lenguajes de programación, todos los cuales pueden hacer uso de estas 
librerías además de interactuar entre sí gracias a una librería de tipos comunes. 
Cuando se compila un programa escrito para .NET, se genera lo que se denomina 
“código gestionado”, que rueda bajo un entorno de ejecución llamado Common 
Language Runtime (CLR). El CLR controla, limita y gestiona el funcionamiento del 
programa compilado. Este entorno aporta diversos servicios, tales como la 
seguridad, gestión de memoria y de excepciones, y la interacción con el código no-
gestionado (especialmente las APIs nativas de Windows). El “Framework” de .NET 
está constituido por el conjunto de las FCL más el CLR. 
Además del soporte que nos proporciona el Framework de .NET, otra de las 
ventajas a la hora de desarrollar aplicaciones sobre esta plataforma consiste en la 
disponibilidad de herramientas de desarrollo muy potentes y versátiles. 
16 | Plataforma .NET y Lenguaje C# 
Libro para José Mora 
Probablemente la herramienta más conocida (aunque no la única) sea Visual 
Studio, que aporta un entorno integrado de desarrollo desde el que se pueden 
editar, compilar, ejecutar y depurar los programas. No obstante, debe quedarnos 
claro que .NET no es Visual Studio sino una infraestructura independiente de dicho 
producto. Es posible desarrollar programas para .NET sin usar en ningún momento 
Visual Studio. 
A continuación 
Veremos seguidamente una breve presentación general del Framework y sus 
librerías, para pasar después a explorar las características del lenguaje C#. 
Plataforma .NET y Lenguaje C# | 17 
 
Guía práctica de desarrollo de aplicaciones Windows en .NET 
El Framework 
Como ya hemos mencionado, el Framework proporciona infraestructura de soporte 
para compilar y ejecutar aplicacionesbasadas en .NET. 
Las aplicaciones deben apoyarse en un sistema operativo. A lo largo de este texto 
presumiremos que se trata de aplicaciones para Windows, pese a que el lenguaje C# 
en sí mismo es independiente del sistema, y de hecho permite generar aplicaciones 
para otros entornos, tales como MONO, Silverlight, o el Micro Framework para 
sistemas embebidos. 
El diagrama que se acompaña muestra los diversos bloques del Framework apilados 
sobre la infraestructura del sistema operativo. 
 
 
Muchas de las librerías del sistema, tales como Windows Management 
Instrumentation (WMI) o colas de mensajes (MSMQ) se encuentran encapsuladas 
18 | Plataforma .NET y Lenguaje C# 
Libro para José Mora 
en las librerías del Framework. De esta manera, nuestros programas de .NET 
pueden utilizarlas de una manera sistemática y uniforme, sin necesidad de conocer 
los entresijos y complicaciones de cada una de estas APIs por separado. 
El Common Language Runtime (CLR), que ya hemos mencionado, proporciona un 
entorno de ejecución que a veces se conoce como “entorno gestionado”. Aporta a las 
aplicaciones una serie de servicios tales como el Garbage Collector, seguridad de 
acceso a código y verificación de código, que contribuyen a la estabilidad y 
simplicidad de despliegue de los programas de .NET. 
El diagrama muestra también varios bloques correspondientes a las librerías de 
clases del Framework (FCL), incluyendo entre otras cosas el acceso a datos o los 
distintos tipos de interfaces de usuario. 
Finalmente, todo ello puede ser controlado desde diversos lenguajes de 
programación, entre los que se encuentra C#, que será el lenguaje estudiado en este 
texto. 
Servicios del CLR 
Estos son algunos de los múltiples servicios aportados por el CLR: 
 Cargador de clases – Gestiona la carga en memoria de las clases y sus
metadatos.
 Compilador de código intermedio a nativo – Los compiladores de .Net
generan archivos ejecutables que en realidad contienen en su interior un
código intermedio que se denomina MSIL (“Microsoft Intermediate
Language”). Al cargarlo en memoria, el CLR traduce el MSIL en código
nativo optimizado para la CPU en la que se esté ejecutando el programa
en ese momento. También se conoce como el compilador JIT (“Just-In-
Time”).
 Gestor de código – Administra la ejecución.
 Recogemigas (“Garbage Collector”) – Gestiona el ciclo de vida de los
objetos, liberándolos cuando ya no se encuentran en uso. Hablaremos
de este tema con más detalle en la sección dedicada a los destructores de
clases, en el capítulo “Orientación a Objetos”.
 Motor de seguridad – Recopila una serie de “pruebas” (evidence)
basándose en el origen del código, y en base a esos datos decide los
Plataforma .NET y Lenguaje C# | 19 
 
Guía práctica de desarrollo de aplicaciones Windows en .NET 
permisos que tendrá el código. Es la base del mecanismo que se conoce 
como CAS (“Code Access Security”). 
 Motor de depuración – Permite conectar una herramienta de 
depuración (como por ejemplo el propio Visual Studio) con el código en 
ejecución, para seguirlo paso a paso, examinar las variables y depurar la 
aplicación. 
 Verificador de tipos – Al cargar el código, verifica que los tipos (clases, 
estructuras, enumeraciones, etc.) no contienen ninguna instrucción 
MSIL que los pueda volver inseguros, como por ejemplo variables sin 
inicializar o accesos a elementos de un arreglo sin comprobar que el 
índice se encuentra dentro del rango válido. Es posible ejecutar código 
no verificado, pero requiere privilegios elevados. El código MSIL 
generado por C# es siempre verificable a condición de que no se utilice 
la instrucción unsafe. 
 Gestor de excepciones – Se encarga de la gestión estructurada de 
excepciones, que pueden fluir desde código desarrollado en un lenguaje 
a otro. En el caso de C#, la construcción que permite tratar estas 
excepciones es try...catch (explicada más adelante). 
 Soporte de hilos de ejecución – Se dispone de infraestructura para dar 
soporte a los programas que utilizan múltiples hilos de ejecución. 
 Transportador para COM – Permite transportar la ejecución entre 
código gestionado de .NET y código no-gestionado implementado por 
medio de COM (Component Object Model). Puede funcionar en ambas 
direcciones, es decir, un programa de .NET puede realizar una llamada 
a un objeto COM, y un consumidor de objetos COM puede consumir un 
componente programado en .NET siempre que se configure 
adecuadamente para permitir esta interacción. 
Librerías del Framework 
Hay un gran número de librerías incluidas en el Framework. Desde nuestros 
programas podemos hacer referencia a las diferentes DLLs para acceder a las clases 
que contienen. Cuando esto se hace desde Visual Studio, se presenta un cuadro que 
enumera las librerías y que reproducimos aquí para dar una idea del aspecto que 
tienen: 
20 | Plataforma .NET y Lenguaje C# 
Libro para José Mora 
Por ejemplo, la ventana anterior nos ofrece la opción de utilizar la librería 
System.Core.dll en versión 4.0.0.0. ¿Dónde se encuentra ubicada esta DLL? 
Durante la instalación del Framework, la mayor parte de las librerías de sistema se 
instalan en una zona reservada que se denomina “caché global de ensamblados” 
(Global Assembly Cache – GAC). 
Las librerías que se instalan aquí se encuentran ya precompiladas (a código nativo 
en lugar de MSIL) y con el código verificado, por lo que el proceso de carga es más 
rápido que las que no han pasado por este proceso. Además, las librerías que se 
instalan en el GAC son encontradas automáticamente por todos los programas de 
.NET que se ejecuten en el sistema, por lo que no es necesario hacer nada en 
especial para indicarle al programa la ubicación en la que se encuentran en tiempo 
de ejecución. 
Físicamente, el GAC está formado por una serie de carpetas por debajo de la ruta 
c:\Windows\Assembly. El Explorador de Windows conoce esta peculiaridad, y 
muestra el contenido del GAC en un listado continuo con independencia de las 
carpetas utilizadas internamente. 
Plataforma .NET y Lenguaje C# | 21 
 
Guía práctica de desarrollo de aplicaciones Windows en .NET 
 
Es lícito tener instaladas a la vez varias copias de una misma librería siempre que 
tengan distintas versiones. En tiempo de ejecución, cada programa carga 
automáticamente la versión de la librería con la que fue compilado, por lo que 
desaparece el infame “infierno de las DLLs” que teníamos que sufrir con tecnologías 
anteriores (COM) cuando instalábamos simultáneamente más de un programa con 
versiones diferentes de una misma librería, que se “pisaban” unas a otras. 
En realidad, el mecanismo de carga de DLLs es sumamente sofisticado, y se conoce 
como fusion en la documentación original. Por mediación de los archivos de 
configuración se puede alterar este proceso, para lograr (por ejemplo) que un 
programa cargue una versión más reciente de una librería que aquella con la que se 
compiló. 
Espacios de nombres 
Las clases que hay dentro de las librerías vienen clasificadas en lo que se 
denominan espacios de nombres. Por ejemplo, hay una clase llamada 
SqlConnection cuyo nombre completo es en realidad 
22 | Plataforma .NET y Lenguaje C# 
Libro para José Mora 
System.Data.SqlClient.SqlConnection. La parte que viene antes del último 
punto (System.Data.SqlClient) es el espacio de nombres de la clase. 
Los espacios de nombres se usan para clasificar y eliminar ambigüedades en los 
nombres de tipos que hay en las librerías de clases. Clasifican los nombres de tipos 
en el sentido de que las diversas clases que tienen funcionalidad similar, o 
relacionada entre sí, se categorizan bajo un mismo espacio de nombres para que 
puedan ser fácilmente encontradas y reconocidas. Eliminan ambigüedades porque 
gracias al espacio de nombres es posible tener varias clases que se llamen igual, 
aunque no tengan nada que ver una con otra. Por ejemplo, hay al menos cuatro 
copias de la clase Timer: 
 System.Windows.Forms.Timer System.Threading.Timer
 System.Timers.Timer
 System.Web.Extensions.Timer
Es lícito que dentro de una DLL se definan clases que pertenezcan a espacios de 
nombres diferentes, y también es lícito que dos DLLs definan clases del mismo 
espacio de nombres. Sin embargo, en la mayor parte de los casos, los espacios de 
nombres y las DLLs coinciden, lo que facilita escoger las referencias que deben 
añadirse al programa. En cualquier caso, la documentación de cada clase anuncia al 
principio cuál es la librería que la contiene. 
En la sección dedicada al lenguaje C# mostraremos cómo emplear la directiva 
using para declarar en un programa fuente los espacios de nombres que se van a 
utilizar, evitando de esa manera tenerlos que escribir cada vez que se haga 
referencia a una de las clases. 
Plataforma .NET y Lenguaje C# | 23 
 
Guía práctica de desarrollo de aplicaciones Windows en .NET 
Algunas clases de uso frecuente 
Dentro de este apartado vamos a mencionar, a título de ejemplo, algunas de las 
librerías que vienen incluidas en el Framework y que se usan con cierta frecuencia, 
dependiendo del tipo de aplicaciones que se desarrollen. 
Interfaces de usuario 
El Framework de .NET permite desarrollar aplicaciones de distintos tipos, desde 
aplicaciones de consola hasta aplicaciones web, pasando por distintas modalidades 
de aplicaciones de escritorio. Estos son los principales tipos de aplicaciones que 
soportan las librerías: 
Aplicaciones de escritorio 
Pueden ser de dos tipos: 
El modelo más clásico se conoce como Windows Forms o abreviadamente 
Winforms. Desde Visual Studio se dibuja la estética de las ventanas que se 
presentarán en pantalla, y esto genera sentencias de código que al ser ejecutadas 
producen el mismo resultado que se preparó en tiempo de diseño. Dentro de las 
ventanas se ubican componentes que son instancias de clases con una serie de 
interfaces predefinidas que les permiten “incrustarse” en el dibujo de la pantalla. 
Para realizar la interacción con el usuario, estos componentes utilizan un modelo de 
eventos, por el que se conectan con ellos una serie rutinas desarrolladas por el 
programador conocidas como “manejadores de eventos”. Estos manejadores se 
añaden a las clases generadas por el diseñador, típicamente en un archivo separado 
que se denomina code behind (“código por detrás”). 
Desde el punto de vista de las librerías del Framework, las clases que representan 
las ventanas en pantalla heredan de la clase System.Windows.Forms.Form. 
Similarmente, los componentes que ubicamos en pantalla se encuentran también 
definidos en ese mismo espacio de nombres, System.Windows.Forms, y las clases 
correspondientes están almacenadas en la librería System.Windows.Forms.dll. 
El segundo tipo de aplicación de escritorio utiliza una tecnología denominada 
Windows Presentation Foundation (WPF). Aunque en teoría es posible crear estas 
aplicaciones con técnicas similares a las de Winforms (mediante sentencias de 
código que dibujen las pantallas), habitualmente siguen un paradigma distinto. Al 
dibujar las ventanas desde el diseñador de Visual Studio, lo que se genera es un 
archivo que contiene XML, siguiendo un esquema que Microsoft denomina XAML 
24 | Plataforma .NET y Lenguaje C# 
Libro para José Mora 
(Extensible Application Markup Language). Este archivo define el contenido 
visible de la ventana de forma similar a la definición de una página Web realizada 
mediante HTML. Al igual que en el caso de Winforms, existe un modelo de eventos 
(diferente del de Winforms) que permite conectar con los controles que hay en 
pantalla las rutinas que escribimos en el code behind. Además, XAML incorpora 
potentes capacidades de manejo de recursos, plantillas, vínculos de datos, 
desencadenadores, animaciones y gráficos, que en muchos casos permiten 
establecer en tiempo de diseño complejos comportamientos y cambios estéticos que 
habrían requerido implementar eventos y escribir código si se hubiera utilizado el 
modelo Winforms. 
En cuanto a las librerías del Framework que implementan todo lo anterior, en su 
mayor parte se trata de PresentationFramework.dll y 
PresentationCore.dll. Éstas se apoyan a su vez en una librería llamada 
MilCore.dll, que contiene código no-gestionado y es la que se encarga de la 
interfaz gráfica a bajo nivel. Los controles que se dibujan en pantalla están en el 
espacio de nombres System.Windows.Controls. 
Aplicaciones para Internet 
Al igual que en el caso de las aplicaciones de escritorio, disponemos en .NET de dos 
tecnologías diferentes para generar desde el lado servidor páginas web dinámicas. 
Ambas en su conjunto forman parte de ASP.NET (“Active Server Pages.NET”). 
Por una parte, tenemos la más antigua de las dos tecnologías, conocida como 
WebForms. En tiempo de diseño funciona de forma parecida a Winforms y WPF, es 
decir, se diseña una página con el diseñador de Visual Studio, el cual genera 
(además de código HTML para representar la página) una clase en la que se crean 
objetos que representan el contenido de la pantalla. Un modelo de eventos conecta 
estos objetos con las subrutinas que se programan en el code behind para 
interactuar con la pantalla. Internamente, dispone de varios automatismos para 
simular en Web el comportamiento de los formularios de Windows, de forma que 
haciendo llamadas de ida y vuelta (“postbacks”) desde el navegador al servidor, 
desde el punto de vista del usuario la página web aparenta comportarse como un 
formulario. 
El espacio de nombres en el que se encuentra implementada esta funcionalidad es 
System.Web, incluyendo los espacios que cuelgan de él, tales como 
System.Web.UI.WebControls y System.Web.UI.HtmlControls, que contienen 
las clases que definen los controles que se utilizan en pantalla. 
La otra tecnología que se utiliza para desarrollar páginas web dinámicas se 
denomina ASP.NET MVC. Las siglas MVC corresponden a Model View Controller, 
que es un patrón de programación muy conocido. Las librerías proveen una 
Plataforma .NET y Lenguaje C# | 25 
 
Guía práctica de desarrollo de aplicaciones Windows en .NET 
infraestructura especialmente diseñada para dar soporte precisamente a este patrón 
de programación. En este caso no se dispone de un mecanismo que directamente 
simule formularios, pero a cambio se tiene un control muy preciso sobre qué es 
exactamente lo que se procesa y se genera en cada momento ante cada interacción 
del usuario con la página. 
Las librerías (y espacios de nombres) que dan soporte a esta funcionalidad son 
System.Web.Mvc y System.Web.Routing. 
Aplicaciones de consola 
Se trata, probablemente, de las aplicaciones con la interfaz de usuario más simple 
de todas. En pantalla, simplemente abren una ventana con líneas de caracteres, y 
toda la entrada/salida de la aplicación se realiza en modo carácter. 
A pesar de lo poco “vistosas” que son estas aplicaciones, es común utilizarlas 
cuando se desea crear herramientas administrativas que funcionen en modo “línea 
de comandos”, o cuando deban automatizarse para ejecutarlas sin interacción con el 
usuario (puesto que sus textos de entrada y salida pueden redirigirse a archivos). 
Cuando se aprende por primera vez un lenguaje de programación, es común 
realizar las primeras pruebas sobre aplicaciones de consola, para concentrarse en el 
propio lenguaje y no distraerse con las complejidades de la interfaz de usuario. De 
hecho, cuando más adelante en este libro comencemos a tratar el lenguaje C#, 
escribiremos nuestro primer ejemplo como aplicación de consola por este mismo 
motivo. 
En la librería System.dll se dispone de la clase System.Console, que contiene 
los métodos necesarios para realizar las entradas/salidas en consola. 
Servicios Windows 
Los Servicios Windows no tienen una interfaz de usuario propiamente dicha 
(funcionan “ocultos” con independencia del usuario que haya hecho “login”). No 
obstante, los clasificamos dentro de este apartado porque de cara al desarrollador 
siguen un patrónsimilar: el diseñador de Visual Studio genera una clase heredada a 
partir de una clase base que implementa este tipo de aplicaciones, y luego se 
“conecta” código sobre esta clase. 
La librería que da soporte a este tipo de aplicaciones es 
System.ServiceProcess.dll, y la clase de la que heredan los servicios, 
System.ServiceProcess.ServiceBase. 
26 | Plataforma .NET y Lenguaje C# 
Libro para José Mora 
Colecciones 
En el espacio de nombres System.Collections hay diversas interfaces y clases 
que definen colecciones de objetos, tales como listas, colas, tablas de hash y 
diccionarios. 
Similarmente, el espacio de nombres System.Collections.Generic incluye 
también diversas colecciones, pero en este caso los elementos almacenados no son 
“Objects”, sino que se pueden personalizar para que tomen un tipo de datos 
concreto. Utilizan para ello un mecanismo llamado “Genéricos”, al que dedicaremos 
posteriormente un capítulo. 
Algunas de las clases correspondientes a los espacios de nombres 
System.Collections y System.Collections.Generic se definen dentro de la 
librería Mscorlib.dll, que constituye un núcleo “básico” que siempre se enlaza 
con las aplicaciones de .NET. Entre otras cosas, Mscorlib.dll define la clase 
System.Object, de la que heredan todas las demás, y tiene la distinción de ser la 
única librería que el CLR requiere que siempre se cargue dentro de todo proceso de 
código gestionado. Por este motivo, no es necesario añadir expresamente una 
referencia a esta DLL en nuestros proyectos, ya que siempre se enlaza de forma 
predeterminada. 
Otras de las clases de estos espacios de nombres se albergan en System.dll y 
System.Core.dll. 
Entradas/Salidas 
En el espacio de nombres System.IO se dispone de clases que permiten leer y 
escribir en archivos y streams, así como manejar archivos y carpetas en disco. 
En el capítulo dedicado a la programación orientada a objetos nos detendremos 
momentáneamente a examinar la clase Stream, ya que la usaremos como ejemplo 
de clase abstracta. Mientras tanto, valga decir que este es en .NET el instrumento 
principal para grabar y leer información desde un archivo u otra ubicación. Por 
ejemplo, entre las clases hijas de Stream se encuentra el FileStream, que permite 
leer y grabar archivos, NetworkStream, que permite enviar y recibir secuencias de 
bytes a un socket de red, MemoryStream, que permite enviarlos a un búfer en 
memoria, etc. 
El Stream representa un flujo de bytes. Podemos pensar en él como una “tubería” 
en la que se inyectan bytes por un extremo y salen por el otro. En un FileStream, 
uno de los extremos se conecta con un archivo en disco. Pero también hay Streams 
que están pensados para conectarlos con otro Stream a continuación, como si 
Plataforma .NET y Lenguaje C# | 27 
 
Guía práctica de desarrollo de aplicaciones Windows en .NET 
empalmásemos dos tuberías. De esta manera, tenemos el CryptoStream, que sirve 
para cifrar los datos que lo atraviesan, el GZipStream, que sirve para comprimir 
datos, o el BufferedStream, que sirve para intercalar una memoria tampón. Así, 
por ejemplo, si conectásemos un GZipStream con un CryptoStream y luego con 
un FileStream, podríamos grabar un archivo con el contenido comprimido y 
cifrado (el orden es importante: si primero lo cifrásemos, no podríamos después 
comprimirlo). 
Las clases derivadas de Stream a veces son incómodas de manejar, ya que operan 
con arreglos de bytes, mientras que nuestros programas normalmente lo que 
manejan son tipos primitivos tales como números enteros o cadenas de caracteres. 
Para simplificar la lectura y escritura de estos datos, se dispone de unas clases 
auxiliares que se interponen entre los Streams y nuestro código, realizando de 
forma interna las conversiones entre los datos que les aportamos y las secuencias de 
bytes. Entre ellas están las clases abstractas TextReader y TextWirter, de las que 
heredan StreamReader y StreamWriter (que trabajan con cadenas de 
caracteres), así como las clases BinaryReader y BinaryWriter, que trabajan con 
datos tales como números enteros o de coma flotante. 
Finalmente, y para terminar de hablar sobre el espacio de nombres System.IO, 
mencionemos que también contiene (entre otras) las clases File y FileInfo, que 
permiten hacer operaciones tales como copiar, borrar y renombrar archivos, y 
también Directory y DirectoryInfo, que hacen lo mismo con los directorios, 
además de permitir enumerar los subdirectorios y archivos que contienen. 
Las clases de este espacio de nombres están en las librerías Mscorlib.dll y 
System.dll. 
Acceso a datos 
El espacio de datos System.Data contiene clases que forman la arquitectura de 
ADO.NET. Estas clases permiten gestionar datos provenientes de diferentes 
orígenes, como por ejemplo bases de datos SQL Server u Oracle, e incluso archivos 
de texto u hojas Excel, siempre que se use el “driver” adecuado. 
Adicionalmente, en las librerías del Framework se dispone de otras tecnologías que, 
apoyándose sobre ADO.NET, aportan funcionalidad más sofisticada. 
Concretamente, LINQ-to-SQL permite incrustar consultas similares a SQL dentro 
del lenguaje C#, y Entity Framework permite crear un mapeo objeto-relacional 
(ORM). 
28 | Plataforma .NET y Lenguaje C# 
Libro para José Mora 
Más adelante en este libro hay una pequeña sección sobre el funcionamiento de 
LINQ, desde el punto de vista de su interacción con el lenguaje (pero no con la base 
de datos). 
Aquí no vamos a hablar más acerca del acceso a datos, ya que sobre este tema existe 
una sección específica en este libro. 
Globalización 
El espacio de nombres System.Globalization contiene clases que definen la 
información relativa a las distintas culturas, tales como el idioma, país o región, 
calendario, formatos para las fechas, la moneda y los números, etc. 
Estas clases son útiles para escribir aplicaciones que funcionen en múltiples países. 
Nos permiten determinar, entre otras muchas cosas, si los números se deben 
escribir con punto o coma decimal, y si las fechas son del tipo día/mes/año o 
mes/día/año. 
También hay métodos para comparar cadenas de texto teniendo en cuenta las 
peculiaridades lingüísticas de distintos idiomas, y para procesar calendarios 
diferentes del gregoriano. 
Con independencia de las capacidades de System.Globalization, es conveniente 
saber también que tanto las aplicaciones de tipo Winforms como las de Webforms 
tienen ya previstos mecanismos automáticos para traducir a distintos idiomas los 
textos presentados al usuario, extrayéndolos de archivos de recursos en los que se 
incorporan las traducciones. 
Manipulación de texto 
El espacio de nombres System.Text contiene clases que representan distintas 
codificaciones de caracteres, tales como ASCII o UTF8. Permite realizar 
conversiones entre bloques de caracteres y bloques de bytes (aplicando la 
codificación correspondiente). Las clases codificadoras tienen principalmente la 
finalidad de convertir desde y hacia Unicode. Internamente, las cadenas de .NET 
utilizan Unicode (codificado como UTF-16), pero no siempre que se lee o escribe un 
archivo se desea grabar el texto en este formato. Utilizando las clases de 
System.Text, como por ejemplo System.Text.Endoding.UTF8, se pueden hacer 
las conversiones oportunas al formato deseado. 
Plataforma .NET y Lenguaje C# | 29 
 
Guía práctica de desarrollo de aplicaciones Windows en .NET 
En este espacio de nombres también se encuentra la clase StringBuilder, que 
permite manipular el contenido de las cadenas de caracteres sin tener que crear 
instancias intermedias de la clase String. Esto merece una explicación adicional: 
En .NET, los objetos de la clase String son invariables, es decir, una vez que se han 
creado, no se les puede cambiar el valor. Cuando de forma aparente se cambia el 
valor de un string, por ejemplo, concatenándole un carácter al final, lo que ocurre 
internamente es que se construye un nuevo string, se le copia el nuevo valor, y se 
destruye el antiguo string.Estas creaciones y destrucciones son costosas, por lo 
que resulta muy lento un bucle de este tipo: 
string s=""; 
for (int i = 0; i < 10000; i++) 
{ 
 s = s + "x"; 
} 
 
El remedio consiste en emplear un StringBuilder, que asigna internamente un 
búfer grande en el que ir manipulando los caracteres, y luego permite convertir el 
resultado en un string una vez terminados los cambios: 
StringBuilder sb = new StringBuilder(); 
for (int i = 0; i < 10000; i++) 
{ 
 sb.Append("x"); 
} 
string s = sb.ToString(); 
 
Esta clase se encuentra definida dentro de la librería Mscorlib.dll. 
Aprovechamos para mencionar también el espacio de nombres 
System.Text.RegularExpressions (en System.dll), en el que se define la 
clase Regex. Gracias a ella podemos procesar las denominadas expresiones 
regulares. Se pueden usar para analizar con rapidez grandes cantidades de texto 
buscando patrones de caracteres, y extraer, editar, reemplazar o borrar subcadenas. 
Multihilo 
El espacio de nombres System.Threading (implementado en Mscorlib.dll) 
pone a nuestra disposición una serie de clases e interfaces que permiten escribir 
programas con múltiples hilos de ejecución. 
Además de permitir lanzar distintos hilos (mediante la clase Thread), contiene los 
elementos necesarios para sincronizar la ejecución de los mismos, por ejemplo, 
semáforos de mutua exclusión (mutex). También se encuentra aquí la clase 
30 | Plataforma .NET y Lenguaje C# 
Libro para José Mora 
TreadPool, que permite acceder al pool de hilos del sistema, y una clase Timer 
para generar eventos periódicos. 
Reflexión 
El espacio de nombres System.Reflection contiene clases que recuperan 
información acerca de los ejecutables, clases, miembros, parámetros y otras 
entidades almacenadas en el código gestionado. Lo consiguen gracias a los 
metadatos que se almacenan dentro del archivo ejecutable al compilar el código 
fuente. 
Las clases de System.Reflection también permiten manipular instancias 
cargadas en memoria, por ejemplo, para conectarse a eventos, cambiar valores de 
propiedades, o invocar métodos (incluso los marcados como privados, no solo los 
públicos). También se pueden crear nuevas clases sobre la marcha, por mediación 
de las clases del espacio de nombres System.Reflection.Emit. 
A pesar de la potencia que tienen estas herramientas de reflexión, no se recomienda 
abusar de ellas porque resultan lentas (en comparación con la ejecución “normal”, 
directa, del código), y porque perjudican la legibilidad y facilidad de mantenimiento 
del programa ya que se “saltan” las características de encapsulación de la 
programación orientada a objetos. 
A continuación 
Después de haber visto estos pocos ejemplos del tipo de funcionalidad que nos 
proporcionan las librerías del Framework, en los próximos capítulos veremos los 
elementos fundamentales del lenguaje C#, apoyándonos inicialmente en un sencillo 
programa ejemplo. 
Seguirá un estudio de las distintas construcciones del lenguaje, para terminar 
examinando algunas de las características periféricas, tales como los Atributos para 
adjuntar metadatos o la infraestructura que da soporte a las consultas integradas en 
el lenguaje. 
Plataforma .NET y Lenguaje C# | 31 
 
Guía práctica de desarrollo de aplicaciones Windows en .NET 
 
32 | Plataforma .NET y Lenguaje C# 
Libro para José Mora 
Plataforma .NET y Lenguaje C# | 33 
 
Guía práctica de desarrollo de aplicaciones Windows en .NET 
El Lenguaje C# 
El lenguaje C# (que se pronuncia “Ce Sharp”) fue diseñado por Microsoft para 
construir todo tipo de aplicaciones bajo la plataforma .NET. Supone una evolución 
de otros lenguajes anteriores de la familia del C y C++. Según la propia Microsoft, 
C# es “simple, moderno, seguro en cuanto a tipos, y orientado a objetos”. 
El código fuente de C# se compila a “código manejado”, lo que significa que se 
beneficia de los servicios del CLR que ya hemos mencionado con anterioridad. 
Dentro de Visual Studio, a veces se hace referencia a este lenguaje como “Visual 
C#”. El entorno de trabajo incluye plantillas de proyecto, diseñadores, páginas de 
propiedades, asistentes para generación de código y otras características que nos 
ayudan durante la escritura de nuestros programas. 
Algunas de las ventajas de desarrollar con C# y Visual Studio son las siguientes: 
 C# un lenguaje sencillo, seguro en cuanto a tipos, orientado a objetos, y 
muy versátil para generar distintos tipos de aplicaciones. 
 Permite integrarse con código ya existente, a través de COM-Interop y 
Platform/Invoke, técnicas que permiten llamar a objetos COM o a APIs 
convencionales (de código no-manejado). 
 Dispone de una potente gestión de memoria, que evita muchos de los 
problemas encontrados en otros entornos más antiguos, tales como los 
“memory leaks” (pérdidas de memoria) que a veces ocurren en C++ o la 
falta de liberación de objetos con referencias circulares que ocurren en 
VB. 
 La Seguridad de Acceso a Código (CAS) permite determinar los 
permisos de una aplicación mediante un mecanismo basado en 
“pruebas” que determina la confianza que tenemos en ese código. 
 Soporta metadatos extensibles, en forma de datos que se adjuntan al 
ejecutable pero no constituyen código que se ejecute. 
34 | Plataforma .NET y Lenguaje C# 
Libro para José Mora 
 Puede interactuar con otros lenguajes, con otras plataformas, y con
datos almacenados en distinto formatos y ubicaciones.
Nuestro primer programa 
Cuando se enseña un nuevo lenguaje de programación, es tradicional comenzar 
escribiendo un pequeño programa denominado “Hola, Mundo”, que se limita a 
escribir en pantalla un texto y a continuación terminar. El propósito es el de 
enseñar desde el principio cuál es la estructura básica de un programa mínimo y la 
forma de compilarlo y ejecutarlo. 
Veamos sin más preliminares cómo se escribe el “Hola Mundo” en C#: 
using System; 
class Program 
{ 
 static void Main() 
 { 
 Console.WriteLine("Hola, Mundo."); 
 } 
} 
Este bloque de código podemos teclearlo dentro del NOTEPAD y salvarlo a disco 
con un nombre acabado en “.cs”, como por ejemplo “HolaMundo.cs”. 
Para compilarlo, basta con invocar desde una línea de comandos al compilador de 
C#, llamado CSC.EXE, pasándole el nombre archivo: 
C:\Prueba\> CSC HolaMundo.cs 
El compilador CSC.EXE se encuentra en la misma carpeta en la que se ha instalado 
el Framework. Para la versión 4.0, la ruta predeterminada es 
C:\Windows\Microsoft.NET\Framework\v4.0.30319. Si no queremos escribir esta 
ruta manualmente para llamar al CSC, podemos añadirla a la variable PATH dentro 
de una ventana de comandos. De hecho, para facilitarnos esta operación, al instalar 
Visual Studio se crea una entrada en el menú de Inicio de Windows llamada “Visual 
Studio Command Prompt” que nos abre una ventana de comandos con al PATH ya 
configurado. Si usamos esa ventana de comandos para compilar, bastará con 
escribir “CSC” sin tener que escribir la ruta completa. 
Plataforma .NET y Lenguaje C# | 35 
 
Guía práctica de desarrollo de aplicaciones Windows en .NET 
 
Después de compilar nuestro HolaMundo.cs, se crea en la misma carpeta un 
archivo HolaMundo.exe, que representa ya el ejecutable final de nuestro programa. 
Podemos lanzarlo sin más que teclear su nombre, obteniendo como resultado el 
mensaje esperado: 
 
Al igual que suele ocurrir con otras herramientas de línea de comandos, CSC 
dispone de múltiples opciones que se pueden añadir para compilar juntos múltiples 
archivos fuente, añadir referencias a librerías, cambiar el nombre y tipo del 
36 | Plataforma .NET y Lenguaje C# 
Libro para José Mora 
ejecutable, etc. Sin embargo, no nos vamos a detener ahora a estudiar esas opciones 
porque normalmente no operaremos de esta manera. 
Nota: El resultado de la compilación se denomina “ensamblado”, o assembly en la 
documentación en inglés. El ensamblado es la unidad mínima de instalación y 
despliegue de .Net, y en términos prácticos es prácticamentesiempre un EXE o una 
DLL. En teoría, se puede producir un ensamblado con múltiples archivos (que
acaban en la extensión .netmodule), pero esta opción no es comúnmente utilizada
en la práctica.
Aunque está bien saber que es posible escribir un programa de .NET con el 
NOTEPAD y compilarlo desde línea de comandos sin utilizar en ningún momento 
Visual Studio, la realidad es que en la práctica trabajaremos casi todo el tiempo con 
esta última herramienta y seleccionaremos desde la interfaz gráfica las opciones 
necesarias. 
No es objetivo de este capítulo enseñar al lector a manejar Visual Studio, sino 
concentrarnos en el lenguaje de programación propiamente dicho. No obstante, y 
por si acaso alguno de nuestros lectores no estuviera familiarizado con la 
herramienta, vamos a indicar muy brevemente los pasos necesarios para crear 
nuestro “Hola Mundo” desde Visual Studio: 
Tras abrir Visual Studio, seleccionaremos en el menú la opción “Archivo -> Nuevo -
> Proyecto”, que nos presentará una lista de plantillas para seleccionar el tipo de
proyecto deseado.
Plataforma .NET y Lenguaje C# | 37 
Guía práctica de desarrollo de aplicaciones Windows en .NET 
En nuestro caso concreto, vamos a seleccionar la plantilla para aplicaciones de 
Consola. Este es el tipo de aplicación que tiene la interfaz de usuario más simple, ya 
que funciona en una ventana de consola escribiendo y leyendo líneas de caracteres. 
De esta manera, podremos concentrarnos en los elementos del lenguaje de 
programación C#, sin distraernos con detalles de manejo de la interfaz de usuario, 
que no son relevantes de cara al estudio del lenguaje en sí mismo. 
Después de seleccionar la plantilla y asignar un nombre al proyecto, se abre en 
Visual Studio la pantalla de edición de texto del archivo principal del proyecto (que 
de forma predeterminada se llama Program.cs pero podemos renombrarlo si es 
necesario). El código fuente presenta un “esqueleto” de programa en el que 
podemos insertar las líneas que deseemos. 
38 | Plataforma .NET y Lenguaje C# 
Libro para José Mora 
Examinando el código que nos proporciona la plantilla, vemos que es muy similar al 
que habíamos escrito a mano con el NOTEPAD, con algunas adiciones que 
comentaremos seguidamente. 
Examinando el programa ejemplo 
La directiva using 
Fijándonos en el HolaMundo.cs, vemos que al principio hay una o más directivas 
“using”. Nuestro propio ejemplo sólo contiene un using System, pero la plantilla 
de Visual Studio aporta varias líneas de este tipo. 
Detrás de la palabra using viene un espacio de nombres (“namespace”). Sabemos 
ya que los espacios de nombres se usan para clasificar y eliminar ambigüedades en 
los nombres de tipos que hay en las librerías de clases. La directiva using anuncia 
al compilador que vamos a utilizar ese espacio de nombres en las llamadas a 
distintas clases que vienen más abajo en el código fuente. 
Por ejemplo, nuestro programa contiene la sentencia Console.WriteLine(...). 
Console es una clase que se encuentra programada dentro del espacio de nombres 
System, por lo que su nombre completo es System.Console. Aunque es lícito 
escribir System.Console.WriteLine(...) cada vez que sea necesario hacer esta 
llamada en el programa, esto se vuelve molesto en programas largos con múltiples 
llamadas a múltiples clases dentro de espacios de nombres con nombres 
complicados. Gracias a la directiva using, podemos declarar al principio que vamos 
a usar System, y luego prescindir de dicho prefijo en las llamadas a las clases de 
este espacio de nombres. 
La plantilla predefinida para aplicaciones de consola presume que vamos a utilizar 
varios espacios de nombres, cuyas declaraciones incluye automáticamente. 
Podemos, por supuesto, borrar las declaraciones que nos sobren si no vamos a usar 
esos espacios de nombres. 
Esta utilización de directivas using para introducir en nuestro código las 
declaraciones de espacios de nombres es frecuentísima, y nos la encontraremos 
prácticamente en todos los programas fuente escritos con C#. Por este motivo 
hemos dejado el using System en nuestro programa ejemplo, pese a que no es 
imprescindible usar esta directiva en un programa mínimo. 
Plataforma .NET y Lenguaje C# | 39 
 
Guía práctica de desarrollo de aplicaciones Windows en .NET 
La declaración del namespace 
La plantilla de Visual Studio incorpora a continuación la línea “namespace 
HolaMundo”, y seguidamente encierra entre llaves el resto del código. Eso significa 
que al compilar, todo ese código quedará asignado al espacio de nombres que se 
indica. Por ejemplo, la clase Program será en realidad HolaMundo.Program. Esto 
deberá ser tenido en cuenta desde otras partes del programa que deban hacer 
llamadas a nuestra clase Program, ya que tendrán que escribir 
“HolaMundo.Program” o incluir una directiva “using HolaMundo”, como vimos 
en el apartado anterior. 
El programa ejemplo que nosotros escribimos desde NOTEPAD no llevaba esta 
directiva, puesto que no resulta imprescindible asignar un espacio de nombres para 
un programa mínimo de este tipo. Sin embargo, en programas más grandes, lo 
habitual es que cada uno de los archivos fuente declare el espacio de nombres del 
código que contiene. 
De manera predeterminada, las plantillas empleadas por Visual Studio introducen 
un namespace que coincide con el nombre del proyecto. Este valor predeterminado 
puede cambiarse desde la ventana de Propiedades del proyecto, pero únicamente 
afectará a los nuevos archivos fuente que en el futuro se añadan al proyecto; los que 
ya estén creados habrá que modificarlos manualmente si queremos cambiarles el 
espacio de nombres. 
La clase 
La siguiente línea que encontramos en el programa fuente es “class Program”, 
seguida del resto del contenido encerrado entre llaves. Esta línea declara que vamos 
a compilar una clase, y el código que va entre las llaves es el contenido de la clase. 
A diferencia de otros lenguajes anteriores tales como C o C++, en C# no podemos 
escribir un método directamente en el programa sin que forme parte de una clase. 
Incluso aunque no vayamos a instanciar la clase Program en ningún momento, es 
obligatorio declararla para poder ubicar en su interior el método Main que contiene 
la funcionalidad de nuestro programa. 
Aprovechamos para mencionar que los saltos de línea y los espacios en blanco son 
irrelevantes en C#, y se emplean sólo por razones estéticas y para facilitar la lectura 
del programa fuente. Este programa compilaría exactamente igual aunque las llaves 
se encontrasen (por ejemplo) en las mismas líneas que el código fuente abarcado 
por ellas. 
40 | Plataforma .NET y Lenguaje C# 
Libro para José Mora 
El método Main 
Dentro de la clase se ha escrito un método que lleva el nombre Main. Este método 
es por convención el “punto de arranque” del programa, o en otras palabras, el lugar 
por el que comenzará a ejecutarse cuando se invoque desde el sistema operativo. 
Para quienes estén acostumbrados a programar en C o C++, nótese que en C# la M 
de Main va en mayúsculas a diferencia de lo que ocurre en los lenguajes más 
antiguos. Y ya que estamos en ello, aprovechamos también para mencionar que C# 
es sensible a mayúsculas y minúsculas, por lo que el método main es distinto del 
método Main. 
Otra observación es que la plantilla de Visual Studio ha añadido como argumento 
de Main un arreglo de cadenas declarado como string[] args. Este arreglo 
recibe los parámetros que se tecleen en la línea de comandos al llamar al 
HolaMundo.exe. En nuestro propio ejemplo de NOTEPAD omitimos este 
argumento porque no hacía uso de los mencionados parámetros. 
Una vez más, los lectores que trabajen en C o C++ notarán una diferencia, ya que 
dichos lenguajes no sólo requieren que main reciba el arreglo de parámetros, sino 
también el número de elementos que contiene el arreglo. En C# esto no es 
necesario, ya que cada arreglo contiene una propiedad llamada Length que 
devuelve el número de elementos que contiene. Más