Tutorial de C#version 0.5

Tutorial de C#: version 0.5

Un tutorial para aprender C# a nivel inicial utilizando mono (http://mono-project.com).

Copyright (c) 2004 MonoHispano. Se otorga permiso para copiar, distribuir y/o modicar este documento bajo los trminos de la Licencia de Documentacin Libre GNU, versin 1.2 o cualquier versin posterior publicada por la Free Software Foundation. No hay Secciones Invariantes ni Textos de Portada o Contraportada. Puedes consultar una copia de la licencia en http://www.gnu.org/copyleft/fdl.html.

Tabla de contenidos1. Introduccin ...........................................................................................................................................1 1.1. El lenguaje C# .............................................................................................................................1 1.1.1. Introduccin....................................................................................................................1 1.1.2. Programacin basada en componentes...........................................................................1 1.1.3. Orientacin a objetos......................................................................................................2 1.1.4. Librera del lenguaje.......................................................................................................2 1.1.5. Estandarizacin...............................................................................................................2 1.1.6. C# frente a Java ..............................................................................................................2 1.1.7. C# frente a C++ ..............................................................................................................3 1.1.8. Porqu C#?....................................................................................................................3 1.2. Primer ejemplo ............................................................................................................................4 2. Tipos........................................................................................................................................................6 2.1. Tipos............................................................................................................................................6 2.1.1. Importancia de los tipos de datos ...................................................................................6 2.1.2. Tipos en C#.....................................................................................................................6 2.2. Tipos por valor ............................................................................................................................6 2.2.1. Tipos por valor................................................................................................................6 2.2.2. Enteros............................................................................................................................7 2.2.3. Tipos de coma otante....................................................................................................8 2.2.4. El tipo decimal................................................................................................................9 2.2.5. El tipo bool .....................................................................................................................9 2.2.6. Tipo arreglo ..................................................................................................................10 2.2.7. El tipo char ...................................................................................................................12 3. Estructuras de control .........................................................................................................................13 3.1. Estructuras de control................................................................................................................13 3.1.1. Instruccin if.................................................................................................................13 3.1.2. Instruccin switch.........................................................................................................15 3.1.3. Bucle for .......................................................................................................................17 3.1.4. Bucle while...................................................................................................................18 3.1.5. Bucle do-while..............................................................................................................18 3.1.6. Bucle foreach................................................................................................................19 3.2. Cambiando el rumbo .................................................................................................................20 3.2.1. Instruccin goto ............................................................................................................20 3.2.2. Sentencia return ............................................................................................................21 3.2.3. La instruccin continue ................................................................................................21 3.2.4. break para salir de bucles..............................................................................................22 3.2.5. throw y el manejo de excepciones ................................................................................23 4. Operadores ...........................................................................................................................................24 4.1. Operadores ................................................................................................................................24 5. Introduccin a las clases......................................................................................................................27 5.1. Introduccin a las clases en C# .................................................................................................27 5.1.1. Mtodos ........................................................................................................................28 5.1.2. Modicadores public y static........................................................................................29 5.1.3. Constructores e instancias de una clase........................................................................30

iii

5.1.4. Sobrecarga de mtodos.................................................................................................32 5.1.5. La palabra reservada this ..............................................................................................33 6. Variables y parmetros........................................................................................................................35 6.1. Variables y parmetros ..............................................................................................................35 6.1.1. Variables .......................................................................................................................35 6.1.2. Parmetros ....................................................................................................................36 6.1.3. Arreglo de parmetros ..................................................................................................37 7. Propiedades e indizadores...................................................................................................................40 7.1. Propiedades e indizadores .........................................................................................................40 7.1.1. Propiedades...................................................................................................................40 7.1.2. Indexadores...................................................................................................................41 8. Clases ....................................................................................................................................................43 8.1. Modicadores de acceso ...........................................................................................................43 8.2. Herencia ....................................................................................................................................43 8.2.1. La palabra reservada base.............................................................................................44 8.2.2. Clases Abstractas..........................................................................................................45 8.2.3. Miembros virtual ..........................................................................................................45 8.3. Interfaces ...................................................................................................................................46 8.4. Modicadores de Herencia .......................................................................................................46 9. Delegados ..............................................................................................................................................47 9.1. Delegados..................................................................................................................................47 9.1.1. Llamadas a mltiples mtodos .....................................................................................48 10. Eventos................................................................................................................................................51 10.1. Eventos....................................................................................................................................51 11. Programacin multihilo ....................................................................................................................57 11.1. Threads -- Programacin multihilo .........................................................................................57 11.1.1. Controlando el tiempo de vida del hilo ......................................................................59 12. Sobrecarga de operadores.................................................................................................................61 12.1. Sobrecarga de operadores .......................................................................................................61 12.1.1. Qu es la sobrecarga de operadores ? ......................................................................61 12.1.2. Sobrecargando operadores en la practica ...................................................................61 13. TRatamiento de cheros ...................................................................................................................64 13.1. Tratamiento de cheros...........................................................................................................64 13.1.1. La primera clase: System.IO.File ...............................................................................64 13.1.2. Obteniendo informacion sobre archivos: System.IO.FileInfo....................................67 14. Interoperabilidad con cdigo nativo ................................................................................................68 14.1. Uso de Platform Invoke...........................................................................................................68 14.1.1. Que es Platform Invoke ?.........................................................................................68 14.1.2. Usando Platform Invoke .............................................................................................68 14.1.3. Ejemplo de uso ...........................................................................................................68 14.1.4. Conclusiones...............................................................................................................69

iv

15. Introspeccin ......................................................................................................................................70 15.1. Introspeccin: El ojo que todo lo ve .......................................................................................70 15.1.1. Metadatos ...................................................................................................................70 15.1.2. Atributos .....................................................................................................................70 15.1.3. Cdigo gestionado: Integracin..................................................................................71 15.1.4. Reexin.....................................................................................................................71 15.1.5. Ejemplo prctico: rboles de Mono...........................................................................71 16. Creacin y uso de libreras................................................................................................................72 16.1. Compilando para una librera..................................................................................................72 16.2. Usando nuestra libreria ...........................................................................................................72 17. Autores ................................................................................................................................................74 Bibliografa...............................................................................................................................................75

v

Lista de tablas2-1. Tipos por valor......................................................................................................................................7

Tabla de ejemplos9-1. Ejemplo simple de uso de delegados..................................................................................................48 9-2. Ejemplo de uso de delegados .............................................................................................................49

vi

