Programacin Orientada a Objetos

mayo, 2005












Introduccin a C#


Miguel ngel Gmez Vicente
Manuel Martn Mohedano













D De ep pa ar rt ta am me en nt to o d de e I In nf fo or rm m t ti ic ca a y y A Au ut to om m t ti ic ca a
U Un ni iv ve er rs si id da ad d d de e S Sa al la am ma an nc ca a




Informacin de los autores:


Miguel ngel Gmez Vicente

3 Ingeniera Tcnica en Informtica de Sistemas
Facultad de Ciencias, Universidad de Salamanca
keepeek@usal.es

Manuel Martn Mohedano

3 Ingeniera Tcnica en Informtica de Sistemas
Facultad de Ciencias, Universidad de Salamanca
manumohedano@usal.es





Este documento puede ser libremente distribuido.

2005 Departamento de Informtica y Automtica - Universidad de Salamanca.

Gmez y Mohedano
i
Resumen

Este documento trata de mostrar de forma breve y sencilla una introduccin al mundo
del C#, el lenguaje estrella de .NET que ha sido construido especialmente para
adaptarse de manera natural al framework y aprovechar al mximo todas sus
caractersticas. No trata de ser un manual de programacin sino una pequea
aproximacin, los que quieran ir ms all pueden consultar las referencias de la
bibliografa.

Abstract
This document tries to show shortly an introduction to C#s world, the new language of
.NET. C# has been built to fit .NET framework and use all its characteristics. It doesnt
want to be a programming manual, but a little approximation. If anyone wants to know
more, he can consult references and bibliography.

Introduccin a C#
- ii -
T Ta ab bl la a d de e C Co on nt te en ni id do os s
1. Introduccin.............................................................................................. . Pg. 1
2. Caractersticas de C# ................................................................................ Pg. 2
3. Herramientas
3.1. Kit de desarrollo............................................................. Pg. 5
3.2. Entornos de desarrollo............................................................ Pg. 5
4. Primer programa en C#: Hello world! .................................................... Pg. 5
5. Compilacin
5.1. En lnea de consola................................................................. Pg. 6
5.2. Mediante Visual Studio .NET ................................................ Pg. 6
6. Plataforma MONO
6.1. Proyecto Mono ....................................................................... Pg. 8
6.2. Compilacin con MONO ....................................................... Pg. 8
7. Clases en C#
7.1. Concepto de Clase y Objeto .................................................... Pg. 10
7.2. Visibilidad de una clase y sus miembros................................. Pg. 10
7.3. Sintaxis de definicin de clases............................................... Pg. 11
8. Creacin de Objetos en C#
8.1. Operador new....................................................................... Pg. 13
8.2. Constructor por defecto ........................................................... Pg. 14
8.3. Referencia al objeto actual con this ..................................... Pg. 14
9. Herencia y mtodos virtuales en C#
9.1. Concepto de Herencia.............................................................. Pg. 15
9.2. Mtodos Virtuales ................................................................... Pg. 16
9.3. Clases Abstractas..................................................................... Pg. 18
10. Polimorfismo en C#
10.1 Concepto de Polimorfismo...................................................... Pg. 19
11. Conclusin y Bibliografa............................................................................... Pg. 20
Gmez y Mohedano
iii
T Ta ab bl la a d de e F Fi ig gu ur ra as s

Programa 1: Aplicacin HelloWorld.................................................................... Pg. 5
Programa 2: Uso de la herencia............................................................................ Pg. 16
Programa 3: Uso de mtodos virtuales................................................................. Pg. 17
Programa 3: Uso del polimorfismo ...................................................................... Pg. 11

Cdigo 1: Definicin de clase sin mtodos .......................................................... Pg. 11
Cdigo 2: Definicin de clase con mtodos ......................................................... Pg. 12
Cdigo 3: Definicin de clase con constructor..................................................... Pg. 13
Cdigo 4: Uso de this........................................................................................ Pg. 14
Cdigo 5: Ejemplo de herencia ............................................................................ Pg. 15
Cdigo 6: Ejemplo de clases abstractas................................................................ Pg. 18


Ilustracin 1: Captura de pantalla de la salida del programa1.............................. Pg. 7
Ilustracin 2: Ventana de creacin de nuevo proyecto en Visual Studio .NET ... Pg. 7
Ilustracin 3: Captura de pantalla de la salida del programa1.............................. Pg. 8
Ilustracin 4: Captura de pantalla de la salida del programa3.............................. Pg. 18
Ilustracin 5: Captura de pantalla de la salida del programa4.............................. Pg. 20





Introduccin a C#
- iv -

1.- I IN NT TR RO OD DU UC CC CI I N N

Durante dos dcadas C y C++ han sido los reyes de los lenguajes de programacin. Pero
apareci Internet y se produjo un cambio de necesidad del usuario respecto a la maquina.
Entonces naci Java que acabo convirtindose en el lenguaje de programacin de Internet.
Basado en un cdigo intermedio, producido mediante compilacin, llamado Byte-code, que se
interpreta en cada ordenador mediante un interprete llamado maquina virtual, consiguiendo un
cdigo independiente de la maquina, de la plataforma y gran robustez.
Aqu es donde entra en juego el seor Gates. Ante el imparable desarrollo en Java,
Microsoft aporta su producto de programacin a la red, despus de fracasar en el intento de su
propio Java (conocido como J++). Nace as la estrategia que Microsoft denomina .NET y su
gama de productos microsoft.NET.
Y dentro de este esta posiblemente el
producto estrella del microsoft.NET, C# esta
diseado para competir con Java. Al igual que
este se basa en producir un cdigo intermedio
MSIL (Microsoft Intermediate Language), que es
ejecutado por maquinas virtuales JIT. Esto nos
recuerda mucho a Java, pero con la forma y la
potencia del C++.
Gracias a la generacin de cdigo MSIL, el
programador que utiliza C# no tiene por qu
preocuparse del sistema operativo o procesador
en el que va a ejecutarse la aplicacin, En
principio la plataforma Microsoft .NET se
encontrar disponible para Windows 98, Me, NT,
2000 y XP, estando en preparacin una compact
.NET Framework para dispositivos mviles tipo
Pocket PC. En el futuro, sin embargo, este
entorno de ejecucin de cdigo MSIL estar
disponible para procesadores de 64 bits y
posteriormente otros sistemas operativos no
Windows. El compilador JIT de cada sistema en
particular se encargara de traducir el MSIL en
cdigo nativo aprovechando las caractersticas
del procesador y sistema operativo concreto en el
que vaya a producirse la ejecucin, sin necesidad
de mantener varias ediciones diferentes del
mismo proyecto.
Otra ventaja del uso de MSIL es que la cooperacin entre C# y otros lenguajes .NET
ajustados a la CLS
1
(Common Language Specification) es total, de tal forma que podemos
derivar una nueva clase C# tomando como base otra escrita en Visual Basic .NET, por poner un
ejemplo. Cada programador puede usar el lenguaje de su preferencia sin limitar las opciones de
los dems. Adems C# nos deja interactuar con los componentes COM (ahora llamados COM+)
y programar a mas bajo nivel.

