Programacion C#.NET

Capítulo 1
FUNDAMENTOS DE PROGRAMACION
EN .NET CON C#
Que es C#
C# (léase, en inglés C sharp, y en español C almohadilla) es un lenguaje de
programación que permite el desarrollo de aplicaciones para Internet, para móviles y
aplicaciones de propósito general. Inicialmente se desarrolló para programar en la
plataforma .NET, pero dadas las características de esta y la estandarización que se ha
hecho de su estructura por parte de las principales entidades de estándares
internacionales, se han desarrollado otras plataformas que cumplen con dicha
estructura y por lo tanto C# puede ser utilizado como lenguaje de programación en
ellas. Entre estas plataformas se destaca el Proyecto MONO, desarrollado para Linux y
Mac.
El lenguaje C# es orientado a objetos y se ha creado basándose en la estructura de C y
C++, especialmente su sintaxis y potencia, y adoptando el estilo y metodología de la
programación en Visual Basic. Sin embargo es importante aclarar que C# no es el
resultado de la evolución directa de ninguno de estos lenguajes, sino que ha sido
creado desde cero, para programar sobre la plataforma .NET. Es un lenguaje que fue
concebido con el objetivo de programar esta plataforma y por lo tanto se puede decir
que es el lenguaje natural de .NET.
La empresa Microsoft, creadora de C#, en un intento de superar a otras plataformas
que están imponiéndose en el soporte a aplicaciones que trabajan en red, especialmente
sobre Internet, decidió estandarizar la plataforma .NET y con ella el lenguaje base de la
misma, C#. Con esta decisión se ha logrado que Microsoft de a conocer las
especificaciones tanto de la plataforma como del lenguaje de programación, y de esta
manera permitir que terceros desarrollen implementaciones de .NET para el mismo
Windows o para sistemas operativos diferentes.
La plataforma .NET
Para comenzar no entraremos en muchos detalles sobre la plataforma .NET, y evitar de
esta manera confundir al lector poco experimentado, con tecnicismos que cuando se
tenga una mejor familiaridad se pueden abordar con mayor propiedad.
.NET, en esencia es una librería de clases que contienen o encapsulan una gran
cantidad de funciones que trabajan sobre el sistema operativo. La característica
fundamental de este aspecto, es que dichas clases tienen una estructura común para
todos los lenguajes que trabajen sobre esta plataforma. Esto trae como consecuencia
que una clase que sea programada en C#, podrá ser heredada o utilizada en cualquier
lenguaje de la plataforma, como pueden ser Visual Basic .NET o JScript, para
comenzar.
Desde la perspectiva del programador el aspecto más importante, es que .NET pone a
su disposición un marco o entorno de trabajo, llamado .NET Framework, el cual le
permite acceder a una infraestructura dotada con lenguajes de programación como C#,
Visual Basic .NET, C++ y JScript, y con la posibilidad de acceder a infinidad de
servicios útiles para desarrollar cualquier tipo de aplicación.

CAPITULO 1CAPITULO 1CAPITULO 1CAPITULO 1 PROGRAMACION CON C#
www.pedrov.phpnet.us
2222
Lo necesario para programar .NET con C#
El objetivo inicial de este curso es conocer los fundamentos básicos de la
programación C# para aplicaciones de propósito general en .NET, y no el manejo de
una herramienta especifica de software. Sin embargo, en el transcurso del mismo, y
para hacer más fácil la tarea de programación, se recomienda utilizar software asistente
que se encargue de administrar los detalles técnicos repetitivos y nos permite
concentrarnos en los detalles de nuestro interés.
Para iniciar a programar en C# y .NET, tan solo se necesita el entorno de trabajo,
conocido como .NET Framework, el cual incluye la plataforma de desarrollo y
ejecución de las aplicaciones .NET. Actualmente está a disposición del público la
versión 3.5 de este entorno, que puede ser descargada gratuitamente desde la página
de Microsoft, pero para efectos de este curso se utilizará la versión 2.0, para la cual
existe mayor soporte y documentación. Sin embargo, se sugiere descargar el kit de
desarrollo de software de Microsoft .NET 2.0, que contiene además del .NET
Framework una serie de herramientas y archivos de ayuda útiles a la hora de
programar.
Se sugiere que las prácticas iniciales se programen utilizando únicamente un editor de
texto sencillo, como el Bloc de notas, y se realice la compilación mediante la línea de
comandos. Esto con el fin de que tengamos la posibilidad de comprender al detalle
aquellos aspectos que un entorno de desarrollo integrado, como el Visual Studio, no
nos permite observar, pero cuya comprensión y familiaridad resultan muy importantes
a la hora de desarrollar aplicaciones que requieren programación avanzada.
Superada la primera etapa del aprendizaje, y con el objetivo de agilizar el proceso de
programación, se utilizará un entorno de programación integrado como el
Sharpdevelop 2.2. Esta herramienta de software es de distribución gratuita y se puede
descargar gratuitamente desde la página de sus creadores,
http://www.icsharpcode.net/OpenSource/SD.
Figura 1.1: Sharpdevelop es un entorno de programación para C# dotado de un diseñador gráfico y un
editor de código.

