1

WCF (I): INTRODUCCIN A WINDOWS

COMMUNICATION FOUNDATION

La plataforma .NET sufri su gran transformacin a partir de sus versiones 3.0/3.5,
momento en el que surgen oficialmente las ahora conocidas
como Foundations, orientadas a especializar secciones completas del framework. Windows
Communication Foundation, originalmente conocida por el nombre de Indigo, es la parte
encargada, como su propio nombre indica, de las comunicaciones y mensajera, aunque
su principal uso son los servicios web.
Hasta el momento, el servicio de mensajera entre aplicaciones se realizaba mediante los
protocolos COM, DCOM o MSQM, que obligaba a los programadores a ceirse no slo a
una forma de programacin concreta, sino que tambin estaba atada a la plataforma y al
lenguaje de programacin. Los servicios web surgen con el propsito de cambiar esta
filosofa, permitiendo hacer la comunicacin independiente de lenguaje de programacin
y plataforma gracias a la creacin de estndares de comunicacin. No importar si un
servicio est codificado en Java o .NET, ni si corre en una plataforma Windows o Linux: lo
importante ser que respeten los estndares del protocolo sobre el cual est construido,
del mismo modo que ocurre con los servidores web.
Tipos de servicios web
A da de hoy existe una gran variedad de protocolos sobre los que los servicios web
pueden operar, pero son dos los protocolos estrella que la prctica totalidad de los
servicios web utilizan hoy da:
SOAP: Simple Object Access Protocol. Creado en 1998, se sirve de mensajes XML
para el intercambio de mensajes. Puede operar sobre cualquier protocolo de
transporte, aunque lo ms comn es que lo haga sobre HTTP o HTTPS. Es el
protocolo ms comn en servicios web de carcter privado.
REST: REpresentational State Transfer. Concepto surgido en el ao 2000, hace uso
del protocolo HTTP para el envo de mensajes, y puede utilizar lenguajes como
XML o JSON.
SOAP
Este protocolo, como ya hemos dicho, utiliza XML como lenguaje de codificacin, y su
principal ventaja es que es agnstico respecto a la capa de transporte, es decir, que puede
2

ser transmitido a travs de HTTP, TCP/IP, SMTP o cualquier otro, a diferencia de REST que
nicamente opera sobre HTTP/HTTPS.
Su estructura recuerda vagamente a la de un documento HTML, constando de una
cabecera (header) que implementar los metadatos del mensaje (opciones de seguridad,
protocolo, transaccionalidad) y de un cuerpo (body) que contendr el mensaje en s.
Todo ello ir encapsulado dentro de un sobre (envelope). Un ejemplo de mensaje SOAP
podra ser el siguiente:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
<?xml version='1.0' ?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">

<soap:Header>
<!-- Metadatos -->
</soap:Header>

<soap:Body xmlns:c="http://www.danigarcia.org/clientes">
<c:ObtenerNombreCliente>
<c:IdCliente>61</c:IdCliente>
</c:ObtenerNombreCliente>
</soap:Body>

</soap:Envelope>
REST
Su filosofa se basa en la ausencia de estado y la equivalencia entre los cuatro verbos
que pueden utilizarse en el protocolo HTTP y las cuatro operaciones CRUD (Create, Read,
Update, Delete) bsicas que pueden realizarse sobre una fuente de datos. Es el protocolo
ms utilizado en servicios web abiertos o pblicos.
GET SELECT (Obtener)
POST INSERT (Crear)
PUT UPDATE (Actualizar)
DELETE DELETE (Borrar)
En la pequea introduccin que vimos hace un par de das acerca de Entity Framework +
Webservices vimos un pequeo ejemplo de cmo se hace uso de REST para generar y
consumir un servicio. As, para recuperar un cliente realizaramos una peticin como la
siguiente:
3

