Práctica sobre WCF

Se definirá e implementará un contrato para un servicio WCF. El servicio emulará el cálculo de

un valor derivativo.

Un derivativo es una entidad financiera cuyo valor se deriva de otro. Por ejemplo, el valor de las
acciones de Microsoft el 11 de octubre de 2005 era $24,41. Teniendo en cuenta que este valor,
se podría ofrecer una opción para comprar 1.000 de esas acciones por $ 25 cada uno, el 11 de
noviembre de 2005. Tal opción, que es conocida como una llamada, podría ser comprada por
alguien que anticipa que el precio de las acciones superará los 25 dólares el 11 de noviembre de
2005, y vendida por alguien que anticipa que el precio de las acciones se reducirá. Esta llamada
es un derivativo, su valor se deriva del valor de Microsoft.

Asignar un precio a un derivativo es una tarea compleja. De hecho, la estimación del valor de los
derivativos es quizás el problema más conocido en la microeconomía moderna.

En el caso de nuestro ejemplo, claramente la cantidad de acciones, y los precios actuales y

pasados de las acciones de Microsoft factores a tener en cuenta, pero otros factores pueden
estar basados en el análisis de los valores de las cantidades que se cree que afectará a los precios
de las acciones, tales como los valores de los diversos índices bursátiles, o la tasa de interés de
la Reserva Federal de Estados Unidos. De hecho, se puede decir que, en general, el precio del
derivativo es alguna función de una o más cantidades, uno o más valores de mercado, y el
resultado de una o más funciones analíticas cuantitativas.

Ejercicio 1

1. Crear un Servicio para Calcular los Derivativos

Crear una nueva solución en blanco (Otros Proyectos, Solución en Blanco), llamada
CalculadoraDeDerivativos.

Agregar un nuevo proyecto de tipo Biblioteca de Clase de C#, denominada

ServicioCalculadoraDerivativos a la solución.

2. Agregar una referencia en el proyecto de tipo Biblioteca de Clase a WCF

Agregar una referencia al Assembly System.ServiceModel. Botón derecho sobre el proyecto,

agregar referencia, escoger System.ServiceModel (pestaña .NET).

3. Definir el contrato del servicio

Renombrar el archivo de clase, de Class1.cs a ICalculadoraDerivativo.cs.

Modificar el archivo con el siguiente código:

using System;
using System.Collections.Generic;
using System.Linq;
using System.ServiceModel;
using System.Text;

namespace ServicioCalculadoraDerivativos
{
[ServiceContract]
public interface ICalculadoraDerivativos
{
 [OperationContract]
Decimal CalcularDerivativo(int dias, string[] simboloss, string[]
funciones);

}
}

4. Implementar el contrato del servicio

Agregar una clase, denominada Calculadora.cs al proyecto, modificar el contenido con el código:
using System;
using System.Collections.Generic;
using System.Linq;
using System.ServiceModel;
using System.Text;

namespace ServicioCalculadoraDerivativos
{
public class Calculadora : ICalculadoraDerivativos
{
#region Miembros de ICalculadoraDerivativos

public decimal CalcularDerivativo(int dias, string[] simboloss, string[]

funciones)
{
return (decimal)(System.DateTime.Now.Millisecond);
}

#endregion

}
}

5. Construya el proyecto

Construya el proyecto. Si se construye sin errores, la implementación del contrato para el

servicio está correcta. Sino revise todos los pasos anteriores.

Ejercicio 2

1. Agregar un Proyecto de Aplicación de Consola a la solución

Agregar un Proyecto de Aplicación de Consola a la solución, denominado Anfitrion.

2. Agregar una referencia a WCF

Agregar una referencia al Assembly System.ServiceModel. Botón derecho sobre el proyecto,

agregar referencia, escoger System.ServiceModel (pestaña .NET).

3. Agregar una referencia al servicio WCF

Agregar una referencia al servicio ServicioCalculadoraDerivativos. Botón derecho sobre el

proyecto, agregar referencia, escoger ServicioCalculadoraDerivativos (pestaña Proyectos).

4. Agregar código para poder ofrecer el servicio WCF

Modificar la clase Program.cs en el proyecto Anfitrion de la siguiente manera:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;

using ServicioCalculadoraDerivativos;