CAPITULO 1CAPITULO 1CAPITULO 1CAPITULO 1: FUNDAMENTOS DE PROGRAMACIÓN EN .NET CON C#
pedrov.cs@hotmail.com
3333
Sharpdevelop es un entorno de programación diseñado especialmente para programar
con C#, pero adaptado también a Visual Basic .NET. La versión 2.2 trabaja
básicamente sobre la versión 2.0 del .NET Framework. Su diseño, al menos en lo
básico, es muy parecido al entorno que ofrece VisualStudio .NET para C#, pero es
open-source y por lo tanto se puede obtener una copia gratuitamente.
La línea de comandos
Para compilar nuestras aplicaciones a través de la línea de comandos, lo primero que se
debe hacer es configurar adecuadamente este entorno. Cualquier aplicación de .NET
depende para su ejecución de una serie de librerías propias de la plataforma, las cuales
le suministran la comunicación necesaria con el sistema operativo. Por lo tanto para
compilar un archivo es necesario poner a disposición del compilador las direcciones
donde posiblemente pueda encontrar algún componente que requiera o que se esté
utilizando en la aplicación. Para facilitar esta tarea vamos a definir algunas variables de
entorno que facilitan el trabajo de indicar las direcciones básicas del framework .NET.
Lo primero que se debe crear es una carpeta, donde se guardarán los archivos fuente y
sus correspondientes compilados. Para facilitar la coherencia entre este escrito y las
prácticas que se desarrollen se sugiere crear la carpeta c:CSCurso.
Para evitar tener que crear manualmente las variables de entorno con las direcciones
necesarias para el compilador, vamos a crear un archivo de procesamiento por lotes,
*.BAT, que realice este trabajo en forma rápida y automática. Ejecute el Bloc de notas,
copie las líneas siguientes y guarde el archivo en el directorio c:CSCurso,
nombrándolo como cmdSharp.bat:
@echo off
Echo Línea de comandos para el compilador de .NET Framework 2.0
Echo.
rem Ejecute este archivo con la instrucción: %comspec% /k cmdSharp.bat
@SET DirFramework=C:WINDOWSMicrosoft.NETFramework
@SET VerFramework=v2.0.50727
@set PATH=%DirFramework%v2.0;%DirFramework%%VerFramework%;%PATH%
@set LIBPATH=%DirFramework%v2.0;%DirFramework%%VerFramework%;%LIBPATH%
cd c:cscurso
A continuación abra la ventana Ejecutar (puede hacerse mediante la combinación de
teclas WINDOWS+R) y ejecute la siguiente instrucción:
%comspec% /k c:cscursocmdsharp.bat

4444
A continuación debe cargarse la ventana de línea de comandos configurada con
las direcciones necesarias para trabajar con los compiladores instalados con el
framework .NET. Se debe repetir este último paso siempre que se desee abrir
una nueva línea de comandos para compilar un programa desarrollado en C#.
Ejemplo 1: Mi primer programa con C#
El primer programa que vamos a desarrollar es el clásico ¡Hola Mundo…!. Este
programa al ejecutarse mostrará en la ventana de comandos el mensaje de texto ¡Hola
mundo C#...! Es un programa muy simple y elemental, además utiliza un medio de
salida en formato texto, poco usual en los programas modernos, que todo lo hacen a
través de ventanas. Pero para comenzar está bien, luego nos preocuparemos por ir
mejorando para mostrar mensajes más sofisticados y a través de las ya tradicionales
ventanas.
Al igual que sus hermanos, C y C++, el lenguaje C# exige que todo programa
ejecutable (*.EXE) debe incluir un punto de acceso, el cual se debe identificar con la
función Main(). Además como C# es un lenguaje totalmente orientado a objetos,
cualquier función que se desee implementar debe estar inmersa dentro de una clase y la
función Main() no es la excepción.
Inicie un nuevo archivo de texto en el Bloc de notas y digite las siguientes líneas de
código C#:
public class PrimerPrograma
{
static void Main()
{
System.Console.WriteLine("¡Hola mundo C#...!");
}
}
Guarde el archivo en la carpeta de trabajo, CSCurso, y asigne el nombre ejemplo01.cs.
El compilador de C# se identifica como csc.exe (C Sharp Compiler), y tiene una
diversidad de opciones, dependiendo del tipo de compilación que se desee realizar.
Para este caso, basta con ejecutar el compilador seguido del nombre del archivo fuente
que se desea compilar. Por defecto se genera un archivo ejecutable, *.EXE.
La instrucción de compilación es la siguiente:
> csc ejemplo01.cs
El siguiente gráfico muestra el resultado de la compilación de ejemplo01.cs y posterior
ejecución del programa generado.