1
Para construir una mquina virtual comn a todos los lenguajes primero hay que definir una serie de caractersticas
comunes a todos ellos. Este conjunto de caractersticas comunes se engloban en el llamado Common Languaje
Runtime(CLR)
1
Introduccin a C#
- 2 -
1.- C CA AR RA AC CT TE ER R S ST TI IC CA AS S D DE E C C# #


El objetivo de Microsoft ha sido la creacin del primer lenguaje orientado a componentes
2
, al
estilo de visual Basic, pero con la flexibilidad y potencia de C++ y sin muchas de sus
complejidades. C, C++ o Visual Basic estn pensados para el desarrollo de aplicacio0nes en
sistemas operativos que ofrecen sus servicios a travs de cientos o miles de funciones
independientes que, en conjunto, forman lo que se conoce coloquialmente como API
(Application Programming Interface). En contraposicin, C# ha sido diseado para una
plataforma, la plataforma Microsoft .NET, en la que los servicios son ofrecidos en forma de
componentes.
Aunque C# es un primo muy cercano de C++, tambin tiene influencias de Visual Basic,
Modula 2, Smalltalk y Java. El resultado es un lenguaje orientado al trabajo con componentes
que mantiene, en su mayor parte, los operadores y estructuras propias del lenguaje C++.
Sus principales caractersticas son:

S Se en nc ci il ll le ez z: C# elimina muchos elementos que otros lenguajes incluyen y que son
innecesarios en .NET. Por ejemplo:

El tamao de los tipos de datos bsicos es fijo e independiente del compilador,
sistema operativo o mquina para quienes se compile (no como en C++), lo
que facilita la portabilidad del cdigo.

No se incluyen elementos poco tiles de lenguajes como C++ tales como
macros, herencia mltiple o la necesidad de un operador diferente del punto (.)
acceder a miembros de espacios de nombres (::)

M Mo od de er rn ni id da ad d: C# incorpora en el propio lenguaje elementos que a lo largo de los aos
ha ido demostrndose son muy tiles para el desarrollo de aplicaciones y que en otros
lenguajes como Java o C++ hay que simular, como un tipo bsico decimal que permita
realizar operaciones de alta precisin con reales de 128 bits (muy til en el mundo
financiero), la inclusin de una instruccin foreach que permita recorrer colecciones
con facilidad y es ampliable a tipos definidos por el usuario, la inclusin de un tipo
bsico string para representar cadenas o la distincin de un tipo bool especfico para
representar valores lgicos.

O Or ri ie en nt ta ac ci i n n a a o ob bj je et to os s: : como hijo directo de C++, C# cuenta con la mayora de las
caractersticas de orientacin a objetos de aqul. La entidad de primer nivel es, como en
todos los lenguajes de esta categora, la clase, definicin a partir de la cual se crearan
objetos y derivaran nuevas clases. La encapsulacin, la herencia y el polimorfismo son,
por tanto, los tres pilares bsicos de la orientacin a objetos en C# como en C++.

En lo referente a la encapsulacin es importante sealar que aparte de los
tpicos modificadores public, private y protected, C# aade un cuarto
modificador llamado internal, que puede combinarse con protected e indica que
al elemento a cuya definicin precede slo puede accederse desde su mismo
ensamblado.





2
Esto significa que cuenta con construcciones sintcticas nativas para la definicin, implementacin y consumo de
propiedades, mtodos y eventos, lo cual le diferencia claramente de C++ o Java.
2
Gmez y Mohedano
- 3 -
Respecto a la herencia -a diferencia de C++ y al igual que Java- C# slo
admite herencia simple de clases ya que la mltiple provoca ms
complicaciones que facilidades y en la mayora de los casos su utilidad puede
ser simulada con facilidad mediante herencia mltiple de interfaces.

O Or ri ie en nt ta ac ci i n n a a c co om mp po on ne en nt te es s: La propia sintaxis de C# incluye elementos propios del
diseo de componentes que otros lenguajes tienen que simular mediante construcciones
ms o menos complejas. Es decir, la sintaxis de C# permite definir cmodamente
propiedades (similares a campos de acceso controlado), eventos (asociacin controlada
de funciones de respuesta a notificaciones) o atributos (informacin sobre un tipo o sus
miembros).

G Ge es st ti i n n a au ut to om m t ti ic ca a d de e m me em mo or ri ia a: todo lenguaje de .NET tiene a su disposicin el
recolector de basura del CLR. Esto tiene el efecto en el lenguaje de que no es necesario
incluir instrucciones de destruccin de objetos. Sin embargo, dado que la destruccin de
los objetos a travs del recolector de basura es indeterminista y slo se realiza cuando
ste se active ya sea por falta de memoria, finalizacin de la aplicacin o solicitud
explcita en el fuente-, C# tambin proporciona un mecanismo de liberacin de recursos
determinista a travs de la instruccin using.

S Se eg gu ur ri id da ad d d de e t ti ip po os s: C# tiene mecanismos que aseguran que los accesos a tipos de
datos se realicen correctamente siempre. Esto los odiosos errores difciles de detectar
por acceso a memoria no perteneciente a ningn objeto y es especialmente necesario en
un entorno gestionado por un recolector de basura. Para ello se toman las siguientes
medidas:

Slo se admiten conversiones entre tipos compatibles. Esto es, entre un tipo y
antecesores suyos, entre tipos para los que explcitamente se haya definido un
operador de conversin, y entre un tipo y un tipo hijo suyo del que un objeto del
primero almacenase una referencia del segundo (downcasting) Obviamente, lo
ltimo slo puede comprobarlo en tiempo de ejecucin el CLR y no el
compilador, por lo que en realidad el CLR y el compilador colaboran para
asegurar la correccin de las conversiones.

No se pueden usar variables no inicializadas. El compilador da a los campos
un valor por defecto consistente en ponerlos a cero y controla mediante anlisis
del flujo de control del fuente que no se lea ninguna variable local sin que se le
haya asignado previamente algn valor.

Se comprueba que todo acceso a los elementos de una tabla se realice con
ndices que se encuentren dentro del rango de la misma.

Se puede controlar la produccin de desbordamientos en operaciones
aritmticas, informndose de ello con una excepcin cuando ocurra. Sin
embargo, para conseguirse un mayor rendimiento en la aritmtica estas
comprobaciones no se hacen por defecto al operar con variables sino slo con
constantes (se pueden detectar en tiempo de compilacin)

A diferencia de Java, C# incluye delegados, que son similares a los punteros a
funciones de C++ pero siguen un enfoque orientado a objetos, pueden
almacenar referencias a varios mtodos simultneamente, y se comprueba que
los mtodos a los que apunten tengan parmetros y valor de retorno del tipo
indicado al definirlos.
Introduccin a C#
- 4 -

