Ejemplos de C# Con Mono

Ejemplos de C# con Mono
© 2007 Martin Marquez: xomalli@gmail.com http://www.humansharp.com; version 0.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”.
2
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
3
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
4
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
5
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.
6
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.
7
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.
8
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.
9
[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.
10
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).
11
Copia de los archivos en el disco duro.
Pantalla final de la instalación.
12
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].
13
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].
14
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.
15
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.
16
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.
17
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.
18
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.
19
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.
20
Si el software se ha instalado correctamente, vera la siguiente pantalla.
Se vera el acceso directo a las herramientas de Mono en el escritorio.
21
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]
22
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
23
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";
24
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
{
25
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
26
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

{
{
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("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("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("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("NOT logico booleano (!)");
Console.WriteLine("!F: " + (!false));
Console.WriteLine("!T: " + (!true));
return 0;
}
}
27
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("| La suma dos matrices se establece solo si las matrices
a sumar son de la |");
Console.WriteLine("| misma dimension, teclee las dimensiones de la matriz 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("| Donde matrix1[i] = matrix2[i] y matrix1[j] =
matrix2[j] |");
|");
28
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 primera matriz
int[,] matrix = new int[filas,columnas];
//en el siguiente ciclo recorro la matrix bidemensional
//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 bidemensional
//primero recorro las filas
{
//aqui recorro las columnas
29
{
do
{
Console.Write("Teclee el valor del elemento: [" + i
+"]" + "["+ j + "] = ");
}
//aqui obtengo el valor
//el metodo console.Readline
regresa un string por eso hago un casting
//usando el metodo
Int32.parse(string)
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];

{
{
matrixresultado[i,j] = matrix[i,j] + matrix2[i,j];
}
}
//@ aqui se imprime el resultado
{
{
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
{
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)
30
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);
31
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();
enums = pila.GetEnumerator();
a = 0;
}
Console.WriteLine("Sacar elemento: pop()");
pila.Pop();
enums = pila.GetEnumerator();
a = 0;
}
Console.WriteLine("Num elementos: {0}",pila.Count);
return 0;
}
}
Compílelo:
$ mcs Pila.cs
Ejecútelo:
$ mono Pila.exe
32
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
33
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);
enOrden(nodo.derecha);
}
public void postOrdenTransversal(){

postOrden(raiz);
}
private void postOrden(NodoArbol nodo){

if(nodo == null)
return ;
postOrden(nodo.izquierda);
postOrden(nodo.derecha);
} }
Igualmente lo compilamos como una biblioteca:
$ mcs –r:NodoArbol.dll /t:library Arbol.cs
34
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
+"]: ");
}
matrix[i] = numero;
}
//aqui se insertan los valores de la matrix en el arbol
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':
arbol.preOrdenTrasversal();
break;
case 'b':
arbol.enOrdenTransversal();
break;
case 'c':
35
arbol.postOrdenTransversal();
break;
default:
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
{
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.
36
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 archivo
StreamReader sr = new StreamReader(args[0]);
while((s = sr.ReadLine()) != null)
{
buf.Append(s.ToUpper());
}
//aqui uso el metodo ToCharArray() para convertir una
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);
37
}
return 0;
}
} //fin de la clase
Compílelo:
$ mcs CFrecuencia.cs
Ejecútelo:
$ mono CFrecuencia.exe [archivo de texto]
38
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);
}
}
39
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.
40
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 {

{
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");
41
}
catch(FileNotFoundException e)
{
Console.WriteLine("El archivo " + args[0] + " no existe " +
e.Message);
}
}
else
ayuda();
}
else
{
ayuda();
}
}
{
ayuda();
Debug.WriteLine(e.Message);
}
return 0;
}
static void ayuda()

{
Console.WriteLine("Usar: mono txt2html.exe [ archivo de texto ][ archivo 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
42
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.
43
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

{
{
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;
}
44
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.StartsWith("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 instruccion
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
45
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

{
{
try
{
DataSet archivoXML = new DataSet();
archivoXML.ReadXml(args[0]);
try
46
{
foreach(DataRow t in archivoXML.Tables[0].Rows)
{
Console.WriteLine(t["apepaterno"]);
Console.WriteLine(t["apematerno"]);
Console.WriteLine(t["nombres"]);
Console.WriteLine(t["telefonos"]);
Console.WriteLine(t["email"]);
}
}
catch(Exception e)
{
Console.WriteLine(e.ToString());
}
}
{
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#
47
using Gtk;
using System;
using System.Net;
using System.Text;
public class NSLookupGTK

{
/* Aqui pongo los componentes para la interfaz grafica*/
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;

{
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)

{
48
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
49
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
50

Ejemplos de C# Con Mono

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Ejemplos de C# Con Mono

Cargado por

Copyright:

Formatos disponibles

Ejemplos de C# con Mono

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

Se otorga el permiso de copiar, distribuir o modificar este documento en los términos de la

Sección I Instalación del software

Instalación bajo Microsoft Windows 5

Sección III Temas prácticos

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

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

Página de descargas del software de instalación

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

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

Pantalla final de la instalación.

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

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

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

Vaya al sitio de mono http://www.go-mono.com y descargue el instalador en su directorio

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

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

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

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

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

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

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

static int Main(string[] args)

static string ImprimeDia(DiasSemana ds)

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:

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

Ejecute ahora programa ejecutable con el intérprete:

public class Recursividad

static bool esNumero(string s)

static long factorial(int n)

static long fibonacci(int n)

Compílelo usando el comando:

public class TablaT

2.4 Arreglos y Matrices

public class Matrices

for (i = 0; i < filas; i++)

Programa de estructura de datos pila

public class Pila

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

public class NodoArbol{

public NodoArbol izquierda,derecha;

public NodoArbol(int d){

public void insertar(int d){

Lo compilamos como biblioteca

public class Arbol{

public void postOrdenTransversal(){

private void postOrden(NodoArbol nodo){

Igualmente lo compilamos como una biblioteca:

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

public class BuscarEnArbol {

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

public class CFrecuencia {

} //aqui obtengo el error si no existe el archivo

$ mono CFrecuencia.exe [archivo de texto]

public class HiloSimple

static void kde()

3.2 Lectura y escritura de archivos

Convertir un archivo de texto a un archivo HTML