5555
Estructura básica de un programa C#
Como se ha dicho, C# es un lenguaje de programación orientada a objetos y todo en él
son clases. La clase es el concepto fundamental de esta metodología de programación
y es quién identifica a los componentes que constituyen un programa. En un sencillo
programa como el del ejemplo 1, el programador solo escribe una clase, pero en la
práctica existen muchas clases trabajando para permitir que el programa se ejecute.
Todo programa C# está constituido por más de una clase, aunque el programador tan
solo deba escribir una de ellas.
El ejemplo 1 muestra una estructura básica de un sencillo programa que se ejecutará en
una consola de comandos, o al menos la parte que debe construir el programador, pero
permite visualizar con detalle los elementos esenciales que soportan a cualquier
aplicación de software, sin importar el entorno donde vaya a ejecutarse.
public class PrimerPrograma
{
static void Main()
{
// Instrucciones
}
}
La clase es algo así como la estructura o molde de un componente de software, y se
define con la palabra clave class. El término public le informa al sistema que dicha
clase y sus componentes están disponibles para ser vistos desde afuera del componente
de software que la contiene, en este caso el propio programa.
El programa en sí, observe, es una clase, pero no se puede perder de vista que en la
práctica el programa necesita otros componentes de software para poder ejecutarse, y
lo más seguro es que estos últimos de alguna manera dependan de una o más clases.
Cuando se ejecuta el programa, el sistema operativo a través de la plataforma de
ejecución, .NET, crea una instancia (para comenzar entiéndase, un componente de
software basado en ese molde) de esta clase e interpreta las ordenes contenidas en ella.
En este caso el nombre que se ha colocado a la clase, PrimerPrograma, es una cadena
de texto tomado arbitrariamente e indiferente a como se lo escriba, lo importante es
tener en cuenta las reglas que la mayoría de lenguajes imponen a los nombres de sus
elementos. Como regla general se ha establecido que los nombres de los elementos de
programación deben iniciar por un carácter alfabético (letra) o por una raya abajo (_).
Sin embargo, se sugiere no utilizar esta última forma de iniciar el nombre de un
elemento, ya que le hace perder estética al contenido y sobre todo dificulta su lectura
por parte del programador. Además, aunque no es un requisito, es importante tener en
cuenta las recomendaciones hechas por la documentación del .NET Framework, sobre
la nomenclatura de los nombres asignados a los diferentes elementos que se utilizan en
el desarrollo de un programa, ya que permiten estandarizar los nombres utilizados en
nuestras aplicaciones y en los componentes que vayamos a agregar al mismo entorno
de desarrollo. Así, por ejemplo, para nombrar las clases se sugiere identificadores que
inicien por una letra mayúscula, y cuando se requiera utilizar palabras compuestas,
cada palabra debe iniciar por mayúscula, tales como: MiPrograma, ProgramaDibujo,
NominaTrabajadoresEmpresa, etc. No es correcto llamar a una clase, como:
5ProgramaDibujo, Programa#dibujo, programa-dibujo.
Además, un buen programador debe manejar un estilo de escritura de código que haga
clara su interpretación, no solo por él mismo, sino por otras personas a quienes les
puede interesar revisarlo. Como sugerencia de estilo, la cual manejaremos en este
escrito, se sugiere utilizar identificadores lo más explicativos posible. Es mejor evitar
el uso de abreviaturas, ya que con el tiempo podemos olvidar su significado y cuando

