Servicios Web con WCF

Una sencilla introducción a los Servicios Web con WCF

Willy Mejía
Junio 2008

Microsoft .NET Framework 3.0 (aka NetFx3, antes WinFX) introdujo a WCF (Windows Communication Foundation) como una ventanilla única para la creación de todo tipo de servicios distribuidos sobre la plataforma .NET, que incluye pero no se limita a los Servicios Web.

El siguiente cuadro muestra algunas clases importantes para WCF.

Elemento	Clase o Interfaz
Address	System.Uri
Binding	System.ServiceModel.Binding
Contract	System.ServiceModel Attributes
Endpoint	System.ServiceModel.ServiceEndpoint

El presente artículo muestra cómo utilizar las clases y herramientas de WCF para crear y publicar un sencillo Servicio Web así como su cliente. Para lo cual se requiere tener instalado NetFx3 —o bien .NET Framework 3.5— con su correspondiente SDK.

Nota: Para una breve introducción a los Servicios Web puede leer: Guía Breve de Servicios Web.

Creando un Servicio Web muy simple

Para ilustrar la creación de Servicio con WCF emplearemos el clásico ejemplo de Hola Mundo, el cual luce así:

Listado de Hello.cs

using System;
using System.Text;
using System.ServiceModel;

namespace hello
{
  [ServiceContract(Namespace="http://hello/")]
  [ServiceBehavior(Namespace="http://hello/", Name="HelloService")]
  public class Hello
  {
    private StringBuilder message = new StringBuilder("Hola ");

    [OperationContract]
    public string SayHello(string name)
    {
      if (name == null || name.Trim().Length == 0)
        throw new FaultException("El parámetro 'name' es nulo o vacío.");
      string msg = message.Append(name + "!").ToString();
      System.Console.WriteLine(msg);
      return msg;
    }
  }
}

Nota: La parte del código en color gris puede omitirse para simplicidad del ejemplo, no obstante sirve de introducción al tema de excepciones en servicios web.

Nótese que luce como una clase normal pero con algunas adiciones: En primer lugar declaramos la utilización del namespace System.ServiceModel dentro del cual se encuentran las clases atributo con las cuales marcamos la clase Hello como el contrato del servicio (atributo ServiceContract) y al método SayHellocomo una operación del mismo (atributo OperationContract). Con esto habilitamos la clase para que pueda comportarse como un Servicio WCF el cual posteriormente publicaremos como un Servicio Web. Finalmente el atributo ServiceBehavior especifica el comportamiento de ejecución de una implementación del contrato de servicio, es éste caso sólo lo empleamos para especificar lo que será el «targetNamespace» y «name» del servicio para la exportación de la definición del mismo a través de WSDL.

Por último note la excepción de tipo FaultException utilizada para enviar un mensaje de error (un mensaje «SOAP Fault») hacia el cliente cuando el mismo envíe el parámetro name nulo o vacío.

Solo resta compilar la clase, asegurándonos de referenciar al ensamblado System.ServiceModel.dll:

>csc /t:library Hello.cs /r:System.ServiceModel.dll

Con lo anterior ya tenemos un sencillo Servicio WCF casi listo para ser alojado y desplegado como un Servicio Web dentro de un Sitio Web ASP.NET, no obstante podemos probarlo sin necesidad de recurrir a IIS (o Cassini) si creamos un Endpoint dentro de una aplicación de consola que actuará como host del servicio, tal como se ilustra en el siguiente código:

Nota: Para revisar otras opciones de «alojamiento» de servicios WCF consultar: Alojando Servicios.

Listado de HelloHost.cs

using System;
using System.ServiceModel;

class HelloHost
{
  static void Main(string[] args)
  {
    string endpointAddress = "http://localhost:8080/hello";
    ServiceHost myServiceHost = 
      new ServiceHost(typeof(hello.Hello), new Uri(endpointAddress));
    myServiceHost.Open();
    System.Console.WriteLine("El Servicio Web Hello se está ejecutando...");
    System.Console.WriteLine("WSDL: " + endpointAddress + "?wsdl");
    System.Console.WriteLine("Presione una tecla para cerrarlo.");
    System.Console.ReadKey();
    if (myServiceHost.State != CommunicationState.Closed)
      myServiceHost.Close();
  }
}

Nótese que se trata de una simple aplicación de consola que utiliza una instancia de la clase ServiceHost para crear un endpoint para un servicio de tipo HelloService.Hello en la dirección (Address) http://localhost:8080/Hello. Esto último gracias a que la clase ServiceHost utiliza la información proporcionada tanto en el código como en el archivo de configuración —que veremos a continuación— para crear y publicar un ServiceEndpoint.

