Programación Orientada a Objetos

mayo, 2005

Introducción a C#

Miguel Ángel Gómez Vicente

Manuel Martín Mohedano

Departamento de Informática y Automática

Universidad de Salamanca
Información de los autores:

Miguel Ángel Gómez Vicente

3º Ingeniería Técnica en Informática de Sistemas

Facultad de Ciencias, Universidad de Salamanca
keepeek@usal.es

Manuel Martín Mohedano

3º Ingeniería Técnica en Informática de Sistemas

Facultad de Ciencias, Universidad de Salamanca
manumohedano@usal.es

Este documento puede ser libremente distribuido.

© 2005 Departamento de Informática y Automática - Universidad de Salamanca.

 Gómez y Mohedano

Resumen

Este documento trata de mostrar de forma breve y sencilla una introducción al mundo
del C#, el lenguaje estrella de .NET que ha sido construido especialmente para
adaptarse de manera natural al framework y aprovechar al máximo todas sus
características. No trata de ser un manual de programación sino una pequeña
aproximación, los que quieran ir más allá pueden consultar las referencias de la
bibliografía.

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 doesn’t
want to be a programming manual, but a little approximation. If anyone wants to know
more, he can consult references and bibliography.

i
Introducción a C#

Tabla de Contenidos
1. Introducción.............................................................................................. .Pág. 1
2. Características de C# ................................................................................ Pág. 2
3. Herramientas

3.1. Kit de desarrollo.............................................................Pág. 5

3.2. Entornos de desarrollo............................................................ Pág. 5

4. Primer programa en C#: ¡Hello world! .................................................... Pág. 5
5. Compilación
5.1. En línea de consola ................................................................. Pág. 6
5.2. Mediante Visual Studio .NET ................................................ Pág. 6
6. Plataforma MONO
6.1. Proyecto Mono ....................................................................... Pág. 8
6.2. Compilación con MONO ....................................................... Pág. 8
7. Clases en C#
7.1. Concepto de Clase y Objeto .................................................... Pág. 10
7.2. Visibilidad de una clase y sus miembros................................. Pág. 10
7.3. Sintaxis de definición de clases ............................................... Pág. 11
8. Creación de Objetos en C#
8.1. Operador “new”....................................................................... Pág. 13
8.2. Constructor por defecto ........................................................... Pág. 14
8.3. Referencia al objeto actual con “this” ..................................... Pág. 14
9. Herencia y métodos virtuales en C#
9.1. Concepto de Herencia.............................................................. Pág. 15
9.2. Métodos Virtuales ................................................................... Pág. 16
9.3. Clases Abstractas..................................................................... Pág. 18
10. Polimorfismo en C#
10.1 Concepto de Polimorfismo ...................................................... Pág. 19
11. Conclusión y Bibliografía............................................................................... Pág. 20

- ii -
 Gómez y Mohedano

Tabla de Figuras

Programa 1: Aplicación HelloWorld.................................................................... Pág. 5

Programa 2: Uso de la herencia............................................................................ Pág. 16
Programa 3: Uso de métodos virtuales ................................................................. Pág. 17
Programa 3: Uso del polimorfismo ...................................................................... Pág. 11

Código 1: Definición de clase sin métodos .......................................................... Pág. 11

Código 2: Definición de clase con métodos ......................................................... Pág. 12
Código 3: Definición de clase con constructor..................................................... Pág. 13
Código 4: Uso de “this”........................................................................................ Pág. 14
Código 5: Ejemplo de herencia ............................................................................ Pág. 15
Código 6: Ejemplo de clases abstractas................................................................ Pág. 18

Ilustración 1: Captura de pantalla de la salida del programa1.............................. Pág. 7

Ilustración 2: Ventana de creación de nuevo proyecto en Visual Studio .NET ... Pág. 7
Ilustración 3: Captura de pantalla de la salida del programa1.............................. Pág. 8
Ilustración 4: Captura de pantalla de la salida del programa3.............................. Pág. 18
Ilustración 5: Captura de pantalla de la salida del programa4.............................. Pág. 20

iii
Introducción a C#

- iv -
 1
1.- INTRODUCCIÓN

Durante dos décadas C y C++ han sido los reyes de los lenguajes de programación. Pero
apareció Internet y se produjo un cambio de necesidad del usuario respecto a la maquina.
Entonces nació Java que acabo convirtiéndose en el lenguaje de programación de Internet.
Basado en un código intermedio, producido mediante compilación, llamado Byte-code, que se
interpreta en cada ordenador mediante un interprete llamado maquina virtual, consiguiendo un
código independiente de la maquina, de la plataforma y gran robustez.