6666
el programador deba volver a revisar su código, después de algunos meses o años, le
complicará su interpretación. Talvez, después de algún tiempo, sea más fácil
interpretar para que sirva una clase llamada IdentidadTrabajador, que una con el
nombre CITra.
Todo programa desarrollado en C# debe incluir un método1
Main(), el cual le informa
al compilador por donde debe iniciar y también terminar un programa. Este método o
función siempre se define antecedida de la palabra clave static, la cual permite utilizar
la clase directamente, sin necesidad de instanciar un objeto de ella. Esto debe ser así
por que en el momentos de iniciar la ejecución de un programa, aún no se ha montado
en el sistema todos los componentes necesarias para manejar objetos y por lo tanto el
procesador no sabe que hacer con ellos
La palabra clave void, que antecede a Main, le dice al sistema que la función que viene
en seguida no retornará ningún valor y que por lo tanto no espere nada. En C#, esta
función también se puede definir como int
La función Main() puede ir como se mostró en el ejemplo 1, o también incluir
argumentos de tipo cadena de texto. Dichos argumentos se identifican por un arreglo o
vector del tipo string (cadena de texto), como en la siguiente forma:
static void Main(string[] argumentos)
{
// Instrucciones
}
En apariencia, los argumentos de inicio de ejecución solo son válidos para programas
de consola, y no para programas que manejan un sistema gráfico de ventanas, como las
aplicaciones tipo Windows. Pero esto no es muy exacto, los programas tipo Windows,
o en general que manejan ventanas, también pueden requerir argumentos de entrada en
el instante en que inician su ejecución. Un buen ejemplo son los programas que
manejan algún formato de archivo especifico, como puede ser el Bloc de notas que
genera archivos de texto que se identifican con la extensión *.TXT y los cuales,
generalmente, el sistema operativo asocia con este editor. Esto trae como consecuencia
dos formas de iniciar la ejecución del Bloc de notas: una, a través de su acceso directo
en el menú de Programas, y la otra haciendo doble clic en el archivo de texto. En este
último caso el sistema operativo envía un argumento al programa informándole que su
ejecución la inicio un archivo y no el acceso directo del menú de programas. El
argumento que se envía contiene el nombre completo del archivo que lo llamó, y de
esta forma el programa se ejecuta y realiza su apertura.
Ejemplo2: Un programa de bienvenida con argumentos de entrada
El siguiente programa, que se identificará con la clase Bienvenidos, recibe una
cadena de texto como argumento, que bien podría ser el nombre de una persona, y lo
muestra en pantalla haciendo parte de un mensaje de bienvenida.
Escriba este programa en el Bloc de notas y guárdelo con el nombre ejemplo02.cs:
public class Bienvenida
{
static void Main(string[] nombre)
{
System.Console.WriteLine("Bienvenido(a) " + nombre[0]);
}
}
1
Un método es el nombre que se asigna a las funciones y procedimientos que se encuentran haciendo parte de una clase
y que pueden ser utilizadas desde el exterior de la misma.