GET http://localhost:6040/GestionPedidosDataService.svc/Cliente(61)
Una eliminacin sera similar, pero haciendo uso del verbo DELETE:
DELETE http://localhost:6040/GestionPedidosDataService.svc/Cliente(61)
SOA
Una vez que hemos descubierto las dos principales tipos de servicios web (SOAP y
RESTful), es hora de hablar de SOA. Seguro que muchos hemos odo hablar de SOA, pero
de qu se trata? SOA son las siglas de Service-Oriented Architecture, es
decir, Arquitectura Orientada a Servicios.
SOA se basa en organizar una aplicacin en unidades funcionales que pueden ser
gestionadas por distintos proveedores e incluso compaas de modo que puedan ser
accedidas de un modo homogneo. Por lo tanto, SOA no habla acerca de la tecnologa a
utilizar, como REST o SOAP, sino lo que conceptualmente debera ser un modelo de
comunicaciones distribuido.
WCF entra en escena
Tras una serie de acercamientos a los servicios web utilizando SOAP y servicios web de
extensin asmx, Microsoft publica finalmente Windows Communication Foundation. Su
objetivo bsico era el de unificar las comunicaciones. Ya no importar que nuestra
aplicacin distribuida se comunique a travs de TCP en unos servicios, SOAP en otros y
REST en otros: WCF soporta todos estos protocolos, y permitir que nuestro cdigo sea
independiente del protocolo que vayamos a utilizar.
Cmo logra WCF esta independencia? Bsicamente, mediante la separacin
entre operaciones y datos. Al igual que hacemos uso de interfaces en nuestro cdigo para
aislar la firma de los mtodos de sus implementaciones (ver este artculo para refrescar
estos conceptos), un servicio web WCF utiliza este mismo concepto: establece
un contrato a travs de una interfaz (que ser adornado con atributos especficos) que una
clase se encargar de implementar. De este modo, un servicio WCF, se compondr, a
grandes rasgos, de:
Contrato de servicio (ServiceContract): expone una operacin que nuestro servicio
web es capaz de ejecutar. Corresponde a una interfaz.
4

Contrato de datos (DataContract): implementa un tipo de dato que el servicio web
ser capaz de manejar. Generalmente, ser el tipo de dato que manejar el
contrato de servicio.
Implementacin del servicio: implementar la interfaz correspondiente al contrato
de servicio, haciendo uso del contrato de datos para intercambiar la informacin.

En cuanto a la comunicacin, se realizar mediante la configuracin de los denominados
endpoints, a travs de un simple fichero XML. Un endpoint no es ms que la direccin de
un servicio, que implementa un protocolo determinado. As, en el siguiente ejemplo
tendramos un nico servicio que puede comunicarse de tres formas distintas a travs de
tres endpoints diferentes:
1
2
3
4
5
6
7
8
9
10
11
12
13
<?xml version='1.0' ?>
<configuration>
<system.serviceModel>
<services>
<service name='GestionPedidosDataService'>
<endpoint
address='http://localhost:6040/GestionPedidosHttpService'
binding='webHttpBinding'
contract='IServiceContract'
/>
<endpoint
address='net.tcp://localhost:9043/GestionPedidosTcpService'
binding='netTcpBinding'
contract='IServiceContract'
/>
<endpoint
5

14
15
16
17
18
19
20

address='net.msmq://localhost/GestionPedidosMsmqService'
binding='netMsmqBinding'
contract='IServiceContract'
/>
</service>
</services>
</system.serviceModel>
</configuration>
El primer endpoint realizar su comunicacin a travs de HTTP utilizando REST. Los otros
dos endpoints realizarn el mismo trabajo que el primero, pero usarn los protocolos TCP
y MSMQ utilizando SOAP. Como podemos observar, tan slo ha sido necesario codificar
una sola vez la funcionalidad del servicio web, creando en un momento tres formas
distintas de realizar la comunicacin.
Con esto podemos entender el xito de WCF en la plataforma .NET: permite olvidarse del
transporte y centrarse en la codificacin de la lgica del servicio, ahorrando una enorme
cantidad de tiempo y recursos y simplificando enormemente la interoperabilidad, ya que,
si en un determinado momento es necesario un protocolo determinado para comunicarse
con un cliente preexistente, basta con configurar un endpoint para que ese cliente pueda
acceder a nuestro servicio en lugar de codificar toda la lgica de comunicaciones que
implicara un servicio web convencional.
A lo largo de los siguientes artculos aprenderemos a implementar distintos tipos de
servicios web haciendo uso de WCF, profundizando un poco ms en las posibilidades que
esta tecnologa nos ofrece.



