PDF de programación - Curso 2014 2

Introducción
En nuestra segunda práctica vamos a utiliza un middleware llamado .Net Remoting.
Este es un entorno (framework) para la construcción de sistemas distribuidos. Como
cualquier framework de esta naturaleza, .Net Remoting nos aporta una serie de
servicios (incluyendo la creación y gestión del tiempo de vida de los objetos) y
mecanismos para el transporte de los mensajes entre objetos que se denominan
canales.

Nuestra intención con esta práctica es valorar la transparencia que nos ofrece el
middleware. En los middleware modernos es habitual ocultar la presencia del mismo
y evitar lo máximo posible la modificación de los programas. Veamos un primer
ejemplo de un sistema distribuido construido con este middleware.

Curso de Middleware. Práctica 2.

1 de 19

Segundo ejemplo: una aplicación distribuida
Retomemos nuestra primera aplicación para convertirla en una aplicación distribuida.
Lo que queremos hacer es que nuestro antiguo programa principal actúe de cliente de
un servidor que ofrezca servicios de calculadora. Lo que vamos a construir son dos
ejecutables (un cliente y otro servidor) que utilizan los servicios de una librería con la
calculadora.
Por lo tanto, antes de seguir, vamos a preparar una solución de Visual Studio que
tenga tres proyectos. Dos proyectos será de tipo “Aplicación de Consola” y el tercero
será una “librería de clases”. La creación del proyecto es muy similar a lo visto en la
práctica anterior. Os recomiendo que le pongamos nombres que sean representativos.
Por ejemplo, nombremos a los proyectos “Servidor”, “Cliente” y “Calculo”. No
detallamos el proceso de creación de estos proyectos. Antes de continuar
comprobemos que tenemos algo similar a lo que muestra la siguiente imagen:



Durante la creación automática de los proyectos se habrán creado clases y programas
por defecto que podemos renombrar o rehacer para adaptarlos a nuestras necesidades.
El siguiente paso es volver a poner nuestra calculadora en el proyecto que hemos
llamado Calculo. Podemos hacer copiar/pegar de la práctica anterior. Pero ahora
necesita una pequeña modificación. Tenemos que indicar al sistema que nuestra clase
pasa a ser un objeto remoto. Para ello, hacemos heredar la clase de otra llamada
“System.MarshalByRefObject”. Por ejemplo:

Curso de Middleware. Práctica 2.

2 de 19

// Calculadora.cs
using System;
namespace Calculo
{
public class Calculadora : System.MarshalByRefObject
{
... el resto del código ...
}
}

Con esto le estamos indicando al sistema que la clase puede ser “un objeto remoto”.
Es decir, que podemos crear una referencia o puntero al objeto remoto, aunque en
lugar de almacenar una dirección de memoria habitual, se utilizará información más
compleja (máquina, servicio, etc.). Es la forma que tiene el cliente de acceder a la
información del objeto almacenada en el servidor.
También necesitaremos un servidor que atienda las peticiones de los clientes y que sea
el que realmente cree el objeto de tipo Calculadora. Los clientes harán llamadas a la
calculadora, pero esas llamadas serán ejecutadas en el proceso servidor (que incluso
podrá estar otra máquina diferente).
En ese programa pondremos un código similar al siguiente:

// Program.cs
using System;
using System.Runtime.Remoting;

namespace Servidor
{
class Program
{
static void Main(string[] args)
{
RemotingConfiguration.Configure("Servidor.exe.config",
false);

Console.WriteLine("Atendiendo las peticiones...");
Console.WriteLine("Pulse Enter para salir...");
Console.ReadLine();
}
}
}

Para que el servidor compile debemos acordarnos que tenemos que incluir el “using”
correspondiente a “System.Runtime.Remoting”. También tenemos que incluir la

Curso de Middleware. Práctica 2.

3 de 19

referencia a la librería “Calculo”. Veamos cómo dar esos dos pasos:

y,

Ahora tenemos que editar el fichero de configuración del servidor. Para ello debemos
editar el fichero que aparece en el proyecto llamado “App.config”. Este fichero
cambia de nombre cuando VisualStudio compila el proyecto. Le llama según el
nombre del ejecutable que tenga el proyecto. En nuestro caso, si todo ha sido correcto,
VisualStudio lo renombrará a “Servidor.exe.config”. Podéis comprobarlo si entráis en
el directorio “bin/Debug” que existe dentro del directorio de trabajo de vuestro
proyecto.

Curso de Middleware. Práctica 2.

4 de 19

Cuando abramos el fichero “App.config” seguramente veamos algo parecido a:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<startup>
<supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5"
/>
</startup>
</configuration>