Por lo que el siguiente paso es crear el archivo de configuración (que se vinculará al ejecutable de HelloHost) con el siguiente contenido:

Listado de HelloHost.exe.config

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.serviceModel>
    <services>
      <service name="hello.Hello" behaviorConfiguration="enableMetadata">
        <endpoint contract="hello.Hello" binding="basicHttpBinding" 
                bindingNamespace="http://hello/" name="HelloPort" />
        <endpoint contract="IMetadataExchange" binding="mexHttpBinding" address="mex" />
      </service>
    </services>
    <behaviors>
      <serviceBehaviors>
        <behavior name="enableMetadata" >
          <serviceMetadata httpGetEnabled="true" />
        </behavior>
      </serviceBehaviors>
    </behaviors>
  </system.serviceModel>
</configuration>

Observe que en éste caso la clase hello.Hello sirve tanto para definir la clase de implementación del servicio como su contrato, es por ello que aparece tanto en el atributo name del elemento service, como en el atributo contract del elemento endpoint. En un artículo posterior veremos que esto se puede realizar de forma separada utilizando una interfaz como contrato.

Lo siguiente a destacar es la línea:

<endpoint contract="hello.Hello" binding="basicHttpBinding" ... />

En la cual se especifica tanto la clase/interfaz que define al servicio (Contract), así como la forma de enlace (Binding) con el endpoint, cuya ubicación en la red (Address) se definió en el código de HelloHost. Estos tres elementos: Address, Binding & Contract, constituyen el ABC de los Endpoints de WCF. Para más información al respecto consultar: Endpoints: Address, Bindings and Contracts.

El enlace de tipo basicHttpBinding representa la forma de enlace que el servicio WCF utiliza para configurar y exponer su correspondiente endpoint de modo que el servicio pueda comunicarse como un Servicio Web (basado en ASMX) que cumple con el WS-I Basic Profile 1.1.

Los enlaces o bindings se utilizan para especificar el transporte, la codificación de mensajes y los detalles de protocolo requeridos para los clientes y servicios para comunicarse entre sí. WCF proporciona una variedad de Bindings, de entre los cuales cuatro admiten transporte HTTP por lo que se utilizan para Servicios Web: basicHttpBinding, wsHttpBinding, wsDualHttpBinding y wsFederationHttpBinding. Los tres últimos admiten además diferentes protocolos WS-* para Servicios Web seguros e interoperables.

Binding	Interop	Seguridad	Duplex	WS-AT / WS-RM
basicHttpBinding	Basic	Ninguna, HTTPS	n/a	No
wsHttpBinding	WS	WS-Security, HTTPS	n/a	Sí
wsDualHttpBinding	WS	WS-Security, Ninguna	Sí	Sí
wsFederationHttpBinding	Federation	WS-Security, Ninguna	No	Sí

WS-AT = WS-AtomicTransaction, WS-RM = WS-ReliableMessaging

Para más información consultar: Bindings proporcionados por el sistema, donde además se listan otros Bindings para .NET Remoting y MSMQ.

Los atributos del endpoint bindingNamespace y name sirven para especificar el «targetNamespace» y «name» del enlace para la definición a través de WSDL.

Nota: El resto de la configuración (de color oliva) sirve para habilitar la exposición de los Metadatos del servicio, de modo que se pueda tener acceso al WSDL generado bajo demanda. No es necesaria para poder consumir el servicio, por lo que si se facilita el WSDL por otra vía bien podría omitirse dicha configuración extra.

Una vez elaborado el archivo de configuración solo resta compilar y ejecutar HelloHost, el cual mostrará unas líneas indicando que el servicio se está ejecutando, así como la ubicación del documento WSDL del mismo para cualquier cliente que desee consumirlo.

>csc /t:exe HelloHost.cs /r:System.ServiceModel.dll,Hello.dll

>HelloHost.exe

El Servicio Web Hello se esta ejecutando...
WSDL: http://localhost:8080/hello?wsdl
Presione una tecla para cerrarlo.

Nota: Se requiere de una cuenta con privilegios de Administrador para ejecutar el host, o bien para modificar los derechos de la reserva para una parte del espacio de nombres HTTP. Para más información consulte: Configuración de los elementos de enlace de transporte HTTP y HTTPS para WCF.

Lo siguiente a realizar, es crear un cliente que lo consuma…

Creando un Cliente muy simple para un Servicio Web muy simple

Ahora crearemos —en un directorio/proyecto distinto— el cliente para nuestro Servicio Web el cual debe estar publicado y en ejecución.