Captulo 1. Introduccin1.1. El lenguaje C#1.1.1. IntroduccinLos primeros rumores de que Microsoft estaba desarrollando un nuevo lenguaje de programacin surgieron en 1998 , haciendo referencia a un lenguaje que entonces llamaban COOL y que decan era muy similar a Java. En junio de 2000, Microsoft despej todas las dudas liberando la especicacin de un nuevo lenguaje llamado C#. A esto le sigui rpidamente la primera versin de prueba del entorno de desarrollo estndar (SDK) .Net, que inclua un compilador de C#. El nuevo lenguaje estaba diseado por Anders Hejlsberg ( creador de Turbo Pascal y arquitecto de Delphi ), Scott Wiltamuth y Peter Golde. Entonces describieron el lenguaje como "...simple, moderno, orientado a objetos, de tipado seguro y con una fuerte herencia de C/C++".

1.1.2. Programacin basada en componentesEn los ltimos 10 aos se han asentado diferentes tcnicas de programacin como lo son la orientacin a objetos, la programacin basada en interfaces o los componentes. A pesar de sto, los lenguajes de programacin siempre han ido un paso por detrs de las mejores prcticas de programacin del momento. Como resultado, los programadores tienden a depender de cdigo especco, usar convenciones, o simplemente a no usar las nuevas tcnicas. Por ejemplo, C++ soporta orientacin a objetos, pero no tiene el concepto formal de interfaces. Entonces los programadores recurren a una mezcla entre clases abstractas bases e interfaces para simular programacin basada en interfaces, mientras que utilizan modelos externos de componentes, como COM y CORBA para obtener los benecios de la programacin orientada a componentes. Aunque Java est un paso adelante de C++ al proporcionar soporte a nivel de lenguaje para interfaces y paquetes (entre otras cosas), tambin tiene poco soporte para construir y mantener a la largo del tiempo completos sistemas basados en componentes (en los que uno necesita desarrollar, desplegar, interconectar y manejar distintas versiones de varias fuentes en un extenso periodo de tiempo). Esto no signica que la comunidad Java no haya construido tales sistemas, simplemente que las necesidades derivadas de la implementacin de tales sistemas se han conseguido a travs de convenciones de notacin y cdigo propio, no a travs de una caracterstica del lenguaje. Por otra parte, el lenguaje C# se ha construido suponiendo que los modernos sistemas de software se construyen usando componentes. Por lo tanto, C# proporciona soporte a nivel de lenguaje para los constructores bsicos de los componentes, como puden ser propiedades, mtodos y eventos. Esto no

1

Captulo 1. Introduccin signica que todo esto no se haya hecho antes, lenguajes como LISP o Smalltak hacan cosas parecidas, pero con un gran coste. C# tiene mecanismos para permitir al mismo tiempo un orientacin a componentes y un gran rendimiento.

1.1.3. Orientacin a objetosAdems del profundo soporte para desarrollo de software basado en componentes, C# es un lenguaje completamente orientado a objetos, que implementa casi todo los conceptos y abstracciones presentes en C++ y Java. Como es de esperar en un lenguaje orientado a objetos, C# implementa conceptos como herencia, encapsulacin, polimorsmo y programacin basada en interfaces. Adems soporta las construcciones tpicas de C++ y Java, como clases, estructuras, interfaces y enumeraciones, as como algunas construcciones nuevas, como los delegados, que son parecidos a los punteros a funciones de C++, o los atributos, lo cual permite aadir metainformacin sobre el cdigo. C# consigue compaginar bien orientacin a objetos y rendimiento. Algunos lenguajes, como Smalltalk, se basan en que "todo es un objetos". Esta aproximacin tiene la ventaja de una completa orientacin a objetos, pero tiene la desventaja de ser muy ineciente. Para mejorar el rendimiento, otros lenguajes, como Java, separan el sistema de tipos en tipos primitivos y todo el resto, dando lugar a mejor rendimiento en los tipos primitivos, pero en una separacin a veces molesta entre tipos primitivos y tipos denidos por el usuario. En C# se han aunado ambas aproximaciones presentando lo que se llama un sistema unicado de tipos, en el que todos los tipos, incluso los primitivos, derivan de un tipo objeto comn, a la vez que permite el uso de optimizaciones para tipos primitivos y tipos sencillos.

1.1.4. Librera del lenguajeContrariamente a la mayora de lenguajes, C# no incluye una librera especca, sino que utiliza la librera de clases de la plataforma .NET para todas sus necesidades, desde utilizacin de la consola hasta la programacin multiproceso o el cifrado de seguridad.

1.1.5. EstandarizacinAdems de los mritos tcnicos, uno de las razones del xito de C# y la plataforma .NET ha sido por el proceso de estandarizacin que Micrsoft ha seguido (y que ha sorprendido a ms de uno). Micrsoft, en lugar de reservarse todos los derechos sobre el lenguaje y la plataforma, ha publicado las especicaciones del lenguaje y de la plataforma, que han sido posteriormente revisadas y raticadas por la Asociacin Europea de Fabricantes de Computadoras (ECMA). Esta especifcacin (que se puede descargar libremente de aqu (http://www.ecma-international.org/publications/standards/Ecma-334.htm)) permite la implementacin del lenguaje C# y de la plataforma .NET por terceros, incluso en entornos distintos de Windows.

2

Captulo 1. Introduccin

1.1.6. C# frente a JavaC# y Java son lenguajes muy similares, de sintaxis basada en C/C++, orientados a objetos y que incluyena las caractersticas ms importantes de los lenguajes modernos, como gestin automtica de memoria y compilacin a cdigo intermedio. Pero por supuesto, tambin hay diferencias. Una de las diferencias ms importantes es que C# es mucho ms cercano a C++ en cuanto a diseo se reere. C# toma casi todos sus operadores, palabras reservadas y expresiones directamente de C++. Tambin se han mantenido algunas caractersticas que en Java se han desestimado. Por ejemplo las enumeraciones. No hay enumeraciones en Java y sin embargo era un concepto muy usado en C/C++. En C# se han mantenido las enumeraciones, y se han adaptado al nuevo lenguaje, de forma que ahora las enumeraciones no son simplemente enteros, sino que son tipos de tipado seguro que derivan de System.Enum en la librera de clases base. Una enumeracin de tipo "ej1" no se puede cambiar con una enumeracin de tipo "ej2" sin una conversin. Creo que esa es una diferencia importante. Toda la estructura de los espacios de nombres es mucho ms cercana a C++. Otra caracterstica que no est presente en Java es la posibilidad de trabajar directamente con direcciones de memoria. Si bien tanto Java como .NET proporcionan recogida automtica de basura, en C# es posible usar lo que se denomina "cdigo no seguro". Cuando se usa cdigo no seguro en C# es posible operar con punteros de forma muy similar a como se hara en C/C++, pero el cdigo que utiliza punteros se queda marcado como no seguro y no se ejecuta en entornos en los que no tiene permisos.