En ese fichero ahora debemos insertar los parámetros de configuración de nuestro
servidor. Debemos editarlo para que sea similar al siguiente (he marcado en color la
parte que debemos añadir):

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<system.runtime.remoting>
<application>
<service>
<wellknown
mode="SingleCall"
type="Calculo.Calculadora, Calculo"
objectUri="Calculadora.remota"
/>
</service>
<channels>
<channel ref="http" port="1234"/>
</channels>
</application>
</system.runtime.remoting>
<startup>
<supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5"
/>
</startup>
</configuration>

Como podemos observar el fichero de configuración tiene una estructura típica de
XML. El primer nivel le indica que es un fichero de configuración y el segundo (el
elemento <system.runtime.remoting>) que la configuración se refiere al sistema de
remoting. Vemos también que hay un punto donde indicamos el tipo de protocolo a

Curso de Middleware. Práctica 2.

5 de 19

utilizar (http) y el puerto (1234) en el que escuchará el servidor.
Es importante que pongas correctamente los nombres de la librería y de tu objeto en la
entrada “<wellknown/>” del fichero de configuración. Si tienes algún problema,
consulta en la ayuda o en el web de Microsoft (MSN). No vamos a detallar el esquema
de estos ficheros de configuración ya que son propios de .Net Remoting y nuestro
interés es entender el comportamiento de los Middleware en general.
Por el momento, vamos a compilar y a lanzar el servidor para estar seguros de que
todo es correcto. Si todo va bien, tendremos que ver algo parecido a la siguiente
pantalla:

Ahora vamos a pasar a desarrollar nuestro cliente. En el fichero “Program.cs” del
proyecto “Cliente” debemos incluir un código muy parecido al programa principal que
teníamos de nuestra anterior práctica. Simplemente, hemos añadido una línea para la
configuración de Remoting. El código debería ser parecido a lo siguiente:

Curso de Middleware. Práctica 2.

6 de 19

using System;
using System.Runtime.Remoting;

using Calculo;
using System.Threading;

namespace Cliente
{
class Program
{
public static void Main(string[] args)
{
Thread.Sleep(2 * 1000); // Esto es para darle tiempo al
servidor a que arranque

Console.WriteLine("Esto es una prueba de calculadora");
RemotingConfiguration.Configure("Cliente.exe.config", false);

Console.WriteLine("Creando la calculadora");
Calculadora calc = new Calculadora();

Console.WriteLine("Prueba de suma 5+3=" + calc.Suma(5, 3));
Console.WriteLine("Prueba de producto 5*3=" + calc.Producto(5,
3));

Console.WriteLine("Pulse Enter para salir...");
Console.ReadLine();
}
}
}

Al igual que antes, para que nuestro proyecto compile y funcione, tenemos que incluir
los “using” correspondientes y la referencia al proyecto “Calculo”. Observad que el
fichero de configuración que se carga en la llamada a “Configure” es ahora “
Cliente.exe.config”. De nuevo, debemos editar el fichero “App.config” y confiemos
en que VisualStudio cambie el nombre correctamente. Para el cliente, el fichero de
configuración debe ser algo de este estilo:

Curso de Middleware. Práctica 2.

7 de 19

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<system.runtime.remoting>
<application>
<client>
<wellknown
type="Calculo.Calculadora, Calculo"
url="http://localhost:1234/Calculadora.remota"
/>
</client>
</application>
</system.runtime.remoting>
<startup>
<supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5"
/>
</startup>
</configuration>

Para probar nuestro ejemplo ahora tenemos que arrancar tanto el servidor como el
cliente. Tenemos dos formas de hacer esto. Una es entrar en los directorios
“bin/Debug” de cada proyecto y lanzar desde dos consolas diferentes (y por lo tanto
desde fuera de VisualStudio) los ejecutables “Servidor.exe” y “Cliente.exe”.
Si queremos hacerlo desde VisualStudio debemos entrar en las propiedades de la
solución y seleccionar arranque de múltiples proyectos. Deberíamos ver una pantalla
similar a la siguiente:

En estos momentos ya estamos en disposición de arrancar nuestros ejecutables y
comprobar si el funcionamiento es el esperado. Si todo es correcto, deberíamos

Curso de Middleware. Práctica 2.

8 de 19

observar la siguiente pantalla:

Pulsando “enter” en ambas pantallas cerramos las mismas y terminamos la ejecución.
Aparentemente no parece que hayamos hecho nada diferente a nuestra práctica
anterior, pero vamos a retomar nuestras antiguas trazas para comprobar si las
operaciones matemáticas de la calculadora se ejecutan en el cliente o en el servidor.
Se admiten apuestas!!
Después de incluir trazas en l