Академический Документы
Профессиональный Документы
Культура Документы
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 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
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.
xomalli@gmail.com
4
1.0 Instalación del software
1.1 Instalación bajo Microsoft Windows
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
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.
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.
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.
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 ]
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.
16
1.3 Instalación bajo Linux
17
Al ejecutar el instalador vera la pantalla de bienvenida del software.
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.
19
Ahora el software esta listo para instalarse, si desea algún cambio pulse el botón [Atrás].
20
Si el software se ha instalado correctamente, vera la siguiente pantalla.
21
1.4 Configuración del entorno bajo Linux
Ejecute el acceso director de Mono en el escritorio.
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
}
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;
}
}
$ 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;
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;
}
$ 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;
return 0;
}
}
27
Compilelo:
$ mcs TablaT.cs
Ejecútelo:
$ mono TablaT.exe
Programa 2.4
Un programa que suma 2 matrices.
using System;
Console.WriteLine("");
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("|
|");
Console.WriteLine("| Donde matrix1[i] = matrix2[i] y matrix1[j] =
matrix2[j] |");
Console.WriteLine("|
|");
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
for (i = 0; i < filas; i++)
{
//aqui recorro las columnas
29
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];
}
}
//@ 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)
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
using System;
using System.Collections;
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();
/*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
32
2.6 Árboles Binarios
Programa 2.6
Este programa se compone de 3 clases la primera clase es el nodo del árbol.
using System;
33
La segunda es la clase Arbol que implementa la clase NodoArbol
using System;
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);
}
34
Finalmente el programa de un árbol binario que realiza recorridos en: pre-orden, orden y en
post-orden.
using System;
35
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;
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;
37
}
return 0;
}
} //fin de la clase
Compílelo:
$ mcs CFrecuencia.cs
Ejecútelo:
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;
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
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
using System;
using System.IO;
using System.Text;
using System.Diagnostics;
try
{
41
}
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;
}
Compílelo:
$mcs txt2html.cs
Ejecútelo:
$ mono txt2html [archivo de texto] [archivo de salida]
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.
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;
44
static void SQLAnali(string chainConn,string consultSQL)
{
Console.WriteLine(chainConn);
//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.
Programa 3.4
using System;
using System.Data;
46
{
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
Programa 3.5
47
using Gtk;
using System;
using System.Net;
using System.Text;
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
50