Creando un proyecto WCFMicrosoft desde ya hace unos años, viene trabajando con el concepto de  Windows Communication Foundation (WCF).  Voy a transcribir la definición oficial de WCF que nos da Microsoft en su página web.

Windows Communication Foundation (WCF) es un marco de trabajo para la creación de aplicaciones orientadas a servicios. Con WCF, es posible enviar datos como mensajes asincrónicos de un extremo de servicio a otro. Un extremo de servicio puede formar parte de un servicio disponible continuamente hospedado por IIS, o puede ser un servicio hospedado en una aplicación. Un extremo puede ser un cliente de un servicio que solicita datos de un extremo de servicio. Los mensajes pueden ser tan simples como un carácter o una palabra que se envía como XML, o tan complejos como una secuencia de datos binarios. A continuación se indican unos cuantos escenarios de ejemplo:

Un servicio seguro para procesar transacciones comerciales. Un servicio que proporciona datos actualizados a otras personas, como un

informe sobre tráfico u otro servicio de supervisión. Un servicio de chat que permite a dos personas comunicarse o intercambiar

datos en tiempo real. Una aplicación de panel que sondea los datos de uno o varios servicios y los

muestra en una presentación lógica. Exponer un flujo de trabajo implementado utilizando Windows Workflow

Foundation como un servicio WCF. Una aplicación de Silverlight para sondear un servicio en busca de las fuentes

de datos más recientes.

Gráficamente, veamos que podemos ganar implementando servicios WCF al momento de desarrollar nuestras aplicaciones.

Como podemos apreciar, WCF nos brinda un canal seguro de comunicación (a través de contratos) no solo entre aplicaciones de una misma máquina, sino a través de una red que puede estar conformada por servidores Windows o Linux (Interoperabilidad).

Bueno, basta de teoría y veamos como crear un proyecto del tipo WCF en Visual Studio 2010 y utilizando las características que nos da el .Net Framework 4.0

Paso 1: Definir el Contrato

Cuando hablamos de servicios, recuerda que siempre debe de haber un proveedor y un consumidor del servicio, por lo que es necesario definir cómo se llevará la comunicación entre estos dos entes. A este proceso le llamaremos: Definición del Contrato.

En el Contrato definiremos básicamente lo siguiente:

Las operaciones que se podrán realizar. Las firmas y los tipos de datos que se enviarán y/o recibirán durante la

invocación de las operaciones. Los protocolos y formatos de serialización que se utilizan para llevar a cabo la

comunicación.

Luego de definido esto, recién podemos llevarlo a la programación.

Para el ejemplo voy a definir algo bastante sencillo. Haremos un contrato para permitir la realización de las siguientes operaciones básicas:

Factorial de un número

1 long Factorial(long x);

Devolver una Lista de enteros, con los "n" primeros números de la serie de Fibonacci.

1 List<int> Numeros_Fibobacci(int n);

Suma de los primeros "n" números de la serie de Fibonacci.

1 double Sumatoria_Fibonacci(int n);

 

Paso 2: Creando un Proyecto del Tipo WCF Service Library

Luego de definido las operaciones y el contrato, vamos a crear una aplicación del tipo WCF Service Library, para implementarlos.

Luego de creada la aplicación te pediría que borres los archivos IService1.cs y Service1.cs para que aprendamos a crear los servicios, sin necesidad de una ayuda.

Luego de borrar ambos archivos, vamos a adicionar (Add New Item) a nuestro proyecto una Clase (llamado MiServicio) y una Interface (llamada IMiServicio). Te dejo la siguiente imagen para que veas a lo que me refiero.

Luego de creada la Clase y la Interface, debes de adicionar el siguiente using en ambas:

1 using System.ServiceModel;

Ahora si, vamos a programar las operaciones que hemos definido dentro de nuestro contrato. Empezaremos con la Interface.

Paso 3: Codificando la Interface

Luego de agregada la referencia, debemos de adicionar un atributo a nuestra interface, el atributo es [ServiceContract], quedando nuestro código de la siguiente forma:

01 using System;

02 using System.Collections.Generic;03 using System.Linq;04 using System.Text;05 using System.ServiceModel;

06  

07 namespace WCFServiceLibrary

08 {

09     [ServiceContract]

10     public interface IMiServicio11     {

12  

13     }

14 }

Ahora codificaremos sólo  las firma de nuestra operaciones anteponiendo a cada una el atributo [OperationContract] , quedando nuestro código de la siguiente forma:

01 using System;

02 using System.Collections.Generic;03 using System.Linq;04 using System.Text;05 using System.ServiceModel;

06  

07 namespace WCFServiceLibrary