Aquí es donde entra en juego el señor Gates. Ante el imparable desarrollo en Java,
Microsoft aporta su producto de programación a la red, después 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
diseñado para competir con Java. Al igual que
este se basa en producir un código 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 generación de código MSIL, el

programador que utiliza C# no tiene por qué
preocuparse del sistema operativo o procesador
en el que va a ejecutarse la aplicación, En
principio la plataforma Microsoft .NET se
encontrará disponible para Windows 98, Me, NT,
2000 y XP, estando en preparación una compact
.NET Framework para dispositivos móviles tipo
Pocket PC. En el futuro, sin embargo, este
entorno de ejecución de código 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
código nativo aprovechando las características
del procesador y sistema operativo concreto en el
que vaya a producirse la ejecución, sin necesidad
de mantener varias ediciones diferentes del
mismo proyecto.

Otra ventaja del uso de MSIL es que la cooperación entre C# y otros lenguajes .NET
ajustados a la CLS1 (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 demás. Además C# nos deja interactuar con los componentes COM (ahora llamados COM+)
y programar a mas bajo nivel.

1
Para construir una máquina virtual común a todos los lenguajes primero hay que definir una serie de características
comunes a todos ellos. Este conjunto de características comunes se engloban en el llamado Common Languaje
Runtime(CLR)
Introducción a C#

2
1.- CARACTERÍSTICAS DE C#

El objetivo de Microsoft ha sido la creación del primer lenguaje orientado a componentes2, al

estilo de visual Basic, pero con la flexibilidad y potencia de C++ y sin muchas de sus
complejidades. C, C++ o Visual Basic están pensados para el desarrollo de aplicacio0nes en
sistemas operativos que ofrecen sus servicios a través de cientos o miles de funciones
independientes que, en conjunto, forman lo que se conoce coloquialmente como API
(Application Programming Interface). En contraposición, C# ha sido diseñado 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++, también 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 características son:

⊗ Sencillez: C# elimina muchos elementos que otros lenguajes incluyen y que son
innecesarios en .NET. Por ejemplo:

◘ El tamaño de los tipos de datos básicos es fijo e independiente del compilador,

sistema operativo o máquina para quienes se compile (no como en C++), lo
que facilita la portabilidad del código.

◘ No se incluyen elementos poco útiles de lenguajes como C++ tales como

macros, herencia múltiple o la necesidad de un operador diferente del punto (.)
acceder a miembros de espacios de nombres (::)

⊗ Modernidad: C# incorpora en el propio lenguaje elementos que a lo largo de los años

ha ido demostrándose son muy útiles para el desarrollo de aplicaciones y que en otros
lenguajes como Java o C++ hay que simular, como un tipo básico decimal que permita
realizar operaciones de alta precisión con reales de 128 bits (muy útil en el mundo
financiero), la inclusión de una instrucción foreach que permita recorrer colecciones
con facilidad y es ampliable a tipos definidos por el usuario, la inclusión de un tipo
básico string para representar cadenas o la distinción de un tipo bool específico para
representar valores lógicos.

⊗ Orientación a objetos: como hijo directo de C++, C# cuenta con la mayoría de las
características de orientación a objetos de aquél. La entidad de primer nivel es, como en
todos los lenguajes de esta categoría, la clase, definición a partir de la cual se crearían
objetos y derivarían nuevas clases. La encapsulación, la herencia y el polimorfismo son,
por tanto, los tres pilares básicos de la orientación a objetos en C# como en C++.

◘ En lo referente a la encapsulación es importante señalar que aparte de los

típicos modificadores public, private y protected, C# añade un cuarto
modificador llamado internal, que puede combinarse con protected e indica que
al elemento a cuya definición precede sólo puede accederse desde su mismo
ensamblado.

2
Esto significa que cuenta con construcciones sintácticas nativas para la definición, implementación y consumo de
propiedades, métodos y eventos, lo cual le diferencia claramente de C++ o Java.

-2-
 Gómez y Mohedano

◘ Respecto a la herencia -a diferencia de C++ y al igual que Java- C# sólo

admite herencia simple de clases ya que la múltiple provoca más
complicaciones que facilidades y en la mayoría de los casos su utilidad puede
ser simulada con facilidad mediante herencia múltiple de interfaces.

⊗ Orientación a componentes: La propia sintaxis de C# incluye elementos propios del

diseño de componentes que otros lenguajes tienen que simular mediante construcciones
más o menos complejas. Es decir, la sintaxis de C# permite definir cómodamente
propiedades (similares a campos de acceso controlado), eventos (asociación controlada
de funciones de respuesta a notificaciones) o atributos (información sobre un tipo o sus
miembros).

⊗ Gestión automática de memoria: todo lenguaje de .NET tiene a su disposición el

recolector de basura del CLR. Esto tiene el efecto en el lenguaje de que no es necesario
incluir instrucciones de destrucción de objetos. Sin embargo, dado que la destrucción de
los objetos a través del recolector de basura es indeterminista y sólo se realiza cuando
éste se active –ya sea por falta de memoria, finalización de la aplicación o solicitud
explícita en el fuente-, C# también proporciona un mecanismo de liberación de recursos
determinista a través de la instrucción using.

⊗ Seguridad de tipos: C# tiene mecanismos que aseguran que los accesos a tipos de
datos se realicen correctamente siempre. Esto los odiosos errores difíciles de detectar
por acceso a memoria no perteneciente a ningún objeto y es especialmente necesario en
un entorno gestionado por un recolector de basura. Para ello se toman las siguientes
medidas:

◘ Sólo se admiten conversiones entre tipos compatibles. Esto es, entre un tipo y
antecesores suyos, entre tipos para los que explícitamente se haya definido un
operador de conversión, y entre un tipo y un tipo hijo suyo del que un objeto del
primero almacenase una referencia del segundo (downcasting) Obviamente, lo
último sólo puede comprobarlo en tiempo de ejecución el CLR y no el
compilador, por lo que en realidad el CLR y el compilador colaboran para
asegurar la corrección 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 análisis
del flujo de control del fuente que no se lea ninguna variable local sin que se le
haya asignado previamente algún 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 producción de desbordamientos en operaciones

aritméticas, informándose de ello con una excepción cuando ocurra. Sin
embargo, para conseguirse un mayor rendimiento en la aritmética estas
comprobaciones no se hacen por defecto al operar con variables sino sólo con
constantes (se pueden detectar en tiempo de compilación)

◘ 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 métodos simultáneamente, y se comprueba que
los métodos a los que apunten tengan parámetros y valor de retorno del tipo
indicado al definirlos.

-3-
Introducción a C#

⊗ Instrucciones seguras: Para evitar errores muy comunes, en C# se han impuesto una
serie de restricciones en el uso de las instrucciones de control más comunes. Por
ejemplo, no es posible utilizar un entero como único operando de una condicional,
evitando de esta manera que una asignación equivocada, por utilizar el operando = en
lugar del ==, genere un error lógico difícil de encontrar. Además todo caso de un switch
ha de terminar en un break o goto que indique cuál es la siguiente acción a realizar, lo
que evita la ejecución accidental de casos y facilita su reordenación.

⊗ Sistema de tipos unificado: A diferencia de C++, en C# todos los tipos de datos que se
definan siempre derivarán, aunque sea de manera implícita, de una clase base común
llamada System.Object, por lo que dispondrán de todos los miembros definidos en ésta
clase (es decir, serán “objetos”)

◘ El hecho de que todos los tipos del lenguaje deriven de una clase común facilita
enormemente el diseño de colecciones genéricas que puedan almacenar objetos
de cualquier tipo.

⊗ Extensibilidad de operadores: C# permite redefinir el significado de la mayoría de los

operadores -incluidos los de conversión, tanto para conversiones implícitas como
explícitas- 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 definición de los operadores ++ y -- el compilador puede
deducir automáticamente como ejecutarlos de manera prefijas y postifja; y
definiendo operadores simples (como +), el compilador deduce cómo aplicar su
versión de asignación compuesta (+=) Además, para asegurar la consistencia, el
compilador vigila que los operadores con opuesto siempre se redefinan por
parejas (por ejemplo, si se redefine ==, también hay que redefinir !=).

◘ También se da la posibilidad, a través 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 actúen como colecciones de objetos.

⊗ Eficiente: En principio, en C# todo el código 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 través de punteros. Para ello basta
marcar regiones de código como inseguras (modificador unsafe) y podrán usarse en
ellas punteros de forma similar a cómo 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 migración de programadores, C# no sólo mantiene una

sintaxis muy similar a C, C++ o Java que permite incluir directamente en código
escrito en C# fragmentos de código escrito en estos lenguajes, sino que el CLR también
ofrece, a través de los llamados Platform Invocation Services (PInvoke), la
posibilidad de acceder a código nativo escrito como funciones sueltas no orientadas a
objetos tales como las DLLs de la API Win32.

-4-
 Gómez y Mohedano

3
1.- HERRAMIENTAS

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 (según 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 diseñado 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 evaluación no nos permite crear proyectos. Además, tan sólo
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
código fuente. Está realizado en C# y nos permite la creación de proyectos, pero la última
versión (0.53) da bastantes problemas, así que habrá que esperar a que implementen una
versión más estable.
De todos modos, la herramienta tiene muy buen aspecto. Quien esté interesado puede
visitar su página: http://www.icsharpcode.net/

-5-
Introducción a C#

5
1.- PRIMER PROGRAMA EN C#: ¡Hello World!

Para iniciarse en C#, nada mejor que el típico programa de “¡Hello World!” que lo único que
hace al ejecutarse es mostrar por pantalla el mensaje ¡Hello World!.
El código necesario para ello, define una clase, llamada HelloWorld, que contiene un
método llamado Main(). En su interior introducimos la sentencia
System.Console.WriteLine(“¡Hello World!” ), de tal forma que el programa completo sería el
mostrado en programa1.

Using System;
class HelloWorld
{
static void Main()
{
System.Console.WriteLine(“¡Hello
World!” );
}

Programa1: Aplicación Hello World

Lo que hacemos en esa sentencia es invocar al método 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 método WriteLine es static, no es necesario crear ningún objeto de
ella para poder usarlo. También 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
explícita mediante la cláusula using System que se encuentra al principio del programa. Con
dicho método ( WriteLine() )se consigue que se muestre por la ventana de consola la cadena que
se le pasa como primer parámetro pero sustituyéndole las subcadenas {i} por el valor convertido
en cadena de texto del parámetro que ocupe la posición i+2 en la llamada a WriteLine(). Por
ejemplo, la siguiente instrucción mostraría: Tengo 21 años por pantalla si x valiese 21.

System.Console.WriteLine(“Tengo {0} años”, x);

Es importante resaltar que C# es sensible a las mayúsculas. 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.

-6-
 Gómez y Mohedano

6
1.- COMPILACIÓN

6.1.- Compilación en línea de comandos

Una vez escrito el código anterior con algún editor de textos –como el Bloc de Notas de
Windows- y almacenado en formato de texto en un fichero HelloWorld.cs3, para compilarlo
basta abrir una ventana de consola (MS-DOS en Windows), colocarse en el directorio donde se
encuentre y pasárselo como parámetro 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 añade
una referencia al mismo en el path. Si utiliza otros compiladores de C# puede que varíe la forma
en que se realice la compilación, por lo que lo que aquí se explica en principio sólo podría ser
válido para el compilador de Microsoft para Windows.

Tras la compilación se obtendría un ejecutable llamado HelloWorld.exe cuya ejecución

produciría la salida por la ventana de consola que se muestra en la Ilustración 1.

¡ Hello World !

Ilustración 1: Captura de pantalla de la salida del programa1.

6.2.- Compilación con Visual Studio.NET

Para compilar una aplicación en Visual Studio.NET primero hay que incluirla dentro de algún
proyecto. Para ello basta pulsar el botón Nuevo Proyecto en la página de inicio que se muestra
nada más arrancar dicha herramienta, tras lo que se obtendrá una pantalla con el aspecto
mostrado en la Ilustración 2.

Ilustración 2: Ventana de creación de nuevo proyecto en Visual Studio.NET

3
El nombre que se dé al fichero puede ser cualquiera, aunque se recomienda darle la extensión .cs ya que es la
utilizada por convenio.

-7-
Introducción a C#

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 opción 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
Aplicación de consola.
Por último, en el recuadro de texto Nombre se ha de escribir el nombre a dar al proyecto y
en Ubicación el del directorio base asociado al mismo. Debajo de Ubicación hay un mensaje
que informa sobre cual será el directorio donde finalmente se almacenarán 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 botón OK Visual Studio creará toda la
infraestructura adecuada para empezar a trabajar cómodamente en el proyecto. Esta
infraestructura consistirá en la generación de un fuente que servirá de plantilla para la
realización de proyectos del tipo elegido (en este caso, aplicaciones de consola en C#):
A partir de esta plantilla, escribir el código de la aplicación del programa1 es tan sencillo
con simplemente teclear System.Console.WriteLine(“¡Hello World!”) dentro de la definición
del método Main() creada por Visual Studio.NET. Claro está, otra posibilidad es borrar toda la
plantilla y sustituirla por el código para HelloWorld mostrado anteriormente.
Sea haga como se haga, para compilar y ejecutar tras ello la aplicación sólo hay que pulsar
CTRL+F5 o seleccionar Depurar Æ Iniciar sin depurar en el menú principal de Visual
Studio.NET. Para sólo 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 podría observar en la Ilustración 3.

¡ Hello World !

Ilustración 3: Captura de pantalla de la salida del programa1.

-8-
 Gómez y Mohedano

6
16- PLATAFORMA “MONO”

6.1. - Proyecto Mono

La creación 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 ejecución 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 mayoría 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 día Mono funciona de manera bastante estable, y la librería
de clases se ha extendido y ya incluye varios componentes, como Gtk# (recubrimiento a las
librerías de GNOME, para poder hacer aplicaciones gráficas con Mono), Mono.Data (acceso a
bases de datos), etc.

6.2. - Compilación con Mono

La compilación es bastante sencilla:
./mcs HelloWorld.cs
Entonces nos aparece en pantalla: "Compilation succeeded". El archivo generado por esta
acción da como resultado al archivo: " HelloWorld.exe" este archivo desde el inicio es marcado
como ejecutable para todos los usuarios. En este caso la extensión *.exe no se refiere a que sea
un ejecutable de DOS/Windows sino que hace referencia a código IL (Lenguaje Intermedio), que
viene a ser como el bytecode de Java.
Podemos poner ficheros de ejecución 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 hubiéramos ejecutado lo que nos generó la compilación ./HelloWorld.exe hubiéramos
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 “. También podríamos hacer uso del archivo " HelloWorld " creado en
el paso anterior.

-9-
Introducción a C#

7
16- CLASES EN C#

7.1.- Conceptos de clase y objeto

C# es un lenguaje orientado a objetos puro, sólo se trabaja con objetos. Un objeto es un
conjunto de datos y de métodos que permiten manipular dichos datos, y un programa en C# no
es más que un conjunto de objetos que se relacionan unos con otros a través de sus métodos.
Una clase es la definición de las características concretas de un determinado tipo de
objetos. Es decir, de cuáles son los datos y los métodos 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
características del mismo4.

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 definición. Estos modificadores pueden también aplicarse a los miembros
de la clase: métodos, 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 públicos de una clase son accesibles, al
crear un objeto, desde fuera de la propia clase.
⊗ protected – este modificador sólo 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 más reducido. Una clase privada sólo 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, sólo 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 combinación 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
También hay otras formas de definir las características de un tipo de objetos, como son las estructuras
y las enumeraciones.

- 10 -
 Gómez y Mohedano

7.3.- Sintaxis de definición de clases

class <Clase_1>
La sintaxis básica para definir una clase es la siguiente: {
<
miembros >
}

De este modo se definiría una clase de nombre < Clase_1 > cuyos miembros son los
definidos en < miembros > Los miembros de una clase son los datos y métodos de los que van a
disponer todos los objetos de dicha clase. Para declarar una clase sin ningún miembro,
utilizaríamos una sentencia como esta: class A { }
Una clase así declarada no dispondrá de ningún miembro excepto los implícitamente
definidos de manera común 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:

⊗ Campos: Un campo es un dato común a todos los objetos de una determinada

clase. Para definir cuáles son los campos de los que una clase dispone se usa la
siguiente sintaxis dentro de la zona señalada como <miembros> en la definición de
la misma:
<tipoCampo> <nombreCampo>;
Los campos de un objeto son a su vez objetos, y en <tipoCampo> se indica cuál
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 continuación se muestra un ejemplo (código1) de definición de una
clase de nombre Persona que dispone de tres campos:

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
}

Código 1: Definición de clase sin métodos

Todos los objetos de la clase Persona incorporarán campos que almacenarán

cuál es el nombre de la persona que cada objeto representa, cuál es su edad y cuál es
su NIF. El tipo int incluido en la definición del campo Edad es un tipo predefinido
en la BCL cuyos objetos son capaces de almacenar números 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 haría:
p.Edad = 20;
En realidad lo marcado como <objeto> no tiene porqué ser necesariamente el
nombre de algún objeto, sino que puede ser cualquier expresión que produzca como
resultado una referencia no nula a un objeto.

- 11 -
Introducción a C#

⊗ Métodos: Un método es un conjunto de instrucciones a las que se les asocia un

nombre de modo que si se desea ejecutarlas basta referenciarlas a través 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 método está definido.

Para definir un método <tipoDevuelto> <nombreMétodo> (<parametros>)

{
en C# se utilizaría un <instrucciones>
código como el siguiente: }

Todo método 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 ejecución
de sus instrucciones con alguna instrucción return <objeto>; que indique qué
objeto ha de devolverse.
Opcionalmente todo método puede recibir en cada llamada una lista de objetos
a los que podrá acceder durante la ejecución de sus instrucciones. Aunque los
objetos que puede recibir el método pueden ser diferentes cada vez que se solicite
su ejecución, siempre han de ser de los mismos tipos y han de seguir el orden
establecido en <parametros>.
Un ejemplo de cómo declarar un método de nombre Cumpleaños es la siguiente
modificación (código2) de la definición de la clase Persona usada antes como
ejemplo:
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 Cumpleaños() // Incrementa en uno de la edad del objeto Persona

{
Edad++;
}
}

Código2: Definición de clase con métodos

La sintaxis usada para llamar a los métodos de un objeto es la misma que la

usada para llamar a sus campos, salvo que ahora tambien se incluyen los parámetros
utilizados en caso de haberlos.
<objeto>.<método>(<parámetros>)
En C# existe la sobrecarga de métodos, es decir, en una misma clase pueden
definirse varios métodos con el mismo nombre siempre y cuando tomen diferente
número o tipo de parámetros. Sin embargo, no se pueden definir varios métodos
que sólo se diferencien en su valor de retorno, ya que como éste no se tiene porqué
indicar al llamarlos no podría diferenciarse a qué método 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 accedería como cualquier objeto definido
por el programador. Por ejemplo: string s = 12.ToString();
Este código almacena el literal de cadena “12” en la variable “s”. 12 es un
objeto de tipo int y posee un método común a todos los int´s llamado ToString()
que lo que hace es devolver una cadena cuyos caracteres son los dígitos 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 código anterior.

- 12 -
 Gómez y Mohedano

8
16- CREACIÓN DE OBJETOS EN C#

8.1.- Operador “new”

El operador new es el encargado de crear objetos en C#. Su utilización 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 creación al constructor del mismo apropiado según los valores que se le pasen en
<parametros>, devolviendo una referencia al objeto recién 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 código suele usarse precisamente para
construir el objeto, es decir, para inicializar sus miembros. Por ejemplo, a la clase de ejemplo
Persona le podríamos añadir un constructor dejándola como se ve en el código3.
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 Cumpleaños() // Incrementa en uno la edad del objeto Persona

{
Edad++;
}

Persona (string nombre, int edad, string nif) // Constructor

{
Nombre = nombre;
Edad = edad;
NIF = nif;
}
Código 3: Definición de clase con constructor

El constructor toma como parámetros 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 años de edad y NIF
12344321-A , así: new Persona(“José”, 22, “12344321-A”)
Al igual que en C++, un objeto puede tener múltiples constructores, aunque para
diferenciar a unos de otros es obligatorio que se diferencien en el número u orden de los
parámetros 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 más normal es almacenar la dirección devuelta por new en una
variable del tipo apropiado para el objeto creado. El siguiente ejemplo muestra cómo crear una
variable de tipo Persona llamada p y cómo almacenar en ella la dirección del objeto que
devolvería la anterior sentencia usando el operador new:

Persona p; // Se crea la variable p

p = new Persona(“Jose”, 22, “12344321-A”);// Se guarda en p el objeto

La variable “p” contendrá una referencia a un objeto de clase Persona que representará a
una persona llamada José de 22 años y NIF 12344321-A.

- 13 -
Introducción a C#

8.2.- Constructor por defecto

No es obligatorio definir un constructor para cada clase, y en <nombreTipo>()

caso de que no se defina ninguno, el compilador creará uno sin {
parámetros ni instrucciones. Es decir, como si se hubiese }
definido de esta forma:

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

Coche c = new Coche(); // Crea coche c llamando al constructor

El constructor por defecto es sólo incluido por el compilador si no hemos definido ningún
otro constructor. Si existe una clase en la que se haya definido algún constructor con parámetros
pero ninguno sin parámetros no será válido crear objetos de la misma llamando al constructor
sin parámetros, pues el compilador no lo habrá definido automáticamente. Por ejemplo, con la
última versión de la clase de ejemplo Persona no es correcto hacer:

Persona p = new Persona(); // ERROR: El único constructor de

8.3.- Referencia al objeto actual con “this”

Dentro del código de cualquier método de un objeto siempre es posible hacer referencia al
propio objeto usando la palabra reservada this. Así, los nombres de los campos podrán coincidir
con el de los parámetros. Por ejemplo en el código4, el constructor de la clase Persona escrito
anteriormente se puede rescribir así usando this.

Persona (string Nombre, int Edad, string NIF)

{
this.Nombre = Nombre;
this.Edad = Edad;
this.NIF = NIF;
}

Código 4: Uso de “this”.

El el código4 puede que no resulte muy interesante debido a que para evitar tener que
usar this podría haberse escrito el constructor tal y como se mostró en la primera versión del
mismo: dando nombres que empiecen en minúscula a los parámetros y nombres que empiecen
con mayúsculas a los campos.
Sin embargo, this es mas útil en C# a la hora de realizar llamadas a un método de un
objeto desde código ubicado en métodos del mismo objeto. En C# siempre es necesario que en
toda llamada a método de un objeto se utilice el operador ”.” <<Objeto.Metodo>>. Si el
método 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 métodos que puedan devolver
como objeto el propio objeto sobre el que el método es aplicado. Para ello se utilizaría una
sentencia la sentencia return this;

- 14 -
 Gómez y Mohedano

9
1.- HERENCIA Y MÉTODOS VIRTUALES EN C#

9.1.- Concepto de herencia

El mecanismo de herencia es uno de los pilares fundamentales en los que se basa la
programación 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 definición de una clase
indicamos que ésta hereda de otra, entonces la primera -clase hija- será tratada por el
compilador automáticamente como si su definición incluyese la definición de la segunda – clase
padre o clase base. Mediante el mecanismo de herencia se contribuye a la reutilización del
código, algo habitual en todos los lenguajes orientados a objetos. La novedad, en C#, es que
dicho código 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 implementación inexistente en COM.
class <nombreHija>:<nombrePadre>
En C# todas las clases derivan por defecto de {
object. Si se desea otra clase distinta se usaría una <miembrosHija>
}
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 código5.