Pero primero necesitamos generar los artefactos cliente. Para ello utilizaremos la herramienta svcutil (Herramienta de utilidad de metadatos de ServiceModel) incluida en el Windows SDK for .NET Framework 3.x, a la cual le pasamos como argumento la ubicación del documento WSDL:

>svcutil http://localhost:8080/hello?wsdl /out:Hello.cs /config:Client.exe.config /n:http://hello/,hello

Esto generará un archivo con la clases proxy las cuales encapsularán la invocación de las operaciones del Servicios Web. En nuestro caso se generará el archivo Hello.cs (con la clase HelloClient que utilizaremos directamente en la aplicación cliente) así como el archivo de configuración Client.exe.config, de modo que coincida con el nombre del ejecutable de la aplicación cliente.

Una vez generados los artefactos cliente (proxy) solo resta crear la aplicación cliente en sí, nuevamente una simple aplicación de consola:

Listado de Client.cs

using System;

public class Client
{
  static void Main(string[] args)
  {
    string arg = null;
    string result = null;
    if (args.Length > 0) {
      arg = args[0];
    }
    else {
      // Comentar para obtener el FaultException...
      arg = "Anónimo";
    }
    try {
      hello.HelloClient service = new hello.HelloClient(); 
      result = service.SayHello(arg);
    }
    catch (System.ServiceModel.FaultException fault) 
    { 
      result = fault.Message; 
    }
    catch (Exception ex) {
      result = ex.ToString();
    }
    finally{
      System.Console.WriteLine(result);
    }
  }
}

Nótese que para invocar la operación de nuestro Servicio Web primero creamos una instancia de la clase HelloClient (generada por svcutil) por medio de la cual después invocamos al método SayHello —y tras del cual se invoca la operación del Servicio Web, el cual a su vez invoca el método correspondiente de la clase Hello implementada al inicio del artículo…

Solo resta compilar tanto el proxy como la aplicación cliente:

>csc /t:library Hello.cs

>csc /t:exe Client.cs /r:Hello.dll

Después ejecute la aplicación cliente con algún argumento, su nombre por ejemplo, si no se especifica argumento alguno la salida será «Hola Anónimo»:

>Client Willy

Hola Willy!

La misma salida se desplegará en la consola del servicio.

Creando un Cliente Java muy simple…

Como ejercicio final crearemos un cliente Java (utilizando JAX-WS) para el Servicio Web, el cual es prácticamente el mismo cliente del artículo Servicios Web con Java SE 6.0.

Primero necesitamos generar los artefactos cliente. Para ello utilizaremos la herramienta wsimport incluida en Java SE 6.0, a la cual le pasamos como argumento la ubicación del documento WSDL:

>wsimport http://localhost:8080/hello?wsdl

Una vez generados los artefactos cliente solo resta crear el cliente en sí, nuevamente una simple aplicación de consola:

Listado de Client.java

public class Client {
  public static void main(String[] args) {
    String arg = null;
    String result = null;
    if (args.length > 0) {
      arg = args[0];
    }
    else {
      arg = "Anonimo";
    }
    try {
      hello.HelloService service = new hello.HelloService();
      hello.Hello port = service.getHelloPort();
      result = port.sayHello(arg);
    }
    catch (Exception ex) {
      result = ex.toString();
    }
    finally{
      System.out.println(result);
    }
  }
}

Tal como puede apreciarse, la razón para nombrar al servicio como HelloService y su endpoint como HelloPort fue para que coincidiera con el Servicio Web elaborado en Java en el artículo anteriorermte citado y así se pudiese reutilizar el código del cliente. No obstante de no haberlo hecho el código del cliente cambiaría en algo como:

hello.Hello_Service service = new hello.Hello_Service();
hello.Hello port = service.getBasicHttpBindingHello();

Finalmente compilamos y ejecutamos nuestro cliente con algún argumento:

>javac Client.java

>java Client Java

Hola Java!

La misma salida se desplegará en la consola del servicio.

Epílogo

Con lo que hemos realizado vemos lo fácil que es crear y publicar un Servicio Web así como su cliente con WCF.

No obstante todo esto tan sólo fue el inicio, la finalidad fue dar una introducción al desarrollo de Servicios Web utilizando WCF esperando le motive a continuar para después «emplearse en la Fábrica». Quedan entonces muchas cosas por tratar, como crear un servicio y cliente a partir de un WSDL, el alojamiento y despliegue en IIS, utilizar contratos tanto de servicios, como de mensajes y de datos, Interoperabilidad y WS-*, etc…

Espero que sirva de algo y hasta la próxima,
Willy Mejía.

P.D.
Como continuación del presente artículo he escrito >> WCF bajo Contrato: Una práctica introducción a los Contratos de WCF.