Taller WCF de Carlos Milán.

Taller: Introducción a Windows Communication Foundation
Autor: Carlos Milán Figueredo
Nivel: 100 (Principiante)
Pre-requisitos: Visual Studio 2008
Email: cmilanf@dotnetclubs.com
Web: http://www.dotnetclubs.com
Duración estimada: 60 minutos
Introducción
Windows Communication Foundation (WCF de ahora en adelante) es la parte del Framework
.NET dedicada a las comunicaciones. Este subsistema fue incorporado a .NET a partir de su
versión 3.0 y está disponible para sistemas basados en Windows XP, Windows 2003 y
superiores, así como dispositivos móviles equipados con el Compact Framework 3.5.
WCF unifica varios modelos de comunicación disponibles en versiones anteriores de .NET bajo
una única especificación SOA (Service Oriented Architecture).
Uno de los grandes atractivos de WCF es la facilidad con la que permite al desarrollador la
creación de servicios web interoperables y aplicaciones que hagan uso de los mismos.
En este taller vamos a utilizar Visual Studio 2008 para crear, usando WCF, un servicio web que
va a ser consumido por otra aplicación cliente.
Descripción del ejemplo: Cartelera de cine
¿Quién no ha ido alguna vez al cine? No importa si con la novia, con amigos, con la familia… Lo
más común a la hora de ir al cine es echar un vistazo a su cartelera para evaluar qué película
nos va a resultar más interesante y/o más entretenida de ver. Pero… ¿y si en el momento de
decidir con los amigos qué película ver no tenemos la cartelera a mano? ¿No sería fantástico
disponer de un servicio que nos exponga la cartelera actual en cualquier dispositivo que
tengamos en el momento? (ej: nuestro teléfono móvil)
En este taller vamos a construir un sencillo servicio de ejemplo que nos permitirá administrar
un listado de estrenos de cine que se encuentran actualmente en cartelera.
Parte 1: Creando el servicio web
¡Crear tu primer servicio web va a ser más sencillo de lo que imaginas! En primer lugar, vamos
a preparar Visual Studio 2008 para la tarea que vamos a realizar:
1. Ejecuta Visual Studio 2008.
2. Vamos a crear un nuevo proyecto “Biblioteca de servicios WCF”. Para ello sigue el
camino Menú Archivo -> Nuevo -> Proyecto… -> WCF
3. Escribe un nombre para tu proyecto y elige su ubicación. En este ejemplo podemos
usar el nombre ServicioEstrenosCine.
4. Va a ser conveniente crear también una solución, que englobe tanto el proyecto de
aplicación servicio como el cliente. El nombre de la solución podría ser
WcfEstrenosCine.
5.
Tras aceptar vemos como se nos crea el proyecto, con código de ejemplo para
ayudarnos a construir el servicio. Sin embargo como queremos empezar desde 0,
vamos a eliminar este código. En el Explorador de soluciones elimina IService1.cs y
Service1.cs.
Implementación del servicio
1. Agregamos una nueva clase a nuestro proyecto, que podemos llamar EstrenoActual.
2. La clase debe estar compuesta por el siguiente código:
using
using
using
using
using
System;
System.Collections.Generic;
System.Linq;
System.Text;
System.Runtime.Serialization;
namespace ServicioEstrenoCine
{
[DataContract]
public class EstrenoActual
{
[DataMember]
public string id;
[DataMember]
public string titulo;
[DataMember]
public string descripcion;
[DataMember]
public DateTime fecha;
}
}
Hay que prestar especial atención a los elementos [DataContract] y [DataMember] así como al
using System.Runtime.Serialization. Esta clase va a ser serializada en XML para que cuando
expongamos el servicio cualquier cliente, sin importar su arquitectura, pueda entenderla.
3. Creamos una nueva clase, cuyo nombre va a ser IEstrenosCine. En efecto, se va a
tratar de un interfaz. El código será el siguiente:
using
using
using
using
using
System;
System.Collections.Generic;
System.Linq;
System.Text;
System.ServiceModel;
namespace ServicioEstrenoCine
{
[ServiceContract]
public interface IEstrenoCine
{
[OperationContract]
int AgregarPelicula(EstrenoActual pelicula);
[OperationContract]
List<EstrenoActual> ObtenerCartelera();
[OperationContract]
int EliminarPelicula(string id);
}
}
De la misma manera que con la clase EstrenoActual estamos especificando una serie
de etiquetas adicionales: [ServiceContract], [OperationContract] y la inclusión de using
System.ServiceModel. En efecto, en esta interfaz estamos especificando las
operaciones disponibles sobre los datos de EstrenoActual. Las etiquetas permiten
exponer estos métodos en el servicio web.
4. Necesitamos una nueva clase que contenga la implementación real de la interfaz que
acabamos de diseñar. Esta será la clase EstrenosCine.
using
using
using
using
using
System;
System.Collections.Generic;
System.Linq;
System.Text;
System.ServiceModel;
namespace ServicioEstrenoCine
{
[ServiceBehavior(InstanceContextMode = InstanceContextMode.Single)]
public class EstrenoCine : IEstrenoCine
{
List<EstrenoActual> estrenos = new List<EstrenoActual>();
public int AgregarPelicula(EstrenoActual pelicula)
{
pelicula.id = Guid.NewGuid().ToString();
pelicula.fecha = DateTime.Now;
estrenos.Add(pelicula);
return 0;
}
public List<EstrenoActual> ObtenerCartelera()
{
return estrenos;
}
public int EliminarPelicula(string id)
{
foreach (EstrenoActual pelicula in estrenos)
{
if (pelicula.id == id)
{
estrenos.Remove(pelicula);
return 0;
}
}
return 1;
}
}
}
5. Llegado este punto podemos generar la solución para ver si todo ha ido bien. ¡Hemos
terminado de escribir nuestro primer servicio web!
Configuración de la conexión
Configurar la conexión es realmente sencillo y no requiere escribir más líneas de código.
1. Buscamos el archivo App.config de nuestra solución y hacemos clic en él con el botón
derecho. En el menú podremos ver la opción Editar configuración del WCF.
2. Ahora podemos ver el programa de configuración de WCF. Como al empezar el
desarrollo eliminamos el servicio por defecto, debemos seleccionar el nombre
adecuado del servicio.
3. La misma operación debe repetirse para el extremo (endpoint) del servicio:
Prueba
¡Ya tenemos nuestro servicio listo para ejecutarse! Si ahora ejecutamos el proyecto con Visual
Studio, nos aparecerá automáticamente el Cliente de prueba de WCF con el cual podremos
probar los distintos métodos que acabamos de crear.
Ahora que tenemos nuestro servicio ejecutándose, lo más lógico es que queramos
construirnos nuestro propio cliente que pueda acceder a la información y operaciones que
ofrece.
Parte 2: Creando el cliente
Sin cerrar la solución que hemos creado en la parte 1, vamos a añadir un nuevo proyecto que
se convertirá en nuestro cliente.
El nuevo proyecto será una aplicación de consola, que de nombre puede tener
ClienteEstrenosCine.
Implementación del cliente
La implementación del cliente es tan sencilla como la del servicio. Empecemos por el primer
paso:
1. Lo primero que nuestro programa necesita es saber que existe un servicio del que
puede nutrirse. Esto lo podemos conseguir añadiendo una referencia al servicio.
Desde el Explorador de soluciones y haciendo clic con el botón derecho en References
seleccionamos Agregar referencia de servicio…
2. Se nos preguntará por la dirección del servicio web. Como este servicio forma parte de
la solución global que estamos desarrollando, podemos dejar que Visual Studio lo
detecte automáticamente presionando el botón Detectar. Veremos cómo
IEstrenosCine es detectado, junto con las operaciones disponibles. Escribimos un
nombre para su espacio, por ejemplo ReferenciaEstrenosCine y aceptamos.
3. Automáticamente se descargará en nuestro proyecto el código necesario para acceder
al servicio. Podemos observar las nuevas referencias disponibles haciendo clic con el
botón derecho en ReferenciaEstrenosCine y seleccionado Ver en explorador de objetos.
4. Para poder instanciar la clase que hace de proxy con el servicio, necesitamos conocer
el nombre del extremo (endpoint). Para ello debemos ir al archivo app.config de
nuestro cliente y buscar en su declaración el parámetro name. Copiaremos su valor al
portapapeles:
<client>
<endpoint
address="http://localhost:8731/Design_Time_Addresses/ServicioEstrenosCine/Service1/"
binding="wsHttpBinding"
bindingConfiguration="WSHttpBinding_IEstrenosCine"
contract="ReferenciaEstrenosCine.IEstrenosCine"
name="WSHttpBinding_IEstrenosCine">
<identity>
<dns value="localhost" />
</identity>
</endpoint>
</client>
5. Hecho esto podemos empezar a escribir el código de nuestra aplicación cliente que
será:
using
using
using
using
using
System;
System.Collections.Generic;
System.Linq;
System.Text;
ClienteEstrenosCine.ReferenciaEstrenosCine;
namespace ClienteEstrenosCine
{
class Program
{
static void Main(string[] args)
{
int op;
EstrenoActual[] cartelera;
EstrenosCineClient cliente = new
EstrenosCineClient("WSHttpBinding_IEstrenosCine");
do
{
op = MuestraMenu();
switch (op)
{
case 1:
cliente.AgregarPelicula(NuevaPelicula());
break;
case 2:
cartelera = cliente.ObtenerCartelera();
foreach (EstrenoActual pelicula in cartelera)
{
Console.Write("\nId: {0}\n", pelicula.id);
Console.Write("Título: {0}\n", pelicula.titulo);
Console.Write("Descripción: {0}\n", pelicula.descripcion);
Console.Write("Fecha: {0}\n", pelicula.fecha.ToString());
}
Console.WriteLine("\nPresiona INTRO...");
Console.ReadLine();
break;
case 3:
Console.WriteLine("\nEscribe su ID: ");
string id = Console.ReadLine();
cliente.EliminarPelicula(id);
break;
case 0:
break;
default:
Console.Beep();
break;
}
} while (op != 0);
}
private static int MuestraMenu()
{
int resultado = -1;
Console.Clear();
Console.WriteLine("Gestor de cartelera de cine");
Console.WriteLine("===========================\n");
Console.WriteLine("\t1. Agregar película");
Console.WriteLine("\t2. Listado de películas");
Console.WriteLine("\t3. Eliminar película");
Console.WriteLine("\t0. Finalizar");
while (resultado < 0 || resultado > 3)
{
Console.Write("\nSeleccione una opción: ");
resultado = Convert.ToInt32(Console.ReadLine());
}
return resultado;
}
private static EstrenoActual NuevaPelicula()
{
EstrenoActual estreno = new EstrenoActual();
Console.Write("\nTítulo: ");
estreno.titulo = Console.ReadLine();
Console.Write("Descripción: ");
estreno.descripcion = Console.ReadLine();
estreno.fecha = DateTime.Now;
return estreno;
}
}
}
Como se puede ver al inicio del código, hemos pegado el nombre del endpoint que
teníamos en el portapapeles como parámetro a la instancia de EstrenoCineClient. La
mayor parte del código es trivial, por lo que las líneas importantes relacionadas con la
comunicación con el cliente han sido resaltadas en amarillo.
6. Llegado este punto, querremos ejecutar nuestra aplicación, pero necesitamos que
tanto el servicio como el cliente se inicien al mismo tiempo. Esto se puede configurar
en las propiedades de la solución, a las que se puede acceder haciendo clic con el
botón derecho en su nombre.
7. Marcamos ambos proyectos con opción Iniciar para que se ejecuten cuando comience
la depuración de la solución.
8. Llegado este punto, puede que no necesitemos que Visual Studio cargue su “cliente
WCF genérico” cada vez que iniciamos la depuración y en su lugar queramos que
arranque nuestro propio cliente. Es posible modificar que aplicación cliente va a
ejecutar el servidor. Para ello debemos acceder a las Propiedades del proyecto
ServiciosEstrenosCine y en la pestaña Depurar cambiar el argumento de inicio:
Una vez hecho esto, deberemos modificar de nuevo las opciones de Proyectos de inicio
múltiples para que nuestro cliente no se ejecute automáticamente al iniciar la
depuración, ya que el servicio lo hará por nosotros.