6

WCF (II) : CREACIN DE UN SERVICIO
WEB SIMPLE

Comprendidos los principios sobre los que se basa Windows Communication Foundation,
es momento de crear un pequeo servicio bsico que maneje una lista interna de clientes.
No haremos uso de bases de datos, puesto que el objetivo principal de este artculo es
centrarnos en la comunicacin. El ltimo artculo dedicado a Entity Framework desarrolla,
precisamente, un ejemplo ms especfico del uso de Entity Framework para desarrollar un
servicio web RESTfulmediante WCF.
Como vimos en el artculo anterior, a grandes rasgos un servicio WCF se compondr de
cuatro elementos:
Contrato de datos: estructura de datos que ser intercambiada por el servicio.
Contrato de servicio: interfaz que expondr los mtodos que pueden ser invocados
por el cliente.
Implementacin del servicio: codificacin del contrato de servicio, incorporar la
lgica interna del servicio.
Configuracin: fichero XML con informacin sobre direccin, nombre o protocolo.
Comenzaremos creando el servicio para pasar, a continuacin, por el primero de estos
elementos: el contrato de datos.
Creacin del servicio
Para comenzar la codificacin de nuestro servicio, crearemos un nuevo proyecto WCF,
especficamente del tipo WCF Service Library, que generar una biblioteca DLL que
contendr la funcionalidad del servicio.
7


Visual Studio crear ahora un esqueleto de nuestro primer servicio web, que tendr un
aspecto similar al siguiente:

Estos ficheros tendrn los nombres IService1.cs y Service1.cs. Comenzaremos eliminando
estos archivos y creando el primero de los elementos que conformar el servicio.

8

Contrato de datos (DataContract)
Aadiremos una nueva clase que simbolizar la estructura de datos que nuestro servicio
web intercambiar con un potencial cliente: el DataContract o contrato de datos.
Llamaremos a la clase Cliente.cs.

Esta informacin no ser ms que un POCO (Plain Old CLR Object) que contendr los
campos que queremos enviar a travs de la red. Un POCO no es ms que una estructura
simple, sin funcionalidad, que contiene una serie de campos que normalmente
simbolizar un registro en una base de datos relacional desde una perspectiva orientada a
objetos. A nivel estructural equivaldra a los struct de C.
Por tanto, haremos la clase pblica y aadiremos los campos que queremos exponer, que
tambin tendrn visibilidad pblica.
1
2
3
4
5
6
7
8
9
namespace WcfServices
{
public class Cliente
{
public int IdCliente;
public string Nombre;
public DateTime FechaNacimiento;
}
}
9

Para que nuestro POCO adquiera la categora de contrato de datos, ser necesario adornar
la clase y sus elementos con un par de atributos heredados
de System.Runtime.Serialization. Por lo tanto, aadimos el using correspondiente y
asignamos el atributo DataContract a la clase y el atributoDataMember a cada uno de los
elementos de la clase.
1
2
3
4
5
6
7
8
9
10
11
12
13
14

namespace WcfServices
{
[DataContract] // System.Runtime.Serialization
public class Cliente
{
[DataMember]
public int IdCliente;

[DataMember]
public string Nombre;

[DataMember]
public DateTime FechaNacimiento;
}
}
Contrato de Servicio (ServiceContract)
El segundo elemento que deberemos configurar ser el contrato de servicio, interfaz que
contendr la firma de los mtodos que el servicio expondr de forma pblica.
Aadiremos, por lo tanto, una nueva interfaz a la que llamaremos IClienteService.
10


