Curso de C# El lenguaje C ha evolucionado de nuevo: programar en el lenguaje de moda no es tan difícil. Empezamos una serie de artículos sobre C#, lenguaje de evidente actualidad tanto por su popularidad (estamos hablando de C) como por tratarse de un lenguaje ".Net Compatible". Vamos a empezar una serie de artículos sobre C# (pronunciado "C sharp") para daros a conocer, estimados lectores, este lenguaje de programación que seguro habéis oído nombrar y que, de un tiempo a esta parte, se ha puesto de moda debido, entre otras muchas cosas, a las soluciones que el software libre está desarrollando para él. Como todos sabemos, el lenguaje C es uno de los más populares entre los programadores de cualquier sistema operativo. Si a esto le añadimos que Microsoft ha "promocionado" la plataforma.net y que Linux también dispone de esa tecnología gracias al proyecto Mono, nos encontramos ante una solución para desarrollo de programas de alta portabilidad y probada potencia. Para los que empezáis a programar, os puedo decir que aprender C# es más sencillo que aprender C++. Ciertamente C++ nos puede ofrecer en muchos casos más potencia, pero también nos deja una libertad para hacer cosas que no deberíamos hacer, y que con seguridad las haremos sin darnos cuenta. C# se denomina lenguaje de tipado-seguro, es decir, que el propio lenguaje nos asegura que una variable que definamos de un tipo determinado (por ejemplo un entero) siempre contendrá un valor de ese tipo, no dejándonos compilar el código en cuanto se detecte una situación de este tipo. C++ simplemente nos dejará compilar y provocará un error en ejecución. Este pretende ser un curso "original". Me explico: Seguro que hay muchos cursos y tutoriales sobre este lenguaje, pero nosotros lo vamos a desarrollar desde el punto de vista del lector. Sí, desde vuestro punto de vista. Y por qué?. Pues porque todos hemos sido alguna vez aprendices de un lenguaje de programación y todos hemos deseado que nos explicaran con detalle esas cosas que muchos pasan por alto y que, muchas veces, suponen parte de la base del lenguaje que estamos aprendiendo. Veremos ejemplos y los revisaremos de cabo a rabo para que entendamos perfectamente el sentido de cada instrucción, bloque de código, etc... De esta forma, iremos aprendiendo conceptos a medida que vayamos necesitándolos para comprender lo que estemos explicando. Claro que en algún momento tendremos que explicar bastante teoría, pero la aderezaremos con ejemplos para que todos podáis experimentar en el ordenador. Espero que os guste. Primero un poco de historia y un poco de teoría El origen de C# está en Microsoft y las malas lenguas (también llamadas leyendas ) dicen que los desarrolladores de.net Framework lo diseñaron a partir de sus conocimientos de C++ y de J++. Es más: se dice que quisieron llamarlo C++++ y que, al reorganizar los +, les salió # ;-) Fuera de habladurías, uno de los padres de C# fue Anders Hejlsberg, que tiene en su currículum a nuestro amado Turbo Pascal, a Delphi y a Visual J++ (ya en Microsoft). Podéis ver una entrevista con él y traducida al castellano en http://www.elavefenix.net/panorama/a069mpm3.htm y su entrada en la wikipedia en http://en.wikipedia.org/wiki/anders_hejlsberg Lo cierto es que de C se tomó su sintaxis, sus operadores... y de C++ los objetos aunque muy mejorados. Con Java observamos también similitudes, empezando por la independencia de la plataforma ya que ambos se basan en código intermedio: Java traduce el código fuente a código de bytes que es el que será interpretado por la máquina virtual Java, C# traduce el código fuente a IL (Intermediate Language). Las demás similitudes son evidentes ya que tanto la sintaxis y la filosofía de Java derivaron de C++ aunque Java tenga su propia personalidad. Vale, pero... qué es eso de.net Framework?. Pues se trata de una plataforma software diseñada para obsequiar a los programadores con un entorno compatible con el desarrollo de aplicaciones en distintos lenguajes y que puedan interoperar entre sí, ofreciendo además seguridad. Algo fundamental de.net Framework es que no está ligado a Windows como cabría esperar de un producto desarrollado por Microsoft, obteniéndose así la portabilidad. Actualmente disponemos de la implementación para Windows que, evidentemente, fue la primera, y de la solución para Linux (también funciona bajo Windows) llamada proyecto Mono (http://www.go-mono.com).
Todos los lenguajes que deban "correr" en.net deben cumplir la Common Language Specification (Especificación de Lenguaje Común) y en eso Microsoft ha sido bastante transparente.es por ello que ya existen bastantes lenguajes acomodados al CLS. Por ejemplo podemos usar Python para.net (http://www.zope.org/members/brian/pythonnet/index_html), Perl (http://www.activestate.com/products/perl_dev_kit/) y los ya indicados C++ en su versión "administrada" (ahora veremos lo que significa este término) y Visual Basic.Net. Con C# (como todos los lenguajes que cumplen la CLS) nos encontramos ante un lenguaje administrado y para entender cómo se ejecuta el código administrado tenemos que hablar del Common Language Runtime (CLR) y de la biblioteca de clases de.net Framework. El CLR es el que administra la ejecución del programa. Una vez hemos convertido el código fuente a Intermediate Language (de ahora en adelante IL) mediante un compilador, el CLR lo transforma a código nativo ejecutable de la plataforma en la que estemos. Esto se hace, a medida que se va necesitando, con un compilador JIT (just-in-time), por lo que el programa se ejecuta en código nativo y no interpretado como algunos creen equivocadamente. Es así como se consigue la portabilidad ya que podemos ejecutar un programa compilado previamente a IL en cualquier plataforma que implemente el CLR. Además controla el manejo de la memoria mediante un recolector de basura (Garbage Collector), es decir, podemos crear un objeto y olvidarnos de liberar la memoria que ocupa, ya que el recolector de basura lo hará por nosotros (también podremos, faltaría más, forzar - y lo haremos - una llamada al Garbage Collector para que empiece a trabajar cuando nosotros queramos). El CLR también maneja los hilos de ejecución y garantiza la "seguridad" del código. Y entendemos "seguridad" como la imposibilidad del código para hacer cosas "no permitidas" o "no recomendables". Por ejemplo, los punteros ya no se utilizan en C# (realmente podemos usarlos pero no es recomendable, aunque veremos cómo hacerlo) ya que es el propio lenguaje el que los manejará internamente mientras nosotros trabajamos con variables. La interoperabilidad entre lenguajes se logra mediante los denominados metadatos. Los metadatos se generan al compilar el código fuente a IL y están en el mismo archivo. Informan sobre los datos usados por el programa y forman parte de lo que se llama el "ensamblado". Figura: Ensamblado Como se ve en la figura, contiene toda la información sobre la versión e implantación de un programa. Incluyen cuatro apartados: La primera es el manifiesto. En él se incluye la versión, el nombre y datos de interés en aras de una buena documentación. La segunda son los metadatos que contienen la información sobre los tipos de datos usados y que ayudarán a conseguir la interacción con otros lenguajes. La tercera parte es el código IL en sí mismo y la cuarta son los recursos usados por el programa.
Tranquilos. El ensamblado se genera automáticamente al compilar ya que el exe que generamos (veremos también que la extensión exe se mantiene por "tradición") es, por sí mismo, un ensamblado que contiene el código IL. La biblioteca de clases: la columna vertebral La biblioteca de clases es la que nos va a proporcionar una inmensa variedad de objetos con sus respectivos métodos que nos van a permitir realizar innumerables tareas gracias a todas las funcionalidades que implementan. Podríamos definir oficiosamente una clase como una plantilla para crear objetos. Es donde se definen las características del objeto describiendo los datos y métodos que lo componen. Un objeto es, sencillamente, la instancia de una clase. Otros lo definen como un compendio de datos y métodos con los cuales podremos manipular esos datos, sus propios datos. A mí me gusta definirlos como una parte encapsulada de lógica y datos, que representa una entidad. Y, finalmente, podemos considerar que un programa en C# es un conjunto de objetos que se relacionan entre sí mediante sus métodos. Los métodos son como las funciones que conocemos de cualquier lenguaje de programación, pero éstos pueden acceder totalmente a los campos definidos dentro de la clase a la que pertenece el método y tienen características de visibilidad. Los métodos constructor y destructor son los básicos para instanciar un objeto y destruir la citada instancia. Los campos almacenan datos (estados) de los objetos y son variables declaradas dentro de la clase. Estos campos tienen características de visibilidad (public, private, internal, etc...) y, normalmente, no deberían ser públicos. Dentro de una clase podemos definir propiedades y métodos estáticos, obteniendo así lo más parecido a las funciones tradicionales, ya que no hace falta crear ningún objeto para utilizarlas. Volveremos a hablar de los campos y métodos en profundidad cuando veamos "de cerca" los objetos. Como hemos dicho al principio, C# es un lenguaje orientado a objetos. No sólo eso. Todo el código que escribamos en C# se trata de un objeto, ya que la función Main() de todo programa C# debe estar dentro de una clase. Para los nuevos en C, decir que la función Main() es la que define el punto de entrada a un programa y es la que se ejecuta cuando llamamos al ejecutable. Así pues, un programa en C# debe tener al menos una función dentro de la clase principal y además debe llamarse Main(). Es importante recalcar que la M es mayúscula. Y es importante porque en C y C++ la función se define como main(). El compilador de C# nos informará de un error al no haber definido ningún punto de entrada si nos olvidamos de este detalle (esto además nos indica que estamos ante un lenguaje case-sensitive, es decir, no es lo mismo main() que Main() simplemente por la letra mayúscula). Mezclamos la teoría con un poquito de práctica. Fieles a la promesa inicial, vamos a introducirnos en las clases escribiendo y explicando nuestra primera clase y la sintaxis necesaria para poder crear nuestro primer programa. Vale, escribamos esto para empezar: class Miprograma static void Main() // aquí irían las instrucciones La palabra clave class define la clase "Miprograma" que es el nombre que le hemos dado. Luego abrimos una llave para indicar que comienza el código de la clase. Definimos después la función Main() como estática. Qué quiere decir esto?. Resulta que una función debe estar definida dentro de una clase, pero no se puede crear un objeto de la clase hasta que no se defina una función en la que se declare el objeto, el resultado es que tenemos un problema. Este problema lo resolvemos declarando la función como static. De este modo la podremos llamar antes de declarar una instancia de la clase, y eso es exactamente lo que haremos al ejecutar el programa dentro de unos párrafos. Seguidamente indicamos que la función no devuelve ningún valor mediante void. Si queremos devolver otro valor, especificaremos el tipo a devolver (por ejemplo un entero - int -) y tendremos que especificar explícitamente una sentencia return (valor_entero). class Miprograma static int Main() // aquí irían las instrucciones // y finalmente devolvemos un entero return (0); Finalmente cerramos la llave de la función Main y la llave de la clase "Miprograma". Simplemente se trata de bloques que empiezan y terminan con las llaves. Los familiarizados con otros lenguajes de programación les sonará esto a los clásicos BEGIN... END. Todas las sentencias van dentro de bloques y los bloques se pueden anidar unos dentro de otros. Observamos también que la sentencia return termina con un punto y coma. Esto es así para todas las sentencias. También os habréis dado cuenta que hemos colocado unos comentarios. Los comentarios son muy importantes para el que lee el código fuente. Tened en cuenta que nuestro código puede ser leído por mucha gente y no todos tienen por qué entender a la primera lo que hace nuestro código. Así pues es aconsejable documentar adecuadamente los programas. Un comentario de linea se indica mediante dos barras inclinadas // y el resto de la linea será considerado un comentario. Para insertar un bloque
entero de lineas como comentario, lo iniciaremos con /* y lo terminaremos con */ delimitando así las lineas que deseamos marcar como comentario. Llegados a este punto, vamos a escribir nuestro primer programa. Y, como no, se tratará del archi-conocido y mundialmente famoso "Hola mundo". Ah no! que hemos dicho que seríamos originales. Bien pues será un "Hola amigos Wadalbertitas". class Hola static void Main() System.Console.WriteLine(" Hola amigos Wadalbertitas."); Bien, como ya sabemos, hemos definido primero la clase "Hola" y hemos creado la función Main() para que el programa se pueda ejecutar al ser llamado. Y ahora viene lo nuevo. Vemos una sentencia que, intuimos, escribe el mensaje por pantalla, pero qué es eso de System y de Console? y los puntos?. Pues estamos ante las clases de la biblioteca de clases de C#. Dada la gran cantidad de clases existentes en la librería, éstas se agrupan en los llamados "espacios de nombres" (namespaces) que, para que nos entendamos, podemos considerarlos como carpetas donde colocamos clases relacionadas entre sí. También veremos más adelante cómo crearnos un espacio de nombres propio donde introducir nuestras propias clases. Realmente, todos los programas están dentro de un espacio de nombres. Si nosotros no hemos usado ningún namespace es porque, si no especificamos nada, se utiliza el espacio de nombres por defecto. Para los ejemplos iniciales de este curso, no utilizaremos ningún espacio de nombres propio, pero que quede claro que siempre se necesita uno para definir una clase, y nuestro primer programa es una clase al fin y al cabo. En el caso de que trabajemos con el entorno de desarrollo de Windows (Visual Studio.Net) nos daremos cuenta que el propio entorno define el espacio de nombres donde vamos a escribir nuestra clase principal. Volviendo al ejemplo, vemos cómo estamos accediendo al método Writeline de la clase Console del espacio de nombres System. Es decir: estamos escribiendo en la consola nuestra original frase de " Hola lectores de la revista @.". La notación namespace.clase.método será habitual durante el curso, aunque lo normal es que usemos simplemente clase.método ya que existe un método para ahorrarnos tener que escribir cada vez el espacio de nombres y es utilizando la clausula using. /* Especificamos que vamos a usar el espacio de nombres System. Las clases serán buscadas dentro de él */ using System; class Hola static void Main() Console.WriteLine(" Hola amigos Wadalbertitas."); De esta forma le estamos indicando al compilador que las clases que vamos a utilizar están dentro del espacio de nombres System. Este espacio de nombres es el más importante de.net Framework. En él se agrupan las clases y demás objetos, que ya iremos viendo, que se utilizan más a menudo y las que se consideran como partes fundamentales de la plataforma.net. Como adelanto decir que se incluyen en él clases como Console para el manejo de la consola de comandos, Math que contiene métodos para implementar operaciones matemáticas y todas las clases de excepciones. Dentro de System también tendremos más espacios de nombres, por lo que ya vemos como podemos tener "subcarpetas" dentro de las "carpetas". Era lo lógico, verdad?. Algunos son muy importantes como System.IO para el manejo de la entrada/salida y System.Net para las funciones de red. Y como no podía ser de otra manera, dentro de System se definen las estructuras que nos permiten utilizar los tipos de datos integrados en C# (int, double, decimal,...). Los espacios de nombres permiten además algo muy importante como el que coexistan clases con el mismo nombre. Imaginemos que programamos una clase llamada Facturas que contiene variables/propiedades y funciones/métodos para crear y manejar objetos "Factura" de nuestra aplicación. Cabría la posibilidad de usar otra clase llamada Facturas con distintas características si la tenemos en otro espacio de nombres. Simplemente se trata de anteponer el namespace a la clase para distinguir los objetos de cada una. Por ejemplo: miespacio.facturas fac = new miespacio.facturas(); arrobasoft.facturas fac2 = new arrobasoft.facturas(); Pasamos a la acción: escribimos y compilamos nuestro primer programa Al principio del artículo os he comentado que podemos trabajar con.net Framework tanto en Windows como en Linux. Si eres un afortunado poseedor de una licencia de Visual Studio.Net, bastará con que abras un proyecto nuevo de consola y teclees el código anterior (ver figura 1) para luego darle a la tecla F11 (paso a paso por instrucciones) para que nos de tiempo a ver la salida por pantalla. Si le dais a F5 para ejecutar el programa, lo hará, pero no os dará tiempo a ver nada ya que el código se ejecuta y al terminar se cierra la consola. También podemos compilar el programa desde una consola. Para ello
basta con invocar al compilador csc.exe seguido del nombre del programa: C:\datos\curso_c#\articulo1> csc hola.cs Figura 1 Si os fijáis en el código, os daréis cuenta que hay cosas que no hemos escrito nosotros. Para empezar, vemos que el mismo editor de VS.Net incluye directamente un espacio de nombres llamado en este caso "Articulo1" que es el nombre que le he dado al proyecto. Esto es lo que hemos comentado antes. Todo programa, al ser, al menos, una clase, se almacena dentro de un espacio de nombres. Bien, ya que VS nos lo coloca ahí, no lo vamos a quitar, verdad?. Recordad que si no se especifica (como haremos en el caso de linux) se usará un espacio de nombres "por defecto". También podéis ver "una especie de comentarios" que comienzan con tres barras y no dos. Esto es para incluir información en un archivo XML que generará Visual Studio a modo de documentación. En C# los comentarios XML se inician con tres barras, lo cual provoca que el compilador interprete lo que sigue como texto a incluir en el fichero XML. Estos comentarios sirven para documentar clases, estructuras, miembros de las clases (propiedades, métodos,...) y espacios de nombres (namespaces), pero no se pueden usar para documentar sentencias. Simplemente escribiendo tres barras, VS ya incluirá lo siguiente: /// <sumary> /// /// </sumary> Esto nos sirve, como seguro habréis adivinado, para escribir un sumario descriptivo de la clase, método, etc... Vuelvo a insistir que la documentación es muy importante y si C# nos proporciona un método para generar la documentación sobre los tipos de datos, de forma automática, mejor que mejor. Además, ya que esta documentación se genera a partir de los comentarios incluidos en el código fuente, estamos evitando tener que mantener esta documentación actualizada cada vez que cambiemos algo en el código. No os parece una gran ventaja para el programador?. De momento nos quedamos aquí respecto a la generación de la documentación en XML, pero sin duda dedicaremos su merecido espacio en próximas entregas. En caso de que estés trabajando con linux o no dispongas de una licencia de Visual Studio.Net, no te preocupes. Abrimos un navegador y nos dirigimos a la dirección http://www.mono-project.com/downloads desde donde podemos bajarnos los fuentes del proyecto mono para compilártelos tú mismo en tu distribución preferida (en Debian te los tendrás que compilar, pero no hay problema. Seguro que si sigues y has seguido el curso de linux lo tienes más que claro. Y, bueno, siempre puedes pedir ayuda en el foro), los paquetes rpm para Red Hat/Fedora y SuSE, ó el binario para Windows. También hay un binario genérico para Linux ;-). Como veis hay donde elegir. Un apunte más antes de continuar: si vuestra distribución es SuSE 9.1 o superior, podéis instalar mono desde los cd's/dvd's de la distribución, ya que viene incluido "de serie". También lo podéis encontrar en otras distros tipo Live-Cd, pero bueno... la primera en incorporarlo fue SuSE.
Para escribir el código nos sirve cualquier editor. Aquí no voy a entrar ya que me consta que cada uno tiene sus gustos. Eso sí, yo en linux uso el entorno de desarrollo Anjuta que me parece de lo más apropiado (últimamente también uso kate y nano). Para Windows también hay programas "free" como SharpDevelop (http://www.icsharpcode.net/opensource/sd) del que os podéis bajar tranquilamente, tanto los fuentes como el ejecutable. De todas formas, repito, podemos usar un simple notepad y el compilador que nos instalará Mono. Vamos a ser minimalistas y vamos a trabajar con un editor de textos y una consola para compilarlo. Ya habéis escrito el código?. Bien pues ahora lo grabamos con el nombre hola.cs y sólo queda compilarlo. Para ello, tecleamos en la consola: jorge@presidiario:~/curso_c#/articulo1> mcs hola.cs En mono, el compilador de C# se llama mcs, por lo que la instrucción anterior lo que hace es compilar nuestro primer programa. Si no nos hemos equivocado al teclear el código, obtendremos un escueto pero significativo Compilation succeeded, indicándonos que todo ha ido perfectamente. Ahora es el momento de ejecutarlo, pero antes comentemos unas cosillas. Si nos fijamos (y lo haremos porque somos curiosos) nos daremos cuenta que tenemos un nuevo fichero llamado hola.exe en el directorio actual. Evidentemente, que su extensión sea exe es una mera anécdota. Nos fijamos ahora en sus permisos. En mi caso, el fichero ya tiene el permiso de ejecución (-rwxr-xr-x) por lo que lo ejecutaremos tal y como vemos en la figura siguiente: Si el fichero no tuviera los permisos de ejecución, tenemos dos opciones. La primera pasa por asignarle los permisos necesarios con chmod 755 hola.exe y ejecutarlo de la manera ya mencionada. La segunda consiste en invocar al "ejecutable" precedido del comando mono, tal que así: mono hola.exe y obtendríamos el mismo resultado. Finalizando por este mes. Hemos tomado el primer contacto con este lenguaje. Ese era el objetivo. Nos hemos hecho una idea de en qué se basa, de donde procede, sobre qué base tecnológica descansa y algunas de sus características más interesantes. Hemos escrito nuestro primer programa y lo hemos compilado y ejecutado. Y eso tanto para Windows como para linux, por lo que, espero, os habremos "metido el gusanillo" de este interesante mundo de la programación en C#. En la próxima entrega seguiremos aprendiendo conceptos, veremos los tipos de datos básicos y, por supuesto, escribiremos algún que otro programa en el que apliquemos esos conceptos a la práctica, que es la mejor forma de aprender. Saludos. ANEXO 1 Yorkshire curso.csharp@gmail.com El proyecto mono. La plataforma.net en linux. Mono es un proyecto open source bajo la tutela de Novell (detrás está SuSE, que fué adquirida por Novell hace ya algún tiempo, y Ximian que previamente fué adquirida por SuSE) para crear una implementación libre de.net Framework. Su principal creador/mentor/impulsor ha sido el conocido Miguel de Icaza (podéis ver una entrevista con él en la revista @rroba nº80), que sigue y seguirá luchando por el proyecto a pesar de los movimientos empresariales que siempre "descentran" y ocasionan muchas veces el abandono de trabajos de desarrollo. Mono incluye el compilador de C#, el Common Language Runtime (CLR), la librería de clases y el runtime,... Durante el presente artículo hemos hablado de mono para linux pero, como podéis ver en la web oficial, el proyecto abarca diferentes arquitecturas. El intérprete: Linux/x86, Linux/PPC, S390, StrongARM, SPARC, HPPA, SPARC v9. El JIT: Linux/x86, Solaris/SPARC, PowerPC: MacOS and Linux. S390: Linux. Y Mono sigue evolucionando ya que además de abarcar distintas arquitecturas, ahora, por ejemplo, se sigue trabajando para alcanzar compatibilidad con.net 2.0 paralelamente a la linea "recta" de su desarrollo. ANEXO 2 Buscando documentación La biblioteca de clases es el pilar fundamental sobre el que se basan los lenguajes.net por lo que es de vital importancia conocerla y, sobre todo, tener documentación accesible de todas las clases y métodos que la componen. Microsoft es consciente de ello y consecuentemente dedica un espacio importante a ello en el MSDN. En la siguiente dirección tenéis la
lista completa de espacios de nombres con sus clases y métodos. http://msdn.microsoft.com/library/default.asp?url=/library/en us/cpref/html/cpref_start.asp Además se incluyen algunos ejemplos. Eso sí: tendréis que desempolvar el inglés si os hace falta (cosa bastante recomendable, por otro lado). Como la biblioteca de clases es la misma estemos en el S.O. que estemos, esta documentación será válida también para los usuarios de linux/mono. Ahora bien, el proyecto mono no está terminado, ni mucho menos. A pesar de que podemos decir que Microsoft ha sido bastante "transparente" para facilitar y extender el soporte.net, es claro que van mucho tiempo por delante en el desarrollo (faltaría más!!). Por lo tanto, es necesario que, a la hora de utilizar las clases bajo mono, nos aseguremos que están completamente desarrolladas o, al menos, lo estén los métodos que vayamos a utilizar. Esto lo podemos comprobar en la web del proyecto mono.