Ejemplos de C# con Mono

© 2007 Martin Marquez: xomalli@gmail.com http://www.humansharp.com; version 0.2

2

Copyright © 2005 Martin Marquez

Se otorga el permiso de copiar, distribuir o modificar este documento en los términos de la licencia GNU Free Documentation License , Versión 1.2 o cualquier versión posterior

publicada por la Free Software Foundation. Una copia de esta licencia esta incluida en este material en la sección titulada “GNU Free Documentation License”

Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License (http://www.gnu.org/licenses/fdl.txt) , Version 1.2 or any

later version published by the Free Software Foundation. A copy of this license is included in this material in the section titled “GNU Free Documentation License”.

3

Contenido

Introducción 4 Sección I Instalación del software Instalación bajo Microsoft Windows 5

Configuración del entorno en Microsoft Windows 13

Instalación bajo Linux 17

Configuración del entorno bajo Linux 22

Sección II Algoritmos Enumeraciones 24

Recursividad 26

Tablas de verdad con operadores lógicos 27

Arreglos y Matrices 28

Pilas 31

Árboles Binarios 33

Trabajo con caracteres 36

Sección III Temas prácticos Threads (hilos) 39

Lectura y escritura de archivos 40

Utilizando el conector .NET de MySQL 42

Usando XML 46

Usando GTK# 47

Referencias 50

4

Introducción Mono es la versión open source de la plataforma .NET de Microsoft, teniendo como

herramienta principal el compilador de C# , el soporte para páginas ASP.NET bajo Linux y

una serie de herramientas para desarrollar distintos tipos de programas de cómputo tal como

aplicaciones gráficas de escritorio, aplicaciones de consola y Formularios Web.

Este manual esta escrito para las personas que requieran aprender a programar, o aquellas

personas que ya dominando un lenguaje de programación y deseen utilizar sus

conocimientos con las herramientas de Mono y el lenguaje de programación C#.

Esperando que este material sea una guía rápida de introducción y aprendizaje al lenguaje y

a las herramientas de .NET y mono, a partir de definiciones y ejemplos.

Si tiene algún comentario respecto a este material, por favor escriba a:

xomalli@gmail.com

5

1.0 Instalación del software 1.1 Instalación bajo Microsoft Windows

Vaya a la página del software mono http://www.go-mono.com y descargue el instalador para

Microsoft Windows.

Página de descargas del software de instalación

6

Cree una carpeta en su sistema de archivos llamado por ejemplo [instalador_mono] y

descargue ahí el ejecutable de instalación.

Teniendo el ejecutable de instalación en el disco duro, haga doble clic o bien seleccione y

pulse el botón [ enter ] para ejecutar el programa.

Al ejecutarse se vera la pantalla de bienvenida de Mono .

7

Al pulsar el botón [ Next ] (siguiente) se ira a la pantalla acerca del la licencia del software,

es recomendable darle una lectura a la licencia para estar enterados de cual son los

derechos y limitantes del software.

Una vez que estemos de acuerdo con la licencia del programa, seleccionamos la opción [ I

accept the agreement ] (yo acepto el contrato), pulsamos el botón [ Next ] (siguiente) para

continuar con la siguiente pantalla.

8

Al pulsar el botón [ Next ] (siguiente) se vera la pantalla, sobre las notas de Mono

La siguiente pantalla nos muestra la ruta de instalación predeterminada, si se necesita

instalarse en otro lugar podemos cambiar la ruta en el cuadro de texto o bien pulsar el botón

[browse] para poder seleccionar la ruta de instalación, seleccionada la ruta pulsamos el

botón [ Next ] (siguiente) para pasar a la siguiente pantalla.

9

Las siguientes pantallas muestran los tipos de instalación, como opción predeterminada [Full

installation] (opción completa) nos instalará todo el software,

[compact installation] nos instalará el soporte mínimo para el lenguaje, opciones como las

bibliotecas gráficas, la documentación y los ejemplos no serán instalados.

10

[Custom installation] nos permite agregar o quitar componentes, excepto los archivos de la

instalación mínima.

La siguiente pantalla pregunta si necesitamos un acceso directo en el menú de programas.

11

La siguiente pantalla pregunta el puerto del servidor XSP, XSP es un servidor web ligero que

nos permite probar las páginas ASP.NET, antes de subirlas a un web de producción como

Apache o IIS. (Recomiendo usar el puerto predeterminado)

Listo para instalar, para cambiar una opción pulsamos el botón [ Back ] (regresar).

12

Copia de los archivos en el disco duro.

Pantalla final de la instalación.

13

1.2 Configuración del entorno en Microsoft Windows Mono tiene un submenú hacia una ventana de MS-DOS con el entorno configurado para

poder usar el compilador, el intérprete y las herramientas.

Si necesitamos que las herramientas y el entorno de programación queden configurados de

manera permanente en nuestro sistema, debemos seguir los pasos siguientes.

1-. Ir al icono de mi PC, hacer clic con el botón secundario del ratón y el submenú elegir la

opción de [propiedades].

14

2-. Vaya a la pestaña [ avanzado ] y presione el botón [ variables de entorno ]

3-. En la ventana [variables de entorno] , en la parte superior seleccione la variable [path] y

presione el botón [editar] .

15

4-. Se abrirá la ventana donde podremos modificar la variable [path] en nuestro entorno.

5-. Buscamos la carpeta de instalación del software, y abrimos la carpeta [bin] donde se

encuentran las herramientas de programación del software.

6-. Una vez teniendo la ruta completa de la carpeta de instalación del software mas la

carpeta [bin] , editamos el valor de la variable [path] colocando ; (punto y coma) al final del

valor y agregamos la ruta de la carpeta [bin] de nuestro software.

16

7-. Cerramos todas las ventanas abiertas presionando el botón [Aceptar] , abrimos una

ventana de MS-DOS y tecleamos el comando mono –help .

Si el comando fue ejecutado correctamente se vera la siguiente pantalla.

Ya tenemos nuestro entorno configurado y listo para trabajar con Mono .

17

1.3 Instalación bajo Linux Vaya al sitio de mono http://www.go-mono.com y descargue el instalador en su directorio

$home .

Abra la carpeta $home , ejecute el archivo seleccionándolo y haga doble clic.

O bien, abra una Terminal y ejecute el instalador con el siguiente comando.

18

Al ejecutar el instalador vera la pantalla de bienvenida del software.

Pulse el botón [Adelante] para ir a la pantalla, que pregunta acerca de la licencia.

19

Pulse el botón [Adelante] para avanzar en la instalación, la siguiente pantalla preguntará

acerca de la ruta de ubicación del software, se recomienda aceptar la ruta predeterminada en

el directorio $home para que el programa de instalación pueda instalar un acceso directo en

el escritorio.

En la siguiente pantalla se pregunta si el programa agrega modifica el archivo de

configuración del entorno, esto depende del nivel de conocimiento del usuario, recomiendo

seleccionar [no] y hacer las modificaciones manualmente.

20

Ahora el software esta listo para instalarse, si desea algún cambio pulse el botón [Atrás] .

Copia de los archivos de instalación al disco duro.

21

Si el software se ha instalado correctamente, vera la siguiente pantalla.

Se vera el acceso directo a las herramientas de Mono en el escritorio.

22

1.4 Configuración del entorno bajo Linux Ejecute el acceso director de Mono en el escritorio.

Edite el archivo de configuración, en SuSe Linux es el archivo .profile que se encuentra en

el directorio $home (el archivo de configuración puede variar según su distribución) agregue

al final del archivo la línea siguiente:

PATH=$PATH:[ruta completa de la carpeta [bin] de la carpeta de instalación de Mono]

23

Guardamos el archivo de configuración, salimos de nuestra sesión actual y si los cambios

fueron hechos correctamente nos mostrara la siguiente pantalla, tecleando: mono --help

24

2.0 Algoritmos 2.1 Enumeraciones con C# Un tipo de datos de enumeración enum es usado para definir un conjunto de elementos

constantes, este tipo de datos se usan para agrupar constantes y en programas de opción

múltiple.

Las enumeraciones pueden ser de cualquier tipo de datos (integer, short, long) excepto el

tipo de datos char.

Programa 2.1 Programa que demuestra el tipo de datos enum (Enumeración) para el conjunto de días de

la semana.

using System ; class Enumeracion { enum DiasSemana { Lunes = 1, Martes = 2, Miercoles = 3, Jueves = 4, Viernes = 5, Sabado = 6, Domingo = 7 } static int Main( string [] args ) { Console . WriteLine( ImprimeDia( DiasSemana . Martes )); Console . WriteLine( ImprimeDia( DiasSemana . Sabado )); return 0; } static string ImprimeDia( DiasSemana ds ) { string s = " " ; switch( ds ) { case DiasSemana . Lunes: s = "Tengo que levantarme temprano" ; break ; case DiasSemana . Martes: s = "Aun no me recupero" ; break ; case DiasSemana . Miercoles: s = "Faltan 2 dias" ; break ; case DiasSemana . Jueves: s = "Falta un dia solamente" ; break ; case DiasSemana . Viernes: s = "Por fin es viernes" ;

25

break ; case DiasSemana . Sabado: s = "Es el mejor dia de la semana" ; break ; case DiasSemana . Domingo: s = "Ya mañana es Lunes de nuevo" ; break ; } return s; } }

Teclee el archivo en un editor de texto ASCII, y guárdelo con el nombre enumeracion.cs Abra una ventana de MS-DOS o de Terminal y compílelo con el comando:

$ mcs enumeracion.cs

Si la compilación tuvo errores corríjalos y ejecute de nuevo la compilación, si tuvo éxito

entonces se genero el archivo: enumeración.exe.

Ejecute ahora programa ejecutable con el intérprete: $ mono enumeración.exe

2.2 Recursividad La recursión es una técnica de programación implementada mediante un método que ya sea

por iteración o por decisión resuelve un problema hasta llegar a un caso base , un método

recursivo es un método que se llama así mismo ya sea directamente o indirectamente a

través de otro método. Los enfoques recursivos para resolver problemas tienen varios

elementos en común. El método en si sabe como resolver el o los casos más sencillos los

llamados casos base.

Programa 2.2 Los números de fibonacci y factorial para mostrar las funciones recursivas. using System ; using System . IO ;

public class Recursividad { static int Main() { int num = 0; string snum; do {

26

Console . Write( "Teclee un numero [ MAX 33 ]: " ); snum = Console . ReadLine(); } while(! esNumero( snum) || Int32 . Parse( snum) > 33); num = Int32 . Parse( snum); Console . WriteLine( "El factorial de {0} es {1}" , num, factorial( num));

Console . WriteLine( "El fibonacci de {0} es {1}" , num, fibonacci( num)); return 0; } static bool esNumero( string s) { if( s. IndexOf( "1" ) != - 1 || s . IndexOf( "2" ) != - 1 || s . IndexOf( "3" ) != - 1 || s . IndexOf( "4" ) != - 1 || s . IndexOf( "5" ) != - 1 || s . IndexOf( "6" ) != - 1 || s . IndexOf( "7" ) != - 1 || s . IndexOf( "8" ) != - 1 || s . IndexOf( "9" ) != - 1 || s . IndexOf( "0" ) != - 1) return true; else return false; } static long factorial( int n) { if( n <= 1) return 1; else return n * factorial( n - 1); } static long fibonacci( int n) { if( n == 0 || n == 1) return n; else return fibonacci( n - 1) + fibonacci( n - 2); } }

Compílelo usando el comando: $ mcs Recursividad.cs

Ejecutelo: $ mono Recursividad.exe

27

2.3 Tablas de verdad con operadores lógicos Una tabla de verdad sirve para mostrar los resultados posibles de una operación lógica. Programa 2.3 Tablas de verdad con los operadores lógicos de C# using System ;

public class TablaT { static int Main( string [] args ) { Console . WriteLine( "logico (&&)" ); Console . WriteLine( "F && F: " + ( false && false)); Console . WriteLine( "F && T: " + ( false && true)); Console . WriteLine( "T && F: " + ( true && false)); Console . WriteLine( "T && T: " + ( true && true)); Console . WriteLine( "" ); Console . WriteLine( "OR logico (||)" ); Console . WriteLine( "F && F: " + ( false || false)); Console . WriteLine( "F && T: " + ( false || true)); Console . WriteLine( "T && F: " + ( true || false)); Console . WriteLine( "T && T: " + ( true || true)); Console . WriteLine( "" ); Console . WriteLine( "AND logico booleano (&)" ); Console . WriteLine( "F & F: " + ( 0 & 0)); Console . WriteLine( "F & T: " + ( 0 & 1)); Console . WriteLine( "T & F: " + ( 1 & 0)); Console . WriteLine( "T & T: " + ( 1 & 1)); Console . WriteLine( "" ); Console . WriteLine( "OR inclusivo logico booleano (|)" ); Console . WriteLine( "F | F: " + ( 0 | 0)); Console . WriteLine( "F | T: " + ( 0 | 1)); Console . WriteLine( "T | F: " + ( 1 | 0)); Console . WriteLine( "T | T: " + ( 1 | 1)); Console . WriteLine( "" ); Console . WriteLine( "OR exclusivo logico booleano (^)" ); Console . WriteLine( "F ^ F: " + ( 0 ^ 0)); Console . WriteLine( "F ^ T: " + ( 0 ^ 1)); Console . WriteLine( "T ^ F: " + ( 1 ^ 0)); Console . WriteLine( "T ^ T: " + ( 1 ^ 1)); Console . WriteLine( "" ); Console . WriteLine( "NOT logico booleano (!)" ); Console . WriteLine( "!F: " + (! false)); Console . WriteLine( "!T: " + (! true)); Console . WriteLine( "" ); return 0; } }

28

Compilelo: $ mcs TablaT.cs

Ejecútelo: $ mono TablaT.exe

2.4 Arreglos y Matrices Un arreglo es un grupo de posiciones de memoria contiguas, todas las cuales tienen el

mismo nombre y el mismo tipo. Para referirnos a una posición o elemento en particular del

arreglo, especificamos el nombre del arreglo y el número de posición de ese elemento en el

arreglo.

Un arreglo multidimensional es un arreglo de 2 o más dimensiones, .la primera dimensión

son las filas y la segunda dimensión son las columnas.

Programa 2.4 Un programa que suma 2 matrices. using System ; public class Matrices { static int Main() { string sfilas = " " , scolumnas = " " , valor = " " ; int filas = 0, columnas = 0, numero = 0, temp = 0, i = 0, j = 0; Console . WriteLine( "" ); Console . WriteLine( "|------------------------------------------------- --------------------------|" ); Console . WriteLine( "| La suma dos matrices se establece solo si las ma trices a sumar son de la |" ); Console . WriteLine( "| misma dimension, teclee las dimensiones de la ma triz 1 y el valor de los |" ); Console . WriteLine( "| elementos, para la matrix 2 solo se le pedira el valor de los elementos. |" ); Console . WriteLine( "| |" ); Console . WriteLine( "| Suma = matrix1[i][j] + matrix2[i][j] |" ); Console . WriteLine( "| |" ); Console . WriteLine( "| Donde matrix1[i] = matrix2[i] y matrix1[j] = matrix2[j] |" ); Console . WriteLine( "| |" );

29

Console . WriteLine( "|------------------------------------------------- --------------------------|" ); Console . WriteLine( "Creacion de la matrix 1" ); do { Console . Write( "Teclee numero de filas: [MAX 16]: " ); sfilas = Console . ReadLine(); } while(! esNumero( sfilas ) || Int32 . Parse( sfilas ) > 16); //aqui obtengo las filas de la primera matrix filas = Int32 . Parse( sfilas ); Console . WriteLine( "Filas [" + filas + "]" ); do { Console . Write( "Teclee numero de columnas: [MAX 16]: " ); scolumnas = Console . ReadLine(); } while(! esNumero( scolumnas ) || Int32 . Parse( scolumnas ) > 16); //aqui obtengo las columnas de la primera matriz columnas = Int32 . Parse( scolumnas ); Console . WriteLine( "Columnas [" + columnas + "]" ); Console . WriteLine( "Matrix1 = [" + filas + "][" + columnas + "]" ); //aqui creo un arreglo bidemensional para la primer a matriz int[,] matrix = new int[ filas , columnas ]; //en el siguiente ciclo recorro la matrix bidemensi onal //primero recorro las filas for ( i = 0; i < filas ; i ++) { //aqui recorro las columnas for ( j = 0; j < columnas ; j ++) { do { Console . Write( "Teclee el valor del elemento: [" + i +"]" + "[" + j + "] = " ); valor = Console . ReadLine(); } while(! esNumero( valor )); //aqui obtengo el valor //el metodo console.Readline regresa un string por eso hago un casting //usando el metodo Int32.parse(string) numero = Int32 . Parse( valor ); temp = numero ; //aqui asigno el valor al arreglo bidimensional matrix [ i , j ] = temp ; } // fin del ciclo j } // fin del ciclo i Console . WriteLine( "*********Matrix 1 generada.**********" ); Console . WriteLine( "de la matrix 2" ); Console . WriteLine( "Matrix2 = [" + filas + "][" + columnas + "]" ); //aqui creo la segunda matrix bidemensional int[,] matrix2 = new int[ filas , columnas ]; //en el siguiente ciclo recorro la matrix bidemensi onal //primero recorro las filas for ( i = 0; i < filas ; i ++) { //aqui recorro las columnas

30

for ( j = 0; j < columnas ; j ++) { do { Console . Write( "Teclee el valor del elemento: [" + i +"]" + "[" + j + "] = " ); valor = Console . ReadLine(); } while(! esNumero( valor )); //aqui obtengo el valor //el metodo console.Readline regresa un string por eso hago un casting //usando el metodo Int32.parse(string) numero = Int32 . Parse( valor ); temp = numero ; matrix2 [ i , j ] = temp ; } // fin del ciclo j } // fin del ciclo i Console . WriteLine( "*********Matrix 2 generada.**********" ); Console . WriteLine( "matrix resultado es: " ); //aqui recorro la matrix bideçimensional resultado int[,] matrixresultado = new int[ filas , columnas ]; for ( i = 0; i < filas ; i ++) { for ( j = 0; j < columnas ; j ++) { matrixresultado [ i , j ] = matrix [ i , j ] + matrix2 [ i , j ]; } } //@ aqui se imprime el resultado for ( i = 0; i < filas ; i ++) { for ( j = 0; j < columnas ; j ++) { Console . Write( "Matrix Resultado = [" + i + "," + j + "]" + " , valor = " + matrixresultado [ i , j ] + "" ); } } return 0; } //usando este metodo compruebo que solo sea //una cadena con números, sin letras ni símbolos static bool esNumero( string s) { if( s. IndexOf( "1" ) != - 1 || s . IndexOf( "2" ) != - 1 || s . IndexOf( "3" ) != - 1 || s . IndexOf( "4" ) != - 1 || s . IndexOf( "5" ) != - 1 || s . IndexOf( "6" ) != - 1 || s . IndexOf( "7" ) != - 1 || s . IndexOf( "8" ) != - 1 || s . IndexOf( "9" ) != - 1 || s . IndexOf( "0" ) != - 1)

31

return true; else return false; } } //fin de la clase

Compilelo: $ mcs Matrices.cs

Ejecutelo: $mono Matrices.exe

2.5 Pilas Una pila es una versión restringida de una lista enlazada: los nodos nuevos solo pueden

agregarse a la pila y retirarse de la pila en el tope, por eso la pila es LIFO (last-in,first-out) es

decir el último en entrar es el primero en salir.

Las pilas apoyan las llamadas de métodos recursivas igual que lo hacen con las llamadas de

métodos convencionales no recursivas.

Las pilas contiene el espacio creado para variables automáticas en cada invocación de un

método. Cuando el método regresa a su invocador, el espacio para las variables automáticas

de ese método se saca de la pila, y el programa deja de conocer dichas variables.

Programa 2.5

Programa de estructura de datos pila

using System ; using System . Collections ; public class Pila { static int Main( string [] args ) { Stack pila = new Stack(); Boolean b = Boolean . Parse( "true" ); Char c = Char . Parse( "c" ); String s = "martin" ; Int32 i = Int32 . Parse( "7890" ); int a = 0; /*aqui ponemos los valores en la pila*/ pila . Push( b); pila . Push( c); pila . Push( s);

32

pila . Push( i ); /*aqui vemos las propiedades de la pila*/ Console . WriteLine( "La pila es LIFO(first in,last out)" ); Console . WriteLine( "Num elementos: {0}" , pila . Count ); /*imprimimos los elementos*/ IEnumerator enums = pila . GetEnumerator(); a = 0; while( enums. MoveNext()) { Console . Write( "|{0}|->{1}" , a++, enums. Current . ToString()); } Console . WriteLine( "Sacar elemento: pop()" ); pila . Pop(); /*imprimimos los elementos*/ enums = pila . GetEnumerator(); a = 0; while( enums. MoveNext()) { Console . Write( "|{0}|->{1}" , a++, enums. Current . ToString()); } Console . WriteLine( "Sacar elemento: pop()" ); pila . Pop(); /*imprimimos los elementos*/ enums = pila . GetEnumerator(); a = 0; while( enums. MoveNext()) { Console . Write( "|{0}|->{1}" , a++, enums. Current . ToString()); } Console . WriteLine( "Num elementos: {0}" , pila . Count ); return 0; } }

Compílelo:

$ mcs Pila.cs

Ejecútelo:

$ mono Pila.exe

33

2.6 Árboles Binarios

Un árbol es una estructura de datos no lineal, bidimensional, con propiedades especiales.

Los nodos de un árbol contienen 2 ó más enlaces. En los árboles binarios todos los nodos

contienen 2 enlaces (de los cuales ninguno, uno o ambos pueden ser null ). El nodo raíz es el

primer nodo de un árbol. Cada enlace del nodo raíz hace referencia a un hijo. El hijo

izquierdo es el primer nodo del subárbol izquierdo, y el hijo derecho es el primer nodo del

subárbol derecho. Los hijos de un nodo se denominan hermanos. Un nodo sin hijos es un

nodo hoja. La representación gráfica de los árboles es de la raíz hacia abajo al revés de los

árboles de la naturaleza.

Programa 2.6

Este programa se compone de 3 clases la primera clase es el nodo del árbol.

using System ; public class NodoArbol { public NodoArbol izquierda , derecha ; public int data ; public NodoArbol( int d){ data = d; izquierda = derecha = null; //este nodo no tiene hijos } public void insertar( int d){ if( d < data ){ if( izquierda == null) izquierda = new NodoArbol( d); else izquierda . insertar( d); } else if( d > data ){ if( derecha == null) derecha = new NodoArbol( d); else derecha . insertar( d); } } }

Lo compilamos como biblioteca

$ mcs /t:library NodoArbol.cs

34

La segunda es la clase Arbol que implementa la clase NodoArbol

using System ; public class Arbol { private NodoArbol raiz ; public Arbol(){ raiz = null; } public void insertarNodo( int d){ if( raiz == null) raiz = new NodoArbol( d); else raiz . insertar( d); } public void preOrdenTrasversal(){ preOrden( raiz ); } private void preOrden( NodoArbol nodo ){ if( nodo == null) return ; Console . Write( nodo . data + " " ); preOrden( nodo . izquierda ); preOrden( nodo . derecha ); } public void enOrdenTransversal(){ enOrden( raiz ); } private void enOrden( NodoArbol nodo ){ if( nodo == null) return ; enOrden( nodo . izquierda ); Console . Write( nodo . data + " " ); enOrden( nodo . derecha ); } public void postOrdenTransversal(){ postOrden( raiz ); } private void postOrden( NodoArbol nodo ){ if( nodo == null) return ; postOrden( nodo . izquierda ); postOrden( nodo . derecha ); Console . Write( nodo . data + " " ); } }

Igualmente lo compilamos como una biblioteca:

$ mcs –r:NodoArbol.dll /t:library Arbol.cs

35

Finalmente el programa de un árbol binario que realiza recorridos en: pre-orden, orden y en

post-orden.

using System ;

public class BuscarEnArbol { public static int Main( string [] args ) { Arbol arbol = new Arbol(); string valor ; int longitud ; string slongitud ; int numero ; Console . WriteLine( "Tecle el número de valores que desea introducir en el arbol: " ); do { Console . Write( "Teclee numero de filas: [MAX 33]: " ); slongitud = Console . ReadLine(); } while(! esNumero( slongitud ) || Int32 . Parse( slongitud ) > 33); longitud = Int32 . Parse( slongitud ); Console . WriteLine( "Total de valores [" + longitud + "]" ); int[] matrix = new int[ longitud ]; //aqui ponemos los valores en el arbol Console . WriteLine( "Teclee los valores: " ); for( int i = 0; i < matrix . Length ; i ++) { do { Console . Write( "Teclee el valor del elemento: [" + i +"]: " ); valor = Console . ReadLine(); } while(! esNumero( valor )); numero = Int32 . Parse( valor ); matrix [ i ] = numero ; } //aqui se insertan los valores de la matrix en el a rbol for( int i = 0; i < matrix . Length ; i ++) { arbol . insertarNodo( matrix [ i ]); } Console . WriteLine( "Elija su tipo de recorrido" ); Console . WriteLine( " a) preorden" ); Console . WriteLine( " b) enorden" ); Console . WriteLine( " c) postorden" ); Console . Write( "Su opcion:" ); char opcion = ( char) Console . Read(); switch( opcion ) { case 'a' : Console . WriteLine( "" ); arbol . preOrdenTrasversal(); break ; case 'b' : Console . WriteLine( "" ); arbol . enOrdenTransversal(); break ; case 'c' :

36

Console . WriteLine( "" ); arbol . postOrdenTransversal(); break ; default: Console . WriteLine( "" ); Console . WriteLine( "No existe esa opción" ); break ; } return 0; } //usando este metodo compruebo que solo sea //una cadena con números, sin letras ni simbolos static bool esNumero( string s) { if( s. IndexOf( "1" ) != - 1 || s . IndexOf( "2" ) != - 1 || s . IndexOf( "3" ) != - 1 || s . IndexOf( "4" ) != - 1 || s . IndexOf( "5" ) != - 1 || s . IndexOf( "6" ) != - 1 || s . IndexOf( "7" ) != - 1 || s . IndexOf( "8" ) != - 1 || s . IndexOf( "9" ) != - 1 || s . IndexOf( "0" ) != - 1) return true; else return false; } }

Lo compilamos junto con las 2 clases anteriores:

$ mcs –r:NodoArbol.dll ,Arbol.dll BuscarEnArbol.cs

2.7 Trabajo con caracteres

Una de las características fundamentales de cualquier lenguaje de programación es el

trabajo con caracteres, todo programa fuente o archivo de texto se compone de una

secuencia de caracteres que son interpretados por la computadora para poder trabajar con

ellos en cadenas o arreglos de caracteres.

Programa 2.7

El programa que muestra los métodos más usuales para convertir cadenas en arreglos de

caracteres y viceversa.

37

using System ; using System . IO ; using System . Text ; public class CFrecuencia { public static int Main( string [] args ) { //esta clase me proporciona un vectos de caracteres o de cadenas StringBuilder buf = new StringBuilder(); //aqui defino mi universo de solo caracteres char[] alfabeto = "ABCDEFGHIJKLMNOPQRSTUVWXYZ". ToCharArray(); try { if( args . Length == 1) { try { string s = "" ; //aqui uso la clase StreamReader para leer un archi vo StreamReader sr = new StreamReader( args [ 0]); while(( s = sr . ReadLine()) != null) { buf . Append( s. ToUpper()); } //aqui uso el metodo ToCharArray() para convertir u na cadena a un // arreglo de caracteres char[] miarreglo = buf . ToString(). ToCharArray(); for( int j = 0; j < alfabeto . Length ; j ++) { int contador = 0; for( int i = 0; i < miarreglo . Length ; i ++) { if( alfabeto [ j ] == miarreglo [ i ]) contador ++; } if( contador > 0) Console . WriteLine( alfabeto [ j ] + " : " + contador ); } } //aqui obtengo el error si no existe el archivo catch( FileNotFoundException e ) { Console . WriteLine( args [ 0] + ": archivo no encontrado " + e. Message ); } } else { Console . WriteLine( "Usar: mono CFrecuencia.exe [archivo de texto]" ); } } //aqui obtengo el error si no hay un argumento para el programa catch( IndexOutOfRangeException e ) { Console . WriteLine( "Usar: mono CFrecuencia.exe [archivo de texto]" + e. Message );

38

} return 0; } } //fin de la clase

Compílelo:

$ mcs CFrecuencia.cs

Ejecútelo:

$ mono CFrecuencia.exe [archivo de texto]

39

3.0 Temas prácticos

3.1 Threads (hilos)

Todos los sistemas operativos modernos permiten hacen uso de la concurrencia para hacer

varias operaciones de manera simultánea o en paralelo, una manera actual de realizar la

concurrencia es con el concepto de: Threads (hilos)

Un thread es un proceso ligero o un subproceso que tiene un simple flujo de control

secuencial, el programa principal siempre tiene un simple flujo de control.

Los métodos comúnmente utilizados por los hilos son:

Start(): Inicia la ejecución de un hilo.

Interrupt(): Interrumpe la ejecución de un hilo

Sleep(): se invoca con un argumento que invoca cuanto tiempo el hilo que se esta

ejecutando debe de dormir (en segundos).

Resume(): reanuda la ejecución de un hilo suspendido

Programa 3.1

using System ; using System . Threading ; public class HiloSimple { static int Main() { Console . WriteLine( "Preciose Ctrl+C para detener" ); Thread h1 = new Thread( new ThreadStart( kde )); Thread h2 = new Thread( new ThreadStart( gnome)); h1. Start(); h2. Start(); return 0; } static void kde() { for( int i = 0; i <= 100 ; i ++) { Console . WriteLine( "KDE esta muy bien programado -> [{0}]" , Math . Log10( i )); Thread . Sleep( 700 ); } }

40

static void gnome() { for( int i = 0; i <= 200 ; i ++) { Console . WriteLine( "Gnome es esteticamente funcional->[{0}]" , Math . Pow( i , 2)); Thread . Sleep( 700 ); } } }

Compílelo

$ mcs HiloSimple.cs

Ejecútelo:

$ mono HiloSimple.exe

3.2 Lectura y escritura de archivos

La lectura y escritura de archivos se realiza por medio de streams (flujos), un stream es una

abstracción en la cual se encapsula las operaciones de entrada y salida, siendo una manera

en la cual .NET es transportable a otros sistemas operativos e independientes del medio

físico donde se almacenen los datos.

Cuando se la entrada de datos es una conexión de red eso se convierte en un flujo de datos,

la lectura de un archivo en el disco duro es también un flujo de datos, la entrada del teclado

también se encapsula en un flujo de datos y así cada operación de entrada y salida.

Los streams tienen las siguientes operaciones:

• Stream (read) leen datos y los convierten en una estructura de bytes.

• Streams (write) escriben convirtiendo una estructura de bytes en datos.

• Streams (Seek) pueden hacer búsquedas y modificaciones en la estructura de datos.

41

Programa 3.2

Convertir un archivo de texto a un archivo HTML

using System ; using System . IO ; using System . Text ; using System . Diagnostics ; public class Txt2html { static int Main( string [] args ) { StringBuilder buf = new StringBuilder(); StringBuilder buf2 = new StringBuilder(); try { if( args . Length > 0 && args . Length < 3) { if( args [ 0] != null && args [ 1] != null) { try { StreamReader reader = new StreamReader( args [ 0]); string s = "" ; while (( s = reader . ReadLine()) != null) { buf . Append( s); } reader . Close(); buf2 . Append( "<html>" ); buf2 . Append( "<head>" ); buf2 . Append( "<title>" + args [ 0] + "</title>" ); buf2 . Append( "<body>" ); buf2 . Append( "<table width=100%><tr><td>" ); buf2 . Append( "<p align=justify>" ); buf2 . Append( "<font face=arial,helvetica size=2>" ); char[] c = buf . ToString(). ToCharArray(); for( int i = 0; i < buf . ToString(). Length ; i ++) { if( c[ i ] == ' ' ) buf2 . Append( "<br>" ); else buf2 . Append( c[ i ]); } buf2 . Append( "</font></p>" ); buf2 . Append( "</td></tr></table>" ); buf2 . Append( "</body>" ); buf2 . Append( "</html>" ); StreamWriter sw = new StreamWriter( args [ 1] + ".html" ); sw. WriteLine( buf2 . ToString()); sw. Close(); Console . WriteLine( args [ 1] + " Archivo creado" );

42

} catch( FileNotFoundException e ) { Console . WriteLine( "El archivo " + args [ 0] + " no existe " + e. Message ); } } else ayuda(); } else { ayuda(); } } catch( IndexOutOfRangeException e ) { ayuda(); Debug. WriteLine( e. Message ); } return 0; } static void ayuda() { Console . WriteLine( "Usar: mono txt2html.exe [ archivo de texto ][ arch ivo html ]" ); } }

Compílelo:

$mcs txt2html.cs

Ejecútelo:

$ mono txt2html [archivo de texto] [archivo de salida]

3.3 Utilizando el conector .NET de MySQL

Una base de datos es un conjunto de programas que dan mantenimiento de manera

ordenada y consistente a la información, estos sistemas esconden los detalles de cómo se

almacenan y se administran los datos, aun así lo datos deben de poder extraerse

eficientemente, esto ha llevado a crear unas estructuras complejas para la representación de

los datos y a unos niveles de abstracción para simplificar al usuario la interacción con el

43

sistema.

Nivel físico: El nivel más bajo de la abstracción describe como se almacenan realmente los

datos.

Nivel conceptual: describe que datos son realmente almacenados en la base de datos y la

relación que existen entre los datos.

Nivel de visión: El nivel más alto de la abstracción describe la parte más compleja, aquí se

usan las estructuras más sencillas en el nivel conceptual.

Descargar e instalar el software MySQL del sitio: http://www.mysql.com

Descargue el conector .NET de MySQL para poder conectarse con la base de datos de la

siguiente dirección: http://dev.mysql.com/downloads/connector/net/1.0.html.

La página de de descarga ofrece los archivos binarios para Windows, esto no es problema

para usuarios de Linux, ya que los binarios de .NET de Windows son soportados por Mono.

44

La archivo que contiene las clases necesarias de conexión para trabajar con MySQL es el

archivo MySql.Data.dll el cual usaremos para compilar el programa siguiente:

Programa 3.3

using System ; using MySql . Data . MySqlClient ;

public class ClienteMySQL { public static int Main( string [] args ) { string ConStr = "Falta cadena de conexion" ; string sql = "Falta Enunciado SQL" ; if( args . Length > 0) { ConStr = String . Format( "server={0};user id={1}; password={2}; database={3}; pooling=false" , args [ 0], args [ 1], args [ 2], args [ 3]); sql = args [ 4]; SQLAnali( ConStr , sql ); } else Console . WriteLine( "insuficientes, usar: ClienteMySQL.exe [server] [user id] [password] [database] [consulta SQL]" ); return 0; }

45

static void SQLAnali( string chainConn , string consultSQL ) { Console . WriteLine( chainConn ); MySqlConnection conn = new MySqlConnection( chainConn ); int columnas = 0; //if(consultSQL.StartsWith("SELECT") || consultSQL.StartsWith("select") || consultSQL.Start sWith("Select")) //{ try { conn . Open(); MySqlCommand cmd = new MySqlCommand( consultSQL , conn ); MySqlDataReader dr = cmd. ExecuteReader(); columnas = dr . FieldCount ; while ( dr . Read()) { for( int i = 0; i < columnas ; i ++) { Console . Write( dr [ i ]. ToString() + "" ); if(( i + 1) == columnas ) Console . Write( "" ); } } conn . Close(); } catch( MySqlException e ) { conn . Close(); Console . WriteLine( "No pude conectarme el error fue " + e. ToString()); } //} //else // Console.WriteLine("Solo puede utilizar la ins truccion SELECT"); } }

* Antes de compilar, asegúrese que [ MySql.Data.dll ] este en el directorio donde se

encuentra el programa o en el Global cache con el comando: gacutil -i MySql.Data.dl]

Compílelo:

$ mcs –r:MySql.Data ClienteMySQL.cs

Ejecútelo:

$ mono ClienteMySQL,exe

46

3.4 Lectura de un XML

XML son las siglas de lenguaje de marcado extensible (Extensible Markup language) es un

archivo de formato de texto simple derivado del SGML (ISO 8879). Originalmente diseñado

para las publicaciones electrónicas a gran escala, XML se ha vuelto indispensable para un

intercambio de información a través de Internet.

XML es un lenguaje de descripción de documentos, XML a diferencia de HTML permite

definir sus propias etiquetas (tags), además de que XML es un lenguaje estructural, XML es

desde un principio un lenguaje orientado a la estructura de los datos y no al diseño y

presentación de estos.

<?xml version="1.0" encoding="ISO-8859-1"?> <Directorio> <contacto>

<apepaterno> Perez </apepaterno> <apematerno> Suarez </apematerno>

nombres> Edith </nombres> <telefonos> 77-686-87 </telefonos>

email> edith@gmail.com </email> </contacto>

<contacto> <apepaterno> Perez </apepaterno> <apematerno> Suarez </apematerno> <nombres> Edith </nombres> <telefonos> 77-686-87 </telefonos>

<email> edith@gmail.com </email> </contacto> </Directorio>

Programa 3.4

Lectura de un archivo XML

using System ; using System . Data ; public class LeerXML { public static int Main( string [] args ) { try { DataSet archivoXML = new DataSet(); archivoXML . ReadXml( args [ 0]); try

47

{ foreach( DataRow t in archivoXML . Tables [ 0]. Rows) { Console . WriteLine( "" ); Console . WriteLine( t [ "apepaterno" ]); Console . WriteLine( t [ "apematerno" ]); Console . WriteLine( t [ "nombres" ]); Console . WriteLine( t [ "telefonos" ]); Console . WriteLine( t [ "email" ]); Console . WriteLine( "" ); } } catch( Exception e ) { Console . WriteLine( e. ToString()); } } catch( IndexOutOfRangeException e ) { Console . WriteLine( "Usar: mono LeerXML.exe [Archivo .xml] " + e. Message ); } return 0; } }

Compílelo: $ mcs –r System.Data

Ejecútelo: $ mono LeerXML

3.5 Usando GTK#

GTK# es la implementación completa de la plataforma GTK usando el lenguaje C#, es uno

de los más completos toolkit de diseño gráfico de aplicaciones, aunque en la plataforma .NET

de Microsoft la implementación natural es usar System.windows.forms , con mono es natural

usar GTK#, además de ser el más completo de los toolkits gráficos () que existen es de los

más transportables entre plataformas.

Programa 3.5

Un programa nslookup gráfico usando GTK#

48

using Gtk ; using System ; using System . Net ; using System . Text ; public class NSLookupGTK { /* Aqui pongo los componentes para la interfaz graf ica*/ private static Window win = null; private static VBox vb = null; private static Entry txtentrada = null; private static Button baceptar = null; private static Entry txtresultados = null; static int Main( string [] args ) { Application . Init(); //aqui inicio la aplicación win = new Window( "Mono NSLookup" ); vb = new VBox( false, 0); txtentrada = new Entry(); baceptar = new Button( "Aceptar" ); txtresultados = new Entry(); //Aqui agrego los componentes vb . PackStart( txtentrada , false, false, 0); txtentrada . Show(); vb . PackStart( baceptar , false, false, 0); baceptar . Show(); vb . PackStart( txtresultados , false, false, 0); txtresultados . Show(); win . Add( vb ); vb . Show(); win . Resize( 300 , 200 ); win . Show(); //---------------------- //aqui registro los eventos win . DeleteEvent += delete_event ; baceptar . Clicked += new EventHandler( aceptar ); Application . Run(); return 0; } static void aceptar( object o, EventArgs args ) { if( txtentrada . Text . Length > 0) { txtresultados . Text = rIP( txtentrada . Text ); } } static void delete_event( object sender , DeleteEventArgs e ) { Application . Quit(); Console . WriteLine( "Aplicacion Cerrada" ); } static string rIP( string host ) { StringBuilder buf = new StringBuilder();

49

try { IPHostEntry ip = Dns. GetHostByName( host ); IPAddress [] direccion = ip . AddressList ; for( int i = 0; i < direccion . Length ; i ++) { buf . Append( direccion [ i ]. ToString()); } return buf . ToString(); } catch( System . Net . Sockets . SocketException se ) { return "No se halla la direcion " + se . Message ; } } }

Compílelo:

$ mcs /t:winexe –pkg:gtk-sharp NSLookupGTK.cs

Como es una aplicación gráfica debe de compilarse con la opción /t:winexe esto para evitar

que aparezca la ventana de Terminal al momento de ejecutarse en un sistema gráfico.

Ejecútelo:

$ mono NSLookupGTK.exe

50

Referencias

Página del proyecto mono: http://www.go-mono.com

Titulo: Como programar en Java

Autores: Deitel & Deitel

Editorial: Prentice Hall

Titulo: C# in a Nutshell, Second Edition

Autores: Peter Drayton, Ben Albahari, Ted Neward

Editorial: O'Reilly

Titulo: Mono: A Developer's Notebook

Autores: Edd Dumbill, Niel M. Bornstein

Editorial: O'Reilly