1.1.7. C# frente a C++Puesto que C# se ejecuta en una mquina virtual, sta se hace cargo de la gestin de memoria y por lo tanto el uso de punteros es mucho menos importante en C# que en C++. C# tambin es mucho ms orientado a objetos que C#, hasta el punto de que todos los tipos usados derivan en ltima instancia el tipo object. Adems, muchos tipos se usan dde forma distinta. Por ejemplo, en C# se comprueba los lmites de los vectores antes de usarlos, evitando as que se pueda escribir pasado el nal del vector. Al igual que Java, C# renuncia a la idea de herencia mltiple de clases presente en C++. Sin embargo, referido a clases, C# implemente propiedades del tipo de las que existen en Visual Basic, y los mtodos de las clases son accedidos mediante . en lugar de ::.

1.1.8. Porqu C#?La plataforma .NET acepta varios lenguajes. Por ahora, C#, Visual Basic, C++ gestionado, Nemerle, FORTRAN, Java, Python, etc. , y con capacidad para aceptar prcticamente cualquier lenguaje. Entonces la pregunta es, porqu se eligi C# en lugar de cualquier otro lenguaje?. La razn fundamental es que C# se dise para la plataforma .NET y es capaz de utilizar todo su potencial. Tambin es cierto que es un lenguaje "limpio" en el sentido de que al no tener que proporcionar compatibilidad hacia detrs se ha tenido ms libertad en el diseo y se ha puesto especial incapi en la simplicidad. Por ejemplo, en C# hay un tipo de clase y siempre se le aplica el recolector de

3

Captulo 1. Introduccin basura mientras que en C++ gestionado hay dos tipos de clases, una a las que se le aplica el recolector y otra a la que no.

1.2. Primer ejemploPara empezar con C#, que mejor que con un ejemplo bsico para entender la estructura bsica de un programa en C# y empezar a conocer las caractersticas del lenguaje. El ejemplo sera el siguiente://Declaracin del espacio de nombres using System; //Clase de nuestro programa principal class PrimerEjemplo { public static void Main() { // Escribir a la consola Console.WriteLine ("Bienvenido al tutorial de C# de M-H"); } }

Todo programa que escribamos en C# va a tener una estructura similar a esta en la que declararemos uno/varios espacios de nombres a utilizar (System), una clase y el mtodo "Main" de esa clase con las sentencias de nuestro programa. Por cierto, todos los archivos en C# llevan la extensin .cs (no hay cheros de cabecera ni nada similar ). Una vez ya visto el primer ejemplo, para compilarlo habra que utilizar mcs (mono compiler suite), que es el compilador de mono de C#, implementado segn las especicaciones del lenguaje segn ECMA-334, que ser el encargado de generar los ejecutables en cdigo intermedio (CIL) que posteriormente tendr que ser ejecutado por mono. Para ello se procedera de la siguiente forma:# mcs ejemplo.cs # mono ejemplo.exe

Dando el siguiente resultado:Bienvenido al tutorial de C# de M-H

Sobre todo si ests en entornos Windows tal vez querrs que la consola no se cierre automticamente. Entonces tendrs que escribir Console.Read() detrs de la ltima sentencia para que el programa espere a que pulses una tecla para poder cerrarse. Esto se hace extensible a todos los ejemplos de este tutorial.

4

Captulo 1. Introduccin En nuestro ejemplo, System es un espacio de nombres y con l le estaremos diciendo que podamos usar todos las clases asociadas a ese espacio de nombres, en nuestro caso la clase Console con el mtodo WriteLine que es el que se encarga de escribir por pantalla el mensaje que queramos mostrar. La clase PrimerEjemplo es la que va a contener la denicin de datos y mtodos que va a usar nuestro programa al ejecutarse. Adems de clases veremos que se pueden denir otros tipos diferentes de elementos tales como estructuras e interfaces con los mtodos asociados a estos tipos. Al utilizar el mtodo Main le estaremos diciendo que nuestro programa empieza ah y tiene los modicadores static (slo se va a usar en esa clase) y void diciendole que nuestro mtodo no va a devolver nada. Ya nicamente queda mostrar por pantalla el resultado, esto se hace utilizando la clase Console y el mtodo asociado WriteLine que es el que muestra por pantalla el mensaje de bienvenido. Para hacer referencia a los mtodos en WriteLine en C# se va a hacer con el operador ".", en diferencia a lo que puede ser en C++ el "::". Para los comentarios se utiliza tanto // como /* esto es un comentario */ al ms puro estilo de C++ y que todas las sentencias tienen que acabar con ; y los delimitadores de bloque son { y }.

5

Captulo 2. Tipos2.1. Tipos2.1.1. Importancia de los tipos de datosLos tipos son la base de cualquier programa. Un tipo no es ms que un espacio en el que se almacena una informacin, ya sean nmeros, palabras o tu fecha de nacimiento. Los tipos de datos son especialmente importantes en C# porque es un lenguaje con informacin de tipos. Esto signica que, en todas las operaciones, el compilador comprueba los tipos para ver su compatibilidad. Las operaciones no vlidas no se compilan. De esta forma se evitan muchos errores y se consigue una mayor abilidad

2.1.2. Tipos en C#En C# los tipos bsicos no son ms que alias para tipos predenidos en la librera base de la plataforma Mono/.NET . As, el tipo entero int, no es ms que una forma rpida de escribir System.Int32 . Los tipos del lenguaje C# son divididos en dos grandes categoras: tipos por valor y tipos por referencia. Existe una tercera categora de tipos, disponible solo cuando se usa cdigo no seguro: los punteros, que se discutirn ms adelante. Los tipos por valor dieren de los tipos por referencia en que las variables de los tipos por valor contienen directamente su valor, mientras que las variables de los tipos por referencia almacenan referencias a objetos. Con los tipos por referencia, es posible que dos variables se reeran al mismo objeto, y por tanto es posible que las operaciones sobre una variable afecten al objeto al que hace referencia otra variable. Con los tipos por valor, cada variable tienen su propia copia de los datos, y las operaciones sobre una no afectar a la otra.

2.2. Tipos por valor2.2.1. Tipos por valorComo hemos comentado, el trmino tipo por valor indica que las variables de esos tipos contienen directamente sus valores. De esta forma, los tipos por valor actan de forma muy parecida a los tipos de