08 {

09     [ServiceContract]

10     public interface IMiServicio

11     {

12         [OperationContract]13         long Factorial(long x);

14  

15         [OperationContract]

16         double Sumatoria_Fibonacci(int n);

17  

18         [OperationContract]19         List<int> Numeros_Fibobacci(int n);

20  

21     }

22 }

 Paso 4: Codificando la Clase

Terminada la Interface, debemos de implementar cada Operación, esto lo hacemos en la clase, por lo que debemos de indicar, mediante un identificador, que la clase va a implementar los métodos definidos en la Interface.

01 using System;

02 using System.Collections.Generic;03 using System.Linq;04 using System.Text;05 using System.ServiceModel;

06  

07 namespace WCFServiceLibrary

08 {

09     //Al momento de definir la clase, indicamos que implementará los

10     //métodos de la Interface IMiServicio

11     public class MiServicio:IMiServicio

12     {

13  

14     }15 }

Luego implementamos los métodos que hemos definido.

01 using System;

02 using System.Collections.Generic;03 using System.Linq;04 using System.Text;05 using System.ServiceModel;

06  

07 namespace WCFServiceLibrary

08 {

09     //Al momento de definir la clase, indicamos que implementará los

10     //métodos de la Interface IMiServicio

11     public class MiServicio:IMiServicio

12     {

13         public long Factorial(long x)

14         {

15             if (x <= 1 ) return 1;

16             else

17             {

18                 return x*Factorial(x - 1);19             }

20         }

21  

22         public double Sumatoria_Fibonacci(int n)

23         {

24             List<int> numeros = Numeros_Fibobacci(n);25             return numeros.Sum();

26        }

27  

28         public List<int> Numeros_Fibobacci(int n)

29         {

30             List<int> numeros = new List<int>();31             int a, b, c;

32             a = 1;

33             b = 0;

34             for (int i = 0; i < n;i++ )

35             {

36                 c = a + b;37                 numeros.Add(c);

38                 a = b;

39                 b = c;

40  

41             }

42             return numeros;43         }

44  

45     }

46 }

Como puedes apreciar, la implementación de las operaciones la he utilizado de forma normal, sin ningún operador o atributo diferente a los que ya conoces.

Paso 5: Cambiando el Archivo de Configuración

 

Luego de definir el contrato, es necesario publicarlo para que pueda ser consumido, esto lo hacemos colocando el nombre del servicio, donde esta publicado, y el tipo de enlace que permitirá.

Voy a colocar parte del App.config para que veas que información se coloca por cada uno de los servicios:

01 <system.serviceModel>

02     <services>

03     <!-- Nombre del Servicio (Namespace.NombreClase) -->

04       <service name="WCFServiceLibrary.MiServicio">

05         <host>

06           <!-- Direccion del Servicio-->

07       <baseAddresses>

08            <add baseAddress = "http://localhost:8732/Design_Time_Addresses/WCFServiceLibrary/MiSer

vicio/" />09           </baseAddresses>

10         </host>

11         <!-- Service Endpoints -->

12         <!-- Unless fully qualified, address is relative to base address supplied above -->

13         <endpoint address ="" binding="wsHttpBinding" contract="WCFServiceLibrary.IMiServicio">

14           <!--

15               Upon deployment, the following identity element should be removed or replaced to reflect the

16               identity under which the deployed service runs.  If removed, WCF will infer an appropriate identity

17               automatically.

18           -->

19           <identity>

20             <dns value="localhost"/>

21           </identity>

22         </endpoint>

23         <!-- Metadata Endpoints -->

24         <!-- The Metadata Exchange endpoint is used by the service to describe itself to clients. -->

25         <!-- This endpoint does not use a secure binding and should be secured or removed before deployment -->

26         <endpoint address="mex" binding="mexHttpBinding" contract="IMetadataExchange"/>

27       </service>

28     </services>

Luego de realizar los cambios podemos probar nuestros servicios, ejecutando nuestra aplicación con F5

Paso 6: Probando nuestro Servicio WCF

Al ejecutar la aplicación creada, Visal Studio, ejecuta WCF Test Client, añadiendo el servicio creado y las operaciones que este contempla, de forma que podremos probar si estas se ejecutan adecuadamente.

Para probar cada operación, basta con dar doble clic en una de ellas y en la pantalla que aparece, dar valores a los datos requeridos para luego invocarlos.  Mira la siguiente imagen, donde pruebo la Función Factorial para un valor de x=5.

Como podrás ver, es bastante sencillo implementar un servicio WCF. Si bien es cierto he usado operaciones bastante sencillas, tu puedes utilizar lo aprendido aquí para trabajar con Base de Datos, por ejemplo, de forma que trabajes a través de servicios que a su vez puedan ser aprovechadas por otras aplicaciones. Espero te sea de ayuda este post para tus trabajos posteriores.