class Trabajador:Persona
{
public int Sueldo;
public Trabajador(string nombre, int edad, string nif, int sueldo)
: base(nombre, edad, nif)
{
Sueldo = sueldo;
}
}

Código 5: Ejemplo de Herencia.

Los objetos de esta clase Trabajador contarán con los mismos miembros que los objetos
Persona y además incorporarán 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
método de una estructura de la forma: : base(<parametrosBase>)
A esta estructura se la conoce como inicializador base y se utiliza para indicar cómo se
desea inicializar los campos heredados de la clase padre. No es más que una llamada al
constructor de la misma con los parámetros adecuados, y si no se incluye, el compilador
consideraría por defecto que vale :base(), lo que sería incorrecto en este ejemplo debido a que
Persona carece de constructor sin parámetros.

- 15 -
 Introducción a C#

Un ejemplo que pone de manifiesto cómo funciona la herencia es el programa2.

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 Cumpleaños() // 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 cuánto 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.

9.2.- Métodos Virtuales

En C# es posible cambiar la definición de un método heredado de una clase padre.
Para ello hay que preceder con la palabra reservada virtual la definición de dicho método
en la clase progenitora. A este tipo de métodos se les llama métodos virtuales. Para definirlos
se usa la siguiente
virtual <tipoDevuelto> <nombreMétodo>(<parámetros>)
sintaxis: {
<código>
}