Esto har que se cree una interfaz vaca con el siguiente aspecto:
1
2
3
4
5
6
namespace WcfServices
{
interface IClienteService
{
}
}
Nuevamente, haremos la interfaz pblica, y aadiremos la firma de los mtodos que
queremos que esta incluya. Para este caso concreto, crearemos un mtodo de
recuperacin, otro de insercin, otro de modificacin y un ltimo mtodo de eliminacin.
Recordemos que en una interfaz no debemos indicar la visibilidad de los mtodos que
sta incluye.
1
2
3
4
5
6
7
8
9
10
namespace WcfServices
{
public interface IClienteService
{
List<Cliente> ObtenerClientes();
void InsertarCliente(Cliente c);
void ModificarCliente(Cliente c);
void EliminarCliente(int id);
}
}
11

Por ltimo, importaremos el espacio de nombres System.ServiceModel y adornaremos la
interfaz con el atributo ServiceContract. Los mtodos de la interfaz, por su parte, irn
adornados con el atributo OperationContract, ya que establecern el contrato de las
operaciones que el servicio puede realizar.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
namespace WcfServices
{
[ServiceContract] // System.ServiceModel
public interface IClienteService
{
[OperationContract]
List<Cliente> ObtenerClientes();

[OperationContract]
void InsertarCliente(Cliente c);

[OperationContract]
void ModificarCliente(Cliente c);

[OperationContract]
void EliminarCliente(int id);
}
}
Implementacin del contrato
Contando con datos y operaciones, es el momento de codificar una clase que implemente
la interfaz que define el contrato de servicio con sus correspondientes operaciones. Por lo
tanto, crearemos una nueva clase, a la que denominaremos ClienteService, que
implemente la interfazIClienteService.
1
2
3
4
5
6
namespace WcfServices
{
class ClienteService : IClienteService
{
}
}
Para que Visual Studio genere el cuerpo de las funciones que debemos implementar,
haremos click derecho sobre el nombre de la interfaz y seleccionaremos la
opcin Implement Interface.
12