6

Captulo 2. Tipos datos de otros lenguajes de programacin como C++. Los tipos por valor tambin se conocen como tipos sencillos Tabla 2-1. Tipos por valor Tipo C# Nombre para la plataforma Mono/.NET System.Boolean System.Byte System.SByte System.Int16 System.Uint16 System.Int32 System.Uint32 System.Int64 Con signo? Bytes utilizados Rango

bool byte sbyte short ushort int uint long

No No Si Si No Si No Si

1 1 1 2 2 4 4 8

verdadero o falso 0 hasta 255 -128 hasta 127 -32.768 hasta 32.767 0 hasta 65535 -2.147.483.648 hasta 2.147.483.647 0 hasta 4.394.967.395 9.223.372.036.854.775.808 hasta 9.223.372.036.854.775.807 0 hasta 18446744073709551615 Approximadamente 1.5E-45 hasta 3.4E38 con 7 cifras signicativas Approximadamente 5.0E-324 hasta 1.7E308 con 7 cifras signicativas Approximadamente 1.0E-28 hasta 7.9E28 con 28 29 cifras signicativas Cualquier carcter Unicode (16 bits) verdadero o falso

ulong

System.Uint64

No

8

oat

System.Single

Si

4

double

System.Double

Si

8

decimal

System.Decimal

Si

12

char bool

System.Char System.Boolean

2 1/2

7

Captulo 2. Tipos

2.2.2. EnterosLos tipos que sirven para almacenar nmeros enteros son: byte, sbyte. short, ushort, int, uint, long y ulong. Como se aprecia en la tabla, C# dene versiones con y sin signo para tipos con los mismo bytes utilizados. La diferencia entre enteros con signo y sin signo radica en el modo de interpretar el bit de nivel superior del entero. Si se especica un entero con signo, el compilador entender que el primer bit indica el signo: 0 si es positivo, 1 si es negativo. Sin embargo, los enteros sin signo, ese bit se puede utilizar para almacen el nmero y as se consigue que los enteros sin signo puedan almacenar nmeros el doble de grandes que los enteros con signo. Probablemente el tipo ms utilizado es el int, pus se utiliza para controlar matrices, inidizar arreglos adems de las operaciones normales con enteros. Adems, se trata de un entero de tamao medio: ms pequeo que long y ulong, pero ms grande que byte, sbyte, short y ushort. El siguiente ejemplo muestra la declaracin y uso de algunos tipos enteros calculando el nmero de segundos en una hora, dia y en un ao.using System; class Enteros{ public static void Main() { int Minuto = 60; //segundos por minuto int Hora = Minuto*60; int Dia = Hora*24; long Anio = Dia*365; Console.WriteLine("Segundos en un dia: {0}", Dia); Console.WriteLine("Segundos en un ao: {0}", Anio); } }

De nuevo hemos usado el mtodo Console.WriteLine para imprimir los resultados por la consola. El identicador {0} dentro de la cadena de texto indica que se sustituye {0} por el primer argumento. si hubiera ms de un argumento, se seguira con {1}, y as sucesivamente. Por ejemplo, las dos lneas que utilizan Console.WriteLine se pueden simplicar as:Console.WriteLine("En un dia: {0}; en un ao: {1}", Dia, Anio );

La clase Console, se describe ms en detalle en

8

Captulo 2. Tipos

2.2.3. Tipos de coma otanteLos tipos de coma otante sirven para representar a nmeros con parte fraccionaria. La representacin por supuesto puede no ser exacta, bien por errores de la mquina, bien porque el nmero de decimales que se puede alojar es nito. Existen dos clases de tipos de punto otante, oat y double. De los dos, el ms usado es double, pus es el valor que devuelven la mayora de las funciones matemticas de la librera base. El siguiente ejemplo calcula la raz cuadrada y el logaritmo de dos:using System; class Flotante{ public static void Main() { int a = 2; double log2 = Math.Log(2); double raiz2 = Math.Sqrt(2); Console.WriteLine("El logaritmo de dos es {0}", log2 ); Console.WriteLine("La raiz de dos es {0}", raiz2 ); } }

y la salida ser la siguiente:El logaritmo de dos es 0.693147180559945 La raiz de dos es 1.4142135623731

si intentamos cambiar el tipo de log2 a otro de menos precisin, como oat o int, el compilador protestar. Esto se debe, como hemos dicho a que el valor devuelto por Math.Log() es de tipo double y si se quiere convertir a oat, pus se perdern datos. Lo mismo ocurre con la mayora de los miembros de la clase Math, como Math.Sin(), Math.Tan(), etc.

2.2.4. El tipo decimalEl tipo decimal es un tipo "nuevo" en el sentido de que no tiene equivalente en C/C++. Es muy parecido a los tipo de coma otante oat y double. En la aritmtica de los tipos de coma otante ordinarios, se pueden producir leves errores de redondeo. El tipo decimal elimina estos errores y puede representar correctamente hasta 28 lugares decimales. Esta capacidad para representar valores decimales sin errores de redondeo lo hace especialmente ecaz para clculos monetarios.

9

Captulo 2. Tipos

2.2.5. El tipo boolEl tipo bool sirve para expresar los valores verdadero/falso, que en C# se muestran con las palabras reservadas true y false. En C#, por ejemplo, una instruccin if solo puede estar gobernada por un valor bool, no como en C/C++, que lo puede estar tambin por un entero. De esta forma se ayuda a eliminar el error tan frecuente en programadores de C/C++ cuando usa "=" en lugar de "==". En denitiva, la inclusin del tipo bool en el lenguaje ayuda a la claridad del cdigo y evita algunos errores muy comunes. El siguiente ejemplo, muestra algunos usos del tipo bool:using System; class Booleano{ public static void Main() { bool b; b = true; Console.WriteLine("b es {0}", b); if(b) { Console.WriteLine("esto saldr"); } b = false; if(b) { Console.WriteLine("esto no saldr"); } Console.WriteLine("2==2 es {0}", 2==2); } }

En la ltima lnea se muesta que el operador "==" tambin devuele un valor booleano. El resultado debera ser el siguiente:b es True esto saldr 2==2 es True

10

Captulo 2. Tipos

2.2.6. Tipo arregloEn C# se pueden construir arreglos de prcticamente cualquier tipo de dato. Los arreglos, tambin llamados vectores o arrays, no son ms que una sucesin de datos. Por ejemplo, el concepto matemtico de vector es una sucesin de nmeros y por lo tanto es un arreglo unidimensional. As, podemos construir arreglos de objetos, de cadenas de texto, y, por supuesto, arreglos de enteros:using System; class Arreglo{ public static void Main() { int[] arr = new int[3]; arr[0] = 1; arr[1] = 2; arr[2] = 3; Console.WriteLine( arr[1] ); } }