Si en alguna clase hija se quiere redefinir el método, se rescribiría el código pero

sustituyendo en su definición la palabra reservada virtual por override:

override <tipoDevuelto> <nombreMétodo>(<parámetros>)

{
<nuevoCódigo>
}

- 16 -
 Gómez y Mohedano

El lenguaje C# impone la restricción de que toda redefinición de método que se quiera

realizar incorpore la partícula override para forzar a que el programador esté seguro de que
verdaderamente lo que quiere hacer es cambiar el significado de un método heredado. Así se
evita que sin querer se defina un método del que ya exista una definición en una clase padre.
Además, C# no permite definir un método como override y virtual
Por otro lado, cuando se defina un método 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
definición del mismo exista un método virtual con el mismo nombre que el redefinido.
A continuación se muestra un ejemplo (programa3) en el que se redefine el método
Cumpleaños() :

using System;

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

public virtual void Cumpleaños() // 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 cuánto 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 Cumpleaños()

{
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.Cumpleaños();
p.Cumpleaños();
}
}

Programa 3: Uso de métodos virtuales.

- 17 -
Introducción a C#

Se ha añadido el modificador virtual en la definición de Cumpleaños() en la clase Persona

para habilitar la posibilidad de que dicho método puede ser redefinido en clases hijas de
Persona. También se ha añadido override en la redefinición del mismo dentro de la clase
Trabajador para indicar que la nueva definición del método es una redefinición del heredado de
la clase. La salida de este programa confirma que la implementación de Cumpleaños() es
distinta en cada clase, como se ve en
la ilustración 2. Incrementada edad de trabajador
Incrementada edad de persona