7777
Compile el programa con la instrucción,
> csc ejemplo02.cs
En seguida realice la ejecución del programa llamando a ejemplo02 seguido de un
nombre, como por ejemplo:
> ejemplo02 Homero
Si todo ha salido bien, la salida que muestra el programa después de teclear ENTER es,
Bienvenido(a) Homero
Pruebe a ejecutar el programa sin enviarle un argumento. Observará que se produce un
error, el cual es informado por la plataforma de ejecución del .NET.
La consola
Este es el nombre como en Windows, e incluso en otros sistemas operativos, se conoce
a la interfaz que permite enviar órdenes al sistema operativo a través de comandos
escritos. Tales comandos, no son otra cosa sino programas desarrollados para este
entorno de ejecución.
Para .NET la consola de Windows se manipula a través de un objeto que se identifica
con el nombre Console, el cual incluye todas las funciones básicas para manejar este
elemento del sistema operativo. Una de esas funciones es WriteLine que se encarga de
enviar a la pantalla, o también a otros dispositivos de salida, el argumento que se le
asigne, ya sea una cadena de texto o un valor numérico.
En la instrucción que hemos utilizado en el anterior ejemplo,
System.Console.WriteLine("Bienvenido(a) " + nombre[0]);
se observa que el objeto Console esta antecedido por el identificador System. Este en
realidad es lo que se denomina espacio de nombres, que no es más que el nombre de
un conjunto que agrupa a una serie de clases, que por lo general el programador
considera guardan alguna relación entre sí. En este caso la clase Console pertenece al
conjunto o espacio de nombres llamado System.
Ejemplo 3: Programa de consola para ingresar y mostrar datos
Vamos a desarrollar un programa que lee dos datos a través de la consola, el nombre y
el documento de identidad, utilizando el método ReadLine de la clase Console. Para
mostrar las etiquetas y los mensajes se utilizarán los métodos WriteLine y Write. La
diferencia entre estos métodos es que el primero escribe el mensaje y pasa el cursor a
la siguiente línea, mientras que Write mantiene el cursor al final de la línea escrita.
Adicional a lo anterior, y para recrearnos un poco en medio de tanta oscuridad de la
consola, vamos a asignar color al texto. Para esta tarea el objeto Console cuenta con la
propiedad ForegroundColor, que permite asignar un color al texto de la consola. La
plataforma de desarrollo de .NET pone a disposición del programador un colección de
colores, mediante la enumeración ConsoleColors, para asignarlos tanto al color de
fondo como al texto de la consola.
public class LectorDatos
{
static void Main()
{
System.Console.ForegroundColor = System.ConsoleColor.Green;
Miembro Color
Black Negro
Blue Azul
Cyan Aguamarina
DarkBlue Azul marino
DarkCyan Verde azulado
DarkGray Gris oscuro
DarkGreen Verde oscuro
DarkMagenta Fucsia oscuro
DarkRed Rojo oscuro
DarkYellow Amarillo oscuro
Gray Gris
Green Verde
Magenta Fucsia
Red Rojo
White Blanco
Yellow Amarillo
Miembros de la enumeración
ConsoleColor

8888
System.Console.Write("Nombre del usuario: ");
System.Console.ReadLine();
System.Console.Write("Número de indentificación: ");
System.Console.ReadLine();
System.Console.WriteLine("Acceso permitido");
System.Console.ResetColor(); // Reestablece las opciones de color
}
}
Inicie un nuevo archivo de texto en el Bloc de notas, incluya las líneas de codigo
sugeridas y guárdelo con el nombre ejemplo03.cs.
En los ejemplos anteriores la compilación se realizó utilizando la opción básica que
ofrece el compilador de C#, llamando al compilador y asignándole el nombre del
archivo fuente que se desea compilar. Por defecto, el compilador asigna al archivo
compilado el mismo nombre del archivo fuente, pero en un momento dado el
programador puede desear asignar un nombre conveniente al archivo ejecutable. Como
cualquiera de los compiladores antecesores a C#, este cuenta con una serie de opciones
que permiten obtener diferentes salidas en el proceso de compilación. Para este caso en
particular, se puede utilizar el parámetro out, que permite asignar un nombre al archivo
compilado, diferente al de su fuente. Se aplica siguiendo la sintaxis,
csc /out:ArchivoCompilado ArchivoFuente
Teniendo en cuenta lo anterior compile el programa con la instrucción,
> csc /out:LectorDatos.exe ejemplo03.cs
y ejecútelo mediante la llamada,
> LectorDatos
En la programación de este ejemplo nos hemos dado cuenta que las instrucciones
pueden ser un tanto complejas de escribir, dada la necesidad de tener que incluir el
espacio de nombres en las llamadas a las clases y sus métodos. Si tenemos en cuenta
que la programación en .NET se hace a base de objetos, cuyas clases hacen parte de
espacios de nombres, y que muchos de estos espacios de nombres a su vez hacen parte
de otros espacios de nombres, el grado de dificultad parece aumentarse
innecesariamente para el programador de C#, a causa de estos métodos de asignación
de nombres. Sin embargo, esta forma de identificar las clases y sus objetos tiene una
poderosa razón de ser y, en vez de perjudicar, más bien es un beneficio para el
programador. En seguida se describe la importancia de esta metodología de
agrupamiento de clases y la forma como podemos evitar las dificultades que ofrece el
manejo de los espacios de nombres.
Espacios de nombres
Un espacio de nombres es un nombre que identifica a un conjunto de clases y que
ayuda a distinguirlas de otras que pueden llevar el mismo nombre base. Por ejemplo, la
clase Console que hemos utilizado en todos los ejemplos, hace parte del espacio de
nombres System, que agrupa a todas las clases básicas de la plataforma .NET. Si un
programador necesita definir otra clase con el nombre Console, puede hacerlo sin
ningún problema siempre y cuando la incluya en un espacio de nombres diferente,
como por ejemplo CursoCSharp.Console. Ambas clases pueden ser utilizadas en una
misma aplicación sin ningún problema, pero para referenciarlas se deberá utilizar su
System.Console
Espacio de
nombres
Nombre de la
clase