Esto har que se genere el cdigo correspondiente a la firma de los mtodos de la
interfaz, indicndonos qu es lo que debemos codificar.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class ClienteService : IClienteService
{
public List<Cliente> ObtenerClientes()
{
throw new NotImplementedException();
}

public void InsertarCliente(Cliente c)
{
throw new NotImplementedException();
}

public void ModificarCliente(Cliente c)
{
throw new NotImplementedException();
}

public void EliminarCliente(int id)
{
throw new NotImplementedException();
}
}
Nuevamente, importaremos el espacio de nombres System.ServiceModel y asignaremos el
atributoServiceBehavior a la clase. Adems, crearemos un atributo esttico de carcter
privado que simbolizar nuestra fuente de datos. Consistir en una lista de clientes sobre
las que realizaremos las operaciones del servicio.
1
2
3
4
[ServiceBehavior]
public class ClienteService : IClienteService
{
private static List<Cliente> listaClientes = new List<Cliente>();
El atributo ServiceBehavior puede aceptar parmetros que permite configurar aspectos
especficos del servicio, como el tipo de concurrencia o si el servicio funcionar en
modo singleton. Pueden consultarse en la MSDN aqu.
13


Finalmente, aadimos la funcionalidad deseada a cada mtodo. Por ejemplo,
codificaramos algo como lo siguiente:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
[ServiceBehavior]
public class ClienteService : IClienteService
{
private static List<Cliente> listaClientes = new List<Cliente>();

public List<Cliente> ObtenerClientes()
{
return listaClientes;
}

public void InsertarCliente(Cliente c)
{
// Calculamos el ID del siguiente elemento
if (listaClientes.Count == 0)
c.IdCliente = 1;
else
c.IdCliente = listaClientes.Max(cliente => cliente.IdCliente) + 1;

// Aadimos el cliente a la lista
listaClientes.Add(c);
}


public void ModificarCliente(Cliente c)
{
// Recuperamos el cliente cuyo ID coincide con el pasado como parmetro
Cliente clienteModif = listaClientes.Where(cliente => cliente.IdCliente
== c.IdCliente).First();
// Si el registro existe, se modifica
14

25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
if (clienteModif != null)
{
clienteModif.Nombre = c.Nombre;
clienteModif.FechaNacimiento = c.FechaNacimiento;
}
}
public void EliminarCliente(int id)
{
// Recuperamos el cliente cuyo ID coincide con el pasado como parmetro
Cliente clienteEliminar = listaClientes.Where(cliente =>
cliente.IdCliente == id).First();

// Si el registro existe, se elimina
if (clienteEliminar != null)
{
listaClientes.Remove(clienteEliminar);
}
}
}
Con esto concluiramos la codificacin del servicio. Slo nos quedan dos pasos: configurar
losendpoints y realizar una prueba para comprobar su funcionamiento. En realidad faltara
un tercer paso, su despliegue, pero esto lo dejaremos para una ocasin posterior.
Configuracin
Para accede a la configuracin del servicio, podemos editar directamente el fichero de
configuracin App.config / web.config o bien podemos dejar que el asistente nos facilite
esta tarea. Para acceder a l, haremos click derecho sobre el App.config y seleccionaremos
la opcinEdit WCF Configuration.

Esto abrir un dilogo que nos mostrar la configuracin de nuestro servicio, mostrando
dosendpoints. Sin embargo, la configuracin que se nos muestra es la configuracin
inicial generada al crear el proyecto, por lo que no nos ser de mucha utilidad.
15


Para solucionarlo, comenzaremos por compilar el servicio web de modo que se genere el
ficherodll objetivo.

Hecho esto, seleccionaremos el servicio preconfigurado y pulsaremos el botn [] que se
muestra a la derecha del nombre del servicio cuando ste es seleccionado.
16


A continuacin buscaremos la dll que acabamos de generar. La encontraremos en el
directorio/bin/Debug de nuestro proyecto.

17

Esto har que el nombre del servicio cambie, mostrando la configuracin correspondiente
al servicio que hemos codificado.

Desplegaremos la carpeta Endpoints y seleccionaremos el primero de ellos, realizando el
mismo proceso de seleccionar el fichero dll para localizar el contrato del servicio.

18

Si desplegamos el combo Binding podremos observar todas las posibilidades que WCF nos
oferta como mtodos de enlace. Sin embargo, tambin dejaremos esto para posteriores
artculos, seleccionando el valor por defecto, basicHttpBinding.

Prueba
Si pulsamos F5 una vez guardada la configuracin, se lanzar el cliente de prueba del
servicio. Este cliente es generado automticamente por Visual Studio, y nos permite
realizar invocaciones a los mtodos expuestos por el servicio a travs de una interfaz de
usuario.

Haremos doble click sobre el mtodo InsertarCliente e introduciremos los datos
solicitados. Hecho esto, pulsaremos el botn Invoke, que har que se ejecute el mtodo
del servicio y se obtenga la respuesta correspondiente, en caso de que sta exista.
Repetiremos el proceso un par de veces ms para que la lista mantenida en el servidor
tenga datos con los que realizar pruebas.
19


Si hacemos doble click sobre ObtenerClientes(), la respuesta no se mostrar vaca, sino
que estar compuesta por un listado de objetos Cliente. Recordemos que Cliente es en
este caso el contrato de datos que es intercambiado mediante los mtodos expuestos por
el contrato de servicio.

La modificacin tambin solicitar un objeto de la clase cliente, que cambiar los datos del
Cliente cuyo ID coincida con el incluido dentro del objeto.
20


Si realizamos una nueva consulta, veremos que, efectivamente, los datos se han
actualizado.

Finalmente, la eliminacin solicitar un entero con el ID del elemento a eliminar.
Procedemos, por lo tanto, a proporcionrselo y a invocar el servicio.

Si volvemos a consultar, comprobamos que, efectivamente, el registro habr sido
eliminado de la lista.

Para finalizar con la introduccin, el cliente de prueba de WCF nos permite comprobar
tambin el contenido de los mensajes. En este caso, se trata de mensajes SOAP. Como
podremos recordar del artculo anterior, el mensaje SOAP se compona de un envoltorio
(envelope) que contiene una cabecera (header) y un cuerpo (body). El resultado de la
peticin y de la respuesta ser el siguiente:
21



22

WCF (III): CREACIN DE UN CLIENTE
DE UN WEBSERVICE

Ahora que ya hemos creado nuestro primer servicio, es el momento de consumirlo. Al
igual que hicimos en ejemplos anteriores, comenzaremos creando un nuevo proyecto, por
ejemplo de consola.

Es importante tener a mano la direccin del servicio, ya que nos har falta para
referenciarlo. Si estamos desarrollando el cliente en el mismo equipo en el que
desarrollamos el webservice, bastar con copiar la direccin del WCF Test Client que
Visual Studio crear por nosotros y que vimos en el artculo anterior.

23

Seleccionaremos la seccin References del proyecto y haremos click derecho sobre ella,
seleccionando la opcin Add Service Reference para aadir una referencia de servicio.

En el campo Address (direccin), insertaremos el valor que copiamos previamente. El
hecho de que la direccin termine en mex indica que se trata el servicio de metadatos
creado por defecto, que proporcionar la informacin sobre el resto de endpoints del
servicio web. Ms adelante profundizaremos en el concepto de endpoint y aprenderemos
qu son, cmo configurarlos y cmo acceder a ellos.
Al pulsar el botn Go, se mostrarn los contratos de servicio disponibles junto a las
operaciones que stos pueden ejecutar.
Asignaremos un nombre al espacio de nombres del cliente y pulsaremos el botn Ok.
24


Si echamos un vistazo a nuestro fichero App.config, veremos que se ha aadido una nueva
seccin system.serviceModel que incluye informacin sobre el servicio web que acabamos
de referenciar, mostrando un endpoint que cumple con los elementos ABC
(Address, Binding,Contract). Toda esta informacin ser recabada automticamente del
servicio web de metadatosmex referenciado en el paso anterior, por lo que no ser
necesario codificar absolutamente nada.

<system.serviceModel>
<bindings>
<basicHttpBinding>
<binding name="BasicHttpBinding_IClienteService" />
</basicHttpBinding>
</bindings>
<client>
<endpoint address="http://localhost:8733/Design_Time_Addresses/WcfServices/Service1/"
binding="basicHttpBinding" bindingConfiguration=
"BasicHttpBinding_IClienteService"
25

contract="ClienteServiceReference.IClienteService" name=
"BasicHttpBinding_IClienteService" />
</client>
</system.serviceModel>
A continuacin aadiremos la clusula using que incluir la referencia del servicio (espacio
de nombres del proyecto + . + nombre que indicamos en el asistente al crear la
referencia) e instanciaremos un cliente del servicio, pasndole como parmetro el nombre
del endpoint al que queremos conectar.
Este nombre podemos consultarlo en el fichero App.config a partir del
atributo name del endpointcorrespondiente. En nuestro caso
ser BasicHttpBinding_IClienteService.











using WCFSimpleClient.ClienteServiceReference;

namespace WCFSimpleClient
{
class Program
{
static void Main(string[] args)
{
ClienteServiceClient servicioCliente = new
ClienteServiceClient("BasicHttpBinding_IClienteService");
}
}
}
Ahora procederemos a realizar las mismas operaciones que realizamos de forma manual
con el cliente de prueba. Comenzaremos instanciando tres nuevos clientes.













System.Console.WriteLine("INSERCIN\n-----------------------------");
Cliente carlos = new Cliente()
{
Nombre = "Carlos Garcia Castao",
FechaNacimiento = new DateTime(1980, 2, 2)
};
Cliente ana = new Cliente()
{
Nombre = "Ana Gonzalez Sierra",
FechaNacimiento = new DateTime(1981, 2, 22)
};
Cliente luis = new Cliente()
{
Nombre = "Luis Coria Chamorro",
FechaNacimiento = new DateTime(1974, 6, 12)
26



};
Una vez creados los objetos, invocamos el mtodo InsertarCliente del servicio web
referenciado pasndoselos como parmetro, y realizaremos una invocacin
a ObtenerClientes() para comprobar que todo es correcto.










servicioCliente.InsertarCliente(carlos);
servicioCliente.InsertarCliente(ana);
servicioCliente.InsertarCliente(luis);
System.Console.WriteLine("CONSULTA\n-----------------------------");
var resultado = servicioCliente.ObtenerClientes();
foreach (Cliente c in resultado)
{
Console.WriteLine(string.Format("\tID: {0}\tNOMBRE: {1}\t }
CUMPLEAOS: {2}/{3}",
c.IdCliente, c.Nombre, c.FechaNacimiento.Day,
c.FechaNacimiento.Month));
}
Realizaremos el mismo proceso con el mtodo ModificarCliente()tras modificar, por
ejemplo, el nombre de uno de los objetos que previamente recuperaremos del listado.










System.Console.WriteLine("MODIFICACIN\n-----------------------------");
Cliente clienteModif = resultado.First();
clienteModif.Nombre = clienteModif.Nombre + " MODIFICADO";
servicioCliente.ModificarCliente(clienteModif);
resultado = servicioCliente.ObtenerClientes();
foreach (Cliente c in resultado)
{
Console.WriteLine(string.Format("\tID: {0}\tNOMBRE: {1}\t
CUMPLEAOS: {2}/{3}",
c.IdCliente, c.Nombre, c.FechaNacimiento.Day,
c.FechaNacimiento.Month));
}
Por ultimo, eliminaremos el segundo registro pasndole el identificador del cliente al
mtodoEliminarCliente().








System.Console.WriteLine("ELIMINACIN\n-----------------------------");
Cliente clienteEliminar = resultado.Skip(1).First();
servicioCliente.EliminarCliente(clienteEliminar.IdCliente);
resultado = servicioCliente.ObtenerClientes();
foreach (Cliente c in resultado)
{
Console.WriteLine(string.Format("\tID: {0}\tNOMBRE: {1}\t
CUMPLEAOS: {2}/{3}",
c.IdCliente, c.Nombre, c.FechaNacimiento.Day,
27


c.FechaNacimiento.Month));
}
Si ejecutamos nuestro programa a partir del cdigo anterior, se mostrar lo siguiente:

Creacin del cliente mediante svcutil.exe
Al igual que la herramienta sqlmetal.exe serva para generar cdigo de forma automtica a
partir de la direccin de una base de datos, Visual Studio nos proporciona una
herramienta que automatiza la creacin de un cliente a partir de la direccin mex de un
servicio web de una forma similar, denominada svcutil.exe. Para hacer uso de esta orden,
abriremos en primer lugar la consola de desarrollo de Visual Studio.


28

A continuacin, nos dirigiremos a la ruta donde queremos crear nuestro cliente y
escribiremos lo siguiente:
svcutil.exe <direccin del endpoint mex>

Esto har que se generen dos ficheros: una clase cliente junto a un fichero de
configuracin.

Ambos ficheros contendrn la funcionalidad necesaria (cdigo y configuracin) para
realizar una conexin al servicio web, tal y como haca la referencia al servicio de forma
implcita.
29


Como podemos observar, tambin contienen la codificacin de las invocaciones a los
mtodos del servicio.

En el siguiente artculo ampliaremos el concepto de endpoint y aprenderemos a crearlos,
modificarlos y (sobre todo) entender un poco mejor de qu se tratan.