Ilustración 4: Captura de pantalla de la salida del programa3.

También es importante señalar que para que la redefinición sea válida ha sido necesario
añadir la operador de control de acceso public en el método original, pues si no se incluyese se
consideraría que el método sólo es accesible desde dentro de la clase donde se ha definido, lo
que no tiene sentido en métodos virtuales ya que entonces nunca podría ser redefinido.

9.3.- Clases abstractas public abstract class A

{
public abstract void F();
Una clase abstracta es aquella que }
forzosamente se ha de derivar si se desea abstract public class B: A
que se puedan crear objetos de la misma o {
public void G() {}
acceder a sus miembros estáticos Para
}
definir una clase abstracta se antepone class C: B
abstract a su definición, como se muestra {
en el código 6. public override void F()
{}
}

Código 6: Ejemplo de clases abstractas

Las clases A y B del código6 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 métodos para los que no se dé
directamente una implementación sino que sean sus clases hijas quienes lo hagan. No es
obligatorio que las clases abstractas contengan métodos de este tipo, pero sí lo es marcar como
abstracta a toda la que tenga alguno. Estos métodos se definen precediendo su definición del
modificador abstract y sustituyendo su código por un punto y coma (;), como se muestra en el
método F() de la clase A del código 6.
Obviamente, como un método abstracto no tiene código no es posible llamarlo.
Todo método definido como abstracto es implícitamente virtual, pues si no sería imposible
redefinirlo para darle una implementación en las clases hijas de la clase abstracta donde esté
definido. Por ello es necesario incluir el modificador override a la hora de darle
implementación. No es posible marcar un objeto como abstract y virtual a la vez, ya que
produce un error de compilación.
En cambio, sí es posible marcar un método como abstract y override a la vez, lo que
convertiría al método en abstracto para sus clases hijas y forzaría a que éstas lo tuviesen que
reimplementar si no se quisiese que fuesen clases abstractas.