I In ns st tr ru uc cc ci io on ne es s s se eg gu ur ra as s: Para evitar errores muy comunes, en C# se han impuesto una
serie de restricciones en el uso de las instrucciones de control ms comunes. Por
ejemplo, no es posible utilizar un entero como nico operando de una condicional,
evitando de esta manera que una asignacin equivocada, por utilizar el operando = en
lugar del ==, genere un error lgico difcil de encontrar. Adems todo caso de un switch
ha de terminar en un break o goto que indique cul es la siguiente accin a realizar, lo
que evita la ejecucin accidental de casos y facilita su reordenacin.

S Si is st te em ma a d de e t ti ip po os s u un ni if fi ic ca ad do o: A diferencia de C++, en C# todos los tipos de datos que se
definan siempre derivarn, aunque sea de manera implcita, de una clase base comn
llamada System.Object, por lo que dispondrn de todos los miembros definidos en sta
clase (es decir, sern objetos)

El hecho de que todos los tipos del lenguaje deriven de una clase comn facilita
enormemente el diseo de colecciones genricas que puedan almacenar objetos
de cualquier tipo.

E Ex xt te en ns si ib bi il li id da ad d d de e o op pe er ra ad do or re es s: C# permite redefinir el significado de la mayora de los
operadores -incluidos los de conversin, tanto para conversiones implcitas como
explcitas- cuando se apliquen a diferentes tipos de objetos.

Las redefiniciones de operadores se hacen de manera inteligente, de modo que a
partir de una nica definicin de los operadores ++ y -- el compilador puede
deducir automticamente como ejecutarlos de manera prefijas y postifja; y
definiendo operadores simples (como +), el compilador deduce cmo aplicar su
versin de asignacin compuesta (+=) Adems, para asegurar la consistencia, el
compilador vigila que los operadores con opuesto siempre se redefinan por
parejas (por ejemplo, si se redefine ==, tambin hay que redefinir !=).

Tambin se da la posibilidad, a travs del concepto de indizador, de redefinir el
significado del operador [] para los tipos de dato definidos por el usuario, con lo
que se consigue que se pueda acceder al mismo como si fuese una tabla. Esto es
muy til para trabajar con tipos que acten como colecciones de objetos.

Eficiente: En principio, en C# todo el cdigo incluye numerosas restricciones para
asegurar su seguridad y no permite el uso de punteros. Sin embargo en C# es posible
saltarse dichas restricciones manipulando objetos a travs de punteros. Para ello basta
marcar regiones de cdigo como inseguras (modificador unsafe) y podrn usarse en
ellas punteros de forma similar a cmo se hace en C++, lo que puede resultar vital para
situaciones donde se necesite una eficiencia y velocidad procesamiento muy grandes.

Compatible: Para facilitar la migracin de programadores, C# no slo mantiene una
sintaxis muy similar a C, C++ o Java que permite incluir directamente en cdigo
escrito en C# fragmentos de cdigo escrito en estos lenguajes, sino que el CLR tambin
ofrece, a travs de los llamados Platform Invocation Services (PInvoke), la
posibilidad de acceder a cdigo nativo escrito como funciones sueltas no orientadas a
objetos tales como las DLLs de la API Win32.

Gmez y Mohedano
- 5 -

1.- H HE ER RR RA AM MI IE EN NT TA AS S

3.1. - El Kit de desarrollo.
Lo primero que hay que hacer es conseguir el compilador requerido, en este caso existe lo que
se denomina entorno de desarrollo .NET SDK e instalarlo en el ordenador. Este paquete se
puede instalar solo en entornos Microsoft bajo Windows98, Windows Me, Windows 2000 y
Windows NT, aunque es aconsejable que tengamos Windows 2000 (segn Microsoft).
Puedes descargarte el .NET Framework SDK Beta 1 de la pagina de Microsoft y es
totalmente gratuito (ocupa 106 Mb). Esta disponible en:
http://www.microsoft.com/downloads/details.aspx?displaylang=es&FamilyID=9b3a2ca6-
3647-4070-9f41-a333c6b9181d

3.2. - Entornos de desarrollo.
El C# esta diseado para formar parte del entorno de desarrollo Visual Studio .NET de
Microsoft, pero existen otros entornos de desarrollo como por ejemplo:
Antechinus C# Editor v3.1.
El Antechinus C# Editor nos permite compilar y tener un editor que nos "colorea" las
palabras clave. Al ser de evaluacin no nos permite crear proyectos. Adems, tan slo
ocupa 887Kb. Puede bajarlo de http://www.c-point.com
Entorno de IC#SharpCode:
Existe otro entorno de desarrollo open-source (GPL) del que podemos disponer del
cdigo fuente. Est realizado en C# y nos permite la creacin de proyectos, pero la ltima
versin (0.53) da bastantes problemas, as que habr que esperar a que implementen una
versin ms estable.
De todos modos, la herramienta tiene muy buen aspecto. Quien est interesado puede
visitar su pgina: http://www.icsharpcode.net/
3
Introduccin a C#
- 6 -

1.- P PR RI IM ME ER R P PR RO OG GR RA AM MA A E EN N C C# #: : H He el ll lo o W Wo or rl ld d! !


Para iniciarse en C#, nada mejor que el tpico programa de Hello World! que lo nico que
hace al ejecutarse es mostrar por pantalla el mensaje Hello World!.
El cdigo necesario para ello, define una clase, llamada HelloWorld, que contiene un
mtodo llamado Main(). En su interior introducimos la sentencia
System.Console.WriteLine(Hello World! ), de tal forma que el programa completo sera el
mostrado en programa1.











Lo que hacemos en esa sentencia es invocar al mtodo WriteLine () de la clase Console,
una clase definida en el mbito System. Es importante insistir en que Console es una clase de
objetos, pero gracias a que el mtodo WriteLine es static, no es necesario crear ningn objeto de
ella para poder usarlo. Tambin es importante aclarar que esta clase no est disponible por
defecto, sino que es necesario indicar al compilador de C# que queremos utilizarla de forma
explcita mediante la clusula using System que se encuentra al principio del programa. Con
dicho mtodo ( WriteLine() )se consigue que se muestre por la ventana de consola la cadena que
se le pasa como primer parmetro pero sustituyndole las subcadenas {i} por el valor convertido
en cadena de texto del parmetro que ocupe la posicin i+2 en la llamada a WriteLine(). Por
ejemplo, la siguiente instruccin mostrara: Tengo 21 aos por pantalla si x valiese 21.





