Creando un Web Service con WCF

Windows Communication Foundation fue una de las novedades de .NET Framework 3.0, la cual permite la creación de sistemas distribuidos orientados a servicios.
Con Visual Studio 2008, disponemos de una plantilla que nos genera todo lo necesario para empezar a trabajar con ello. No obstante, en esta ocasión, dejaremos de lado la misma para poder visualizar claramente qué es lo necesario para que WCF funcione.

CREACIÓN DEL PROYECTO

Creamos un nuevo proyecto de tipo librería:

Incluimos las librerías System.ServiceModel y System.Runtime.Serialization.

EL CONTRATO (CONTRACT)

Lo primero que debemos crear es una interfaz que tendrá como misión ser el Contrato del servicio web. Lo que nos indica el mismo es qué funcionalidades tiene operativas el servicio de cara a las aplicaciones que lo van a consumir.
Creamos una interfaz llamada IService.cs y codificamos las siguientes funcionalidades:

using System.ServiceModel;
using System.ServiceModel.Web;
using System.Runtime.Serialization;

namespace WCF
{
    [ServiceContract]
    public interface IService
    {
        [OperationContract]
        [WebGet]
        Resultado Suma(int a, int b);

        [OperationContract]
        [WebGet]
        Resultado Resta(int a, int b);
    }

   [DataContract]
    public class Resultado
   {
       [DataMember]
       public int Result { get; set; }
   }
}

Tenemos los siguientes atributos:

* ServiceContract, el cual indica que nuestra interfaz va a hacer las veces de contrato.
* OperationContract por cada método que queramos exponer.
* Por último, dentro del mismo archivo (No es recomendable) hemos creado una pequeña clase con el atributo DataContract que será el objeto serializado que viajará como respuesta a las peticiones tanto de la Suma como la Resta. Por cada miembro dentro del contrato de datos, contiene un DataMember.

Es una clase perfectamente normal que contiene los métodos que definimos en el contrato. Si creamos código adicional, para realizar cualquier otra operación, no sería visible al no estar definido en la interfaz del servicio.

EL ARCHIVO SVC

Un archivo importante a tener muy en cuenta es el archivo con extensión svc, el cual erá de utilidad a IIS cuando publiquemos el servicio. Añadimos un documento en blanco, llamado Service.svc, con el siguiente contenido:

<%@ ServiceHost Service="WCF.Service" %>

Le indicamos el namespace de la  implementación del contrato como valor de Service para que pueda localizarlo.

DLL FUERA DE DEBUG Y RELEASE

Para que IIS pueda localizar correctamente las librerías del servicio web, debemos cambiar las propiedades de Build en nuestro proyecto y dejar nuestro “Output path” de la siguiente forma:

Por último, quizás la parte más compleja, necesitamos configurar el archivo web.config con los endpoints necesarios para aceptar peticiones. Dependiendo de los distintos tipos de comunicacion que tengamos, deberemos implementar más o menos endpoints.

¿Qué es un Endpoint?

Un endpoint está compuesto por tres valores: Address (¿Dónde?), Binding (¿Cómo?) y Contract (¿Qué?). La suma de ellos genera una serie de requisitos para poder establecer una conexión con nuestro servidor. Un servicio con WCF puede disponder de varios endpoints distintos, por lo que el número de clientes de diferentes características pueden consumirlo.

Creamos pues un archivo Web.config y eliminamos el contenido. En este post, voy a crear un endpoint para un cliente JSON.

<?xml version="1.0"?>
<configuration>
  <system.serviceModel>
    <bindings>
      <webHttpBinding>
        <binding name="webBinding">
        </binding>
      </webHttpBinding>
    </bindings>
    <services>
      <service name="WCF.Service"
               behaviorConfiguration="MiBehavior">
        <endpoint address="json"
                  binding="webHttpBinding"
                  bindingConfiguration="webBinding"
                  behaviorConfiguration="jsonBehavior"
                  contract="WCF.IService"/>
      </service>
    </services>
    <behaviors>
      <endpointBehaviors>
        <behavior name="jsonBehavior">
          <enableWebScript/>
        </behavior>
      </endpointBehaviors>
      <serviceBehaviors>
        <behavior name="MiBehavior">
          <serviceMetadata httpGetEnabled="true"/>
          <serviceDebug includeExceptionDetailInFaults="True"/>
        </behavior>
      </serviceBehaviors>
    </behaviors>
  </system.serviceModel>
</configuration>

Dentro de la sección system.serviceModel tenemos:

Por un lado, la sección de los bidings disponibles, que en este caso sólo tenemos el necesario para una configuración de JSON; services donde indicamos el address, el nombre de nuestro binding, el behavior (indicado más abajo)  y el nombre del contrato que queremos utilizar.

Llegados a este punto, podemos crear una aplicación que tenga hosteado el servicio que acabamos de crear o bien utilizar IIS, configurando como documento de inicio Service.svc.

IMPLEMENTACIÓN DEL CONTRATO

El siguiente paso es crear una clase que implemente el contrato que acabamos de definir.

namespace WCF
{
    public class Service : IService
    {
        public Resultado Suma(int a, int b)
        {
            var resultado = new Resultado {Result = a + b};
            return resultado;
        }

        public Resultado Resta(int a, int b)
        {
            var resultado = new Resultado {Result = a - b};
            return resultado;
        }
    }
}

Si accedemos a las dos direcciones que indico abajo a través del explorador, debería devolvernos un archivo en formato JSON por cada petición.

http://localhost/WCF/Service.svc/json/Suma

http://localhost/WCF/Service.svc/json/Resta

Ambas devolverían cero porque no se les está pasando ningún parámetro.
En el siguiente post de WCF, crearé un cliente que realice y reciba la respuesta con JSON para poder acceder a nuestro servicio web y pasarle los parámetros necesarios.

¡Saludos!