9999
nombre compuesto, espacio de nombres y nombre de la clase, tal como System.Console
y CursoCSharp.Console.
También se puede decir que un espacio de nombres es algo así como un directorio que
agrupa a un conjunto de clases, las cuales el programador las agrupa dependiendo de su
criterio. La plataforma .NET posee muchos espacios de nombres, que agrupan a clases
cuya funcionalidad tiene alguna característica que las relaciona a unas con otras. La
siguiente tabla muestra algunos de los espacios de nombres básicos que se han definido
en .NET, y los archivos DLL que los contienen junto a sus clases (o también llamadas
tipos):
Espacio de nombres Nombre de la DLL Descripción
System MsCorLib.dll Las clases base de .NET
System.Data System.Data.dll Clases especializadas en
manejar bases de datos
System.Diagnostics MsCorLib.dll Tipos para ayudara la
depuración
System.Drawing System.Drawing.dll Tipos para crear gráficos en
aplicaciones tipo Windows
System.Globalization MsCorLib.dll Tipos para generar
aplicaciones con varios
idiomas
System.IO MsCorLib.dll Tipos que proporcionan acceso
a los atributos de los archivos
System.Net System.dll Tipos para enviar solicitudes
Web HTTP
System.Reflection MsCorLib.dll Tipos para el manejo de
ensamblados y otros tipos
System.Resources MsCorLib.dll Tipos para trabajar con
archivos de recursos
System.Security MsCorLib.dll Tipos para dar soporte a la
seguridad
System.Threading MsCorLib y System.dll Tipos para trabajar con
procesamiento múltiple
System.Web System.Web.dll Tipos para trabajar con
aplicaciones Web
System.Windows.Forms System.Windows.Forms.dll Tipos para crear aplicaciones
con ventanas Windows
System.Xml System.Xml.dll Tipos para trabajar con
esquemas XML
Es importante destacar que estos son solo algunos de los espacios de nombres que
existen en .NET. Pero todos los espacios de nombre que conforman la plataforma
.NET se encuentran definidos dentro del espacio de nombres System, y una gran
cantidad de ellos están ubicados dentro de los anteriores espacios de nombres.
Otro aspecto interesante, es observar la forma como han sido nombrados los archivos
DLL que contienen a estos espacios de nombres, como por ejemplo el espacio de
nombres System.Drawing es guardado en el archivo compilado System.Drawing.dll.
No significa esto que se trate de una regla obligatoria que vaya a tener algún efecto en
el proceso de compilación, sino más bien una cuestión de organización que facilita
mucho la identificación del espacio de nombres y sus clases. Por lo general los
entornos de desarrollo integrado, como Sharpdevelop y VisualStudio .NET generan
estos nombres en forma automática.

10101010
El objetivo fundamental de los espacios de nombres, además de ayudar en la
organización, es impedir las incompatibilidades creadas por la posible duplicidad de
nombres asignados a las clases. Es tanta la cantidad de clases que se encuentran
definidas dentro de la plataforma de .NET y las que vaya a utilizar el programador de
aplicaciones, que bien podría entrar en conflicto a la hora de dar un nombre a una
clase, lo cual aunque puede ser detectado por el compilador, de todas maneras puede
perjudicar el diseño y sobre todo la posibilidad de trabajar un proyecto con
componentes de software asignados a diferentes grupos de desarrollo. Además se corre
el riesgo que los nombres de las clases de un programador coincidan con las de otro, lo
cual crearía inconsistencias al sistema.
Supongamos un caso: un equipo de desarrollo encarga a dos grupos diferentes de
programadores el diseño de algunos de los componentes de software para la aplicación
de software que está desarrollando. Los dos grupos, debido a la dificultad que tienen de
comunicación, implementan, cada uno de ellos, una clase llamada ColorTexto para
colorear las líneas de texto de la salida, pero con funcionalidades un tanto diferentes.
Por ejemplo, el primer grupo dota a esta clase con la funcionalidad de colorear el texto
con rojo, mientras que el segundo grupo le asigna funcionalidades para colorear con
amarillo y azul. Si el equipo de desarrollo base necesita utilizar los tres colores, está
obligado a utilizar las dos clases por que cuentan con las funcionalidades que se
necesitan y no se puede obviar una de ellas, pero puede verse en un serio problema si
ambas fueron compiladas con el mismo nombre.
La solución al anterior problema es utilizar los espacios de nombres para identificar
claramente a cada clase y evitar conflicto de nombres. Supongamos que los equipos de
programadores se identifican con los nombres de Alfa y Beta y hacen parte de la
organización MiEmpresa, entonces podrían utilizar como nombres para sus respectivas
clases,
MiEmpresa.EquipoAlfa.ColorTexto
y
MiEmpresa.EquipoBeta.ColorTexto
Con esto queda perfectamente solucionado el problema de la duplicidad de clases y
permite la utilización de ambas clases sin ningún problema.
Para establecer un espacio de nombres se utiliza la palabra clave namespace, que tiene
la siguiente estructura:
namespace Nombre
{
// Definición de las clases que
// conforman el espacio de nombres
}
Se puede anidar cualquier cantidad de espacios de nombres para permitir alargar la
identidad de las clases. De esta manera la clase de nuestro ejemplo puede definirse, por
parte del Equipo Alfa así:
namespace MiEmpresa
{
namespace EquipoAlfa
{
public class ColorTexto
{
// Instrucciones
}
}
}