Es importante resaltar que C# es sensible a las maysculas. Es decir, no es lo mismo
escribir WriteLine, que WriTeLiNe o WRITELINE, y si se hace de alguna de las dos ltimas
formas el compilador producir un error debido a que en el espacio de nombres System no existe
ninguna clase con dichos nombres.
Using System;
class HelloWorld
{
static void Main()
{
System.Console.WriteLine(Hello
World! );
}
Programa1: Aplicacin Hello World

System.Console.WriteLine(Tengo {0} aos, x);
5
Gmez y Mohedano
- 7 -


1.- C CO OM MP PI IL LA AC CI I N N

6.1.- Compilacin en lnea de comandos

Una vez escrito el cdigo anterior con algn editor de textos como el Bloc de Notas de
Windows- y almacenado en formato de texto en un fichero HelloWorld.cs
3
, para compilarlo
basta abrir una ventana de consola (MS-DOS en Windows), colocarse en el directorio donde se
encuentre y pasrselo como parmetro al compilador as:
C:\ csc HelloWorld.cs
csc.exe es el compilador de C# incluido en el .NET Framework SDK para Windows de
Microsoft, y es posible llamarlo desde cualquier directorio en tanto que al instalarlo se aade
una referencia al mismo en el path. Si utiliza otros compiladores de C# puede que vare la forma
en que se realice la compilacin, por lo que lo que aqu se explica en principio slo podra ser
vlido para el compilador de Microsoft para Windows.

Tras la compilacin se obtendra un ejecutable llamado HelloWorld.exe cuya ejecucin
producira la salida por la ventana de consola que se muestra en la Ilustracin 1.





6.2.- Compilacin con Visual Studio.NET

Para compilar una aplicacin en Visual Studio.NET primero hay que incluirla dentro de algn
proyecto. Para ello basta pulsar el botn Nuevo Proyecto en la pgina de inicio que se muestra
nada ms arrancar dicha herramienta, tras lo que se obtendr una pantalla con el aspecto
mostrado en la Ilustracin 2.

















Ilustracin 2: Ventana de creacin de nuevo proyecto en Visual Studio.NET

3
El nombre que se d al fichero puede ser cualquiera, aunque se recomienda darle la extensin .cs ya que es la
utilizada por convenio.
6
Hel l o Wor l d !

Ilustracin 1: Captura de pantalla de la salida del programa1.
Introduccin a C#
- 8 -
En el recuadro de la ventana mostrada etiquetado como Tipos de Proyectos se ha de
seleccionar el tipo de proyecto a crear. Obviamente, si se va a trabajar en C# la opcin que
habr que escoger en la misma ser siempre Proyectos de Visual C#.
En el recuadro Plantillas se ha de seleccionar la plantilla correspondiente al subtipo de
proyecto dentro del tipo indicado en Tipos de Proyectos que se va a realizar. Para realizar un
ejecutable de consola, como es nuestro caso, hay que seleccionar el icono etiquetado como
Aplicacin de consola.
Por ltimo, en el recuadro de texto Nombre se ha de escribir el nombre a dar al proyecto y
en Ubicacin el del directorio base asociado al mismo. Debajo de Ubicacin hay un mensaje
que informa sobre cual ser el directorio donde finalmente se almacenarn los archivos del
proyecto, que ser el resultante de concatenar la ruta especificada para el directorio base y el
nombre del proyecto.
Una vez configuradas todas estas opciones, al pulsar botn OK Visual Studio crear toda la
infraestructura adecuada para empezar a trabajar cmodamente en el proyecto. Esta
infraestructura consistir en la generacin de un fuente que servir de plantilla para la
realizacin de proyectos del tipo elegido (en este caso, aplicaciones de consola en C#):
A partir de esta plantilla, escribir el cdigo de la aplicacin del programa1 es tan sencillo
con simplemente teclear System.Console.WriteLine(Hello World!) dentro de la definicin
del mtodo Main() creada por Visual Studio.NET. Claro est, otra posibilidad es borrar toda la
plantilla y sustituirla por el cdigo para HelloWorld mostrado anteriormente.
Sea haga como se haga, para compilar y ejecutar tras ello la aplicacin slo hay que pulsar
CTRL+F5 o seleccionar Depurar Iniciar sin depurar en el men principal de Visual
Studio.NET. Para slo compilar el proyecto, entonces hay que seleccionar Depurar Iniciar.
De todas formas, en ambos casos el ejecutable generado se almacenar en el subdirectorio
Bin\Debug del directorio del proyecto.
La salida por pantalla se podra observar en la Ilustracin 3.
Hel l o Wor l d !

Ilustracin 3: Captura de pantalla de la salida del programa1.
Gmez y Mohedano
- 9 -


16- PLATAFORMA MONO


6.1. - Proyecto Mono

La creacin de Mono ha sido un arduo proceso en el que se ha dependido
mucho de las herramientas de Microsoft para ir creando la plataforma.
Hasta el 16 de Julio de 2002 no ha sido posible desarrollar totalmente
todas las labores de Mono en GNU/Linux. El desarrollo del compilador y
todas las clases de la plataforma Mono han necesitado ser desarrolladas
inicialmente con el compilador y el entorno .NET de Microsoft. Poco a poco se ha ido logrando
independencia en GNU/Linux, primero logrando que el compilador de Mono, desarrollado en
C#, pudiera ser ejecutado dentro del entorno de ejecucin Mono en GNU/Linux.
Una vez que se tuvo un compilador de C# en GNU/Linux, se aceler
el desarrollo y poco a poco, la mayora de las clases de la plataforma
.NET se fueron implementando y comprobando su funcionamiento en
GNU/Linux, hasta lograr el hito actual de que todas las clases
fundamentales cd Mono, corlib, fueran compiladas y ejecutadas con el
compilador C# (mcs) en GNU/Linux y ejecutadas en el entorno Mono de
GNU/Linux (mono).
Hoy en da Mono funciona de manera bastante estable, y la librera
de clases se ha extendido y ya incluye varios componentes, como Gtk# (recubrimiento a las
libreras de GNOME, para poder hacer aplicaciones grficas con Mono), Mono.Data (acceso a
bases de datos), etc.

6.2. - Compilacin con Mono

La compilacin es bastante sencilla:
./mcs HelloWorld.cs
Entonces nos aparece en pantalla: "Compilation succeeded". El archivo generado por esta
accin da como resultado al archivo: " HelloWorld.exe" este archivo desde el inicio es marcado
como ejecutable para todos los usuarios. En este caso la extensin *.exe no se refiere a que sea
un ejecutable de DOS/Windows sino que hace referencia a cdigo IL (Lenguaje Intermedio), que
viene a ser como el bytecode de Java.
Podemos poner ficheros de ejecucin a este ejecutable y directamente correrlo:
1.- Creamos el archivo " HelloWorld "
2.- Insertamos: "mono HelloWorld.exe" y guardamos
3.- Lo hacemos ejecutable: "chmod u+x HelloWorld "
4.- Corremos "./ HelloWorld
Si hubiramos ejecutado lo que nos gener la compilacin ./HelloWorld.exe hubiramos
obtenido este bonito error de: "./ HelloWorld .exe: cannot execute binary file" y cuando esto
pasa lo que debemos hacer para correrlo es hacer: "mono HelloWorld .exe" y as obtendremos
de salida: " Hello World . Tambin podramos hacer uso del archivo " HelloWorld " creado en
el paso anterior.
6
Introduccin a C#
- 10 -



16- CLASES EN C#

7.1.- Conceptos de clase y objeto
C# es un lenguaje orientado a objetos puro, slo se trabaja con objetos. Un objeto es un
conjunto de datos y de mtodos que permiten manipular dichos datos, y un programa en C# no
es ms que un conjunto de objetos que se relacionan unos con otros a travs de sus mtodos.
Una clase es la definicin de las caractersticas concretas de un determinado tipo de
objetos. Es decir, de cules son los datos y los mtodos de los que van a disponer todos los
objetos de ese tipo. Se suele decir que el tipo de dato de un objeto es la clase que define las
caractersticas del mismo
4
.

7.2.- Visibilidad de una clase y sus miembros
Las clases pueden estar incluidas en un mbito con nombre o en otras clases. Su visibilidad,
fuera de ese mbito depender de los modificadores que se incluyan delante de la palabra class
en el momento de la definicin. Estos modificadores pueden tambin aplicarse a los miembros
de la clase: mtodos, propiedades, variables, etc Las posibilidades son las siguientes:
public - la clase, o el miembro, es visible en todos los mbitos, no solo en el que se
ha definido. Las clases publicas, por ejemplo, pueden usarse desde mbitos con
nombres externos al propio. Los miembros pblicos de una clase son accesibles, al
crear un objeto, desde fuera de la propia clase.
protected este modificador slo es aplicable a los miembros de una clase, no a la
clase en s. La visibilidad est reducida a la propia clase y las que pudieran
derivarse de ella. Es decir, un miembro protegido no es accesible externamente.
private es el mbito ms reducido. Una clase privada slo puede utilizarse en el
interior del mbito en que se encuentra incluida, ya sea un nameespace u otra clase.
Los miembros que tienen este modificador, igualmente, slo pueden ser usados
desde el interior de la clase donde se han definido, nunca desde fuera, ni siquiera en
clases derivadas.
internal es similar a public. Si bien la clase o el miembro es visible desde fuera de
su mbito inmediato, esta regla solamente se aplica dentro del ensamblado al que
pertenece. La clase public puede usarse desde diferentes ensamblados, mientras que
una internal no.
protected internal es una combinacin de protected e internal. El resultado es que
los identificadores pueden utilizarse en el ensamblado en el que se han definido, as
como en clases derivadas a pesar de que se encuentren en otros ensamblados.

4
Tambin hay otras formas de definir las caractersticas de un tipo de objetos, como son las estructuras
y las enumeraciones.
7
Gmez y Mohedano
- 11 -
7.3.- Sintaxis de definicin de clases

La sintaxis bsica para definir una clase es la siguiente:



De este modo se definira una clase de nombre < Clase_1 > cuyos miembros son los
definidos en < miembros > Los miembros de una clase son los datos y mtodos de los que van a
disponer todos los objetos de dicha clase. Para declarar una clase sin ningn miembro,
utilizaramos una sentencia como esta: class A {}
Una clase as declarada no dispondr de ningn miembro excepto los implcitamente
definidos de manera comn para todos los objetos que creemos en C#. Estos miembros se
definen dentro de la clase primitiva System.Object.
En C# existen muchos tipos de miembros. Entre ellos destacan:

C Ca am mp po os s: Un campo es un dato comn a todos los objetos de una determinada
clase. Para definir cules son los campos de los que una clase dispone se usa la
siguiente sintaxis dentro de la zona sealada como <miembros> en la definicin de
la misma:
<tipoCampo> <nombreCampo>;
Los campos de un objeto son a su vez objetos, y en <tipoCampo> se indica cul
es el tipo de dato del objeto que se va a crear. ste tipo puede corresponderse con
cualquiera que los predefinidos en la BCL o con cualquier otro definido
previamente. A continuacin se muestra un ejemplo (cdigo1) de definicin de una
clase de nombre Persona que dispone de tres campos:










Todos los objetos de la clase Persona incorporarn campos que almacenarn
cul es el nombre de la persona que cada objeto representa, cul es su edad y cul es
su NIF. El tipo int incluido en la definicin del campo Edad es un tipo predefinido
en la BCL cuyos objetos son capaces de almacenar nmeros enteros.
Para acceder a un campo de un determinado objeto se utiliza el operador .:
<objeto>.<campo>
Por ejemplo, para acceder al campo Edad de un objeto Persona llamado
p y cambiar su valor por 20 se hara:
p.Edad = 20;
En realidad lo marcado como <objeto> no tiene porqu ser necesariamente el
nombre de algn objeto, sino que puede ser cualquier expresin que produzca como
resultado una referencia no nula a un objeto.


class <Clase_1>
{
<
miembros >
}
class Persona
{
string Nombre;// Campo de cada objeto Persona que almacena su
nombre
int Edad; // Campo de cada objeto Persona que almacena
su edad
string NIF; // Campo de cada objeto Persona que almacena
su NIF
}
Cdigo 1: Definicin de clase sin mtodos
Introduccin a C#
- 12 -
M M t to od do os s: Un mtodo es un conjunto de instrucciones a las que se les asocia un
nombre de modo que si se desea ejecutarlas basta referenciarlas a travs de dicho
nombre en vez de tener que escribirlas. Mediante estas instrucciones se puede
acceder a los campos de la clase en la que el mtodo est definido.

Para definir un mtodo
en C# se utilizara un
cdigo como el siguiente:

Todo mtodo puede devolver un objeto que pertenecer a un tipo de dato. Si no
devuelve nada se indica void, y si devuelve algo es obligatorio finalizar la ejecucin
de sus instrucciones con alguna instruccin return <objeto>; que indique qu
objeto ha de devolverse.
Opcionalmente todo mtodo puede recibir en cada llamada una lista de objetos
a los que podr acceder durante la ejecucin de sus instrucciones. Aunque los
objetos que puede recibir el mtodo pueden ser diferentes cada vez que se solicite
su ejecucin, siempre han de ser de los mismos tipos y han de seguir el orden
establecido en <parametros>.
Un ejemplo de cmo declarar un mtodo de nombre Cumpleaos es la siguiente
modificacin (cdigo2) de la definicin de la clase Persona usada antes como
ejemplo:











La sintaxis usada para llamar a los mtodos de un objeto es la misma que la
usada para llamar a sus campos, salvo que ahora tambien se incluyen los parmetros
utilizados en caso de haberlos.
<objeto>.<mtodo>(<parmetros>)
En C# existe la sobrecarga de mtodos, es decir, en una misma clase pueden
definirse varios mtodos con el mismo nombre siempre y cuando tomen diferente
nmero o tipo de parmetros. Sin embargo, no se pueden definir varios mtodos
que slo se diferencien en su valor de retorno, ya que como ste no se tiene porqu
indicar al llamarlos no podra diferenciarse a qu mtodo en concreto se hace
referencia en cada llamada.
En C# todo, incluido los literales, son objetos del tipo de cada literal y por tanto
pueden contar con miembros a los que se accedera como cualquier objeto definido
por el programador. Por ejemplo: string s = 12.ToString();
Este cdigo almacena el literal de cadena 12 en la variable s. 12 es un
objeto de tipo int y posee un mtodo comn a todos los ints llamado ToString()
que lo que hace es devolver una cadena cuyos caracteres son los dgitos que forman
el entero representado por el int sobre el que se aplica; y como la variable s es de
tipo string es perfectamente posible almacenar dicha cadena en ella, que es lo que
se hace en el cdigo anterior.

<tipoDevuelto> <nombreMtodo> (<parametros>)
{
<instrucciones>
}
class Persona
{
string Nombre; // Campo de cada objeto Persona que almacena su nombre
int Edad; // Campo de cada objeto Persona que almacena su edad
string NIF; // Campo de cada objeto Persona que almacena su
NIF

void Cumpleaos() // Incrementa en uno de la edad del objeto Persona
{
Edad++;
}
}
Cdigo2: Definicin de clase con mtodos
Gmez y Mohedano
- 13 -

16- CREACIN DE OBJETOS EN C#

8.1.- Operador new

El operador new es el encargado de crear objetos en C#. Su utilizacin es la siguiente:
new <nombreTipo>(<parametros>)
Este operador crea un nuevo objeto del tipo cuyo nombre se le indica y llama durante su
proceso de creacin al constructor del mismo apropiado segn los valores que se le pasen en
<parametros>, devolviendo una referencia al objeto recin creado. Es importante resaltar este
ltimo punto, ya que new no devuelve el objeto en s, sino una referencia en memoria a dicho
objeto.
El constructor recibe ese nombre debido a que su cdigo suele usarse precisamente para
construir el objeto, es decir, para inicializar sus miembros. Por ejemplo, a la clase de ejemplo
Persona le podramos aadir un constructor dejndola como se ve en el cdigo3.














El constructor toma como parmetros los valores con los que se desea inicializar el objeto a
crear. Gracias a l, se puede crear un objeto Persona de nombre Jos, de 22 aos de edad y NIF
12344321-A , as: new Persona(Jos, 22, 12344321-A)
Al igual que en C++, un objeto puede tener mltiples constructores, aunque para
diferenciar a unos de otros es obligatorio que se diferencien en el nmero u orden de los
parmetros que aceptan, ya que el nombre de todos ellos ha de coincidir con el nombre de la
clase de la que son miembros.
Una vez creado un objeto lo ms normal es almacenar la direccin devuelta por new en una
variable del tipo apropiado para el objeto creado. El siguiente ejemplo muestra cmo crear una
variable de tipo Persona llamada p y cmo almacenar en ella la direccin del objeto que
devolvera la anterior sentencia usando el operador new:




La variable p contendr una referencia a un objeto de clase Persona que representar a
una persona llamada Jos de 22 aos y NIF 12344321-A.


8
class Persona{

string Nombre; // Campo de cada objeto Persona que almacena su nombre
int Edad; // Campo de cada objeto Persona que almacena su
edad
string NIF; // Campo de cada objeto Persona que almacena su NIF

void Cumpleaos() // Incrementa en uno la edad del objeto Persona
{
Edad++;
}

Persona (string nombre, int edad, string nif) // Constructor
{
Nombre = nombre;
Edad = edad;
NIF = nif;
}
Cdigo 3: Definicin de clase con constructor
Persona p; // Se crea la variable p
p = new Persona(Jose, 22, 12344321-A);// Se guarda en p el objeto

Introduccin a C#
- 14 -

8.2.- Constructor por defecto

No es obligatorio definir un constructor para cada clase, y en
caso de que no se defina ninguno, el compilador crear uno sin
parmetros ni instrucciones. Es decir, como si se hubiese
definido de esta forma:


As se podr crear un objeto utilizando el operador new::



El constructor por defecto es slo incluido por el compilador si no hemos definido ningn
otro constructor. Si existe una clase en la que se haya definido algn constructor con parmetros
pero ninguno sin parmetros no ser vlido crear objetos de la misma llamando al constructor
sin parmetros, pues el compilador no lo habr definido automticamente. Por ejemplo, con la
ltima versin de la clase de ejemplo Persona no es correcto hacer:




8.3.- Referencia al objeto actual con this

Dentro del cdigo de cualquier mtodo de un objeto siempre es posible hacer referencia al
propio objeto usando la palabra reservada this. As, los nombres de los campos podrn coincidir
con el de los parmetros. Por ejemplo en el cdigo4, el constructor de la clase Persona escrito
anteriormente se puede rescribir as usando this.








El el cdigo4 puede que no resulte muy interesante debido a que para evitar tener que
usar this podra haberse escrito el constructor tal y como se mostr en la primera versin del
mismo: dando nombres que empiecen en minscula a los parmetros y nombres que empiecen
con maysculas a los campos.
Sin embargo, this es mas til en C# a la hora de realizar llamadas a un mtodo de un
objeto desde cdigo ubicado en mtodos del mismo objeto. En C# siempre es necesario que en
toda llamada a mtodo de un objeto se utilice el operador . <<Objeto.Metodo>>. Si el
mtodo pertenece al mismo objeto que hace la llamada, la nica forma de conseguir indicarlo
en C# es usando <<this. Metodo >>.
Finalmente, una tercera utilidad de this es permitir escribir mtodos que puedan devolver
como objeto el propio objeto sobre el que el mtodo es aplicado. Para ello se utilizara una
sentencia la sentencia return this;

<nombreTipo>()
{
}

Coche c = new Coche(); // Crea coche c llamando al constructor
Persona p = new Persona(); // ERROR: El nico constructor de

Persona (string Nombre, int Edad, string NIF)
{
this.Nombre = Nombre;
this.Edad = Edad;
this.NIF = NIF;
}

Cdigo 4: Uso de this.
Gmez y Mohedano
- 15 -


1.- HERENCIA Y MTODOS VIRTUALES EN C#

9.1.- Concepto de herencia
El mecanismo de herencia es uno de los pilares fundamentales en los que se basa la
programacin orientada a objetos. Al igual que en C++, es un mecanismo que permite definir
nuevas clases a partir de otras ya definidas de modo que si en la definicin de una clase
indicamos que sta hereda de otra, entonces la primera -clase hija- ser tratada por el
compilador automticamente como si su definicin incluyese la definicin de la segunda clase
padre o clase base. Mediante el mecanismo de herencia se contribuye a la reutilizacin del
cdigo, algo habitual en todos los lenguajes orientados a objetos. La novedad, en C#, es que
dicho cdigo no tiene por qu estar escrito en el mismo lenguaje. Desde C# podemos derivar
una nueva clase tomando como base otra escrita en Visual Basic .NET, J#, C++ o COBOL, por
poner algunos ejemplos, obteniendo, de esta forma, lo mejor del modelo de componentes COM,
que era la independencia del lenguaje, y lo mejor de los lenguajes orientados a objetos, la
herencia de implementacin inexistente en COM.
En C# todas las clases derivan por defecto de
object. Si se desea otra clase distinta se usara una
sintaxis como la siguiente:

A los miembros definidos en <miembrosHija> hay que sumarles los definidos en la clase
padre. Por ejemplo, a partir de la clase Persona puede crearse una clase Trabajador,como se
observa en el cdigo5.











Los objetos de esta clase Trabajador contarn con los mismos miembros que los objetos
Persona y adems incorporarn un nuevo campo llamado Sueldo que almacenar el dinero que
cada trabajador gane. A la hora de escribir el constructor de esta clase ha sido necesario
escribirlo con una sintaxis especial consistente en preceder la llave de apertura del cuerpo del
mtodo de una estructura de la forma: : base(<parametrosBase>)
A esta estructura se la conoce como inicializador base y se utiliza para indicar cmo se
desea inicializar los campos heredados de la clase padre. No es ms que una llamada al
constructor de la misma con los parmetros adecuados, y si no se incluye, el compilador
considerara por defecto que vale :base(), lo que sera incorrecto en este ejemplo debido a que
Persona carece de constructor sin parmetros.
9
class <nombreHija>:<nombrePadre>
{
<miembrosHija>
}
class Trabajador:Persona
{
public int Sueldo;

public Trabajador(string nombre, int edad, string nif, int sueldo)
: base(nombre, edad, nif)
{
Sueldo = sueldo;
}
}
Cdigo 5: Ejemplo de Herencia.
Introduccin a C#
- 16 -
Un ejemplo que pone de manifiesto cmo funciona la herencia es el programa2.






















9.2.- Mtodos Virtuales
En C# es posible cambiar la definicin de un mtodo heredado de una clase padre.
Para ello hay que preceder con la palabra reservada virtual la definicin de dicho mtodo
en la clase progenitora. A este tipo de mtodos se les llama mtodos virtuales. Para definirlos
se usa la siguiente
sintaxis:





Si en alguna clase hija se quiere redefinir el mtodo, se rescribira el cdigo pero
sustituyendo en su definicin la palabra reservada virtual por override:




using System;

class Persona
{
public string Nombre; // Campo de cada objeto Persona que almacena su nombre
public int Edad; // Campo de cada objeto Persona que almacena su edad
public string NIF; // Campo de cada objeto Persona que almacena su NIF

void Cumpleaos() // Incrementa en uno de edad del objeto Persona
{
Edad++;
}

public Persona (string nombre, int edad, string nif) // Constructor de Persona
{
Nombre = nombre;
Edad = edad;
NIF = nif;
}
}

class Trabajador: Persona
{
public int Sueldo; // Campo de cada objeto Trabajador que almacena cunto gana

Trabajador(string nombre, int edad, string nif, int sueldo): base(nombre, edad, nif)
{ // Se inicializa cada Trabajador en base al constructor de Persona
Sueldo = sueldo;
}

public static void Main()
{
Trabajador p = new Trabajador("Josan", 22, "77588260-Z", 100000);

Console.WriteLine ("Nombre="+p.Nombre);
Console.WriteLine ("Edad="+p.Edad);
Console.WriteLine ("NIF="+p.NIF);
Console.WriteLine ("Sueldo="+p.Sueldo);
}
}

Programa 2: Uso de la herencia.
virtual <tipoDevuelto> <nombreMtodo>(<parmetros>)
{
<cdigo>
}
override <tipoDevuelto> <nombreMtodo>(<parmetros>)
{
<nuevoCdigo>
}
Gmez y Mohedano
- 17 -

El lenguaje C# impone la restriccin de que toda redefinicin de mtodo que se quiera
realizar incorpore la partcula override para forzar a que el programador est seguro de que
verdaderamente lo que quiere hacer es cambiar el significado de un mtodo heredado. As se
evita que sin querer se defina un mtodo del que ya exista una definicin en una clase padre.
Adems, C# no permite definir un mtodo como override y virtual
Por otro lado, cuando se defina un mtodo como override ha de cumplirse que en alguna
clase antecesora (su clase padre, su clase abuela, etc.) de la clase en la que se ha realizado la
definicin del mismo exista un mtodo virtual con el mismo nombre que el redefinido.
A continuacin se muestra un ejemplo (programa3) en el que se redefine el mtodo
Cumpleaos() :


using System;

class Persona
{
public string Nombre; // Campo de cada objeto Persona que almacena su nombre
public int Edad; // Campo de cada objeto Persona que almacena su edad
public string NIF; // Campo de cada objeto Persona que almacena su NIF

public virtual void Cumpleaos() // Incrementa en uno de la edad del objeto Persona
{
Console.WriteLine(Incrementada edad de persona);
}

public Persona (string nombre, int edad, string nif) // Constructor de Persona
{
Nombre = nombre;
Edad = edad;
NIF = nif;
}

}

class Trabajador: Persona
{
public int Sueldo; // Campo de cada objeto Trabajador que almacena cunto gana

Trabajador(string nombre, int edad, string nif, int sueldo): base(nombre, edad, nif)
{ // Se inicializa cada Trabajador en base al constructor de Persona
Sueldo = sueldo;
}

public override Cumpleaos()
{
Edad++;
Console.WriteLine(Incrementada edad de persona);
}

public static void Main()
{
Persona p = new Persona("Carlos", 22, "77588261-Z", 100000);
Trabajador t = new Trabajador("Josan", 22, "77588260-Z", 100000);

t.Cumpleaos();
p.Cumpleaos();
}
}

Programa 3: Uso de mtodos virtuales.
Introduccin a C#
- 18 -

Se ha aadido el modificador virtual en la definicin de Cumpleaos() en la clase Persona
para habilitar la posibilidad de que dicho mtodo puede ser redefinido en clases hijas de
Persona. Tambin se ha aadido override en la redefinicin del mismo dentro de la clase
Trabajador para indicar que la nueva definicin del mtodo es una redefinicin del heredado de
la clase. La salida de este programa confirma que la implementacin de Cumpleaos() es
distinta en cada clase, como se ve en
la ilustracin 2.





Tambin es importante sealar que para que la redefinicin sea vlida ha sido necesario
aadir la operador de control de acceso public en el mtodo original, pues si no se incluyese se
considerara que el mtodo slo es accesible desde dentro de la clase donde se ha definido, lo
que no tiene sentido en mtodos virtuales ya que entonces nunca podra ser redefinido.

9.3.- Clases abstractas

Una clase abstracta es aquella que
forzosamente se ha de derivar si se desea
que se puedan crear objetos de la misma o
acceder a sus miembros estticos Para
definir una clase abstracta se antepone
abstract a su definicin, como se muestra
en el cdigo 6.





Las clases A y B del cdigo6 son abstractas, y como puede verse es posible combinar en
cualquier orden el modificador abstract con modificadores de acceso.
La utilidad de las clases abstractas es que pueden contener mtodos para los que no se d
directamente una implementacin sino que sean sus clases hijas quienes lo hagan. No es
obligatorio que las clases abstractas contengan mtodos de este tipo, pero s lo es marcar como
abstracta a toda la que tenga alguno. Estos mtodos se definen precediendo su definicin del
modificador abstract y sustituyendo su cdigo por un punto y coma (;), como se muestra en el
mtodo F() de la clase A del cdigo 6.
Obviamente, como un mtodo abstracto no tiene cdigo no es posible llamarlo.
Todo mtodo definido como abstracto es implcitamente virtual, pues si no sera imposible
redefinirlo para darle una implementacin en las clases hijas de la clase abstracta donde est
definido. Por ello es necesario incluir el modificador override a la hora de darle
implementacin. No es posible marcar un objeto como abstract y virtual a la vez, ya que
produce un error de compilacin.
En cambio, s es posible marcar un mtodo como abstract y override a la vez, lo que
convertira al mtodo en abstracto para sus clases hijas y forzara a que stas lo tuviesen que
reimplementar si no se quisiese que fuesen clases abstractas.

I ncr ement ada edad de t r abaj ador
I ncr ement ada edad de per sona

Ilustracin 4: Captura de pantalla de la salida del programa3.
public abstract class A
{
public abstract void F();
}
abstract public class B: A
{
public void G() {}
}
class C: B
{
public override void F()
{}
}
Cdigo 6: Ejemplo de clases abstractas
Gmez y Mohedano
- 19 -
1.- POLIMORFISMO EN C#

10.1.- Concepto de polimorfismo
El polimorfismo es otro de los pilares fundamentales de la programacin orientada a objetos.
Es la capacidad de almacenar objetos de un determinado tipo en variables de tipos antecesores
del primero a costa, claro est, de slo poderse acceder a travs de dicha variable a los
miembros comunes a ambos tipos. Sin embargo, las versiones de los mtodos virtuales a las que
se llamara a travs de esas variables no seran las definidas como miembros del tipo de dichas
variables, sino las definidas en el verdadero tipo de los objetos que almacenan.
A continuacin se muestra un ejemplo (programa4) de cmo una variable de tipo Persona
puede usarse para almacenar objetos de tipo Trabajador. En esos casos el campo Sueldo del
objeto referenciado por la variable no ser accesible, y la versin del mtodo Cumpleaos() a la
que se podra llamar a travs de la variable de tipo Persona sera la definida en la clase
Trabajador, y no la definida en Persona:
10
using System;

class Persona
{
public string Nombre; // Campo de cada objeto Persona que almacena su nombre
public int Edad; // Campo de cada objeto Persona que almacena su edad
public string NIF; // Campo de cada objeto Persona que almacena su NIF

public virtual void Cumpleaos() // Incrementa en uno la edad del objeto Persona
{
Console.WriteLine(Incrementada edad de persona);
}

public Persona (string nombre, int edad, string nif) // Constructor de Persona
{
Nombre = nombre;
Edad = edad;
NIF = nif;
}

}

class Trabajador: Persona
{
int Sueldo; // Campo de cada objeto Trabajador que almacena cunto gana

Trabajador(string nombre, int edad, string nif, int sueldo): base(nombre, edad, nif)
{ // Inicializamos cada Trabajador en base al constructor de Persona
Sueldo = sueldo;
}

public override Cumpleaos()
{
Edad++;
Console.WriteLine("Incrementada edad de trabajador");
}

public static void Main()
{
Persona p = new Trabajador("Josan", 22, "77588260-Z", 100000);

p.Cumpleaos();
// p.Sueldo++; //ERROR: Sueldo no es miembro de Persona
}
}

Programa 4: Uso del Polimorfismo.
Introduccin a C#
- 20 -

El mensaje mostrado por pantalla al ejecutar este mtodo confirma lo antes dicho respecto
a que la versin de Cumpleaos() a la que
se llama, como se puede comprobar en la
ilustracin 3.


I ncr ement ada edad de t r abaj ador

Ilustracin 5: Captura de pantalla de la salida del programa4.
Gmez y Mohedano
- 21 -

1.- CONCLUSIN Y BIBLIOGRAFA

Conclusin
C# es un lenguaje de programacin moderno e innovador que incorpora cuidadosamente
caractersticas encontradas en los lenguajes industriales y de investigacin ms habituales.
Manteniendo la filosofa de diseo de C#, Microsoft ha introducido varias caractersticas nuevas
potenciales al lenguaje C# con el fin de aumentar la productividad del desarrollador con
construcciones de lenguaje.
Desde su introduccin en febrero de 2001, numerosos desarrolladores han comenzado a
crear software utilizando el lenguaje de programacin C#. Incluso en Microsoft, C# se ha
utilizado para crear varias aplicaciones comerciales, entre las que se incluyen .NET Framework,
las propiedades Web de MSN y el SDK de Tablet PC. Como tal, C# ha demostrado ser un
lenguaje adecuado para la creacin de software comercial de alta calidad.
Actualmente Microsoft Corporation se encuentra desarrollando la segunda versin ms
importante del lenguaje de programacin C#, que incorporara cuatro nuevas caractersticas
fundamentales: componentes genricos, iteradores, mtodos annimos y tipos parciales.
Informacin de referencia
Manuales de C#
http://www.programatuweb.com/ - Pagina en la que se puede encontrar
manuales de muchos lenguajes incluido C#.
http://www.ciberteca.net - En esta pgina hay tanto manuales y tutoriales de
C#, como pequeos trucos que se utilizan a la hora de programar.
http://usuarios.lycos.es/somm2000/index.html -Esta pgina tiene una seccin
muy curiosa sobre C#, en la que se tratan temas de actualidad.
Francisco Charte Ojeda: Programacin con Visual C# .NET, Ed. ANAYA
Tom Archer, A FONDO C#, Ed. McGraw-Hill
Sobre el proyecto MONO
http://www.go-mono.com/ - Informacin general sobre el proyecto mono.
http://www.monohispano.org/ -Comunidad espaola que se dedica a temas
relacionados con el proyecto mono.
Otros enlaces interesantes:
http://ww.programacion.net.- Pgina con multitud de ejemplos de cdigo.
http://www.microsoft.com/spanish/msdn/articulos/archivo/050503/voices/v
bconC.asp -Pagina de la ayuda MSDN que ofrece Microsoft al programador.
11