- 18 -
 Gómez y Mohedano

10
1.- POLIMORFISMO EN C#

10.1.- Concepto de polimorfismo

El polimorfismo es otro de los pilares fundamentales de la programación 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 sólo poderse acceder a través de dicha variable a los
miembros comunes a ambos tipos. Sin embargo, las versiones de los métodos virtuales a las que
se llamaría a través de esas variables no serían las definidas como miembros del tipo de dichas
variables, sino las definidas en el verdadero tipo de los objetos que almacenan.
A continuación se muestra un ejemplo (programa4) de cómo 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 versión del método Cumpleaños() a la
que se podría llamar a través de la variable de tipo Persona sería la definida en la clase
Trabajador, y no la definida en Persona:

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 Cumpleaños() // 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 cuánto 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 Cumpleaños()

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

public static void Main()

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

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

Programa 4: Uso del Polimorfismo.

- 19 -
Introducción a C#

El mensaje mostrado por pantalla al ejecutar este método confirma lo antes dicho respecto
a que la versión de Cumpleaños() a la que
Incrementada edad de trabajador
se llama, como se puede comprobar en la
ilustración 3.

Ilustración 5: Captura de pantalla de la salida del programa4.

- 20 -
 Gómez y Mohedano

11
1.- CONCLUSIÓN Y BIBLIOGRAFÍA