En este ejemplo se crea un arreglo arr unidimensional con capacidad para 3 enteros, y luego se le asigna a cada valor un entero distinto (ntese que se comienza a contar a partir de 0 ). Existe una forma ms corta para declarar el arreglo y asignarle las variables:int[] arr = {1,2,3};

Tambin se pueden crear arreglos bidimensionales ( de la misma forma para ms dimensiones). En ese caso la sintaxis para declarar un arreglo bidimensional de enterios serint[,] arr

en contraposicin a C/C++, en el que se declarara comoint[][] arr

De esta forma, un arreglo bidimensional se declarara y utilizara de la siguiente forma:using System; class Arreglo2{ public static void Main() { int[,] arr = new int[2,2]; arr[0,0] = 1;

11

Captulo 2. Tiposarr[1,0] = 2; arr[0,1] = 3; arr[1,1] = 4; Console.WriteLine( arr[1,1] ); } }

que, igual que el ejemplo anterior, podamos hacer declarado todo el arreglo de la siguiente forma:int[,] arr = {{1,2},{3,4}};

Se hablar con ms detalle sobre arreglos en la seccin

2.2.7. El tipo charEl tipo char permite almacenar un carcter en formato unicode de 16 bits, lo que nos garantiza que los acentos se ven de forma adecuada y adems permite la representacin de otros alfabetos, como el griego, cirlico, etc. Para introducir un carcter se utilizan comillas simples, de forma de declarar un carcter sigue la estructurachar letra = a

De igual forma que hemos hecho con los enteros, es posible declarar un arreglo de charchar[] cadena = {a, b, c };

aunque para almacenar algunas cadenas de caracteres, como las palabras, es ms indicado usar el tipo string .

12

Captulo 3. Estructuras de control3.1. Estructuras de controlEn este captulo se describen algunas sentencias que sirven para controlar la ejecucin de un programa. Algunas son muy similares a las existentes en otros lenguajes, como las sentencias if, for, while, etc. y otras, como foreach, throw o continue, son algo ms especcas.

3.1.1. Instruccin ifEsta sentencia sirve para ejecutar unas instrucciones en caso de que se cumpla determinada condicin. La forma completa de la instruccin if esif( condicin ) { instruccin1; instruccin2; ... } else { instruccin1; instruccin2; ... }

donde la clusula else es opcional. Si la condicin es verdadera, se ejecutarn las instrucciones dentro del bloque if, y si es falsa, se ejecutar el bloque else. El valor que controla el if debe ser de tipo bool. El siguiente ejemplo//programa que determina si un valor es positivo o negativo using System; class InstruccionIf{ public static void Main() { double d; Console.WriteLine("Introduce un numero"); d = Double.Parse( Console.ReadLine() ); if( d>0 ) { Console.WriteLine("El numero {0} es positivo", d); } else { Console.WriteLine("El numeros {0} es negativo", d);

13

Captulo 3. Estructuras de control} } }

te pide que introduzcas un nmero y dependiendo de si se cumple que dicho nmero es mayor que cero (condicin), se ejecuta un bloque u otro. La sentencia d = Double.Parse( Console.ReadLine() ); tal vez requiera algo de explicacin adicional. En realidad, con Console.ReadLine() estamos leyendo lo que el usuario introduce por pantalla, que es una cadena de caractres, y con Double.Parse lo que hacemos es interpretar esa cadena de caractres y conventirna en un tipo numrico double, de forma que d tendr el valor del nmero que introduzcamos por la consola. Las intrucciones if se pueden anidar, y existe tambin una extensin de la sentencia if, la sentencia if-else-if. Su formato es el siguiente:if( condicin ) { instrucciones; } else if( condicin ) { instrucciones; } ... else { instrucciones; }

Las instrucciones condicionales se evalan de arriba a abajo. Tan pronto como se encuentra una condicin true, se ejecuta la instruccin asociada con ella, y el resto de la escalera se omite. Si ninguna de las condiciones es true, se ejecutar la ltima instruccin else. La ltima instruccin else acta como condicin predeterminada, es decir, si no funciona ninguna de las otras pruebas condicionaes, se realiza esta ltima instruccin. Si no existe esta instruccin else nal y el resto de de las condiciones son falsas, entonces no se realizar ninguna accin. El siguiente ejemplousing System; class IfElseIf{ public static void Main() { string opcion; Console.WriteLine("Elija una opcin (si/no)"); opcion = Console.ReadLine(); if( opcion=="si" )

14

Captulo 3. Estructuras de control{ Console.WriteLine( "Muy bien, ha elegido si" ); } else if( opcion=="no" ) { Console.WriteLine( "Ha elegido no" ); } else{ Console.WriteLine("No entiendo lo que ha escrito"); } } }

le pide al usuario que elija una opcin si/no y la procesa usando una estructura if-else-if. Si la opcin no es ni "si" ni "no", entonces se ejecuta la sentencia else por defecto, que imprime por pantalla el mensaje "No entiendo lo que ha escrito"

3.1.2. Instruccin switchLa instruccin switch es muy parecida a la estructura if-else-if, slo que permite seleccionar entre varias alternativas de una manera ms cmoda. Funciona de la siguiente manera: el valor de una expresin se prueba sucesivamente con una lista de constantes. Cuando se encuentra una coincidencia, se ejecuta la secuencia de instrucciones asociada con esa coincidencia. La forma general de la instruccin switch es la siguiente:switch( expresin ){ case constante1: instrucciones; break; case constante2: instrucciones; break; ... default: instrucciones; break; }