namespace Anfitrion
{
class Program
{
static void Main(string[] args)
{
using (ServiceHost anfitrion = new ServiceHost(typeof(Calculadora),
new Uri("http://localhost:8080/Derivativos/Calculadora")))
{
anfitrion.Open();
Console.WriteLine("El servicio de Calculadora de Derivativos está
corriendo... Para terminar presione una tecla");
Console.ReadKey();
}
}
}
}

5. Configurar el anfitrión

Agregar un archivo de configuración denominado app.confg al proyecto Anfitrion.

Modificar el archivo app.config de la siguiente manera:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<system.serviceModel>
<services>
<service name="ServicioCalculadoraDerivativos.Calculadora"
behaviorConfiguration="NewBehavior0">
<endpoint address="http://localhost:8080/Derivativos/Calculadora"
binding="basicHttpBinding"

contract="ServicioCalculadoraDerivativos.ICalculadoraDerivativos"/>
</service>
</services>
<behaviors>
<serviceBehaviors>
<behavior name="NewBehavior0">
<serviceMetadata httpGetEnabled="true" />
</behavior>
</serviceBehaviors>
</behaviors>
</system.serviceModel>
</configuration>

6. Probar el servicio

Construir la solución.

Establecer como proyecto por defecto al Anfitrion

Ejecutar el proyecto

En el explorador web, ingresar a: http://localhost:8080/Derivativos/Calculadora

Ejercicio 3

1. Agregar un segundo Proyecto de Aplicación de Consola a la solución

Agregar un Proyecto de Aplicación de Consola a la solución, denominado Cliente.

2. Generar el proxy

Abra el explorador de Windows, diríjase a la carpeta debug del Anfitrión y ejecute el anfitrión
como Administrador.

En las propiedades del Cliente, clic derecho y escoger Agregar Referencia de Servicio...

Ingresar como Dirección la URL del servicio http://localhost:8080/Derivativos/Calculadora

Establecer el nombre de referencia del servicio como ServicioDerivativos

Al aceptar, se creará un archivo app.config y un archivo Calculadora.map. El archivo app.config

contiene la información requerida por el cliente para comunicarse con el servicio y el archivo
map contiene la clase proxy para el servicio.

3. Código para consumir el Servicio

Modificar el código del cliente de la siguiente forma:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Cliente.ServicioDerivativos;

namespace Cliente
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Presionar una tecla para iniciar...");
Console.ReadKey();

CalculadoraDerivativosClient proxy = new

CalculadoraDerivativosClient();
decimal resultado = proxy.CalcularDerivativo(3, new string[] { "MSFT"
}, new string[] { });
proxy.Close();
Console.WriteLine(string.Format("Resultdado: {0}", resultado));

Console.WriteLine("Presione una tecla para continuar...");

Console.ReadKey();

}
}
}
 4. Pruebe la solución completa

Inicie el cliente y el anfitrión.

En el cliente, digite una tecla para obtener el valor del servicio.

Ejercicio 4

Implemente en el servicio las siguientes funcionalidades:

 Decimal Suma(Decimal x, Decimal y)

 Decimal Resta(Decimal x, Decimal y)
 Decimal Multiplicación(Decimal x, Decimal y)
 Decimal Division(Decimal x, Decimal y)

La operación división en caso de que y será 0 debe retornar cero.

Ejercicio 5

Creación de un servicio web para determinar la capital de un país.

1. Cree una nueva solución, con un proyecto de Biblioteca de Servicio WCF, denominada
ServicioCapitales.
2. Elimine los archivos IService1.cs y Service1.cs
3. Agregue un archivo de Interfaz denominado IInformacionPais.cs, modifique su
contenido con el siguiente:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using System.ServiceModel;

namespace ServicioCapitales
{
[ServiceContract]
interface IInformacionPais
{
[OperationContract]
string ObtenerCapital(string pais);
}
}

4. Agregue un archivo de clase denominado InformacionPais.cs, modifique su contenido

con el siguiente, el servicio será de tipo PerCall:
using System.ServiceModel;

namespace ServicioCapitales
{
[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall)]
class InformacionPais : IInformacionPais
{
public string ObtenerCapital(string pais)
 {
Console.WriteLine("Contactando al servidor....");
if (pais == "Ecuador")
return "Quito";
else if (pais == "Colombia")
return "Bogota";
return "Pais Desconocido";
}
}
}

public class Program

{
private static System.Threading.AutoResetEvent eventoTerminacion = new
System.Threading.AutoResetEvent(false);

public static void Main()

{
ServiceHost anfitrion = new
ServiceHost(typeof(ServicioCapitales.InformacionPais));
anfitrion.AddServiceEndpoint(typeof(ServicioCapitales.IInformacionPais),
new NetTcpBinding(), "net.tcp://localhost:8080");
anfitrion.Open();
Console.WriteLine("Servidor corriendo");
eventoTerminacion.WaitOne();
Console.WriteLine("Servidor está apagándose");
anfitrion.Close();
Console.WriteLine("Servidor detenido");
}

public static void StopServer()

{
eventoTerminacion.Set();
}

5. Construya el proyecto y determine en donde está la DLL generada. En caso de

presentarse advertencias, indicar que se desea continuar con la ejecución.
6. Genere un proyecto de consola, agregue la referencia a la DLL construida
anteriormente. Modifique el archivo Program.cs con lo siguiente:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using System.ServiceModel;
using ServicioCapitales;

namespace Cliente
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Uso de WCF");
System.Threading.Thread servidor = new
System.Threading.Thread(ServicioCapitales.Program.Main);
servidor.IsBackground = true;
servidor.Start();
 System.Threading.Thread.Sleep(100);

ChannelFactory<ServicioCapitales.IInformacionPais> canal;
canal = new ChannelFactory<ServicioCapitales.IInformacionPais>(
new NetTcpBinding(),
"net.tcp://localhost:8080");
ServicioCapitales.IInformacionPais interfaz;
interfaz = canal.CreateChannel();

while (true)
{
Console.Write("Ingrese un país: ");
string pais = Console.ReadLine();
if (pais == "")
break;
string capital = interfaz.ObtenerCapital(pais);
Console.WriteLine("La capital es: " + capital);
}

(interfaz as ICommunicationObject).Close();

ServicioCapitales.Program.DeternerServidor();

}
}
}

7. Pruebe el cliente generado.

8. Agregue más funcionalidad al servicio. Los métodos deben ofrecer respuesta para los
países: Ecuador, Colombia, Perú, México, Estados Unidos, Alemania. El servicio debe
tener los métodos:
 string IndicarPais(string capital)
 string IndicarMoneda(string pais)
9. Agregar un mecanismo que genere a partir de un rango, los números primos en el rango,
así como su cantidad:
 int ObtenerCantidadDePrimos(inicio, fin)
 ArrayList EncontrarPrimos(inicio, fin)
10. Comente el código, no olvide las cabeceras en cada archivo.