Conclusión
C# es un lenguaje de programación moderno e innovador que incorpora cuidadosamente
características encontradas en los lenguajes industriales y de investigación más habituales.
Manteniendo la filosofía de diseño de C#, Microsoft ha introducido varias características nuevas
potenciales al lenguaje C# con el fin de aumentar la productividad del desarrollador con
construcciones de lenguaje.

Desde su introducción en febrero de 2001, numerosos desarrolladores han comenzado a

crear software utilizando el lenguaje de programación 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 creación de software comercial de alta calidad.

Actualmente Microsoft Corporation se encuentra desarrollando la segunda versión más

importante del lenguaje de programación C#, que incorporara cuatro nuevas características
fundamentales: componentes genéricos, iteradores, métodos anónimos y tipos parciales.

Información 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 página hay tanto manuales y tutoriales de
C#, como pequeños trucos que se utilizan a la hora de programar.
◘ http://usuarios.lycos.es/somm2000/index.html -Esta página tiene una sección
muy curiosa sobre C#, en la que se tratan temas de actualidad.
◘ Francisco Charte Ojeda: “Programación con Visual C# .NET”, Ed. ANAYA
◘ Tom Archer,” A FONDO C#”, Ed. McGraw-Hill

⊗ Sobre el proyecto MONO

◘ http://www.go-mono.com/ - Información general sobre el proyecto mono.

◘ http://www.monohispano.org/ -Comunidad española que se dedica a temas
relacionados con el proyecto mono.

⊗ Otros enlaces interesantes:

◘ http://ww.programacion.net.- Página con multitud de ejemplos de código.

◘ http://www.microsoft.com/spanish/msdn/articulos/archivo/050503/voices/v
bconC.asp -Pagina de la ayuda MSDN que ofrece Microsoft al programador.

- 21 -