La sentencia default se ejecutar slo si ninguna constante de las que siguen a case coincide con expresin. Es algo similar al else nal de la instruccin if-ese-if. Sin ms, vamos a por un ejemplousing System; class InstruccionSwitch{ public static void Main() {

15

Captulo 3. Estructuras de controlstring s; Console.WriteLine( Console.WriteLine( Console.WriteLine( Console.WriteLine( Console.WriteLine( "Elige " + " " * " / hacer algo con los nmeros 2 y 3"); para sumarlos" ); para restarlos" ); para multiplicarlos" ); para dividirlos (division entera)" );

s = Console.ReadLine(); switch(s){ case "+": Console.WriteLine("El break; case "-": Console.WriteLine("El break; case "*": Console.WriteLine("El break; case "/": Console.WriteLine("El break; default: Console.WriteLine("No break; } } }

resultado es {0}", 2+3);

resultado es {0}", 2-3);

resultado es {0}", 2*3);

resultado es {0}", 2/3);

te entiendo");

El cual solicita al usuario que inserte uno de los smbolos +-*/ , y con un switch compara los resultados para hacer diferentes acciones dependiendo del valor de s, que es la cadena de caracteres que almacena la eleccin del usuario. El resultado debera de ser algo parecido a esto:Elige hacer algo con los nmeros 2 y 3 + para sumarlos - para restarlos * para multiplicarlos / para dividirlos (division entera) * El resultado es 6

Como habr notado, al nal de todo case siempre hay una sentencia break. Esto no es obligatorio, puede haber en su lugar otra sentencia de salto, como un goto, pero siempre tiene que haber una sentencia de salto, incluso en el default nal, a no ser que la sentencia case est vaca. En caso contrario se obtiene un error en tiempo de compilacin. Otros lenguajes, como C/C++ o Java no tienen esta restriccin. La razn de adoptarla en C# es doble: por un lado, elimina muchos errores comunes y en segundo lugar permite al compilador reorganizar las sentencias de los case, y as permitir su optimizacin.

16

Captulo 3. Estructuras de control

3.1.3. Bucle forEl bucle for de C# es idntico al encontrado en los lenguajes C/C++, Java. El formato general esfor( inicializacin; condicin; iteracin ) { instrucciones; }

Las sentencias de inicializacin se ejecutan una vez al principio y sirven principalmente para asignar valores a las variables que servirn de contador. Las sentencias de condicin, por su parte, se ejecutan cada vez que el bucle vuelve al principio y sirven para controlar el bucle: ste seguir realizndose siempre y cuando estas codiciones sea true. Las sentencias de iteracin se ejecutan tambin cada vez que se realiza una nueva "vuelva" en el bucle, y sirven para cambiar el estado de las variables que gobiernan las sentencias de condicin. Pero todo esto se entiende mejor con un ejemplousing System; class BucleFor{ public static void Main() { int i; //el contador for( i = 0; i < 10; i++) { Console.WriteLine( i ); } } }

Este ejemplo imprime por pantalla los 10 primero enteros positivos. Es un caso muy simple y muy tpico de bucle for. Por cierto, el operador ++ lo que hace es que aade una unidad a la variable a la que acompaa, de forma que, por ejemplo, 9++ es 10. De esta forma, la variable se incrementa a cada vuelta. En el ejemplo anterior, las sentencias de inicializacin y te iteracin eran nicas, pero esto no tiene porqu ser as, se pueden utilizar varias sentencias separadas por comas. Por ejemplo, se pueden usar dos variables para controlar el bucleusing System; class BucleFor2{ public static void Main() { int i; int j; for( i=0, j=10; ij, pero tambin hubiera sido vlida i==5, true (el bucle se realizar indenidamente), false (el bucle no se realizar).

3.1.4. Bucle whileEl bucle while es un bucle que se realiza hasta que se cumpla determinada condicin. Tiene la formawhile( condicin ) { instrucciones; }

Donde la condicin de nuevo tiene que ser un valor booleano. Tiene una estructura muy sencilla, as que vamos directamente a ver un ejemplo.using System; class BucleWhile{ public static void Main() { int i = 0; while( i= 0 ) return _real + "+" + _img +"i"; else return _real + "" + _img + "i"; } }

En el ejemplo hemos puesto la clase, con un par de constructores , dos getters para obtener los datos privados de la clase y un metodo que nos transfoma el numero complejo a cadena para que se pueda visualizarlo facilmente, a esta clase la iremos aadiendo mtodos para que tenga capacidad de usar operadores sobrecargados. 12.1.2.1. Operadores binarios Para empezar vamos a sobrecargar el operador suma(+) para que al sumar dos objetos de la clase ComplexNum, es decir dos numeros complejos obtengamos otro numero complejo que sera la suma de ambas partes. Cabe destacar que los prototipos para sobrecargar operadores seran:public static Operando operator+(Operando a, Operando b)

Este es el prototipo para el operador +, el resto de operadores binarios van a seguir el mismo patron. Por tanto el cdigo del mtodo de sobrecarga ser:public static ComplexNum operator+(ComplexNum a, ComplexNum b) { return new ComplexNum(a.getReal() + b.getReal(), a.getImg() + b.getImg()); }

62

Captulo 12. Sobrecarga de operadores Este mtodo sobrecarga el operador suma para que podamos sumar dos numeros complejos. Un dato a tener en cuenta es que los mtodos que sobrecargan operadores deben ser static. Como se ve en el cdigo los operandos son a y b, que se reciben como parametro y el resultado de la operacion es otro numero complejo que es el que retorna el mtodo. Por tanto se limita a crear un nuevo numero complejo con ambas partes operadas. De la misma forma podemos crear la sobrecarga del operador resta(-) para que lleve a cabo la misma funcinpublic static ComplexNum operator-(ComplexNum a, ComplexNum b) { return new ComplexNum(a.getReal() - b.getReal(), a.getImg() - b.getImg()); }

Como vemos el metodo es identico solo q sustituyendo los + por -. En este caso el trabajo que hacemos dentro del metodo es trivial pero podria ser tan complejo como se quiera. 12.1.2.2. Operadores Unarios En esta seccin se vera como sobrecargar los operadores unarios, es decir aquellos que toman un solo operando, como por ejemplo a++. El prototipo de los mtodos que van a sobrecargar operadores unarios ser:public static Operando operator++(Operando a)

Como antes sustituyendo el ++ por cualquier operador unario. El ejemplo dentro de nuestra clase de numeros complejos sera:public static ComplexNum operator++(ComplexNum a) { float auximg = a.getImg(); float auxreal = a.getReal(); return new ComplexNum(++auxreal, ++auximg); }

A primera vista puede quedar la duda si estamos sobrecargando la operacion ++a o a++. Este aspecto se encarga el compilador de resolverlo, es decir, se sobrecarga la operacion ++ y el compilador se encarga de sumar y asignar o asignar y sumar. Este problema no ocurria en C++, cosa que teniamos que manejar nosotros Como hemos dicho antes la operacion que hagamos dentro del metodo que sobrecarga el operador es totalmente libre, se puede poder el ejemplo de multiplicar dos matrices lo que es mas complejo que sumar dos numeros complejos

63

Captulo 13. TRatamiento de cheros13.1. Tratamiento de cheros13.1.1. La primera clase: System.IO.File

Esta clase estatica nos provee de las operaciones basicas a realizar con cheros a nivel externo. Es una clase sellada, por lo que ninguna clase puede derivar de ella. Es una clase que hace los tests de permisos y seguridad en cada invocacion.

13.1.1.1. Metodo System.IO.File.AppendText()StreamReader System.IO.File.AppendText(string camino)

Este metodo devuelve un StreamWriter (Explicado mas adelante) que nos permite aadir texto en formato UTF-8 al chero especicado en la cadena"camino" 13.1.1.2. Metodo System.IO.File.Copy()void System.IO.File.Copy(string org, string dest); void System.IO.File.Copy(string org, string dest, bool sobreescribe);

Este metodo nos permite copiar un chero a otro lugar, el chero org se copia en dest, el tercer parametro es si se debe sobreescribir o no el chero destino 13.1.1.3. Metodo System.IO.File.Create()TextWriter System.IO.File.Create(string camino); TextWriter System.IO.File.Create(string camino; int buffer);

Este metodo devuelve un TextWriter, crea o sobreescribe el chero identicado por camino, el segundo parametro especica el tamao del buffer a usar en el TextWriter creado 13.1.1.4. System.IO.File.CreateText()StreamWriter System.IO.File.CreateText(string camino);

Este metodo devuelve un StreamWriter usando la codicacion UTF-8.

64

Captulo 13. TRatamiento de cheros 13.1.1.5. System.IO.File.Delete()void System.IO.File.Delete(string camino);

Este metodo borra el chero especicado en camino. 13.1.1.6. System.IO.File.Exists()bool System.IO.File.Exists(string camino);

Este metodo borra el chero especicado en camino. 13.1.1.7. System.IO.File.GetAttributes()FileAttributes System.IO.File.GetAttributes(string ruta);

Este metodo devuelve la enumeracion FileAttributes y -1 si no existe la ruta. 13.1.1.8. System.IO.File.GetCreationTime()DateTime System.IO.File.GetCreationTime(string ruta)

Devuelve un tipo DateTime que contiene la cha del chero asociado a esa ruta 13.1.1.9. System.IO.File.GetLastAccessTime()DateTime System.IO.File.GetLastAccessTime(string ruta);

Devuelve un DateTime que contiene la fecha del ultimo acceso al chero asociado a la ruta 13.1.1.10. System.IO.File.GetLastWriteTime()DateTime System.IO.File.GetLastAccessTime(string ruta);

Devuelve un DateTime que contiene la fecha del ultimo acceso al chero asociado a la ruta 13.1.1.11. System.IO.File.Move()void System.IO.File.Move(string origen, string destino);

Mueve el chero identicado por la cadena origen a destino.

65

Captulo 13. TRatamiento de cheros 13.1.1.12. System.IO.File.Open()FileStream FileStream FileAccess FileStream FileAccess System.IO.File.Open(string ruta, FileMode modo); System.IO.File.Open(string ruta, FileMode modo, modo_a); System.IO.File.Open(string ruta, FileMode modo, modo_a, FileShare modo_s);

Abre el chero especicado por ruta, devuelve un FileStream asociado a el en los modos especicados 13.1.1.13. System.IO.File.OpenRead()FileStream System.IO.File.OpenRead(string ruta);

Abre el chero especicado para lectura y devuelve un FileStream asociado a el 13.1.1.14. System.IO.File.OpenText()StreamReader System.IO.File.OpenText(string ruta);

Abre el chero especicado para lectura y devuelve un StreamReader asociado a el. 13.1.1.15. System.IO.File.OpenWrite()FileStream System.IO.File.OpenWrite(stream ruta);

Abre un chero para escritura y devuelve un FileStream asociado a el. 13.1.1.16. System.IO.File.SetAttributes()void System.IO.File.SetAttributes(string ruta,FileAttributes atribs);

Pone los atributos especicados en atribs al chero especicado por la ruta. 13.1.1.17. System.IO.File.SetCreationTime()void System.IO.File.SetCreationTime(string ruta, DateTime cr_tm);

Pone la fecha de creacion del archivo especicado en ruta a lo especicado en cr_tm

66

Captulo 13. TRatamiento de cheros 13.1.1.18. System.IO.File.SetLastAccessTime()void System.IO.File.SetLastAccessTime(string ruta, DateTime la_tm);

Pone la fecha de ultimo acceso especicada en la_tm al chero asociado a ruta. 13.1.1.19. System.IO.File.SetLastWriteTime()void System.IO.File.SetLastWriteTime(string ruta, DateTime lw_tm);

Pone la fecha de la ultima escritura del archivo identicado en ruta, al valor especicado en lw_tm 13.1.1.20. Ejemplo de uso de la clase System.IO.FileTODO

13.1.2. Obteniendo informacion sobre archivos: System.IO.FileInfoUna de las primeras cosas que interesa conseguir de un archivo es la informacion que el sistema operativo puede proveernos, tamao, localizacion, fechas de creacion, modicacion, acceso...; para ello la BCL nos provee de una clase (System.IO.FileInfo) que nos permite obtener informacion sobre un archivo.

67

Captulo 14. Interoperabilidad con cdigo nativo14.1. Uso de Platform Invoke14.1.1. Que es Platform Invoke ?Platform Invoke o su abreviatura PInvoke es un metodo que tenemos en C# para poder llamar a funciones de otras librerias desde nuestros programas, como por ejemplo gtk+ en el caso de gtk# o a la propia api de windows desde un programa en C# para windows. El metodo que usa PInvoke es importar la funcion de la libreria donde reside declarandola dentro de nuestro programa y usando nuestros parametros de C#

14.1.2. Usando Platform InvokePara usar PInvoke primeramente como hemos dicho debemos importar la funcion, para ello usaremos la siguente sintaxis[DllImport("libreria desde la que importamos la funcion")] -- Declaracion de la funcion --;

La forma de uso es sencilla y se ve que mediante la llamada DllImport indicamos la libreria donde se encuentra la funcion q pasamos a declarar para su siguiente uso

14.1.3. Ejemplo de usoPara ver como funciona lo mas facil es ver un ejemplo[DllImport("glade-2.0")] static extern IntPtr glade_xml_new(string fname, string root, string domain);

En el ejemplo lo que se hace es importar de la libreria glade-2.0 la funcion glade_xml_new. Como hemos dicho antes declaramos la funcion para nuestro uso, mientras que el prototipo original de la funcion dentro de libglade esGladeXML* glade_xml_new (const char *fname, const char *root, const char *domain)

68

Captulo 14. Interoperabilidad con cdigo nativo Con PInvoke lo declaramos para su uso en C# asi const char se convierte en string y el puntero a GladeXML en un puntero general en c#. Tambien es importante notar que la funcion la denimos como static y extern, denotando que puede ser llamada sin denir una clase y que esta denida externamente al codigo del programa Finalmente vamos a ver un ejemplo de importacion y llamada[DllImport("gtk-x11-2.0")] static extern IntPtr gtk_button_new_with_mnemonic(string label); public Button(string label) { Raw = gtk_button_new_with_mnemonic(label); }

El ejemplo esta tomado de la clase Button de la libreria Gtk#. Como vemos el metodo que se dene es un constructor al que le pasamos el nombre que llevara el propio boton, dentro de gtk+ usamos la funcion gtk_button_new_with_mnemonic, por lo tanto la importamos desde la libreria gtk para llamarlo posteriormente. Al igual que antes los parametros cambian y el const gchar * que recibe la funcion en gtk+ lo cambiamos por el tipo string Una vez que tenemos importada la funcion y declarada en nuestro entorno el siguiente paso natural es usarla. Para ello en el ejemplo dentro del constructor llamamos a la funcion importada con el parametro que nos pasan.

14.1.4. ConclusionesPara terminar es importante resaltar la gran utilidad que tiene este prodecimiento dentro de C# ya que podemos llamar a funciones dentro de otras librerias que estan escritas en otro lenguaje de programacion ( realmente no importa cual ). Esto es de una gran utilidad dentro de librerias que hacen de wrappers como es el caso de gtk# y gtk+

69

Captulo 15. Introspeccin15.1. Introspeccin: El ojo que todo lo veCdigo gestionado (managed code), la nueva palabra de moda dentro del mundo de la programacin, hace referencia a un nuevo tipo de cdigo que se ejecuta bajo el escrutinio de una mquina virtual, al cual nos permite conocer muchas cosas sobre ese cdigo, saber que va a hacer, de que cosas depende y muchas otras cosas. En realidad todos estos conceptos ya los tenamos en Java, por lo que se podra decir que el cdigo Java tambin es cdigo gestionado. Vamos a ver en esta seccin del tutorial de C# como se nos abren grandes posibilidades con este tipo de cdigo, que vamos a poder relacionarlo de forma sencilla con otras herramientas o que incluso vamos a poder modicar el cdigo que se ejecuta en funcin del contexto de ejecucin en el que se encuentre el programa. Lo primero que vamos a realizar es la presentacin de algunos conceptos que vamos a utilizar dentro de la seccin, para luego ir buceando en todos ellos.

15.1.1. MetadatosEl primer concepto con el que vamos a jugar es con el de metadatos, que se reere al conjunto de descripciones que se hacen sobre los datos, lo que muchas veces se llama "los datos sobre los datos". En nuestro caso, los datos que vamos a describir con metadatos son el cdigo de nuestra aplicacin. Vamos a ir aadiendo al cdigo caractersticas que enriquezcan la interpretacin posterior y lo que se puede hacer con ese cdigo posteriormente. Los detalles sobre los datos, metadatos, tambin pueden ser detallados con otras descripciones, con lo que tenemos otro nivel de metadatos, es decir, "meta"-"metadatos". Como vemos el concepto de metadatos es algo abstracto pero vamos a comenzar a ver ejemplos reales que nos permitan tocar el suelo, y ver su gran utilidad.

15.1.2. AtributosLos atributos son el pilar de los metadatos en C#. Con ellos vamos a poder especicar caractersticas de diferentes partes del cdigo C#. Segn donde situemos el atributo, se aplicar a una zona u otra (clase, mtodo, ensamblado ...). Tenemos atributos que ya estn predenidos dentro de C#, otros dentro de .NET, otros dentro de Mono y otros que nos podemos crear nosotros mismos.

70

Captulo 15. Introspeccin Los atributos no dejan de ser objetos de C#.

15.1.3. Cdigo gestionado: Integracin

15.1.4. Reexin

15.1.5. Ejemplo prctico: rboles de Mono

71

Captulo 16. Creacin y uso de librerasUsando las opciones correctas en la compilacin, C# genera libreras con sujo dll que se pueden acceder directamente desde una aplicacin cliente.

16.1. Compilando para una libreraEsto es muy sencillo, simplemente especifcale al compilador la opcin -targe:library y te generar un archivo dll. Supongamos que nuestra librera es un archivo MisMetodos.cs con el siguiente cdigo:namespace MisMetodos{ public class Mates { public static int Factorial( int n ) { int fact = n; for( int i = n-1; i> 0; i-- ) { fact = fact*i; } return fact; } } }

que simplemente contiene una funcin para calcular el factorial de un entero. Lo compilamos ahora conmcs MisMetodos.cs -target:library

y obtendremos nuestra librera MisMetodos.cs

16.2. Usando nuestra libreriaAhora nos falta construir una aplicacin cliente que utilize los mtodos denidos en nuestra librera. El cdigo de esta aplicacin podra ser la seguiente (supongamos que est en un archivos llamado MiApliCliente.cs):using System; using MisMetodos; class MiApliCliente { public static void Main() { int n = Mates.Factorial(5); Console.WriteLine("5! = {0}", n );

72

Captulo 16. Creacin y uso de libreras} }

Ahora para compilar ste archivo debemos de referenciar la librera que acabamos de compilar. es necesario que la librera y nuestra aplicacin estn en el mismo directorio. Referenciar una librea siempre se consigue dndole al compilador la opcin -r:nombre_de_la_libreria.dll. El nuestro caso sera algo as:mcs MiApliCliente.cs -r:MisMetodos.dll

y cuando lo ejecutemos (mono MiAplicliente o ./MiApliCliente ) debera de producir la siguiente salida5! = 120

73

Captulo 17. AutoresPara la versin 0.6 (octubre-2004):

Fabian Seoane (http://fseoane.net), (fseoane),

Para la versin 0.5 (agosto-2004):

Fabian Seoane (http://fseoane.net), (fseoane),

En versiones anteriores han colaborado las siguientes personas

Alejando Snchez, Alvaro del Castillo, Eduardo Garca Cebollero, Csar Garca Tapia, Sergio Gmez Bachiller, Roberto Prez Cubero, Jaime Anguiano Olarra,

74

BibliografaLibrosHerbert Schild, Mc Graw Hill, Manual de referencia C#. Ecma-International, Estndar Ecma-334.

ArtculosDare Obsanjo, MSDN, Understanding XML (http://msdn.microsoft.com/XML/Understanding/default.aspx?pull=/library/enus/dnxml/html/understxml.asp).

75