11111111
y por parte del equipo Beta así:
namespace MiEmpresa
{
namespace EquipoBeta
{
public class ColorTexto
{
// Instrucciones
}
}
}
En el caso antes planteado, la referencia a las clases resulta un tanto compleja ya que se
debe escribir el nombre completo de la clase, incluyendo los identificadores de sus
espacios de nombres. Esto puede complicar el trabajo del programador, al obligarlo a
teclear demasiado código. Para evitar tener que teclear nombres demasiado largos a
causa de los espacios de nombres, C# cuenta con la palabra clave using que permite
direccionar los espacios de nombres en el encabezado del archivo fuente y acortar la
referencia a una clase, ya sea llamándola por su nombre básico o al menos sin tener
que recurrir a todos los espacios de nombres que la identifican, siempre y cuando no
entre en conflicto con otros nombres.
Ejemplo 4: Ensamblado para colorear texto
En el siguiente ejemplo de programación vamos llevar a la práctica el trabajo del
equipo Alfa, antes mencionado, para mostrar básicamente el uso de la palabra clave
using. Pero, además este ejercicio nos permitirá acercarnos a la descripción teórica de
desarrollar una aplicación por componentes. Vamos a suponer que este equipo debe
compilar y entregar su componente de software en un archivo DLL, que en el mundo
.NET se conoce como ensamblado.
Inicie un nuevo archivo, en el Bloc de notas, y escriba el siguiente código:
// Archivo: EquipoAlfa.ColorTexto.cs
using System;
namespace EquipoAlfa
{
public static class ColorTexto
{
public static void Rojo(string cadena)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(cadena);
Console.ResetColor();
}
}
}
Observe que, se ha utilizado la instrucción
using System;
para direccionar al espacio de nombres System. De esta manera se le informa al
compilador donde debe buscar la definición de la clase Console.

12121212
Aunque la programación orientada a objetos establece que las clases son plantillas, o
moldes, que describen en forma general como es un objeto, hasta el momento no la
hemos utilizado en este contexto, que en la práctica es su verdadera y más importante
finalidad, sino a través del uso directo de las clases y sus métodos. C# le permite al
programador, en cierta manera, evadir el concepto de programación orientada a objetos
definiendo clases estáticas. Este tipo de clases se comportan como plantillas que
únicamente sirven para agrupar funciones, como aquellas que se utilizan en cualquier
lenguaje de programación estructurada y que le sirven al programador para realizar
alguna tarea concreta. Este tipo de clases se definen con la palabra clave static. Todos
los métodos o funciones de una clase estática deben definirse también como static.
Además, estas clases se utilizan directamente ya que no permiten definir objetos a
partir de ellas.
Siguiendo el esquema de nombres sugerido anteriormente, guarde el archivo anterior
con el nombre EquipoAlfa.ColorTexto.cs y compílelo utilizando el parámetro
/target:library, como lo muestra la siguiente instrucción tecleada en la línea de
comandos:
> csc /t:library EquipoAlfa.ColorTexto.cs
Si todo sale bien, al revisar la carpeta de trabajo se observa que se ha compilado en el
ensamblado EquipoAlfa.ColorTexto.dll.La siguiente parte del ejemplo consiste en
utilizar esta librería y su clase en un programa ejecutable.
El programa que se va a desarrollar le pide al usuario ingresar un mensaje desde el
teclado y lo escribe a continuación en color rojo.
Inicie un nuevo archivo en el Bloc de notas y teclee el siguiente código:
// Archivo: Ejemplo04.cs
using System;
using EquipoAlfa;
public class MensajeDeColor
{
static void Main()
{
string sMensaje;
Console.Write("Escriba su mensaje: ");
sMensaje = Console.ReadLine();
ColorTexto.Rojo(sMensaje);
Console.WriteLine("Terminado...");
}
}
Para cambiar a color rojo el mensaje ingresado por el usuario, el programa utiliza la
clase ColorTexto definida en el ensamblado EquipoAlfa.ColorTexto.dll. En el proceso
de compilación de este programa, el compilador debe establecer donde se encuentra la
clase y fijar está información en el archivo ejecutable que se va a generar. Para ello es
necesario indicarle al compilador de C# el nombre del recurso con el cual debe realizar
el enlace, mediante la opción /resources seguido del nombre del archivo DLL, que
en forma simplificada se escribe como /r.
En consecuencia la compilación se debe realizar mediante la siguiente instrucción:
>csc /r:EquipoAlfa.ColorTexto.dll ejemplo04.cs

