Indice general de los manuales

1. Introducción, instalación en Ubuntu y creación de una calculadora.  «  [Leyendo]
2. Modos de compartición de objetos. Creando nuestra primera calculadora distribuida.
   1. Modos de compartición de objetos: Singlecall.
   2. Modos de compartición de objetos: Singleton.
   3. Modos de compartición de objetos: CAO.
3. Canales: TCP y HTTP. Configuración en archivo XML.
4. Uso de interfaces para separar el código entre cliente y servidor.

Introducción

C# es un lenguaje de programación orientado a objetos, con una sintaxis muy similar a C++. Se diseñó con la intención de derivar las mejoras de otros lenguajes (Java, Delphi…) mezclando la posibilidad de programar en bajo nivel, y la flexibilidad de los lenguajes orientados a objetos. Entre todas la ventajas de este lenguaje, vease en wikipedia, destacamos el uso del modelo de objetos .NET (o Mono) y la portabilidad del código.

.NET Remoting (Mono Remoting) es un entorno (framework) para la creación de aplicaciones distribuidas. Como cualquier otro framework, Remoting nos ofrece una serie de servicios y mecanismos para el paso de mensajes entre objetos, creación y gestión de vida de los objetos.

El código fuente de este tutorial te lo puedes bajar desde aquí.

0. Instalación de los compiladores y el framework bajo [X]Ubuntu

Para instalar tanto el compilador de C# como el framework de Mono, abriremos una consola y escribiremos:

sudo aptitude install monodevelop mono-gmcs

Con estas instrucciones no solo instalaremos el compilador y el framework, sino también un editor gráfico para programar sobre C# y Mono.

1. Creación de una calculadora

El objetivo de esta serie de tutoriales, será ofrecer remotamente el servicio de una calculadora de diferentes modos, que veremos más adelante. Para empezar, crearemos un calculadora simple que sume, divida y haga la potencia sobre una base, y así podremos familiarizarnos con el lenguaje C#.

1. // Archivo: Calculo.cs
2. // Descripcion: Clase que simula algunas operaciones de una calculadora
3. // Biblioteca estandar
4. using System;
5.  
6. // Un espacio de nombres puede contener varias clases
7. // En este caso, tendra una llamada Calculadora
8. namespace Calculo
9. {
10.   // Clase Calculadora
11.   public class Calculadora
12.   {
13.     // Atributo para usarlo en el metodo Potencia
14.     private double laBase;
15.  
16.     // Properties: son el GET y el POST, en C#, de un atributo
17.     // y asi poderlo usarlo de esta forma: obj.Base
18.     // Nos evita, como en otro lenguajes, el uso de obj.getBase()
19.     // y obj.setBase()
20.     public double LaBase
21.     {
22.       get { return this.laBase; }
23.       set { this.laBase = value; }
24.     }
25.  
26.     // Constructor
27.     public Calculadora()
28.     {
29.       Console.WriteLine(“Constructor.”);
30.       this.laBase = 10.0;
31.     }
32.  
33.     // POST: Suma dos numeros
34.     public double Suma(double izq, double dcha)
35.     {
36.       Console.WriteLine(“Metodo: Suma.”);
37.       return izq + dcha;
38.     }
39.  
40.     // POST: Divide dos numeros
41.     // EXCEPTION: si el denominador es 0
42.     public double Divide(double numerador, double denominador)
43.     {
44.       Console.WriteLine(“Metodo: Divide.”);
45.       if (denominador == 0)
46.       {
47.         throw new Exception(“Division por 0″);
48.       }
49.       else
50.       {
51.         return (numerador / denominador);
52.       }
53.     }
54.  
55.     // POST: Eleva nuestra base al numero que le pasamos en
56.     // el argumento
57.     public double Potencia(double valor)
58.     {
59.       Console.WriteLine(“Metodo: Potencia.”);
60.       return Math.Pow(this.laBase, valor);
61.     }
62.   }
63. }

Podéis ver que he añadido algunos comentarios para seguir fácilmente el código y que he añadido trazas en el constructor y los métodos. Con estas trazas podremos comprobar en que máquina se ejecuta el código cuando hagamos la aplicación distribuida.

Ahora necesitamos el programa principal que haga uso de la calculadora:

1. // Archivo: Principal.cs
2. // Descripcion: programa principal que usa la calculadora
3. // Bibliotecas a usar:
4. using System;
5. using Calculo;
6.  
7. public class Principal
8. {
9.   public static void Main (String[] args)
10.   {
11.     Calculadora calc = new Calculadora();
12.     Console.WriteLine(“Suma 2+2 = “ + calc.Suma(2.0, 2.0));
13.     Console.WriteLine(“Potencia 10^5 = “ + calc.Potencia(5.0));
14.  
15.     try
16.     {
17.       // La division puede darnos una excepcion, por eso
18.       // la metemos en este bloque de captura de excepciones.
19.  
20.       Console.WriteLine(“Division 8/2 = “ + calc.Divide(8.0,2.0));
21.       Console.WriteLine(“Division 5/0 = “ + calc.Divide(5.0,0.0));
22.     }
23.     catch (Exception e)
24.     {
25.       Console.WriteLine(e);
26.     }
27.   }
28. }

Una vez que tenemos los dos archivos creados, “Calculo.cs” y “Principal.cs”, vamos a compilarlos. Para ello, abriremos una consola. Primero vamos a compilar el archivo “Calculo.cs” y decirle que es un archivo de biblioteca:

mcs -target:library Calculo.cs

Esto nos generará un archivo llamado “Calculo.dll”, que contendrá todas las clases que estén en el espacio de nombres “Calculo”, en nuestro caso la clase “Calculadora”. Ahora pasamos a compilar el programa principal junto con la biblioteca, para que pueda hacer uso de esta:

mcs -r:Calculo.dll Principal.cs

Y esto nos generará el archivo ejecutable “Principal.exe” (todo esto de archivos “dll” y “exe” suena un poco a Windows… aunque lo estemos haciendo en Linux). Para ejecutar el programa, simplemente lo escribimos en consola:

./Principal.exe

Y obtendremos:

Constructor.
Metodo: Suma.
Suma 2+2 = 4
Metodo: Potencia.
Potencia 10^5 = 100000
Metodo: Divide.
Division 8/2 = 4
Metodo: Divide.
System.Exception: Division por 0
at Calculo.Calculadora.Divide (Double numerador, Double denominador) [0x00000]
at Principal.Main (System.String[] args) [0x00000]

Si pruebas a ejecutar el programa bajo Windows (con las bibliotecas .NET instaladas) nos daremos cuenta de que… también funciona!!

Con esto, terminamos este primer acercamiento a C#. Ahora viene lo interesante: como hacer la aplicación distribuida.

Indice general de los manuales

1. Introducción, instalación en Ubuntu y creación de una calculadora.  «  [Leyendo]
2. Modos de compartición de objetos. Creando nuestra primera calculadora distribuida.
   1. Modos de compartición de objetos: Singlecall.
   2. Modos de compartición de objetos: Singleton.
   3. Modos de compartición de objetos: CAO.
3. Canales: TCP y HTTP. Configuración en archivo XML.
4. Uso de interfaces para separar el código entre cliente y servidor.