13131313
Ejecute el programa en la línea de comandos y observe sus resultados.
En definitiva hemos desarrollado una aplicación que consta de dos ensamblados, al
menos desde la perspectiva del programador: un archivo ejecutable obtenido en la
última compilación y un archivo DLL que contiene a la clase que se encarga de ponerle
color al texto. Esta estructura es la que utilizan la mayoría de aplicaciones modernas,
donde cada componente se compila en un archivo independiente, en el caso de .NET
en un ensamblado, lo cual trae una ventaja principal, es que permite hacer cambios a la
aplicación sin necesidad de tener que volver a compilar todo, sino únicamente el
componente que sea necesario.
Ejemplo 5: Cálculo de las funciones trigonométricas
El siguiente ejemplo solicita un valor numérico correspondiente a un ángulo y calcula
el valor de las tres principales funciones trigonométricas. El valor de cada función es
mostrado en un color diferente.
Para asignar color al texto de salida, reutilizaremos el ensamblado
EquipoAlfa.ColorTexto.dll, creado en el ejemplo anterior y que escribe un texto en
color rojo, y crearemos el componente que permite trabajar con dos colores más,
creado por el equipo Beta. Como se estableció en la descripción teórica, este
ensamblado debe pertenecer al espacio de nombres EquipoBeta y realizar el trabajo a
través de una clase estática llamada ColorTexto. Al final, el programa ejecutable
utilizará, para realizar su trabajo, dos ensamblados: EquipoAlfa.ColorTexto.dll y
EquipoBeta.ColorTexto.dll.
// Archivo: EquipoBeta.ColorTexto.cs
using System;
namespace EquipoBeta
{
public static class ColorTexto
{
public static void Amarillo(string cadena)
{
Console.ForegroundColor = ConsoleColor.Yellow;
}
public static void Azul(string cadena)
{
Console.ForegroundColor = ConsoleColor.Blue;
}
}
}
Guarde el archivo con el nombre EquipoBeta.ColorTexto.cs y compílelo con la
instrucción de línea de comandos,
> csc /t:library EquipoBeta.ColorTexto.cs
Con esto ya tenemos los ensamblados entregados por los equipos Alfa y Beta y los
vamos a utilizar en nuestro proyecto de software. El código del programa que nos
permite calcular las funciones trigonométricas es el siguiente:

14141414
// Archivo: Ejemplo05.cs
using System;
public class Trigonometria
{
static void Main()
{
double angulo = 0;
Console.Clear();
Console.Title = "Funciones trigonométricas";
Console.Write("Valor del ángulo en grados = ");
angulo = Convert.ToDouble(Console.ReadLine());
angulo = angulo * Math.PI / 180; // Convierte de grados a radianes
EquipoBeta.ColorTexto.Amarillo("nSeno = " + Math.Sin(angulo));
EquipoBeta.ColorTexto.Azul("Coseno = " + Math.Cos(angulo));
EquipoAlfa.ColorTexto.Rojo("Tangente = " + Math.Tan(angulo));
Console.ReadLine(); // Detiene la ejecución hasta presionar ENTER
}
}
Este programa, para empezar limpia e inicializa la pantalla mediante el método clear
de la clase Console y asigna un título a la barra de títulos de la consola, mediante la
propiedad Title.
La lectura de datos se realiza mediante el método ReadLine. Pero este método captura
el dato como una cadena de texto de tipo string, lo cual implica que para poderse
manipular como un valor numérico se debe convertir primero a número. En este caso
se utiliza la Clase estática Convert y su método ToDouble, que lo convierte de cadena
a un valor de tipo double (numero real de precisión doble).
También, es necesario realizar una conversión del dato ingresado, pasándolo de grados
a radianes, ya que este es el formato que utilizan las funciones trigonométricas de
.NET. Tanto el valor de la constante PI como las funciones trigonométricas, y otras
funciones matemáticas, se encuentran definidas e implementadas en al clase estática
Math.
Finalmente, hay que compilar este archivo fuente, para generar el ensamblado de
nuestro programa, teniendo en cuenta que este depende de dos ensamblados más,
EquipoAlfa.ColorTexto.dll y EquipoBeta.ColorTexto.dll. En el llamado al compilador
se debe pasar el listado de las librerías que se necesitan para la compilación, utilizando
la opción /r: seguida de los nombres de los archivos DLL, separados por comas (pero
sin espacios).
Debe tenerse en cuenta que para llamar a la clase ColorTexto, fue necesario incluir el
espacio de nombres al cual pertenecía, dado que si no se hacia así se crearía una
ambigüedad que no permitiría al sistema saber de cual clase se está hablando.
La compilación se realiza ejecutando la siguiente instrucción en la línea de comandos:
> csc /r:EquipoAlfa.ColorTexto.dll,EquipoBeta.ColorTexto.dll ejercicio05.cs
Con este sencillo ejemplo se ha mostrado la forma como se puede organizar una
aplicación de software y la reutilización de algunos de sus componentes para ahorrar
trabajo y ganar tiempo en el proceso de desarrollo. Cuando abordemos el concepto de
programación orientada a objetos, propiamente dicho, se dará mayor énfasis a este tipo
de diseño.

Programacion C#.NET

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Programacion C#.NET

Similar a Programacion C#.NET (20)

Programacion C#.NET